WIP OmniSharp update

andyleejordan · andyleejordan · commit a384a2c5b8d9 · 2021-03-12T14:05:46.000-08:00
diff --git a/src/PowerShellEditorServices/Server/PsesLanguageServer.cs b/src/PowerShellEditorServices/Server/PsesLanguageServer.cs
@@ -67,7 +67,7 @@ public async Task StartAsync()
                         .AddPsesLanguageServices(_hostDetails))
                     .ConfigureLogging(builder => builder
                         .AddSerilog(Log.Logger)
-                        .AddLanguageProtocolLogging(_minimumLogLevel)
+                        .AddLanguageProtocolLogging()
                         .SetMinimumLevel(_minimumLogLevel))
                     .WithHandler<PsesWorkspaceSymbolsHandler>()
                     .WithHandler<PsesTextDocumentHandler>()
diff --git a/src/PowerShellEditorServices/Services/DebugAdapter/DebugEventHandlerService.cs b/src/PowerShellEditorServices/Services/DebugAdapter/DebugEventHandlerService.cs
@@ -146,7 +146,11 @@ private void DebugService_BreakpointUpdated(object sender, BreakpointUpdatedEven
                     break;
             }
 
-            OmniSharp.Extensions.DebugAdapter.Protocol.Models.Breakpoint breakpoint;
+            var breakpoint = new OmniSharp.Extensions.DebugAdapter.Protocol.Models.Breakpoint
+            {
+                Verified = e.UpdateType != BreakpointUpdateType.Disabled
+            };
+
             if (e.Breakpoint is LineBreakpoint)
             {
                 breakpoint = LspDebugUtils.CreateBreakpoint(BreakpointDetails.Create(e.Breakpoint));
@@ -162,8 +166,6 @@ private void DebugService_BreakpointUpdated(object sender, BreakpointUpdatedEven
                 return;
             }
 
-            breakpoint.Verified = e.UpdateType != BreakpointUpdateType.Disabled;
-
             _debugAdapterServer.SendNotification(EventNames.Breakpoint,
                 new BreakpointEvent
                 {
diff --git a/src/PowerShellEditorServices/Services/DebugAdapter/Handlers/DebuggerActionHandlers.cs b/src/PowerShellEditorServices/Services/DebugAdapter/Handlers/DebuggerActionHandlers.cs
@@ -22,7 +22,7 @@ public DebuggerActionHandlers(
             ILoggerFactory loggerFactory,
             DebugService debugService)
         {
-            _logger = loggerFactory.CreateLogger<ContinueHandler>();
+            _logger = loggerFactory.CreateLogger<IContinueHandler>();
             _debugService = debugService;
         }
 
diff --git a/src/PowerShellEditorServices/Services/DebugAdapter/Handlers/LaunchAndAttachHandler.cs b/src/PowerShellEditorServices/Services/DebugAdapter/Handlers/LaunchAndAttachHandler.cs
@@ -22,7 +22,7 @@
 
 namespace Microsoft.PowerShell.EditorServices.Handlers
 {
-    internal class PsesLaunchRequestArguments : LaunchRequestArguments
+    internal record PsesLaunchRequestArguments : LaunchRequestArguments
     {
         /// <summary>
         /// Gets or sets the absolute path to the script to debug.
@@ -70,7 +70,7 @@ internal class PsesLaunchRequestArguments : LaunchRequestArguments
         public Dictionary<string, string> Env { get; set; }
     }
 
-    internal class PsesAttachRequestArguments : AttachRequestArguments
+    internal record PsesAttachRequestArguments : AttachRequestArguments
     {
         public string ComputerName { get; set; }
 
diff --git a/src/PowerShellEditorServices/Services/DebugAdapter/Handlers/ThreadsHandler.cs b/src/PowerShellEditorServices/Services/DebugAdapter/Handlers/ThreadsHandler.cs
@@ -16,13 +16,8 @@ public Task<ThreadsResponse> Handle(ThreadsArguments request, CancellationToken
         {
             return Task.FromResult(new ThreadsResponse
             {
-                // TODO: What do I do with these?
-                Threads = new Container<OmniSharp.Extensions.DebugAdapter.Protocol.Models.Thread>(
-                    new OmniSharp.Extensions.DebugAdapter.Protocol.Models.Thread
-                    {
-                        Id = 1,
-                        Name = "Main Thread"
-                    })
+                // TODO: This is an empty container of threads...do we need to make a thread?
+                Threads = new Container<System.Threading.Thread>()
             });
         }
     }
diff --git a/src/PowerShellEditorServices/Services/TextDocument/Handlers/CodeActionHandler.cs b/src/PowerShellEditorServices/Services/TextDocument/Handlers/CodeActionHandler.cs
@@ -19,15 +19,13 @@
 
 namespace Microsoft.PowerShell.EditorServices.Handlers
 {
-    internal class PsesCodeActionHandler : ICodeActionHandler
+    internal class PsesCodeActionHandler : CodeActionHandlerBase
     {
         private static readonly CodeActionKind[] s_supportedCodeActions = new[]
         {
             CodeActionKind.QuickFix
         };
 
-        private readonly CodeActionRegistrationOptions _registrationOptions;
-
         private readonly ILogger _logger;
 
         private readonly AnalysisService _analysisService;
@@ -41,24 +39,31 @@ public PsesCodeActionHandler(ILoggerFactory factory, AnalysisService analysisSer
             _logger = factory.CreateLogger<PsesCodeActionHandler>();
             _analysisService = analysisService;
             _workspaceService = workspaceService;
-            _registrationOptions = new CodeActionRegistrationOptions
+        }
+
+        protected override CodeActionRegistrationOptions CreateRegistrationOptions(CodeActionCapability capability, ClientCapabilities clientCapabilities) => new CodeActionRegistrationOptions
             {
-                DocumentSelector = LspUtils.PowerShellDocumentSelector,
+            // TODO: What do we do with the arguments?
+            DocumentSelector = LspUtils.PowerShellDocumentSelector,
                 CodeActionKinds = s_supportedCodeActions
-            };
-        }
+        };
 
-        public CodeActionRegistrationOptions GetRegistrationOptions()
+        public void SetCapability(CodeActionCapability capability)
         {
-            return _registrationOptions;
+            _capability = capability;
         }
 
-        public void SetCapability(CodeActionCapability capability)
+        public override async Task<CodeAction> Handle(CodeAction request, CancellationToken cancellationToken)
         {
-            _capability = capability;
+            // TODO: How on earth do we handle a CodeAction? This is new...
+            if (cancellationToken.IsCancellationRequested)
+            {
+                _logger.LogDebug("CodeAction request canceled for: {0}", request.Title);
+            }
+            return request;
         }
 
-        public async Task<CommandOrCodeActionContainer> Handle(CodeActionParams request, CancellationToken cancellationToken)
+        public override async Task<CommandOrCodeActionContainer> Handle(CodeActionParams request, CancellationToken cancellationToken)
         {
             if (cancellationToken.IsCancellationRequested)
             {
@@ -101,7 +106,7 @@ public async Task<CommandOrCodeActionContainer> Handle(CodeActionParams request,
                                 new WorkspaceEditDocumentChange(
                                     new TextDocumentEdit
                                     {
-                                        TextDocument = new VersionedTextDocumentIdentifier
+                                        TextDocument = new OptionalVersionedTextDocumentIdentifier
                                         {
                                             Uri = request.TextDocument.Uri
                                         },
diff --git a/src/PowerShellEditorServices/Services/TextDocument/Handlers/CodeLensHandlers.cs b/src/PowerShellEditorServices/Services/TextDocument/Handlers/CodeLensHandlers.cs
@@ -15,7 +15,6 @@
 using Microsoft.PowerShell.EditorServices.Services;
 using Microsoft.PowerShell.EditorServices.Services.TextDocument;
 using Microsoft.PowerShell.EditorServices.Utility;
-using OmniSharp.Extensions.LanguageServer.Protocol;
 using OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities;
 using OmniSharp.Extensions.LanguageServer.Protocol.Document;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
@@ -39,13 +38,15 @@ public PsesCodeLensHandlers(ILoggerFactory factory, SymbolsService symbolsServic
             _symbolsService = symbolsService;
         }
 
-        CodeLensRegistrationOptions IRegistration<CodeLensRegistrationOptions>.GetRegistrationOptions()
+        public CodeLensRegistrationOptions GetRegistrationOptions(CodeLensCapability capability, ClientCapabilities clientCapabilities) => new CodeLensRegistrationOptions
         {
-            return new CodeLensRegistrationOptions
-            {
-                DocumentSelector = LspUtils.PowerShellDocumentSelector,
-                ResolveProvider = true
-            };
+            DocumentSelector = LspUtils.PowerShellDocumentSelector,
+            ResolveProvider = true
+        };
+
+        public void SetCapability(CodeLensCapability capability, ClientCapabilities clientCapabilities)
+        {
+            _capability = capability;
         }
 
         public Task<CodeLensContainer> Handle(CodeLensParams request, CancellationToken cancellationToken)
@@ -57,14 +58,6 @@ public Task<CodeLensContainer> Handle(CodeLensParams request, CancellationToken
             return Task.FromResult(new CodeLensContainer(codeLensResults));
         }
 
-        public TextDocumentRegistrationOptions GetRegistrationOptions()
-        {
-            return new TextDocumentRegistrationOptions
-            {
-                DocumentSelector = LspUtils.PowerShellDocumentSelector,
-            };
-        }
-
         public bool CanResolve(CodeLens value)
         {
             CodeLensData codeLensData = value.Data.ToObject<CodeLensData>();
diff --git a/src/PowerShellEditorServices/Services/TextDocument/Handlers/CompletionHandler.cs b/src/PowerShellEditorServices/Services/TextDocument/Handlers/CompletionHandler.cs
@@ -21,7 +21,7 @@
 
 namespace Microsoft.PowerShell.EditorServices.Handlers
 {
-    internal class PsesCompletionHandler : ICompletionHandler, ICompletionResolveHandler
+    internal class PsesCompletionHandler : CompletionHandlerBase
     {
         const int DefaultWaitTimeoutMilliseconds = 5000;
         private readonly SemaphoreSlim _completionLock = AsyncUtils.CreateSimpleLockingSemaphore();
@@ -51,17 +51,14 @@ public PsesCompletionHandler(
             _workspaceService = workspaceService;
         }
 
-        public CompletionRegistrationOptions GetRegistrationOptions()
+        protected override CompletionRegistrationOptions CreateRegistrationOptions(CompletionCapability capability, ClientCapabilities clientCapabilities) => new CompletionRegistrationOptions
         {
-            return new CompletionRegistrationOptions
-            {
-                DocumentSelector = LspUtils.PowerShellDocumentSelector,
-                ResolveProvider = true,
-                TriggerCharacters = new[] { ".", "-", ":", "\\" }
-            };
-        }
+            DocumentSelector = LspUtils.PowerShellDocumentSelector,
+            ResolveProvider = true,
+            TriggerCharacters = new[] { ".", "-", ":", "\\" }
+        };
 
-        public async Task<CompletionList> Handle(CompletionParams request, CancellationToken cancellationToken)
+        public override async Task<CompletionList> Handle(CompletionParams request, CancellationToken cancellationToken)
         {
             int cursorLine = request.Position.Line + 1;
             int cursorColumn = request.Position.Character + 1;
@@ -117,7 +114,7 @@ public bool CanResolve(CompletionItem value)
         }
 
         // Handler for "completionItem/resolve". In VSCode this is fired when a completion item is highlighted in the completion list.
-        public async Task<CompletionItem> Handle(CompletionItem request, CancellationToken cancellationToken)
+        public async override Task<CompletionItem> Handle(CompletionItem request, CancellationToken cancellationToken)
         {
             // We currently only support this request for anything that returns a CommandInfo: functions, cmdlets, aliases.
             if (request.Kind != CompletionItemKind.Function)
@@ -145,10 +142,11 @@ await CommandHelpers.GetCommandInfoAsync(
 
                 if (commandInfo != null)
                 {
-                    request.Documentation =
-                        await CommandHelpers.GetCommandSynopsisAsync(
-                            commandInfo,
-                            _powerShellContextService).ConfigureAwait(false);
+                    return new CompletionItem()
+                    {
+                        // TODO: Do we need to fill in the rest of the fields?
+                        Documentation = await CommandHelpers.GetCommandSynopsisAsync(commandInfo, _powerShellContextService).ConfigureAwait(false)
+                    };
                 }
 
                 // Send back the updated CompletionItem
diff --git a/src/PowerShellEditorServices/Services/TextDocument/Handlers/DefinitionHandler.cs b/src/PowerShellEditorServices/Services/TextDocument/Handlers/DefinitionHandler.cs
@@ -36,13 +36,10 @@ public PsesDefinitionHandler(
             _workspaceService = workspaceService;
         }
 
-        public DefinitionRegistrationOptions GetRegistrationOptions()
+        public DefinitionRegistrationOptions GetRegistrationOptions(DefinitionCapability capability, ClientCapabilities clientCapabilities) => new DefinitionRegistrationOptions
         {
-            return new DefinitionRegistrationOptions
-            {
-                DocumentSelector = LspUtils.PowerShellDocumentSelector
-            };
-        }
+            DocumentSelector = LspUtils.PowerShellDocumentSelector
+        };
 
         public async Task<LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
         {
diff --git a/src/PowerShellEditorServices/Services/TextDocument/Handlers/DocumentHighlightHandler.cs b/src/PowerShellEditorServices/Services/TextDocument/Handlers/DocumentHighlightHandler.cs
@@ -40,13 +40,10 @@ public PsesDocumentHighlightHandler(
             _logger.LogInformation("highlight handler loaded");
         }
 
-        public DocumentHighlightRegistrationOptions GetRegistrationOptions()
+        public DocumentHighlightRegistrationOptions GetRegistrationOptions(DocumentHighlightCapability capab, ClientCapabilities clientCapabilities) => new DocumentHighlightRegistrationOptions
         {
-            return new DocumentHighlightRegistrationOptions
-            {
-                DocumentSelector = LspUtils.PowerShellDocumentSelector
-            };
-        }
+            DocumentSelector = LspUtils.PowerShellDocumentSelector
+        };
 
         public Task<DocumentHighlightContainer> Handle(
             DocumentHighlightParams request,
diff --git a/src/PowerShellEditorServices/Services/TextDocument/Handlers/DocumentSymbolHandler.cs b/src/PowerShellEditorServices/Services/TextDocument/Handlers/DocumentSymbolHandler.cs
@@ -23,7 +23,7 @@
 
 namespace Microsoft.PowerShell.EditorServices.Handlers
 {
-    internal class PsesDocumentSymbolHandler : IDocumentSymbolHandler
+    internal class PsesDocumentSymbolHandler : DocumentSymbolHandlerBase
     {
         private readonly ILogger _logger;
         private readonly WorkspaceService _workspaceService;
@@ -44,15 +44,12 @@ public PsesDocumentSymbolHandler(ILoggerFactory factory, ConfigurationService co
             };
         }
 
-        public DocumentSymbolRegistrationOptions GetRegistrationOptions()
+        protected override DocumentSymbolRegistrationOptions CreateRegistrationOptions(DocumentSymbolCapability capability, ClientCapabilities clientCapabilities) => new DocumentSymbolRegistrationOptions
         {
-            return new DocumentSymbolRegistrationOptions
-            {
-                DocumentSelector = LspUtils.PowerShellDocumentSelector
-            };
-        }
+            DocumentSelector = LspUtils.PowerShellDocumentSelector
+        };
 
-        public Task<SymbolInformationOrDocumentSymbolContainer> Handle(DocumentSymbolParams request, CancellationToken cancellationToken)
+        public override Task<SymbolInformationOrDocumentSymbolContainer> Handle(DocumentSymbolParams request, CancellationToken cancellationToken)
         {
             ScriptFile scriptFile = _workspaceService.GetFile(request.TextDocument.Uri);
 
diff --git a/src/PowerShellEditorServices/Services/TextDocument/Handlers/FoldingRangeHandler.cs b/src/PowerShellEditorServices/Services/TextDocument/Handlers/FoldingRangeHandler.cs
@@ -16,7 +16,7 @@
 
 namespace Microsoft.PowerShell.EditorServices.Handlers
 {
-    internal class PsesFoldingRangeHandler : IFoldingRangeHandler
+    internal class PsesFoldingRangeHandler : FoldingRangeHandlerBase
     {
         private readonly ILogger _logger;
         private readonly ConfigurationService _configurationService;
@@ -26,20 +26,17 @@ internal class PsesFoldingRangeHandler : IFoldingRangeHandler
 
         public PsesFoldingRangeHandler(ILoggerFactory factory, ConfigurationService configurationService, WorkspaceService workspaceService)
         {
-            _logger = factory.CreateLogger<FoldingRangeHandler>();
+            _logger = factory.CreateLogger<PsesFoldingRangeHandler>();
             _configurationService = configurationService;
             _workspaceService = workspaceService;
         }
 
-        public FoldingRangeRegistrationOptions GetRegistrationOptions()
+        protected override FoldingRangeRegistrationOptions CreateRegistrationOptions(FoldingRangeCapability capability, ClientCapabilities clientCapabilities) => new FoldingRangeRegistrationOptions
         {
-            return new FoldingRangeRegistrationOptions
-            {
-                DocumentSelector = LspUtils.PowerShellDocumentSelector
-            };
-        }
+            DocumentSelector = LspUtils.PowerShellDocumentSelector
+        };
 
-        public Task<Container<FoldingRange>> Handle(FoldingRangeRequestParam request, CancellationToken cancellationToken)
+        public override Task<Container<FoldingRange>> Handle(FoldingRangeRequestParam request, CancellationToken cancellationToken)
         {
             if (cancellationToken.IsCancellationRequested)
             {
diff --git a/src/PowerShellEditorServices/Services/TextDocument/Handlers/PsesSemanticTokensHandler.cs b/src/PowerShellEditorServices/Services/TextDocument/Handlers/PsesSemanticTokensHandler.cs
@@ -13,15 +13,14 @@
 using Microsoft.PowerShell.EditorServices.Services.TextDocument;
 using Microsoft.PowerShell.EditorServices.Utility;
 using OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities;
-using OmniSharp.Extensions.LanguageServer.Protocol.Document.Proposals;
+using OmniSharp.Extensions.LanguageServer.Protocol.Document;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
-using OmniSharp.Extensions.LanguageServer.Protocol.Models.Proposals;
 
 namespace Microsoft.PowerShell.EditorServices.Handlers
 {
     internal class PsesSemanticTokensHandler : SemanticTokensHandlerBase
     {
-        private static readonly SemanticTokensRegistrationOptions s_registrationOptions = new SemanticTokensRegistrationOptions
+        protected override SemanticTokensRegistrationOptions CreateRegistrationOptions(SemanticTokensCapability capability, ClientCapabilities clientCapabilities) => new SemanticTokensRegistrationOptions
         {
             DocumentSelector = LspUtils.PowerShellDocumentSelector,
             Legend = new SemanticTokensLegend(),
@@ -36,7 +35,6 @@ internal class PsesSemanticTokensHandler : SemanticTokensHandlerBase
         private readonly WorkspaceService _workspaceService;
 
         public PsesSemanticTokensHandler(ILogger<PsesSemanticTokensHandler> logger, WorkspaceService workspaceService)
-            : base(s_registrationOptions)
         {
             _logger = logger;
             _workspaceService = workspaceService;
@@ -161,7 +159,7 @@ protected override Task<SemanticTokensDocument> GetSemanticTokensDocument(
             ITextDocumentIdentifierParams @params,
             CancellationToken cancellationToken)
         {
-            return Task.FromResult(new SemanticTokensDocument(GetRegistrationOptions().Legend));
+            return Task.FromResult(new SemanticTokensDocument(RegistrationOptions.Legend));
         }
     }
 }
diff --git a/src/PowerShellEditorServices/Services/TextDocument/Handlers/ReferencesHandler.cs b/src/PowerShellEditorServices/Services/TextDocument/Handlers/ReferencesHandler.cs
diff --git a/src/PowerShellEditorServices/Services/TextDocument/Handlers/TextDocumentHandler.cs b/src/PowerShellEditorServices/Services/TextDocument/Handlers/TextDocumentHandler.cs
diff --git a/src/PowerShellEditorServices/Services/TextDocument/SemanticToken.cs b/src/PowerShellEditorServices/Services/TextDocument/SemanticToken.cs
diff --git a/src/PowerShellEditorServices/Services/Workspace/Handlers/ConfigurationHandler.cs b/src/PowerShellEditorServices/Services/Workspace/Handlers/ConfigurationHandler.cs
diff --git a/src/PowerShellEditorServices/Services/Workspace/Handlers/WorkspaceSymbolsHandler.cs b/src/PowerShellEditorServices/Services/Workspace/Handlers/WorkspaceSymbolsHandler.cs

Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,11 @@ private void DebugService_BreakpointUpdated(object sender, BreakpointUpdatedEven`
`146`	`146`	`break;`
`147`	`147`	`}`
`148`	`148`
`149`		`- OmniSharp.Extensions.DebugAdapter.Protocol.Models.Breakpoint breakpoint;`
	`149`	`+ var breakpoint = new OmniSharp.Extensions.DebugAdapter.Protocol.Models.Breakpoint`
	`150`	`+ {`
	`151`	`+ Verified = e.UpdateType != BreakpointUpdateType.Disabled`
	`152`	`+ };`
	`153`	`+`
`150`	`154`	`if (e.Breakpoint is LineBreakpoint)`
`151`	`155`	`{`
`152`	`156`	`breakpoint = LspDebugUtils.CreateBreakpoint(BreakpointDetails.Create(e.Breakpoint));`
`@@ -162,8 +166,6 @@ private void DebugService_BreakpointUpdated(object sender, BreakpointUpdatedEven`
`162`	`166`	`return;`
`163`	`167`	`}`
`164`	`168`
`165`		`- breakpoint.Verified = e.UpdateType != BreakpointUpdateType.Disabled;`
`166`		`-`
`167`	`169`	`_debugAdapterServer.SendNotification(EventNames.Breakpoint,`
`168`	`170`	`new BreakpointEvent`
`169`	`171`	`{`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public DebuggerActionHandlers(`
`22`	`22`	`ILoggerFactory loggerFactory,`
`23`	`23`	`DebugService debugService)`
`24`	`24`	`{`
`25`		`- _logger = loggerFactory.CreateLogger<ContinueHandler>();`
	`25`	`+ _logger = loggerFactory.CreateLogger<IContinueHandler>();`
`26`	`26`	`_debugService = debugService;`
`27`	`27`	`}`
`28`	`28`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@`
`22`	`22`
`23`	`23`	`namespace Microsoft.PowerShell.EditorServices.Handlers`
`24`	`24`	`{`
`25`		`- internal class PsesLaunchRequestArguments : LaunchRequestArguments`
	`25`	`+ internal record PsesLaunchRequestArguments : LaunchRequestArguments`
`26`	`26`	`{`
`27`	`27`	`/// <summary>`
`28`	`28`	`/// Gets or sets the absolute path to the script to debug.`
`@@ -70,7 +70,7 @@ internal class PsesLaunchRequestArguments : LaunchRequestArguments`
`70`	`70`	`public Dictionary<string, string> Env { get; set; }`
`71`	`71`	`}`
`72`	`72`
`73`		`- internal class PsesAttachRequestArguments : AttachRequestArguments`
	`73`	`+ internal record PsesAttachRequestArguments : AttachRequestArguments`
`74`	`74`	`{`
`75`	`75`	`public string ComputerName { get; set; }`
`76`	`76`
Original file line number	Diff line number	Diff line change
`@@ -16,13 +16,8 @@ public Task<ThreadsResponse> Handle(ThreadsArguments request, CancellationToken`
`16`	`16`	`{`
`17`	`17`	`return Task.FromResult(new ThreadsResponse`
`18`	`18`	`{`
`19`		`- // TODO: What do I do with these?`
`20`		`- Threads = new Container<OmniSharp.Extensions.DebugAdapter.Protocol.Models.Thread>(`
`21`		`- new OmniSharp.Extensions.DebugAdapter.Protocol.Models.Thread`
`22`		`- {`
`23`		`- Id = 1,`
`24`		`- Name = "Main Thread"`
`25`		`- })`
	`19`	`+ // TODO: This is an empty container of threads...do we need to make a thread?`
	`20`	`+ Threads = new Container<System.Threading.Thread>()`
`26`	`21`	`});`
`27`	`22`	`}`
`28`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,15 +19,13 @@`
`19`	`19`
`20`	`20`	`namespace Microsoft.PowerShell.EditorServices.Handlers`
`21`	`21`	`{`
`22`		`- internal class PsesCodeActionHandler : ICodeActionHandler`
	`22`	`+ internal class PsesCodeActionHandler : CodeActionHandlerBase`
`23`	`23`	`{`
`24`	`24`	`private static readonly CodeActionKind[] s_supportedCodeActions = new[]`
`25`	`25`	`{`
`26`	`26`	`CodeActionKind.QuickFix`
`27`	`27`	`};`
`28`	`28`
`29`		`- private readonly CodeActionRegistrationOptions _registrationOptions;`
`30`		`-`
`31`	`29`	`private readonly ILogger _logger;`
`32`	`30`
`33`	`31`	`private readonly AnalysisService _analysisService;`
`@@ -41,24 +39,31 @@ public PsesCodeActionHandler(ILoggerFactory factory, AnalysisService analysisSer`
`41`	`39`	`_logger = factory.CreateLogger<PsesCodeActionHandler>();`
`42`	`40`	`_analysisService = analysisService;`
`43`	`41`	`_workspaceService = workspaceService;`
`44`		`- _registrationOptions = new CodeActionRegistrationOptions`
	`42`	`+ }`
	`43`	`+`
	`44`	`+ protected override CodeActionRegistrationOptions CreateRegistrationOptions(CodeActionCapability capability, ClientCapabilities clientCapabilities) => new CodeActionRegistrationOptions`
`45`	`45`	`{`
`46`		`- DocumentSelector = LspUtils.PowerShellDocumentSelector,`
	`46`	`+ // TODO: What do we do with the arguments?`
	`47`	`+ DocumentSelector = LspUtils.PowerShellDocumentSelector,`
`47`	`48`	`CodeActionKinds = s_supportedCodeActions`
`48`		`- };`
`49`		`- }`
	`49`	`+ };`
`50`	`50`
`51`		`- public CodeActionRegistrationOptions GetRegistrationOptions()`
	`51`	`+ public void SetCapability(CodeActionCapability capability)`
`52`	`52`	`{`
`53`		`- return _registrationOptions;`
	`53`	`+ _capability = capability;`
`54`	`54`	`}`
`55`	`55`
`56`		`- public void SetCapability(CodeActionCapability capability)`
	`56`	`+ public override async Task<CodeAction> Handle(CodeAction request, CancellationToken cancellationToken)`
`57`	`57`	`{`
`58`		`- _capability = capability;`
	`58`	`+ // TODO: How on earth do we handle a CodeAction? This is new...`
	`59`	`+ if (cancellationToken.IsCancellationRequested)`
	`60`	`+ {`
	`61`	`+ _logger.LogDebug("CodeAction request canceled for: {0}", request.Title);`
	`62`	`+ }`
	`63`	`+ return request;`
`59`	`64`	`}`
`60`	`65`
`61`		`- public async Task<CommandOrCodeActionContainer> Handle(CodeActionParams request, CancellationToken cancellationToken)`
	`66`	`+ public override async Task<CommandOrCodeActionContainer> Handle(CodeActionParams request, CancellationToken cancellationToken)`
`62`	`67`	`{`
`63`	`68`	`if (cancellationToken.IsCancellationRequested)`
`64`	`69`	`{`
`@@ -101,7 +106,7 @@ public async Task<CommandOrCodeActionContainer> Handle(CodeActionParams request,`
`101`	`106`	`new WorkspaceEditDocumentChange(`
`102`	`107`	`new TextDocumentEdit`
`103`	`108`	`{`
`104`		`- TextDocument = new VersionedTextDocumentIdentifier`
	`109`	`+ TextDocument = new OptionalVersionedTextDocumentIdentifier`
`105`	`110`	`{`
`106`	`111`	`Uri = request.TextDocument.Uri`
`107`	`112`	`},`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@`
`21`	`21`
`22`	`22`	`namespace Microsoft.PowerShell.EditorServices.Handlers`
`23`	`23`	`{`
`24`		`- internal class PsesCompletionHandler : ICompletionHandler, ICompletionResolveHandler`
	`24`	`+ internal class PsesCompletionHandler : CompletionHandlerBase`
`25`	`25`	`{`
`26`	`26`	`const int DefaultWaitTimeoutMilliseconds = 5000;`
`27`	`27`	`private readonly SemaphoreSlim _completionLock = AsyncUtils.CreateSimpleLockingSemaphore();`
`@@ -51,17 +51,14 @@ public PsesCompletionHandler(`
`51`	`51`	`_workspaceService = workspaceService;`
`52`	`52`	`}`
`53`	`53`
`54`		`- public CompletionRegistrationOptions GetRegistrationOptions()`
	`54`	`+ protected override CompletionRegistrationOptions CreateRegistrationOptions(CompletionCapability capability, ClientCapabilities clientCapabilities) => new CompletionRegistrationOptions`
`55`	`55`	`{`
`56`		`- return new CompletionRegistrationOptions`
`57`		`- {`
`58`		`- DocumentSelector = LspUtils.PowerShellDocumentSelector,`
`59`		`- ResolveProvider = true,`
`60`		`- TriggerCharacters = new[] { ".", "-", ":", "\\" }`
`61`		`- };`
`62`		`- }`
	`56`	`+ DocumentSelector = LspUtils.PowerShellDocumentSelector,`
	`57`	`+ ResolveProvider = true,`
	`58`	`+ TriggerCharacters = new[] { ".", "-", ":", "\\" }`
	`59`	`+ };`
`63`	`60`
`64`		`- public async Task<CompletionList> Handle(CompletionParams request, CancellationToken cancellationToken)`
	`61`	`+ public override async Task<CompletionList> Handle(CompletionParams request, CancellationToken cancellationToken)`
`65`	`62`	`{`
`66`	`63`	`int cursorLine = request.Position.Line + 1;`
`67`	`64`	`int cursorColumn = request.Position.Character + 1;`
`@@ -117,7 +114,7 @@ public bool CanResolve(CompletionItem value)`
`117`	`114`	`}`
`118`	`115`
`119`	`116`	`// Handler for "completionItem/resolve". In VSCode this is fired when a completion item is highlighted in the completion list.`
`120`		`- public async Task<CompletionItem> Handle(CompletionItem request, CancellationToken cancellationToken)`
	`117`	`+ public async override Task<CompletionItem> Handle(CompletionItem request, CancellationToken cancellationToken)`
`121`	`118`	`{`
`122`	`119`	`// We currently only support this request for anything that returns a CommandInfo: functions, cmdlets, aliases.`
`123`	`120`	`if (request.Kind != CompletionItemKind.Function)`
`@@ -145,10 +142,11 @@ await CommandHelpers.GetCommandInfoAsync(`
`145`	`142`
`146`	`143`	`if (commandInfo != null)`
`147`	`144`	`{`
`148`		`- request.Documentation =`
`149`		`- await CommandHelpers.GetCommandSynopsisAsync(`
`150`		`- commandInfo,`
`151`		`- _powerShellContextService).ConfigureAwait(false);`
	`145`	`+ return new CompletionItem()`
	`146`	`+ {`
	`147`	`+ // TODO: Do we need to fill in the rest of the fields?`
	`148`	`+ Documentation = await CommandHelpers.GetCommandSynopsisAsync(commandInfo, _powerShellContextService).ConfigureAwait(false)`
	`149`	`+ };`
`152`	`150`	`}`
`153`	`151`
`154`	`152`	`// Send back the updated CompletionItem`
Original file line number	Diff line number	Diff line change
`@@ -36,13 +36,10 @@ public PsesDefinitionHandler(`
`36`	`36`	`_workspaceService = workspaceService;`
`37`	`37`	`}`
`38`	`38`
`39`		`- public DefinitionRegistrationOptions GetRegistrationOptions()`
	`39`	`+ public DefinitionRegistrationOptions GetRegistrationOptions(DefinitionCapability capability, ClientCapabilities clientCapabilities) => new DefinitionRegistrationOptions`
`40`	`40`	`{`
`41`		`- return new DefinitionRegistrationOptions`
`42`		`- {`
`43`		`- DocumentSelector = LspUtils.PowerShellDocumentSelector`
`44`		`- };`
`45`		`- }`
	`41`	`+ DocumentSelector = LspUtils.PowerShellDocumentSelector`
	`42`	`+ };`
`46`	`43`
`47`	`44`	`public async Task<LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)`
`48`	`45`	`{`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@`
`23`	`23`
`24`	`24`	`namespace Microsoft.PowerShell.EditorServices.Handlers`
`25`	`25`	`{`
`26`		`- internal class PsesDocumentSymbolHandler : IDocumentSymbolHandler`
	`26`	`+ internal class PsesDocumentSymbolHandler : DocumentSymbolHandlerBase`
`27`	`27`	`{`
`28`	`28`	`private readonly ILogger _logger;`
`29`	`29`	`private readonly WorkspaceService _workspaceService;`
`@@ -44,15 +44,12 @@ public PsesDocumentSymbolHandler(ILoggerFactory factory, ConfigurationService co`
`44`	`44`	`};`
`45`	`45`	`}`
`46`	`46`
`47`		`- public DocumentSymbolRegistrationOptions GetRegistrationOptions()`
	`47`	`+ protected override DocumentSymbolRegistrationOptions CreateRegistrationOptions(DocumentSymbolCapability capability, ClientCapabilities clientCapabilities) => new DocumentSymbolRegistrationOptions`
`48`	`48`	`{`
`49`		`- return new DocumentSymbolRegistrationOptions`
`50`		`- {`
`51`		`- DocumentSelector = LspUtils.PowerShellDocumentSelector`
`52`		`- };`
`53`		`- }`
	`49`	`+ DocumentSelector = LspUtils.PowerShellDocumentSelector`
	`50`	`+ };`
`54`	`51`
`55`		`- public Task<SymbolInformationOrDocumentSymbolContainer> Handle(DocumentSymbolParams request, CancellationToken cancellationToken)`
	`52`	`+ public override Task<SymbolInformationOrDocumentSymbolContainer> Handle(DocumentSymbolParams request, CancellationToken cancellationToken)`
`56`	`53`	`{`
`57`	`54`	`ScriptFile scriptFile = _workspaceService.GetFile(request.TextDocument.Uri);`
`58`	`55`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@`
`16`	`16`
`17`	`17`	`namespace Microsoft.PowerShell.EditorServices.Handlers`
`18`	`18`	`{`
`19`		`- internal class PsesFoldingRangeHandler : IFoldingRangeHandler`
	`19`	`+ internal class PsesFoldingRangeHandler : FoldingRangeHandlerBase`
`20`	`20`	`{`
`21`	`21`	`private readonly ILogger _logger;`
`22`	`22`	`private readonly ConfigurationService _configurationService;`
`@@ -26,20 +26,17 @@ internal class PsesFoldingRangeHandler : IFoldingRangeHandler`
`26`	`26`
`27`	`27`	`public PsesFoldingRangeHandler(ILoggerFactory factory, ConfigurationService configurationService, WorkspaceService workspaceService)`
`28`	`28`	`{`
`29`		`- _logger = factory.CreateLogger<FoldingRangeHandler>();`
	`29`	`+ _logger = factory.CreateLogger<PsesFoldingRangeHandler>();`
`30`	`30`	`_configurationService = configurationService;`
`31`	`31`	`_workspaceService = workspaceService;`
`32`	`32`	`}`
`33`	`33`
`34`		`- public FoldingRangeRegistrationOptions GetRegistrationOptions()`
	`34`	`+ protected override FoldingRangeRegistrationOptions CreateRegistrationOptions(FoldingRangeCapability capability, ClientCapabilities clientCapabilities) => new FoldingRangeRegistrationOptions`
`35`	`35`	`{`
`36`		`- return new FoldingRangeRegistrationOptions`
`37`		`- {`
`38`		`- DocumentSelector = LspUtils.PowerShellDocumentSelector`
`39`		`- };`
`40`		`- }`
	`36`	`+ DocumentSelector = LspUtils.PowerShellDocumentSelector`
	`37`	`+ };`
`41`	`38`
`42`		`- public Task<Container<FoldingRange>> Handle(FoldingRangeRequestParam request, CancellationToken cancellationToken)`
	`39`	`+ public override Task<Container<FoldingRange>> Handle(FoldingRangeRequestParam request, CancellationToken cancellationToken)`
`43`	`40`	`{`
`44`	`41`	`if (cancellationToken.IsCancellationRequested)`
`45`	`42`	`{`
Original file line number	Diff line number	Diff line change
`@@ -13,15 +13,14 @@`
`13`	`13`	`using Microsoft.PowerShell.EditorServices.Services.TextDocument;`
`14`	`14`	`using Microsoft.PowerShell.EditorServices.Utility;`
`15`	`15`	`using OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities;`
`16`		`-using OmniSharp.Extensions.LanguageServer.Protocol.Document.Proposals;`
	`16`	`+using OmniSharp.Extensions.LanguageServer.Protocol.Document;`
`17`	`17`	`using OmniSharp.Extensions.LanguageServer.Protocol.Models;`
`18`		`-using OmniSharp.Extensions.LanguageServer.Protocol.Models.Proposals;`
`19`	`18`
`20`	`19`	`namespace Microsoft.PowerShell.EditorServices.Handlers`
`21`	`20`	`{`
`22`	`21`	`internal class PsesSemanticTokensHandler : SemanticTokensHandlerBase`
`23`	`22`	`{`
`24`		`- private static readonly SemanticTokensRegistrationOptions s_registrationOptions = new SemanticTokensRegistrationOptions`
	`23`	`+ protected override SemanticTokensRegistrationOptions CreateRegistrationOptions(SemanticTokensCapability capability, ClientCapabilities clientCapabilities) => new SemanticTokensRegistrationOptions`
`25`	`24`	`{`
`26`	`25`	`DocumentSelector = LspUtils.PowerShellDocumentSelector,`
`27`	`26`	`Legend = new SemanticTokensLegend(),`
`@@ -36,7 +35,6 @@ internal class PsesSemanticTokensHandler : SemanticTokensHandlerBase`
`36`	`35`	`private readonly WorkspaceService _workspaceService;`
`37`	`36`
`38`	`37`	`public PsesSemanticTokensHandler(ILogger<PsesSemanticTokensHandler> logger, WorkspaceService workspaceService)`
`39`		`- : base(s_registrationOptions)`
`40`	`38`	`{`
`41`	`39`	`_logger = logger;`
`42`	`40`	`_workspaceService = workspaceService;`
`@@ -161,7 +159,7 @@ protected override Task<SemanticTokensDocument> GetSemanticTokensDocument(`
`161`	`159`	`ITextDocumentIdentifierParams @params,`
`162`	`160`	`CancellationToken cancellationToken)`
`163`	`161`	`{`
`164`		`- return Task.FromResult(new SemanticTokensDocument(GetRegistrationOptions().Legend));`
	`162`	`+ return Task.FromResult(new SemanticTokensDocument(RegistrationOptions.Legend));`
`165`	`163`	`}`
`166`	`164`	`}`
`167`	`165`	`}`