feat: support SimpleLambdaExpressionSyntax in callback validation

src/Analyzers/CallbackSignatureShouldMatchMockedMethodAnalyzer.cs

@@ -80,14 +80,14 @@ private static void Analyze(OperationAnalysisContext context, MoqKnownSymbols kn
             return;
         }
 
-        ParenthesizedLambdaExpressionSyntax? callbackLambda = TryGetCallbackLambda(callbackOrReturnsInvocation);
+        LambdaExpressionSyntax? callbackLambda = TryGetCallbackLambda(callbackOrReturnsInvocation);
         if (callbackLambda == null)
         {
             return;
         }
 
         // Ignoring calls with no arguments because those are valid in Moq
-        SeparatedSyntaxList<ParameterSyntax> lambdaParameters = callbackLambda.ParameterList.Parameters;
+        SeparatedSyntaxList<ParameterSyntax> lambdaParameters = GetLambdaParameters(callbackLambda);
         if (lambdaParameters.Count == 0)
         {
             return;
@@ -98,9 +98,9 @@ private static void Analyze(OperationAnalysisContext context, MoqKnownSymbols kn
         ValidateCallbackAgainstSetup(context, semanticModel, setupInvocation, callbackLambda, lambdaParameters);
     }
 
-    private static ParenthesizedLambdaExpressionSyntax? TryGetCallbackLambda(InvocationExpressionSyntax callbackOrReturnsInvocation)
+    private static LambdaExpressionSyntax? TryGetCallbackLambda(InvocationExpressionSyntax callbackOrReturnsInvocation)
     {
-        if (callbackOrReturnsInvocation.ArgumentList.Arguments[0]?.Expression is ParenthesizedLambdaExpressionSyntax directLambda)
+        if (callbackOrReturnsInvocation.ArgumentList.Arguments[0]?.Expression is LambdaExpressionSyntax directLambda)
         {
             return directLambda;
         }
@@ -113,23 +113,34 @@ private static void Analyze(OperationAnalysisContext context, MoqKnownSymbols kn
         }
 
         // Extract the lambda from the delegate constructor (support both parenthesized and simple lambdas)
-        LambdaExpressionSyntax? lambdaExpression = delegateConstructor.ArgumentList!.Arguments[0]?.Expression as LambdaExpressionSyntax;
+        return delegateConstructor.ArgumentList!.Arguments[0]?.Expression as LambdaExpressionSyntax;
+    }
 
-        // Simple lambdas are currently skipped to avoid handling edge cases and maintain simplicity.
-        // TODO: Implement support for SimpleLambdaExpressionSyntax in delegate constructors.
-        if (lambdaExpression is SimpleLambdaExpressionSyntax)
+    private static SeparatedSyntaxList<ParameterSyntax> GetLambdaParameters(LambdaExpressionSyntax lambda)
+    {
+        return lambda switch
         {
-            return null;
-        }
+            ParenthesizedLambdaExpressionSyntax parenthesized => parenthesized.ParameterList.Parameters,
+            SimpleLambdaExpressionSyntax simple => SyntaxFactory.SingletonSeparatedList(simple.Parameter),
+            _ => default,
+        };
+    }
 
