Moq1100 incorrectly firing on nullable parameters

src/Moq.Analyzers/CallbackSignatureShouldMatchMockedMethodAnalyzer.cs

@@ -58,31 +58,52 @@ private static void Analyze(SyntaxNodeAnalysisContext context)
 
         if (mockedMethodArguments.Count != lambdaParameters.Count)
         {
-            Diagnostic diagnostic = Diagnostic.Create(Rule, callbackLambda.ParameterList.GetLocation());
+            Diagnostic diagnostic = callbackLambda.ParameterList.GetLocation().CreateDiagnostic(Rule);
             context.ReportDiagnostic(diagnostic);
         }
         else
         {
-            for (int argumentIndex = 0; argumentIndex < mockedMethodArguments.Count; argumentIndex++)
+            ValidateParameters(context, mockedMethodArguments, lambdaParameters);
+        }
+    }
+
+    private static void ValidateParameters(
+        SyntaxNodeAnalysisContext context,
+        SeparatedSyntaxList<ArgumentSyntax> mockedMethodArguments,
+        SeparatedSyntaxList<ParameterSyntax> lambdaParameters)
+    {
+        for (int argumentIndex = 0; argumentIndex < mockedMethodArguments.Count; argumentIndex++)
+        {
+            TypeSyntax? lambdaParameterTypeSyntax = lambdaParameters[argumentIndex].Type;
+
+            // TODO: Don't know if continue or break is the right thing to do here
+            if (lambdaParameterTypeSyntax is null)
             {
-                TypeSyntax? lambdaParameterTypeSyntax = lambdaParameters[argumentIndex].Type;
+                continue;
+            }
 
-                // TODO: Don't know if continue or break is the right thing to do here
-                if (lambdaParameterTypeSyntax is null) continue;
+            TypeInfo lambdaParameterType = context.SemanticModel.GetTypeInfo(lambdaParameterTypeSyntax, context.CancellationToken);
+            TypeInfo mockedMethodArgumentType = context.SemanticModel.GetTypeInfo(mockedMethodArguments[argumentIndex].Expression, context.CancellationToken);
 
-                TypeInfo lambdaParameterType = context.SemanticModel.GetTypeInfo(lambdaParameterTypeSyntax, context.CancellationToken);
+            ITypeSymbol? lambdaParameterTypeSymbol = lambdaParameterType.Type;
+            ITypeSymbol? mockedMethodTypeSymbol = mockedMethodArgumentType.Type;
 
-                TypeInfo mockedMethodArgumentType = context.SemanticModel.GetTypeInfo(mockedMethodArguments[argumentIndex].Expression, context.CancellationToken);
+            if (lambdaParameterTypeSymbol is null || mockedMethodTypeSymbol is null)
+            {
+                continue;
+            }
 
-                string? mockedMethodTypeName = mockedMethodArgumentType.ConvertedType?.ToString();
-                string? lambdaParameterTypeName = lambdaParameterType.ConvertedType?.ToString();
+            // Check if there's an implicit conversion or identity conversion
+            Conversion conversion = context.SemanticModel.Compilation.ClassifyConversion(lambdaParameterTypeSymbol, mockedMethodTypeSymbol);
 
-                if (!string.Equals(mockedMethodTypeName, lambdaParameterTypeName, StringComparison.Ordinal))
-                {
-                    Diagnostic diagnostic = callbackLambda.ParameterList.CreateDiagnostic(Rule);
-                    context.ReportDiagnostic(diagnostic);
-                }
+            // Where a conversion exists, even if it is explicit
+            if (conversion.Exists && conversion is not { IsImplicit: false, IsIdentity: false, IsExplicit: false })
+            {
+                continue;
             }
+
+            Diagnostic diagnostic = lambdaParameters[argumentIndex].GetLocation().CreateDiagnostic(Rule);
+            context.ReportDiagnostic(diagnostic);
         }
     }
 }

tests/Moq.Analyzers.Test/CallbackSignatureShouldMatchMockedMethodCodeFixTests.cs

