Handle recursive builder

Author: JohanLarsson

IDisposableAnalyzers.Test/Helpers/DisposableTests.Ignores.cs

@@ -1089,6 +1089,43 @@ public void Dispose()
                 var value = syntaxTree.FindExpression(expressionText);
                 Assert.AreEqual(false, Disposable.Ignores(value, semanticModel, CancellationToken.None));
             }
+
+            [Test]
+            public static void Builder()
+            {
+                var syntaxTree = CSharpSyntaxTree.ParseText("""
+                namespace N;
+
+                using System;
+
+                public record struct S : IDisposable
+                {
+                    public S Append(int value)
+                    {
+                        if (value > 3)
+                        {
+                            return this;
+                        }
+                
+                        throw new Exception();
+                    }
+                
+                    internal S Append(bool value) => this.Append(1);
+
+                    public void Dispose() { }
+
+                    public void M()
+                    {
+                        using var s = new S().Append(true);
+                    }
+                }
+                """);
+
+                var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, Settings.Default.MetadataReferences);
+                var semanticModel = compilation.GetSemanticModel(syntaxTree);
+                var value = syntaxTree.FindExpression("new S()");
+                Assert.AreEqual(false, Disposable.Ignores(value, semanticModel, CancellationToken.None));
+            }
         }
     }
 }

IDisposableAnalyzers.Test/IDISP004DoNotIgnoreCreatedTests/Valid.cs

@@ -966,6 +966,8 @@ public S Append(int value)
                         throw new Exception();
                     }
 
+                    internal S Append(bool value) => this.Append(1);
+
                     public void Dispose() { }
                 }
                 """;
@@ -976,7 +978,7 @@ sealed class C
                 {
                     void M()
                     {
-                        using var s = new S().Append(1);
+                        using var s = new S().Append(true);
                     }
                 }
                 """;

IDisposableAnalyzers/Helpers/Disposable.Identity.cs

@@ -113,9 +113,14 @@ when target.Declaration is MethodDeclarationSyntax methodDeclaration &&
                     {
                         foreach (var returnValue in walker.ReturnValues)
                         {
-                            if (returnValue is ThisExpressionSyntax)
+                            switch (returnValue)
                             {
-                                return true;
+                                case ThisExpressionSyntax:
+                                    return true;
+                                case InvocationExpressionSyntax invocation
+                                    when recursion.Target(invocation) is { Symbol: { IsStatic: false } } next &&
+                                         next.Symbol.ContainingType.IsAssignableTo(target.Symbol.ContainingType, recursion.SemanticModel.Compilation):
+                                    return IsIdentity(next, recursion);
                             }
                         }
                     }

ValidCode/StructBuilder/Request.cs

@@ -8,7 +8,7 @@
 using System.Threading;
 
 [DebuggerDisplay("{ToString(),nq}")]
-public record struct Request : IDisposable
+public struct Request : IDisposable
 {
     private static int id;