Fetch script listings for debugger stop events with no ScriptName

This change adds new behavior to the DebugService which enables it to
gather the listing of any source code that is being executed outside of a
script file when the debugger hits a breakpoint.  This is useful for
allowing the user to step through code in this type of scenario.

Currently this is being used for an unreleased feature in PowerShell 6.0
which allows you to step into ScriptBlocks run against remote sessions
with Invoke-Command.

Author: daviwil

src/PowerShellEditorServices/Debugging/DebugService.cs

@@ -12,7 +12,6 @@
 using System.Threading.Tasks;
 using Microsoft.PowerShell.EditorServices.Debugging;
 using Microsoft.PowerShell.EditorServices.Utility;
-using System.IO;
 using Microsoft.PowerShell.EditorServices.Session;
 
 namespace Microsoft.PowerShell.EditorServices
@@ -26,6 +25,7 @@ public class DebugService
         #region Fields
 
         private const string PsesGlobalVariableNamePrefix = "__psEditorServices_";
+        private const string TemporaryScriptFileName = "TemporaryScript.ps1";
 
         private PowerShellContext powerShellContext;
         private RemoteFileManager remoteFileManager;
@@ -35,6 +35,7 @@ public class DebugService
             new Dictionary<string, List<Breakpoint>>();
 
         private int nextVariableId;
+        private string temporaryScriptListingPath;
         private List<VariableDetailsBase> variables;
         private VariableContainerDetails globalScopeVariables;
         private VariableContainerDetails scriptScopeVariables;
@@ -93,8 +94,8 @@ public DebugService(
         /// <param name="clearExisting">If true, causes all existing breakpoints to be cleared before setting new ones.</param>
         /// <returns>An awaitable Task that will provide details about the breakpoints that were set.</returns>
         public async Task<BreakpointDetails[]> SetLineBreakpoints(
-            ScriptFile scriptFile, 
-            BreakpointDetails[] breakpoints, 
+            ScriptFile scriptFile,
+            BreakpointDetails[] breakpoints,
             bool clearExisting = true)
         {
             var resultBreakpointDetails = new List<BreakpointDetails>();
@@ -111,22 +112,32 @@ public async Task<BreakpointDetails[]> SetLineBreakpoints(
                 if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
                     this.remoteFileManager != null)
                 {
-                    string mappedPath =
-                        this.remoteFileManager.GetMappedPath(
-                            scriptPath,
-                            this.powerShellContext.CurrentRunspace);
-
-                    if (mappedPath == null)
+                    if (!this.remoteFileManager.IsUnderRemoteTempPath(scriptPath))
                     {
                         Logger.Write(
-                            LogLevel.Error,
-                            $"Could not map local path '{scriptPath}' to a remote path.");
+                            LogLevel.Verbose,
+                            $"Could not set breakpoints for local path '{scriptPath}' in a remote session.");
 
                         return resultBreakpointDetails.ToArray();
                     }
 
+                    string mappedPath =
+                        this.remoteFileManager.GetMappedPath(
+                            scriptPath,
+                            this.powerShellContext.CurrentRunspace);
+
                     scriptPath = mappedPath;
                 }
+                else if (
+                    this.temporaryScriptListingPath != null &&
+                    this.temporaryScriptListingPath.Equals(scriptPath, StringComparison.CurrentCultureIgnoreCase))
+                {
+                    Logger.Write(
+                        LogLevel.Verbose,
+                        $"Could not set breakpoint on temporary script listing path '{scriptPath}'.");
+
+                    return resultBreakpointDetails.ToArray();
+                }
 
                 // Fix for issue #123 - file paths that contain wildcard chars [ and ] need to
                 // quoted and have those wildcard chars escaped.
@@ -622,7 +633,7 @@ private async Task ClearCommandBreakpoints()
             await this.powerShellContext.ExecuteCommand<object>(psCommand);
         }
 
-        private async Task FetchStackFramesAndVariables()
+        private async Task FetchStackFramesAndVariables(string scriptNameOverride)
         {
             this.nextVariableId = VariableDetailsBase.FirstVariableId;
             this.variables = new List<VariableDetailsBase>();
@@ -633,7 +644,7 @@ private async Task FetchStackFramesAndVariables()
             // Must retrieve global/script variales before stack frame variables
             // as we check stack frame variables against globals.
             await FetchGlobalAndScriptVariables();
-            await FetchStackFrames();
+            await FetchStackFrames(scriptNameOverride);
         }
 
         private async Task FetchGlobalAndScriptVariables()
@@ -750,7 +761,7 @@ private bool AddToAutoVariables(PSObject psvariable, string scope)
             return true;
         }
 