@@ -1,9 +1,17 @@
+using Xunit.Abstractions;
 using Verifier = Moq.Analyzers.Test.Helpers.CodeFixVerifier<Moq.Analyzers.CallbackSignatureShouldMatchMockedMethodAnalyzer, Moq.Analyzers.CallbackSignatureShouldMatchMockedMethodCodeFix>;
 
 namespace Moq.Analyzers.Test;
 
 public class CallbackSignatureShouldMatchMockedMethodCodeFixTests
 {
+    private readonly ITestOutputHelper _output;
+
+    public CallbackSignatureShouldMatchMockedMethodCodeFixTests(ITestOutputHelper output)
+    {
+        _output = output;
+    }
+
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "MA0051:Method is too long", Justification = "Contains test data")]
     public static IEnumerable<object[]> TestData()
     {
@@ -22,7 +30,7 @@ public static IEnumerable<object[]> TestData()
                 """new Mock<IFoo>().Setup(x => x.Do(It.IsAny<List<string>>())).Returns((List<string> l) => { return 0; });""",
             ],
             [
-                """new Mock<IFoo>().Setup(x => x.Do(It.IsAny<string>())).Callback({|Moq1100:(int i)|} => { });""",
+                """new Mock<IFoo>().Setup(x => x.Do(It.IsAny<string>())).Callback(({|Moq1100:int i|}) => { });""",
                 """new Mock<IFoo>().Setup(x => x.Do(It.IsAny<string>())).Callback((string s) => { });""",
             ],
             [
@@ -34,7 +42,7 @@ public static IEnumerable<object[]> TestData()
                 """new Mock<IFoo>().Setup(x => x.Do(It.IsAny<int>(), It.IsAny<string>(), It.IsAny<DateTime>())).Callback((int i, string s, DateTime dt) => { });""",
             ],
             [
-                """new Mock<IFoo>().Setup(x => x.Do(It.IsAny<List<string>>())).Callback({|Moq1100:(int i)|} => { });""",
+                """new Mock<IFoo>().Setup(x => x.Do(It.IsAny<List<string>>())).Callback(({|Moq1100:int i|}) => { });""",
                 """new Mock<IFoo>().Setup(x => x.Do(It.IsAny<List<string>>())).Callback((List<string> l) => { });""",
             ],
             [
@@ -73,6 +81,26 @@ public static IEnumerable<object[]> TestData()
                 """new Mock<IFoo>().Setup(x => x.Do(It.IsAny<List<string>>())).Returns(0).Callback((List<string> l) => { });""",
                 """new Mock<IFoo>().Setup(x => x.Do(It.IsAny<List<string>>())).Returns(0).Callback((List<string> l) => { });""",
             ],
+            [ // Repros for https://github.com/rjmurillo/moq.analyzers/issues/172
+                """new Mock<IFoo>().Setup(m => m.Do(It.IsAny<object?>())).Returns((object? bar) => true);""",
+                """new Mock<IFoo>().Setup(m => m.Do(It.IsAny<object?>())).Returns((object? bar) => true);""",
+            ],
+            [
+                """new Mock<IFoo>().Setup(m => m.Do(42)).Returns((long bar) => true);""",
+                """new Mock<IFoo>().Setup(m => m.Do(42)).Returns((long bar) => true);""",
+            ],
+            [
+                """new Mock<IFoo>().Setup(m => m.Do((long)42)).Returns((long bar) => true);""",
+                """new Mock<IFoo>().Setup(m => m.Do((long)42)).Returns((long bar) => true);""",
+            ],
+            [
+                """new Mock<IFoo>().Setup(m => m.Do((long)42)).Returns((long bar) => true);""",
+                """new Mock<IFoo>().Setup(m => m.Do((long)42)).Returns((long bar) => true);""",
+            ],
+            [ // This was also reported as part of 172, but is a different error
+                """new Mock<IFoo>().Setup(m => m.Do(42)).Returns((int bar) => true);""",
+                """new Mock<IFoo>().Setup(m => m.Do(42)).Returns((int bar) => true);""",
+            ],
         }.WithNamespaces().WithMoqReferenceAssemblyGroups();
     }
 
@@ -91,6 +119,10 @@ internal interface IFoo
                 int Do(int i, string s, DateTime dt);
 
                 int Do(List<string> l);
+
+                bool Do(object? bar);
+
+                // bool Do(long bar);
             }
 
             internal class UnitTest
@@ -102,6 +134,15 @@ private void Test()
             }
             """;
 
-        await Verifier.VerifyCodeFixAsync(Template(@namespace, original), Template(@namespace, quickFix), referenceAssemblyGroup);
+        string o = Template(@namespace, original);
+        string f = Template(@namespace, quickFix);
+
+        _output.WriteLine("Original:");
+        _output.WriteLine(o);
+        _output.WriteLine(string.Empty);
+        _output.WriteLine("Fixed:");
+        _output.WriteLine(f);
+
+        await Verifier.VerifyCodeFixAsync(o, f, referenceAssemblyGroup);
     }
 }