Adds support for metadata LSP language features in VSCode

src/EditorFeatures/CSharpTest/PdbSourceDocument/NullResultMetadataAsSourceFileProvider.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Composition;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Formatting;
@@ -47,8 +48,9 @@ public void CleanupGeneratedFiles(MetadataAsSourceWorkspace workspace)
         return null;
     }
 
-    public bool TryAddDocumentToWorkspace(MetadataAsSourceWorkspace workspace, string filePath, Text.SourceTextContainer sourceTextContainer)
+    public bool TryAddDocumentToWorkspace(MetadataAsSourceWorkspace workspace, string filePath, Text.SourceTextContainer sourceTextContainer, [NotNullWhen(true)] out DocumentId? documentId)
     {
+        documentId = null!;
         return true;
     }
 

src/EditorFeatures/Test/MetadataAsSource/AbstractMetadataAsSourceTests.TestContext.cs

@@ -300,7 +300,7 @@ internal Document GetDocument(MetadataAsSourceFile file)
             using var reader = File.OpenRead(file.FilePath);
             var stringText = EncodedStringText.Create(reader);
 
-            Assert.True(_metadataAsSourceService.TryAddDocumentToWorkspace(file.FilePath, stringText.Container));
+            Assert.True(_metadataAsSourceService.TryAddDocumentToWorkspace(file.FilePath, stringText.Container, out var _));
 
             return stringText.Container.GetRelatedDocuments().Single();
         }

src/Features/Core/Portable/MetadataAsSource/DecompilationMetadataAsSourceFileProvider.cs

