Additional extract method cleanup.

src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.Analyzer.cs

@@ -24,12 +24,6 @@ protected override bool TreatOutAsRef
             protected override bool IsInPrimaryConstructorBaseType()
                 => this.SelectionResult.GetContainingScopeOf<PrimaryConstructorBaseTypeSyntax>() != null;
 
-            protected override VariableInfo CreateFromSymbol(
-                ISymbol symbol, ITypeSymbol type, VariableStyle style, bool variableDeclared)
-            {
-                return CreateFromSymbolCommon(symbol, type, style);
-            }
-
             protected override ITypeSymbol? GetRangeVariableType(IRangeVariableSymbol symbol)
             {
                 var info = this.SemanticModel.GetSpeculativeTypeInfo(SelectionResult.FinalSpan.Start, SyntaxFactory.ParseName(symbol.Name), SpeculativeBindingOption.BindAsExpression);

src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.CSharpCodeGenerator.cs

@@ -37,7 +37,7 @@ internal sealed partial class CSharpExtractMethodService
 {
     internal sealed partial class CSharpMethodExtractor
     {
-        private abstract partial class CSharpCodeGenerator : CodeGenerator<StatementSyntax, SyntaxNode, CSharpCodeGenerationOptions>
+        private abstract partial class CSharpCodeGenerator : CodeGenerator<SyntaxNode, CSharpCodeGenerationOptions>
         {
             private readonly SyntaxToken _methodName;
 
@@ -159,7 +159,7 @@ private static bool IsExpressionBodiedMember(SyntaxNode node)
                 => node is MemberDeclarationSyntax member && member.GetExpressionBody() != null;
 
             private static bool IsExpressionBodiedAccessor(SyntaxNode node)
-                => node is AccessorDeclarationSyntax accessor && accessor.ExpressionBody != null;
+                => node is AccessorDeclarationSyntax { ExpressionBody: not null };
 
             private SimpleNameSyntax CreateMethodNameForInvocation()
             {
@@ -662,8 +662,7 @@ protected override StatementSyntax CreateDeclarationStatement(
 
                 if (variableInfos is [var singleVariable])
                 {
-                    var type = singleVariable.GetVariableType();
-                    var typeNode = type.GenerateTypeSyntax();
+                    var typeNode = singleVariable.SymbolType.GenerateTypeSyntax();
 
                     var originalIdentifierToken = singleVariable.GetOriginalIdentifierToken(cancellationToken);
 
@@ -704,15 +703,15 @@ protected override StatementSyntax CreateDeclarationStatement(
                     {
                         left = TupleExpression(
                             [.. variableInfos.Select(v => Argument(v.ReturnBehavior == ReturnBehavior.Initialization
-                            ? DeclarationExpression(v.GetVariableType().GenerateTypeSyntax(), SingleVariableDesignation(v.Name.ToIdentifierToken()))
+                            ? DeclarationExpression(v.SymbolType.GenerateTypeSyntax(), SingleVariableDesignation(v.Name.ToIdentifierToken()))
                             : v.Name.ToIdentifierName()))]);
                     }
 
                     return ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, left, initialValue));
                 }
             }
 
-            protected override async Task<GeneratedCode> CreateGeneratedCodeAsync(
+            protected override async Task<SemanticDocument> PerformFinalTriviaFixupAsync(
                 SemanticDocument newDocument, CancellationToken cancellationToken)
             {
                 // in hybrid code cases such as extract method, formatter will have some difficulties on where it breaks lines in two.
@@ -731,7 +730,7 @@ protected override async Task<GeneratedCode> CreateGeneratedCodeAsync(
                 newDocument = await newDocument.WithSyntaxRootAsync(
                     root.ReplaceNode(methodDefinition, newMethodDefinition), cancellationToken).ConfigureAwait(false);
 
-                return await base.CreateGeneratedCodeAsync(newDocument, cancellationToken).ConfigureAwait(false);
+                return newDocument;
             }
 
             private static MethodDeclarationSyntax TweakNewLinesInMethod(MethodDeclarationSyntax method)

src/Features/CSharp/Portable/ExtractMethod/CSharpMethodExtractor.cs

@@ -23,8 +23,8 @@ internal sealed partial class CSharpMethodExtractor(
         SelectionResult result, ExtractMethodGenerationOptions options, bool localFunction)
         : MethodExtractor(result, options, localFunction)
     {
-        protected override CodeGenerator CreateCodeGenerator(AnalyzerResult analyzerResult)
-            => CSharpCodeGenerator.Create(this.OriginalSelectionResult, analyzerResult, this.Options, this.LocalFunction);
+        protected override CodeGenerator CreateCodeGenerator(SelectionResult selectionResult, AnalyzerResult analyzerResult)
+            => CSharpCodeGenerator.Create(selectionResult, analyzerResult, this.Options, this.LocalFunction);
 
         protected override AnalyzerResult Analyze(CancellationToken cancellationToken)
         {
@@ -170,12 +170,6 @@ await semanticDocument.WithSyntaxRootAsync(result.Root, cancellationToken).Confi
                 result);
         }
 
-        protected override Task<GeneratedCode> GenerateCodeAsync(InsertionPoint insertionPoint, SelectionResult selectionResult, AnalyzerResult analyzeResult, ExtractMethodGenerationOptions options, CancellationToken cancellationToken)
-        {
-            var codeGenerator = CSharpCodeGenerator.Create(selectionResult, analyzeResult, options, this.LocalFunction);
-            return codeGenerator.GenerateAsync(insertionPoint, cancellationToken);
-        }
-
         protected override AbstractFormattingRule GetCustomFormattingRule(Document document)
             => FormattingRule.Instance;
 

src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.ExpressionResult.cs

@@ -45,7 +45,7 @@ public override SyntaxNode GetContainingScope()
                 return CSharpSyntaxFacts.Instance.GetRootStandaloneExpression(scope);
             }
 
-            public override (ITypeSymbol? returnType, bool returnsByRef) GetReturnTypeInfo(CancellationToken cancellationToken)
+            protected override (ITypeSymbol? returnType, bool returnsByRef) GetReturnTypeInfoWorker(CancellationToken cancellationToken)
             {
                 if (GetContainingScope() is not ExpressionSyntax node)
                 {
@@ -130,19 +130,31 @@ private static (ITypeSymbol? typeSymbol, bool returnsByRef) GetRegularExpression
                     return !info.Type.IsObjectType() ? info.GetTypeWithAnnotatedNullability() : info.GetConvertedTypeWithAnnotatedNullability();
                 }
             }
-        }
 
-        private static bool IsCoClassImplicitConversion(TypeInfo info, Conversion conversion, INamedTypeSymbol? coclassSymbol)
-        {
-            if (!conversion.IsImplicit ||
-                 info.ConvertedType == null ||
-                 info.ConvertedType.TypeKind != TypeKind.Interface)
+            private static bool IsCoClassImplicitConversion(TypeInfo info, Conversion conversion, INamedTypeSymbol? coclassSymbol)
             {
-                return false;
+                if (!conversion.IsImplicit ||
+                     info.ConvertedType == null ||
+                     info.ConvertedType.TypeKind != TypeKind.Interface)
+                {
+                    return false;
+                }
+
+                // let's see whether this interface has coclass attribute
+                return info.ConvertedType.HasAttribute(coclassSymbol);
             }
 
-            // let's see whether this interface has coclass attribute
-            return info.ConvertedType.HasAttribute(coclassSymbol);
+            public override SyntaxNode GetOutermostCallSiteContainerToProcess(CancellationToken cancellationToken)
+            {
+                var container = this.GetInnermostStatementContainer();
+
+                Contract.ThrowIfNull(container);
+                Contract.ThrowIfFalse(
+                    container.IsStatementContainerNode() ||
+                    container is BaseListSyntax or TypeDeclarationSyntax or ConstructorDeclarationSyntax or CompilationUnitSyntax);
+
+                return container;
+            }
         }
     }
 }

src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.StatementResult.cs

@@ -32,33 +32,27 @@ public override bool ContainingScopeHasAsyncKeyword()
 
                 return node switch
                 {
-                    AccessorDeclarationSyntax _ => false,
                     MethodDeclarationSyntax method => method.Modifiers.Any(SyntaxKind.AsyncKeyword),
-                    ParenthesizedLambdaExpressionSyntax lambda => lambda.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword,
-                    SimpleLambdaExpressionSyntax lambda => lambda.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword,
-                    AnonymousMethodExpressionSyntax anonymous => anonymous.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword,
+                    LocalFunctionStatementSyntax localFunction => localFunction.Modifiers.Any(SyntaxKind.AsyncKeyword),
+                    AnonymousFunctionExpressionSyntax anonymousFunction => anonymousFunction.AsyncKeyword != default,
                     _ => false,
                 };
             }
 
             public override SyntaxNode GetContainingScope()
             {
-                Contract.ThrowIfNull(SemanticDocument);
                 Contract.ThrowIfTrue(IsExtractMethodOnExpression);
 
                 return GetFirstTokenInSelection().GetRequiredParent().AncestorsAndSelf().First(n =>
                     n is AccessorDeclarationSyntax or
                          LocalFunctionStatementSyntax or
                          BaseMethodDeclarationSyntax or
-                         AccessorDeclarationSyntax or
                          AnonymousFunctionExpressionSyntax or
                          CompilationUnitSyntax);
             }
 
-            public override (ITypeSymbol? returnType, bool returnsByRef) GetReturnTypeInfo(CancellationToken cancellationToken)
+            protected override (ITypeSymbol? returnType, bool returnsByRef) GetReturnTypeInfoWorker(CancellationToken cancellationToken)
             {
-                Contract.ThrowIfTrue(IsExtractMethodOnExpression);
-
                 var node = GetContainingScope();
                 var semanticModel = SemanticDocument.SemanticModel;
 
@@ -72,7 +66,13 @@ public override (ITypeSymbol? returnType, bool returnsByRef) GetReturnTypeInfo(C
                             _ => throw ExceptionUtilities.UnexpectedValue(node),
                         };
 
-                    case MethodDeclarationSyntax methodDeclaration:
+                    case LocalFunctionStatementSyntax localFunction:
+                        {
+                            var method = semanticModel.GetRequiredDeclaredSymbol(localFunction, cancellationToken);
+                            return (method.ReturnType, method.ReturnsByRef);
+                        }
+
+                    case BaseMethodDeclarationSyntax methodDeclaration:
                         {
                             var method = semanticModel.GetRequiredDeclaredSymbol(methodDeclaration, cancellationToken);
                             return (method.ReturnType, method.ReturnsByRef);
@@ -89,6 +89,24 @@ public override (ITypeSymbol? returnType, bool returnsByRef) GetReturnTypeInfo(C
                         return default;
                 }
             }
+
+            public override SyntaxNode GetOutermostCallSiteContainerToProcess(CancellationToken cancellationToken)
+            {
+                if (this.IsExtractMethodOnSingleStatement)
+                {
+                    var firstStatement = this.GetFirstStatement();
+                    return firstStatement.GetRequiredParent();
+                }
+
+                if (this.IsExtractMethodOnMultipleStatements)
+                {
+                    var firstStatement = this.GetFirstStatementUnderContainer();
+                    var container = firstStatement.GetRequiredParent();
+                    return container is GlobalStatementSyntax ? container.GetRequiredParent() : container;
+                }
+
+                throw ExceptionUtilities.Unreachable();
+            }
         }
     }
 }

