Bug/fix issue 144

src/Moq.Analyzers/SetupShouldNotIncludeAsyncResultAnalyzer.cs

@@ -32,24 +32,38 @@ public override void Initialize(AnalysisContext context)
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Maintainability", "AV1500:Member or local function contains too many statements", Justification = "Tracked in https://github.com/rjmurillo/moq.analyzers/issues/90")]
     private static void Analyze(SyntaxNodeAnalysisContext context)
     {
+        // Check Moq version and skip analysis if the version is 4.16.0 or later
+        AssemblyIdentity? moqAssembly = context.Compilation.ReferencedAssemblyNames.FirstOrDefault(a => a.Name.Equals("Moq", StringComparison.OrdinalIgnoreCase));
+
+        if (moqAssembly != null && moqAssembly.Version >= new Version(4, 16, 0))
+        {
+            // Skip analysis for Moq 4.16.0 or later
+            return;
+        }
+
         InvocationExpressionSyntax setupInvocation = (InvocationExpressionSyntax)context.Node;
 
-        if (setupInvocation.Expression is MemberAccessExpressionSyntax memberAccessExpression && context.SemanticModel.IsMoqSetupMethod(memberAccessExpression, context.CancellationToken))
+        if (setupInvocation.Expression is not MemberAccessExpressionSyntax memberAccessExpression ||
+            !context.SemanticModel.IsMoqSetupMethod(memberAccessExpression, context.CancellationToken))
         {
-            ExpressionSyntax? mockedMemberExpression = setupInvocation.FindMockedMemberExpressionFromSetupMethod();
-            if (mockedMemberExpression == null)
-            {
-                return;
-            }
-
-            SymbolInfo symbolInfo = context.SemanticModel.GetSymbolInfo(mockedMemberExpression, context.CancellationToken);
-            if ((symbolInfo.Symbol is IPropertySymbol || symbolInfo.Symbol is IMethodSymbol)
-                && !symbolInfo.Symbol.IsOverridable()
-                && symbolInfo.Symbol.IsMethodReturnTypeTask())
-            {
-                Diagnostic diagnostic = mockedMemberExpression.GetLocation().CreateDiagnostic(Rule);
-                context.ReportDiagnostic(diagnostic);
-            }
+            return;
         }
+
+        ExpressionSyntax? mockedMemberExpression = setupInvocation.FindMockedMemberExpressionFromSetupMethod();
+        if (mockedMemberExpression == null)
+        {
+            return;
+        }
+
+        SymbolInfo symbolInfo = context.SemanticModel.GetSymbolInfo(mockedMemberExpression, context.CancellationToken);
+        if (symbolInfo.Symbol is not (IPropertySymbol or IMethodSymbol)
+            || symbolInfo.Symbol.IsOverridable()
+            || !symbolInfo.Symbol.IsMethodReturnTypeTask())
+        {
+            return;
+        }
+
+        Diagnostic diagnostic = mockedMemberExpression.GetLocation().CreateDiagnostic(Rule);
+        context.ReportDiagnostic(diagnostic);
     }
 }

tests/Moq.Analyzers.Test/CallbackSignatureShouldMatchMockedMethodCodeFixTests.cs

@@ -1,4 +1,3 @@
-using Xunit.Abstractions;
 using Verifier = Moq.Analyzers.Test.Helpers.CodeFixVerifier<Moq.Analyzers.CallbackSignatureShouldMatchMockedMethodAnalyzer, Moq.CodeFixes.CallbackSignatureShouldMatchMockedMethodCodeFix>;
 
 namespace Moq.Analyzers.Test;

tests/Moq.Analyzers.Test/GlobalUsings.cs

@@ -1 +1,2 @@
 global using Moq.Analyzers.Test.Helpers;
+global using Xunit.Abstractions;

tests/Moq.Analyzers.Test/Helpers/TestDataExtensions.cs

@@ -20,6 +20,14 @@ public static IEnumerable<object[]> WithMoqReferenceAssemblyGroups(this IEnumera
         }
     }
 
+    public static IEnumerable<object[]> WithOldMoqReferenceAssemblyGroups(this IEnumerable<object[]> data)
+    {
+        foreach (object[] item in data)
+        {
+            yield return item.Prepend(ReferenceAssemblyCatalog.Net80WithOldMoq).ToArray();
+        }
+    }
+
     public static IEnumerable<object[]> WithNewMoqReferenceAssemblyGroups(this IEnumerable<object[]> data)
     {
         foreach (object[] item in data)

tests/Moq.Analyzers.Test/SetupShouldBeUsedOnlyForOverridableMembersAnalyzerTests.cs

@@ -1,4 +1,3 @@
-using Xunit.Abstractions;
 using Verifier = Moq.Analyzers.Test.Helpers.AnalyzerVerifier<Moq.Analyzers.SetupShouldBeUsedOnlyForOverridableMembersAnalyzer>;
 
 namespace Moq.Analyzers.Test;

tests/Moq.Analyzers.Test/SetupShouldNotIncludeAsyncResultAnalyzerTests.cs

@@ -2,41 +2,50 @@
 
 namespace Moq.Analyzers.Test;
 
-public class SetupShouldNotIncludeAsyncResultAnalyzerTests
+public class SetupShouldNotIncludeAsyncResultAnalyzerTests(ITestOutputHelper output)
 {
     public static IEnumerable<object[]> TestData()
     {
         return new object[][]
         {
             ["""new Mock<AsyncClient>().Setup(c => c.TaskAsync());"""],
+
+            // Prior to Moq 4.16, the setup helper ReturnsAsync(), ThrowsAsync() are preferred
             ["""new Mock<AsyncClient>().Setup(c => c.GenericTaskAsync()).ReturnsAsync(string.Empty);"""],
+
+            // Starting with Moq 4.16, you can simply .Setup the returned tasks's .Result property
             ["""new Mock<AsyncClient>().Setup(c => {|Moq1201:c.GenericTaskAsync().Result|});"""],
-        }.WithNamespaces().WithMoqReferenceAssemblyGroups();
+        }.WithNamespaces().WithOldMoqReferenceAssemblyGroups();
     }
 
     [Theory]
     [MemberData(nameof(TestData))]
     public async Task ShouldAnalyzeSetupForAsyncResult(string referenceAssemblyGroup, string @namespace, string mock)
     {
+        string source =
+            $$"""
+              {{@namespace}}
+
+              public class AsyncClient
+              {
+                  public virtual Task TaskAsync() => Task.CompletedTask;
+
+                  public virtual Task<string> GenericTaskAsync() => Task.FromResult(string.Empty);
+              }
+
+              internal class UnitTest
+              {
+                  private void Test()
+                  {
+                      {{mock}}
+                  }
+              }
+              """;
+
+        output.WriteLine(source);
+
         await Verifier.VerifyAnalyzerAsync(
-                $$"""
-                {{@namespace}}
-
-                public class AsyncClient
-                {
-                    public virtual Task TaskAsync() => Task.CompletedTask;
-
-                    public virtual Task<string> GenericTaskAsync() => Task.FromResult(string.Empty);
-                }
-
-                internal class UnitTest
-                {
-                    private void Test()
-                    {
-                        {{mock}}
-                    }
-                }
-                """,
+                source,
                 referenceAssemblyGroup);
     }
 }