-        private async Task FetchStackFrames()
+        private async Task FetchStackFrames(string scriptNameOverride)
         {
             PSCommand psCommand = new PSCommand();
 
@@ -782,7 +793,12 @@ private async Task FetchStackFrames()
                     StackFrameDetails.Create(callStackFrames[i], autoVariables, localVariables);
 
                 string stackFrameScriptPath = this.stackFrameDetails[i].ScriptPath;
-                if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
+                if (scriptNameOverride != null &&
+                    string.Equals(stackFrameScriptPath, StackFrameDetails.NoFileScriptPath))
+                {
+                    this.stackFrameDetails[i].ScriptPath = scriptNameOverride;
+                }
+                else if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
                     this.remoteFileManager != null &&
                     !string.Equals(stackFrameScriptPath, StackFrameDetails.NoFileScriptPath))
                 {
@@ -979,6 +995,25 @@ private string FormatInvalidBreakpointConditionMessage(string condition, string
             return $"'{condition}' is not a valid PowerShell expression. {message}";
         }
 
+        private string TrimScriptListingLine(PSObject scriptLineObj, ref int prefixLength)
+        {
+            string scriptLine = scriptLineObj.ToString();
+
+            if (!string.IsNullOrWhiteSpace(scriptLine))
+            {
+                if (prefixLength == 0)
+                {
+                    // The prefix is a padded integer ending with ':', an asterisk '*'
+                    // if this is the current line, and one character of padding
+                    prefixLength = scriptLine.IndexOf(':') + 2;
+                }
+
+                return scriptLine.Substring(prefixLength);
+            }
+
+            return null;
+        }
+
         #endregion
 
         #region Events
@@ -990,11 +1025,56 @@ private string FormatInvalidBreakpointConditionMessage(string condition, string
 
         private async void OnDebuggerStop(object sender, DebuggerStopEventArgs e)
         {
+            bool noScriptName = false;
+            string localScriptPath = e.InvocationInfo.ScriptName;
+
+            // If there's no ScriptName, get the "list" of the current source
+            if (this.remoteFileManager != null && string.IsNullOrEmpty(localScriptPath))
+            {
+                // Get the current script listing and create the buffer
+                PSCommand command = new PSCommand();
+                command.AddScript($"list 1 {int.MaxValue}");
+
+                IEnumerable<PSObject> scriptListingLines =
+                    await this.powerShellContext.ExecuteCommand<PSObject>(
+                        command, false, false);
+
+                if (scriptListingLines != null)
+                {
+                    int linePrefixLength = 0;
+
+                    string scriptListing =
+                        string.Join(
+                            Environment.NewLine,
+                            scriptListingLines
+                                .Select(o => this.TrimScriptListingLine(o, ref linePrefixLength))
+                                .Where(s => s != null));
+
+                    this.temporaryScriptListingPath =
+                        this.remoteFileManager.CreateTemporaryFile(
+                            TemporaryScriptFileName,
+                            scriptListing,
+                            this.powerShellContext.CurrentRunspace);
+
+                    localScriptPath =
+                        this.temporaryScriptListingPath
+                        ?? StackFrameDetails.NoFileScriptPath;
+
+                    noScriptName = localScriptPath != null;
+                }
+                else
+                {
+                    Logger.Write(
+                        LogLevel.Warning,
+                        $"Could not load script context");
+                }
+            }
+
             // Get call stack and variables.
-            await this.FetchStackFramesAndVariables();
+            await this.FetchStackFramesAndVariables(
+                noScriptName ? localScriptPath : null);
 
             // If this is a remote connection, get the file content
-            string localScriptPath = e.InvocationInfo.ScriptName;
             if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote &&
                 this.remoteFileManager != null)
             {

src/PowerShellEditorServices/Session/PowerShellContext.cs

@@ -776,31 +776,29 @@ public void Dispose()
             // Clean up the active runspace
             this.CleanupRunspace(this.CurrentRunspace);
 
-            // Drain the runspace stack if any have been pushed
-            if (this.runspaceStack.Count > 0)
+            // Push the active runspace so it will be included in the loop
+            this.runspaceStack.Push(this.CurrentRunspace);
+
+            while (this.runspaceStack.Count > 0)
             {
-                // Push the active runspace so it will be included in the loop
-                this.runspaceStack.Push(this.CurrentRunspace);
+                RunspaceDetails poppedRunspace = this.runspaceStack.Pop();
 
-                while (this.runspaceStack.Count > 1)
+                // Close the popped runspace if it isn't the initial runspace
+                // or if it is the initial runspace and we own that runspace
+                if (this.initialRunspace != poppedRunspace || this.ownsInitialRunspace)
                 {
-                    RunspaceDetails poppedRunspace = this.runspaceStack.Pop();
                     this.CloseRunspace(poppedRunspace);
-
-                    this.OnRunspaceChanged(
-                        this,
-                        new RunspaceChangedEventArgs(
-                            RunspaceChangeAction.Shutdown,
-                            poppedRunspace,
-                            null));
                 }
-            }
 
-            if (this.ownsInitialRunspace && this.initialRunspace != null)
-            {
-                this.CloseRunspace(this.initialRunspace);
-                this.initialRunspace = null;
+                this.OnRunspaceChanged(
+                    this,
+                    new RunspaceChangedEventArgs(
+                        RunspaceChangeAction.Shutdown,
+                        poppedRunspace,
+                        null));
             }
+
+            this.initialRunspace = null;
         }
 
         private void CloseRunspace(RunspaceDetails runspaceDetails)

src/PowerShellEditorServices/Session/PowerShellVersionDetails.cs

@@ -117,7 +117,7 @@ public static PowerShellVersionDetails GetVersionDetails(Runspace runspace)
                     {
                         powerShellVersion = (Version)version;
                     }
-                    else if (string.Equals(powerShellEdition, "Core", StringComparison.CurrentCultureIgnoreCase))
+                    else if (version != null)
                     {
                         // Expected version string format is 6.0.0-alpha so build a simpler version from that
                         powerShellVersion = new Version(version.ToString().Split('-')[0]);
@@ -148,7 +148,7 @@ public static PowerShellVersionDetails GetVersionDetails(Runspace runspace)
             {
                 Logger.Write(
                     LogLevel.Warning,
-                    "Failed to look up PowerShell version. Defaulting to version 5. " + ex.Message);
+                    "Failed to look up PowerShell version, defaulting to version 5.\r\n\r\n" + ex.ToString());
             }
 
             return new PowerShellVersionDetails(