[don't review]Creating environment variable test for lldbd

[• diazhector98]

Creating env tes

[• diazhector98]

Squashing

[wallace]

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

26 ↗

(On Diff #244547)

don't forget to remove the #

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

20–25

remove this

39–44

you can write different tests:

• inheritEnvironment = false -> no PATH
• inheritEnvironment = true
  • send an additional env in the config -> it should override the inherited
  • PATH should be correct

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

917–919

inheritEnv should be passed here

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

1374–1387

the env sent by the user in the launch.json config should have more priority than the inherited environment. For example, if env = ["X=A"] and the inherited env is ["X=Z", "Y=V"], then the resulting environment should be ["X=A", "Y=V"].
You should also write a test for that

1389

remove this

2222–2223

lol

lldb/tools/lldb-vscode/package.json

89

Inherit the debugger environment when launching a process. Only works for binaries launched directly by LLDB.

[• diazhector98]

Working on comments

[wallace]

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

32–36

this becomes more readable if you make it a function. That way you avoid having the mutable found variable and you can stop the for loop as soon as you return

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/environmentVariables/main.cpp

11

remove this comment

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

317

try not to delete existing blank lines

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

917–919

I think you need a comma here

918–919

put the ) in line 906

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

1395–1397

in llvm, you don't need to use { } for one line ifs

[• diazhector98]

.

[• diazhector98]

• Merge branch 'master' of https://github.com/llvm/llvm-project

[• diazhector98]

• Comment

[• diazhector98]

Comments

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/environmentVariables/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

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

+"""
+Test lldb-vscode completions request
+"""
+
+
+import lldbvscode_testcase
+import unittest2
+import vscode
+from lldbsuite.test import lldbutil
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+import os
+
+
+class TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfWindows
+    #@skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    def test_environment_variable(self):
+        """
+            Tests the completion request at different breakpoints
+        """
+        program = self.getBuildArtifact("a.out")
+        path_env_variable = 'PATH='+os.environ['PATH']
+        self.build_and_launch(program, inheritEnvironment=False)
+        self.continue_to_exit()
+        output = self.get_stdout().encode('utf-8')
+        lines = output.splitlines()
+        found = False
+        for line in lines:
+            if line.startswith('PATH='):
+                found = True
+                self.assertTrue(path_env_variable == line, "PATH environment variable not the same")
+        self.assertTrue(found, 'PATH environment variable not found')
 No newline at end of file

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/environmentVariables/main.cpp

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+extern char **environ;
+
+int main(int argc, char const *argv[], char const *envp[]) {
+    char** env_var_pointer = environ;
+    // std::vector<std::string> vscode_env_variables;
+    int count = 0;
+    for (char* env_variable = *env_var_pointer; env_variable; env_variable=*++env_var_pointer) {
+        printf("%s\n", env_variable);
+        count++;
+    }
+    return 0; // breakpoint 1
+}

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, inheritEnvironment=False):
         '''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,
+            inheritEnvironment=inheritEnvironment
+            )
         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, inheritEnvironment=False):
         '''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, inheritEnvironment=inheritEnvironment)

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, inheritEnvironment=False):
         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
+        if inheritEnvironment:
+            args_dict['inheritEnvironment'] = inheritEnvironment
         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
else:
                                       args=args,
                                       env=options.envs,
                                       cwd=options.workingDir,
                                       debuggerRoot=options.debuggerRoot,
                                       sourcePath=options.sourcePath,
                                       initCommands=options.initCmds,
                                       preRunCommands=options.preRunCmds,
                                       stopCommands=options.stopCmds,
