Do not offer to use expression body on a lambda if it would cause overload resolution to change. (#76646)

Fixes #76645

Author: CyrusNajmabadi

src/Analyzers/CSharp/Analyzers/UseExpressionBodyForLambda/UseExpressionBodyForLambdaDiagnosticAnalyzer.cs

@@ -71,30 +71,30 @@ private static void AnalyzeSyntax(SyntaxNodeAnalysisContext context, CodeStyleOp
         SemanticModel semanticModel, CodeStyleOption2<ExpressionBodyPreference> option,
         LambdaExpressionSyntax declaration, AnalyzerOptions analyzerOptions, CancellationToken cancellationToken)
     {
-        if (UseExpressionBodyForLambdaHelpers.CanOfferUseExpressionBody(option.Value, declaration, declaration.GetLanguageVersion(), cancellationToken))
+        if (UseExpressionBodyForLambdaHelpers.CanOfferUseExpressionBody(
+                semanticModel, option.Value, declaration, declaration.GetLanguageVersion(), cancellationToken))
         {
-            var location = GetDiagnosticLocation(declaration);
-
-            var additionalLocations = ImmutableArray.Create(declaration.GetLocation());
-            var properties = ImmutableDictionary<string, string?>.Empty;
             return DiagnosticHelper.Create(
                 s_useExpressionBodyForLambda,
-                location, option.Notification,
-                analyzerOptions, additionalLocations, properties);
+                GetDiagnosticLocation(declaration),
+                option.Notification,
+                analyzerOptions,
+                [declaration.GetLocation()],
+                ImmutableDictionary<string, string?>.Empty);
         }
 
-        if (UseExpressionBodyForLambdaHelpers.CanOfferUseBlockBody(semanticModel, option.Value, declaration, cancellationToken))
+        if (UseExpressionBodyForLambdaHelpers.CanOfferUseBlockBody(
+                semanticModel, option.Value, declaration, cancellationToken))
         {
             // They have an expression body.  Create a diagnostic to convert it to a block
             // if they don't want expression bodies for this member.  
-            var location = GetDiagnosticLocation(declaration);
-
-            var properties = ImmutableDictionary<string, string?>.Empty;
-            var additionalLocations = ImmutableArray.Create(declaration.GetLocation());
             return DiagnosticHelper.Create(
                 s_useBlockBodyForLambda,
-                location, option.Notification,
-                analyzerOptions, additionalLocations, properties);
+                 GetDiagnosticLocation(declaration),
+                option.Notification,
+                analyzerOptions,
+                [declaration.GetLocation()],
+                ImmutableDictionary<string, string?>.Empty);
         }
 
         return null;

src/Analyzers/CSharp/Analyzers/UseExpressionBodyForLambda/UseExpressionBodyForLambdaHelpers.cs

@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Utilities;
 using Microsoft.CodeAnalysis.Diagnostics;
 
 namespace Microsoft.CodeAnalysis.CSharp.UseExpressionBodyForLambda;