src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.cs

@@ -52,9 +52,6 @@ public static async Task<CSharpSelectionResult> CreateAsync(
                 : new StatementResult(newDocument, selectionType, finalSpan);
         }
 
-        protected override ISyntaxFacts SyntaxFacts
-            => CSharpSyntaxFacts.Instance;
-
         protected override OperationStatus ValidateLanguageSpecificRules(CancellationToken cancellationToken)
         {
             // Nothing language specific for C#.
@@ -92,39 +89,6 @@ public static bool IsUnderAnonymousOrLocalMethod(SyntaxToken token, SyntaxToken
             return false;
         }
 
-        public override SyntaxNode GetOutermostCallSiteContainerToProcess(CancellationToken cancellationToken)
-        {
-            if (this.IsExtractMethodOnExpression)
-            {
-                var container = this.GetInnermostStatementContainer();
-
-                Contract.ThrowIfNull(container);
-                Contract.ThrowIfFalse(
-                    container.IsStatementContainerNode() ||
-                    container is BaseListSyntax or TypeDeclarationSyntax or ConstructorDeclarationSyntax or CompilationUnitSyntax);
-
-                return container;
-            }
-
-            if (this.IsExtractMethodOnSingleStatement)
-            {
-                var firstStatement = this.GetFirstStatement();
-                return firstStatement.Parent;
-            }
-
-            if (this.IsExtractMethodOnMultipleStatements)
-            {
-                var firstStatement = this.GetFirstStatementUnderContainer();
-                var container = firstStatement.Parent;
-                if (container is GlobalStatementSyntax)
-                    return container.Parent;
-
-                return container;
-            }
-
-            throw ExceptionUtilities.Unreachable();
-        }
-
         public override StatementSyntax GetFirstStatementUnderContainer()
         {
             Contract.ThrowIfTrue(IsExtractMethodOnExpression);
@@ -189,23 +153,11 @@ public SyntaxNode GetInnermostStatementContainer()
             return last.Parent.Parent;
         }
 
-        public override bool ContainsNonReturnExitPointsStatements(ImmutableArray<SyntaxNode> jumpsOutOfRegion)
-            => jumpsOutOfRegion.Any(n => n is not ReturnStatementSyntax);
+        public override bool ContainsNonReturnExitPointsStatements(ImmutableArray<SyntaxNode> exitPoints)
+            => exitPoints.Any(n => n is not ReturnStatementSyntax);
 
-        public override ImmutableArray<StatementSyntax> GetOuterReturnStatements(SyntaxNode commonRoot, ImmutableArray<SyntaxNode> jumpsOutOfRegion)
-        {
-            var container = commonRoot.GetAncestorsOrThis<SyntaxNode>().Where(a => a.IsReturnableConstruct()).FirstOrDefault();
-            if (container == null)
-                return [];
-
-            // now filter return statements to only include the one under outmost container
-            return jumpsOutOfRegion
-                .OfType<ReturnStatementSyntax>()
-                .Select(returnStatement => (returnStatement, container: returnStatement.GetAncestors<SyntaxNode>().Where(a => a.IsReturnableConstruct()).FirstOrDefault()))
-                .Where(p => p.container == container)
-                .SelectAsArray(p => p.returnStatement)
-                .CastArray<StatementSyntax>();
-        }
+        public override ImmutableArray<StatementSyntax> GetOuterReturnStatements(SyntaxNode commonRoot, ImmutableArray<SyntaxNode> exitPoints)
+            => exitPoints.OfType<ReturnStatementSyntax>().ToImmutableArray().CastArray<StatementSyntax>();
 
         public override bool IsFinalSpanSemanticallyValidSpan(
             ImmutableArray<StatementSyntax> returnStatements, CancellationToken cancellationToken)
@@ -226,22 +178,7 @@ public override bool IsFinalSpanSemanticallyValidSpan(
             if (body.CloseBraceToken != GetLastTokenInSelection().GetNextToken(includeZeroWidth: true))
                 return false;
 
-            // alright, for these constructs, it must be okay to be extracted
-            switch (container.Kind())
-            {
-                case SyntaxKind.AnonymousMethodExpression:
-                case SyntaxKind.SimpleLambdaExpression:
-                case SyntaxKind.ParenthesizedLambdaExpression:
-                    return true;
-            }
-
-            // now, only method is okay to be extracted out
-            if (body.Parent is not MethodDeclarationSyntax method)
-                return false;
-
-            // make sure this method doesn't have return type.
-            return method.ReturnType is PredefinedTypeSyntax p &&
-                p.Keyword.Kind() == SyntaxKind.VoidKeyword;
+            return true;
         }
     }
 }