RenameProvider for variable/function renaming

src/PowerShellEditorServices/Server/PsesLanguageServer.cs

@@ -118,6 +118,8 @@ public async Task StartAsync()
                     .WithHandler<ExpandAliasHandler>()
                     .WithHandler<PsesSemanticTokensHandler>()
                     .WithHandler<DidChangeWatchedFilesHandler>()
+                    .WithHandler<PrepareRenameSymbolHandler>()
+                    .WithHandler<RenameSymbolHandler>()
                     // NOTE: The OnInitialize delegate gets run when we first receive the
                     // _Initialize_ request:
                     // https://microsoft.github.io/language-server-protocol/specifications/specification-current/#initialize

src/PowerShellEditorServices/Services/PowerShell/Handlers/PrepareRenameSymbol.cs

@@ -0,0 +1,123 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Threading;
+using System.Threading.Tasks;
+using MediatR;
+using System.Management.Automation.Language;
+using OmniSharp.Extensions.JsonRpc;
+using Microsoft.PowerShell.EditorServices.Services;
+using Microsoft.PowerShell.EditorServices.Services.TextDocument;
+using Microsoft.PowerShell.EditorServices.Refactoring;
+using Microsoft.PowerShell.EditorServices.Services.Symbols;
+
+namespace Microsoft.PowerShell.EditorServices.Handlers
+{
+    [Serial, Method("powerShell/PrepareRenameSymbol")]
+    internal interface IPrepareRenameSymbolHandler : IJsonRpcRequestHandler<PrepareRenameSymbolParams, PrepareRenameSymbolResult> { }
+
+    internal class PrepareRenameSymbolParams : IRequest<PrepareRenameSymbolResult>
+    {
+        public string FileName { get; set; }
+        public int Line { get; set; }
+        public int Column { get; set; }
+        public string RenameTo { get; set; }
+    }
+    internal class PrepareRenameSymbolResult
+    {
+        public string message;
+    }
+
+    internal class PrepareRenameSymbolHandler : IPrepareRenameSymbolHandler
+    {
+        private readonly WorkspaceService _workspaceService;
+
+        public PrepareRenameSymbolHandler(WorkspaceService workspaceService) => _workspaceService = workspaceService;
+
+        public async Task<PrepareRenameSymbolResult> Handle(PrepareRenameSymbolParams request, CancellationToken cancellationToken)
+        {
+            if (!_workspaceService.TryGetFile(request.FileName, out ScriptFile scriptFile))
+            {
+                // TODO: Unsaved file support. We need to find the unsaved file in the text documents synced to the LSP and use that as our Ast Base.
+                throw new HandlerErrorException($"File {request.FileName} not found in workspace. Unsaved files currently do not support the rename symbol feature.");
+            }
+            return await Task.Run(() =>
+            {
+                PrepareRenameSymbolResult result = new()
+                {
+                    message = ""
+                };
+                // ast is FunctionDefinitionAst or CommandAst or VariableExpressionAst or StringConstantExpressionAst &&
+                SymbolReference symbol = scriptFile.References.TryGetSymbolAtPosition(request.Line + 1, request.Column + 1);
+                Ast token = Utilities.GetAst(request.Line + 1, request.Column + 1, scriptFile.ScriptAst);
+
+                if (token == null)
+                {
+                    result.message = "Unable to find symbol";
+                    return result;
+                }
+                if (Utilities.AssertContainsDotSourced(scriptFile.ScriptAst))
+                {
+                    result.message = "Dot Source detected, this is currently not supported operation aborted";
+                    return result;
+                }
+
+                bool IsFunction = false;
+                string tokenName = "";
+
+                switch (token)
+                {
+
+                    case FunctionDefinitionAst FuncAst:
+                        IsFunction = true;
+                        tokenName = FuncAst.Name;
+                        break;
+                    case VariableExpressionAst or CommandParameterAst or ParameterAst:
+                        IsFunction = false;
+                        tokenName = request.RenameTo;
+                        break;
+                    case StringConstantExpressionAst:
+
+                        if (token.Parent is CommandAst CommAst)
+                        {
+                            IsFunction = true;
+                            tokenName = CommAst.GetCommandName();
+                        }
+                        else
+                        {
+                            IsFunction = false;
+                        }
+                        break;
+                }
+
+                if (IsFunction)
+                {
+                    try
+                    {
+                        IterativeFunctionRename visitor = new(tokenName,
+                            request.RenameTo,
+                            token.Extent.StartLineNumber,
+                            token.Extent.StartColumnNumber,
+                            scriptFile.ScriptAst);
+                    }
+                    catch (FunctionDefinitionNotFoundException)
+                    {
+                        result.message = "Failed to Find function definition within current file";
+                    }
+                }
+                else
+                {
+                    IterativeVariableRename visitor = new(tokenName,
+                                        token.Extent.StartLineNumber,
+                                        token.Extent.StartColumnNumber,
+                                        scriptFile.ScriptAst);
+                    if (visitor.TargetVariableAst == null)
+                    {
+                        result.message = "Failed to find variable definition within the current file";
+                    }
+                }
+                return result;
+            }).ConfigureAwait(false);
+        }
+    }
+}

src/PowerShellEditorServices/Services/PowerShell/Handlers/RenameSymbol.cs

