Changes from review

Author: jborean93

src/PowerShellEditorServices/Services/DebugAdapter/DebugService.cs

@@ -48,7 +48,6 @@ internal class DebugService
         private VariableContainerDetails scriptScopeVariables;
         private VariableContainerDetails localScopeVariables;
         private StackFrameDetails[] stackFrameDetails;
-        private PathMapping[] _pathMappings;
 
         private readonly SemaphoreSlim debugInfoHandle = AsyncUtils.CreateSimpleLockingSemaphore();
         #endregion
@@ -87,6 +86,11 @@ public bool IsDebuggingRemoteRunspace
             set => _debugContext.IsDebuggingRemoteRunspace = value;
         }
 
+        /// <summary>
+        /// Gets or sets an array of path mappings for the current debug session.
+        /// </summary>
+        public PathMapping[] PathMappings { get; set; } = [];
+
         #endregion
 
         #region Constructors
@@ -603,27 +607,20 @@ public VariableScope[] GetVariableScopes(int stackFrameId)
             };
         }
 
-        internal void SetPathMappings(PathMapping[] pathMappings) => _pathMappings = pathMappings;
-
-        internal void UnsetPathMappings() => _pathMappings = null;
-
         internal bool TryGetMappedLocalPath(string remotePath, out string localPath)
         {
-            if (_pathMappings is not null)
+            foreach (PathMapping mapping in PathMappings)
             {
-                foreach (PathMapping mapping in _pathMappings)
+                if (string.IsNullOrWhiteSpace(mapping.LocalRoot) || string.IsNullOrWhiteSpace(mapping.RemoteRoot))
                 {
-                    if (string.IsNullOrWhiteSpace(mapping.LocalRoot) || string.IsNullOrWhiteSpace(mapping.RemoteRoot))
-                    {
-                        // If either path mapping is null, we can't map the path.
-                        continue;
-                    }
+                    // If either path mapping is null, we can't map the path.
+                    continue;
+                }
 
-                    if (remotePath.StartsWith(mapping.RemoteRoot, StringComparison.OrdinalIgnoreCase))
-                    {
-                        localPath = mapping.LocalRoot + remotePath.Substring(mapping.RemoteRoot.Length);
-                        return true;
-                    }
+                if (remotePath.StartsWith(mapping.RemoteRoot, StringComparison.OrdinalIgnoreCase))
+                {
+                    localPath = mapping.LocalRoot + remotePath.Substring(mapping.RemoteRoot.Length);
+                    return true;
                 }
             }
 
@@ -633,22 +630,19 @@ internal bool TryGetMappedLocalPath(string remotePath, out string localPath)
 
         internal bool TryGetMappedRemotePath(string localPath, out string remotePath)
         {
-            if (_pathMappings is not null)
+            foreach (PathMapping mapping in PathMappings)
             {
-                foreach (PathMapping mapping in _pathMappings)
+                if (string.IsNullOrWhiteSpace(mapping.LocalRoot) || string.IsNullOrWhiteSpace(mapping.RemoteRoot))
                 {
-                    if (string.IsNullOrWhiteSpace(mapping.LocalRoot) || string.IsNullOrWhiteSpace(mapping.RemoteRoot))
-                    {
-                        // If either path mapping is null, we can't map the path.
-                        continue;
-                    }
+                    // If either path mapping is null, we can't map the path.
+                    continue;
+                }
 
-                    if (localPath.StartsWith(mapping.LocalRoot, StringComparison.OrdinalIgnoreCase))
-                    {
-                        // If the local path starts with the local path mapping, we can replace it with the remote path.
-                        remotePath = mapping.RemoteRoot + localPath.Substring(mapping.LocalRoot.Length);
-                        return true;
-                    }
+                if (localPath.StartsWith(mapping.LocalRoot, StringComparison.OrdinalIgnoreCase))
+                {
+                    // If the local path starts with the local path mapping, we can replace it with the remote path.
+                    remotePath = mapping.RemoteRoot + localPath.Substring(mapping.LocalRoot.Length);
+                    return true;
                 }
             }
 

src/PowerShellEditorServices/Services/DebugAdapter/Handlers/DisconnectHandler.cs

@@ -50,7 +50,7 @@ public async Task<DisconnectResponse> Handle(DisconnectArguments request, Cancel
             //       We should instead ensure that the debugger is in some valid state, lock it and then tear things down
 
             _debugEventHandlerService.UnregisterEventHandlers();
-            _debugService.UnsetPathMappings();
+            _debugService.PathMappings = [];
 
             if (!_debugStateService.ExecutionCompleted)
             {

src/PowerShellEditorServices/Services/DebugAdapter/Handlers/LaunchAndAttachHandler.cs

@@ -140,14 +140,14 @@ public LaunchAndAttachHandler(
 
         public async Task<LaunchResponse> Handle(PsesLaunchRequestArguments request, CancellationToken cancellationToken)
         {
-            _debugService.SetPathMappings(request.PathMappings);
+            _debugService.PathMappings = request.PathMappings;
             try
             {
                 return await HandleImpl(request, cancellationToken).ConfigureAwait(false);
             }
             catch
             {
-                _debugService.UnsetPathMappings();
+                _debugService.PathMappings = [];
                 throw;
             }
         }
@@ -230,38 +230,11 @@ await _executionService.ExecutePSCommandAsync(
 
             // Store the launch parameters so that they can be used later
             _debugStateService.NoDebug = request.NoDebug;
-            _debugStateService.ScriptToLaunch = request.Script;
+            _debugStateService.ScriptToLaunch = GetLaunchScript(request);
             _debugStateService.Arguments = request.Args;
             _debugStateService.IsUsingTempIntegratedConsole = request.CreateTemporaryIntegratedConsole;
             _debugStateService.ExecuteMode = request.ExecuteMode;
 
-            if (request.CreateTemporaryIntegratedConsole
-                && !string.IsNullOrEmpty(request.Script)
-                && ScriptFile.IsUntitledPath(request.Script))
-            {
-                throw new RpcErrorException(0, null, "Running an Untitled file in a temporary Extension Terminal is currently not supported!");
-            }
-
-            // If the current session is remote, map the script path to the remote
-            // machine if necessary
-            if (_debugStateService.ScriptToLaunch != null
-                && _runspaceContext.CurrentRunspace.IsOnRemoteMachine)
-            {
-                if (_debugService.TryGetMappedRemotePath(_debugStateService.ScriptToLaunch, out string remoteMappedPath))
-                {
-                    _debugStateService.ScriptToLaunch = remoteMappedPath;
-                }
-                else
-                {
-                    // If the script is not mapped, we will map it to the remote path
-                    // using the RemoteFileManagerService.
-                    _debugStateService.ScriptToLaunch =
-                        _remoteFileManagerService.GetMappedPath(
-                            _debugStateService.ScriptToLaunch,
-                            _runspaceContext.CurrentRunspace);
-                }
-            }
-
             // If no script is being launched, mark this as an interactive
             // debugging session
             _debugStateService.IsInteractiveDebugSession = string.IsNullOrEmpty(_debugStateService.ScriptToLaunch);
@@ -284,13 +257,13 @@ public async Task<AttachResponse> Handle(PsesAttachRequestArguments request, Can
             _debugService.IsDebuggingRemoteRunspace = true;
             try
             {
-                _debugService.SetPathMappings(request.PathMappings);
+                _debugService.PathMappings = request.PathMappings;
                 return await HandleImpl(request, cancellationToken).ConfigureAwait(false);
             }
             catch
             {
                 _debugService.IsDebuggingRemoteRunspace = false;
-                _debugService.UnsetPathMappings();
+                _debugService.PathMappings = [];
                 throw;
             }
         }
@@ -522,7 +495,7 @@ private async Task OnExecutionCompletedAsync(Task executeTask)
             _debugEventHandlerService.UnregisterEventHandlers();
 
             _debugService.IsDebuggingRemoteRunspace = false;
-            _debugService.UnsetPathMappings();
+            _debugService.PathMappings = [];
 
             if (!isRunspaceClosed && _debugStateService.IsAttachSession)
             {
@@ -552,5 +525,36 @@ await _executionService.ExecutePSCommandAsync(
             _debugService.IsClientAttached = false;
             _debugAdapterServer.SendNotification(EventNames.Terminated);
         }
+
+        private string GetLaunchScript(PsesLaunchRequestArguments request)
+        {
+            string scriptToLaunch = request.Script;
+            if (request.CreateTemporaryIntegratedConsole
+                && !string.IsNullOrEmpty(scriptToLaunch)
+                && ScriptFile.IsUntitledPath(scriptToLaunch))
+            {
+                throw new RpcErrorException(0, null, "Running an Untitled file in a temporary Extension Terminal is currently not supported!");
+            }
+
+            // If the current session is remote, map the script path to the remote
+            // machine if necessary
+            if (scriptToLaunch is not null && _runspaceContext.CurrentRunspace.IsOnRemoteMachine)
+            {
+                if (_debugService.TryGetMappedRemotePath(scriptToLaunch, out string remoteMappedPath))
+                {
+                    scriptToLaunch = remoteMappedPath;
+                }
+                else
+                {
+                    // If the script is not mapped, we will map it to the remote path
+                    // using the RemoteFileManagerService.
+                    scriptToLaunch = _remoteFileManagerService.GetMappedPath(
+                        scriptToLaunch,
+                        _runspaceContext.CurrentRunspace);
+                }
+            }
+
+            return scriptToLaunch;
+        }
     }
 }