File-based program directive diagnostics in editor

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/FileBasedProgramsProjectSystem.cs

@@ -153,4 +153,9 @@ public async ValueTask TryRemoveMiscellaneousDocumentAsync(DocumentUri uri)
             Preferred: buildHostKind,
             Actual: buildHostKind);
     }
+
+    protected override async ValueTask OnProjectUnloadedAsync(string projectFilePath)
+    {
+        await _projectXmlProvider.UnloadCachedDiagnosticsAsync(projectFilePath);
+    }
 }

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/RunApiModels.cs

@@ -43,28 +43,46 @@ public sealed class Project : RunApiOutput
             public required ImmutableArray<SimpleDiagnostic> Diagnostics { get; init; }
         }
     }
-    internal sealed class SimpleDiagnostic
+
+    internal sealed record SimpleDiagnostic
     {
         public required Position Location { get; init; }
         public required string Message { get; init; }
 
         /// <summary>
         /// An adapter of <see cref="FileLinePositionSpan"/> that ensures we JSON-serialize only the necessary fields.
         /// </summary>
-        public readonly struct Position
+        public readonly record struct Position
         {
             public string Path { get; init; }
-            public LinePositionSpan Span { get; init; }
+            public LinePositionSpanInternal Span { get; init; }
+        }
+    }
 
-            public static implicit operator Position(FileLinePositionSpan fileLinePositionSpan) => new()
-            {
-                Path = fileLinePositionSpan.Path,
-                Span = fileLinePositionSpan.Span,
-            };
+    internal record struct LinePositionInternal
+    {
+        public int Line { get; init; }
+        public int Character { get; init; }
+    }
+
+    /// <summary>
+    /// Workaround for inability to deserialize directly to <see cref="LinePositionSpan"/>.
+    /// </summary>
+    internal record struct LinePositionSpanInternal
+    {
+        public LinePositionInternal Start { get; init; }
+        public LinePositionInternal End { get; init; }
+
+        public LinePositionSpan ToLinePositionSpan()
+        {
+            return new LinePositionSpan(
+                start: new LinePosition(Start.Line, Start.Character),
+                end: new LinePosition(End.Line, End.Character));
         }
     }
 
     [JsonSerializable(typeof(RunApiInput))]
     [JsonSerializable(typeof(RunApiOutput))]
+    [JsonSerializable(typeof(LinePositionSpanInternal))]
     internal partial class RunFileApiJsonSerializerContext : JsonSerializerContext;
 }

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/VirtualProjectXmlDiagnosticSourceProvider.cs