@@ -0,0 +1,147 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MediatR;
+using System.Management.Automation.Language;
+using OmniSharp.Extensions.JsonRpc;
+using Microsoft.PowerShell.EditorServices.Services;
+using Microsoft.PowerShell.EditorServices.Services.TextDocument;
+using Microsoft.PowerShell.EditorServices.Refactoring;
+using System;
+namespace Microsoft.PowerShell.EditorServices.Handlers
+{
+    [Serial, Method("powerShell/renameSymbol")]
+    internal interface IRenameSymbolHandler : IJsonRpcRequestHandler<RenameSymbolParams, RenameSymbolResult> { }
+
+    public class RenameSymbolOptions
+    {
+        public bool CreateAlias { get; set; }
+    }
+
+    public class RenameSymbolParams : IRequest<RenameSymbolResult>
+    {
+        public string FileName { get; set; }
+        public int Line { get; set; }
+        public int Column { get; set; }
+        public string RenameTo { get; set; }
+        public RenameSymbolOptions Options { get; set; }
+    }
+    public class TextChange
+    {
+        public string NewText { get; set; }
+        public int StartLine { get; set; }
+        public int StartColumn { get; set; }
+        public int EndLine { get; set; }
+        public int EndColumn { get; set; }
+    }
+    public class ModifiedFileResponse
+    {
+        public string FileName { get; set; }
+        public List<TextChange> Changes { get; set; }
+        public ModifiedFileResponse(string fileName)
+        {
+            FileName = fileName;
+            Changes = new List<TextChange>();
+        }
+
+        public void AddTextChange(Ast Symbol, string NewText)
+        {
+            Changes.Add(
+                new TextChange
+                {
+                    StartColumn = Symbol.Extent.StartColumnNumber - 1,
+                    StartLine = Symbol.Extent.StartLineNumber - 1,
+                    EndColumn = Symbol.Extent.EndColumnNumber - 1,
+                    EndLine = Symbol.Extent.EndLineNumber - 1,
+                    NewText = NewText
+                }
+            );
+        }
+    }
+    public class RenameSymbolResult
+    {
+        public RenameSymbolResult() => Changes = new List<ModifiedFileResponse>();
+        public List<ModifiedFileResponse> Changes { get; set; }
+    }
+
+    internal class RenameSymbolHandler : IRenameSymbolHandler
+    {
+        private readonly WorkspaceService _workspaceService;
+
+        public RenameSymbolHandler(WorkspaceService workspaceService) => _workspaceService = workspaceService;
+
+        internal static ModifiedFileResponse RenameFunction(Ast token, Ast scriptAst, RenameSymbolParams request)
+        {
+            string tokenName = "";
+            if (token is FunctionDefinitionAst funcDef)
+            {
+                tokenName = funcDef.Name;
+            }
+            else if (token.Parent is CommandAst CommAst)
+            {
+                tokenName = CommAst.GetCommandName();
+            }
+            IterativeFunctionRename visitor = new(tokenName,
+                        request.RenameTo,
+                        token.Extent.StartLineNumber,
+                        token.Extent.StartColumnNumber,
+                        scriptAst);
+            visitor.Visit(scriptAst);
+            ModifiedFileResponse FileModifications = new(request.FileName)
+            {
+                Changes = visitor.Modifications
+            };
+            return FileModifications;
+        }
+
+        internal static ModifiedFileResponse RenameVariable(Ast symbol, Ast scriptAst, RenameSymbolParams request)
+        {
+            if (symbol is VariableExpressionAst or ParameterAst or CommandParameterAst or StringConstantExpressionAst)
+            {
+
+                IterativeVariableRename visitor = new(
+                    request.RenameTo,
+                    symbol.Extent.StartLineNumber,
+                    symbol.Extent.StartColumnNumber,
+                    scriptAst,
+                    request.Options ?? null
+                );
+                visitor.Visit(scriptAst);
+                ModifiedFileResponse FileModifications = new(request.FileName)
+                {
+                    Changes = visitor.Modifications
+                };
+                return FileModifications;
+
+            }
+            return null;
+        }
+
+        public async Task<RenameSymbolResult> Handle(RenameSymbolParams request, CancellationToken cancellationToken)
+        {
+            if (!_workspaceService.TryGetFile(request.FileName, out ScriptFile scriptFile))
+            {
+                throw new InvalidOperationException("This should not happen as PrepareRename should have already checked for viability. File an issue if you see this.");
+            }
+
+            return await Task.Run(() =>
+            {
+                Ast token = Utilities.GetAst(request.Line + 1, request.Column + 1, scriptFile.ScriptAst);
+                if (token == null) { return null; }
+
+                ModifiedFileResponse FileModifications = (token is FunctionDefinitionAst || token.Parent is CommandAst)
+                    ? RenameFunction(token, scriptFile.ScriptAst, request)
+                    : RenameVariable(token, scriptFile.ScriptAst, request);
+
+                RenameSymbolResult result = new();
+
+                result.Changes.Add(FileModifications);
+
+                return result;
+            }).ConfigureAwait(false);
+        }
+    }
+}

src/PowerShellEditorServices/Services/PowerShell/Refactoring/Exceptions.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+namespace Microsoft.PowerShell.EditorServices.Refactoring
+{
+
+    public class TargetSymbolNotFoundException : Exception
+    {
+        public TargetSymbolNotFoundException()
+        {
+        }
+
+        public TargetSymbolNotFoundException(string message)
+            : base(message)
+        {
+        }
+
+        public TargetSymbolNotFoundException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+
+    public class FunctionDefinitionNotFoundException : Exception
+    {
+        public FunctionDefinitionNotFoundException()
+        {
+        }
+
+        public FunctionDefinitionNotFoundException(string message)
+            : base(message)
+        {
+        }
+
+        public FunctionDefinitionNotFoundException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}