Enable extract refactorings in LSP

src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs

@@ -25,6 +25,8 @@ namespace Microsoft.CodeAnalysis.CodeRefactorings.ExtractMethod;
 [method: SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
 internal sealed class ExtractMethodCodeRefactoringProvider() : CodeRefactoringProvider
 {
+    internal override CodeRefactoringKind Kind => CodeRefactoringKind.Extract;
+
     public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
     {
         // Don't bother if there isn't a selection

src/Features/Core/Portable/ExtractClass/AbstractExtractClassRefactoringProvider.cs

@@ -22,6 +22,8 @@ internal abstract class AbstractExtractClassRefactoringProvider(IExtractClassOpt
     protected abstract Task<ImmutableArray<SyntaxNode>> GetSelectedNodesAsync(CodeRefactoringContext context);
     protected abstract Task<SyntaxNode?> GetSelectedClassDeclarationAsync(CodeRefactoringContext context);
 
+    internal override CodeRefactoringKind Kind => CodeRefactoringKind.Extract;
+
     public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
     {
         var solution = context.Document.Project.Solution;

src/Features/Core/Portable/ExtractInterface/ExtractInterfaceCodeRefactoringProvider.cs

@@ -23,6 +23,8 @@ public ExtractInterfaceCodeRefactoringProvider()
     {
     }
 
+    internal override CodeRefactoringKind Kind => CodeRefactoringKind.Extract;
+
     public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
     {
         var (document, textSpan, cancellationToken) = context;

src/Features/Core/Portable/InlineMethod/AbstractInlineMethodRefactoringProvider.cs

@@ -79,6 +79,8 @@ protected AbstractInlineMethodRefactoringProvider(
         _semanticFactsService = semanticFactsService;
     }
 
+    internal override CodeRefactoringKind Kind => CodeRefactoringKind.Inline;
+
     public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
     {
         var (document, _, cancellationToken) = context;

src/Features/Core/Portable/InlineTemporary/AbstractInlineTemporaryCodeRefactoringProvider.cs

@@ -19,6 +19,8 @@ internal abstract class AbstractInlineTemporaryCodeRefactoringProvider<
     where TIdentifierNameSyntax : SyntaxNode
     where TVariableDeclaratorSyntax : SyntaxNode
 {
+    internal override CodeRefactoringKind Kind => CodeRefactoringKind.Inline;
+
     protected static async Task<ImmutableArray<TIdentifierNameSyntax>> GetReferenceLocationsAsync(
         Document document,
         TVariableDeclaratorSyntax variableDeclarator,

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj

@@ -17,20 +17,41 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\Compilers\Test\Core\Microsoft.CodeAnalysis.Test.Utilities.csproj" />
-    <ProjectReference Include="..\Microsoft.CodeAnalysis.LanguageServer\Microsoft.CodeAnalysis.LanguageServer.csproj"/>
+    <ProjectReference Include="..\Microsoft.CodeAnalysis.LanguageServer\Microsoft.CodeAnalysis.LanguageServer.csproj" />
+    <ProjectReference Include="..\Protocol\Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj" />
 
-    <ProjectReference Include="..\..\VisualStudio\DevKit\Impl\Microsoft.VisualStudio.LanguageServices.DevKit.csproj"
-                      ReferenceOutputAssembly="false"
-                      Private="false" />
+    <ProjectReference Include="..\..\VisualStudio\DevKit\Impl\Microsoft.VisualStudio.LanguageServices.DevKit.csproj" ReferenceOutputAssembly="false" Private="false" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.XUnit" />
+  </ItemGroup>
+
+  <!--
+    Copy files contained in the project to a RoslynLSP subdirectory to emulate deployment of the language server.
+  -->
+  <Target Name="_CopyLanguageServerFiles" AfterTargets="ResolveProjectReferences">
+    <MSBuild Projects="..\Microsoft.CodeAnalysis.LanguageServer\Microsoft.CodeAnalysis.LanguageServer.csproj" Targets="GetTargetPath">
+      <Output TaskParameter="TargetOutputs" ItemName="_LanguageServerFilePath" />
+    </MSBuild>
+
+    <PropertyGroup>
+      <_LanguageServerOutputPath>$([System.IO.Path]::GetDirectoryName(%(_LanguageServerFilePath.Identity)))</_LanguageServerOutputPath>
+    </PropertyGroup>
+
+    <ItemGroup Condition="'$(_LanguageServerOutputPath)' != ''">
+      <_LanguageServerFile Include="$(_LanguageServerOutputPath)\**\*.*" />
+      <_LanguageServerFile Remove="$(_LanguageServerOutputPath)\**\*.mef-composition" />
+      <Content Include="@(_LanguageServerFile)" Link="RoslynLSP\%(RecursiveDir)\%(_LanguageServerFile.Filename)%(_LanguageServerFile.Extension)" CopyToOutputDirectory="PreserveNewest" />
+    </ItemGroup>
+  </Target>
+
   <!--
     Copy files contained in the NPM package to a DevKit subdirectory to emulate deployment of the DevKit extension in VS Code.
   -->
   <Target Name="_CopyDevKitExtensionFiles" AfterTargets="ResolveProjectReferences">
-    <MSBuild Projects="..\..\VisualStudio\DevKit\Impl\Microsoft.VisualStudio.LanguageServices.DevKit.csproj"
-             Targets="GetPackInputs">
-      <Output TaskParameter="TargetOutputs" ItemName="_DevKitExtensionFile"/>
+    <MSBuild Projects="..\..\VisualStudio\DevKit\Impl\Microsoft.VisualStudio.LanguageServices.DevKit.csproj" Targets="GetPackInputs">
+      <Output TaskParameter="TargetOutputs" ItemName="_DevKitExtensionFile" />
     </MSBuild>
 
     <ItemGroup>

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Services/ExtractRefactoringTests.cs

@@ -0,0 +1,100 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.CodeAnalysis;
+using Roslyn.Test.Utilities;
+using Xunit.Abstractions;
+using LSP = Roslyn.LanguageServer.Protocol;
+
+namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests.Services;
+
+public class ExtractRefactoringTests(ITestOutputHelper testOutputHelper) : AbstractLanguageServerClientTests(testOutputHelper)
+{
+    [Theory]
+    [CombinatorialData]
+    public async Task TestExtractBaseClass(bool includeDevKitComponents)
+    {
+        var markup =
+            """
+            class {|caret:A|}
+            {
+                public void M()
+                {
+                }
+            }
+            """;
+        var expected =
+            """
+            internal class NewBaseType
+            {
+                public void M()
+                {
+                }
+            }
+
+            class A : NewBaseType
+            {
+            }
+            """;
+
+        await using var testLspServer = await CreateCSharpLanguageServerAsync(markup, includeDevKitComponents);
+        var caretLocation = testLspServer.GetLocations("caret").Single();
+
+        await TestCodeActionAsync(testLspServer, caretLocation, "Extract base class...", expected);
+    }
+
+    [Theory]
+    [CombinatorialData]
+    public async Task TestExtractInterface(bool includeDevKitComponents)
+    {
+        var markup =
+            """
+            class {|caret:A|}
+            {
+                public void M()
+                {
+                }
+            }
+            """;
+        var expected =
+            """
+            interface IA
+            {
+                void M();
+            }
+
+            class A : IA
+            {
+                public void M()
+                {
+                }
+            }
+            """;
+
+        await using var testLspServer = await CreateCSharpLanguageServerAsync(markup, includeDevKitComponents);
+        var caretLocation = testLspServer.GetLocations("caret").Single();
+
+        await TestCodeActionAsync(testLspServer, caretLocation, "Extract interface...", expected);
+    }
+
+    private static async Task TestCodeActionAsync(
+        TestLspClient testLspClient,
+        LSP.Location caretLocation,
+        string codeActionTitle,
+        [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string expected)
+    {
+        var codeActionResults = await testLspClient.RunGetCodeActionsAsync(CreateCodeActionParams(caretLocation));
+
+        var unresolvedCodeAction = Assert.Single(codeActionResults, codeAction => codeAction.Title == codeActionTitle);
+
+        var resolvedCodeAction = await testLspClient.RunGetCodeActionResolveAsync(unresolvedCodeAction);
+
+        testLspClient.ApplyWorkspaceEdit(resolvedCodeAction.Edit);
+
+        var updatedCode = testLspClient.GetDocumentText(caretLocation.Uri);
+
+        AssertEx.Equal(expected, updatedCode);
+    }
+}