@@ -6,6 +6,7 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Composition;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -33,6 +34,11 @@ internal class DecompilationMetadataAsSourceFileProvider(IImplementationAssembly
 {
     internal const string ProviderName = "Decompilation";
 
+    /// <summary>
+    /// Guards access to <see cref="_openedDocumentIds"/> and workspace updates when opening / closing documents.
+    /// </summary>
+    private readonly object _gate = new();
+
     /// <summary>
     /// Accessed only in <see cref="GetGeneratedFileAsync"/> and <see cref="CleanupGeneratedFiles"/>, both of which
     /// are called under a lock in <see cref="MetadataAsSourceFileService"/>.  So this is safe as a plain
@@ -271,17 +277,8 @@ private async Task<Location> RelocateSymbol_NoLockAsync(Solution solution, Metad
         return await MetadataAsSourceHelpers.GetLocationInGeneratedSourceAsync(symbolId, temporaryDocument, cancellationToken).ConfigureAwait(false);
     }
 
-    private static void AssertIsMainThread(MetadataAsSourceWorkspace workspace)
-    {
-        Contract.ThrowIfNull(workspace);
-        var threadingService = workspace.Services.GetRequiredService<IWorkspaceThreadingServiceProvider>().Service;
-        Contract.ThrowIfFalse(threadingService.IsOnMainThread);
-    }
-
     public bool ShouldCollapseOnOpen(MetadataAsSourceWorkspace workspace, string filePath, BlockStructureOptions blockStructureOptions)
     {
-        AssertIsMainThread(workspace);
-
         if (_generatedFilenameToInformation.TryGetValue(filePath, out var info))
         {
             return info.SignaturesOnly
@@ -292,45 +289,46 @@ public bool ShouldCollapseOnOpen(MetadataAsSourceWorkspace workspace, string fil
         return false;
     }
 
-    public bool TryAddDocumentToWorkspace(MetadataAsSourceWorkspace workspace, string filePath, SourceTextContainer sourceTextContainer)
+    public bool TryAddDocumentToWorkspace(MetadataAsSourceWorkspace workspace, string filePath, SourceTextContainer sourceTextContainer, [NotNullWhen(true)] out DocumentId? documentId)
     {
-        AssertIsMainThread(workspace);
-
-        if (_generatedFilenameToInformation.TryGetValue(filePath, out var fileInfo))
+        lock (_gate)
         {
-            Contract.ThrowIfTrue(_openedDocumentIds.ContainsKey(fileInfo));
+            if (_generatedFilenameToInformation.TryGetValue(filePath, out var fileInfo))
+            {
+                Contract.ThrowIfTrue(_openedDocumentIds.ContainsKey(fileInfo));
 
-            // We do own the file, so let's open it up in our workspace
-            var (projectInfo, documentId) = fileInfo.GetProjectInfoAndDocumentId(workspace.Services.SolutionServices, loadFileFromDisk: true);
+                // We do own the file, so let's open it up in our workspace
+                (var projectInfo, documentId) = fileInfo.GetProjectInfoAndDocumentId(workspace.Services.SolutionServices, loadFileFromDisk: true);
 
-            workspace.OnProjectAdded(projectInfo);
-            workspace.OnDocumentOpened(documentId, sourceTextContainer);
+                workspace.OnProjectAdded(projectInfo);
+                workspace.OnDocumentOpened(documentId, sourceTextContainer);
 
-            _openedDocumentIds = _openedDocumentIds.Add(fileInfo, documentId);
+                _openedDocumentIds = _openedDocumentIds.Add(fileInfo, documentId);
+                return true;
+            }
 
-            return true;
+            documentId = null;
+            return false;
         }
-
-        return false;
     }
 
     public bool TryRemoveDocumentFromWorkspace(MetadataAsSourceWorkspace workspace, string filePath)
     {
-        AssertIsMainThread(workspace);
-
-        if (_generatedFilenameToInformation.TryGetValue(filePath, out var fileInfo))
+        lock (_gate)
         {
-            if (_openedDocumentIds.ContainsKey(fileInfo))
-                return RemoveDocumentFromWorkspace(workspace, fileInfo);
-        }
+            if (_generatedFilenameToInformation.TryGetValue(filePath, out var fileInfo))
+            {
+                if (_openedDocumentIds.ContainsKey(fileInfo))
+                    return RemoveDocumentFromWorkspace_NoLock(workspace, fileInfo);
+            }
 
-        return false;
+            return false;
+        }
     }
 
-    private bool RemoveDocumentFromWorkspace(MetadataAsSourceWorkspace workspace, MetadataAsSourceGeneratedFileInfo fileInfo)
+    private bool RemoveDocumentFromWorkspace_NoLock(MetadataAsSourceWorkspace workspace, MetadataAsSourceGeneratedFileInfo fileInfo)
     {
-        AssertIsMainThread(workspace);
-
+        // Serial access is guaranteed by the caller.
         var documentId = _openedDocumentIds.GetValueOrDefault(fileInfo);
         Contract.ThrowIfNull(documentId);
 
@@ -359,16 +357,19 @@ private bool RemoveDocumentFromWorkspace(MetadataAsSourceWorkspace workspace, Me
 
     public void CleanupGeneratedFiles(MetadataAsSourceWorkspace workspace)
     {
-        // Clone the list so we don't break our own enumeration
-        foreach (var generatedFileInfo in _generatedFilenameToInformation.Values.ToList())
+        lock (_gate)
         {
-            if (_openedDocumentIds.ContainsKey(generatedFileInfo))
-                RemoveDocumentFromWorkspace(workspace, generatedFileInfo);
-        }
+            // Clone the list so we don't break our own enumeration
+            foreach (var generatedFileInfo in _generatedFilenameToInformation.Values.ToList())
+            {
+                if (_openedDocumentIds.ContainsKey(generatedFileInfo))
+                    RemoveDocumentFromWorkspace_NoLock(workspace, generatedFileInfo);
+            }
 
-        _generatedFilenameToInformation.Clear();
-        _keyToInformation.Clear();
-        Contract.ThrowIfFalse(_openedDocumentIds.IsEmpty);
+            _generatedFilenameToInformation.Clear();
+            _keyToInformation.Clear();
+            Contract.ThrowIfFalse(_openedDocumentIds.IsEmpty);
+        }
     }
 
     private static async Task<UniqueDocumentKey> GetUniqueDocumentKeyAsync(Project project, INamedTypeSymbol topLevelNamedType, bool signaturesOnly, CancellationToken cancellationToken)

src/Features/Core/Portable/MetadataAsSource/IMetadataAsSourceFileProvider.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Formatting;
@@ -36,7 +37,7 @@ internal interface IMetadataAsSourceFileProvider
     /// Called when the file returned from <see cref="GetGeneratedFileAsync"/> needs to be added to the workspace,
     /// to be opened.  Will be called on the main thread of the workspace host.
     /// </summary>
-    bool TryAddDocumentToWorkspace(MetadataAsSourceWorkspace workspace, string filePath, SourceTextContainer sourceTextContainer);
+    bool TryAddDocumentToWorkspace(MetadataAsSourceWorkspace workspace, string filePath, SourceTextContainer sourceTextContainer, [NotNullWhen(true)] out DocumentId? documentId);
 
     /// <summary>
     /// Called when the file is being closed, and so needs to be removed from the workspace.  Will be called on the

src/Features/Core/Portable/MetadataAsSource/IMetadataAsSourceFileService.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Formatting;
@@ -31,8 +32,16 @@ Task<MetadataAsSourceFile> GetGeneratedFileAsync(
         MetadataAsSourceOptions options,
         CancellationToken cancellationToken);
 
-    bool TryAddDocumentToWorkspace(string filePath, SourceTextContainer buffer);
+    /// <summary>
+    /// Checks if the given file path is a metadata as source file and adds to the metadata workspace if it is.
+    /// Callers must ensure this is only called serially.
+    /// </summary>
+    bool TryAddDocumentToWorkspace(string filePath, SourceTextContainer sourceTextContainer, [NotNullWhen(true)] out DocumentId? documentId);
 
+    /// <summary>
+    /// Checks if the given file path is a metadata as source file and removes from the metadata workspace if it is.
+    /// Callers must ensure this is only called serially.
+    /// </summary>
     bool TryRemoveDocumentFromWorkspace(string filePath);
 
     bool IsNavigableMetadataSymbol(ISymbol symbol);

src/Features/Core/Portable/MetadataAsSource/MetadataAsSourceFileService.cs

@@ -6,12 +6,12 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Composition;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.ErrorReporting;
-using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.Utilities;
@@ -163,26 +163,27 @@ private static void AssertIsMainThread(MetadataAsSourceWorkspace workspace)
         Contract.ThrowIfFalse(threadingService.IsOnMainThread);
     }
 
-    public bool TryAddDocumentToWorkspace(string filePath, SourceTextContainer sourceTextContainer)
+    public bool TryAddDocumentToWorkspace(string filePath, SourceTextContainer sourceTextContainer, [NotNullWhen(true)] out DocumentId? documentId)
     {
         // If we haven't even created a MetadataAsSource workspace yet, then this file definitely cannot be added to
         // it. This happens when the MiscWorkspace calls in to just see if it can attach this document to the
         // MetadataAsSource instead of itself.
         var workspace = _workspace;
         if (workspace != null)
         {
-            AssertIsMainThread(workspace);
-
             foreach (var provider in _providers.Value)
             {
                 if (!provider.IsValueCreated)
                     continue;
 
-                if (provider.Value.TryAddDocumentToWorkspace(workspace, filePath, sourceTextContainer))
+                if (provider.Value.TryAddDocumentToWorkspace(workspace, filePath, sourceTextContainer, out documentId))
+                {
                     return true;
+                }
             }
         }
 
+        documentId = null;
         return false;
     }
 
@@ -194,8 +195,6 @@ public bool TryRemoveDocumentFromWorkspace(string filePath)
         var workspace = _workspace;
         if (workspace != null)
         {
-            AssertIsMainThread(workspace);
-
             foreach (var provider in _providers.Value)
             {
                 if (!provider.IsValueCreated)

src/Features/Core/Portable/PdbSourceDocument/PdbSourceDocumentMetadataAsSourceFileProvider.cs

@@ -7,6 +7,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Composition;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Reflection.Metadata.Ecma335;
@@ -43,6 +44,11 @@ internal sealed class PdbSourceDocumentMetadataAsSourceFileProvider(
     private readonly IImplementationAssemblyLookupService _implementationAssemblyLookupService = implementationAssemblyLookupService;
     private readonly IPdbSourceDocumentLogger? _logger = logger;
 
+    /// <summary>
+    /// Lock to guard access to workspace updates when opening / closing documents.
+    /// </summary>
+    private readonly object _gate = new();
+
     /// <summary>
     /// Accessed only in <see cref="GetGeneratedFileAsync"/> and <see cref="CleanupGeneratedFiles"/>, both of which
     /// are called under a lock in <see cref="MetadataAsSourceFileService"/>.  So this is safe as a plain
@@ -342,43 +348,39 @@ private ImmutableArray<DocumentInfo> CreateDocumentInfos(
         return documents.ToImmutableAndClear();
     }
 
-    private static void AssertIsMainThread(MetadataAsSourceWorkspace workspace)
-    {
-        Contract.ThrowIfNull(workspace);
-        var threadingService = workspace.Services.GetRequiredService<IWorkspaceThreadingServiceProvider>().Service;
-        Contract.ThrowIfFalse(threadingService.IsOnMainThread);
-    }
-
     public bool ShouldCollapseOnOpen(MetadataAsSourceWorkspace workspace, string filePath, BlockStructureOptions blockStructureOptions)
     {
-        AssertIsMainThread(workspace);
         return _fileToDocumentInfoMap.TryGetValue(filePath, out _) && blockStructureOptions.CollapseMetadataImplementationsWhenFirstOpened;
     }
 
-    public bool TryAddDocumentToWorkspace(MetadataAsSourceWorkspace workspace, string filePath, SourceTextContainer sourceTextContainer)
+    public bool TryAddDocumentToWorkspace(MetadataAsSourceWorkspace workspace, string filePath, SourceTextContainer sourceTextContainer, [NotNullWhen(true)] out DocumentId? documentId)
     {
-        AssertIsMainThread(workspace);
-
-        if (_fileToDocumentInfoMap.TryGetValue(filePath, out var info))
+        lock (_gate)
         {
-            workspace.OnDocumentOpened(info.DocumentId, sourceTextContainer);
-            return true;
-        }
+            if (_fileToDocumentInfoMap.TryGetValue(filePath, out var info))
+            {
+                workspace.OnDocumentOpened(info.DocumentId, sourceTextContainer);
+                documentId = info.DocumentId;
+                return true;
+            }
 
-        return false;
+            documentId = null;
+            return false;
+        }
     }
 
     public bool TryRemoveDocumentFromWorkspace(MetadataAsSourceWorkspace workspace, string filePath)
     {
-        AssertIsMainThread(workspace);
-
-        if (_fileToDocumentInfoMap.TryGetValue(filePath, out var info))
+        lock (_gate)
         {
-            workspace.OnDocumentClosed(info.DocumentId, new WorkspaceFileTextLoader(workspace.Services.SolutionServices, filePath, info.Encoding));
-            return true;
-        }
+            if (_fileToDocumentInfoMap.TryGetValue(filePath, out var info))
+            {
+                workspace.OnDocumentClosed(info.DocumentId, new WorkspaceFileTextLoader(workspace.Services.SolutionServices, filePath, info.Encoding));
+                return true;
+            }
 
-        return false;
+            return false;
+        }
     }
 
     public Project? MapDocument(Document document)

src/LanguageServer/Protocol/RoslynLanguageServer.cs

@@ -99,7 +99,7 @@ private FrozenDictionary<string, ImmutableArray<BaseService>> GetBaseServices(
             // those cases, we do not need to add an additional workspace to manage new files we hear about.  So only
             // add the LspMiscellaneousFilesWorkspace for hosts that have not already brought their own.
             if (serverKind == WellKnownLspServerKinds.CSharpVisualBasicLspServer)
-                AddLazyService<LspMiscellaneousFilesWorkspace>(lspServices => new LspMiscellaneousFilesWorkspace(lspServices, hostServices));
+                AddLazyService<LspMiscellaneousFilesWorkspace>(lspServices => lspServices.GetRequiredService<LspMiscellaneousFilesWorkspaceProvider>().CreateLspMiscellaneousFilesWorkspace(lspServices, hostServices));
 
             return baseServiceMap.ToFrozenDictionary(
                 keySelector: kvp => kvp.Key,