-        return lambdaExpression as ParenthesizedLambdaExpressionSyntax;
+    private static SyntaxNode GetDiagnosticNode(LambdaExpressionSyntax lambda)
+    {
+        return lambda switch
+        {
+            ParenthesizedLambdaExpressionSyntax parenthesized => parenthesized.ParameterList,
+            SimpleLambdaExpressionSyntax simple => simple.Parameter,
+            _ => lambda,
+        };
     }
 
     private static void ValidateCallbackAgainstSetup(
         OperationAnalysisContext context,
         SemanticModel semanticModel,
         InvocationExpressionSyntax? setupInvocation,
-        ParenthesizedLambdaExpressionSyntax callbackLambda,
+        LambdaExpressionSyntax callbackLambda,
         SeparatedSyntaxList<ParameterSyntax> lambdaParameters)
     {
         InvocationExpressionSyntax? mockedMethodInvocation = setupInvocation.FindMockedMethodInvocationFromSetupMethod();
@@ -143,7 +154,7 @@ private static void ValidateCallbackAgainstSetup(
 
         if (mockedMethodArguments.Count != lambdaParameters.Count)
         {
-            Diagnostic diagnostic = callbackLambda.ParameterList.CreateDiagnostic(Rule, methodName);
+            Diagnostic diagnostic = GetDiagnosticNode(callbackLambda).CreateDiagnostic(Rule, methodName);
             context.ReportDiagnostic(diagnostic);
         }
         else

src/CodeFixes/CallbackSignatureShouldMatchMockedMethodFixer.cs

@@ -12,6 +12,8 @@
 [Shared]
 public class CallbackSignatureShouldMatchMockedMethodFixer : CodeFixProvider
 {
+    private const string FixTitle = "Fix Moq callback signature";
+
     /// <inheritdoc />
     public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(DiagnosticIds.BadCallbackParameters);
 
@@ -31,66 +33,158 @@
         Diagnostic diagnostic = context.Diagnostics.First();
         TextSpan diagnosticSpan = diagnostic.Location.SourceSpan;
 
-        // Find the type declaration identified by the diagnostic.
-        ParameterListSyntax? badArgumentListSyntax = root.FindToken(diagnosticSpan.Start)
-                                        .Parent?
+        SyntaxNode? node = root.FindToken(diagnosticSpan.Start).Parent;
+
+        // Try parenthesized lambda path first (diagnostic on ParameterListSyntax).
+        ParameterListSyntax? badArgumentListSyntax = node?
                                         .AncestorsAndSelf()
                                         .OfType<ParameterListSyntax>()
                                         .FirstOrDefault();
 
-        if (badArgumentListSyntax is null)
+        if (badArgumentListSyntax is not null)
         {
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    FixTitle,
+                    cancellationToken => FixParenthesizedCallbackSignatureAsync(root, context.Document, badArgumentListSyntax, cancellationToken),
+                    FixTitle),
+                diagnostic);
             return;
         }
 
-        // Register a code action that will invoke the fix.
-        context.RegisterCodeFix(
-            CodeAction.Create(
-                "Fix Moq callback signature",
-                cancellationToken => FixCallbackSignatureAsync(root, context.Document, badArgumentListSyntax, cancellationToken),
-                "Fix Moq callback signature"),
-            diagnostic);
+        // SimpleLambdaExpressionSyntax nodes never contain a ParameterListSyntax,
+        // so the ancestor search above intentionally falls through to this path.
+        SimpleLambdaExpressionSyntax? simpleLambda = node?
+                                        .AncestorsAndSelf()
+                                        .OfType<SimpleLambdaExpressionSyntax>()
+                                        .FirstOrDefault();
+
+        if (simpleLambda is not null && !IsInsideDelegateConstructor(simpleLambda))
+        {
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    FixTitle,
+                    cancellationToken => FixSimpleLambdaCallbackSignatureAsync(root, context.Document, simpleLambda, cancellationToken),
+                    FixTitle),
+                diagnostic);
+        }
     }
 
-    private static async Task<Document> FixCallbackSignatureAsync(SyntaxNode root, Document document, ParameterListSyntax? oldParameters, CancellationToken cancellationToken)
+    private static async Task<Document> FixParenthesizedCallbackSignatureAsync(SyntaxNode root, Document document, ParameterListSyntax oldParameters, CancellationToken cancellationToken)
     {
-        SemanticModel? semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+        if (IsInsideDelegateConstructor(oldParameters))
+        {
+            return document;
+        }
 
-        if (semanticModel is null)
+        ParameterListSyntax? newParameters = await ResolveNewParameterListAsync(document, oldParameters, oldParameters.SpanStart, oldParameters.Parameters, cancellationToken).ConfigureAwait(false);
+        if (newParameters is null)
         {
             return document;
         }
 
-        MoqKnownSymbols knownSymbols = new(semanticModel.Compilation);
+        SyntaxNode newRoot = root.ReplaceNode(oldParameters, newParameters);
+        return document.WithSyntaxRoot(newRoot);
+    }
 
