BUGFIX IDISP017 when DisposeAsync()

Fix #204.

Author: JohanLarsson

IDisposableAnalyzers.NetCoreTests/IDISP017PreferUsingTests/Valid.cs

@@ -0,0 +1,51 @@
+namespace IDisposableAnalyzers.NetCoreTests.IDISP017PreferUsingTests
+{
+    using Gu.Roslyn.Asserts;
+    using Microsoft.CodeAnalysis.Diagnostics;
+    using NUnit.Framework;
+
+    public static class Valid
+    {
+        private static readonly DiagnosticAnalyzer Analyzer = new DisposeCallAnalyzer();
+
+        [TestCase("c.DisposeAsync()")]
+        [TestCase("c.DisposeAsync().ConfigureAwait(false)")]
+        public static void DisposeAsync(string expression)
+        {
+            var code = @"
+namespace N
+{
+    using System;
+    using System.IO;
+    using System.Threading.Tasks;
+
+    class Issue204
+    {
+        public async ValueTask M()
+        {
+            var c = new C();
+            try
+            {
+
+            }
+            finally
+            {
+                await c.DisposeAsync().ConfigureAwait(false);
+            }
+        }
+
+        public class C : IAsyncDisposable
+        {
+            private readonly IAsyncDisposable disposable = File.OpenRead(string.Empty);
+
+            public async ValueTask DisposeAsync()
+            {
+                await this.disposable.DisposeAsync().ConfigureAwait(false);
+            }
+        }
+    }
+}".AssertReplace("c.DisposeAsync().ConfigureAwait(false)", expression);
+            RoslynAssert.Valid(Analyzer, code);
+        }
+    }
+}

IDisposableAnalyzers/Analyzers/DisposeCallAnalyzer.cs

@@ -29,7 +29,7 @@ private static void Handle(SyntaxNodeAnalysisContext context)
         {
             if (!context.IsExcludedFromAnalysis() &&
                 context.Node is InvocationExpressionSyntax invocation &&
-                DisposeCall.IsMatch(invocation, context.SemanticModel, context.CancellationToken) &&
+                DisposeCall.IsMatchAny(invocation, context.SemanticModel, context.CancellationToken) &&
                 !invocation.TryFirstAncestorOrSelf<AnonymousFunctionExpressionSyntax>(out _) &&
                 DisposeCall.TryGetDisposedRootMember(invocation, context.SemanticModel, context.CancellationToken, out var root))
             {
@@ -117,7 +117,8 @@ bool IsReassigned(ExpressionSyntax location)
 
         private static bool IsPreferUsing(ILocalSymbol local, InvocationExpressionSyntax invocation, SyntaxNodeAnalysisContext context)
         {
-            return local.TrySingleDeclaration(context.CancellationToken, out var declaration) &&
+            return invocation.IsSymbol(KnownSymbol.IDisposable.Dispose, context.SemanticModel, context.CancellationToken) &&
+                   local.TrySingleDeclaration(context.CancellationToken, out var declaration) &&
                    declaration is VariableDeclaratorSyntax declarator &&
                    declaration.TryFirstAncestor(out LocalDeclarationStatementSyntax? localDeclarationStatement) &&
                    invocation.TryFirstAncestor(out ExpressionStatementSyntax? expressionStatement) &&

IDisposableAnalyzers/Helpers/Disposable.Disposes.cs

@@ -180,7 +180,7 @@ when recursion.Target(argument) is { } target
 
             bool IsDisposeOrReturnValueDisposed(InvocationExpressionSyntax invocation)
             {
-                if (DisposeCall.IsMatch(invocation, recursion.SemanticModel, recursion.CancellationToken))
+                if (DisposeCall.IsMatchAny(invocation, recursion.SemanticModel, recursion.CancellationToken))
                 {
                     return true;
                 }

IDisposableAnalyzers/Helpers/DisposeCall.cs

@@ -11,7 +11,7 @@ internal static class DisposeCall
         internal static bool TryGetDisposed(InvocationExpressionSyntax disposeCall, SemanticModel semanticModel, CancellationToken cancellationToken, [NotNullWhen(true)] out ISymbol? disposed)
         {
             disposed = null;
-            return IsMatch(disposeCall, semanticModel, cancellationToken) &&
+            return IsMatchAny(disposeCall, semanticModel, cancellationToken) &&
                    MemberPath.TrySingle(disposeCall, out var expression) &&
                    semanticModel.TryGetSymbol(expression, cancellationToken, out disposed);
         }
@@ -71,7 +71,7 @@ internal static bool IsDisposing(InvocationExpressionSyntax disposeCall, ISymbol
             return false;
         }
 
-        internal static bool IsMatch(InvocationExpressionSyntax candidate, SemanticModel semanticModel, CancellationToken cancellationToken)
+        internal static bool IsMatchAny(InvocationExpressionSyntax candidate, SemanticModel semanticModel, CancellationToken cancellationToken)
         {
             return candidate.ArgumentList is { Arguments: { Count: 0 } } &&
                    (candidate.IsSymbol(KnownSymbol.IDisposable.Dispose, semanticModel, cancellationToken) ||

ValidCode.NetCore/AsyncDisposable/Issue204.cs

@@ -0,0 +1,33 @@
+namespace ValidCode.NetCore.AsyncDisposable
+{
+    using System;
+    using System.IO;
+    using System.Threading.Tasks;
+
+    class Issue204
+    {
+        public async ValueTask M()
+        {
+            var c = new C();
+            try
+            {
+
+            }
+            finally
+            {
+                await c.DisposeAsync()
+                       .ConfigureAwait(false);
+            }
+        }
+
+        public class C : IAsyncDisposable
+        {
+            private readonly IAsyncDisposable disposable = File.OpenRead(string.Empty);
+
+            public async ValueTask DisposeAsync()
+            {
+                await this.disposable.DisposeAsync().ConfigureAwait(false);
+            }
+        }
+    }
+}