IDISP013 handle returning new ValueTask

fix #475

Author: JohanLarsson

IDisposableAnalyzers.Test/IDISP013AwaitInUsingTests/Valid.cs

@@ -420,4 +420,42 @@ public ValueTask<IDisposable> M()
                 """;
         RoslynAssert.Valid(Analyzer, disposable, code);
     }
+
+    [TestCase("default")]
+    [TestCase("new ValueTask<int>(1)")]
+    [TestCase("new ValueTask<int>(disposable.Equals(disposable) ? 1 : 0)")]
+    public static void ReturnNewValueTask(string expression)
+    {
+        var disposable = """
+                namespace N;
+
+                using System;
+
+                public class Disposable : IDisposable
+                {
+                    public void Dispose()
+                    {
+                    }
+                }
+                """;
+
+        var code = """
+
+                namespace N;
+
+                using System.Threading.Tasks;
+
+                public class C
+                {
+                    public ValueTask<int> M1Async()
+                    {
+                      using (var disposable = new Disposable())
+                      {
+                        return new ValueTask<int>(1);
+                      }
+                    }
+                }
+                """.AssertReplace("new ValueTask<int>(1)", expression);
+        RoslynAssert.Valid(Analyzer, disposable, code);
+    }
 }

IDisposableAnalyzers/Analyzers/ReturnValueAnalyzer.cs

@@ -125,12 +125,39 @@ private static void HandleReturnValue(SyntaxNodeAnalysisContext context, Express
         if (ReturnType(context)?.IsAwaitable() == true &&
             IsInUsing(returnValue) &&
             !returnValue.TryFirstAncestorOrSelf<AwaitExpressionSyntax>(out _) &&
-            context.SemanticModel.TryGetType(returnValue, context.CancellationToken, out var returnValueType2) &&
-            returnValueType2.IsAwaitable() &&
             ShouldAwait(context, returnValue))
         {
             context.ReportDiagnostic(Diagnostic.Create(Descriptors.IDISP013AwaitInUsing, returnValue.GetLocation()));
         }
+
+        static bool ShouldAwait(SyntaxNodeAnalysisContext context, ExpressionSyntax returnValue)
+        {
+            if (context.SemanticModel.GetType(returnValue, context.CancellationToken)?.IsAwaitable() == true)
+            {
+                if (returnValue.TryFirstAncestor(out InvocationExpressionSyntax? ancestor) &&
+                    ancestor.TryGetMethodName(out var ancestorName) &&
+                    ancestorName == "ThrowsAsync")
+                {
+                    return false;
+                }
+
+                return returnValue switch
+                {
+                    InvocationExpressionSyntax invocation
+                        => !(invocation.IsSymbol(KnownSymbols.Task.FromResult,         context.SemanticModel, context.CancellationToken)
+                             || invocation.IsSymbol(KnownSymbols.ValueTask.FromResult, context.SemanticModel, context.CancellationToken)),
+                    MemberAccessExpressionSyntax { Name.Identifier.ValueText: "CompletedTask" } memberAccess
+                        => !(memberAccess.IsSymbol(KnownSymbols.Task.CompletedTask,         context.SemanticModel, context.CancellationToken)
+                             || memberAccess.IsSymbol(KnownSymbols.ValueTask.CompletedTask, context.SemanticModel, context.CancellationToken)),
+                    DefaultExpressionSyntax => false,
+                    LiteralExpressionSyntax => false,
+                    ObjectCreationExpressionSyntax => false,
+                    _ => true,
+                };
+            }
+
+            return false;
+        }
     }
 
     private static bool IsInUsing(SyntaxNode node)
@@ -176,27 +203,6 @@ private static bool IsUsing(ISymbol symbol, CancellationToken cancellationToken)
         return false;
     }
 
-    private static bool ShouldAwait(SyntaxNodeAnalysisContext context, ExpressionSyntax returnValue)
-    {
-        if (returnValue.TryFirstAncestor(out InvocationExpressionSyntax? ancestor) &&
-            ancestor.TryGetMethodName(out var ancestorName) &&
-            ancestorName == "ThrowsAsync")
-        {
-            return false;
-        }
-
-        return returnValue switch
-        {
-            InvocationExpressionSyntax invocation
-            => !(invocation.IsSymbol(KnownSymbols.Task.FromResult, context.SemanticModel, context.CancellationToken)
-                || invocation.IsSymbol(KnownSymbols.ValueTask.FromResult, context.SemanticModel, context.CancellationToken)),
-            MemberAccessExpressionSyntax { Name.Identifier.ValueText: "CompletedTask" } memberAccess
-            => !(memberAccess.IsSymbol(KnownSymbols.Task.CompletedTask,   context.SemanticModel, context.CancellationToken)
-                || memberAccess.IsSymbol(KnownSymbols.ValueTask.CompletedTask, context.SemanticModel, context.CancellationToken)),
-            _ => true,
-        };
-    }
-
     private static bool IsLazyEnumerable(InvocationExpressionSyntax invocation, INamedTypeSymbol containingType, SemanticModel semanticModel, CancellationToken cancellationToken)
     {
         using var recursion = Recursion.Borrow(containingType, semanticModel, cancellationToken);

ValidCode/Async.cs

@@ -152,4 +152,12 @@ private static void M()
         using var ct = new CancellationTokenSource();
         _ = ct.Token.Register(() => { }, useSynchronizationContext: false);
     }
+
+    public ValueTask<int> Issue457Async()
+    {
+        using (var disposable = new Disposable())
+        {
+            return new ValueTask<int>(disposable.Equals(disposable) ? 1 : 0);
+        }
+    }
 }