Support Launching in External Console in lldb-vscode

[puremourning]

Summary

When testing terminal-mode applications using lldb-vscode on macOS, it's
currently required to set LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY when starting
lldb-vscode so that the application launches in a new Terminal.app
window. This is unlikely to work for VSCode as there's no obvious way to
set it.

vscode-cpptools uses externalConsole: true to enable this behaviour,
so we implement the same here .

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/launch/TestVSCode_launch.py

 import os
 
 
 class TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows
-    @skipIfDarwin # Flaky
     def test_default(self):
         '''
             Tests the default launch of a simple program. No arguments,
             environment, or anything else is specified.
         '''
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         self.continue_to_exit()
def test_stopOnEntry(self):
                 body = stopped_event['body']
                 if 'reason' in body:
                     reason = body['reason']
                     self.assertTrue(
                         reason != 'breakpoint',
                         'verify stop isn\'t "main" breakpoint')
 
     @skipIfWindows
+    def test_externalConsole(self):
+        '''
+            Tests the default launch of a simple program that launches in a
+            new TTY.
+        '''
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program, externalConsole=True)
+        self.continue_to_exit()
+        # Now get the STDOUT and verify we connected it to another TTY
+        output = self.get_stdout()
+        self.assertEqual(output, None, "Program output goes TTY")
+
+    @skipIfWindows
     def test_cwd(self):
         '''
             Tests the default launch of a simple program with a current working
             directory.
         '''
         program = self.getBuildArtifact("a.out")
         program_parent_dir = os.path.realpath(
             os.path.dirname(os.path.dirname(program)))

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py

def attach(self, program=None, pid=None, waitFor=None, trace=None,
             self.assertTrue(response['success'],
                             'attach failed (%s)' % (response['message']))
 
     def launch(self, program=None, args=None, cwd=None, env=None,
                stopOnEntry=False, disableASLR=True,
                disableSTDIO=False, shellExpandArguments=False,
                trace=False, initCommands=None, preRunCommands=None,
                stopCommands=None, exitCommands=None,sourcePath= None,
-               debuggerRoot=None, launchCommands=None):
+               debuggerRoot=None, launchCommands=None, **kwargs):
         '''Sending launch request to vscode
         '''
 
         # Make sure we disconnect and terminate the VSCode debug adapter,
         # if we throw an exception during the test case
         def cleanup():
             self.vscode.request_disconnect(terminateDebuggee=True)
             self.vscode.terminate()
def launch(self, program=None, args=None, cwd=None, env=None,
             shellExpandArguments=shellExpandArguments,
             trace=trace,
             initCommands=initCommands,
             preRunCommands=preRunCommands,
             stopCommands=stopCommands,
             exitCommands=exitCommands,
             sourcePath=sourcePath,
             debuggerRoot=debuggerRoot,
-            launchCommands=launchCommands)
+            launchCommands=launchCommands,
+            **kwargs)
         if not (response and response['success']):
             self.assertTrue(response['success'],
                             'launch failed (%s)' % (response['message']))
 
     def build_and_launch(self, program, args=None, cwd=None, env=None,
                          stopOnEntry=False, disableASLR=True,
                          disableSTDIO=False, shellExpandArguments=False,
                          trace=False, initCommands=None, preRunCommands=None,
                          stopCommands=None, exitCommands=None,
-                         sourcePath=None, debuggerRoot=None):
+                         sourcePath=None, debuggerRoot=None,
+                         **kwargs):
         '''Build the default Makefile target, create the VSCode debug adaptor,
            and launch the process.
         '''
         self.build_and_create_debug_adaptor()
         self.assertTrue(os.path.exists(program), 'executable must exist')
 
         self.launch(program, args, cwd, env, stopOnEntry, disableASLR,
                     disableSTDIO, shellExpandArguments, trace,
                     initCommands, preRunCommands, stopCommands, exitCommands,
-                    sourcePath, debuggerRoot)
+                    sourcePath, debuggerRoot, **kwargs)

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

def request_initialize(self):
                 self.initialize_body = response['body']
         return response
 
     def request_launch(self, program, args=None, cwd=None, env=None,
                        stopOnEntry=False, disableASLR=True,
                        disableSTDIO=False, shellExpandArguments=False,
                        trace=False, initCommands=None, preRunCommands=None,
                        stopCommands=None, exitCommands=None, sourcePath=None,
-                       debuggerRoot=None, launchCommands=None):
+                       debuggerRoot=None, launchCommands=None, **kwargs):
         args_dict = {
             'program': program
         }
         if args:
             args_dict['args'] = args
         if cwd:
             args_dict['cwd'] = cwd
         if env:
def request_launch(self, program, args=None, cwd=None, env=None,
         if exitCommands:
             args_dict['exitCommands'] = exitCommands
         if sourcePath:
             args_dict['sourcePath'] = sourcePath
         if debuggerRoot:
             args_dict['debuggerRoot'] = debuggerRoot
         if launchCommands:
             args_dict['launchCommands'] = launchCommands
+        args_dict.update(kwargs)
+
         command_dict = {
             'command': 'launch',
             'type': 'request',
             'arguments': args_dict
         }
         response = self.send_recv(command_dict)
 
         # Wait for a 'process' and 'initialized' event in any order

lldb/tools/lldb-vscode/README.md

 |**env**            |dictionary| | Environment variables to set when launching the program. The format of each environment variable string is "VAR=VALUE" for environment variables with values or just "VAR" for environment variables with no values.
 |**stopOnEntry**    |boolean| | Whether to stop program immediately after launching.
 |**initCommands**   |[string]| | LLDB commands executed upon debugger startup prior to creating the LLDB target. Commands and command output will be sent to the debugger console when they are executed.
 |**preRunCommands** |[string]| | LLDB commands executed just before launching after the LLDB target has been created. Commands and command output will be sent to the debugger console when they are executed.
 |**stopCommands**   |[string]| | LLDB commands executed just after each stop. Commands and command output will be sent to the debugger console when they are executed.
 |**exitCommands**   |[string]| | LLDB commands executed when the program exits. Commands and command output will be sent to the debugger console when they are executed.
 |**sourceMap**      |[string[2]]| | Specify an array of path re-mappings. Each element in the array must be a two element array containing a source and destination pathname.
 |**debuggerRoot**   | string| |Specify a working directory to use when launching lldb-vscode. If the debug information in your executable contains relative paths, this option can be used so that `lldb-vscode` can find source files and object files that have relative paths.
+| **externalConsole** |boolean| | Set to TRUE to start the application in a new terminal. Useful for testing console applications.
 
 ## Attaching Settings
 
 When attaching to a process using LLDB you can attach in a few ways
 
 1. Attach to an existing process using the process ID
 2. Attach to an existing process by name
 3. Attach by name by waiting for the next instance of a process to launch

lldb/tools/lldb-vscode/lldb-vscode.cpp

void request_launch(const llvm::json::Object &request) {
   auto flags = g_vsc.launch_info.GetLaunchFlags();
 
   if (GetBoolean(arguments, "disableASLR", true))
     flags |= lldb::eLaunchFlagDisableASLR;
   if (GetBoolean(arguments, "disableSTDIO", false))
     flags |= lldb::eLaunchFlagDisableSTDIO;
   if (GetBoolean(arguments, "shellExpandArguments", false))
     flags |= lldb::eLaunchFlagShellExpandArguments;
+  if (GetBoolean(arguments, "externalConsole", false ))
+    flags |= lldb::eLaunchFlagLaunchInTTY | lldb::eLaunchFlagCloseTTYOnExit;
   const bool detatchOnError = GetBoolean(arguments, "detachOnError", false);
   g_vsc.launch_info.SetDetachOnError(detatchOnError);
   g_vsc.launch_info.SetLaunchFlags(flags | lldb::eLaunchFlagDebug |
                                    lldb::eLaunchFlagStopAtEntry);
 
   // Run any pre run LLDB commands the user specified in the launch.json
   g_vsc.RunPreRunCommands();
   if (launchCommands.empty()) {

lldb/tools/lldb-vscode/package.json

"debuggers": [
                 "description": "Additional environment variables.",
                 "default": []
               },
               "stopOnEntry": {
                 "type": "boolean",
                 "description": "Automatically stop after launch.",
                 "default": false
               },
+              "externalConsole": {
+                "type": "boolean",
+                "description": "Launch the program in a new terminal",
+                "default": false
+              },
               "disableASLR": {
                 "type": "boolean",
                 "description": "Enable or disable Address space layout randomization if the debugger supports it.",
                 "default": true
               },
               "disableSTDIO": {
                 "type": "boolean",
                 "description": "Don't retrieve STDIN, STDOUT and STDERR as the program is running.",