@@ -64,7 +65,7 @@ internal static bool CanOfferUseBlockBody(
     }
 
     internal static bool CanOfferUseExpressionBody(
-        ExpressionBodyPreference preference, LambdaExpressionSyntax declaration, LanguageVersion languageVersion, CancellationToken cancellationToken)
+        SemanticModel semanticModel, ExpressionBodyPreference preference, LambdaExpressionSyntax declaration, LanguageVersion languageVersion, CancellationToken cancellationToken)
     {
         var userPrefersExpressionBodies = preference != ExpressionBodyPreference.Never;
         if (!userPrefersExpressionBodies)
@@ -82,7 +83,7 @@ internal static bool CanOfferUseExpressionBody(
 
         // They don't have an expression body.  See if we could convert the block they 
         // have into one.
-        return TryConvertToExpressionBody(declaration, languageVersion, preference, cancellationToken, out _);
+        return TryConvertToExpressionBody(semanticModel, declaration, languageVersion, preference, cancellationToken, out _);
     }
 
     internal static ExpressionSyntax? GetBodyAsExpression(LambdaExpressionSyntax declaration)
@@ -105,6 +106,7 @@ internal static ReportDiagnostic GetOptionSeverity(CodeStyleOption2<ExpressionBo
     }
 
     internal static bool TryConvertToExpressionBody(
+        SemanticModel semanticModel,
         LambdaExpressionSyntax declaration,
         LanguageVersion languageVersion,
         ExpressionBodyPreference conversionPreference,
@@ -140,6 +142,22 @@ internal static bool TryConvertToExpressionBody(
         if (semicolonToken.TrailingTrivia.Any(t => t.IsDirective))
             return false;
 
+        // Changing from a block to an expression body can change semantics.  Consider:
+        //
+        //     X(() => { A = 1; });
+        //     
+        //     void X(Action action);
+        //     void X(Func<int> func);
+        //
+        // Changing this to `X(() => A = 1);` would change from calling the 'Action' overload to the 'Func<int>'
+        // overload.  Do a final semantic check to make sure the code meaning stays the same.
+        var speculationAnalyzer = new SpeculationAnalyzer(
+            declaration,
+            declaration.WithBody(expression),
+            semanticModel, cancellationToken);
+        if (speculationAnalyzer.ReplacementChangesSemantics())
+            return false;
+
         return true;
     }
 }

src/Analyzers/CSharp/CodeFixes/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeActionHelpers.cs

@@ -19,22 +19,23 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeFixes.UseExpressionBodyForLambda;
 
 internal static class UseExpressionBodyForLambdaCodeActionHelpers
 {
-    internal static LambdaExpressionSyntax Update(SemanticModel semanticModel, LambdaExpressionSyntax originalDeclaration, LambdaExpressionSyntax currentDeclaration, CancellationToken cancellationToken)
-        => UpdateWorker(semanticModel, originalDeclaration, currentDeclaration, cancellationToken).WithAdditionalAnnotations(Formatter.Annotation);
+    internal static LambdaExpressionSyntax Update(SemanticModel semanticModel, LambdaExpressionSyntax lambdaExpression, CancellationToken cancellationToken)
+        => UpdateWorker(semanticModel, lambdaExpression, cancellationToken).WithAdditionalAnnotations(Formatter.Annotation);
 
     private static LambdaExpressionSyntax UpdateWorker(
-        SemanticModel semanticModel, LambdaExpressionSyntax originalDeclaration, LambdaExpressionSyntax currentDeclaration, CancellationToken cancellationToken)
+        SemanticModel semanticModel, LambdaExpressionSyntax lambdaExpression, CancellationToken cancellationToken)
     {
-        var expressionBody = UseExpressionBodyForLambdaHelpers.GetBodyAsExpression(currentDeclaration);
+        var expressionBody = UseExpressionBodyForLambdaHelpers.GetBodyAsExpression(lambdaExpression);
         return expressionBody == null
-            ? WithExpressionBody(currentDeclaration, originalDeclaration.GetLanguageVersion(), cancellationToken)
-            : WithBlockBody(semanticModel, originalDeclaration, currentDeclaration, expressionBody);
+            ? WithExpressionBody(semanticModel, lambdaExpression, cancellationToken)
+            : WithBlockBody(semanticModel, lambdaExpression, expressionBody);
     }
 
-    private static LambdaExpressionSyntax WithExpressionBody(LambdaExpressionSyntax declaration, LanguageVersion languageVersion, CancellationToken cancellationToken)
+    private static LambdaExpressionSyntax WithExpressionBody(
+        SemanticModel semanticModel, LambdaExpressionSyntax declaration, CancellationToken cancellationToken)
     {
         if (!UseExpressionBodyForLambdaHelpers.TryConvertToExpressionBody(
-                declaration, languageVersion, ExpressionBodyPreference.WhenPossible, cancellationToken, out var expressionBody))
+                semanticModel, declaration, declaration.GetLanguageVersion(), ExpressionBodyPreference.WhenPossible, cancellationToken, out var expressionBody))
         {
             return declaration;
         }
