Re-enable line breakpoints for untitled scripts

We managed to make the previous hack work while continuing to support
passing the users' arguments. As there was demand for this feature to
continue working, despite being a hack, we're keeping it.

Author: andyleejordan

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

@@ -1,13 +1,17 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Management.Automation;
+using System.Management.Automation.Language;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Microsoft.PowerShell.EditorServices.Services;
+using Microsoft.PowerShell.EditorServices.Services.DebugAdapter;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Debugging;
 using Microsoft.PowerShell.EditorServices.Services.PowerShell.Execution;
+using Microsoft.PowerShell.EditorServices.Services.PowerShell.Runspace;
 using Microsoft.PowerShell.EditorServices.Services.TextDocument;
 using Microsoft.PowerShell.EditorServices.Utility;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Events;
@@ -18,6 +22,9 @@ namespace Microsoft.PowerShell.EditorServices.Handlers
 {
     internal class ConfigurationDoneHandler : IConfigurationDoneHandler
     {
+        // TODO: We currently set `WriteInputToHost` as true, which writes our debugged commands'
+        // `GetInvocationText` and that reveals some obscure implementation details we should
+        // instead hide from the user with pretty strings (or perhaps not write out at all).
         private static readonly PowerShellExecutionOptions s_debuggerExecutionOptions = new()
         {
             MustRunInForeground = true,
@@ -35,7 +42,10 @@ internal class ConfigurationDoneHandler : IConfigurationDoneHandler
         private readonly IInternalPowerShellExecutionService _executionService;
         private readonly WorkspaceService _workspaceService;
         private readonly IPowerShellDebugContext _debugContext;
+        private readonly IRunspaceContext _runspaceContext;
 
+        // TODO: Decrease these arguments since they're a bunch of interfaces that can be simplified
+        // (i.e., `IRunspaceContext` should just be available on `IPowerShellExecutionService`).
         public ConfigurationDoneHandler(
             ILoggerFactory loggerFactory,
             IDebugAdapterServerFacade debugAdapterServer,
@@ -44,7 +54,8 @@ public ConfigurationDoneHandler(
             DebugEventHandlerService debugEventHandlerService,
             IInternalPowerShellExecutionService executionService,
             WorkspaceService workspaceService,
-            IPowerShellDebugContext debugContext)
+            IPowerShellDebugContext debugContext,
+            IRunspaceContext runspaceContext)
         {
             _logger = loggerFactory.CreateLogger<ConfigurationDoneHandler>();
             _debugAdapterServer = debugAdapterServer;
@@ -54,6 +65,7 @@ public ConfigurationDoneHandler(
             _executionService = executionService;
             _workspaceService = workspaceService;
             _debugContext = debugContext;
+            _runspaceContext = runspaceContext;
         }
 
         public Task<ConfigurationDoneResponse> Handle(ConfigurationDoneArguments request, CancellationToken cancellationToken)
@@ -90,16 +102,51 @@ public Task<ConfigurationDoneResponse> Handle(ConfigurationDoneArguments request
 
         private async Task LaunchScriptAsync(string scriptToLaunch)
         {
-            // TODO: Theoretically we can make PowerShell respect line breakpoints in untitled
-            // files, but the previous method was a hack that conflicted with correct passing of
-            // arguments to the debugged script. We are prioritizing the latter over the former, as
-            // command breakpoints and `Wait-Debugger` work fine.
-            string command = ScriptFile.IsUntitledPath(scriptToLaunch)
-                ? string.Concat("{ ", _workspaceService.GetFile(scriptToLaunch).Contents, " }")
-                : string.Concat('"', scriptToLaunch, '"');
+            PSCommand command;
+            if (ScriptFile.IsUntitledPath(scriptToLaunch))
+            {
+                ScriptFile untitledScript = _workspaceService.GetFile(scriptToLaunch);
+                if (BreakpointApiUtils.SupportsBreakpointApis(_runspaceContext.CurrentRunspace))
+                {
+                    // Parse untitled files with their `Untitled:` URI as the filename which will
+                    // cache the URI and contents within the PowerShell parser. By doing this, we
+                    // light up the ability to debug untitled files with line breakpoints. This is
+                    // only possible with PowerShell 7's new breakpoint APIs since the old API,
+                    // Set-PSBreakpoint, validates that the given path points to a real file.
+                    ScriptBlockAst ast = Parser.ParseInput(
+                        untitledScript.Contents,
+                        untitledScript.DocumentUri.ToString(),
+                        out Token[] _,
+                        out ParseError[] _);
+
+                    // In order to use utilize the parser's cache (and therefore hit line
+                    // breakpoints) we need to use the AST's `ScriptBlock` object. Due to
+                    // limitations in PowerShell's public API, this means we must use the
+                    // `PSCommand.AddArgument(object)` method, hence this hack where we dot-source
+                    // `$args[0]. Fortunately the dot-source operator maintains a stack of arguments
+                    // on each invocation, so passing the user's arguments directly in the initial
+                    // `AddScript` surprisingly works.
+                    command = PSCommandHelpers
+                        .BuildDotSourceCommandWithArguments("$args[0]", _debugStateService.Arguments)
+                        .AddArgument(ast.GetScriptBlock());
+                }
+                else
+                {
+                    // Without the new APIs we can only execute the untitled script's contents.
+                    // Command breakpoints and `Wait-Debugger` will work.
+                    command = PSCommandHelpers.BuildDotSourceCommandWithArguments(
+                        string.Concat("{ ", untitledScript.Contents, " }"), _debugStateService.Arguments);
+                }
+            }
+            else
+            {
+                // For a saved file we just execute its path (after escaping it).
+                command = PSCommandHelpers.BuildDotSourceCommandWithArguments(
+                    string.Concat('"', scriptToLaunch, '"'), _debugStateService.Arguments);
+            }
 
             await _executionService.ExecutePSCommandAsync(
-                PSCommandHelpers.BuildCommandFromArguments(command, _debugStateService.Arguments),
+                command,
                 CancellationToken.None,
                 s_debuggerExecutionOptions).ConfigureAwait(false);
             _debugAdapterServer.SendNotification(EventNames.Terminated);

src/PowerShellEditorServices/Utility/PSCommandExtensions.cs

@@ -129,10 +129,11 @@ private static StringBuilder AddCommandText(this StringBuilder sb, Command comma
             return sb;
         }
 
-        public static PSCommand BuildCommandFromArguments(string command, IEnumerable<string> arguments)
+        public static PSCommand BuildDotSourceCommandWithArguments(string command, IEnumerable<string> arguments)
         {
+            string args = string.Join(" ", arguments ?? Array.Empty<string>());
+            string script = string.Concat(". ", command, string.IsNullOrEmpty(args) ? "" : " ", args);
             // HACK: We use AddScript instead of AddArgument/AddParameter to reuse Powershell parameter binding logic.
-            string script = string.Concat(". ", command, " ", string.Join(" ", arguments ?? Array.Empty<string>()));
             return new PSCommand().AddScript(script);
         }
     }

test/PowerShellEditorServices.Test/Debugging/DebugServiceTests.cs

@@ -96,7 +96,7 @@ private VariableDetailsBase[] GetVariables(string scopeName)
         private Task ExecutePowerShellCommand(string command, params string[] args)
         {
             return psesHost.ExecutePSCommandAsync(
-                PSCommandHelpers.BuildCommandFromArguments(string.Concat('"', command, '"'), args),
+                PSCommandHelpers.BuildDotSourceCommandWithArguments(string.Concat('"', command, '"'), args),
                 CancellationToken.None);
         }