-                                      exitCommands=options.exitCmds)
+                                      exitCommands=options.exitCmds
+                                      inheritEnvironment=options.inheritEnvironment
+                                      )
 
     if response['success']:
         if options.sourceBreakpoints:
             source_to_lines = {}
             for file_line in options.sourceBreakpoints:
                 (path, line) = file_line.split(':')
                 if len(path) == 0 or len(line) == 0:
                     print('error: invalid source with line "%s"' %

lldb/test/API/testcases/tools/lldb-vscode/environmentVariables/TestVSCode_environmentVariables.py

+"""
+Test lldb-vscode completions request
+"""
+
+
+import lldbvscode_testcase
+import unittest2
+import vscode
+from lldbsuite.test import lldbutil
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+import os
+
+
+class TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    def test_environment_variable(self):
+        """
+            Tests the environment variables
+        """
+        program = self.getBuildArtifact("a.out")
+        path_env_variable = 'PATH='+os.environ['PATH']
+        self.build_and_launch(program, inheritEnvironment=False)
+        self.continue_to_exit()
+        output = self.get_stdout().encode('utf-8')
+        lines = output.splitlines()
+        found = False
+        for line in lines:
+            if line.startswith('PATH='):
+                found = True
+                self.assertTrue(path_env_variable == line, "PATH environment variable not the same")
+        self.assertTrue(found, 'PATH environment variable not found')
 No newline at end of file

lldb/test/API/testcases/tools/lldb-vscode/lldbvscode_testcase.py

 
 from lldbsuite.test.lldbtest import *
 import os
 import vscode
 
 
 class VSCodeTestCaseBase(TestBase):
 
     NO_DEBUG_INFO_TESTCASE = True
 
     def create_debug_adaptor(self):
         '''Create the Visual Studio Code debug adaptor'''
         self.assertTrue(os.path.exists(self.lldbVSCodeExec),
                         'lldb-vscode must exist')
-        log_file_path = self.getBuildArtifact('vscode.txt')
         self.vscode = vscode.DebugAdaptor(
-            executable=self.lldbVSCodeExec, init_commands=self.setUpCommands(),
-            log_file=log_file_path)
+            executable=self.lldbVSCodeExec, init_commands=self.setUpCommands())
 
     def build_and_create_debug_adaptor(self):
         self.build()
         self.create_debug_adaptor()
 
     def set_source_breakpoints(self, source_path, lines, condition=None,
                                hitCondition=None):
         '''Sets source breakpoints and returns an array of strings containing
-           the breakpoint IDs ("1", "2") for each breakpoint that was set.
+           the breakpoint location IDs ("1.1", "1.2") for each breakpoint
+           that was set.
         '''
         response = self.vscode.request_setBreakpoints(
             source_path, lines, condition=condition, hitCondition=hitCondition)
         if response is None:
             return []
         breakpoints = response['body']['breakpoints']
         breakpoint_ids = []
         for breakpoint in breakpoints:
-            breakpoint_ids.append('%i' % (breakpoint['id']))
+            response_id = breakpoint['id']
+            bp_id = response_id >> 32
+            bp_loc_id = response_id & 0xffffffff
+            breakpoint_ids.append('%i.%i' % (bp_id, bp_loc_id))
         return breakpoint_ids
 
     def set_function_breakpoints(self, functions, condition=None,
                                  hitCondition=None):
         '''Sets breakpoints by function name given an array of function names
-           and returns an array of strings containing the breakpoint IDs
-           ("1", "2") for each breakpoint that was set.
+           and returns an array of strings containing the breakpoint location
+           IDs ("1.1", "1.2") for each breakpoint that was set.
         '''
         response = self.vscode.request_setFunctionBreakpoints(
             functions, condition=condition, hitCondition=hitCondition)
         if response is None:
             return []
         breakpoints = response['body']['breakpoints']
         breakpoint_ids = []
         for breakpoint in breakpoints:
-            breakpoint_ids.append('%i' % (breakpoint['id']))
+            response_id = breakpoint['id']
+            bp_id = response_id >> 32
+            bp_loc_id = response_id & 0xffffffff
+            breakpoint_ids.append('%i.%i' % (bp_id, bp_loc_id))
         return breakpoint_ids
 
     def verify_breakpoint_hit(self, breakpoint_ids):
         '''Wait for the process we are debugging to stop, and verify we hit
            any breakpoint location in the "breakpoint_ids" array.
-           "breakpoint_ids" should be a list of breakpoint ID strings
-           (["1", "2"]). The return value from self.set_source_breakpoints()
-           or self.set_function_breakpoints() can be passed to this function'''
+           "breakpoint_ids" should be a list of breakpoint location ID strings
+           (["1.1", "2.1"]). The return value from
+           self.set_source_breakpoints() can be passed to this function'''
         stopped_events = self.vscode.wait_for_stopped()
         for stopped_event in stopped_events:
             if 'body' in stopped_event:
                 body = stopped_event['body']
                 if 'reason' not in body:
                     continue
                 if body['reason'] != 'breakpoint':
                     continue
                 if 'description' not in body:
                     continue
-                # Descriptions for breakpoints will be in the form
-                # "breakpoint 1.1", so look for any description that matches
-                # ("breakpoint 1.") in the description field as verification
-                # that one of the breakpoint locations was hit. VSCode doesn't
-                # allow breakpoints to have multiple locations, but LLDB does.
-                # So when looking at the description we just want to make sure
-                # the right breakpoint matches and not worry about the actual
-                # location.
+                # Description is "breakpoint 1.1", so look for any location id
+                # ("1.1") in the description field as verification that one of
+                # the breakpoint locations was hit
                 description = body['description']
-                print("description: %s" % (description))
                 for breakpoint_id in breakpoint_ids:
-                    match_desc = 'breakpoint %s.' % (breakpoint_id)
-                    if match_desc in description:
-                        return
-        self.assertTrue(False, "breakpoint not hit")
+                    if breakpoint_id in description:
+                        return True
+        return False
 
     def verify_exception_breakpoint_hit(self, filter_label):
         '''Wait for the process we are debugging to stop, and verify the stop
            reason is 'exception' and that the description matches
            'filter_label'
         '''
         stopped_events = self.vscode.wait_for_stopped()
         for stopped_event in stopped_events:
def get_dict_value(self, d, key_path):
             if key in value:
                 value = value[key]
             else:
                 self.assertTrue(key in value,
                                 'key "%s" from key_path "%s" not in "%s"' % (
                                     key, key_path, d))
         return value
 
-    def get_stackFrames_and_totalFramesCount(self, threadId=None, startFrame=None,
+    def get_stackFrames_and_totalFramesCount(self, threadId=None, startFrame=None, 
                         levels=None, dump=False):
         response = self.vscode.request_stackTrace(threadId=threadId,
                                                   startFrame=startFrame,
                                                   levels=levels,
                                                   dump=dump)
         if response:
             stackFrames = self.get_dict_value(response, ['body', 'stackFrames'])
             totalFrames = self.get_dict_value(response, ['body', 'totalFrames'])
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, inheritEnvironment=False):
         '''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,
