Prevent lldb-vscode tests from source lldbinit file

[yinghuitan]

Summary

lldb-vscode is hard-coded to source .lldbinit file which causes some tests to
fail on my machine.
This patch adds a new option to control this:

1. vscode.py and lldb-vscode tests will not source .lldbinit by default
2. lldb-vscode will source .lldbinit in production if not specified otherwise

[clayborg]

Just add a comment as suggested and this is good to go!

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

1448–1449

Please add a comment stating this is only used for LLDB unit tests and that this isn't part of the actual packet definition for "initialize". Also state something like "When testing lldb-vscode, we never want to source the init files as these files can change the outcome of tests if the user replaces or modifies commands".

[yinghuitan]

Add comment per feedback

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

def continue_to_exit(self, exitCode=0):
                         'make sure program ran to completion')
         self.assertEquals(stopped_events[0]['body']['exitCode'], exitCode,
                         'exitCode == %i' % (exitCode))
 
     def attach(self, program=None, pid=None, waitFor=None, trace=None,
                initCommands=None, preRunCommands=None, stopCommands=None,
                exitCommands=None, attachCommands=None, coreFile=None,
                disconnectAutomatically=True, terminateCommands=None,
-               postRunCommands=None, sourceMap=None):
+               postRunCommands=None, sourceMap=None, sourceInitFile=False):
         '''Build the default Makefile target, create the VSCode debug adaptor,
            and attach to the process.
         '''
         # Make sure we disconnect and terminate the VSCode debug adaptor even
         # if we throw an exception during the test case.
         def cleanup():
             if disconnectAutomatically:
                 self.vscode.request_disconnect(terminateDebuggee=True)
             self.vscode.terminate()
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
         # Initialize and launch the program
-        self.vscode.request_initialize()
+        self.vscode.request_initialize(sourceInitFile)
         response = self.vscode.request_attach(
             program=program, pid=pid, waitFor=waitFor, trace=trace,
             initCommands=initCommands, preRunCommands=preRunCommands,
             stopCommands=stopCommands, exitCommands=exitCommands,
             attachCommands=attachCommands, terminateCommands=terminateCommands,
             coreFile=coreFile, postRunCommands=postRunCommands,
             sourceMap=sourceMap)
         if not (response and response['success']):
             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, terminateCommands=None,
-               sourcePath=None, debuggerRoot=None, launchCommands=None,
+               sourcePath=None, debuggerRoot=None, sourceInitFile=False, launchCommands=None,
                sourceMap=None, disconnectAutomatically=True, runInTerminal=False,
                expectFailure=False, postRunCommands=None):
         '''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():
             if disconnectAutomatically:
                 self.vscode.request_disconnect(terminateDebuggee=True)
             self.vscode.terminate()
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
         # Initialize and launch the program
-        self.vscode.request_initialize()
+        self.vscode.request_initialize(sourceInitFile)
         response = self.vscode.request_launch(
             program,
             args=args,
             cwd=cwd,
             env=env,
             stopOnEntry=stopOnEntry,
             disableASLR=disableASLR,
             disableSTDIO=disableSTDIO,
class VSCodeTestCaseBase(TestBase):
 
 
     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,
                          terminateCommands=None, sourcePath=None,
-                         debuggerRoot=None, runInTerminal=False,
+                         debuggerRoot=None, sourceInitFile=False, runInTerminal=False,
                          disconnectAutomatically=True, postRunCommands=None,
                          lldbVSCodeEnv=None):
         '''Build the default Makefile target, create the VSCode debug adaptor,
            and launch the process.
         '''
         self.build_and_create_debug_adaptor(lldbVSCodeEnv)
         self.assertTrue(os.path.exists(program), 'executable must exist')
 
         return self.launch(program, args, cwd, env, stopOnEntry, disableASLR,
                     disableSTDIO, shellExpandArguments, trace,
                     initCommands, preRunCommands, stopCommands, exitCommands,
-                    terminateCommands, sourcePath, debuggerRoot, runInTerminal=runInTerminal,
+                    terminateCommands, sourcePath, debuggerRoot, sourceInitFile,
+                    runInTerminal=runInTerminal,
                     disconnectAutomatically=disconnectAutomatically,
                     postRunCommands=postRunCommands)

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

def request_evaluate(self, expression, frameIndex=0, threadId=None, context=None):
         }
         command_dict = {
             'command': 'evaluate',
             'type': 'request',
             'arguments': args_dict
         }
         return self.send_recv(command_dict)
 
-    def request_initialize(self):
+    def request_initialize(self, sourceInitFile):
         command_dict = {
             'command': 'initialize',
             'type': 'request',
             'arguments': {
                 'adapterID': 'lldb-native',
                 'clientID': 'vscode',
                 'columnsStartAt1': True,
                 'linesStartAt1': True,
                 'locale': 'en-us',
                 'pathFormat': 'path',
                 'supportsRunInTerminalRequest': True,
                 'supportsVariablePaging': True,
-                'supportsVariableType': True
+                'supportsVariableType': True,
+                'sourceInitFile': sourceInitFile
             }
         }
         response = self.send_recv(command_dict)
         if response:
             if 'body' in response:
                 self.initialize_body = response['body']
         return response
 
def attach_options_specified(options):
     if options.attach:
         return True
     if options.attachCmds:
         return True
     return False
 
 
 def run_vscode(dbg, args, options):
-    dbg.request_initialize()
+    dbg.request_initialize(options.sourceInitFile)
     if attach_options_specified(options):
         response = dbg.request_attach(program=options.program,
                                       pid=options.pid,
                                       waitFor=options.waitFor,
                                       attachCommands=options.attachCmds,
                                       initCommands=options.initCmds,
                                       preRunCommands=options.preRunCmds,
                                       stopCommands=options.stopCmds,
def main():
     parser.add_option(
         '-g', '--debug',
         action='store_true',
         dest='debug',
         default=False,
         help='Pause waiting for a debugger to attach to the debug adaptor')
 
     parser.add_option(
+        '--sourceInitFile',
+        action='store_true',
+        dest='sourceInitFile',
+        default=False,
+        help='Whether lldb-vscode should source .lldbinit file or not')
+
+    parser.add_option(
         '--port',
         type='int',
         dest='port',
         help="Attach a socket to a port instead of using STDIN for VSCode",
         default=None)
 
     parser.add_option(
         '--pid',

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

 //       }
 //     }
 //   }]
 // }
 void request_initialize(const llvm::json::Object &request) {
   auto log_cb = [](const char *buf, void *baton) -> void {
     g_vsc.SendOutput(OutputType::Console, llvm::StringRef{buf});
   };
+
+  auto arguments = request.getObject("arguments");
+  // sourceInitFile option is not from formal DAP specification. It is only
+  // used by unit tests to prevent sourcing .lldbinit files from environment
+  // which may affect the outcome of tests.
+  bool source_init_file = GetBoolean(arguments, "sourceInitFile", true);
+
   g_vsc.debugger =
-      lldb::SBDebugger::Create(true /*source_init_files*/, log_cb, nullptr);
+      lldb::SBDebugger::Create(source_init_file, log_cb, nullptr);
   g_vsc.progress_event_thread = std::thread(ProgressEventThreadFunction);
 
   // Start our event thread so we can receive events from the debugger, target,
   // process and more.
   g_vsc.event_thread = std::thread(EventThreadFunction);
 
   llvm::json::Object response;
   FillResponse(request, response);