Use a named pipe to communicate projectinfo in vscode

src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace/PublicAPI.Unshipped.txt

@@ -1,6 +1,6 @@
 #nullable enable
 Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace.RazorWorkspaceListener
 Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace.RazorWorkspaceListener.Dispose() -> void
-Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace.RazorWorkspaceListener.EnsureInitialized(Microsoft.CodeAnalysis.Workspace! workspace, string! projectInfoFileName) -> void
+Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace.RazorWorkspaceListener.EnsureInitialized(Microsoft.CodeAnalysis.Workspace! workspace, string! pipeName) -> void
 Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace.RazorWorkspaceListener.NotifyDynamicFile(Microsoft.CodeAnalysis.ProjectId! projectId) -> void
 Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace.RazorWorkspaceListener.RazorWorkspaceListener(Microsoft.Extensions.Logging.ILoggerFactory! loggerFactory) -> void

src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace/RazorProjectInfoSerializer.cs → src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace/RazorProjectInfoFactory.cs

@@ -19,31 +19,31 @@
 
 namespace Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace;
 
-internal static class RazorProjectInfoSerializer
+internal static class RazorProjectInfoFactory
 {
     private static readonly StringComparison s_stringComparison;
 
-    static RazorProjectInfoSerializer()
+    static RazorProjectInfoFactory()
     {
         s_stringComparison = RuntimeInformation.IsOSPlatform(OSPlatform.Linux)
             ? StringComparison.Ordinal
             : StringComparison.OrdinalIgnoreCase;
     }
 
-    public static async Task SerializeAsync(Project project, string configurationFileName, ILogger? logger, CancellationToken cancellationToken)
+    public static async Task<RazorProjectInfo?> ConvertAsync(Project project, ILogger? logger, CancellationToken cancellationToken)
     {
         var projectPath = Path.GetDirectoryName(project.FilePath);
         if (projectPath is null)
         {
-            logger?.LogTrace("projectPath is null, skipping writing info for {projectId}", project.Id);
-            return;
+            logger?.LogTrace("projectPath is null, skip conversion for {projectId}", project.Id);
+            return null;
         }
 
         var intermediateOutputPath = Path.GetDirectoryName(project.CompilationOutputInfo.AssemblyPath);
         if (intermediateOutputPath is null)
         {
-            logger?.LogTrace("intermediatePath is null, skipping writing info for {projectId}", project.Id);
-            return;
+            logger?.LogTrace("intermediatePath is null, skip conversion for {projectId}", project.Id);
+            return null;
         }
 
         // First, lets get the documents, because if there aren't any, we can skip out early
@@ -53,7 +53,7 @@ public static async Task SerializeAsync(Project project, string configurationFil
         if (documents.Length == 0)
         {
             logger?.LogTrace("No razor documents for {projectId}", project.Id);
-            return;
+            return null;
         }
 
         var csharpLanguageVersion = (project.ParseOptions as CSharpParseOptions)?.LanguageVersion ?? LanguageVersion.Default;
@@ -86,18 +86,14 @@ public static async Task SerializeAsync(Project project, string configurationFil
 
         var projectWorkspaceState = ProjectWorkspaceState.Create(tagHelpers, csharpLanguageVersion);
 
-        var configurationFilePath = Path.Combine(intermediateOutputPath, configurationFileName);
-
-        var projectInfo = new RazorProjectInfo(
+        return new RazorProjectInfo(
             projectKey: new ProjectKey(intermediateOutputPath),
             filePath: project.FilePath!,
             configuration: configuration,
             rootNamespace: defaultNamespace,
             displayName: project.Name,
             projectWorkspaceState: projectWorkspaceState,
             documents: documents);
-
-        WriteToFile(configurationFilePath, projectInfo, logger);
     }
 
     private static RazorConfiguration ComputeRazorConfigurationOptions(AnalyzerConfigOptionsProvider options, ILogger? logger, out string defaultNamespace)
@@ -126,38 +122,6 @@ private static RazorConfiguration ComputeRazorConfigurationOptions(AnalyzerConfi
         return razorConfiguration;
     }
 
-    private static void WriteToFile(string configurationFilePath, RazorProjectInfo projectInfo, ILogger? logger)
-    {
-        // We need to avoid having an incomplete file at any point, but our
-        // project configuration is large enough that it will be written as multiple operations.
-        var tempFilePath = string.Concat(configurationFilePath, ".temp");
-        var tempFileInfo = new FileInfo(tempFilePath);
-
-        if (tempFileInfo.Exists)
-        {
-            // This could be caused by failures during serialization or early process termination.
-            logger?.LogTrace("deleting existing file {filePath}", tempFilePath);
-            tempFileInfo.Delete();
-        }
-
-        // This needs to be in explicit brackets because the operation needs to be completed
-        // by the time we move the temp file into its place
-        using (var stream = tempFileInfo.Create())
-        {
-            projectInfo.SerializeTo(stream);
-        }
-
-        var fileInfo = new FileInfo(configurationFilePath);
-        if (fileInfo.Exists)
-        {
-            logger?.LogTrace("deleting existing file {filePath}", configurationFilePath);
-            fileInfo.Delete();
-        }
-
-        logger?.LogTrace("Moving {tmpPath} to {newPath}", tempFilePath, configurationFilePath);
-        File.Move(tempFileInfo.FullName, configurationFilePath);
-    }
-
     internal static ImmutableArray<DocumentSnapshotHandle> GetDocuments(Project project, string projectPath)
     {
         using var documents = new PooledArrayBuilder<DocumentSnapshotHandle>();

src/Razor/src/Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace/RazorWorkspaceListener.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
 using System.Collections.Immutable;
+using System.IO.Pipes;
 using Microsoft.AspNetCore.Razor.Utilities;
 using Microsoft.CodeAnalysis;
 using Microsoft.Extensions.Logging;
@@ -13,20 +14,24 @@ public class RazorWorkspaceListener : IDisposable
     private static readonly TimeSpan s_debounceTime = TimeSpan.FromMilliseconds(500);
 
     private readonly ILogger _logger;
-
-    private string? _projectInfoFileName;
     private Workspace? _workspace;
 
     // Use an immutable dictionary for ImmutableInterlocked operations. The value isn't checked, just
     // the existance of the key so work is only done for projects with dynamic files.
     private ImmutableDictionary<ProjectId, bool> _projectsWithDynamicFile = ImmutableDictionary<ProjectId, bool>.Empty;
     private readonly CancellationTokenSource _disposeTokenSource = new();
-    private readonly AsyncBatchingWorkQueue<ProjectId> _workQueue;
+    private readonly AsyncBatchingWorkQueue<Work> _workQueue;
+
+    record Work(ProjectId ProjectId);
+    record UpdateWork(ProjectId ProjectId) : Work(ProjectId);
+    record RemovalWork(ProjectId ProjectId, string IntermediateOutputPath) : Work(ProjectId);
+
+    private Stream? _stream;
 
     public RazorWorkspaceListener(ILoggerFactory loggerFactory)
     {
         _logger = loggerFactory.CreateLogger(nameof(RazorWorkspaceListener));
-        _workQueue = new(TimeSpan.FromMilliseconds(500), UpdateCurrentProjectsAsync, EqualityComparer<ProjectId>.Default, _disposeTokenSource.Token);
+        _workQueue = new(TimeSpan.FromMilliseconds(500), UpdateCurrentProjectsAsync, EqualityComparer<Work>.Default, _disposeTokenSource.Token);
     }
 
     public void Dispose()
@@ -45,17 +50,38 @@ public void Dispose()
         _disposeTokenSource.Dispose();
     }
 
-    public void EnsureInitialized(Workspace workspace, string projectInfoFileName)
+    public void EnsureInitialized(Workspace workspace, string pipeName)
+    {
+        // Make sure we don't hook up the event handler multiple times
+        if (_stream is not null)
+        {
+            return;
+        }
+
+        _logger.LogTrace("Opening named pipe server: {0}", pipeName);
+        var stream = new NamedPipeServerStream(
+            pipeName,
+            PipeDirection.Out,
+            maxNumberOfServerInstances: 1,
+            PipeTransmissionMode.Byte,
+            PipeOptions.CurrentUserOnly | PipeOptions.Asynchronous);
+
+        EnsureInitialized(workspace, stream);
+    }
+
+    // Internal for testing
+    internal void EnsureInitialized(Workspace workspace, Stream stream)
     {
         // Make sure we don't hook up the event handler multiple times
-        if (_projectInfoFileName is not null)
+        if (_stream is not null)
         {
             return;
         }
 
-        _projectInfoFileName = projectInfoFileName;
         _workspace = workspace;
         _workspace.WorkspaceChanged += Workspace_WorkspaceChanged;
+
+        _stream = stream;
     }
 
     public void NotifyDynamicFile(ProjectId projectId)
@@ -72,7 +98,7 @@ public void NotifyDynamicFile(ProjectId projectId)
 
         // Schedule a task, in case adding a dynamic file is the last thing that happens
         _logger.LogTrace("{projectId} scheduling task due to dynamic file", projectId);
-        _workQueue.AddWork(projectId);
+        _workQueue.AddWork(new UpdateWork(projectId));
     }
 
     private void Workspace_WorkspaceChanged(object? sender, WorkspaceChangeEventArgs e)
@@ -101,7 +127,7 @@ private void Workspace_WorkspaceChanged(object? sender, WorkspaceChangeEventArgs
                 break;
 
             case WorkspaceChangeKind.ProjectRemoved:
-                RemoveProject(e.ProjectId.AssumeNotNull());
+                RemoveProject(e.OldSolution.GetProject(e.ProjectId.AssumeNotNull()).AssumeNotNull());
                 break;
 
             case WorkspaceChangeKind.ProjectAdded:
@@ -131,7 +157,7 @@ private void Workspace_WorkspaceChanged(object? sender, WorkspaceChangeEventArgs
             case WorkspaceChangeKind.SolutionRemoved:
                 foreach (var project in e.OldSolution.Projects)
                 {
-                    RemoveProject(project.Id);
+                    RemoveProject(project);
                 }
 
                 break;
@@ -141,14 +167,24 @@ private void Workspace_WorkspaceChanged(object? sender, WorkspaceChangeEventArgs
         }
     }
 
-    private void RemoveProject(ProjectId projectId)
+    private void RemoveProject(Project project)
     {
-        ImmutableInterlocked.TryRemove(ref _projectsWithDynamicFile, projectId, out var _);
+        if (ImmutableInterlocked.TryRemove(ref _projectsWithDynamicFile, project.Id, out var _))
+        {
+            var intermediateOutputPath = Path.GetDirectoryName(project.CompilationOutputInfo.AssemblyPath);
+            if (intermediateOutputPath is null)
+            {
+                _logger?.LogTrace("intermediatePath is null, skipping notification of removal for {projectId}", project.Id);
+                return;
+            }
+
+            _workQueue.AddWork(new RemovalWork(project.Id, intermediateOutputPath));   
+        }
     }
 
     private void EnqueueUpdate(Project? project)
     {
-        if (_projectInfoFileName is null ||
+        if (_stream is null ||
             project is not
             {
                 Language: LanguageNames.CSharp
@@ -164,35 +200,63 @@ private void EnqueueUpdate(Project? project)
         }
 
         var projectId = project.Id;
-        _workQueue.AddWork(projectId);
+        _workQueue.AddWork(new UpdateWork(projectId));
     }
 
-    private async ValueTask UpdateCurrentProjectsAsync(ImmutableArray<ProjectId> projectIds, CancellationToken cancellationToken)
+    private async ValueTask UpdateCurrentProjectsAsync(ImmutableArray<Work> work, CancellationToken cancellationToken)
     {
         var solution = _workspace.AssumeNotNull().CurrentSolution;
+        _stream.AssumeNotNull();
 
-        foreach (var projectId in projectIds)
+        foreach (var unit in work)
         {
-            if (_disposeTokenSource.IsCancellationRequested)
+            try
             {
-                return;
-            }
+                if (_disposeTokenSource.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                if (unit is RemovalWork removalWork)
+                {
+                    await ReportRemovalAsync(removalWork, cancellationToken).ConfigureAwait(false);
+                }
 
-            var project = solution.GetProject(projectId);
-            if (project is null)
+                var project = solution.GetProject(unit.ProjectId);
+                if (project is null)
+                {
+                    _logger?.LogTrace("Project {projectId} is not in workspace", unit.ProjectId);
+                    continue;
+                }
+
+                await UpdateProjectAsync(project, solution, cancellationToken).ConfigureAwait(false);
+            }
+            catch (Exception ex)
             {
-                _logger?.LogTrace("Project {projectId} is not in workspace", projectId);
-                continue;
+                _logger?.LogError(ex, "Encountered exception while processing unit: {message}", ex.Message);
             }
-
-            await SerializeProjectAsync(project, solution, cancellationToken).ConfigureAwait(false);
         }
+
+        await _stream.AssumeNotNull().FlushAsync(cancellationToken).ConfigureAwait(false);
+    }
+
+    private Task ReportRemovalAsync(RemovalWork unit, CancellationToken cancellationToken)
+    {
+        _logger?.LogTrace("Reporting removal of {projectId}", unit.ProjectId);
+        return _stream.AssumeNotNull().WriteProjectInfoRemovalAsync(unit.IntermediateOutputPath, cancellationToken);
     }
 
     // private protected for testing
-    private protected virtual Task SerializeProjectAsync(Project project, Solution solution, CancellationToken cancellationToken)
+    private protected virtual async Task UpdateProjectAsync(Project project, Solution solution, CancellationToken cancellationToken)
     {
         _logger?.LogTrace("Serializing information for {projectId}", project.Id);
-        return RazorProjectInfoSerializer.SerializeAsync(project, _projectInfoFileName.AssumeNotNull(), _logger, cancellationToken);
+        var projectInfo = await RazorProjectInfoFactory.ConvertAsync(project, _logger, cancellationToken).ConfigureAwait(false);
+        if (projectInfo is null)
+        {
+            _logger?.LogTrace("Skipped writing data for {projectId}", project.Id);
+            return;
+        }
+
+        await _stream.AssumeNotNull().WriteProjectInfoAsync(projectInfo, cancellationToken).ConfigureAwait(false);
     }
 }

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/DefaultLanguageServerFeatureOptions.cs

@@ -13,8 +13,6 @@ internal class DefaultLanguageServerFeatureOptions : LanguageServerFeatureOption
 
     public override bool SupportsFileManipulation => true;
 
-    public override string ProjectConfigurationFileName => "project.razor.bin";
-
     public override string CSharpVirtualDocumentSuffix => DefaultCSharpVirtualDocumentSuffix;
 
     public override string HtmlVirtualDocumentSuffix => DefaultHtmlVirtualDocumentSuffix;

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Hosting/ConfigurableLanguageServerFeatureOptions.cs

@@ -11,7 +11,6 @@ internal class ConfigurableLanguageServerFeatureOptions : LanguageServerFeatureO
     private readonly LanguageServerFeatureOptions _defaults = new DefaultLanguageServerFeatureOptions();
 
     private readonly bool? _supportsFileManipulation;
-    private readonly string? _projectConfigurationFileName;
     private readonly string? _csharpVirtualDocumentSuffix;
     private readonly string? _htmlVirtualDocumentSuffix;
     private readonly bool? _singleServerCompletionSupport;
@@ -27,7 +26,6 @@ internal class ConfigurableLanguageServerFeatureOptions : LanguageServerFeatureO
     private readonly bool? _forceRuntimeCodeGeneration;
 
     public override bool SupportsFileManipulation => _supportsFileManipulation ?? _defaults.SupportsFileManipulation;
-    public override string ProjectConfigurationFileName => _projectConfigurationFileName ?? _defaults.ProjectConfigurationFileName;
     public override string CSharpVirtualDocumentSuffix => _csharpVirtualDocumentSuffix ?? DefaultLanguageServerFeatureOptions.DefaultCSharpVirtualDocumentSuffix;
     public override string HtmlVirtualDocumentSuffix => _htmlVirtualDocumentSuffix ?? DefaultLanguageServerFeatureOptions.DefaultHtmlVirtualDocumentSuffix;
     public override bool SingleServerCompletionSupport => _singleServerCompletionSupport ?? _defaults.SingleServerCompletionSupport;
@@ -52,7 +50,6 @@ public ConfigurableLanguageServerFeatureOptions(string[] args)
             }
 
             TryProcessBoolOption(nameof(SupportsFileManipulation), ref _supportsFileManipulation, option, args, i);
-            TryProcessStringOption(nameof(ProjectConfigurationFileName), ref _projectConfigurationFileName, option, args, i);
             TryProcessStringOption(nameof(CSharpVirtualDocumentSuffix), ref _csharpVirtualDocumentSuffix, option, args, i);
             TryProcessStringOption(nameof(HtmlVirtualDocumentSuffix), ref _htmlVirtualDocumentSuffix, option, args, i);
             TryProcessBoolOption(nameof(SingleServerCompletionSupport), ref _singleServerCompletionSupport, option, args, i);