-        if (oldParameters?.Parent?.Parent?.Parent?.Parent is not InvocationExpressionSyntax callbackInvocation)
+    private static async Task<Document> FixSimpleLambdaCallbackSignatureAsync(SyntaxNode root, Document document, SimpleLambdaExpressionSyntax simpleLambda, CancellationToken cancellationToken)
+    {
+        if (IsInsideDelegateConstructor(simpleLambda))
         {
             return document;
         }
 
+        SeparatedSyntaxList<ParameterSyntax> originalParams = SyntaxFactory.SeparatedList(new[] { simpleLambda.Parameter });
+        ParameterListSyntax? newParameters = await ResolveNewParameterListAsync(document, simpleLambda, simpleLambda.SpanStart, originalParams, cancellationToken).ConfigureAwait(false);
+        if (newParameters is null)
+        {
+            return document;
+        }
+
+        ParenthesizedLambdaExpressionSyntax parenthesizedLambda = SyntaxFactory.ParenthesizedLambdaExpression(
+            simpleLambda.AsyncKeyword,
+            newParameters,
+            simpleLambda.ArrowToken,
+            simpleLambda.Block,
+            simpleLambda.ExpressionBody)
+            .WithTriviaFrom(simpleLambda);
+
+        SyntaxNode newRoot = root.ReplaceNode(simpleLambda, parenthesizedLambda);
+        return document.WithSyntaxRoot(newRoot);
+    }
+
+    private static async Task<ParameterListSyntax?> ResolveNewParameterListAsync(Document document, SyntaxNode lambdaNode, int position, SeparatedSyntaxList<ParameterSyntax>? originalParameters, CancellationToken cancellationToken)
+    {
+        SemanticModel? semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+        if (semanticModel is null)
+        {
+            return null;
+        }
+
+        MoqKnownSymbols knownSymbols = new(semanticModel.Compilation);
+
+        InvocationExpressionSyntax? callbackInvocation = lambdaNode
+            .Ancestors()
+            .OfType<InvocationExpressionSyntax>()
+            .FirstOrDefault();
+
+        if (callbackInvocation is null)
+        {
+            return null;
+        }
+
+        IMethodSymbol? mockedMethod = FindSingleMockedMethod(semanticModel, knownSymbols, callbackInvocation, cancellationToken);
+        if (mockedMethod is null)
+        {
+            return null;
+        }
+
+        return BuildParameterList(semanticModel, mockedMethod, position, originalParameters);
+    }
+
+    private static bool IsInsideDelegateConstructor(SyntaxNode node)
+    {
+        return node
+            .Ancestors()
+            .OfType<ObjectCreationExpressionSyntax>()
+            .Any();
+    }
+
+    private static IMethodSymbol? FindSingleMockedMethod(SemanticModel semanticModel, MoqKnownSymbols knownSymbols, InvocationExpressionSyntax callbackInvocation, CancellationToken cancellationToken)
+    {
         InvocationExpressionSyntax? setupMethodInvocation = semanticModel.FindSetupMethodFromCallbackInvocation(knownSymbols, callbackInvocation, cancellationToken);
         if (setupMethodInvocation is null)
         {
-            return document;
+            return null;
         }
 
-        IMethodSymbol[] matchingMockedMethods = semanticModel.GetAllMatchingMockedMethodSymbolsFromSetupMethodInvocation(setupMethodInvocation).ToArray();
+        // Short-circuit: we only need to know if there is exactly one match.
+        IMethodSymbol[] matchingMockedMethods = semanticModel.GetAllMatchingMockedMethodSymbolsFromSetupMethodInvocation(setupMethodInvocation).Take(2).ToArray();
 
         if (matchingMockedMethods.Length != 1)
         {
-            return document;
+            return null;
         }
 
-        ParameterListSyntax newParameters = SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(matchingMockedMethods[0].Parameters.Select(
-            parameterSymbol =>
+        return matchingMockedMethods[0];
+    }
+
+    private static ParameterListSyntax BuildParameterList(SemanticModel semanticModel, IMethodSymbol mockedMethod, int position, SeparatedSyntaxList<ParameterSyntax>? originalParameters = null)
+    {
+        return SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(mockedMethod.Parameters.Select(
+            (parameterSymbol, index) =>
             {
-                TypeSyntax type = SyntaxFactory.ParseTypeName(parameterSymbol.Type.ToMinimalDisplayString(semanticModel, oldParameters.SpanStart));
+                TypeSyntax type = SyntaxFactory.ParseTypeName(parameterSymbol.Type.ToMinimalDisplayString(semanticModel, position));
                 SyntaxTokenList modifiers = GetParameterModifiers(parameterSymbol.RefKind);
-                return SyntaxFactory.Parameter(default, modifiers, type, SyntaxFactory.Identifier(parameterSymbol.Name), null);
-            })));
 
-        SyntaxNode newRoot = root.ReplaceNode(oldParameters, newParameters);
-        return document.WithSyntaxRoot(newRoot);
+                string name = originalParameters.HasValue && index < originalParameters.Value.Count
+                    ? originalParameters.Value[index].Identifier.ValueText
+                    : parameterSymbol.Name;
+
+                SyntaxToken identifier = SyntaxFactory.Identifier(name);
+
+                return SyntaxFactory.Parameter(default, modifiers, type, identifier, null);
+            })));
     }
 
     private static SyntaxTokenList GetParameterModifiers(RefKind refKind)

