Add diagnostics (PowerShell#18)

Author: TylerLeonhardt

src/PowerShellEditorServices.Engine/Hosting/EditorServicesHost.cs

@@ -227,6 +227,12 @@ public void StartLanguageService(
 
             _serviceCollection.AddSingleton<WorkspaceService>();
             _serviceCollection.AddSingleton<SymbolsService>();
+            _serviceCollection.AddSingleton<AnalysisService>(
+                (provider) => {
+                    // TODO: Fill in settings
+                    return AnalysisService.Create(null, _factory.CreateLogger<AnalysisService>());
+                }
+            );
 
             _languageServer = new OmnisharpLanguageServerBuilder(_serviceCollection)
             {

src/PowerShellEditorServices.Engine/LanguageServer/OmnisharpLanguageServer.cs

@@ -7,7 +7,7 @@
 using OS = OmniSharp.Extensions.LanguageServer.Server;
 using System.Security.AccessControl;
 using OmniSharp.Extensions.LanguageServer.Server;
-using PowerShellEditorServices.Engine.Services.Workspace.Handlers;
+using PowerShellEditorServices.Engine.Services.Handlers;
 
 namespace Microsoft.PowerShell.EditorServices.Engine
 {

src/PowerShellEditorServices.Engine/Services/Analysis/AnalysisService.cs

@@ -13,7 +13,7 @@
 using System.Collections;
 using Microsoft.Extensions.Logging;
 
-namespace Microsoft.PowerShell.EditorServices.Services
+namespace Microsoft.PowerShell.EditorServices
 {
     /// <summary>
     /// Provides a high-level service for performing semantic analysis

src/PowerShellEditorServices.Engine/Services/PowerShellContext/Handlers/GetVersionHandler.cs

@@ -4,7 +4,7 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.PowerShell.EditorServices;
 
-namespace PowerShellEditorServices.Engine.Services.Workspace.Handlers
+namespace PowerShellEditorServices.Engine.Services.Handlers
 {
     public class GetVersionHandler : IGetVersionHandler
     {

src/PowerShellEditorServices.Engine/Services/PowerShellContext/Handlers/IGetVersionHandler.cs

@@ -1,7 +1,7 @@
 using OmniSharp.Extensions.Embedded.MediatR;
 using OmniSharp.Extensions.JsonRpc;
 
-namespace PowerShellEditorServices.Engine.Services.Workspace.Handlers
+namespace PowerShellEditorServices.Engine.Services.Handlers
 {
     [Serial, Method("powerShell/getVersion")]
     public interface IGetVersionHandler : IJsonRpcRequestHandler<GetVersionParams, PowerShellVersionDetails> { }

src/PowerShellEditorServices.Engine/Services/TextDocument/Handlers/TextDocumentHandler.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
@@ -11,14 +12,21 @@
 using OmniSharp.Extensions.LanguageServer.Protocol.Server;
 using OmniSharp.Extensions.LanguageServer.Protocol.Server.Capabilities;
 
-namespace PowerShellEditorServices.Engine.Services.Workspace.Handlers
+namespace PowerShellEditorServices.Engine.Services.Handlers
 {
     class TextDocumentHandler : ITextDocumentSyncHandler
     {
 
         private readonly ILogger _logger;
+        private readonly ILanguageServer _languageServer;
+        private readonly AnalysisService _analysisService;
         private readonly WorkspaceService _workspaceService;
 
+        private Dictionary<string, Dictionary<string, MarkerCorrection>> codeActionsPerFile =
+            new Dictionary<string, Dictionary<string, MarkerCorrection>>();
+
+        private static CancellationTokenSource s_existingRequestCancellation;
+
         private readonly DocumentSelector _documentSelector = new DocumentSelector(
             new DocumentFilter()
             {
@@ -30,9 +38,11 @@ class TextDocumentHandler : ITextDocumentSyncHandler
 
         public TextDocumentSyncKind Change => TextDocumentSyncKind.Incremental;
 
-        public TextDocumentHandler(ILoggerFactory factory, WorkspaceService workspaceService)
+        public TextDocumentHandler(ILoggerFactory factory, ILanguageServer languageServer, AnalysisService analysisService, WorkspaceService workspaceService)
         {
             _logger = factory.CreateLogger<TextDocumentHandler>();
+            _languageServer = languageServer;
+            _analysisService = analysisService;
             _workspaceService = workspaceService;
         }
 
@@ -54,10 +64,7 @@ public Task<Unit> Handle(DidChangeTextDocumentParams notification, CancellationT
             }
 
             // TODO: Get all recently edited files in the workspace
-            // this.RunScriptDiagnosticsAsync(
-            //     changedFiles.ToArray(),
-            //     editorSession,
-            //     eventContext);
+            RunScriptDiagnosticsAsync(changedFiles.ToArray());
             return Unit.Task;
         }
 
@@ -83,10 +90,7 @@ public Task<Unit> Handle(DidOpenTextDocumentParams notification, CancellationTok
                     notification.TextDocument.Text);
 
             // TODO: Get all recently edited files in the workspace
-            // this.RunScriptDiagnosticsAsync(
-            //     new ScriptFile[] { openedFile },
-            //     editorSession,
-            //     eventContext);
+            RunScriptDiagnosticsAsync(new ScriptFile[] { openedFile });
 
             _logger.LogTrace("Finished opening document.");
             return Unit.Task;
@@ -108,7 +112,7 @@ public Task<Unit> Handle(DidCloseTextDocumentParams notification, CancellationTo
             if (fileToClose != null)
             {
                 _workspaceService.CloseFile(fileToClose);
-                // await ClearMarkersAsync(fileToClose, eventContext);
+                ClearMarkers(fileToClose);
             }
 
             _logger.LogTrace("Finished closing document.");
@@ -162,14 +166,241 @@ private static FileChange GetFileChangeDetails(Range changeRange, string insertS
             };
         }
 
-        // private async Task ClearMarkersAsync(ScriptFile scriptFile, EventContext eventContext)
-        // {
-        //     // send empty diagnostic markers to clear any markers associated with the given file
-        //     await PublishScriptDiagnosticsAsync(
-        //             scriptFile,
-        //             new List<ScriptFileMarker>(),
-        //             this.codeActionsPerFile,
-        //             eventContext);
-        // }
+        private Task RunScriptDiagnosticsAsync(
+            ScriptFile[] filesToAnalyze)
+        {
+            // If there's an existing task, attempt to cancel it
+            try
+            {
+                if (s_existingRequestCancellation != null)
+                {
+                    // Try to cancel the request
+                    s_existingRequestCancellation.Cancel();
+
+                    // If cancellation didn't throw an exception,
+                    // clean up the existing token
+                    s_existingRequestCancellation.Dispose();
+                    s_existingRequestCancellation = null;
+                }
+            }
+            catch (Exception e)
+            {
+                // TODO: Catch a more specific exception!
+                _logger.LogError(
+                    string.Format(
+                        "Exception while canceling analysis task:\n\n{0}",
+                        e.ToString()));
+
+                TaskCompletionSource<bool> cancelTask = new TaskCompletionSource<bool>();
+                cancelTask.SetCanceled();
+                return cancelTask.Task;
+            }
+
+            // If filesToAnalzye is empty, nothing to do so return early.
+            if (filesToAnalyze.Length == 0)
+            {
+                return Task.FromResult(true);
+            }
+
+            // Create a fresh cancellation token and then start the task.
+            // We create this on a different TaskScheduler so that we
+            // don't block the main message loop thread.
+            // TODO: Is there a better way to do this?
+            s_existingRequestCancellation = new CancellationTokenSource();
+            // TODO use settings service
+            Task.Factory.StartNew(
+                () =>
+                    DelayThenInvokeDiagnosticsAsync(
+                        750,
+                        filesToAnalyze,
+                        true,
+                        this.codeActionsPerFile,
+                        _logger,
+                        s_existingRequestCancellation.Token),
+                CancellationToken.None,
+                TaskCreationOptions.None,
+                TaskScheduler.Default);
+
+            return Task.FromResult(true);
+        }
+
+        private async Task DelayThenInvokeDiagnosticsAsync(
+            int delayMilliseconds,
+            ScriptFile[] filesToAnalyze,
+            bool isScriptAnalysisEnabled,
+            Dictionary<string, Dictionary<string, MarkerCorrection>> correctionIndex,
+            ILogger Logger,
+            CancellationToken cancellationToken)
+        {
+            // First of all, wait for the desired delay period before
+            // analyzing the provided list of files
+            try
+            {
+                await Task.Delay(delayMilliseconds, cancellationToken);
+            }
+            catch (TaskCanceledException)
+            {
+                // If the task is cancelled, exit directly
+                foreach (var script in filesToAnalyze)
+                {
+                    PublishScriptDiagnostics(
+                        script,
+                        script.DiagnosticMarkers,
+                        correctionIndex);
+                }
+
+                return;
+            }
+
+            // If we've made it past the delay period then we don't care
+            // about the cancellation token anymore.  This could happen
+            // when the user stops typing for long enough that the delay
+            // period ends but then starts typing while analysis is going
+            // on.  It makes sense to send back the results from the first
+            // delay period while the second one is ticking away.
+
+            // Get the requested files
+            foreach (ScriptFile scriptFile in filesToAnalyze)
+            {
+                List<ScriptFileMarker> semanticMarkers = null;
+                if (isScriptAnalysisEnabled && _analysisService != null)
+                {
+                    semanticMarkers = await _analysisService.GetSemanticMarkersAsync(scriptFile);
+                }
+                else
+                {
+                    // Semantic markers aren't available if the AnalysisService
+                    // isn't available
+                    semanticMarkers = new List<ScriptFileMarker>();
+                }
+
+                scriptFile.DiagnosticMarkers.AddRange(semanticMarkers);
+
+                PublishScriptDiagnostics(
+                    scriptFile,
+                    // Concat script analysis errors to any existing parse errors
+                    scriptFile.DiagnosticMarkers,
+                    correctionIndex);
+            }
+        }
+
+        private void ClearMarkers(ScriptFile scriptFile)
+        {
+            // send empty diagnostic markers to clear any markers associated with the given file
+            PublishScriptDiagnostics(
+                    scriptFile,
+                    new List<ScriptFileMarker>(),
+                    this.codeActionsPerFile);
+        }
+
+        private void PublishScriptDiagnostics(
+            ScriptFile scriptFile,
+            List<ScriptFileMarker> markers,
+            Dictionary<string, Dictionary<string, MarkerCorrection>> correctionIndex)
+        {
+            List<Diagnostic> diagnostics = new List<Diagnostic>();
+
+            // Hold on to any corrections that may need to be applied later
+            Dictionary<string, MarkerCorrection> fileCorrections =
+                new Dictionary<string, MarkerCorrection>();
+
+            foreach (var marker in markers)
+            {
+                // Does the marker contain a correction?
+                Diagnostic markerDiagnostic = GetDiagnosticFromMarker(marker);
+                if (marker.Correction != null)
+                {
+                    string diagnosticId = GetUniqueIdFromDiagnostic(markerDiagnostic);
+                    fileCorrections.Add(diagnosticId, marker.Correction);
+                }
+
+                diagnostics.Add(markerDiagnostic);
+            }
+
+            correctionIndex[scriptFile.DocumentUri] = fileCorrections;
+
+            var uriBuilder = new UriBuilder()
+            {
+                Scheme = Uri.UriSchemeFile,
+                Path = scriptFile.FilePath,
+                Host = string.Empty,
+            };
+
+            // Always send syntax and semantic errors.  We want to
+            // make sure no out-of-date markers are being displayed.
+            _languageServer.Document.PublishDiagnostics(new PublishDiagnosticsParams()
+            {
+                Uri = uriBuilder.Uri,
+                Diagnostics = new Container<Diagnostic>(diagnostics),
+            });
+        }
+
+        // Generate a unique id that is used as a key to look up the associated code action (code fix) when
+        // we receive and process the textDocument/codeAction message.
+        private static string GetUniqueIdFromDiagnostic(Diagnostic diagnostic)
+        {
+            Position start = diagnostic.Range.Start;
+            Position end = diagnostic.Range.End;
+
+            var sb = new StringBuilder(256)
+            .Append(diagnostic.Source ?? "?")
+            .Append("_")
+            .Append(diagnostic.Code.ToString())
+            .Append("_")
+            .Append(diagnostic.Severity?.ToString() ?? "?")
+            .Append("_")
+            .Append(start.Line)
+            .Append(":")
+            .Append(start.Character)
+            .Append("-")
+            .Append(end.Line)
+            .Append(":")
+            .Append(end.Character);
+
+            var id = sb.ToString();
+            return id;
+        }
+
+        private static Diagnostic GetDiagnosticFromMarker(ScriptFileMarker scriptFileMarker)
+        {
+            return new Diagnostic
+            {
+                Severity = MapDiagnosticSeverity(scriptFileMarker.Level),
+                Message = scriptFileMarker.Message,
+                Code = scriptFileMarker.RuleName,
+                Source = scriptFileMarker.Source,
+                Range = new Range
+                {
+                    Start = new Position
+                    {
+                        Line = scriptFileMarker.ScriptRegion.StartLineNumber - 1,
+                        Character = scriptFileMarker.ScriptRegion.StartColumnNumber - 1
+                    },
+                    End = new Position
+                    {
+                        Line = scriptFileMarker.ScriptRegion.EndLineNumber - 1,
+                        Character = scriptFileMarker.ScriptRegion.EndColumnNumber - 1
+                    }
+                }
+            };
+        }
+
+        private static DiagnosticSeverity MapDiagnosticSeverity(ScriptFileMarkerLevel markerLevel)
+        {
+            switch (markerLevel)
+            {
+                case ScriptFileMarkerLevel.Error:
+                    return DiagnosticSeverity.Error;
+
+                case ScriptFileMarkerLevel.Warning:
+                    return DiagnosticSeverity.Warning;
+
+                case ScriptFileMarkerLevel.Information:
+                    return DiagnosticSeverity.Information;
+
+                default:
+                    return DiagnosticSeverity.Error;
+            }
+        }
     }
 }

src/PowerShellEditorServices.Engine/Services/Workspace/Handlers/WorkspaceSymbolsHandler.cs

@@ -11,7 +11,7 @@
 using OmniSharp.Extensions.LanguageServer.Protocol.Server;
 using PowerShellEditorServices.Engine.Utility;
 
-namespace PowerShellEditorServices.Engine.Services.Workspace.Handlers
+namespace PowerShellEditorServices.Engine.Services.Handlers
 {
     public class WorkspaceSymbolsHandler : IWorkspaceSymbolsHandler
     {