Fix running untitled scripts with arguments (but break debugging)

So the extant hack that enabled debugging untitled scripts is really
untenable. It shifted the user's args by one since it ran the untitled
script as the first arg to the dot-source operator. Unfortunately, there
doesn't seem to be a clear way to break on lines in an untitled script.
However, `Wait-Debugger` and command breakpoints should still work.

Author: andyleejordan

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

@@ -1,6 +1,10 @@
 // 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;
@@ -13,10 +17,6 @@
 using OmniSharp.Extensions.DebugAdapter.Protocol.Events;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Requests;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Server;
-using System.Management.Automation;
-using System.Management.Automation.Language;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace Microsoft.PowerShell.EditorServices.Handlers
 {
@@ -102,48 +102,36 @@ public Task<ConfigurationDoneResponse> Handle(ConfigurationDoneArguments request
 
         private async Task LaunchScriptAsync(string scriptToLaunch)
         {
-            // Is this an untitled script?
+            PSCommand cmd;
             if (ScriptFile.IsUntitledPath(scriptToLaunch))
             {
                 ScriptFile untitledScript = _workspaceService.GetFile(scriptToLaunch);
-
                 if (BreakpointApiUtils.SupportsBreakpointApis(_runspaceContext.CurrentRunspace))
                 {
-                    // Parse untitled files with their `Untitled:` URI as the file name which will cache the URI & contents within the PowerShell parser.
-                    // By doing this, we light up the ability to debug Untitled files with breakpoints.
-                    // This is only possible via the direct usage of the breakpoint APIs in PowerShell because
+                    // Parse untitled files with their `Untitled:` URI as the file name which will
+                    // cache the URI and contents within the PowerShell parser. By doing this, we
+                    // light up the ability to debug Untitled files with breakpoints. This is only
+                    // possible via the direct usage of the breakpoint APIs in PowerShell because
                     // Set-PSBreakpoint validates that paths are actually on the filesystem.
-                    ScriptBlockAst ast = Parser.ParseInput(untitledScript.Contents, untitledScript.DocumentUri.ToString(), out Token[] tokens, out ParseError[] errors);
-
-                    // This seems to be the simplest way to invoke a script block (which contains breakpoint information) via the PowerShell API.
-                    //
-                    // TODO: Fix this so the added script doesn't show up.
-                    var cmd = new PSCommand().AddScript(". $args[0]").AddArgument(ast.GetScriptBlock());
-                    await _executionService
-                        .ExecutePSCommandAsync<object>(cmd, CancellationToken.None, s_debuggerExecutionOptions)
-                        .ConfigureAwait(false);
+                    ScriptBlockAst ast = Parser.ParseInput(
+                        untitledScript.Contents,
+                        untitledScript.DocumentUri.ToString(),
+                        out _,
+                        out _);
+                    // TODO: This breaks the ability to debug untitled files with breakpoints.
+                    cmd = PSCommandHelpers.BuildCommandFromArguments(ast.GetScriptBlock().ToString(), _debugStateService.Arguments, isScriptBlock: true);
                 }
                 else
                 {
-                    await _executionService
-                        .ExecutePSCommandAsync(
-                            new PSCommand().AddScript(untitledScript.Contents),
-                            CancellationToken.None,
-                            s_debuggerExecutionOptions)
-                        .ConfigureAwait(false);
+                    cmd = PSCommandHelpers.BuildCommandFromArguments(untitledScript.Contents, _debugStateService.Arguments, isScriptBlock: true);
                 }
             }
             else
             {
-                // TODO: Fix this so the added script doesn't show up.
-                await _executionService
-                    .ExecutePSCommandAsync(
-                        PSCommandHelpers.BuildCommandFromArguments(scriptToLaunch, _debugStateService.Arguments),
-                        CancellationToken.None,
-                        s_debuggerExecutionOptions)
-                    .ConfigureAwait(false);
+                cmd = PSCommandHelpers.BuildCommandFromArguments(scriptToLaunch, _debugStateService.Arguments, isScriptBlock: false);
             }
 
+            await _executionService.ExecutePSCommandAsync(cmd, CancellationToken.None, s_debuggerExecutionOptions).ConfigureAwait(false);
             _debugAdapterServer.SendNotification(EventNames.Terminated);
         }
     }

src/PowerShellEditorServices/Utility/PSCommandExtensions.cs

@@ -129,16 +129,16 @@ private static StringBuilder AddCommandText(this StringBuilder sb, Command comma
             return sb;
         }
 
-        public static PSCommand BuildCommandFromArguments(string command, IReadOnlyList<string> arguments)
+        public static PSCommand BuildCommandFromArguments(string command, IReadOnlyList<string> arguments, bool isScriptBlock = false)
         {
             // HACK: We use AddScript instead of AddArgument/AddParameter to reuse Powershell parameter binding logic.
             // We quote the command parameter so that expressions can still be used in the arguments.
             var sb = new StringBuilder()
                 .Append('.')
                 .Append(' ')
-                .Append('"')
+                .Append(isScriptBlock ? "{ " : '"')
                 .Append(command)
-                .Append('"');
+                .Append(isScriptBlock ? " }" : '"');
 
             foreach (string arg in arguments ?? System.Linq.Enumerable.Empty<string>())
             {