tests/Moq.Analyzers.Test/CallbackSignatureShouldMatchMockedMethodAnalyzerTests.cs

@@ -54,6 +54,12 @@ public static IEnumerable<object[]> CallbackValidationData()
 
             // Explicitly typed lambda with correct parameter type (exercises GetDeclaredSymbol path)
             ["""new Mock<IFoo>().Setup(x => x.DoWork("test")).Callback((string x) => { });"""],
+
+            // Simple lambda in delegate constructor with correct type (issue #1012)
+            ["""new Mock<IFoo>().Setup(x => x.DoWork("test")).Callback(new Action<string>(x => { }));"""],
+
+            // Simple lambda in delegate constructor with correct type using Returns (issue #1012)
+            ["""new Mock<IFoo>().Setup(x => x.DoWork("test")).Returns(new Func<string, int>(x => 42));"""],
         }.WithNamespaces().WithMoqReferenceAssemblyGroups();
 
         // Invalid patterns that SHOULD trigger the analyzer
@@ -76,6 +82,12 @@ public static IEnumerable<object[]> CallbackValidationData()
 
             // Explicitly typed lambda with wrong parameter type (exercises semantic resolution mismatch)
             ["""new Mock<IFoo>().Setup(x => x.DoWork("test")).Callback(({|Moq1100:DateTime wrongParam|}) => { });"""],
+
+            // Simple lambda in delegate constructor with wrong type (issue #1012)
+            ["""new Mock<IFoo>().Setup(x => x.DoWork("test")).Callback(new Action<int>({|Moq1100:x|} => { }));"""],
+
+            // Simple lambda in delegate constructor with argument count mismatch (issue #1012)
+            ["""new Mock<IFoo>().Setup(x => x.ProcessMultiple(It.IsAny<int>(), It.IsAny<string>(), It.IsAny<DateTime>())).Callback(new Action<int>({|Moq1100:x|} => { }));"""],
         }.WithNamespaces().WithMoqReferenceAssemblyGroups();
 
         return validPatterns.Concat(invalidPatterns);