@@ -0,0 +1,97 @@
+// 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 System.Collections.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.LanguageServer.Handler;
+using Microsoft.CodeAnalysis.LanguageServer.Handler.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.LanguageServer.Protocol;
+
+namespace Microsoft.CodeAnalysis.LanguageServer.FileBasedPrograms;
+
+[Export(typeof(IDiagnosticSourceProvider)), Shared]
+[method: ImportingConstructor]
+[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+internal sealed class VirtualProjectXmlDiagnosticSourceProvider(VirtualProjectXmlProvider virtualProjectXmlProvider) : IDiagnosticSourceProvider
+{
+    public const string FileBasedPrograms = nameof(FileBasedPrograms);
+
+    public bool IsDocument => true;
+    public string Name => FileBasedPrograms;
+
+    public bool IsEnabled(ClientCapabilities clientCapabilities) => true;
+
+    public ValueTask<ImmutableArray<IDiagnosticSource>> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)
+    {
+        ImmutableArray<IDiagnosticSource> sources = context.Document is null
+            ? []
+            : [new VirtualProjectXmlDiagnosticSource(context.Document, virtualProjectXmlProvider)];
+
+        return ValueTask.FromResult(sources);
+    }
+
+    private sealed class VirtualProjectXmlDiagnosticSource(Document document, VirtualProjectXmlProvider virtualProjectXmlProvider) : IDiagnosticSource
+    {
+        public async Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(RequestContext context, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(document.FilePath))
+                return [];
+
+            var simpleDiagnostics = await virtualProjectXmlProvider.GetCachedDiagnosticsAsync(document.FilePath, cancellationToken);
+            if (simpleDiagnostics.IsDefaultOrEmpty)
+                return [];
+
+            var diagnosticDatas = new FixedSizeArrayBuilder<DiagnosticData>(simpleDiagnostics.Length);
+            foreach (var simpleDiagnostic in simpleDiagnostics)
+            {
+                var location = new FileLinePositionSpan(simpleDiagnostic.Location.Path, simpleDiagnostic.Location.Span.ToLinePositionSpan());
+                var diagnosticData = new DiagnosticData(
+                    id: FileBasedPrograms,
+                    category: FileBasedPrograms,
+                    message: simpleDiagnostic.Message,
+                    severity: DiagnosticSeverity.Error,
+                    defaultSeverity: DiagnosticSeverity.Error,
+                    isEnabledByDefault: true,
+                    // Warning level 0 is used as a placeholder when the diagnostic has error severity
+                    warningLevel: 0,
+                    customTags: ImmutableArray<string>.Empty,
+                    properties: ImmutableDictionary<string, string?>.Empty,
+                    projectId: document.Project.Id,
+                    location: new DiagnosticDataLocation(location, document.Id)
+                );
+                diagnosticDatas.Add(diagnosticData);
+            }
+            return diagnosticDatas.MoveToImmutable();
+        }
+
+        public TextDocumentIdentifier? GetDocumentIdentifier()
+        {
+            return !string.IsNullOrEmpty(document.FilePath)
+            ? new VSTextDocumentIdentifier { ProjectContext = ProtocolConversions.ProjectToProjectContext(document.Project), DocumentUri = document.GetURI() }
+            : null;
+        }
+
+        public ProjectOrDocumentId GetId()
+        {
+            return new ProjectOrDocumentId(document.Id);
+        }
+
+        public Project GetProject()
+        {
+            return document.Project;
+        }
+
+        /// <summary>
+        /// These diagnostics are from the last time 'dotnet run-api' was invoked, which only occurs when a design time build is performed.
+        /// <seealso cref="IDiagnosticSource.IsLiveSource"/>.
+        /// </summary>
+        /// <returns></returns>
+        public bool IsLiveSource() => false;
+
+        public string ToDisplayString() => nameof(VirtualProjectXmlDiagnosticSource);
+    }
+}

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/VirtualProjectXmlProvider.cs

@@ -11,6 +11,7 @@
 using System.Text.Json;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.Extensions.Logging;
