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

957

commit_points

959

int breakpoint_index = -1

960

space before {

967

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

960

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

957–973

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

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/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;
-    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));
   }
 
   body.try_emplace("targets", std::move(targets));
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
 //  "EvaluateRequest": {
 //    "allOf": [ { "$ref": "#/definitions/Request" }, {
 //      "type": "object",
 //      "description": "Evaluate request; value of command field is 'evaluate'.