Implemtation of VSCode 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,109 @@
+// 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.Extensions.Logging;
+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 ILogger _logger;
+        private readonly WorkspaceService _workspaceService;
+
+        public PrepareRenameSymbolHandler(ILoggerFactory loggerFactory, WorkspaceService workspaceService)
+        {
+            _logger = loggerFactory.CreateLogger<RenameSymbolHandler>();
+            _workspaceService = workspaceService;
+        }
+
+        public async Task<PrepareRenameSymbolResult> Handle(PrepareRenameSymbolParams request, CancellationToken cancellationToken)
+        {
+            if (!_workspaceService.TryGetFile(request.FileName, out ScriptFile scriptFile))
+            {
+                _logger.LogDebug("Failed to open file!");
+                return await Task.FromResult<PrepareRenameSymbolResult>(null).ConfigureAwait(false);
+            }
+            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;
+                }
+                switch (token)
+                {
+                    case FunctionDefinitionAst funcDef:
+                        {
+                            try
+                            {
+
+                                IterativeFunctionRename visitor = new(funcDef.Name,
+                                            request.RenameTo,
+                                            funcDef.Extent.StartLineNumber,
+                                            funcDef.Extent.StartColumnNumber,
+                                            scriptFile.ScriptAst);
+                            }
+                            catch (FunctionDefinitionNotFoundException)
+                            {
+
+                                result.message = "Failed to Find function definition within current file";
+                            }
+
+                            break;
+                        }
+
+                    case VariableExpressionAst or CommandAst or CommandParameterAst or ParameterAst or StringConstantExpressionAst:
+                        {
+                            IterativeVariableRename visitor = new(request.RenameTo,
+                                                token.Extent.StartLineNumber,
+                                                token.Extent.StartColumnNumber,
+                                                scriptFile.ScriptAst);
+                            if (visitor.TargetVariableAst == null)
+                            {
+                                result.message = "Failed to find variable definition within the current file";
+                            }
+                            break;
+                        }
+                }
+                return result;
+            }).ConfigureAwait(false);
+        }
+    }
+}

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

@@ -0,0 +1,140 @@
+// 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.Extensions.Logging;
+using Microsoft.PowerShell.EditorServices.Services.TextDocument;
+using Microsoft.PowerShell.EditorServices.Refactoring;
+namespace Microsoft.PowerShell.EditorServices.Handlers
+{
+    [Serial, Method("powerShell/renameSymbol")]
+    internal interface IRenameSymbolHandler : IJsonRpcRequestHandler<RenameSymbolParams, RenameSymbolResult> { }
+
+    internal class RenameSymbolParams : IRequest<RenameSymbolResult>
+    {
+        public string FileName { get; set; }
+        public int Line { get; set; }
+        public int Column { get; set; }
+        public string RenameTo { get; set; }
+    }
+    internal 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; }
+    }
+    internal 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
+                }
+            );
+        }
+    }
+    internal class RenameSymbolResult
+    {
+        public RenameSymbolResult() => Changes = new List<ModifiedFileResponse>();
+        public List<ModifiedFileResponse> Changes { get; set; }
+    }
+
+    internal class RenameSymbolHandler : IRenameSymbolHandler
+    {
+        private readonly ILogger _logger;
+        private readonly WorkspaceService _workspaceService;
+
+        public RenameSymbolHandler(ILoggerFactory loggerFactory, WorkspaceService workspaceService)
+        {
+            _logger = loggerFactory.CreateLogger<RenameSymbolHandler>();
+            _workspaceService = workspaceService;
+        }
+        internal static ModifiedFileResponse RenameFunction(Ast token, Ast scriptAst, RenameSymbolParams request)
+        {
+            if (token is FunctionDefinitionAst funcDef)
+            {
+                IterativeFunctionRename visitor = new(funcDef.Name,
+                            request.RenameTo,
+                            funcDef.Extent.StartLineNumber,
+                            funcDef.Extent.StartColumnNumber,
+                            scriptAst);
+                visitor.Visit(scriptAst);
+                ModifiedFileResponse FileModifications = new(request.FileName)
+                {
+                    Changes = visitor.Modifications
+                };
+                return FileModifications;
+
+            }
+            return null;
+
+        }
+        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);
+                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))
+            {
+                _logger.LogDebug("Failed to open file!");
+                return await Task.FromResult<RenameSymbolResult>(null).ConfigureAwait(false);
+            }
+
+            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
+                    ? 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)
+        {
+        }
+    }
+}