Merge branch 'main' into useCollectionExpr

CyrusNajmabadi · CyrusNajmabadi · commit c9063d95b24c · 2025-01-06T22:16:52.000-08:00
diff --git a/src/Analyzers/CSharp/Analyzers/MakeStructMemberReadOnly/CSharpMakeStructMemberReadOnlyAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/MakeStructMemberReadOnly/CSharpMakeStructMemberReadOnlyAnalyzer.cs
@@ -140,7 +140,7 @@ private void AnalyzeBlock(
             return;
 
         var (location, additionalLocation) = GetDiagnosticLocation(owningMethod, cancellationToken);
-        if (location == null || !context.ShouldAnalyzeSpan(location.SourceSpan))
+        if (location == null || additionalLocation is null || !context.ShouldAnalyzeSpan(location.SourceSpan))
             return;
 
         foreach (var blockOperation in context.OperationBlocks)
diff --git a/src/Analyzers/CSharp/Analyzers/UseExpressionBodyForLambda/UseExpressionBodyForLambdaDiagnosticAnalyzer.cs b/src/Analyzers/CSharp/Analyzers/UseExpressionBodyForLambda/UseExpressionBodyForLambdaDiagnosticAnalyzer.cs
@@ -71,29 +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 properties = ImmutableDictionary<string, string?>.Empty;
             return DiagnosticHelper.Create(
                 s_useExpressionBodyForLambda,
-                location, option.Notification,
-                analyzerOptions, [declaration.GetLocation()], 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;
diff --git a/src/Analyzers/CSharp/Analyzers/UseExpressionBodyForLambda/UseExpressionBodyForLambdaHelpers.cs b/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;
     }
 }
diff --git a/src/Analyzers/CSharp/CodeFixes/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeActionHelpers.cs b/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));
diff --git a/src/Analyzers/CSharp/CodeFixes/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeFixProvider.cs b/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));
     }
 }
diff --git a/src/Analyzers/CSharp/Tests/UseExpressionBodyForLambda/UseExpressionBodyForLambdasAnalyzerTests.cs b/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));
+    }
 }
diff --git a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.MethodTypeParameterTypeSymbol.vb b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.MethodTypeParameterTypeSymbol.vb
@@ -129,6 +129,64 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.FindReferences
             Await TestAPIAndFeature(input, kind, host)
         End Function
 
