Auto-completion bug fix for dot operator

[• diazhector98]

Summary

There was a bug on LLDB VSCode where there was the following behavior:

//Code

struct foo {
    int bar:
};
...
foo my_foo = {10};

Trying to auto-complete my_foo.b with my_foo.bar resulted instead with my_foo.my_foo.bar

This diff fixes this bug and adds some tests to check correct behavior.

It also fixes the same bug using the arrow operator (->) when user manually requests completions.
TODO: Fix bug where no recommended completions are automatically shown with arrow operator

[• diazhector98]

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

118

also test this

foo.var1 + var2

foo.var1 + va

var2
var1

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

956

commit_points

958

int breakpoint_index = -1

959

space before {

966

space before {

[• diazhector98]

1. Updating D73506: Bug fix #
2. Enter a brief description of the changes included in this update.
3. The first line is used as subject, next lines as comment. #
4. If you intended to create a new revision, use:
5. $ arc diff --create

Removed print statements

As title

[• diazhector98]

1. Updating D73506: Bug fix #
2. Enter a brief description of the changes included in this update.
3. The first line is used as subject, next lines as comment. #
4. If you intended to create a new revision, use:
5. $ arc diff --create

Syntax fixes and uncommenting @darwin

As title

[• diazhector98]

1. Updating D73506: Bug fix #
2. Enter a brief description of the changes included in this update.
3. The first line is used as subject, next lines as comment. #
4. If you intended to create a new revision, use:
5. $ arc diff --create

Replaced storing breakpoint string with its index
.

[• diazhector98]

Brackets syntax

[• diazhector98]

Added more tests

[• diazhector98]

Uncomment @skipIfDarwin

[wallace]

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

959

int or size_t is fine

[• diazhector98]

int32 to int

[• diazhector98]

changed int to size_t to avoid warning

[labath]

Thanks for the patch.

I don't know much about the LSP protocol, but I see opportunities for simplifying the string chopping code. See the inline comment for what /I think/ should be the equivalent code.

It has also occurred to me that this may break for expressions containing quoted dots (foo(".", b<TAB>), but I don't know if there's anything we can do about that...

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

956–972

If I correctly understand what this is doing, all of this should boil down to something like:

llvm::StringRef match_ref = match;
for (StringRef commit_point: {".", "->"}) {
  if (match_ref.contains(commit_point))
    match_ref = match_ref.rsplit(commit_point).second;
}
EmplaceSafeString(item, "text", match_ref);

[teemperor]

I don't really know the vscode plugin code but I pointed out when this was implemented that the whole token replacement mechanism that LLDB's completion API uses is really hard to get right. If you're at it, you might also add some tests for the things I pointed out back then (e.g., foo1. v and foo1 .v and foo1 . v) where the returned tokens might be unexpectedly cut off.

[• diazhector98]

Simplifying code

[• diazhector98]

Added tests for spaces between member operators

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
+    #@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"
+                }
+            ]
+        )

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/vscode.py

def get_stackFrame(self, frameIndex=0, threadId=None):
                                            levels=1)
         if response:
             return response['body']['stackFrames'][0]
         print('invalid response')
         return None
 
     def get_completions(self, text):
         response = self.request_completions(text)
+        print(response['body']['targets'])
+        print("==========")
         return response['body']['targets']
 
     def get_scope_variables(self, scope_name, frameIndex=0, threadId=None):
         stackFrame = self.get_stackFrame(frameIndex=frameIndex,
                                          threadId=threadId)
         if stackFrame is None:
             return []
         frameId = stackFrame['id']

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

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;
+
+    std::vector<std::string> breakpoints = {".", "->"};
+    int max_breakpoint_position = -1;
+    std::string breakpoint_string = "";
+    for (std::string breakpoint : breakpoints){
+      int breakpoint_position = match.rfind(breakpoint);
+      if (max_breakpoint_position < breakpoint_position){
+        breakpoint_string = breakpoint;
+        max_breakpoint_position = breakpoint_position;
+      }
+    }
+    if (max_breakpoint_position != -1){
+      std::string cut_match = match.substr(max_breakpoint_position + breakpoint_string.length(), match.length() - max_breakpoint_position);
+      EmplaceSafeString(item, "text", cut_match);
+    } else {
       EmplaceSafeString(item, "text", match);
+    }
+
     if (description.empty())
       EmplaceSafeString(item, "label", match);
     else
       EmplaceSafeString(item, "label", match + " -- " + description);
 
     targets.emplace_back(std::move(item));
   }