+            inheritEnvironment=inheritEnvironment)
+
         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, inheritEnvironment=False):
         '''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, inheritEnvironment=inheritEnvironment)

lldb/test/API/testcases/tools/lldb-vscode/vscode.py

def __init__(self, recv, send, init_commands):
         self.recv_packets = []
         self.recv_condition = threading.Condition()
         self.recv_thread = threading.Thread(target=read_packet_thread,
                                             args=(self,))
         self.process_event_body = None
         self.exit_status = None
         self.initialize_body = None
         self.thread_stop_reasons = {}
-        self.breakpoint_events = []
         self.sequence = 1
         self.threads = None
         self.recv_thread.start()
         self.output_condition = threading.Condition()
         self.output = {}
         self.configuration_done_sent = False
         self.frame_scopes = {}
         self.init_commands = init_commands
def handle_recv_packet(self, packet):
                 output = body['output']
                 self.output_condition.acquire()
                 if category in self.output:
                     self.output[category] += output
                 else:
                     self.output[category] = output
                 self.output_condition.notify()
                 self.output_condition.release()
-                # no need to add 'output' event packets to our packets list
+                # no need to add 'output' packets to our packets list
                 return keepGoing
             elif event == 'process':
                 # When a new process is attached or launched, remember the
                 # details that are available in the body of the event
                 self.process_event_body = body
             elif event == 'stopped':
                 # Each thread that stops with a reason will send a
                 # 'stopped' event. We need to remember the thread stop
                 # reasons since the 'threads' command doesn't return
                 # that information.
                 self._process_stopped()
                 tid = body['threadId']
                 self.thread_stop_reasons[tid] = body
-            elif event == 'breakpoint':
-                # Breakpoint events come in when a breakpoint has locations
-                # added or removed. Keep track of them so we can look for them
-                # in tests.
-                self.breakpoint_events.append(packet)
-                # no need to add 'breakpoint' event packets to our packets list
-                return keepGoing
         elif packet_type == 'response':
             if packet['command'] == 'disconnect':
                 keepGoing = False
         self.enqueue_recv_packet(packet)
         return keepGoing
 
     def send_packet(self, command_dict, set_sequence=True):
         '''Take the "command_dict" python dictionary and encode it as a JSON
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, inheritEnvironment=False):
         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
+        if inheritEnvironment:
+            args_dict['inheritEnvironment'] = inheritEnvironment
         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
def request_testGetTargetBreakpoints(self):
         return self.send_recv(command_dict)
 
     def terminate(self):
         self.send.close()
         # self.recv.close()
 
 
 class DebugAdaptor(DebugCommunication):
-    def __init__(self, executable=None, port=None, init_commands=[], log_file=None):
+    def __init__(self, executable=None, port=None, init_commands=[]):
         self.process = None
         if executable is not None:
-            adaptor_env = os.environ.copy()
-            if log_file:
-                adaptor_env['LLDBVSCODE_LOG'] = log_file
             self.process = subprocess.Popen([executable],
                                             stdin=subprocess.PIPE,
                                             stdout=subprocess.PIPE,
-                                            stderr=subprocess.PIPE,
-                                            env=adaptor_env)
+                                            stderr=subprocess.PIPE)
             DebugCommunication.__init__(self, self.process.stdout,
                                         self.process.stdin, init_commands)
         elif port is not None:
             s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             s.connect(('127.0.0.1', port))
             DebugCommunication.__init__(self, s.makefile('r'), s.makefile('w'),
                 init_commands)
 
