Working...

Author: Andrew Hall

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Cohost/CohostDocumentPullDiagnosticsEndpoint.cs

@@ -10,7 +10,6 @@
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Razor;
 using Microsoft.AspNetCore.Razor.PooledObjects;
-using Microsoft.AspNetCore.Razor.ProjectSystem;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor.Cohost;
 using Microsoft.CodeAnalysis.Razor.Logging;

src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Endpoints/RazorDynamicFileChangedEndpoint.cs

@@ -7,16 +7,17 @@
 namespace Microsoft.VisualStudioCode.RazorExtension.Endpoints;
 
 [Shared]
-[RazorVSCodeEndpoint("razor/dynamicFileInfoChanged")]
+[ExportRazorStatelessLspService(typeof(RazorDynamicFileChangedEndpoint))]
+[RazorEndpoint("razor/dynamicFileInfoChanged")]
 internal class RazorDynamicFileChangedEndpoint : AbstractRazorNotificationHandler<RazorDynamicFileChangedParams>
 {
     public override bool MutatesSolutionState => false;
 
-    public override bool RequiresLSPSolution => throw new NotImplementedException();
+    public override bool RequiresLSPSolution => false;
 
     protected override Task HandleNotificationAsync(RazorDynamicFileChangedParams request, RazorRequestContext context, CancellationToken cancellationToken)
     {
-        var dynamicFileInfoProvider = context.GetRequiredService<IRazorLspDynamicFileInfoProvider>();
+        var dynamicFileInfoProvider = context.GetRequiredService<RazorLspDynamicFileInfoProvider>();
         dynamicFileInfoProvider.Update(request.RazorDocument.Uri);
 
         return Task.CompletedTask;

src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Endpoints/RazorInitializeEndpoint.cs

@@ -0,0 +1,32 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System.Composition;
+using System.Text.Json.Serialization;
+using Microsoft.AspNetCore.Razor;
+using Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
+
+namespace Microsoft.VisualStudioCode.RazorExtension.Endpoints;
+
+[Shared]
+[ExportRazorStatelessLspService(typeof(RazorInitializeEndpoint))]
+[RazorEndpoint("razor/initialize")]
+internal class RazorInitializeEndpoint : AbstractRazorNotificationHandler<RazorInitializeParams>
+{
+    public override bool MutatesSolutionState => false;
+
+    public override bool RequiresLSPSolution => true;
+
+    protected override Task HandleNotificationAsync(RazorInitializeParams request, RazorRequestContext requestContext, CancellationToken cancellationToken)
+    {
+        var workspaceService = requestContext.GetRequiredService<RazorWorkspaceService>();
+        workspaceService.Initialize(requestContext.Workspace.AssumeNotNull(), request.PipeName);
+        return Task.CompletedTask;
+    }
+}
+
+internal class RazorInitializeParams
+{
+    [JsonPropertyName("pipeName")]
+    public required string PipeName { get; set; }
+}

src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Microsoft.VisualStudioCode.RazorExtension.csproj

@@ -8,13 +8,17 @@
     <!-- Ensure we run our custom target, below, to copy compiler project references -->
     <TargetsForTfmSpecificBuildOutput>$(TargetsForTfmSpecificBuildOutput);CopyProjectReferencesToPackage</TargetsForTfmSpecificBuildOutput>
   </PropertyGroup>
+  <ItemGroup>
+    <Compile Remove="S:\razor\src\Shared\files\LanguageSupport\IsExternalInit.cs" />
+  </ItemGroup>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
     <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" />
     <PackageReference Include="Microsoft.Extensions.ObjectPool" />
     <PackageReference Include="Microsoft.Extensions.Logging" />
     <PackageReference Include="Microsoft.CodeAnalysis.ExternalAccess.Razor.Features" />
+    <PackageReference Include="Microsoft.VisualStudio.LanguageServer.Protocol" GeneratePathProperty="True" />
   </ItemGroup>
 
   <ItemGroup>
@@ -27,14 +31,17 @@
     <InternalsVisibleTo Include="Microsoft.VisualStudioCode.RazorExtension.Test" Key="$(RazorKey)" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Content Include="$(PkgMicrosoft_VisualStudio_LanguageServer_Protocol)\lib\netstandard2.0\Microsoft.VisualStudio.LanguageServer.Protocol.dll" Pack="true" PackagePath="content" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
   <!--
     Include the build output of project references in the package created. We need to do this because the compiler packages
     are published via a separate process to tooling, so anything that references this package will try to transitively pull
     in the compiler packages, but will be unable to find packages with the same version.
 
     This means we end up with the package for this project including the following additional DLLs:
       * Microsoft.CodeAnalysis.Razor.Compiler.dll
-      * Microsoft.AspNetCore.Razor.ProjectEngineHost.dll
       * Microsoft.AspNetCore.Razor.Utilities.Shared.dll
 
     (and Microsoft.VisualStudioCode.RazorExtension.dll obviously)

src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/PublicAPI.Unshipped.txt

@@ -1,6 +1 @@
-#nullable enable
-Microsoft.VisualStudioCode.RazorExtension.RazorWorkspaceListener
-Microsoft.VisualStudioCode.RazorExtension.RazorWorkspaceListener.EnsureInitialized(Microsoft.CodeAnalysis.Workspace! workspace, string! pipeName) -> void
-Microsoft.VisualStudioCode.RazorExtension.RazorWorkspaceListener.RazorWorkspaceListener(Microsoft.Extensions.Logging.ILoggerFactory! loggerFactory) -> void
-Microsoft.VisualStudioCode.RazorExtension.RazorWorkspaceListenerBase
-Microsoft.VisualStudioCode.RazorExtension.RazorWorkspaceListenerBase.NotifyDynamicFile(Microsoft.CodeAnalysis.ProjectId! projectId) -> void
+#nullable enable

src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/RazorWorkspaceListener.cs

@@ -7,9 +7,9 @@
 
 namespace Microsoft.VisualStudioCode.RazorExtension;
 
-public sealed class RazorWorkspaceListener : RazorWorkspaceListenerBase
+internal sealed class RazorWorkspaceListener : RazorWorkspaceListenerBase
 {
-    public RazorWorkspaceListener(ILoggerFactory loggerFactory) : base(loggerFactory.CreateLogger(nameof(RazorWorkspaceListener)))
+    public RazorWorkspaceListener(ILoggerFactory loggerFactory) : base(loggerFactory.CreateLogger<RazorWorkspaceListener>())
     {
     }
 

src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/RazorWorkspaceListenerBase.cs

@@ -10,7 +10,7 @@
 
 namespace Microsoft.VisualStudioCode.RazorExtension;
 
-public abstract class RazorWorkspaceListenerBase : IDisposable
+internal abstract class RazorWorkspaceListenerBase : IDisposable
 {
     private static readonly TimeSpan s_debounceTime = TimeSpan.FromMilliseconds(500);
     private readonly CancellationTokenSource _disposeTokenSource = new();
@@ -30,15 +30,15 @@ internal record Work(ProjectId ProjectId);
     internal record UpdateWork(ProjectId ProjectId) : Work(ProjectId);
     internal record RemovalWork(ProjectId ProjectId, string IntermediateOutputPath) : Work(ProjectId);
 
-    private protected RazorWorkspaceListenerBase(ILogger logger)
+    protected RazorWorkspaceListenerBase(ILogger logger)
     {
         _logger = logger;
         _workQueue = new(s_debounceTime, ProcessWorkAsync, EqualityComparer<Work>.Default, _disposeTokenSource.Token);
     }
 
     private protected abstract Task CheckConnectionAsync(Stream stream, CancellationToken cancellationToken);
 
-    void IDisposable.Dispose()
+    public void Dispose()
     {
         if (_workspace is not null)
         {

src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Services/RazorLspDynamicFileInfoProvider.cs

@@ -5,21 +5,27 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
-using Microsoft.CodeAnalysis.Razor.Workspaces;
 
 namespace Microsoft.VisualStudioCode.RazorExtension.Services;
 
-[Export(typeof(IRazorLspDynamicFileInfoProvider)), Shared]
-internal sealed class RazorLspDynamicFileInfoProvider(IRazorClientLanguageServerManager clientLanguageServerManager, IWorkspaceProvider workspaceProvider) : IRazorLspDynamicFileInfoProvider
+[ExportRazorLspServiceFactory(typeof(RazorLspDynamicFileInfoProvider)), Shared]
+internal sealed class DynamicFileProviderFactory : AbstractRazorLspServiceFactory
+{
+    protected override AbstractRazorLspService CreateService(IRazorLspServices lspServices)
+    {
+        var clientLanguageServerManager = lspServices.GetRequiredService<IRazorClientLanguageServerManager>();
+        return new LspDynamicFileProvider(clientLanguageServerManager);
+    }
+}
+
+file sealed class LspDynamicFileProvider(IRazorClientLanguageServerManager clientLanguageServerManager) : RazorLspDynamicFileInfoProvider
 {
     private const string ProvideRazorDynamicFileInfoMethodName = "razor/provideDynamicFileInfo";
+    private const string RemoveRazorDynamicFileInfoMethodName = "razor/removeDynamicFileInfo";
 
     private readonly IRazorClientLanguageServerManager _clientLanguageServerManager = clientLanguageServerManager;
-    private readonly IWorkspaceProvider _workspaceProvider = workspaceProvider;
-
-    public event EventHandler<string>? Updated;
 
-    public async Task<RazorDynamicFileInfo?> GetDynamicFileInfoAsync(ProjectId projectId, string? projectFilePath, string filePath, CancellationToken cancellationToken)
+    public override async Task<RazorDynamicFileInfo?> GetDynamicFileInfoAsync(Workspace workspace, ProjectId projectId, string? projectFilePath, string filePath, CancellationToken cancellationToken)
     {
         var razorUri = new Uri(filePath);
 
@@ -41,7 +47,6 @@ internal sealed class RazorLspDynamicFileInfoProvider(IRazorClientLanguageServer
             return null;
         }
 
-        var workspace = _workspaceProvider.GetWorkspace();
         var textDocument = await WorkspaceExtensions.GetTextDocumentAsync(workspace, response.CSharpDocument.Uri, cancellationToken).ConfigureAwait(false);
         var checksum = Convert.FromBase64String(response.Checksum);
         var textLoader = new LspTextChangesTextLoader(
@@ -60,14 +65,17 @@ internal sealed class RazorLspDynamicFileInfoProvider(IRazorClientLanguageServer
             documentServiceProvider: EmptyServiceProvider.Instance);
     }
 
-    public Task RemoveDynamicFileInfoAsync(ProjectId projectId, string? projectFilePath, string filePath, CancellationToken cancellationToken)
+    public override Task RemoveDynamicFileInfoAsync(Workspace workspace, ProjectId projectId, string? projectFilePath, string filePath, CancellationToken cancellationToken)
     {
-        throw new NotImplementedException();
-    }
-
-    public void Update(Uri razorUri)
-    {
-        Updated?.Invoke(this, razorUri.ToString());
+        var notificationParams = new RazorRemoveDynamicFileParams
+        {
+            CSharpDocument = new()
+            {
+                Uri = new Uri(filePath)
+            }
+        };
+        return _clientLanguageServerManager.SendNotificationAsync(
+            RemoveRazorDynamicFileInfoMethodName, notificationParams, cancellationToken).AsTask();
     }
 }
 

src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Services/RazorRemoveDynamicFileParams.cs

@@ -0,0 +1,13 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System.Text.Json.Serialization;
+using Microsoft.VisualStudio.LanguageServer.Protocol;
+
+namespace Microsoft.VisualStudioCode.RazorExtension.Services;
+
+internal class RazorRemoveDynamicFileParams
+{
+    [JsonPropertyName("csharpDocument")]
+    public required TextDocumentIdentifier CSharpDocument { get; set; }
+}

src/Razor/src/Microsoft.VisualStudioCode.RazorExtension/Services/RazorWorkspaceService.cs

@@ -0,0 +1,52 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System.Composition;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.VisualStudioCode.RazorExtension.Services;
+
+[ExportRazorStatelessLspService(typeof(RazorWorkspaceService)), Shared]
+[method: ImportingConstructor]
+file class WorkspaceService(ILoggerFactory loggerFactory) : RazorWorkspaceService
+{
+    private readonly ILoggerFactory _loggerFactory = loggerFactory;
+    private readonly ILogger _logger = loggerFactory.CreateLogger<RazorWorkspaceService>();
+    private Lock _initializeLock = new();
+    private RazorWorkspaceListener? _razorWorkspaceListener;
+    private HashSet<ProjectId> _projectIdWithDynamicFiles = [];
+
+    public override void Initialize(Workspace workspace, string pipeName)
+    {
+        HashSet<ProjectId> projectsToInitialize;
+        lock (_initializeLock)
+        {
+            // Only initialize once
+            if (_razorWorkspaceListener is not null)
+            {
+                return;
+            }
+
+            //_logger.LogTrace("Initializing the Razor workspace listener with pipe name {0}", pipeName);
+            _razorWorkspaceListener = new RazorWorkspaceListener(_loggerFactory);
+            _razorWorkspaceListener.EnsureInitialized(workspace, pipeName);
+
+            projectsToInitialize = _projectIdWithDynamicFiles;
+            // May as well clear out the collection, it will never get used again anyway.
+            _projectIdWithDynamicFiles = [];
+        }
+
+        foreach (var projectId in projectsToInitialize)
+        {
+            _logger.LogTrace("{projectId} notifying a dynamic file for the first time", projectId);
+            _razorWorkspaceListener.NotifyDynamicFile(projectId);
+        }
+    }
+
+    public override void NotifyDynamicFile(ProjectId projectId)
+    {
+        _razorWorkspaceListener?.NotifyDynamicFile(projectId);
+    }
+}