Add feature flag to allow VS to use the LSP based editor

azure-pipelines-integration-lsp.yml

@@ -0,0 +1,29 @@
+# Branches that trigger a build on commit
+trigger:
+- master
+- master-vs-deps
+- release/*
+- features/*
+- demos/*
+
+# Branches that trigger builds on PR
+pr:
+- master
+- master-vs-deps
+- release/*
+- features/*
+- demos/*
+
+jobs:
+- job: VS_Integration_LSP
+  pool:
+    name: NetCorePublic-Pool
+    queue: $(queueName)
+  timeoutInMinutes: 135
+
+  steps:
+    - template: eng/pipelines/test-integration-job.yml
+      parameters:
+        configuration: Debug
+        oop64bit: true
+        lspEditor: true

azure-pipelines-integration.yml

@@ -37,37 +37,8 @@ jobs:
   timeoutInMinutes: 135
 
   steps:
-    - template: eng/pipelines/checkout-windows-task.yml
-
-    - task: PowerShell@2
-      displayName: Build and Test
-      inputs:
-        filePath: eng/build.ps1
-        arguments: -ci -restore -build -pack -sign -publish -binaryLog -configuration $(_configuration) -prepareMachine -testVsi -oop64bit:$$(_oop64bit) -collectDumps
-
-    - task: PublishTestResults@2
-      displayName: Publish xUnit Test Results
-      inputs:
-        testRunner: XUnit
-        testResultsFiles: $(Build.SourcesDirectory)\artifacts\TestResults\$(_configuration)\*.xml
-        mergeTestResults: true
-        testRunTitle: '$(System.JobAttempt)-Integration $(_configuration) OOP64_$(_oop64bit)'
-      condition: always()
-
-    - task: PublishBuildArtifacts@1
-      displayName: Publish Logs
-      inputs:
-        PathtoPublish: '$(Build.SourcesDirectory)\artifacts\log\$(_configuration)'
-        ArtifactName: '$(System.JobAttempt)-Logs $(_configuration) OOP64_$(_oop64bit) $(Build.BuildNumber)'
-        publishLocation: Container
-      continueOnError: true
-      condition: not(succeeded())
-
-    - task: PublishBuildArtifacts@1
-      displayName: Publish Screenshots
-      inputs:
-        PathtoPublish: '$(Build.SourcesDirectory)\artifacts\bin\Microsoft.VisualStudio.LanguageServices.IntegrationTests\$(_configuration)\net472\xUnitResults'
-        ArtifactName: '$(System.JobAttempt)-Screenshots $(_configuration) OOP64_$(_oop64bit) $(Build.BuildNumber)'
-        publishLocation: Container
-      continueOnError: true
-      condition: not(succeeded())
+    - template: eng/pipelines/test-integration-job.yml
+      parameters:
+        configuration: $(_configuration)
+        oop64bit: $(_oop64bit)
+        lspEditor: false

eng/build.ps1

@@ -45,6 +45,7 @@ param (
   [switch]$warnAsError = $false,
   [switch]$sourceBuild = $false,
   [switch]$oop64bit = $true,
+  [switch]$lspEditor = $false,
 
   # official build settings
   [string]$officialBuildId = "",
@@ -385,6 +386,13 @@ function TestUsingRunTests() {
     $args += " --sequential"
     $args += " --include '\.IntegrationTests'"
     $args += " --include 'Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests'"
+
+    if ($lspEditor) {
+      $args += " --testfilter FullyQualifiedName~Roslyn.VisualStudio.IntegrationTests.LanguageServerProtocol|Editor=LanguageServerProtocol"
+    }
+    else {
+      $args += " --testfilter FullyQualifiedName!~Roslyn.VisualStudio.IntegrationTests.LanguageServerProtocol"
+    }
   }
 
   if (-not $ci -and -not $testVsi) {
@@ -437,6 +445,24 @@ function TestUsingRunTests() {
       } else {
         Write-Host "No ServiceHub logs found to copy"
       }
+
+      if ($lspEditor) {
+        $lspLogs = Join-Path $TempDir "VisualStudio\LSP"
+        $telemetryLog = Join-Path $TempDir "VSTelemetryLog"
+        if (Test-Path $lspLogs) {
+          Write-Host "Copying LSP logs to $LogDir"
+          Copy-Item -Path $lspLogs -Destination (Join-Path $LogDir "LSP") -Recurse
+        } else {
+          Write-Host "No LSP logs found to copy"
+        }
+
+        if (Test-Path $telemetryLog) {
+          Write-Host "Copying telemetry logs to $LogDir"
+          Copy-Item -Path $telemetryLog -Destination (Join-Path $LogDir "Telemetry") -Recurse
+        } else {
+          Write-Host "No telemetry logs found to copy"
+        }
+      }
     }
   }
 }
@@ -575,6 +601,7 @@ function Setup-IntegrationTestRun() {
   }
 
   $env:ROSLYN_OOP64BIT = "$oop64bit"
+  $env:ROSLYN_LSPEDITOR = "$lspEditor"
 }
 
 function Prepare-TempDir() {

eng/pipelines/test-integration-job.yml

@@ -0,0 +1,48 @@
+parameters:
+  - name: configuration
+    type: string
+    default: 'Debug'
+  - name: oop64bit
+    # Why string?  Parameters are evaluated at compile time, but all variables are strings at compile time.
+    # So in order to pass a variable in as a parameter here, it must be string.
+    type: string
+    default: true
+  - name: lspEditor
+    type: string
+    default: false
+
+steps:
+  - template: checkout-windows-task.yml
+
+  - task: PowerShell@2
+    displayName: Build and Test
+    inputs:
+      filePath: eng/build.ps1
+      arguments: -ci -restore -build -pack -sign -publish -binaryLog -configuration ${{ parameters.configuration }} -prepareMachine -testVsi -oop64bit:$${{ parameters.oop64bit }} -collectDumps -lspEditor:$${{ parameters.lspEditor }}
+
+  - task: PublishTestResults@2
+    displayName: Publish xUnit Test Results
+    inputs:
+      testRunner: XUnit
+      testResultsFiles: $(Build.SourcesDirectory)\artifacts\TestResults\${{ parameters.configuration }}\*.xml
+      mergeTestResults: true
+      testRunTitle: '$(System.JobAttempt)-Integration ${{ parameters.configuration }} OOP64_${{ parameters.oop64bit }}'
+    condition: always()
+
+  - task: PublishBuildArtifacts@1
+    displayName: Publish Logs
+    inputs:
+      PathtoPublish: '$(Build.SourcesDirectory)\artifacts\log\${{ parameters.configuration }}'
+      ArtifactName: '$(System.JobAttempt)-Logs ${{ parameters.configuration }} OOP64_${{ parameters.oop64bit }} LspEditor_${{ parameters.lspEditor }} $(Build.BuildNumber)'
+      publishLocation: Container
+    continueOnError: true
+    condition: not(succeeded())
+
+  - task: PublishBuildArtifacts@1
+    displayName: Publish Screenshots
+    inputs:
+      PathtoPublish: '$(Build.SourcesDirectory)\artifacts\bin\Microsoft.VisualStudio.LanguageServices.IntegrationTests\${{ parameters.configuration }}\net472\xUnitResults'
+      ArtifactName: '$(System.JobAttempt)-Screenshots ${{ parameters.configuration }} OOP64_${{ parameters.oop64bit }} LspEditor_${{ parameters.lspEditor }} $(Build.BuildNumber)'
+      publishLocation: Container
+    continueOnError: true
+    condition: not(succeeded())

src/Compilers/Test/Core/Traits/Traits.cs

@@ -14,6 +14,7 @@ public static class Editors
             public const string KeyProcessors = nameof(KeyProcessors);
             public const string KeyProcessorProviders = nameof(KeyProcessorProviders);
             public const string Preview = nameof(Preview);
+            public const string LanguageServerProtocol = nameof(LanguageServerProtocol);
         }
 
         public const string Feature = nameof(Feature);

src/EditorFeatures/Core/Implementation/Classification/SemanticClassificationUtilities.cs

@@ -34,6 +34,12 @@ public static async Task ProduceTagsAsync(
             IClassificationService classificationService,
             ClassificationTypeMap typeMap)
         {
+            // Let LSP handle semantic classification when running in the LSP editor.
+            if (spanToTag.SnapshotSpan.Snapshot.TextBuffer.IsInLspEditorContext())
+            {
+                return;
+            }
+
             var document = spanToTag.Document;
             if (document == null)
             {

src/Tools/Source/RunTests/ITestExecutor.cs

@@ -13,18 +13,16 @@ internal readonly struct TestExecutionOptions
         internal string DotnetFilePath { get; }
         internal ProcDumpInfo? ProcDumpInfo { get; }
         internal string TestResultsDirectory { get; }
-        internal string? Trait { get; }
-        internal string? NoTrait { get; }
+        internal string? TestFilter { get; }
         internal bool IncludeHtml { get; }
         internal bool Retry { get; }
 
-        internal TestExecutionOptions(string dotnetFilePath, ProcDumpInfo? procDumpInfo, string testResultsDirectory, string? trait, string? noTrait, bool includeHtml, bool retry)
+        internal TestExecutionOptions(string dotnetFilePath, ProcDumpInfo? procDumpInfo, string testResultsDirectory, string? testFilter, bool includeHtml, bool retry)
         {
             DotnetFilePath = dotnetFilePath;
             ProcDumpInfo = procDumpInfo;
             TestResultsDirectory = testResultsDirectory;
-            Trait = trait;
-            NoTrait = noTrait;
+            TestFilter = testFilter;
             IncludeHtml = includeHtml;
             Retry = retry;
         }

src/Tools/Source/RunTests/Options.cs

@@ -34,14 +34,9 @@ internal class Options
         public Display Display { get; set; }
 
         /// <summary>
-        /// Trait string to pass to xunit.
+        /// Filter string to pass to xunit.
         /// </summary>
-        public string? Trait { get; set; }
-
-        /// <summary>
-        /// The no-trait string to pass to xunit.
-        /// </summary>
-        public string? NoTrait { get; set; }
+        public string? TestFilter { get; set; }
 
         public string Configuration { get; set; }
 
@@ -137,8 +132,7 @@ public Options(
             var helix = false;
             var helixQueueName = "Windows.10.Amd64.Open";
             var retry = false;
-            string? traits = null;
-            string? noTraits = null;
+            string? testFilter = null;
             int? timeout = null;
             string? resultFileDirectory = null;
             string? logFileDirectory = null;
@@ -158,8 +152,7 @@ public Options(
                 { "sequential", "Run tests sequentially", o => sequential = o is object },
                 { "helix", "Run tests on Helix", o => helix = o is object },
                 { "helixQueueName=", "Name of the Helix queue to run tests on", (string s) => helixQueueName = s },
-                { "traits=", "xUnit traits to include (semicolon delimited)", (string s) => traits = s },
-                { "notraits=", "xUnit traits to exclude (semicolon delimited)", (string s) => noTraits = s },
+                { "testfilter=", "xUnit string to pass to --filter, e.g. FullyQualifiedName~TestClass1|Category=CategoryA", (string s) => testFilter = s },
                 { "timeout=", "Minute timeout to limit the tests to", (int i) => timeout = i },
                 { "out=", "Test result file directory (when running on Helix, this is relative to the Helix work item directory)", (string s) => resultFileDirectory = s },
                 { "logs=", "Log file directory (when running on Helix, this is relative to the Helix work item directory)", (string s) => logFileDirectory = s },
@@ -241,8 +234,7 @@ public Options(
                 UseHelix = helix,
                 HelixQueueName = helixQueueName,
                 IncludeHtml = includeHtml,
-                Trait = traits,
-                NoTrait = noTraits,
+                TestFilter = testFilter,
                 Timeout = timeout is { } t ? TimeSpan.FromMinutes(t) : null,
                 Retry = retry,
             };

src/Tools/Source/RunTests/ProcessTestExecutor.cs

@@ -39,7 +39,7 @@ public string GetCommandLineArguments(AssemblyInfo assemblyInfo, bool useSingleQ
             builder.Append($@"test");
             builder.Append($@" {sep}{assemblyInfo.AssemblyName}{sep}");
             var typeInfoList = assemblyInfo.PartitionInfo.TypeInfoList;
-            if (typeInfoList.Length > 0 || !string.IsNullOrWhiteSpace(Options.Trait) || !string.IsNullOrWhiteSpace(Options.NoTrait))
+            if (typeInfoList.Length > 0 || !string.IsNullOrWhiteSpace(Options.TestFilter))
             {
                 builder.Append($@" --filter {sep}");
                 var any = false;
@@ -50,22 +50,10 @@ public string GetCommandLineArguments(AssemblyInfo assemblyInfo, bool useSingleQ
                 }
                 builder.Append(sep);
 
-                if (Options.Trait is object)
+                if (Options.TestFilter is object)
                 {
-                    foreach (var trait in Options.Trait.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
-                    {
-                        MaybeAddSeparator();
-                        builder.Append($"Trait={trait}");
-                    }
-                }
-
-                if (Options.NoTrait is object)
-                {
-                    foreach (var trait in Options.NoTrait.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
-                    {
-                        MaybeAddSeparator('&');
-                        builder.Append($"Trait!~{trait}");
-                    }
+                    MaybeAddSeparator();
+                    builder.Append(Options.TestFilter);
                 }
 
                 void MaybeAddSeparator(char separator = '|')

src/Tools/Source/RunTests/Program.cs

@@ -35,7 +35,6 @@ internal static async Task<int> Main(string[] args)
         {
             Logger.Log("RunTest command line");
             Logger.Log(string.Join(" ", args));
-
             var options = Options.Parse(args);
             if (options == null)
             {
@@ -372,8 +371,7 @@ private static ProcessTestExecutor CreateTestExecutor(Options options)
                 dotnetFilePath: options.DotnetFilePath,
                 procDumpInfo: options.CollectDumps ? GetProcDumpInfo(options) : null,
                 testResultsDirectory: options.TestResultsDirectory,
-                trait: options.Trait,
-                noTrait: options.NoTrait,
+                testFilter: options.TestFilter,
                 includeHtml: options.IncludeHtml,
                 retry: options.Retry);
             return new ProcessTestExecutor(testExecutionOptions);

src/VisualStudio/Core/Def/Implementation/LanguageClient/AlwaysActivateInProcLanguageClient.cs

@@ -6,6 +6,7 @@
 using System.ComponentModel.Composition;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.Experiments;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.LanguageServer;
 using Microsoft.CodeAnalysis.Options;
@@ -27,6 +28,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.LanguageClient
     [Export(typeof(AlwaysActivateInProcLanguageClient))]
     internal class AlwaysActivateInProcLanguageClient : AbstractInProcLanguageClient
     {
+        private readonly DefaultCapabilitiesProvider _defaultCapabilitiesProvider;
         private readonly IGlobalOptionService _globalOptionService;
 
         [ImportingConstructor]
@@ -36,26 +38,40 @@ public AlwaysActivateInProcLanguageClient(
             CSharpVisualBasicRequestDispatcherFactory csharpVBRequestDispatcherFactory,
             VisualStudioWorkspace workspace,
             IAsynchronousOperationListenerProvider listenerProvider,
-            ILspWorkspaceRegistrationService lspWorkspaceRegistrationService)
+            ILspWorkspaceRegistrationService lspWorkspaceRegistrationService,
+            DefaultCapabilitiesProvider defaultCapabilitiesProvider)
             : base(csharpVBRequestDispatcherFactory, workspace, diagnosticService: null, listenerProvider, lspWorkspaceRegistrationService, diagnosticsClientName: null)
         {
             _globalOptionService = globalOptionService;
+            _defaultCapabilitiesProvider = defaultCapabilitiesProvider;
         }
 
         public override string Name => "C#/Visual Basic Language Server Client";
 
         protected internal override VSServerCapabilities GetCapabilities()
-            => new VSServerCapabilities
+        {
+            var serverCapabilities = new VSServerCapabilities();
+
+            // If the LSP editor feature flag is enabled advertise support for LSP features here so they are available locally and remote.
+            var isLspEditorEnabled = Workspace.Services.GetRequiredService<IExperimentationService>().IsExperimentEnabled(VisualStudioWorkspaceContextService.LspEditorFeatureFlagName);
+            if (isLspEditorEnabled)
+            {
+                serverCapabilities = _defaultCapabilitiesProvider.GetCapabilities();
+            }
+
+            serverCapabilities.TextDocumentSync = new TextDocumentSyncOptions
             {
-                TextDocumentSync = new TextDocumentSyncOptions
-                {
-                    Change = TextDocumentSyncKind.Incremental,
-                    OpenClose = true,
-                },
-                SupportsDiagnosticRequests = this.Workspace.IsPullDiagnostics(InternalDiagnosticsOptions.NormalDiagnosticMode),
-                // This flag ensures that ctrl+, search locally uses the old editor APIs so that only ctrl+Q search is powered via LSP.
-                DisableGoToWorkspaceSymbols = true,
-                WorkspaceSymbolProvider = true,
+                Change = TextDocumentSyncKind.Incremental,
+                OpenClose = true,
             };
+            serverCapabilities.SupportsDiagnosticRequests = Workspace.IsPullDiagnostics(InternalDiagnosticsOptions.NormalDiagnosticMode);
+
+            // When using the lsp editor, set this to false to allow LSP to power goto.
+            // Otherwise set to true to disable LSP for goto
+            serverCapabilities.DisableGoToWorkspaceSymbols = !isLspEditorEnabled;
+            serverCapabilities.WorkspaceSymbolProvider = true;
+
+            return serverCapabilities;
+        }
     }
 }