Update for PSES preview 9 (#49)

- Refactor to use new API's
- Fix some inconsistencies with ExpandMemberExpression
- Fix a bug where the drop namespace refactor would not work with
  generic type names
- Add a refactor to change named block kinds

Author: SeeminglyScience

EditorServicesCommandSuite.build.ps1

@@ -155,6 +155,7 @@ task CopyToRelease  {
     $srcBase = "$CSharpPath/$ModuleName"
     Copy-Item "$srcBase/bin/$Configuration/$Framework/publish/EditorServicesCommandSuite.*" -Destination $ReleasePath
     Copy-Item "$srcBase.EditorServices/bin/$Configuration/$Framework/publish/EditorServicesCommandSuite.*" -Destination $ReleasePath
+    Copy-Item "$srcBase.EditorServices/bin/$Configuration/$Framework/publish/*.dll" -Destination $ReleasePath
 
     $psrlReleaseItems =
         'EditorServicesCommandSuite.*',

module/EditorServicesCommandSuite.psd1

@@ -61,8 +61,7 @@ FunctionsToExport = 'Add-ModuleQualification',
 # Cmdlets to export from this module, for best performance, do not use wildcards and do not delete the entry, use an empty array if there are no cmdlets to export.
 CmdletsToExport = 'Get-CommandSuiteSetting',
                   'Set-CommandSuiteSetting',
-                  'New-CommandSuiteSettingFile',
-                  'Get-RefactorOption'
+                  'New-CommandSuiteSettingFile'
 
 # Variables to export from this module
 VariablesToExport = @()
@@ -121,6 +120,3 @@ PrivateData = @{
 } # End of PrivateData hashtable
 
 }
-
-
-

module/EditorServicesCommandSuite.psm1

@@ -4,10 +4,10 @@ Update-FormatData -AppendPath $PSScriptRoot/EditorServicesCommandSuite.format.ps
 
 if ($null -ne $psEditor) {
     if ($PSVersionTable.PSVersion.Major -ge 6) {
-        $psesLoadContext = [System.Runtime.Loader.AssemblyLoadContext]::GetLoadContext(
-            [Microsoft.PowerShell.EditorServices.Services.PowerShellContext.EditorObject].Assembly)
+        $extensionService = [Microsoft.PowerShell.EditorServices.Extensions.EditorObjectExtensions]::
+            GetExtensionServiceProvider($psEditor)
 
-        $assembly = $psesLoadContext.LoadFromAssemblyPath((
+        $assembly = $extensionService.LoadAssemblyInPsesLoadContext((
             Join-Path $PSScriptRoot -ChildPath 'EditorServicesCommandSuite.EditorServices.dll'))
 
         $type = $assembly.GetType('EditorServicesCommandSuite.EditorServices.Internal.CommandSuite')

src/EditorServicesCommandSuite.EditorServices/ContextService.cs

@@ -1,25 +1,24 @@
+using System.Linq;
 using System.Management.Automation;
 using System.Threading;
 using System.Threading.Tasks;
 
 using EditorServicesCommandSuite.Internal;
 using EditorServicesCommandSuite.Utility;
-using Microsoft.PowerShell.EditorServices.Services.PowerShellContext;
-
-using PSWorkspaceService = Microsoft.PowerShell.EditorServices.Services.WorkspaceService;
+using Microsoft.PowerShell.EditorServices.Extensions.Services;
 
 namespace EditorServicesCommandSuite.EditorServices
 {
     internal class ContextService : DocumentContextProvider
     {
-        private readonly MessageService _messages;
+        private readonly IWorkspaceService _workspace;
 
-        private readonly PSWorkspaceService _workspace;
+        private readonly IEditorContextService _context;
 
-        internal ContextService(PSWorkspaceService workspace, MessageService messages)
+        internal ContextService(IWorkspaceService workspace, IEditorContextService context)
         {
             _workspace = workspace;
-            _messages = messages;
+            _context = context;
         }
 
         internal override string Workspace => _workspace.WorkspacePath;
@@ -29,13 +28,9 @@ internal override async Task<DocumentContextBase> GetDocumentContextAsync(
             CancellationToken cancellationToken,
             ThreadController threadController)
         {
-            var context = await _messages.SendRequestAsync(
-                Messages.GetEditorContext,
-                new GetEditorContextRequest())
-                .ConfigureAwait(false);
-
-            var scriptFile = _workspace.GetFile(context.CurrentFilePath);
-            return GetContextBuilder(scriptFile.ScriptAst, scriptFile.ScriptTokens)
+            var context = await _context.GetCurrentLspFileContextAsync().ConfigureAwait(false);
+            var scriptFile = _workspace.GetFile(context.Uri);
+            return GetContextBuilder(scriptFile.Ast, scriptFile.Tokens.ToArray())
                 .AddCursorPosition(
                     (int)context.CursorPosition.Line + 1,
                     (int)context.CursorPosition.Character + 1)

src/EditorServicesCommandSuite.EditorServices/DiagnosticsService.cs

@@ -5,6 +5,7 @@
 using System.Management.Automation;
 using System.Threading;
 using System.Threading.Tasks;
+
 using EditorServicesCommandSuite.Internal;
 using EditorServicesCommandSuite.Utility;
 

src/EditorServicesCommandSuite.EditorServices/DocumentService.cs

@@ -6,55 +6,54 @@
 using System.Threading.Tasks;
 
 using EditorServicesCommandSuite.Internal;
-using Microsoft.PowerShell.EditorServices.Handlers;
-using Microsoft.PowerShell.EditorServices.Services.PowerShellContext;
-using Microsoft.PowerShell.EditorServices.Services.TextDocument;
+using Microsoft.PowerShell.EditorServices.Extensions;
+using Microsoft.PowerShell.EditorServices.Extensions.Services;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
-using OmniSharp.Extensions.LanguageServer.Protocol.Server;
-
-using PSWorkspaceService = Microsoft.PowerShell.EditorServices.Services.WorkspaceService;
 
 namespace EditorServicesCommandSuite.EditorServices
 {
     internal class DocumentService : IDocumentEditProcessor
     {
-        private readonly PSWorkspaceService _workspace;
+        private readonly IWorkspaceService _workspace;
+
+        private readonly IEditorContextService _context;
 
-        private readonly MessageService _messages;
+        private readonly ILanguageServerService _messages;
 
-        internal DocumentService(PSWorkspaceService workspace, MessageService messages)
+        internal DocumentService(
+            IWorkspaceService workspace,
+            IEditorContextService context,
+            ILanguageServerService messages)
         {
             _workspace = workspace;
+            _context = context;
             _messages = messages;
         }
 
         public async Task WriteDocumentEditsAsync(IEnumerable<DocumentEdit> edits, CancellationToken cancellationToken)
         {
-            ClientEditorContext context = await GetClientContext()
+            ILspCurrentFileContext context = await GetClientContext()
                 .ConfigureAwait(false);
 
             // Order by empty file names first so the first group processed is the current file.
-            IOrderedEnumerable<IGrouping<string, DocumentEdit>> orderedGroups = edits
-                .GroupBy(e => e.FileName)
-                .OrderByDescending(g => string.IsNullOrEmpty(g.Key));
+            IOrderedEnumerable<IGrouping<Uri, DocumentEdit>> orderedGroups = edits
+                .GroupBy(e => e.Uri)
+                .OrderByDescending(g => g.Key == null);
 
             var workspaceChanges = new List<WorkspaceEditDocumentChange>();
-            foreach (IGrouping<string, DocumentEdit> editGroup in orderedGroups)
+            foreach (IGrouping<Uri, DocumentEdit> editGroup in orderedGroups)
             {
-                ScriptFile scriptFile;
+                IEditorScriptFile scriptFile;
                 try
                 {
-                    scriptFile = _workspace.GetFile(
-                        string.IsNullOrEmpty(editGroup.Key) ? context.CurrentFilePath : editGroup.Key);
+                    scriptFile = _workspace.GetFile(editGroup.Key ?? context.Uri);
                 }
                 catch (FileNotFoundException)
                 {
                     scriptFile = await CreateNewFile(context, editGroup.Key, cancellationToken)
                         .ConfigureAwait(false);
                 }
 
-                // ScriptFile.ClientFilePath isn't always a URI.
-                string clientFilePath = DocumentHelpers.GetPathAsClientPath(scriptFile.ClientFilePath);
                 var textEdits = new List<TextEdit>();
                 foreach (DocumentEdit edit in editGroup)
                 {
@@ -77,7 +76,7 @@ public async Task WriteDocumentEditsAsync(IEnumerable<DocumentEdit> edits, Cance
 
                 var versionedIdentifier = new VersionedTextDocumentIdentifier
                 {
-                    Uri = new Uri(clientFilePath),
+                    Uri = editGroup.Key ?? context.Uri,
                     Version = default,
                 };
 
@@ -91,60 +90,47 @@ public async Task WriteDocumentEditsAsync(IEnumerable<DocumentEdit> edits, Cance
             }
 
             var workspaceEdit = new WorkspaceEdit { DocumentChanges = workspaceChanges };
-            await _messages.Sender.Workspace.ApplyEdit(
+            await _messages.ApplyEdit(
                 new ApplyWorkspaceEditParams { Edit = workspaceEdit })
                 .ConfigureAwait(false);
         }
 
-        internal static Position ToServerPosition(BufferPosition position)
+        internal static Position ToServerPosition(LspPosition position)
         {
             return new Position()
             {
                 Line = position.Line - 1,
-                Character = position.Column - 1,
+                Character = position.Character - 1,
             };
         }
 
-        private async Task<ScriptFile> CreateNewFile(
-            ClientEditorContext context,
-            string path,
+        private async Task<IEditorScriptFile> CreateNewFile(
+            ILspCurrentFileContext context,
+            Uri uri,
             CancellationToken cancellationToken)
         {
             // Path parameter doesn't actually do anything currently. The new file will be untitled.
-            await _messages.SendRequestAsync(Messages.NewFile, path)
-                .ConfigureAwait(false);
+            await _context.OpenNewUntitledFileAsync().ConfigureAwait(false);
 
-            ClientEditorContext newContext;
+            ILspCurrentFileContext newContext;
             while (true)
             {
                 newContext = await GetClientContext().ConfigureAwait(false);
-                if (!newContext.CurrentFilePath.Equals(context.CurrentFilePath, StringComparison.OrdinalIgnoreCase))
+                if (newContext.Uri != context.Uri)
                 {
                     break;
                 }
 
                 await Task.Delay(200, cancellationToken).ConfigureAwait(false);
             }
 
-            ScriptFile scriptFile = _workspace.GetFile(newContext.CurrentFilePath);
-            await _messages.SendRequestAsync(
-                Messages.SaveFile,
-                new SaveFileDetails()
-                {
-                    FilePath = scriptFile.ClientFilePath,
-                    NewPath = path,
-                }).ConfigureAwait(false);
+            IEditorScriptFile scriptFile = _workspace.GetFile(newContext.Uri);
+            await _context.SaveFileAsync(scriptFile.Uri, uri).ConfigureAwait(false);
 
             cancellationToken.ThrowIfCancellationRequested();
-            return _workspace.GetFile(path);
+            return _workspace.GetFile(uri);
         }
 
-        private async Task<ClientEditorContext> GetClientContext()
-        {
-            return await _messages.SendRequestAsync(
-                Messages.GetEditorContext,
-                new GetEditorContextRequest())
-                .ConfigureAwait(false);
-        }
+        private Task<ILspCurrentFileContext> GetClientContext() => _context.GetCurrentLspFileContextAsync();
     }
 }