@@ -53,23 +54,23 @@ private static LambdaExpressionSyntax WithExpressionBody(LambdaExpressionSyntax
     }
 
     private static LambdaExpressionSyntax WithBlockBody(
-        SemanticModel semanticModel, LambdaExpressionSyntax originalDeclaration, LambdaExpressionSyntax currentDeclaration, ExpressionSyntax expressionBody)
+        SemanticModel semanticModel, LambdaExpressionSyntax lambdaExpression, ExpressionSyntax expressionBody)
     {
         var createReturnStatementForExpression = CreateReturnStatementForExpression(
-            semanticModel, originalDeclaration);
+            semanticModel, lambdaExpression);
 
         if (!expressionBody.TryConvertToStatement(
                 semicolonTokenOpt: null,
                 createReturnStatementForExpression,
                 out var statement))
         {
-            return currentDeclaration;
+            return lambdaExpression;
         }
 
         // If the user is converting to a block, it's likely they intend to add multiple
         // statements to it.  So make a multi-line block so that things are formatted properly
         // for them to do so.
-        return currentDeclaration.WithBody(Block(
+        return lambdaExpression.WithBody(Block(
             OpenBraceToken.WithAppendedTrailingTrivia(ElasticCarriageReturnLineFeed),
             [statement],
             CloseBraceToken));

src/Analyzers/CSharp/CodeFixes/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeFixProvider.cs

@@ -7,7 +7,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp.CodeFixes.UseExpressionBodyForLambda;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -20,51 +19,28 @@ namespace Microsoft.CodeAnalysis.CSharp.UseExpressionBodyForLambda;
 [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.UseExpressionBodyForLambda), Shared]
 [method: ImportingConstructor]
 [method: SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
-internal sealed class UseExpressionBodyForLambdaCodeFixProvider() : SyntaxEditorBasedCodeFixProvider
+internal sealed class UseExpressionBodyForLambdaCodeFixProvider() : ForkingSyntaxEditorBasedCodeFixProvider<LambdaExpressionSyntax>
 {
     public override ImmutableArray<string> FixableDiagnosticIds { get; } = [IDEDiagnosticIds.UseExpressionBodyForLambdaExpressionsDiagnosticId];
 
-    public override Task RegisterCodeFixesAsync(CodeFixContext context)
+    protected override (string title, string equivalenceKey) GetTitleAndEquivalenceKey(CodeFixContext context)
     {
-        var document = context.Document;
         var diagnostic = context.Diagnostics[0];
-
         var title = diagnostic.GetMessage();
-        var codeAction = CodeAction.Create(
-            title,
-            c => FixWithSyntaxEditorAsync(document, diagnostic, c),
-            title);
-
-        context.RegisterCodeFix(codeAction, context.Diagnostics);
-        return Task.CompletedTask;
+        return (title, title);
     }
 
-    protected override Task FixAllAsync(Document document, ImmutableArray<Diagnostic> diagnostics, SyntaxEditor editor, CancellationToken cancellationToken)
-        => FixAllImplAsync(document, diagnostics, editor, cancellationToken);
-
-    private static async Task FixAllImplAsync(Document document, ImmutableArray<Diagnostic> diagnostics, SyntaxEditor editor, CancellationToken cancellationToken)
+    protected override async Task FixAsync(
+        Document document,
+        SyntaxEditor editor,
+        LambdaExpressionSyntax lambdaExpression,
+        ImmutableDictionary<string, string?> properties,
+        CancellationToken cancellationToken)
     {
         var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-        foreach (var diagnostic in diagnostics)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            AddEdits(editor, semanticModel, diagnostic, cancellationToken);
-        }
-    }
-
-    private static Task<Document> FixWithSyntaxEditorAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken)
-        => FixAllWithEditorAsync(
-            document, editor => FixAllImplAsync(document, [diagnostic], editor, cancellationToken), cancellationToken);
-
-    private static void AddEdits(
-        SyntaxEditor editor, SemanticModel semanticModel,
-        Diagnostic diagnostic, CancellationToken cancellationToken)
-    {
-        var declarationLocation = diagnostic.AdditionalLocations[0];
-        var originalDeclaration = (LambdaExpressionSyntax)declarationLocation.FindNode(getInnermostNodeForTie: true, cancellationToken);
-
         editor.ReplaceNode(
-            originalDeclaration,
-            (current, _) => UseExpressionBodyForLambdaCodeActionHelpers.Update(semanticModel, originalDeclaration, (LambdaExpressionSyntax)current, cancellationToken));
+            lambdaExpression,
+            UseExpressionBodyForLambdaCodeActionHelpers.Update(
+                semanticModel, lambdaExpression, cancellationToken));
     }
 }

