Get it building again

By searching OmniSharp's diff for what changed, whee.

Author: andyleejordan

src/PowerShellEditorServices/Services/TextDocument/FoldingReference.cs

@@ -58,22 +58,18 @@ public int CompareTo(FoldingReference that)
             if (EndCharacter > that.EndCharacter) { return 1; }
 
             // They're the same range, but what about kind
-            if (Kind == null)
+            if (Kind == that.Kind)
             {
-                if (that.Kind == null)
-                {
-                    return 0;
-                }
-                // that has a kind but this doesn't.
-                return 1;
+                return 0;
             }
 
-            if (that.Kind != null)
+            // That has a kind but this doesn't.
+            if (Kind is null && that.Kind is not null)
             {
-                return that.Kind.Value - Kind.Value;
+                return 1;
             }
 
-            // this has a kind but that doesn't.
+            // This has a kind but that doesn't.
             return -1;
         }
 

src/PowerShellEditorServices/Services/TextDocument/Handlers/DocumentSymbolHandler.cs

@@ -2,15 +2,13 @@
 // Licensed under the MIT License.
 
 using System.Collections.Generic;
-using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Microsoft.PowerShell.EditorServices.Services;
 using Microsoft.PowerShell.EditorServices.Services.Symbols;
 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;
@@ -48,7 +46,6 @@ public override async Task<SymbolInformationOrDocumentSymbolContainer> Handle(Do
             _logger.LogDebug($"Handling document symbols for {request.TextDocument.Uri}");
 
             ScriptFile scriptFile = _workspaceService.GetFile(request.TextDocument.Uri);
-            string containerName = Path.GetFileNameWithoutExtension(scriptFile.FilePath);
             List<SymbolInformationOrDocumentSymbol> symbols = new();
 
             foreach (SymbolReference r in ProvideDocumentSymbols(scriptFile))
@@ -70,27 +67,15 @@ public override async Task<SymbolInformationOrDocumentSymbolContainer> Handle(Do
                     continue;
                 }
 
-                // TODO: This should be a DocumentSymbol now as SymbolInformation is deprecated. But
-                // this requires figuring out how to populate `children`. Once we do that, the range
-                // can be NameRegion.
-                //
-                // symbols.Add(new SymbolInformationOrDocumentSymbol(new DocumentSymbol
-                // {
-                //     Name = SymbolTypeUtils.GetDecoratedSymbolName(r),
-                //     Kind = SymbolTypeUtils.GetSymbolKind(r.SymbolType),
-                //     Range = r.ScriptRegion.ToRange(),
-                //     SelectionRange = r.NameRegion.ToRange()
-                // }));
-                symbols.Add(new SymbolInformationOrDocumentSymbol(new SymbolInformation
+                // TODO: This now needs the Children property filled out to support hierarchical
+                // symbols, and we don't have the information nor algorithm to do that currently.
+                // OmniSharp was previously doing this for us based on the range, perhaps we can
+                // find that logic and reuse it.
+                symbols.Add(new SymbolInformationOrDocumentSymbol(new DocumentSymbol
                 {
-                    ContainerName = containerName,
                     Kind = SymbolTypeUtils.GetSymbolKind(r.Type),
-                    Location = new Location
-                    {
-                        Uri = DocumentUri.From(r.FilePath),
-                        // Jump to name start, but keep whole range to support symbol tree in outline
-                        Range = new Range(r.NameRegion.ToRange().Start, r.ScriptRegion.ToRange().End)
-                    },
+                    Range = r.ScriptRegion.ToRange(),
+                    SelectionRange = r.NameRegion.ToRange(),
                     Name = r.Name
                 }));
             }

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

@@ -61,7 +61,7 @@ public override Task<Unit> Handle(DidChangeTextDocumentParams notification, Canc
             return Unit.Task;
         }
 
-        protected override TextDocumentSyncRegistrationOptions CreateRegistrationOptions(SynchronizationCapability capability, ClientCapabilities clientCapabilities)
+        protected override TextDocumentSyncRegistrationOptions CreateRegistrationOptions(TextSynchronizationCapability capability, ClientCapabilities clientCapabilities)
         {
             _isFileWatcherSupported = clientCapabilities.Workspace.DidChangeWatchedFiles.IsSupported;
             return new TextDocumentSyncRegistrationOptions()

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

@@ -19,7 +19,7 @@ namespace Microsoft.PowerShell.EditorServices.Handlers
 {
     internal class PsesWorkspaceSymbolsHandler : WorkspaceSymbolsHandlerBase
     {
-        private static readonly Container<SymbolInformation> s_emptySymbolInformationContainer = new();
+        private static readonly Container<WorkspaceSymbol> s_emptySymbolInformationContainer = new();
         private readonly ILogger _logger;
         private readonly SymbolsService _symbolsService;
         private readonly WorkspaceService _workspaceService;
@@ -33,12 +33,12 @@ public PsesWorkspaceSymbolsHandler(ILoggerFactory loggerFactory, SymbolsService
 
         protected override WorkspaceSymbolRegistrationOptions CreateRegistrationOptions(WorkspaceSymbolCapability capability, ClientCapabilities clientCapabilities) => new() { };
 
-        public override async Task<Container<SymbolInformation>> Handle(WorkspaceSymbolParams request, CancellationToken cancellationToken)
+        public override async Task<Container<WorkspaceSymbol>> Handle(WorkspaceSymbolParams request, CancellationToken cancellationToken)
         {
             _logger.LogDebug($"Handling workspace symbols request for query {request.Query}");
 
             await _symbolsService.ScanWorkspacePSFiles(cancellationToken).ConfigureAwait(false);
-            List<SymbolInformation> symbols = new();
+            List<WorkspaceSymbol> symbols = new();
 
             foreach (ScriptFile scriptFile in _workspaceService.GetOpenedFiles())
             {
@@ -84,8 +84,7 @@ public override async Task<Container<SymbolInformation>> Handle(WorkspaceSymbolP
                         Range = symbol.NameRegion.ToRange()
                     };
 
-                    // TODO: This should be a WorkplaceSymbol now as SymbolInformation is deprecated.
-                    symbols.Add(new SymbolInformation
+                    symbols.Add(new WorkspaceSymbol
                     {
                         ContainerName = containerName,
                         Kind = SymbolTypeUtils.GetSymbolKind(symbol.Type),

src/PowerShellEditorServices/Utility/LspUtils.cs

@@ -7,19 +7,19 @@ namespace Microsoft.PowerShell.EditorServices.Utility
 {
     internal static class LspUtils
     {
-        public static DocumentSelector PowerShellDocumentSelector => new(
-            DocumentFilter.ForLanguage("powershell"),
-            DocumentFilter.ForLanguage("pwsh"),
+        public static TextDocumentSelector PowerShellDocumentSelector => new(
+            TextDocumentFilter.ForLanguage("powershell"),
+            TextDocumentFilter.ForLanguage("pwsh"),
 
             // The vim extension sets all PowerShell files as language "ps1" so this
             // makes sure we track those.
-            DocumentFilter.ForLanguage("ps1"),
-            DocumentFilter.ForLanguage("psm1"),
-            DocumentFilter.ForLanguage("psd1"),
+            TextDocumentFilter.ForLanguage("ps1"),
+            TextDocumentFilter.ForLanguage("psm1"),
+            TextDocumentFilter.ForLanguage("psd1"),
 
             // Also specify the file extensions to be thorough
             // This won't handle untitled files which is why we have to do the ones above.
-            DocumentFilter.ForPattern("**/*.ps*1")
+            TextDocumentFilter.ForPattern("**/*.ps*1")
         );
     }
 }

test/PowerShellEditorServices.Test.E2E/LanguageServerProtocolMessageTests.cs

@@ -122,16 +122,16 @@ function CanSendWorkspaceSymbolRequest {
 }
 ");
 
-            Container<SymbolInformation> symbols = await PsesLanguageClient
+            Container<WorkspaceSymbol> symbols = await PsesLanguageClient
                 .SendRequest(
                     "workspace/symbol",
                     new WorkspaceSymbolParams
                     {
                         Query = "CanSendWorkspaceSymbolRequest"
                     })
-                .Returning<Container<SymbolInformation>>(CancellationToken.None).ConfigureAwait(true);
+                .Returning<Container<WorkspaceSymbol>>(CancellationToken.None).ConfigureAwait(true);
 
-            SymbolInformation symbol = Assert.Single(symbols);
+            WorkspaceSymbol symbol = Assert.Single(symbols);
             Assert.Equal("function CanSendWorkspaceSymbolRequest ()", symbol.Name);
         }
 
@@ -420,12 +420,22 @@ await PsesLanguageClient
             Assert.Collection(symbolInformationOrDocumentSymbols,
                 symInfoOrDocSym =>
                 {
-                    Range range = symInfoOrDocSym.SymbolInformation.Location.Range;
-
-                    Assert.Equal(1, range.Start.Line);
-                    Assert.Equal(9, range.Start.Character);
-                    Assert.Equal(3, range.End.Line);
-                    Assert.Equal(1, range.End.Character);
+                    Assert.True(symInfoOrDocSym.IsDocumentSymbol);
+                    Assert.NotNull(symInfoOrDocSym.DocumentSymbol);
+                    DocumentSymbol symbol = symInfoOrDocSym.DocumentSymbol;
+
+                    Assert.Equal(symbol.Name, "function CanSendDocumentSymbolRequest ()");
+                    Assert.Equal(symbol.Kind, SymbolKind.Function);
+
+                    Assert.Equal(1, symbol.Range.Start.Line);
+                    Assert.Equal(0, symbol.Range.Start.Character);
+                    Assert.Equal(3, symbol.Range.End.Line);
+                    Assert.Equal(1, symbol.Range.End.Character);
+
+                    Assert.Equal(1, symbol.SelectionRange.Start.Line);
+                    Assert.Equal(9, symbol.SelectionRange.Start.Character);
+                    Assert.Equal(1, symbol.SelectionRange.End.Line);
+                    Assert.Equal(37, symbol.SelectionRange.End.Character);
                 });
         }