File-based program directive diagnostics in editor

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,91 @@
+// 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 class VirtualProjectXmlDiagnosticSourceProvider(VirtualProjectXmlProvider virtualProjectXmlProvider) : IDiagnosticSourceProvider
+{
+    public bool IsDocument => true;
+
+    public const string FileBasedPrograms = nameof(FileBasedPrograms);
+    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 DiagnosticSource(context.Document, virtualProjectXmlProvider)];
+
+        return ValueTask.FromResult(sources);
+    }
+
+    private class DiagnosticSource(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 = ImmutableArray.CreateBuilder<DiagnosticData>(simpleDiagnostics.Length);
+            foreach (var simpleDiagnostic in simpleDiagnostics)
+            {
+                var location = new FileLinePositionSpan(simpleDiagnostic.Location.Path, simpleDiagnostic.Location.Span.ToLinePositionSpan());
+                var diagnosticData = new DiagnosticData(
+                    id: "FBP",
+                    category: FileBasedPrograms,
+                    message: simpleDiagnostic.Message,
+                    severity: DiagnosticSeverity.Error,
+                    defaultSeverity: DiagnosticSeverity.Error,
+                    isEnabledByDefault: true,
+                    warningLevel: 1,
+                    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;
+        }
+
+        public bool IsLiveSource() => false;
+
+        public string ToDisplayString() => $"{nameof(VirtualProjectXmlProvider)}.{nameof(DiagnosticSource)}";
+    }
+}

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

@@ -11,18 +11,34 @@
 using System.Text.Json;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+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 Microsoft.Extensions.Logging;
+using Roslyn.LanguageServer.Protocol;
 using Roslyn.Utilities;
 
 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 Task<(string VirtualProjectXml, ImmutableArray<SimpleDiagnostic> Diagnostics)?> GetVirtualProjectContentAsync(string documentFilePath, ILogger logger, CancellationToken cancellationToken)
     {
         var workingDirectory = Path.GetDirectoryName(documentFilePath);
@@ -70,7 +86,15 @@ internal class VirtualProjectXmlProvider(DotnetCliHelper dotnetCliHelper)
 
             if (response is RunApiOutput.Project 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();
+                }
                 return (project.Content, project.Diagnostics);
             }