[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

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

905–907

inheritEnv should be passed here

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

1397–1410

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

1402

remove this

2245–2246

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

31–35

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

10

remove this comment

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

315

try not to delete existing blank lines

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

905

I think you need a comma here

906–907

put the ) in line 906

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

1408–1410

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/completions/TestVSCode_completions.py

class TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
     def verify_completions(self, actual_list, expected_list, not_expected_list=[]):
         for expected_item in expected_list:
             self.assertTrue(expected_item in actual_list)
 
         for not_expected_item in not_expected_list:
             self.assertFalse(not_expected_item in actual_list)
 
     @skipIfWindows
     @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
     def test_completions(self):
         """
             Tests the completion request at different breakpoints
         """
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         source = "main.cpp"
         breakpoint1_line = line_number(source, "// breakpoint 1")
def test_completions(self):
             self.vscode.get_completions("`'comm"),
             [
                 {
                     "text": "command",
                     "label": "command -- Commands for managing custom LLDB commands.",
                 }
             ],
         )
+
+        self.verify_completions(
+            self.vscode.get_completions("foo1.v"),
+            [
+                {
+                    "text": "var1",
+                    "label": "foo1.var1 -- int"
+                }
+            ]
+        )
+
+        self.verify_completions(
+            self.vscode.get_completions("foo1.my_bar_object.v"),
+            [
+                {
+                    "text": "var1",
+                    "label": "foo1.my_bar_object.var1 -- int"
+                }
+            ]
+        )
+
+        self.verify_completions(
+            self.vscode.get_completions("foo1.var1 + foo1.v"),
+            [
+                {
+                    "text": "var1",
+                    "label": "foo1.var1 -- int"
+                }
+            ]
+        )
+
+        self.verify_completions(
+            self.vscode.get_completions("foo1.var1 + v"),
+            [
+                {
+                    "text": "var1",
+                    "label": "var1 -- int &"
+                }
+            ]
+        )
+
+        #should correctly handle spaces between objects and member operators
+        self.verify_completions(
+            self.vscode.get_completions("foo1 .v"),
+            [
+                {
+                    "text": "var1",
+                    "label": ".var1 -- int"
+                }
+            ],
+            [
+                {
+                    "text": "var2",
+                    "label": ".var2 -- int"
+                }
+            ]
+        )
+
+        self.verify_completions(
+            self.vscode.get_completions("foo1 . v"),
+            [
+                {
+                    "text": "var1",
+                    "label": "var1 -- int"
+                }
+            ], 
+            [
+                {
+                    "text": "var2",
+                    "label": "var2 -- int"
+                }
+            ]
+        )

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

 #include <string>
 #include <vector>
 
+struct bar {
+  int var1;
+};
+
+struct foo {
+  int var1;
+  bar* my_bar_pointer;
+  bar my_bar_object;
+  foo* next_foo;
+};
+
 int fun(std::vector<std::string> var) {
   return var.size(); // breakpoint 1
 }
 
 int main(int argc, char const *argv[]) {
   int var1 = 0;
   int var2 = 1;
   std::string str1 = "a";
   std::string str2 = "b";
   std::vector<std::string> vec;
   fun(vec);
+  bar bar1 = {2};
+  bar* bar2 = &bar1; 
+  foo foo1 = {3,&bar1, bar1, NULL};
   return 0; // breakpoint 2
 }

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/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
g_vsc.debugger.GetCommandInterpreter().HandleCompletionWithDescriptions(
     text.c_str(),
     actual_column,
     0, -1, matches, descriptions);
   size_t count = std::min((uint32_t)50, matches.GetSize());
   targets.reserve(count);
   for (size_t i = 0; i < count; i++) {
     std::string match = matches.GetStringAtIndex(i);
     std::string description = descriptions.GetStringAtIndex(i);
     
     llvm::json::Object item;
-    EmplaceSafeString(item, "text", match);
+
+    llvm::StringRef match_ref = match;
+    for(llvm::StringRef commit_point: {".", "->"}) {
+      if (match_ref.contains(commit_point)){
+        match_ref = match_ref.rsplit(commit_point).second;
+      }
+    }
+    EmplaceSafeString(item, "text", match_ref);
+
     if (description.empty())
       EmplaceSafeString(item, "label", match);
     else
       EmplaceSafeString(item, "label", match + " -- " + description);
 
     targets.emplace_back(std::move(item));
   }
 
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());
   }
if (!module.IsValid()) {
       g_vsc.SendJSON(llvm::json::Value(std::move(response)));
       return;
     }
   }
 
   // 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 (!envs.empty())
+
+  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))

 // "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.",