+        <WpfTheory, CombinatorialData>
+        <WorkItem("https://github.com/dotnet/roslyn/issues/76650")>
+        Public Async Function TestMethodTypeParameter_TopLevelLocalFunction(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document><![CDATA[
+[|T|] TopLevelLocalFunction<{|Definition:$$T|}>() where [|T|] : new()
+{
+    return new [|T|]();
+}]]></Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData>
+        <WorkItem("https://github.com/dotnet/roslyn/issues/76650")>
+        Public Async Function TestMethodTypeParameter_MethodLevelLocalFunction(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document><![CDATA[
+class C
+{
+    void Goo()
+    {
+        [|T|] LocalFunction<{|Definition:$$T|}>() where [|T|] : new()
+        {
+            return new [|T|]();
+        }
+    }
+}]]></Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData>
+        <WorkItem("https://github.com/dotnet/roslyn/issues/76650")>
+        Public Async Function TestMethodTypeParameter_NormalMethod(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document><![CDATA[
+class C
+{
+    [|T|] TopLevelMethod<{|Definition:$$T|}>() where [|T|] : new()
+    {
+        return new [|T|]();
+    }
+}
+}]]></Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
 #End Region
 
 #Region "FAR on generic partial methods"
diff --git a/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.vb b/src/EditorFeatures/Test2/FindReferences/FindReferencesTests.vb
@@ -11,12 +11,10 @@ Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.FindSymbols
 Imports Microsoft.CodeAnalysis.FindUsages
 Imports Microsoft.CodeAnalysis.Host
-Imports Microsoft.CodeAnalysis.Options
 Imports Microsoft.CodeAnalysis.PooledObjects
 Imports Microsoft.CodeAnalysis.Remote.Testing
 Imports Microsoft.CodeAnalysis.Test.Utilities.FindUsages
 Imports Microsoft.CodeAnalysis.Text
-Imports Microsoft.CodeAnalysis.VisualBasic.Completion.KeywordRecommenders.PreprocessorDirectives
 Imports Roslyn.Utilities
 Imports Xunit.Abstractions
 
diff --git a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeRefactoringProvider.cs
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder.cs
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractTypeParameterSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractTypeParameterSymbolReferenceFinder.cs
diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/MethodTypeParameterSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/MethodTypeParameterSymbolReferenceFinder.cs

Original file line number	Diff line number	Diff line change
`@@ -19,22 +19,23 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeFixes.UseExpressionBodyForLambda;`
`19`	`19`
`20`	`20`	`internal static class UseExpressionBodyForLambdaCodeActionHelpers`
`21`	`21`	`{`
`22`		`- internal static LambdaExpressionSyntax Update(SemanticModel semanticModel, LambdaExpressionSyntax originalDeclaration, LambdaExpressionSyntax currentDeclaration, CancellationToken cancellationToken)`
`23`		`- => UpdateWorker(semanticModel, originalDeclaration, currentDeclaration, cancellationToken).WithAdditionalAnnotations(Formatter.Annotation);`
	`22`	`+ internal static LambdaExpressionSyntax Update(SemanticModel semanticModel, LambdaExpressionSyntax lambdaExpression, CancellationToken cancellationToken)`
	`23`	`+ => UpdateWorker(semanticModel, lambdaExpression, cancellationToken).WithAdditionalAnnotations(Formatter.Annotation);`
`24`	`24`
`25`	`25`	`private static LambdaExpressionSyntax UpdateWorker(`
`26`		`- SemanticModel semanticModel, LambdaExpressionSyntax originalDeclaration, LambdaExpressionSyntax currentDeclaration, CancellationToken cancellationToken)`
	`26`	`+ SemanticModel semanticModel, LambdaExpressionSyntax lambdaExpression, CancellationToken cancellationToken)`
`27`	`27`	`{`
`28`		`- var expressionBody = UseExpressionBodyForLambdaHelpers.GetBodyAsExpression(currentDeclaration);`
	`28`	`+ var expressionBody = UseExpressionBodyForLambdaHelpers.GetBodyAsExpression(lambdaExpression);`
`29`	`29`	`return expressionBody == null`
`30`		`- ? WithExpressionBody(currentDeclaration, originalDeclaration.GetLanguageVersion(), cancellationToken)`
`31`		`- : WithBlockBody(semanticModel, originalDeclaration, currentDeclaration, expressionBody);`
	`30`	`+ ? WithExpressionBody(semanticModel, lambdaExpression, cancellationToken)`
	`31`	`+ : WithBlockBody(semanticModel, lambdaExpression, expressionBody);`
`32`	`32`	`}`
`33`	`33`
`34`		`- private static LambdaExpressionSyntax WithExpressionBody(LambdaExpressionSyntax declaration, LanguageVersion languageVersion, CancellationToken cancellationToken)`
	`34`	`+ private static LambdaExpressionSyntax WithExpressionBody(`
	`35`	`+ SemanticModel semanticModel, LambdaExpressionSyntax declaration, CancellationToken cancellationToken)`
`35`	`36`	`{`
`36`	`37`	`if (!UseExpressionBodyForLambdaHelpers.TryConvertToExpressionBody(`
`37`		`- declaration, languageVersion, ExpressionBodyPreference.WhenPossible, cancellationToken, out var expressionBody))`
	`38`	`+ semanticModel, declaration, declaration.GetLanguageVersion(), ExpressionBodyPreference.WhenPossible, cancellationToken, out var expressionBody))`
`38`	`39`	`{`
`39`	`40`	`return declaration;`
`40`	`41`	`}`
`@@ -53,23 +54,23 @@ private static LambdaExpressionSyntax WithExpressionBody(LambdaExpressionSyntax`
`53`	`54`	`}`
`54`	`55`
`55`	`56`	`private static LambdaExpressionSyntax WithBlockBody(`
`56`		`- SemanticModel semanticModel, LambdaExpressionSyntax originalDeclaration, LambdaExpressionSyntax currentDeclaration, ExpressionSyntax expressionBody)`
	`57`	`+ SemanticModel semanticModel, LambdaExpressionSyntax lambdaExpression, ExpressionSyntax expressionBody)`
`57`	`58`	`{`
`58`	`59`	`var createReturnStatementForExpression = CreateReturnStatementForExpression(`
`59`		`- semanticModel, originalDeclaration);`
	`60`	`+ semanticModel, lambdaExpression);`
`60`	`61`
`61`	`62`	`if (!expressionBody.TryConvertToStatement(`
`62`	`63`	`semicolonTokenOpt: null,`
`63`	`64`	`createReturnStatementForExpression,`
`64`	`65`	`out var statement))`
`65`	`66`	`{`
`66`		`- return currentDeclaration;`
	`67`	`+ return lambdaExpression;`
`67`	`68`	`}`
`68`	`69`
`69`	`70`	`// If the user is converting to a block, it's likely they intend to add multiple`
`70`	`71`	`// statements to it. So make a multi-line block so that things are formatted properly`
`71`	`72`	`// for them to do so.`
`72`		`- return currentDeclaration.WithBody(Block(`
	`73`	`+ return lambdaExpression.WithBody(Block(`
`73`	`74`	`OpenBraceToken.WithAppendedTrailingTrivia(ElasticCarriageReturnLineFeed),`
`74`	`75`	`[statement],`
`75`	`76`	`CloseBraceToken));`