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

azure-pipelines-integration-lsp.yml

@@ -0,0 +1,31 @@
+# Separate pipeline from normal integration CI to allow branches to change legs
+
+# 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.Wpf/Suggestions/SuggestedActionsSourceProvider.cs

@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.Host;
+using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Editor.Tags;
 using Microsoft.CodeAnalysis.Host.Mef;
@@ -76,11 +77,18 @@ public SuggestedActionsSourceProvider(
             ImageMonikerServices = ExtensionOrderer.Order(imageMonikerServices).ToImmutableArray();
         }
 
-        public ISuggestedActionsSource CreateSuggestedActionsSource(ITextView textView, ITextBuffer textBuffer)
+        public ISuggestedActionsSource? CreateSuggestedActionsSource(ITextView textView, ITextBuffer textBuffer)
         {
             Contract.ThrowIfNull(textView);
             Contract.ThrowIfNull(textBuffer);
 
+            // Disable lightbulb points when running under the LSP editor.
+            // The LSP client will interface with the editor to display our code actions.
+            if (textBuffer.IsInLspEditorContext())
+            {
+                return null;
+            }
+
             return new SuggestedActionsSource(_threadingContext, this, textView, textBuffer, _suggestedActionCategoryRegistry);
         }
     }

src/EditorFeatures/Core/Implementation/Classification/SemanticClassificationBufferTaggerProvider.Tagger.cs

@@ -11,6 +11,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Editor.Tagging;
@@ -139,6 +140,13 @@ public IEnumerable<ITagSpan<IClassificationTag>> GetAllTags(NormalizedSnapshotSp
                 var snapshot = firstSpan.Snapshot;
                 Debug.Assert(snapshot.TextBuffer == _subjectBuffer);
 
+                // The LSP client will handle producing tags when running under the LSP editor.
+                // Our tagger implementation should return nothing to prevent conflicts.
+                if (snapshot.TextBuffer.IsInLspEditorContext())
+                {
+                    return Array.Empty<ITagSpan<IClassificationTag>>();
+                }
+
                 // We want to classify from the start of the first requested span to the end of the 
                 // last requested span.
                 var spanToTag = new SnapshotSpan(snapshot,

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

@@ -106,6 +106,14 @@ protected override Task ProduceTagsAsync(TaggerContext<IClassificationTag> conte
                 return Task.CompletedTask;
             }
 
+            // The LSP client will handle producing tags when running under the LSP editor.
+            // Our tagger implementation should return nothing to prevent conflicts.
+            var workspaceContextService = document?.Project.Solution.Workspace.Services.GetRequiredService<IWorkspaceContextService>();
+            if (workspaceContextService?.IsInLspEditorContext() == true)
+            {
+                return Task.CompletedTask;
+            }
+
             return SemanticClassificationUtilities.ProduceTagsAsync(context, spanToTag, classificationService, _typeMap);
         }
     }

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);