Support using declaration in IDISP013

Author: Bouke

IDisposableAnalyzers.Test/IDISP013AwaitInUsingTests/Diagnostics.cs

@@ -60,6 +60,32 @@ private static async ValueTask<int> InnerAsync()
             RoslynAssert.Diagnostics(Analyzer, ExpectedDiagnostic, code);
         }
 
+        [Test]
+        public static void UsingDeclaration()
+        {
+            var code = @"
+namespace N
+{
+    using System.Threading.Tasks;
+
+    public static class C
+    {
+        public static ValueTask<int> MAsync()
+        {
+            using var file = System.IO.File.OpenRead(string.Empty);
+            return ↓InnerAsync();
+        }
+
+        private static async ValueTask<int> InnerAsync()
+        {
+            await Task.Delay(10).ConfigureAwait(false);
+            return 1;
+        }
+    }
+}";
+            RoslynAssert.Diagnostics(Analyzer, ExpectedDiagnostic, code);
+        }
+
         [Test]
         public static void LocalTask()
         {

IDisposableAnalyzers.Test/IDISP013AwaitInUsingTests/Valid.cs

@@ -32,6 +32,28 @@ public async Task<string> M()
             RoslynAssert.Valid(Analyzer, code);
         }
 
+        [Test]
+        public static void AwaitWebClientDownloadStringTaskAsyncInUsingDeclaration()
+        {
+            var code = @"
+#pragma warning disable SYSLIB0014
+namespace N
+{
+    using System.Net;
+    using System.Threading.Tasks;
+
+    public class C
+    {
+        public Task<string> M()
+        {
+            var client = new WebClient();
+            return client.DownloadStringTaskAsync(string.Empty);
+        }
+    }
+}";
+            RoslynAssert.Valid(Analyzer, code);
+        }
+
         [Test]
         public static void UsingAwaited()
         {

IDisposableAnalyzers/Analyzers/ReturnValueAnalyzer.cs

@@ -1,10 +1,12 @@
 namespace IDisposableAnalyzers
 {
+    using System.Collections.Generic;
     using System.Collections.Immutable;
+    using System.Linq;
     using System.Threading;
 
     using Gu.Roslyn.AnalyzerExtensions;
-
+    using Gu.Roslyn.CodeFixExtensions;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -123,17 +125,48 @@ private static void HandleReturnValue(SyntaxNodeAnalysisContext context, Express
             }
 
             if (ReturnType(context)?.IsAwaitable() == true &&
-                returnValue.TryFirstAncestor<UsingStatementSyntax>(out var usingStatement) &&
-                usingStatement.Statement.Contains(returnValue) &&
+                IsInUsingScope(returnValue) &&
                 !returnValue.TryFirstAncestorOrSelf<AwaitExpressionSyntax>(out _) &&
-                context.SemanticModel.TryGetType(returnValue, context.CancellationToken, out var returnValueType) &&
-                returnValueType.IsAwaitable() &&
+                context.SemanticModel.TryGetType(returnValue, context.CancellationToken, out var returnValueType2) &&
+                returnValueType2.IsAwaitable() &&
                 ShouldAwait(context, returnValue))
             {
                 context.ReportDiagnostic(Diagnostic.Create(Descriptors.IDISP013AwaitInUsing, returnValue.GetLocation()));
             }
         }
 
+        private static bool IsInUsingScope(SyntaxNode node)
+        {
+            return IsInUsingStatement(node) || HasPrecedingUsingDeclaration(node);
+        }
+
+        private static bool IsInUsingStatement(SyntaxNode node)
+        {
+            return node.TryFirstAncestor<UsingStatementSyntax>(out var usingStatement) &&
+                   usingStatement.Statement.Contains(node);
+        }
+
+        private static bool HasPrecedingUsingDeclaration(SyntaxNode node)
+        {
+            if (node.TryFirstAncestor<UsingStatementSyntax>(out var usingStatement) &&
+                usingStatement.Statement.Contains(node))
+            {
+                return true;
+            }
+
+            if (node.Parent?.ChildNodes().TakeWhile(x => x != node).OfType<LocalDeclarationStatementSyntax>().Any(x => x.UsingKeyword.Text == "using") ?? false)
+            {
+                return true;
+            }
+
+            if (node.Parent is { } parent)
+            {
+                return HasPrecedingUsingDeclaration(parent);
+            }
+
+            return false;
+        }
+
         private static bool IsInUsing(ISymbol symbol, CancellationToken cancellationToken)
         {
             return symbol.TrySingleDeclaration<SyntaxNode>(cancellationToken, out var declaration) &&