@@ -21,9 +22,63 @@ namespace Microsoft.CodeAnalysis.LanguageServer.FileBasedPrograms;
 [Export(typeof(VirtualProjectXmlProvider)), Shared]
 [method: ImportingConstructor]
 [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-internal class VirtualProjectXmlProvider(DotnetCliHelper dotnetCliHelper)
+internal class VirtualProjectXmlProvider(IDiagnosticsRefresher diagnosticRefresher, DotnetCliHelper dotnetCliHelper)
 {
+    private readonly SemaphoreSlim _gate = new(initialCount: 1);
+    private readonly Dictionary<string, ImmutableArray<SimpleDiagnostic>> _diagnosticsByFilePath = [];
+
+    internal async ValueTask<ImmutableArray<SimpleDiagnostic>> GetCachedDiagnosticsAsync(string path, CancellationToken cancellationToken)
+    {
+        using (await _gate.DisposableWaitAsync(cancellationToken))
+        {
+            _diagnosticsByFilePath.TryGetValue(path, out var diagnostics);
+            return diagnostics;
+        }
+    }
+
+    internal async ValueTask UnloadCachedDiagnosticsAsync(string path)
+    {
+        using (await _gate.DisposableWaitAsync(CancellationToken.None))
+        {
+            _diagnosticsByFilePath.Remove(path);
+        }
+    }
+
     internal async Task<(string VirtualProjectXml, ImmutableArray<SimpleDiagnostic> Diagnostics)?> GetVirtualProjectContentAsync(string documentFilePath, ILogger logger, CancellationToken cancellationToken)
+    {
+        var result = await GetVirtualProjectContentImplAsync(documentFilePath, logger, cancellationToken);
+        if (result is { } project)
+        {
+            using (await _gate.DisposableWaitAsync(cancellationToken))
+            {
+                _diagnosticsByFilePath.TryGetValue(documentFilePath, out var previousCachedDiagnostics);
+                _diagnosticsByFilePath[documentFilePath] = project.Diagnostics;
+
+                // check for difference, and signal to host to update if so.
+                if (previousCachedDiagnostics.IsDefault || !project.Diagnostics.SequenceEqual(previousCachedDiagnostics))
+                    diagnosticRefresher.RequestWorkspaceRefresh();
+            }
+        }
+        else
+        {
+            using (await _gate.DisposableWaitAsync(CancellationToken.None))
+            {
+                if (_diagnosticsByFilePath.TryGetValue(documentFilePath, out var diagnostics))
+                {
+                    _diagnosticsByFilePath.Remove(documentFilePath);
+                    if (!diagnostics.IsDefaultOrEmpty)
+                    {
+                        // diagnostics have changed from "non-empty" to "unloaded". refresh.
+                        diagnosticRefresher.RequestWorkspaceRefresh();
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+    private async Task<(string VirtualProjectXml, ImmutableArray<SimpleDiagnostic> Diagnostics)?> GetVirtualProjectContentImplAsync(string documentFilePath, ILogger logger, CancellationToken cancellationToken)
     {
         var workingDirectory = Path.GetDirectoryName(documentFilePath);
         var process = dotnetCliHelper.Run(["run-api"], workingDirectory, shouldLocalizeOutput: true, keepStandardInputOpen: true);
@@ -70,7 +125,6 @@ internal class VirtualProjectXmlProvider(DotnetCliHelper dotnetCliHelper)
 
             if (response is RunApiOutput.Project project)
             {
-
                 return (project.Content, project.Diagnostics);
             }
 

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerProjectLoader.cs

@@ -181,6 +181,14 @@ protected sealed record RemoteProjectLoadResult(RemoteProjectFile ProjectFile, P
     protected abstract Task<RemoteProjectLoadResult?> TryLoadProjectInMSBuildHostAsync(
         BuildHostProcessManager buildHostProcessManager, string projectPath, CancellationToken cancellationToken);
 
+    /// <summary>Called after a project is unloaded to allow the subtype to clean up any resources associated with the project.</summary>
+    /// <remarks>
+    /// Note that this refers to unloading of the project on the project-system level.
+    /// So, for example, changing the target frameworks of a project, or transitioning between
+    /// "file-based program" and "true miscellaneous file", will not result in this being called.
+    /// </remarks>
+    protected abstract ValueTask OnProjectUnloadedAsync(string projectFilePath);
+
     /// <returns>True if the project needs a NuGet restore, false otherwise.</returns>
     private async Task<bool> ReloadProjectAsync(ProjectToLoad projectToLoad, ToastErrorReporter toastErrorReporter, BuildHostProcessManager buildHostProcessManager, CancellationToken cancellationToken)
     {
@@ -445,5 +453,7 @@ protected async ValueTask UnloadProjectAsync(string projectPath)
                 throw ExceptionUtilities.UnexpectedValue(loadState);
             }
         }
+
+        await OnProjectUnloadedAsync(projectPath);
     }
 }

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerProjectSystem.cs

@@ -92,4 +92,10 @@ public async Task OpenProjectsAsync(ImmutableArray<string> projectFilePaths)
         var loadedFile = await buildHost.LoadProjectFileAsync(projectPath, languageName, cancellationToken);
         return new RemoteProjectLoadResult(loadedFile, _hostProjectFactory, IsMiscellaneousFile: false, preferredBuildHostKind, actualBuildHostKind);
     }
+
+    protected override ValueTask OnProjectUnloadedAsync(string projectFilePath)
+    {
+        // Nothing else to unload for ordinary projects.
+        return ValueTask.CompletedTask;
+    }
 }

src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/IDiagnosticSource.cs

@@ -24,8 +24,8 @@ internal interface IDiagnosticSource
     /// <summary>
     /// True if this source produces diagnostics that are considered 'live' or not.  Live errors represent up to date
     /// information that should supersede other sources.  Non 'live' errors (aka "build errors") are recognized to
-    /// potentially represent stale results from a point in the past when the computation occurred.  The only time
-    /// Roslyn produces non-live errors through an explicit user gesture to "run code analysis". Because these represent
+    /// potentially represent stale results from a point in the past when the computation occurred.  An example of when
+    /// Roslyn produces non-live errors is with an explicit user gesture to "run code analysis". Because these represent
     /// errors from the past, we do want them to be superseded by a more recent live run, or a more recent build from
     /// another source.
     /// </summary>