From fd06e3474eda7138eb64e48889ba7aaf3a171eae Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Thu, 7 May 2020 10:54:53 -0700
Subject: [PATCH 1/8] Exclude performance tests from debug builds

---
 .../Test/Semantic/Semantics/OverloadResolutionPerfTests.cs     | 3 ++-
 src/Compilers/CSharp/Test/Semantic/Semantics/SlowTests.cs      | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionPerfTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionPerfTests.cs
index c59f9b8e44643..fbdcd51f605b6 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionPerfTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionPerfTests.cs
@@ -232,7 +232,8 @@ public static void Method<TClass>(Func<TClass, Func<string, string>> method) { }
             comp.VerifyDiagnostics();
         }
 
-        [Fact, WorkItem(35949, "https://github.com/dotnet/roslyn/issues/35949")]
+        [WorkItem(35949, "https://github.com/dotnet/roslyn/issues/35949")]
+        [ConditionalFact(typeof(IsRelease))]
         public void NotNull_Complexity()
         {
             var source = @"
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/SlowTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/SlowTests.cs
index b7998d7128f1c..cae66d5683a69 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/SlowTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/SlowTests.cs
@@ -10,7 +10,8 @@ namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Semantics
 {
     public class SlowTests : CSharpTestBase
     {
-        [Fact, WorkItem(35949, "https://github.com/dotnet/roslyn/issues/35949")]
+        [WorkItem(35949, "https://github.com/dotnet/roslyn/issues/35949")]
+        [ConditionalFact(typeof(IsRelease))]
         public void NotNull_Complexity()
         {
             var source = @"

From 3c6b60ea3d8972342a536b27cddf7fb5161f38dd Mon Sep 17 00:00:00 2001
From: Allison Chou <allichou@microsoft.com>
Date: Thu, 14 May 2020 13:27:18 -0700
Subject: [PATCH 2/8] Fix for assertion error

---
 .../AbstractFindUsagesService_FindReferences.cs    | 14 +++++++++++++-
 .../CustomProtocol/FindUsagesLSPContext.cs         |  1 -
 .../Handler/References/FindAllReferencesHandler.cs |  1 -
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs b/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs
index 2247675080223..0eaa67a2a4a1a 100644
--- a/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs
+++ b/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs
@@ -20,7 +20,7 @@ namespace Microsoft.CodeAnalysis.Editor.FindUsages
 {
     internal abstract partial class AbstractFindUsagesService
     {
-        public async Task FindReferencesAsync(
+        async Task IFindUsagesService.FindReferencesAsync(
             Document document, int position, IFindUsagesContext context)
         {
             var definitionTrackingContext = new DefinitionTrackingContext(context);
@@ -48,6 +48,18 @@ await FindLiteralOrSymbolReferencesAsync(
             }
         }
 
+        async Task IFindUsagesLSPService.FindReferencesAsync(
+            Document document, int position, IFindUsagesContext context)
+        {
+            // We don't need to get third party definitions when finding references in LSP.
+            // Currently, 3rd party definitions = XAML definitions, and XAML will provide
+            // references via LSP instead of hooking into Roslyn.
+            // This also means that we don't need to be on the UI thread.
+            var definitionTrackingContext = new DefinitionTrackingContext(context);
+            await FindLiteralOrSymbolReferencesAsync(
+                document, position, definitionTrackingContext).ConfigureAwait(false);
+        }
+
         private async Task FindLiteralOrSymbolReferencesAsync(
             Document document, int position, IFindUsagesContext context)
         {
diff --git a/src/Features/LanguageServer/Protocol/CustomProtocol/FindUsagesLSPContext.cs b/src/Features/LanguageServer/Protocol/CustomProtocol/FindUsagesLSPContext.cs
index 4b46052e3344c..c2cbe9905a951 100644
--- a/src/Features/LanguageServer/Protocol/CustomProtocol/FindUsagesLSPContext.cs
+++ b/src/Features/LanguageServer/Protocol/CustomProtocol/FindUsagesLSPContext.cs
@@ -12,7 +12,6 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Classification;
-using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.FindSymbols.Finders;
diff --git a/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs b/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs
index 4d67cb49eea66..f534b6f13439a 100644
--- a/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs
@@ -9,7 +9,6 @@
 using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.FindUsages;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.LanguageServer.CustomProtocol;

From 45fc68b077c2263ab98aa8360273438e6052348a Mon Sep 17 00:00:00 2001
From: Allison Chou <allichou@microsoft.com>
Date: Thu, 14 May 2020 23:23:58 -0700
Subject: [PATCH 3/8] Code review feedback

---
 .../FindUsages/AbstractFindUsagesService_FindReferences.cs  | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs b/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs
index 0eaa67a2a4a1a..1a824ca2a655c 100644
--- a/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs
+++ b/src/EditorFeatures/Core/FindUsages/AbstractFindUsagesService_FindReferences.cs
@@ -48,16 +48,14 @@ await FindLiteralOrSymbolReferencesAsync(
             }
         }
 
-        async Task IFindUsagesLSPService.FindReferencesAsync(
+        Task IFindUsagesLSPService.FindReferencesAsync(
             Document document, int position, IFindUsagesContext context)
         {
             // We don't need to get third party definitions when finding references in LSP.
             // Currently, 3rd party definitions = XAML definitions, and XAML will provide
             // references via LSP instead of hooking into Roslyn.
             // This also means that we don't need to be on the UI thread.
-            var definitionTrackingContext = new DefinitionTrackingContext(context);
-            await FindLiteralOrSymbolReferencesAsync(
-                document, position, definitionTrackingContext).ConfigureAwait(false);
+            return FindLiteralOrSymbolReferencesAsync(document, position, new DefinitionTrackingContext(context));
         }
 
         private async Task FindLiteralOrSymbolReferencesAsync(

From b329cc6813defd29e0a1e373fb8f929aad6cf4b2 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Thu, 7 May 2020 14:49:28 -0700
Subject: [PATCH 4/8] Remove duplicate test

---
 .../Test/Semantic/Semantics/SlowTests.cs      | 66 -------------------
 1 file changed, 66 deletions(-)
 delete mode 100644 src/Compilers/CSharp/Test/Semantic/Semantics/SlowTests.cs

diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/SlowTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/SlowTests.cs
deleted file mode 100644
index cae66d5683a69..0000000000000
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/SlowTests.cs
+++ /dev/null
@@ -1,66 +0,0 @@
-// 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 Microsoft.CodeAnalysis.CSharp.Test.Utilities;
-using Roslyn.Test.Utilities;
-using Xunit;
-
-namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Semantics
-{
-    public class SlowTests : CSharpTestBase
-    {
-        [WorkItem(35949, "https://github.com/dotnet/roslyn/issues/35949")]
-        [ConditionalFact(typeof(IsRelease))]
-        public void NotNull_Complexity()
-        {
-            var source = @"
-#nullable enable
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-class C
-{
-    C f = null!;
-
-    void M(C c)
-    {
-        c.f = c;
-        c.NotNull(
-            x => x.f.NotNull(
-                y => y.f.NotNull(
-                    z => z.f.NotNull(
-                        q => q.f.NotNull(
-                            w => w.f.NotNull(
-                                e => e.f.NotNull(
-                                    r => r.f.NotNull(
-                                        _ =>
-                                        {
-                                            """".NotNull(s => s);
-                                            """".NotNull(s => s);
-                                            """".NotNull(s => s);
-                                            """".NotNull(s => s);
-                                            """".NotNull(s => s);
-                                            """".NotNull(s => s);
-                                            """".NotNull(s => s);
-                                            """".NotNull(s => s);
-                                            """".NotNull(s => s);
-                                            """".NotNull(s => s);
-                                            """".NotNull(s => s);
-                                            """".NotNull(s => s);
-
-                                            return """";
-                                        }))))))));
-    }
-}
-
-static class Ext
-{
-    public static V NotNull<T, V>([NotNull] this T t, Func<T, V> f) => throw null!;
-}
-";
-            var comp = CreateCompilation(new[] { NotNullAttributeDefinition, source });
-            comp.VerifyDiagnostics();
-        }
-    }
-}

From 54ffb390d050978d2b41b1993a3f751a1a5a8fb4 Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Wed, 13 May 2020 16:28:06 -0700
Subject: [PATCH 5/8] Add support for the textDocument/_ms_getProjectContexts
 method

---
 eng/Versions.props                            |   2 +-
 .../AbstractLanguageServerProtocolTests.cs    |   2 +-
 .../Extensions/ProtocolConversions.cs         |   5 +
 .../Handler/Initialize/InitializeHandler.cs   |   3 +-
 .../GetTextDocumentWithContextHandler.cs      |  81 +++++++++++++
 .../Initialize/InitializeTests.cs             |   4 +-
 .../GetTextDocumentWithContextHandlerTests.cs | 109 ++++++++++++++++++
 .../LanguageClient/InProcLanguageServer.cs    |   5 +
 8 files changed, 206 insertions(+), 5 deletions(-)
 create mode 100644 src/Features/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs
 create mode 100644 src/Features/LanguageServer/ProtocolUnitTests/ProjectContext/GetTextDocumentWithContextHandlerTests.cs

diff --git a/eng/Versions.props b/eng/Versions.props
index a3a22df8224df..91111f73bca7d 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -33,7 +33,7 @@
     <CodeStyleAnalyzerVersion>3.7.0-1.20210.7</CodeStyleAnalyzerVersion>
     <VisualStudioEditorPackagesVersion>16.4.248</VisualStudioEditorPackagesVersion>
     <ILToolsPackageVersion>5.0.0-alpha1.19409.1</ILToolsPackageVersion>
-    <MicrosoftVisualStudioLanguageServerPackagesVersion>16.7.12-g74a1f6f85d</MicrosoftVisualStudioLanguageServerPackagesVersion>
+    <MicrosoftVisualStudioLanguageServerPackagesVersion>16.7.29</MicrosoftVisualStudioLanguageServerPackagesVersion>
   </PropertyGroup>
   <!--
     Dependency versions
diff --git a/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs b/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
index 9db64803282fc..f16adac5f3bfd 100644
--- a/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
+++ b/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
@@ -203,7 +203,7 @@ protected Workspace CreateTestWorkspace(string[] markups, out Dictionary<string,
             return workspace;
         }
 
-        protected Workspace CreateXmlTestWorkspace(string xmlContent, out Dictionary<string, IList<LSP.Location>> locations)
+        protected TestWorkspace CreateXmlTestWorkspace(string xmlContent, out Dictionary<string, IList<LSP.Location>> locations)
         {
             var workspace = TestWorkspace.Create(xmlContent, exportProvider: GetExportProvider());
             locations = GetAnnotatedLocations(workspace, workspace.CurrentSolution);
diff --git a/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs b/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs
index a3e88e40efb0d..24aa72ff16ab6 100644
--- a/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs
+++ b/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs
@@ -443,5 +443,10 @@ public static LSP.ReferenceKind[] SymbolUsageInfoToReferenceKinds(SymbolUsageInf
 
             return referenceKinds.ToArrayAndFree();
         }
+
+        public static string ProjectIdToProjectContextId(ProjectId id)
+        {
+            return id.Id + "|" + id.DebugName;
+        }
     }
 }
diff --git a/src/Features/LanguageServer/Protocol/Handler/Initialize/InitializeHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Initialize/InitializeHandler.cs
index f76bfa9e41aee..8e8e0007ab46e 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Initialize/InitializeHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Initialize/InitializeHandler.cs
@@ -39,7 +39,7 @@ public InitializeHandler([ImportMany] IEnumerable<Lazy<CompletionProvider, Compl
 
             return Task.FromResult(new LSP.InitializeResult
             {
-                Capabilities = new LSP.ServerCapabilities
+                Capabilities = new LSP.VSServerCapabilities
                 {
                     DefinitionProvider = true,
                     RenameProvider = true,
@@ -53,6 +53,7 @@ public InitializeHandler([ImportMany] IEnumerable<Lazy<CompletionProvider, Compl
                     DocumentOnTypeFormattingProvider = new LSP.DocumentOnTypeFormattingOptions { FirstTriggerCharacter = "}", MoreTriggerCharacter = new[] { ";", "\n" } },
                     DocumentHighlightProvider = true,
                     ReferencesProvider = true,
+                    ProjectContextProvider = true
                 }
             });
         }
diff --git a/src/Features/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs b/src/Features/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs
new file mode 100644
index 0000000000000..c22388e9c6000
--- /dev/null
+++ b/src/Features/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs
@@ -0,0 +1,81 @@
+// 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.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.VisualStudio.LanguageServer.Protocol;
+
+namespace Microsoft.CodeAnalysis.LanguageServer.Handler
+{
+    [Shared]
+    [ExportLspMethod(MSLSPMethods.ProjectContextsName)]
+    internal class GetTextDocumentWithContextHandler : IRequestHandler<GetTextDocumentWithContextParams, ActiveProjectContexts?>
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public GetTextDocumentWithContextHandler()
+        {
+        }
+
+        public Task<ActiveProjectContexts?> HandleRequestAsync(
+            Solution solution,
+            GetTextDocumentWithContextParams request,
+            ClientCapabilities clientCapabilities,
+            string? clientName,
+            CancellationToken cancellationToken)
+        {
+            var startingDocument = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+
+            if (startingDocument == null || startingDocument.FilePath == null)
+            {
+                return Task.FromResult<ActiveProjectContexts?>(null);
+            }
+
+            var allDocumentIds = solution.GetDocumentIdsWithFilePath(startingDocument.FilePath);
+            var contexts = new List<ProjectContext>();
+
+            foreach (var documentId in allDocumentIds)
+            {
+                var project = solution.GetRequiredProject(documentId.ProjectId);
+                var context = new ProjectContext
+                {
+                    Id = ProtocolConversions.ProjectIdToProjectContextId(project.Id),
+                    Label = project.Name
+                };
+
+                if (project.Language == LanguageNames.CSharp)
+                {
+                    context.Kind = ProjectContextKind.CSharp;
+                }
+                else if (project.Language == LanguageNames.VisualBasic)
+                {
+                    context.Kind = ProjectContextKind.VisualBasic;
+                }
+
+                contexts.Add(context);
+            }
+
+            // If the document is open, it doesn't matter which DocumentId we pass to GetDocumentIdInCurrentContext since
+            // all the documents are linked at that point, so we can just pass the first arbitrarily. If the document is closed
+            // GetDocumentIdInCurrentContext will just return the same ID back, which means we're going to pick the first
+            // ID in GetDocumentIdsWithFilePath, but there's really nothing we can do since we don't have contexts for
+            // close documents anyways.
+            var currentContextDocumentId = solution.Workspace.GetDocumentIdInCurrentContext(allDocumentIds.First());
+
+            return Task.FromResult<ActiveProjectContexts?>(new ActiveProjectContexts
+            {
+                ProjectContexts = contexts.ToArray(),
+                DefaultIndex = allDocumentIds.IndexOf(currentContextDocumentId)
+            });
+        }
+    }
+}
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/Initialize/InitializeTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/Initialize/InitializeTests.cs
index 561db10a14bc6..584078587566c 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/Initialize/InitializeTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/Initialize/InitializeTests.cs
@@ -32,8 +32,8 @@ private static void AssertServerCapabilities(LSP.ServerCapabilities actual)
             Assert.True(actual.ImplementationProvider);
             Assert.True(actual.DocumentSymbolProvider);
             Assert.True(actual.WorkspaceSymbolProvider);
-            Assert.True(actual.DocumentFormattingProvider);
-            Assert.True(actual.DocumentRangeFormattingProvider);
+            Assert.True((bool)actual.DocumentFormattingProvider.Value);
+            Assert.True((bool)actual.DocumentRangeFormattingProvider.Value);
             Assert.True(actual.DocumentHighlightProvider);
 
             Assert.True(actual.CompletionProvider.ResolveProvider);
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/ProjectContext/GetTextDocumentWithContextHandlerTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/ProjectContext/GetTextDocumentWithContextHandlerTests.cs
new file mode 100644
index 0000000000000..7c84128444e18
--- /dev/null
+++ b/src/Features/LanguageServer/ProtocolUnitTests/ProjectContext/GetTextDocumentWithContextHandlerTests.cs
@@ -0,0 +1,109 @@
+// 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.
+
+#nullable enable
+
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Roslyn.Test.Utilities;
+using Xunit;
+using LSP = Microsoft.VisualStudio.LanguageServer.Protocol;
+
+namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests.ProjectContext
+{
+    public class GetTextDocumentWithContextHandlerTests : AbstractLanguageServerProtocolTests
+    {
+        [Fact]
+        public async Task SingleDocumentReturnsSingleContext()
+        {
+            var workspaceXml =
+@"<Workspace>
+    <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""CSProj"">
+        <Document FilePath = ""C:\C.cs"">{|caret:|}</Document>
+    </Project>
+</Workspace>";
+
+            using var workspace = CreateXmlTestWorkspace(workspaceXml, out var locations);
+            var documentUri = locations["caret"].Single().Uri;
+            var result = await RunGetProjectContext(workspace.CurrentSolution, documentUri);
+
+            Assert.NotNull(result);
+            Assert.Equal(0, result!.DefaultIndex);
+            var context = Assert.Single(result.ProjectContexts);
+
+            Assert.Equal(ProtocolConversions.ProjectIdToProjectContextId(workspace.CurrentSolution.ProjectIds.Single()), context.Id);
+            Assert.Equal(LSP.ProjectContextKind.CSharp, context.Kind);
+            Assert.Equal("CSProj", context.Label);
+        }
+
+        [Fact]
+        public async Task MultipleDocumentsReturnsMultipleContexts()
+        {
+            var workspaceXml =
+@"<Workspace>
+    <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""CSProj1"">
+        <Document FilePath=""C:\C.cs"">{|caret:|}</Document>
+    </Project>
+    <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""CSProj2"">
+        <Document IsLinkFile=""true"" LinkFilePath=""C:\C.cs"" LinkAssemblyName=""CSProj1"">{|caret:|}</Document>
+    </Project>
+</Workspace>";
+
+            using var workspace = CreateXmlTestWorkspace(workspaceXml, out var locations);
+            var documentUri = locations["caret"].Single().Uri;
+            var result = await RunGetProjectContext(workspace.CurrentSolution, documentUri);
+
+            Assert.NotNull(result);
+
+            Assert.Collection(result!.ProjectContexts.OrderBy(c => c.Label),
+                c => Assert.Equal("CSProj1", c.Label),
+                c => Assert.Equal("CSProj2", c.Label));
+        }
+
+        [Fact]
+        public async Task SwitchingContextsChangesDefaultContext()
+        {
+            var workspaceXml =
+@"<Workspace>
+    <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""CSProj1"">
+        <Document FilePath=""C:\C.cs"">{|caret:|}</Document>
+    </Project>
+    <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""CSProj2"">
+        <Document IsLinkFile=""true"" LinkFilePath=""C:\C.cs"" LinkAssemblyName=""CSProj1""></Document>
+    </Project>
+</Workspace>";
+
+            using var workspace = CreateXmlTestWorkspace(workspaceXml, out var locations);
+
+            // Ensure the documents are open so we can change contexts
+            foreach (var document in workspace.Documents)
+            {
+                _ = document.GetOpenTextContainer();
+            }
+
+            var documentUri = locations["caret"].Single().Uri;
+
+            foreach (var project in workspace.CurrentSolution.Projects)
+            {
+                workspace.SetDocumentContext(project.DocumentIds.Single());
+                var result = await RunGetProjectContext(workspace.CurrentSolution, documentUri);
+
+                Assert.Equal(ProtocolConversions.ProjectIdToProjectContextId(project.Id), result!.ProjectContexts[result.DefaultIndex].Id);
+                Assert.Equal(project.Name, result!.ProjectContexts[result.DefaultIndex].Label);
+            }
+        }
+
+        private static async Task<LSP.ActiveProjectContexts?> RunGetProjectContext(Solution solution, Uri uri)
+            => await GetLanguageServer(solution).ExecuteRequestAsync<LSP.GetTextDocumentWithContextParams, LSP.ActiveProjectContexts?>(LSP.MSLSPMethods.ProjectContextsName,
+                solution, CreateGetProjectContextParams(uri), new LSP.ClientCapabilities(), clientName: null, CancellationToken.None);
+
+        private static LSP.GetTextDocumentWithContextParams CreateGetProjectContextParams(Uri uri)
+            => new LSP.GetTextDocumentWithContextParams()
+            {
+                TextDocument = new LSP.TextDocumentItem { Uri = uri }
+            };
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs b/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs
index a0bcb49b1072b..6427939c576bd 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs
@@ -176,6 +176,11 @@ public Task<SymbolInformation[]> GetWorkspaceSymbolsAsync(WorkspaceSymbolParams
             => _protocol.ExecuteRequestAsync<WorkspaceSymbolParams, SymbolInformation[]>(Methods.WorkspaceSymbolName,
                 _workspace.CurrentSolution, workspaceSymbolParams, _clientCapabilities, _clientName, cancellationToken);
 
+        [JsonRpcMethod(MSLSPMethods.ProjectContextsName, UseSingleObjectParameterDeserialization = true)]
+        public Task<ActiveProjectContexts?> GetProjectContextsAsync(GetTextDocumentWithContextParams textDocumentWithContextParams, CancellationToken cancellationToken)
+            => _protocol.ExecuteRequestAsync<GetTextDocumentWithContextParams, ActiveProjectContexts?>(MSLSPMethods.ProjectContextsName,
+                _workspace.CurrentSolution, textDocumentWithContextParams, _clientCapabilities, _clientName, cancellationToken);
+
 #pragma warning disable VSTHRD100 // Avoid async void methods
         private async void DiagnosticService_DiagnosticsUpdated(object sender, DiagnosticsUpdatedArgs e)
 #pragma warning restore VSTHRD100 // Avoid async void methods

From 26cc5f6012965d3ce23768fc07aa9327ee50a2db Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Wed, 13 May 2020 18:31:14 -0700
Subject: [PATCH 6/8] Update all of our handlers to support finding the right
 document context

This replaces our existing "GetDocumentFromURI" helper with one that
instead takes the full TextDocumentIdentifier, and uses the context
information to figure out which document to use in the case of
multi-targeting or linked documents.
---
 .../AbstractLanguageServerProtocolTests.cs    | 19 ++++--
 .../Protocol/Extensions/Extensions.cs         | 61 ++++++++++++++++---
 .../Extensions/ProtocolConversions.cs         | 10 +++
 .../Handler/CodeActions/CodeActionsHandler.cs |  2 +-
 .../CodeActions/CodeActionsHandlerBase.cs     |  4 +-
 .../Handler/Completion/CompletionHandler.cs   |  2 +-
 .../Completion/CompletionResolveHandler.cs    |  2 +-
 .../Definitions/GoToDefinitionHandlerBase.cs  |  2 +-
 .../FoldingRanges/FoldingRangesHandler.cs     |  2 +-
 .../Formatting/FormatDocumentHandler.cs       |  2 +-
 .../Formatting/FormatDocumentHandlerBase.cs   |  5 +-
 .../Formatting/FormatDocumentOnTypeHandler.cs |  2 +-
 .../Formatting/FormatDocumentRangeHandler.cs  |  2 +-
 .../Highlights/DocumentHighlightHandler.cs    |  2 +-
 .../Protocol/Handler/Hover/HoverHandler.cs    |  2 +-
 .../GetTextDocumentWithContextHandler.cs      | 13 ++--
 .../References/FindAllReferencesHandler.cs    |  2 +-
 .../References/FindImplementationsHandler.cs  |  2 +-
 .../Protocol/Handler/Rename/RenameHandler.cs  |  2 +-
 .../SignatureHelp/SignatureHelpHandler.cs     |  2 +-
 .../Handler/Symbols/DocumentSymbolsHandler.cs |  2 +-
 .../Formatting/FormatDocumentOnTypeTests.cs   |  2 +-
 .../Formatting/FormatDocumentRangeTests.cs    |  2 +-
 .../Formatting/FormatDocumentTests.cs         |  2 +-
 .../ProtocolUnitTests/Hover/HoverTests.cs     | 60 +++++++++++++++++-
 .../LanguageClient/InProcLanguageServer.cs    |  7 ++-
 .../Impl/AbstractClassificationsHandler.cs    |  3 +-
 ...oDefinitionWithFindUsagesServiceHandler.cs |  2 +-
 .../CodeActions/RoslynRemoteCodeAction.cs     |  7 ++-
 .../Impl/PreviewCodeActionsHandler.cs         |  4 +-
 .../LiveShare/Impl/RunCodeActionsHandler.cs   |  2 +-
 31 files changed, 176 insertions(+), 57 deletions(-)

diff --git a/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs b/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
index f16adac5f3bfd..c91a81be25052 100644
--- a/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
+++ b/src/EditorFeatures/TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs
@@ -114,16 +114,23 @@ protected static LSP.SymbolInformation CreateSymbolInformation(LSP.SymbolKind ki
                 ContainerName = containerName
             };
 
-        protected static LSP.TextDocumentIdentifier CreateTextDocumentIdentifier(Uri uri)
-            => new LSP.TextDocumentIdentifier()
+        protected static LSP.TextDocumentIdentifier CreateTextDocumentIdentifier(Uri uri, ProjectId projectContext = null)
+        {
+            var documentIdentifier = new LSP.VSTextDocumentIdentifier() { Uri = uri };
+
+            if (projectContext != null)
             {
-                Uri = uri
-            };
+                documentIdentifier.ProjectContext =
+                    new LSP.ProjectContext { Id = ProtocolConversions.ProjectIdToProjectContextId(projectContext) };
+            }
 
-        protected static LSP.TextDocumentPositionParams CreateTextDocumentPositionParams(LSP.Location caret)
+            return documentIdentifier;
+        }
+
+        protected static LSP.TextDocumentPositionParams CreateTextDocumentPositionParams(LSP.Location caret, ProjectId projectContext = null)
             => new LSP.TextDocumentPositionParams()
             {
-                TextDocument = CreateTextDocumentIdentifier(caret.Uri),
+                TextDocument = CreateTextDocumentIdentifier(caret.Uri, projectContext),
                 Position = caret.Range.Start
             };
 
diff --git a/src/Features/LanguageServer/Protocol/Extensions/Extensions.cs b/src/Features/LanguageServer/Protocol/Extensions/Extensions.cs
index 38d8446cd4300..3b3aa39a739e3 100644
--- a/src/Features/LanguageServer/Protocol/Extensions/Extensions.cs
+++ b/src/Features/LanguageServer/Protocol/Extensions/Extensions.cs
@@ -5,11 +5,13 @@
 #nullable enable
 
 using System;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.FindUsages;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 using Microsoft.VisualStudio.Text.Adornments;
@@ -23,31 +25,70 @@ public static Uri GetURI(this Document document)
             return ProtocolConversions.GetUriFromFilePath(document.FilePath);
         }
 
-        public static Document? GetDocumentFromURI(this Solution solution, Uri fileName, string? clientName = null)
+        public static ImmutableArray<Document> GetDocuments(this Solution solution, Uri uri, string? clientName = null)
         {
             // TODO: we need to normalize this. but for now, we check both absolute and local path
             //       right now, based on who calls this, solution might has "/" or "\\" as directory
             //       separator
-            var documentId = solution.GetDocumentIdsWithFilePath(fileName.AbsolutePath).FirstOrDefault() ??
-                             solution.GetDocumentIdsWithFilePath(fileName.LocalPath).FirstOrDefault();
+            var documentIds = solution.GetDocumentIdsWithFilePath(uri.AbsolutePath);
 
-            var document = solution.GetDocument(documentId);
+            if (!documentIds.Any())
+            {
+                documentIds = solution.GetDocumentIdsWithFilePath(uri.LocalPath);
+            }
+
+            var documents = documentIds.SelectAsArray(id => solution.GetRequiredDocument(id));
 
-            if (clientName != null)
+            // If we don't have a client name, then we're done filtering
+            if (clientName == null)
             {
-                var documentPropertiesService = document?.Services.GetService<DocumentPropertiesService>();
+                return documents;
+            }
+
+            // We have a client name, so we need to filter to only documents that match that name
+            return documents.WhereAsArray(document =>
+            {
+                var documentPropertiesService = document.Services.GetService<DocumentPropertiesService>();
+
                 // When a client name is specified, only return documents that have a matching client name.
                 // Allows the razor lsp server to return results only for razor documents.
                 // This workaround should be removed when https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1106064/
                 // is fixed (so that the razor language server is only asked about razor buffers).
-                if (!Equals(documentPropertiesService?.DiagnosticsLspClientName, clientName))
+                return Equals(documentPropertiesService?.DiagnosticsLspClientName, clientName);
+            });
+        }
+
+        public static Document? GetDocument(this Solution solution, TextDocumentIdentifier documentIdentifier, string? clientName = null)
+        {
+            var documents = solution.GetDocuments(documentIdentifier.Uri, clientName);
+
+            if (documents.Length == 0)
+            {
+                return null;
+            }
+
+            if (documents.Length > 1)
+            {
+                // We have more than one document; try to find the one that matches the right context
+                if (documentIdentifier is VSTextDocumentIdentifier vsDocumentIdentifier)
                 {
-                    return null;
+                    if (vsDocumentIdentifier.ProjectContext != null)
+                    {
+                        var projectId = ProtocolConversions.ProjectContextToProjectId(vsDocumentIdentifier.ProjectContext);
+                        var matchingDocument = documents.FirstOrDefault(d => d.Project.Id == projectId);
+
+                        if (matchingDocument != null)
+                        {
+                            return matchingDocument;
+                        }
+                    }
                 }
             }
 
-            return document;
-
+            // We either have only one document or have multiple, but none of them  matched our context. In the
+            // latter case, we'll just return the first one arbitrarily since this might just be some temporary mis-sync
+            // of client and server state.
+            return documents[0];
         }
 
         public static async Task<int> GetPositionFromLinePositionAsync(this Document document, LinePosition linePosition, CancellationToken cancellationToken)
diff --git a/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs b/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs
index 24aa72ff16ab6..db2090b9863bc 100644
--- a/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs
+++ b/src/Features/LanguageServer/Protocol/Extensions/ProtocolConversions.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.NavigateTo;
 using Microsoft.CodeAnalysis.Tags;
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.VisualStudio.LanguageServer.Protocol;
 using Microsoft.VisualStudio.Text.Adornments;
 using Microsoft.VisualStudio.Utilities;
 using Roslyn.Utilities;
@@ -448,5 +449,14 @@ public static string ProjectIdToProjectContextId(ProjectId id)
         {
             return id.Id + "|" + id.DebugName;
         }
+
+        public static ProjectId ProjectContextToProjectId(ProjectContext projectContext)
+        {
+            int delimiter = projectContext.Id.IndexOf('|');
+
+            return ProjectId.CreateFromSerialized(
+                Guid.Parse(projectContext.Id.Substring(0, delimiter)),
+                debugName: projectContext.Id.Substring(delimiter + 1));
+        }
     }
 }
diff --git a/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionsHandler.cs b/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionsHandler.cs
index 410cd325d88ca..a818584b1acc4 100644
--- a/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionsHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionsHandler.cs
@@ -36,7 +36,7 @@ public CodeActionsHandler(ICodeFixService codeFixService, ICodeRefactoringServic
             LSP.ClientCapabilities clientCapabilities, string? clientName, CancellationToken cancellationToken)
         {
             var codeActions = await GetCodeActionsAsync(solution,
-                request.TextDocument.Uri,
+                request.TextDocument,
                 request.Range,
                 clientName, cancellationToken).ConfigureAwait(false);
 
diff --git a/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionsHandlerBase.cs b/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionsHandlerBase.cs
index 855206dc31c85..4da764ef05fe4 100644
--- a/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionsHandlerBase.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/CodeActions/CodeActionsHandlerBase.cs
@@ -30,9 +30,9 @@ public CodeActionsHandlerBase(ICodeFixService codeFixService, ICodeRefactoringSe
             _codeRefactoringService = codeRefactoringService ?? throw new ArgumentNullException(nameof(codeRefactoringService));
         }
 
-        public async Task<IEnumerable<CodeAction>> GetCodeActionsAsync(Solution solution, Uri documentUri, LSP.Range selection, string? clientName, CancellationToken cancellationToken)
+        public async Task<IEnumerable<CodeAction>> GetCodeActionsAsync(Solution solution, LSP.TextDocumentIdentifier documentIdentifier, LSP.Range selection, string? clientName, CancellationToken cancellationToken)
         {
-            var document = solution.GetDocumentFromURI(documentUri, clientName);
+            var document = solution.GetDocument(documentIdentifier, clientName);
             if (document == null)
             {
                 return ImmutableArray<CodeAction>.Empty;
diff --git a/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionHandler.cs
index 7b41583f18121..c5daed4d385c4 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionHandler.cs
@@ -35,7 +35,7 @@ public CompletionHandler()
         public async Task<LSP.CompletionItem[]> HandleRequestAsync(Solution solution, LSP.CompletionParams request, LSP.ClientCapabilities clientCapabilities,
             string? clientName, CancellationToken cancellationToken)
         {
-            var document = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var document = solution.GetDocument(request.TextDocument, clientName);
             if (document == null)
             {
                 return Array.Empty<LSP.CompletionItem>();
diff --git a/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionResolveHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionResolveHandler.cs
index 36d147cb4c1d8..770647a781f2d 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionResolveHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Completion/CompletionResolveHandler.cs
@@ -46,7 +46,7 @@ public CompletionResolveHandler()
 
             var request = data.CompletionParams;
 
-            var document = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var document = solution.GetDocument(request.TextDocument, clientName);
             if (document == null)
             {
                 return completionItem;
diff --git a/src/Features/LanguageServer/Protocol/Handler/Definitions/GoToDefinitionHandlerBase.cs b/src/Features/LanguageServer/Protocol/Handler/Definitions/GoToDefinitionHandlerBase.cs
index 815dae2a3888e..dd92db30ab98c 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Definitions/GoToDefinitionHandlerBase.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Definitions/GoToDefinitionHandlerBase.cs
@@ -28,7 +28,7 @@ public GoToDefinitionHandlerBase(IMetadataAsSourceFileService metadataAsSourceFi
         {
             var locations = ArrayBuilder<LSP.Location>.GetInstance();
 
-            var document = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var document = solution.GetDocument(request.TextDocument, clientName);
             if (document == null)
             {
                 return locations.ToArrayAndFree();
diff --git a/src/Features/LanguageServer/Protocol/Handler/FoldingRanges/FoldingRangesHandler.cs b/src/Features/LanguageServer/Protocol/Handler/FoldingRanges/FoldingRangesHandler.cs
index 2bbe20afea735..2a921880d067d 100644
--- a/src/Features/LanguageServer/Protocol/Handler/FoldingRanges/FoldingRangesHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/FoldingRanges/FoldingRangesHandler.cs
@@ -30,7 +30,7 @@ public async Task<FoldingRange[]> HandleRequestAsync(Solution solution, FoldingR
         {
             var foldingRanges = ArrayBuilder<FoldingRange>.GetInstance();
 
-            var document = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var document = solution.GetDocument(request.TextDocument, clientName);
             if (document == null)
             {
                 return foldingRanges.ToArrayAndFree();
diff --git a/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentHandler.cs
index 370a93142f565..91c93c0d6ac3d 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentHandler.cs
@@ -26,7 +26,7 @@ public FormatDocumentHandler()
         public async Task<LSP.TextEdit[]> HandleRequestAsync(Solution solution, LSP.DocumentFormattingParams request, LSP.ClientCapabilities clientCapabilities,
             string? clientName, CancellationToken cancellationToken)
         {
-            return await GetTextEditsAsync(solution, request.TextDocument.Uri, clientName, cancellationToken).ConfigureAwait(false);
+            return await GetTextEditsAsync(solution, request.TextDocument, clientName, cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentHandlerBase.cs b/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentHandlerBase.cs
index d1be09f6894e0..a5ecef92cce6b 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentHandlerBase.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentHandlerBase.cs
@@ -4,7 +4,6 @@
 
 #nullable enable
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -18,10 +17,10 @@ namespace Microsoft.CodeAnalysis.LanguageServer.Handler
 {
     internal abstract class FormatDocumentHandlerBase
     {
-        protected async Task<LSP.TextEdit[]> GetTextEditsAsync(Solution solution, Uri documentUri, string? clientName, CancellationToken cancellationToken, LSP.Range? range = null)
+        protected async Task<LSP.TextEdit[]> GetTextEditsAsync(Solution solution, LSP.TextDocumentIdentifier documentIdentifier, string? clientName, CancellationToken cancellationToken, LSP.Range? range = null)
         {
             var edits = new ArrayBuilder<LSP.TextEdit>();
-            var document = solution.GetDocumentFromURI(documentUri, clientName);
+            var document = solution.GetDocument(documentIdentifier, clientName);
 
             if (document != null)
             {
diff --git a/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs
index 1644e73582af3..8dcdf9a1a2eb8 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentOnTypeHandler.cs
@@ -33,7 +33,7 @@ public async Task<TextEdit[]> HandleRequestAsync(Solution solution, DocumentOnTy
             string? clientName, CancellationToken cancellationToken)
         {
             var edits = new ArrayBuilder<TextEdit>();
-            var document = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var document = solution.GetDocument(request.TextDocument, clientName);
             if (document != null)
             {
                 var formattingService = document.Project.LanguageServices.GetRequiredService<IEditorFormattingService>();
diff --git a/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentRangeHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentRangeHandler.cs
index c206aa17f63c7..7584e4ecd6184 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentRangeHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Formatting/FormatDocumentRangeHandler.cs
@@ -26,7 +26,7 @@ public FormatDocumentRangeHandler()
         public async Task<TextEdit[]> HandleRequestAsync(Solution solution, DocumentRangeFormattingParams request, ClientCapabilities clientCapabilities,
             string? clientName, CancellationToken cancellationToken)
         {
-            return await GetTextEditsAsync(solution, request.TextDocument.Uri, clientName, cancellationToken, range: request.Range).ConfigureAwait(false);
+            return await GetTextEditsAsync(solution, request.TextDocument, clientName, cancellationToken, range: request.Range).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Features/LanguageServer/Protocol/Handler/Highlights/DocumentHighlightHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Highlights/DocumentHighlightHandler.cs
index 908a5949bb7da..7a3c2b09ab739 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Highlights/DocumentHighlightHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Highlights/DocumentHighlightHandler.cs
@@ -29,7 +29,7 @@ public DocumentHighlightsHandler()
         public async Task<DocumentHighlight[]> HandleRequestAsync(Solution solution, TextDocumentPositionParams request,
             ClientCapabilities clientCapabilities, string? clientName, CancellationToken cancellationToken)
         {
-            var document = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var document = solution.GetDocument(request.TextDocument, clientName);
             if (document == null)
             {
                 return Array.Empty<DocumentHighlight>();
diff --git a/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs
index e102df51e33a5..4555709c2eaa6 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs
@@ -28,7 +28,7 @@ public HoverHandler()
         public async Task<Hover?> HandleRequestAsync(Solution solution, TextDocumentPositionParams request,
             ClientCapabilities clientCapabilities, string? clientName, CancellationToken cancellationToken)
         {
-            var document = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var document = solution.GetDocument(request.TextDocument, clientName);
             if (document == null)
             {
                 return null;
diff --git a/src/Features/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs b/src/Features/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs
index c22388e9c6000..37dc5b13d0ccf 100644
--- a/src/Features/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs
@@ -33,19 +33,18 @@ public GetTextDocumentWithContextHandler()
             string? clientName,
             CancellationToken cancellationToken)
         {
-            var startingDocument = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var documents = solution.GetDocuments(request.TextDocument.Uri, clientName);
 
-            if (startingDocument == null || startingDocument.FilePath == null)
+            if (!documents.Any())
             {
                 return Task.FromResult<ActiveProjectContexts?>(null);
             }
 
-            var allDocumentIds = solution.GetDocumentIdsWithFilePath(startingDocument.FilePath);
             var contexts = new List<ProjectContext>();
 
-            foreach (var documentId in allDocumentIds)
+            foreach (var document in documents)
             {
-                var project = solution.GetRequiredProject(documentId.ProjectId);
+                var project = document.Project;
                 var context = new ProjectContext
                 {
                     Id = ProtocolConversions.ProjectIdToProjectContextId(project.Id),
@@ -69,12 +68,12 @@ public GetTextDocumentWithContextHandler()
             // GetDocumentIdInCurrentContext will just return the same ID back, which means we're going to pick the first
             // ID in GetDocumentIdsWithFilePath, but there's really nothing we can do since we don't have contexts for
             // close documents anyways.
-            var currentContextDocumentId = solution.Workspace.GetDocumentIdInCurrentContext(allDocumentIds.First());
+            var currentContextDocumentId = solution.Workspace.GetDocumentIdInCurrentContext(documents.First().Id);
 
             return Task.FromResult<ActiveProjectContexts?>(new ActiveProjectContexts
             {
                 ProjectContexts = contexts.ToArray(),
-                DefaultIndex = allDocumentIds.IndexOf(currentContextDocumentId)
+                DefaultIndex = documents.IndexOf(d => d.Id == currentContextDocumentId)
             });
         }
     }
diff --git a/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs b/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs
index 4d67cb49eea66..04a7d1cf169d2 100644
--- a/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs
@@ -41,7 +41,7 @@ public FindAllReferencesHandler(IMetadataAsSourceFileService metadataAsSourceFil
         {
             Debug.Assert(clientCapabilities.HasVisualStudioLspCapability());
 
-            var document = solution.GetDocumentFromURI(referenceParams.TextDocument.Uri, clientName);
+            var document = solution.GetDocument(referenceParams.TextDocument, clientName);
             if (document == null)
             {
                 return Array.Empty<LSP.VSReferenceItem>();
diff --git a/src/Features/LanguageServer/Protocol/Handler/References/FindImplementationsHandler.cs b/src/Features/LanguageServer/Protocol/Handler/References/FindImplementationsHandler.cs
index acb2a2957a077..03d4dec92960e 100644
--- a/src/Features/LanguageServer/Protocol/Handler/References/FindImplementationsHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/References/FindImplementationsHandler.cs
@@ -31,7 +31,7 @@ public FindImplementationsHandler()
         {
             var locations = ArrayBuilder<LSP.Location>.GetInstance();
 
-            var document = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var document = solution.GetDocument(request.TextDocument, clientName);
             if (document == null)
             {
                 return locations.ToArrayAndFree();
diff --git a/src/Features/LanguageServer/Protocol/Handler/Rename/RenameHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Rename/RenameHandler.cs
index 0e336d8bb8130..babfed1c4819c 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Rename/RenameHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Rename/RenameHandler.cs
@@ -31,7 +31,7 @@ public RenameHandler()
         public async Task<WorkspaceEdit?> HandleRequestAsync(Solution oldSolution, RenameParams request, ClientCapabilities clientCapabilities, string? clientName, CancellationToken cancellationToken)
         {
             WorkspaceEdit? workspaceEdit = null;
-            var document = oldSolution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var document = oldSolution.GetDocument(request.TextDocument, clientName);
             if (document != null)
             {
                 var renameService = document.Project.LanguageServices.GetRequiredService<IEditorInlineRenameService>();
diff --git a/src/Features/LanguageServer/Protocol/Handler/SignatureHelp/SignatureHelpHandler.cs b/src/Features/LanguageServer/Protocol/Handler/SignatureHelp/SignatureHelpHandler.cs
index 1397aa4a5569e..fa751f0dac2c3 100644
--- a/src/Features/LanguageServer/Protocol/Handler/SignatureHelp/SignatureHelpHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/SignatureHelp/SignatureHelpHandler.cs
@@ -33,7 +33,7 @@ public SignatureHelpHandler([ImportMany] IEnumerable<Lazy<ISignatureHelpProvider
         public async Task<LSP.SignatureHelp> HandleRequestAsync(Solution solution, LSP.TextDocumentPositionParams request,
             LSP.ClientCapabilities clientCapabilities, string? clientName, CancellationToken cancellationToken)
         {
-            var document = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var document = solution.GetDocument(request.TextDocument, clientName);
             if (document == null)
             {
                 return new LSP.SignatureHelp();
diff --git a/src/Features/LanguageServer/Protocol/Handler/Symbols/DocumentSymbolsHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Symbols/DocumentSymbolsHandler.cs
index a12e0e8209868..0ff8ec2dc05d2 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Symbols/DocumentSymbolsHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Symbols/DocumentSymbolsHandler.cs
@@ -32,7 +32,7 @@ public DocumentSymbolsHandler()
         public async Task<object[]> HandleRequestAsync(Solution solution, DocumentSymbolParams request,
             ClientCapabilities clientCapabilities, string clientName, CancellationToken cancellationToken)
         {
-            var document = solution.GetDocumentFromURI(request.TextDocument.Uri, clientName);
+            var document = solution.GetDocument(request.TextDocument, clientName);
             if (document == null)
             {
                 return Array.Empty<SymbolInformation>();
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs
index 9e0884d49ac2f..507bd4a67b99f 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentOnTypeTests.cs
@@ -37,7 +37,7 @@ void M()
             using var workspace = CreateTestWorkspace(markup, out var locations);
             var characterTyped = ";";
             var locationTyped = locations["type"].Single();
-            var documentText = await workspace.CurrentSolution.GetDocumentFromURI(locationTyped.Uri).GetTextAsync();
+            var documentText = await workspace.CurrentSolution.GetDocuments(locationTyped.Uri).Single().GetTextAsync();
 
             var results = await RunFormatDocumentOnTypeAsync(workspace.CurrentSolution, characterTyped, locationTyped);
             var actualText = ApplyTextEdits(results, documentText);
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentRangeTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentRangeTests.cs
index 1a34557d6a1bd..2e3bdb2a2b3b6 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentRangeTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentRangeTests.cs
@@ -34,7 +34,7 @@ void M()
 }";
             using var workspace = CreateTestWorkspace(markup, out var locations);
             var rangeToFormat = locations["format"].Single();
-            var documentText = await workspace.CurrentSolution.GetDocumentFromURI(rangeToFormat.Uri).GetTextAsync();
+            var documentText = await workspace.CurrentSolution.GetDocuments(rangeToFormat.Uri).Single().GetTextAsync();
 
             var results = await RunFormatDocumentRangeAsync(workspace.CurrentSolution, rangeToFormat);
             var actualText = ApplyTextEdits(results, documentText);
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentTests.cs
index 6c2ee9fd16888..4367a7a01699c 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/Formatting/FormatDocumentTests.cs
@@ -35,7 +35,7 @@ void M()
 }";
             using var workspace = CreateTestWorkspace(markup, out var locations);
             var documentURI = locations["caret"].Single().Uri;
-            var documentText = await workspace.CurrentSolution.GetDocumentFromURI(documentURI).GetTextAsync();
+            var documentText = await workspace.CurrentSolution.GetDocuments(documentURI).Single().GetTextAsync();
 
             var results = await RunFormatDocumentAsync(workspace.CurrentSolution, documentURI);
             var actualText = ApplyTextEdits(results, documentText);
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/Hover/HoverTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/Hover/HoverTests.cs
index fb4924a01f98f..a1e58199c8d7f 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/Hover/HoverTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/Hover/HoverTests.cs
@@ -136,9 +136,65 @@ private string Method(int i)
             Assert.Null(results);
         }
 
-        private static async Task<LSP.Hover> RunGetHoverAsync(Solution solution, LSP.Location caret)
+        // Test that if we pass a project context along to hover, the right context is chosen. We are using hover
+        // as a general proxy to test that our context tracking works in all cases, although there's nothing specific
+        // about hover that needs to be different here compared to any other feature.
+        [Fact]
+        public async Task TestGetHoverWithProjectContexts()
+        {
+            var source = @"
+using System;
+
+#if NET472
+
+class WithConstant
+{
+    public const string Target = ""Target in net472"";
+}
+
+#else
+
+class WithConstant
+{
+    public const string Target = ""Target in netcoreapp3.1"";
+}
+
+#endif
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        Console.WriteLine(WithConstant.{|caret:Target|});
+    }
+}";
+
+            var workspaceXml =
+$@"<Workspace>
+    <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""Net472"" PreprocessorSymbols=""NET472"">
+        <Document FilePath=""C:\C.cs""><![CDATA[${source}]]></Document>
+    </Project>
+    <Project Language=""C#"" CommonReferences=""true"" AssemblyName=""NetCoreApp3"" PreprocessorSymbols=""NETCOREAPP3.1"">
+        <Document IsLinkFile=""true"" LinkFilePath=""C:\C.cs"" LinkAssemblyName=""Net472""></Document>
+    </Project>
+</Workspace>";
+
+            using var workspace = CreateXmlTestWorkspace(workspaceXml, out var locations);
+            var location = locations["caret"].Single();
+
+            foreach (var project in workspace.Projects)
+            {
+                var result = await RunGetHoverAsync(workspace.CurrentSolution, location, project.Id);
+
+                var expectedConstant = project.Name == "Net472" ? "Target in net472" : "Target in netcoreapp3.1";
+                var expectedHover = CreateHover(location, $"({FeaturesResources.constant}) string WithConstant.Target = \"{expectedConstant}\"");
+                AssertJsonEquals(expectedHover, result);
+            }
+        }
+
+        private static async Task<LSP.Hover> RunGetHoverAsync(Solution solution, LSP.Location caret, ProjectId projectContext = null)
             => await GetLanguageServer(solution).ExecuteRequestAsync<LSP.TextDocumentPositionParams, LSP.Hover>(LSP.Methods.TextDocumentHoverName,
-                solution, CreateTextDocumentPositionParams(caret), new LSP.ClientCapabilities(), null, CancellationToken.None);
+                solution, CreateTextDocumentPositionParams(caret, projectContext), new LSP.ClientCapabilities(), null, CancellationToken.None);
 
         private static LSP.Hover CreateHover(LSP.Location location, string text)
             => new LSP.Hover()
diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs b/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs
index 6427939c576bd..3df0692c14167 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs
@@ -14,7 +14,6 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.ErrorReporting;
-using Microsoft.CodeAnalysis.ExternalAccess.Razor.Lsp;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.LanguageServer;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -49,7 +48,11 @@ public InProcLanguageServer(Stream inputStream, Stream outputStream, LanguageSer
             _protocol = protocol;
             _workspace = workspace;
 
-            _jsonRpc = new JsonRpc(outputStream, inputStream, this);
+            var jsonMessageFormatter = new JsonMessageFormatter();
+            jsonMessageFormatter.JsonSerializer.Converters.Add(new VSExtensionConverter<TextDocumentIdentifier, VSTextDocumentIdentifier>());
+
+            _jsonRpc = new JsonRpc(new HeaderDelimitedMessageHandler(outputStream, inputStream, jsonMessageFormatter));
+            _jsonRpc.AddLocalRpcTarget(this);
             _jsonRpc.StartListening();
 
             _diagnosticService = diagnosticService;
diff --git a/src/VisualStudio/LiveShare/Impl/AbstractClassificationsHandler.cs b/src/VisualStudio/LiveShare/Impl/AbstractClassificationsHandler.cs
index 2aefd18cfefbd..baab619918c43 100644
--- a/src/VisualStudio/LiveShare/Impl/AbstractClassificationsHandler.cs
+++ b/src/VisualStudio/LiveShare/Impl/AbstractClassificationsHandler.cs
@@ -28,8 +28,7 @@ internal abstract class AbstractClassificationsHandler : ILspRequestHandler<Clas
 
         public async Task<object[]> HandleAsync(ClassificationParams request, RequestContext<Solution> requestContext, CancellationToken cancellationToken)
         {
-            var actualDocumentURI = requestContext.ProtocolConverter.FromProtocolUri(request.TextDocument.Uri);
-            var document = requestContext.Context.GetDocumentFromURI(actualDocumentURI);
+            var document = requestContext.Context.GetDocument(request.TextDocument);
             var classificationService = document?.Project.LanguageServices.GetService<IClassificationService>();
 
             if (document == null || classificationService == null)
diff --git a/src/VisualStudio/LiveShare/Impl/AbstractGoToDefinitionWithFindUsagesServiceHandler.cs b/src/VisualStudio/LiveShare/Impl/AbstractGoToDefinitionWithFindUsagesServiceHandler.cs
index 3aaed127cc9ec..c18e60a9a2015 100644
--- a/src/VisualStudio/LiveShare/Impl/AbstractGoToDefinitionWithFindUsagesServiceHandler.cs
+++ b/src/VisualStudio/LiveShare/Impl/AbstractGoToDefinitionWithFindUsagesServiceHandler.cs
@@ -37,7 +37,7 @@ public async Task<object> HandleAsync(LSP.TextDocumentPositionParams request, Re
         {
             var solution = requestContext.Context;
 
-            var document = solution.GetDocumentFromURI(request.TextDocument.Uri);
+            var document = solution.GetDocument(request.TextDocument);
             if (document == null)
             {
                 return Array.Empty<LSP.Location>();
diff --git a/src/VisualStudio/LiveShare/Impl/Client/CodeActions/RoslynRemoteCodeAction.cs b/src/VisualStudio/LiveShare/Impl/Client/CodeActions/RoslynRemoteCodeAction.cs
index 385dd7a90fe7e..5af9f4b845359 100644
--- a/src/VisualStudio/LiveShare/Impl/Client/CodeActions/RoslynRemoteCodeAction.cs
+++ b/src/VisualStudio/LiveShare/Impl/Client/CodeActions/RoslynRemoteCodeAction.cs
@@ -105,7 +105,12 @@ protected override async Task<IEnumerable<CodeActionOperation>> ComputeOperation
             foreach (var changePair in _codeActionWorkspaceEdit.Changes)
             {
                 var documentName = await _lspClient.ProtocolConverter.FromProtocolUriAsync(new Uri(changePair.Key), true, cancellationToken).ConfigureAwait(false);
-                var doc = newSolution.GetDocumentFromURI(documentName);
+
+                // The document name here is a document URI that we're trying to apply an edit to. The edit was already computed on the
+                // server and we're trying to create an equivalent copy on the client; we're only fetching the text of the document
+                // rather than any syntax trees, and so it doesn't matter from which context we grab if there are linked files --
+                // all the files are the same and modifying any of them is fine.
+                var doc = newSolution.GetDocuments(documentName).First();
                 if (doc == null)
                 {
                     continue;
diff --git a/src/VisualStudio/LiveShare/Impl/PreviewCodeActionsHandler.cs b/src/VisualStudio/LiveShare/Impl/PreviewCodeActionsHandler.cs
index b98ba3471c91b..15c47073a6648 100644
--- a/src/VisualStudio/LiveShare/Impl/PreviewCodeActionsHandler.cs
+++ b/src/VisualStudio/LiveShare/Impl/PreviewCodeActionsHandler.cs
@@ -30,7 +30,7 @@ public PreviewCodeActionsHandler(ICodeFixService codeFixService, ICodeRefactorin
             var edits = ArrayBuilder<LSP.TextEdit>.GetInstance();
             var solution = requestContext.Context;
             var codeActions = await GetCodeActionsAsync(solution,
-                request.CodeActionParams.TextDocument.Uri,
+                request.CodeActionParams.TextDocument,
                 request.CodeActionParams.Range,
                 null, cancellationToken).ConfigureAwait(false);
 
@@ -41,7 +41,7 @@ public PreviewCodeActionsHandler(ICodeFixService codeFixService, ICodeRefactorin
                 var operations = await actionToRun.GetOperationsAsync(cancellationToken).ConfigureAwait(false);
                 var applyChangesOperation = operations.OfType<ApplyChangesOperation>().FirstOrDefault();
 
-                var document = solution.GetDocumentFromURI(request.CodeActionParams.TextDocument.Uri);
+                var document = solution.GetDocument(request.CodeActionParams.TextDocument);
                 var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
 
                 if (applyChangesOperation != null && document != null)
diff --git a/src/VisualStudio/LiveShare/Impl/RunCodeActionsHandler.cs b/src/VisualStudio/LiveShare/Impl/RunCodeActionsHandler.cs
index 616c7215f9fc6..ed1a643fcdb95 100644
--- a/src/VisualStudio/LiveShare/Impl/RunCodeActionsHandler.cs
+++ b/src/VisualStudio/LiveShare/Impl/RunCodeActionsHandler.cs
@@ -49,7 +49,7 @@ public async Task<object> HandleAsync(LSP.ExecuteCommandParams request, RequestC
             {
                 var runRequest = ((JToken)request.Arguments.Single()).ToObject<RunCodeActionParams>();
                 var codeActions = await GetCodeActionsAsync(requestContext.Context,
-                    runRequest.CodeActionParams.TextDocument.Uri,
+                    runRequest.CodeActionParams.TextDocument,
                     runRequest.CodeActionParams.Range,
                     null, cancellationToken).ConfigureAwait(false);
 

From 52b124a90c7bde1090dcb33054e2e67139cfa37c Mon Sep 17 00:00:00 2001
From: Jason Malinowski <jason.malinowski@microsoft.com>
Date: Fri, 15 May 2020 11:40:35 -0700
Subject: [PATCH 7/8] Now that we are using JsonConverters we can use that for
 VSClientCapabilities too

---
 .../LanguageClient/InProcLanguageServer.cs        | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs b/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs
index 3df0692c14167..8938098d4974a 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageClient/InProcLanguageServer.cs
@@ -21,7 +21,6 @@
 using Microsoft.VisualStudio.LanguageServer.Client;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 using Microsoft.VisualStudio.Utilities.Internal;
-using Newtonsoft.Json.Linq;
 using Roslyn.Utilities;
 using StreamJsonRpc;
 using LSP = Microsoft.VisualStudio.LanguageServer.Protocol;
@@ -50,6 +49,7 @@ public InProcLanguageServer(Stream inputStream, Stream outputStream, LanguageSer
 
             var jsonMessageFormatter = new JsonMessageFormatter();
             jsonMessageFormatter.JsonSerializer.Converters.Add(new VSExtensionConverter<TextDocumentIdentifier, VSTextDocumentIdentifier>());
+            jsonMessageFormatter.JsonSerializer.Converters.Add(new VSExtensionConverter<ClientCapabilities, VSClientCapabilities>());
 
             _jsonRpc = new JsonRpc(new HeaderDelimitedMessageHandler(outputStream, inputStream, jsonMessageFormatter));
             _jsonRpc.AddLocalRpcTarget(this);
@@ -67,15 +67,14 @@ public InProcLanguageServer(Stream inputStream, Stream outputStream, LanguageSer
         /// and responding with the server capabilities.
         /// The specification assures that the initialize request is sent only once.
         /// </summary>
-        [JsonRpcMethod(Methods.InitializeName)]
-        public async Task<InitializeResult> InitializeAsync(JToken input, CancellationToken cancellationToken)
+        [JsonRpcMethod(Methods.InitializeName, UseSingleObjectParameterDeserialization = true)]
+        public async Task<InitializeResult> InitializeAsync(InitializeParams initializeParams, CancellationToken cancellationToken)
         {
-            // InitializeParams only references ClientCapabilities, but the VS LSP client
-            // sends additional VS specific capabilities, so directly deserialize them into the VSClientCapabilities
-            // to avoid losing them.
-            _clientCapabilities = input["capabilities"].ToObject<VSClientCapabilities>();
+            _clientCapabilities = (VSClientCapabilities)initializeParams.Capabilities;
+
             var serverCapabilities = await _protocol.ExecuteRequestAsync<InitializeParams, InitializeResult>(Methods.InitializeName,
-                _workspace.CurrentSolution, input.ToObject<InitializeParams>(), _clientCapabilities, _clientName, cancellationToken).ConfigureAwait(false);
+                _workspace.CurrentSolution, initializeParams, _clientCapabilities, _clientName, cancellationToken).ConfigureAwait(false);
+
             // Always support hover - if any LSP client for a content type advertises support,
             // then the liveshare provider is disabled.  So we must provide for both C# and razor
             // until https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1106064/ is fixed

From 70e0d53e1f1b0c497c0e161028c6cda1fc612af3 Mon Sep 17 00:00:00 2001
From: Joey Robichaud <jorobich@microsoft.com>
Date: Mon, 18 May 2020 16:03:05 -0700
Subject: [PATCH 8/8] Update version and publish data for snap

---
 eng/Versions.props          | 2 +-
 eng/config/PublishData.json | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/eng/Versions.props b/eng/Versions.props
index d0db774a97c25..51fc9e6eb2279 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -8,7 +8,7 @@
     <MajorVersion>3</MajorVersion>
     <MinorVersion>7</MinorVersion>
     <PatchVersion>0</PatchVersion>
-    <PreReleaseVersionLabel>2</PreReleaseVersionLabel>
+    <PreReleaseVersionLabel>3</PreReleaseVersionLabel>
     <VersionPrefix>$(MajorVersion).$(MinorVersion).$(PatchVersion)</VersionPrefix>
     <!--
       By default the assembly version in official builds is "$(MajorVersion).$(MinorVersion).0.0".
diff --git a/eng/config/PublishData.json b/eng/config/PublishData.json
index dfd37461e16f8..ec02c1b6ccb26 100644
--- a/eng/config/PublishData.json
+++ b/eng/config/PublishData.json
@@ -72,13 +72,13 @@
       "vsBranch": "rel/d16.6",
       "vsMajorVersion": 16
     },
-    "release/dev16.7-preview1-vs-deps": {
+    "release/dev16.7-preview2-vs-deps": {
       "nugetKind": ["Shipping", "NonShipping"],
       "version": "3.7.*",
       "nuget": [ "https://dotnet.myget.org/F/roslyn/api/v2/package" ],
       "vsix": [ "https://dotnet.myget.org/F/roslyn/vsix/upload" ],
-      "channels": [ "dev16.7", "dev16.7p1" ],
-      "vsBranch": "rel/d16.7",
+      "channels": [ "dev16.7", "dev16.7p2" ],
+      "vsBranch": "master",
       "vsMajorVersion": 16
     },
     "master-vs-deps": {
@@ -86,7 +86,7 @@
       "version": "3.7.*",
       "nuget": [ "https://dotnet.myget.org/F/roslyn/api/v2/package" ],
       "vsix": [ "https://dotnet.myget.org/F/roslyn/vsix/upload" ],
-      "channels": [ "dev16.7", "dev16.7p2" ],
+      "channels": [ "dev16.7", "dev16.7p3" ],
       "vsBranch": "master",
       "vsMajorVersion": 16
     },