else:
                                       args=args,
                                       env=options.envs,
                                       cwd=options.workingDir,
                                       debuggerRoot=options.debuggerRoot,
                                       sourcePath=options.sourcePath,
                                       initCommands=options.initCmds,
                                       preRunCommands=options.preRunCmds,
                                       stopCommands=options.stopCmds,
-                                      exitCommands=options.exitCmds)
+                                      exitCommands=options.exitCmds,
+                                      inheritEnvironment=options.inheritEnvironment)
 
     if response['success']:
         if options.sourceBreakpoints:
             source_to_lines = {}
             for file_line in options.sourceBreakpoints:
                 (path, line) = file_line.split(':')
                 if len(path) == 0 or len(line) == 0:
                     print('error: invalid source with line "%s"' %

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

 #include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "JSONUtils.h"
 #include "LLDBUtils.h"
 #include "VSCode.h"
 
+extern char **environ;
+
 #if defined(_WIN32)
 #ifndef PATH_MAX
 #define PATH_MAX MAX_PATH
 #endif
 typedef int socklen_t;
 constexpr const char *dev_null_path = "nul";
 
 #else
void request_launch(const llvm::json::Object &request) {
   auto arguments = request.getObject("arguments");
   g_vsc.init_commands = GetStrings(arguments, "initCommands");
   g_vsc.pre_run_commands = GetStrings(arguments, "preRunCommands");
   g_vsc.stop_commands = GetStrings(arguments, "stopCommands");
   g_vsc.exit_commands = GetStrings(arguments, "exitCommands");
   auto launchCommands = GetStrings(arguments, "launchCommands");
   g_vsc.stop_at_entry = GetBoolean(arguments, "stopOnEntry", false);
   const auto debuggerRoot = GetString(arguments, "debuggerRoot");
+  bool launchWithDebuggerEnvironment = GetBoolean(arguments, "inheritEnvironment", false);
 
   // This is a hack for loading DWARF in .o files on Mac where the .o files
   // in the debug map of the main executable have relative paths which require
   // the lldb-vscode binary to have its working directory set to that relative
   // root for the .o files in order to be able to load debug info.
   if (!debuggerRoot.empty()) {
     llvm::sys::fs::set_current_path(debuggerRoot.data());
   }
void request_launch(const llvm::json::Object &request) {
   // launch info.
   const auto cwd = GetString(arguments, "cwd");
   if (!cwd.empty())
     g_vsc.launch_info.SetWorkingDirectory(cwd.data());
 
   // Extract any extra arguments and append them to our program arguments for
   // when we launch
   auto args = GetStrings(arguments, "args");
-  if (!args.empty())
+  if (!args.empty()) 
     g_vsc.launch_info.SetArguments(MakeArgv(args).data(), true);
 
   // Pass any environment variables along that the user specified.
   auto envs = GetStrings(arguments, "env");
+
+  if (launchWithDebuggerEnvironment) {
+    char** env_var_pointer = environ;
+    std::vector<std::string> vscode_env_variables;
+    for (char* env_variable = *env_var_pointer; env_variable; env_variable=*++env_var_pointer){
+      vscode_env_variables.push_back(env_variable);
+    }
+    envs.insert(std::end(envs), std::begin(vscode_env_variables), std::end(vscode_env_variables));
+  } 
+
   if (!envs.empty())
     g_vsc.launch_info.SetEnvironmentEntries(MakeArgv(envs).data(), true);
   
+
   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;
   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()) {
     // Disable async events so the launch will be successful when we return from

 // "StepInResponse": {
 //   "allOf": [ { "$ref": "#/definitions/Response" }, {
 //     "type": "object",
 //     "description": "Response to 'stepIn' request. This is just an
 //     acknowledgement, so no body field is required."
 //   }]
 // }
 void request_stepIn(const llvm::json::Object &request) {
   llvm::json::Object response;
   FillResponse(request, response);
   auto arguments = request.getObject("arguments");
   lldb::SBThread thread = g_vsc.GetLLDBThread(*arguments);
   if (thread.IsValid()) {
     // Remember the thread ID that caused the resume so we can set the
     // "threadCausedFocus" boolean value in the "stopped" events.
     g_vsc.focus_tid = thread.GetThreadID();
     thread.StepInto();
   } else {

lldb/tools/lldb-vscode/package.json

"debuggers": [
                 "description": "Program working directory.",
                 "default": "${workspaceRoot}"
               },
               "env": {
                 "type": "array",
                 "description": "Additional environment variables.",
                 "default": []
               },
+              "inheritEnvironment": {
+                "type": "boolean",
+                "description": "Inherit the VSCode Environment Variables",
+                "default": false
+              },
               "stopOnEntry": {
                 "type": "boolean",
                 "description": "Automatically stop after launch.",
                 "default": false
               },
               "disableASLR": {
                 "type": "boolean",
                 "description": "Enable or disable Address space layout randomization if the debugger supports it.",