src/Analyzers/CSharp/Tests/UseExpressionBodyForLambda/UseExpressionBodyForLambdasAnalyzerTests.cs

@@ -10,19 +10,16 @@
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
 using Xunit;
 using Xunit.Abstractions;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.UseExpressionBody;
 
 [Trait(Traits.Feature, Traits.Features.CodeActionsUseExpressionBody)]
-public class UseExpressionBodyForLambdasAnalyzerTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor
+public sealed class UseExpressionBodyForLambdasAnalyzerTests(ITestOutputHelper logger)
+    : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor(logger)
 {
-    public UseExpressionBodyForLambdasAnalyzerTests(ITestOutputHelper logger)
-        : base(logger)
-    {
-    }
-
     internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
         => (new UseExpressionBodyForLambdaDiagnosticAnalyzer(), new UseExpressionBodyForLambdaCodeFixProvider());
 
@@ -1469,4 +1466,27 @@ void Goo()
             }
             """, options: UseBlockBody);
     }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/76645")]
+    public async Task TestMethodOverloadResolutionChange()
+    {
+        await TestMissingInRegularAndScriptAsync(
+            """
+            using System;
+
+            class C
+            {
+                void Goo(int result, Func<int> function)
+                {
+                    Execute(() [|=>|]
+                    {
+                        result = function();
+                    });
+                }
+
+                void Execute(Action action) { }
+                void Execute(Func<int> function) { }
+            }
+            """, new(options: UseExpressionBody));
+    }
 }

src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeRefactoringProvider.cs

@@ -169,7 +169,8 @@ private static async Task<ImmutableArray<CodeAction>> ComputeRefactoringsAsync(
         var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
         using var result = TemporaryArray<CodeAction>.Empty;
-        if (UseExpressionBodyForLambdaHelpers.CanOfferUseExpressionBody(option, lambdaNode, root.GetLanguageVersion(), cancellationToken))
+        var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+        if (UseExpressionBodyForLambdaHelpers.CanOfferUseExpressionBody(semanticModel, option, lambdaNode, root.GetLanguageVersion(), cancellationToken))
         {
             var title = UseExpressionBodyForLambdaHelpers.UseExpressionBodyTitle.ToString();
             result.Add(CodeAction.Create(
@@ -178,7 +179,6 @@ private static async Task<ImmutableArray<CodeAction>> ComputeRefactoringsAsync(
                 title));
         }
 
-        var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
         if (UseExpressionBodyForLambdaHelpers.CanOfferUseBlockBody(semanticModel, option, lambdaNode, cancellationToken))
         {
             var title = UseExpressionBodyForLambdaHelpers.UseBlockBodyTitle.ToString();
@@ -196,9 +196,8 @@ private static async Task<Document> UpdateDocumentAsync(
     {
         var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
-        // We're only replacing a single declaration in the refactoring.  So pass 'declaration'
-        // as both the 'original' and 'current' declaration.
-        var updatedDeclaration = UseExpressionBodyForLambdaCodeActionHelpers.Update(semanticModel, declaration, declaration, cancellationToken);
+        var updatedDeclaration = UseExpressionBodyForLambdaCodeActionHelpers.Update(
+            semanticModel, declaration, cancellationToken);
 
         var newRoot = root.ReplaceNode(declaration, updatedDeclaration);
         return document.WithSyntaxRoot(newRoot);