Improve initialization, logging, and add more features to cohosting in VS Code (#11788)

Part of #11759

Commit-at-a-time probably makes sense, there are a few things here

Goes with dotnet/vscode-csharp#8218

Author: davidwengier

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/EndpointContracts/IRazorNotificationHandler.cs

@@ -5,7 +5,7 @@
 
 namespace Microsoft.AspNetCore.Razor.LanguageServer.EndpointContracts;
 
-internal interface IRazorNotificationHandler<TRequestType> : INotificationHandler<TRequestType, RazorRequestContext>
+internal interface IRazorNotificationHandler<TRequest> : INotificationHandler<TRequest, RazorRequestContext>
 {
 }
 

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Cohost/CohostCodeActionsEndpoint.cs renamed to src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/CodeActions/CohostCodeActionsEndpoint.cs

@@ -4,13 +4,15 @@
 using System;
 using System.Collections.Immutable;
 using System.Composition;
+using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Razor;
 using Microsoft.AspNetCore.Razor.LanguageServer.Hosting;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor.Cohost;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor.Cohost.Handlers;
+using Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
 using Microsoft.CodeAnalysis.Razor.CodeActions;
 using Microsoft.CodeAnalysis.Razor.CodeActions.Models;
 using Microsoft.CodeAnalysis.Razor.Protocol;
@@ -24,7 +26,7 @@ namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
 [Shared]
 [CohostEndpoint(Methods.TextDocumentCodeActionName)]
 [Export(typeof(IDynamicRegistrationProvider))]
-[ExportCohostStatelessLspService(typeof(CohostCodeActionsEndpoint))]
+[ExportRazorStatelessLspService(typeof(CohostCodeActionsEndpoint))]
 [method: ImportingConstructor]
 #pragma warning restore RS0030 // Do not use banned APIs
 internal sealed class CohostCodeActionsEndpoint(
@@ -80,9 +82,15 @@ public ImmutableArray<Registration> GetRegistrations(VSInternalClientCapabilitie
             return null;
         }
 
+        // This is just to prevent a warning for an unused field in the VS Code extension
+        Debug.Assert(_requestInvoker is not null);
+
         var delegatedCodeActions = requestInfo.LanguageKind switch
         {
+            // We don't support Html code actions in VS Code
+#if !VSCODE
             RazorLanguageKind.Html => await GetHtmlCodeActionsAsync(razorDocument, request, correlationId, cancellationToken).ConfigureAwait(false),
+#endif
             RazorLanguageKind.CSharp => await GetCSharpCodeActionsAsync(razorDocument, requestInfo.CSharpRequest.AssumeNotNull(), correlationId, cancellationToken).ConfigureAwait(false),
             _ => []
         };
@@ -110,6 +118,7 @@ private async Task<RazorVSInternalCodeAction[]> GetCSharpCodeActionsAsync(TextDo
         return JsonHelpers.ConvertAll<CodeAction, RazorVSInternalCodeAction>(csharpCodeActions);
     }
 
+#if !VSCODE
     private async Task<RazorVSInternalCodeAction[]> GetHtmlCodeActionsAsync(TextDocument razorDocument, VSCodeActionParams request, Guid correlationId, CancellationToken cancellationToken)
     {
         var result = await _requestInvoker.MakeHtmlLspRequestAsync<VSCodeActionParams, RazorVSInternalCodeAction[]>(
@@ -127,6 +136,7 @@ private async Task<RazorVSInternalCodeAction[]> GetHtmlCodeActionsAsync(TextDocu
 
         return result;
     }
+#endif
 
     internal TestAccessor GetTestAccessor() => new(this);
 

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Cohost/CohostCodeActionsResolveEndpoint.cs renamed to src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/CodeActions/CohostCodeActionsResolveEndpoint.cs

@@ -10,32 +10,38 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor.Cohost;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor.Cohost.Handlers;
+using Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
 using Microsoft.CodeAnalysis.Razor.CodeActions;
 using Microsoft.CodeAnalysis.Razor.CodeActions.Models;
 using Microsoft.CodeAnalysis.Razor.Formatting;
 using Microsoft.CodeAnalysis.Razor.Protocol;
 using Microsoft.CodeAnalysis.Razor.Remote;
-using Microsoft.VisualStudio.Razor.Settings;
+using Microsoft.CodeAnalysis.Razor.Workspaces.Settings;
 
 namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
 
 #pragma warning disable RS0030 // Do not use banned APIs
+#if !VSCODE
+// Visual Studio requires us to register for every method name, VS Code correctly realises that if you
+// register for code actions, and say you have resolve support, then registering for resolve is unnecessary.
+// In fact it's an error.
+[Export(typeof(IDynamicRegistrationProvider))]
+#endif
 [Shared]
 [CohostEndpoint(Methods.CodeActionResolveName)]
-[Export(typeof(IDynamicRegistrationProvider))]
-[ExportCohostStatelessLspService(typeof(CohostCodeActionsResolveEndpoint))]
+[ExportRazorStatelessLspService(typeof(CohostCodeActionsResolveEndpoint))]
 [method: ImportingConstructor]
 #pragma warning restore RS0030 // Do not use banned APIs
 internal sealed class CohostCodeActionsResolveEndpoint(
     IRemoteServiceInvoker remoteServiceInvoker,
     IClientCapabilitiesService clientCapabilitiesService,
-    IClientSettingsManager clientSettingsManager,
+    IClientSettingsReader clientSettingsManager,
     IHtmlRequestInvoker requestInvoker)
     : AbstractRazorCohostDocumentRequestHandler<CodeAction, CodeAction?>, IDynamicRegistrationProvider
 {
     private readonly IRemoteServiceInvoker _remoteServiceInvoker = remoteServiceInvoker;
     private readonly IClientCapabilitiesService _clientCapabilitiesService = clientCapabilitiesService;
-    private readonly IClientSettingsManager _clientSettingsManager = clientSettingsManager;
+    private readonly IClientSettingsReader _clientSettingsManager = clientSettingsManager;
     private readonly IHtmlRequestInvoker _requestInvoker = requestInvoker;
 
     protected override bool MutatesSolutionState => false;

src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/CohostStartupService.cs

@@ -5,45 +5,49 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.ComponentModel.Composition;
+using System.Linq;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor.Cohost;
+using Microsoft.CodeAnalysis.Razor.Logging;
 using Microsoft.CodeAnalysis.Razor.Protocol;
-using Microsoft.CodeAnalysis.Razor.Workspaces;
 
 namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
 
 [Export(typeof(ICohostStartupService))]
 [method: ImportingConstructor]
-internal class CohostStartupService(
-    LanguageServerFeatureOptions languageServerFeatureOptions,
-    [ImportMany] IEnumerable<Lazy<IRazorCohostStartupService>> lazyStartupServices)
-    : ICohostStartupService
+internal sealed class CohostStartupService(
+    [ImportMany] IEnumerable<Lazy<IRazorCohostStartupService>> lazyStartupServices,
+    ILoggerFactory loggerFactory) : ICohostStartupService
 {
-    private readonly LanguageServerFeatureOptions _languageServerFeatureOptions = languageServerFeatureOptions;
     private readonly ImmutableArray<Lazy<IRazorCohostStartupService>> _lazyStartupServices = [.. lazyStartupServices];
+    private readonly ILogger _logger = loggerFactory.GetOrCreateLogger<CohostStartupService>();
 
     public async Task StartupAsync(string clientCapabilitiesString, RazorCohostRequestContext requestContext, CancellationToken cancellationToken)
     {
         var clientCapabilities = JsonSerializer.Deserialize<VSInternalClientCapabilities>(clientCapabilitiesString, JsonHelpers.JsonSerializerOptions) ?? new();
 
-        // We want to make sure LanguageServerFeatureOptions is initialized first, so decisions can be made based on flags,
-        // and we also ensure we have a RazorClientLanguageServerManager available for anything that needs to call back to the client,
-        // so we do those two things first, manually.
-        if (_languageServerFeatureOptions is IRazorCohostStartupService startupService)
-        {
-            await startupService.StartupAsync(clientCapabilities, requestContext, cancellationToken).ConfigureAwait(false);
-        }
+        var providers = _lazyStartupServices.Select(p => p.Value).OrderByAsArray(p => p.Order);
 
-        if (!_languageServerFeatureOptions.UseRazorCohostServer)
+        foreach (var provider in providers)
         {
-            return;
-        }
+            if (cancellationToken.IsCancellationRequested)
+            {
+                _logger.LogInformation($"Razor extension startup cancelled.");
+                return;
+            }
 
-        foreach (var provider in _lazyStartupServices)
-        {
-            await provider.Value.StartupAsync(clientCapabilities, requestContext, cancellationToken).ConfigureAwait(false);
+            try
+            {
+                await provider.StartupAsync(clientCapabilities, requestContext, cancellationToken).ConfigureAwait(false);
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+                _logger.LogError(ex, $"Error initializing Razor startup service '{provider.GetType().Name}'");
+            }
         }
+
+        _logger.LogInformation($"Razor extension startup finished.");
     }
 }

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Cohost/CohostCompletionListCache.cs renamed to src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/Completion/CohostCompletionListCache.cs

@@ -11,6 +11,7 @@
 using Microsoft.AspNetCore.Razor.PooledObjects;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor.Cohost;
+using Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
 using Microsoft.CodeAnalysis.Razor.Completion;
 using Microsoft.CodeAnalysis.Razor.Completion.Delegation;
 using Microsoft.CodeAnalysis.Razor.Logging;
@@ -19,8 +20,7 @@
 using Microsoft.CodeAnalysis.Razor.Remote;
 using Microsoft.CodeAnalysis.Razor.Telemetry;
 using Microsoft.CodeAnalysis.Razor.Workspaces;
-using Microsoft.VisualStudio.Razor.Settings;
-using Microsoft.VisualStudio.Razor.Snippets;
+using Microsoft.CodeAnalysis.Razor.Workspaces.Settings;
 using Response = Microsoft.CodeAnalysis.Razor.Remote.RemoteResponse<Roslyn.LanguageServer.Protocol.RazorVSInternalCompletionList?>;
 
 namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
@@ -29,14 +29,16 @@ namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
 [Shared]
 [CohostEndpoint(Methods.TextDocumentCompletionName)]
 [Export(typeof(IDynamicRegistrationProvider))]
-[ExportCohostStatelessLspService(typeof(CohostDocumentCompletionEndpoint))]
+[ExportRazorStatelessLspService(typeof(CohostDocumentCompletionEndpoint))]
 [method: ImportingConstructor]
 #pragma warning restore RS0030 // Do not use banned APIs
 internal sealed class CohostDocumentCompletionEndpoint(
     IRemoteServiceInvoker remoteServiceInvoker,
-    IClientSettingsManager clientSettingsManager,
+    IClientSettingsReader clientSettingsManager,
     IClientCapabilitiesService clientCapabilitiesService,
-    SnippetCompletionItemProvider snippetCompletionItemProvider,
+#pragma warning disable RS0030 // Do not use banned APIs
+    [Import(AllowDefault = true)] ISnippetCompletionItemProvider? snippetCompletionItemProvider,
+#pragma warning restore RS0030 // Do not use banned APIs
     LanguageServerFeatureOptions languageServerFeatureOptions,
     IHtmlRequestInvoker requestInvoker,
     CompletionListCache completionListCache,
@@ -45,9 +47,9 @@ internal sealed class CohostDocumentCompletionEndpoint(
     : AbstractRazorCohostDocumentRequestHandler<CompletionParams, RazorVSInternalCompletionList?>, IDynamicRegistrationProvider
 {
     private readonly IRemoteServiceInvoker _remoteServiceInvoker = remoteServiceInvoker;
-    private readonly IClientSettingsManager _clientSettingsManager = clientSettingsManager;
+    private readonly IClientSettingsReader _clientSettingsManager = clientSettingsManager;
     private readonly IClientCapabilitiesService _clientCapabilitiesService = clientCapabilitiesService;
-    private readonly SnippetCompletionItemProvider _snippetCompletionItemProvider = snippetCompletionItemProvider;
+    private readonly ISnippetCompletionItemProvider? _snippetCompletionItemProvider = snippetCompletionItemProvider;
     private readonly CompletionTriggerAndCommitCharacters _triggerAndCommitCharacters = new(languageServerFeatureOptions);
     private readonly IHtmlRequestInvoker _requestInvoker = requestInvoker;
     private readonly CompletionListCache _completionListCache = completionListCache;
@@ -194,7 +196,8 @@ public ImmutableArray<Registration> GetRegistrations(VSInternalClientCapabilitie
             combinedCompletionList = htmlCompletionList;
         }
 
-        if (completionPositionInfo.ShouldIncludeDelegationSnippets)
+        if (completionPositionInfo.ShouldIncludeDelegationSnippets &&
+            _snippetCompletionItemProvider is not null)
         {
             combinedCompletionList = AddSnippets(
                 combinedCompletionList,
@@ -250,11 +253,11 @@ public ImmutableArray<Registration> GetRegistrations(VSInternalClientCapabilitie
         string? triggerCharacter)
     {
         using var builder = new PooledArrayBuilder<VSInternalCompletionItem>();
-        _snippetCompletionItemProvider.AddSnippetCompletions(
+        _snippetCompletionItemProvider.AssumeNotNull().AddSnippetCompletions(
+            ref builder.AsRef(),
             languageKind,
             invokeKind,
-            triggerCharacter,
-            ref builder.AsRef());
+            triggerCharacter);
 
         // If there were no snippets, just return the original list
         if (builder.Count == 0)

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Cohost/CohostDocumentCompletionEndpoint.cs renamed to src/Razor/src/Microsoft.CodeAnalysis.Razor.CohostingShared/Completion/CohostDocumentCompletionEndpoint.cs

@@ -9,34 +9,40 @@
 using Microsoft.AspNetCore.Razor;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor.Cohost;
+using Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
 using Microsoft.CodeAnalysis.Razor.Completion;
 using Microsoft.CodeAnalysis.Razor.Completion.Delegation;
 using Microsoft.CodeAnalysis.Razor.Formatting;
 using Microsoft.CodeAnalysis.Razor.Logging;
 using Microsoft.CodeAnalysis.Razor.Protocol;
 using Microsoft.CodeAnalysis.Razor.Remote;
-using Microsoft.VisualStudio.Razor.Settings;
+using Microsoft.CodeAnalysis.Razor.Workspaces.Settings;
 
 namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
 
 #pragma warning disable RS0030 // Do not use banned APIs
+#if !VSCODE
+// Visual Studio requires us to register for every method name, VS Code correctly realises that if you
+// register for code actions, and say you have resolve support, then registering for resolve is unnecessary.
+// In fact it's an error.
+[Export(typeof(IDynamicRegistrationProvider))]
+#endif
 [Shared]
 [CohostEndpoint(Methods.TextDocumentCompletionResolveName)]
-[Export(typeof(IDynamicRegistrationProvider))]
-[ExportCohostStatelessLspService(typeof(CohostDocumentCompletionResolveEndpoint))]
+[ExportRazorStatelessLspService(typeof(CohostDocumentCompletionResolveEndpoint))]
 [method: ImportingConstructor]
 #pragma warning restore RS0030 // Do not use banned APIs
 internal sealed class CohostDocumentCompletionResolveEndpoint(
     CompletionListCache completionListCache,
     IRemoteServiceInvoker remoteServiceInvoker,
-    IClientSettingsManager clientSettingsManager,
+    IClientSettingsReader clientSettingsManager,
     IHtmlRequestInvoker requestInvoker,
     ILoggerFactory loggerFactory)
     : AbstractRazorCohostDocumentRequestHandler<VSInternalCompletionItem, VSInternalCompletionItem?>, IDynamicRegistrationProvider
 {
     private readonly CompletionListCache _completionListCache = completionListCache;
     private readonly IRemoteServiceInvoker _remoteServiceInvoker = remoteServiceInvoker;
-    private readonly IClientSettingsManager _clientSettingsManager = clientSettingsManager;
+    private readonly IClientSettingsReader _clientSettingsManager = clientSettingsManager;
     private readonly IHtmlRequestInvoker _requestInvoker = requestInvoker;
     private readonly ILogger _logger = loggerFactory.GetOrCreateLogger<CohostDocumentCompletionEndpoint>();
 
@@ -92,8 +98,17 @@ public ImmutableArray<Registration> GetRegistrations(VSInternalClientCapabilitie
         {
             Debug.Assert(delegatedContext.ProjectedKind == RazorLanguageKind.Html);
 
+#if VSCODE
+            Debug.Assert(_requestInvoker is not null);
+            Debug.Assert(_logger is not null);
+            Debug.Assert(nameof(DelegatedCompletionHelper).Length > 0);
+
+            // We don't support completion resolve in VS Code
+            return completionItem;
+#else
             completionItem.Data = DelegatedCompletionHelper.GetOriginalCompletionItemData(completionItem, completionList, delegatedContext.OriginalCompletionListData);
             return await ResolveHtmlCompletionItemAsync(completionItem, razorDocument, cancellationToken).ConfigureAwait(false);
+#endif
         }
 
         var clientSettings = _clientSettingsManager.GetClientSettings();
@@ -119,6 +134,7 @@ public ImmutableArray<Registration> GetRegistrations(VSInternalClientCapabilitie
         return result;
     }
 
+#if !VSCODE
     private async Task<VSInternalCompletionItem> ResolveHtmlCompletionItemAsync(
         VSInternalCompletionItem request,
         TextDocument razorDocument,
@@ -134,6 +150,7 @@ private async Task<VSInternalCompletionItem> ResolveHtmlCompletionItemAsync(
 
         return result ?? request;
     }
+#endif
 
     internal TestAccessor GetTestAccessor() => new(this);