Handle Task.Run in Identity

Author: JohanLarsson

IDisposableAnalyzers.Test/Helpers/DisposableWalkerTests.Assigns.cs

@@ -212,9 +212,9 @@ private void M(IDisposable arg)
 
             [TestCase("Task.FromResult(File.OpenRead(fileName))")]
             [TestCase("Task.FromResult(File.OpenRead(fileName)).ConfigureAwait(true)")]
-            //[TestCase("Task.Run(() => File.OpenRead(fileName))")]
-            //[TestCase("Task.Run(() => { return File.OpenRead(fileName); })")]
-            //[TestCase("Task.Run(() => File.OpenRead(fileName)).ConfigureAwait(true)")]
+            [TestCase("Task.Run(() => File.OpenRead(fileName))")]
+            [TestCase("Task.Run(() => { return File.OpenRead(fileName); })")]
+            [TestCase("Task.Run(() => File.OpenRead(fileName)).ConfigureAwait(true)")]
             public static void AssigningFieldAwait(string expression)
             {
                 var code = @"
@@ -250,10 +250,10 @@ public void Dispose()
 
             [TestCase("Task.FromResult(File.OpenRead(fileName)).Result")]
             [TestCase("Task.FromResult(File.OpenRead(fileName)).GetAwaiter().GetResult()")]
-            //[TestCase("Task.Run(() => File.OpenRead(fileName)).Result")]
-            //[TestCase("Task.Run(() => File.OpenRead(fileName)).GetAwaiter().GetResult()")]
-            //[TestCase("Task.Run(() => { return File.OpenRead(fileName); }).Result")]
-            //[TestCase("Task.Run(() => { return File.OpenRead(fileName); }).GetAwaiter().GetResult()")]
+            [TestCase("Task.Run(() => File.OpenRead(fileName)).Result")]
+            [TestCase("Task.Run(() => File.OpenRead(fileName)).GetAwaiter().GetResult()")]
+            [TestCase("Task.Run(() => { return File.OpenRead(fileName); }).Result")]
+            [TestCase("Task.Run(() => { return File.OpenRead(fileName); }).GetAwaiter().GetResult()")]
             public static void AssigningFieldGetAwaiterGetResult(string expression)
             {
                 var code = @"

IDisposableAnalyzers/Helpers/Walkers/DisposableWalker.DisposedByReturnValue.cs

@@ -136,18 +136,9 @@ private static bool DisposedByReturnValue<TSource, TSymbol, TNode>(Target<TSourc
         {
             switch (target.Symbol)
             {
-                case IPropertySymbol { ContainingType: { MetadataName: "Task`1" }, Name: "Result" }:
-                    return true;
                 case IMethodSymbol { ReturnsVoid: true }:
                 case IMethodSymbol { ReturnType: { MetadataName: "Task" } }:
                     return false;
-                case IMethodSymbol { ReturnType: { MetadataName: "ConfiguredTaskAwaitable`1" } }:
-                case IMethodSymbol { ReturnType: { MetadataName: "TaskAwaiter`1" } }:
-                case IMethodSymbol { ContainingSymbol: { MetadataName: "TaskAwaiter`1" }, Name: "GetResult" }:
-                    return true;
-                case IMethodSymbol { ReturnType: INamedTypeSymbol { MetadataName: "Task`1" } taskOfT }
-                    when taskOfT.TypeArguments.TrySingle(out var type):
-                    return Disposable.IsAssignableFrom(type, recursion.SemanticModel.Compilation);
                 case IMethodSymbol { ReturnType: { } returnType, DeclaringSyntaxReferences: { Length: 0 } }:
                     // we assume here, not sure it is the best assumption.
                     return Disposable.IsAssignableFrom(returnType, recursion.SemanticModel.Compilation);

IDisposableAnalyzers/Helpers/Walkers/DisposableWalker.Identity.cs

@@ -26,6 +26,14 @@ when invocation.IsSymbol(KnownSymbol.Task.FromResult, recursion.SemanticModel, r
                 => Recursive(invocation, recursion),
                 { Parent: MemberAccessExpressionSyntax { Name: IdentifierNameSyntax { Identifier: { ValueText: "GetAwaiter" } }, Parent: InvocationExpressionSyntax invocation } }
                 => Recursive(invocation, recursion),
+                { Parent: LambdaExpressionSyntax { Parent: ArgumentSyntax { Parent: ArgumentListSyntax { Parent: InvocationExpressionSyntax invocation } } } }
+                when invocation.IsSymbol(KnownSymbol.Task.Run, recursion.SemanticModel, recursion.CancellationToken)
+                => Recursive(invocation, recursion),
+                { Parent:ReturnStatementSyntax returnStatement}
+                when returnStatement.TryFirstAncestor(out LambdaExpressionSyntax? lambda) &&
+                     lambda is { Parent: ArgumentSyntax { Parent: ArgumentListSyntax { Parent: InvocationExpressionSyntax invocation } } } &&
+                     invocation.IsSymbol(KnownSymbol.Task.Run, recursion.SemanticModel, recursion.CancellationToken)
+                => Recursive(invocation, recursion),
                 { Parent: MemberAccessExpressionSyntax { Expression: { } expression, Name: IdentifierNameSyntax { Identifier: { ValueText: "Result" } } } memberAccess }
                 when recursion.SemanticModel.TryGetNamedType(expression, recursion.CancellationToken, out var type) &&
                      type.IsAssignableTo(KnownSymbol.Task, recursion.SemanticModel.Compilation)