Merge pull request #6389 from apple/dwim-print-cherries

kastiglione · web-flow · commit 91de136f4ef5 · 2023-03-07T13:57:47.000-08:00
[lldb] Cherry pick dwim-print updates
diff --git a/lldb/source/Commands/CommandObjectDWIMPrint.cpp b/lldb/source/Commands/CommandObjectDWIMPrint.cpp
@@ -32,6 +32,10 @@ CommandObjectDWIMPrint::CommandObjectDWIMPrint(CommandInterpreter &interpreter)
                        "Print a variable or expression.",
                        "dwim-print [<variable-name> | <expression>]",
                        eCommandProcessMustBePaused | eCommandTryTargetAPILock) {
+
+  CommandArgumentData var_name_arg(eArgTypeVarName, eArgRepeatPlain);
+  m_arguments.push_back({var_name_arg});
+
   m_option_group.Append(&m_format_options,
                         OptionGroupFormat::OPTION_GROUP_FORMAT |
                             OptionGroupFormat::OPTION_GROUP_GDB_FMT,
@@ -44,6 +48,13 @@ CommandObjectDWIMPrint::CommandObjectDWIMPrint(CommandInterpreter &interpreter)
 
 Options *CommandObjectDWIMPrint::GetOptions() { return &m_option_group; }
 
+void CommandObjectDWIMPrint::HandleArgumentCompletion(
+    CompletionRequest &request, OptionElementVector &opt_element_vector) {
+  CommandCompletions::InvokeCommonCompletionCallbacks(
+      GetCommandInterpreter(), CommandCompletions::eVariablePathCompletion,
+      request, nullptr);
+}
+
 bool CommandObjectDWIMPrint::DoExecute(StringRef command,
                                        CommandReturnObject &result) {
   m_option_group.NotifyOptionParsingStarting(&m_exe_ctx);
diff --git a/lldb/source/Commands/CommandObjectDWIMPrint.h b/lldb/source/Commands/CommandObjectDWIMPrint.h
@@ -37,6 +37,12 @@ class CommandObjectDWIMPrint : public CommandObjectRaw {
 
   Options *GetOptions() override;
 
+  bool WantsCompletion() override { return true; }
+
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override;
+
 private:
   bool DoExecute(llvm::StringRef command, CommandReturnObject &result) override;
 
diff --git a/lldb/source/Interpreter/CommandInterpreter.cpp b/lldb/source/Interpreter/CommandInterpreter.cpp
@@ -412,24 +412,21 @@ void CommandInterpreter::Initialize() {
 
   alias_arguments_vector_sp = std::make_shared<OptionArgVector>();
 
-  cmd_obj_sp = GetCommandSPExact("expression");
+  cmd_obj_sp = GetCommandSPExact("dwim-print");
   if (cmd_obj_sp) {
     AddAlias("p", cmd_obj_sp, "--")->SetHelpLong("");
     AddAlias("print", cmd_obj_sp, "--")->SetHelpLong("");
-    AddAlias("call", cmd_obj_sp, "--")->SetHelpLong("");
     if (auto *po = AddAlias("po", cmd_obj_sp, "-O --")) {
       po->SetHelp("Evaluate an expression on the current thread.  Displays any "
                   "returned value with formatting "
                   "controlled by the type's author.");
       po->SetHelpLong("");
     }
+  }
 
-#ifdef LLDB_ENABLE_SWIFT
-    // FIXME: Upstream the REPL command together with support for a default
-    // language, similar to what exists for scripting.
-    AddAlias("repl", cmd_obj_sp, "--repl --language swift -- ");
-#endif
-
+  cmd_obj_sp = GetCommandSPExact("expression");
+  if (cmd_obj_sp) {
+    AddAlias("call", cmd_obj_sp, "--")->SetHelpLong("");
     CommandAlias *parray_alias =
         AddAlias("parray", cmd_obj_sp, "--element-count %1 --");
     if (parray_alias) {
@@ -447,6 +444,12 @@ void CommandInterpreter::Initialize() {
           "objects in memory, and will call po on them.");
       poarray_alias->SetHelpLong("");
     }
+
+#ifdef LLDB_ENABLE_SWIFT
+    // FIXME: Upstream the REPL command together with support for a default
+    // language, similar to what exists for scripting.
+    AddAlias("repl", cmd_obj_sp, "--repl --language swift -- ");
+#endif
   }
 
   cmd_obj_sp = GetCommandSPExact("platform shell");
diff --git a/lldb/test/API/functionalities/completion/TestCompletion.py b/lldb/test/API/functionalities/completion/TestCompletion.py
@@ -36,42 +36,55 @@ def test_de(self):
 
     def test_frame_variable(self):
         self.build()
-        self.main_source = "main.cpp"
-        self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
-        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
-                                          '// Break here', self.main_source_spec)
+        _, process, _, _ = lldbutil.run_to_source_breakpoint(
+            self, '// Break here', lldb.SBFileSpec("main.cpp"))
         self.assertState(process.GetState(), lldb.eStateStopped)
 
         # Since CommandInterpreter has been corrected to update the current execution
         # context at the beginning of HandleCompletion, we're here explicitly testing
         # the scenario where "frame var" is completed without any preceding commands.
+        self.do_test_variable_completion('frame variable')
 
-        self.complete_from_to('frame variable fo',
-                              'frame variable fooo')
-        self.complete_from_to('frame variable fooo.',
-                              'frame variable fooo.')
-        self.complete_from_to('frame variable fooo.dd',
-                              'frame variable fooo.dd')
-
-        self.complete_from_to('frame variable ptr_fooo->',
-                              'frame variable ptr_fooo->')
-        self.complete_from_to('frame variable ptr_fooo->dd',
-                              'frame variable ptr_fooo->dd')
-
-        self.complete_from_to('frame variable cont',
-                              'frame variable container')
-        self.complete_from_to('frame variable container.',
-                              'frame variable container.MemberVar')
-        self.complete_from_to('frame variable container.Mem',
-                              'frame variable container.MemberVar')
-
-        self.complete_from_to('frame variable ptr_cont',
-                              'frame variable ptr_container')
-        self.complete_from_to('frame variable ptr_container->',
-                              'frame variable ptr_container->MemberVar')
-        self.complete_from_to('frame variable ptr_container->Mem',
-                              'frame variable ptr_container->MemberVar')
+    def test_dwim_print(self):
+        self.build()
+
+        _, process, _, _ = lldbutil.run_to_source_breakpoint(
+            self, '// Break here', lldb.SBFileSpec("main.cpp"))
+        self.assertState(process.GetState(), lldb.eStateStopped)
+
+        # Since CommandInterpreter has been corrected to update the current execution
+        # context at the beginning of HandleCompletion, we're here explicitly testing
+        # the scenario where "frame var" is completed without any preceding commands.
+        self.do_test_variable_completion('dwim-print')
+
+
+    def do_test_variable_completion(self, command):
+        self.complete_from_to(f'{command} fo',
+                              f'{command} fooo')
+        self.complete_from_to(f'{command} fooo.',
+                              f'{command} fooo.')
+        self.complete_from_to(f'{command} fooo.dd',
+                              f'{command} fooo.dd')
+
+        self.complete_from_to(f'{command} ptr_fooo->',
+                              f'{command} ptr_fooo->')
+        self.complete_from_to(f'{command} ptr_fooo->dd',
+                              f'{command} ptr_fooo->dd')
+
+        self.complete_from_to(f'{command} cont',
+                              f'{command} container')
+        self.complete_from_to(f'{command} container.',
+                              f'{command} container.MemberVar')
+        self.complete_from_to(f'{command} container.Mem',
+                              f'{command} container.MemberVar')
+
+        self.complete_from_to(f'{command} ptr_cont',
+                              f'{command} ptr_container')
+        self.complete_from_to(f'{command} ptr_container->',
+                              f'{command} ptr_container->MemberVar')
+        self.complete_from_to(f'{command} ptr_container->Mem',
+                              f'{command} ptr_container->MemberVar')
 
     def test_process_attach_dash_dash_con(self):
         """Test that 'process attach --con' completes to 'process attach --continue '."""
diff --git a/lldb/test/API/lang/swift/clangimporter/hard_macro_conflict/TestSwiftHardMacroConflict.py b/lldb/test/API/lang/swift/clangimporter/hard_macro_conflict/TestSwiftHardMacroConflict.py
@@ -35,7 +35,7 @@ def test(self):
         process.Continue()
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, b_breakpoint)
-        self.expect("p foo", error=True)
+        self.expect("expression foo", error=True)
 
         per_module_fallback = 0
         import io
diff --git a/lldb/test/API/lang/swift/clangimporter/objcmain_conflicting_dylibs_bridging_headers/TestSwiftObjCMainConflictingDylibsBridgingHeader.py b/lldb/test/API/lang/swift/clangimporter/objcmain_conflicting_dylibs_bridging_headers/TestSwiftObjCMainConflictingDylibsBridgingHeader.py
@@ -38,14 +38,14 @@ def test(self):
 
 
         self.expect("fr var bar", "expected result", substrs=["42"])
-        self.expect("p bar", "expected result", substrs=["$R0", "42"])
-        self.expect("p $R0", "expected result", substrs=["$R1", "42"])
-        self.expect("p $R1", "expected result", substrs=["$R2", "42"])
+        self.expect("expression bar", "expected result", substrs=["$R0", "42"])
+        self.expect("expression $R0", "expected result", substrs=["$R1", "42"])
+        self.expect("expression $R1", "expected result", substrs=["$R2", "42"])
         
         foo_breakpoint = target.BreakpointCreateBySourceRegex(
             'break here', lldb.SBFileSpec('Foo.swift'))
         process.Continue()
         self.expect("fr var foo", "expected result", substrs=["23"])
-        self.expect("p foo", "expected result", substrs=["$R3", "23"])
-        self.expect("p $R3", "expected result", substrs=["23"])
-        self.expect("p $R4", "expected result", substrs=["23"])
+        self.expect("expression foo", "expected result", substrs=["$R3", "23"])
+        self.expect("expression $R3", "expected result", substrs=["23"])
+        self.expect("expression $R4", "expected result", substrs=["23"])
diff --git a/lldb/test/API/lang/swift/clangimporter/rewrite_clang_paths/TestSwiftRewriteClangPaths.py b/lldb/test/API/lang/swift/clangimporter/rewrite_clang_paths/TestSwiftRewriteClangPaths.py
@@ -82,13 +82,13 @@ def dotest(self, remap):
 
         if remap:
             comment = "returns correct value"
-            self.expect("p foo", comment, substrs=["x", "23"])
-            self.expect("p bar", comment, substrs=["y", "42"])
+            self.expect("expression foo", comment, substrs=["x", "23"])
+            self.expect("expression bar", comment, substrs=["y", "42"])
             self.expect("fr var foo", comment, substrs=["x", "23"])
             self.expect("fr var bar", comment, substrs=["y", "42"])
             self.assertTrue(os.path.isdir(mod_cache), "module cache exists")
         else:
-            self.expect("p foo", error=True)
+            self.expect("expression foo", error=True)
 
         # Scan through the types log.
         errs = 0
diff --git a/lldb/test/API/lang/swift/parseable_interfaces/dsym/TestSwiftInterfaceDsym.py b/lldb/test/API/lang/swift/parseable_interfaces/dsym/TestSwiftInterfaceDsym.py
@@ -114,7 +114,7 @@ def test_sanity_negative(self):
         # prints the type *name*.
         self.assertEqual(var.GetTypeName(), "AA.MyPoint")
         # Evaluating an expression fails, though.
-        self.expect("p x", error=1)
+        self.expect("expression x", error=1)
 
     @swiftTest
     @skipIf(archs=no_match("x86_64"))
@@ -153,7 +153,7 @@ def test_sanity_positive(self):
 
         # The expression evaluator sees the whole program, so it also
         # sees the private members.
-        self.expect("p x", substrs=["x = 10"])
+        self.expect("expression x", substrs=["x = 10"])
         # FIXME: this doesn't work, the summary/value is null/null.
         #lldbutil.check_expression(
         #    self, frame, "x", "x = 10", use_summary=False)
@@ -168,5 +168,5 @@ def test_sanity_positive(self):
         # MyPoint.x is private and we should still see it.
         child_x = var.GetChildMemberWithName("x")
         lldbutil.check_variable(self, child_x, value="10")
-        self.expect("p self", substrs=["x = 10"])
+        self.expect("expression self", substrs=["x = 10"])
 
diff --git a/lldb/test/API/lang/swift/private_discriminator/TestSwiftPrivateDiscriminator.py b/lldb/test/API/lang/swift/private_discriminator/TestSwiftPrivateDiscriminator.py
@@ -28,10 +28,10 @@ def test(self):
         self.expect("e --bind-generic-types true -- self", error=True, substrs=["Hint"])
         # This should work because expression evaluation automatically falls back
         # to not binding generic parameters.
-        self.expect("p self", substrs=['Generic', '<T>', 'n', '23'])
+        self.expect("expression self", substrs=['Generic', '<T>', 'n', '23'])
 
         process.Continue()
         # This should work.
         self.expect("frame var -d run -- visible",
                     substrs=['Generic.Visible', 'n', '42'])
-        self.expect("p visible", substrs=['Generic.Visible', 'n', '42'])
+        self.expect("expression visible", substrs=['Generic.Visible', 'n', '42'])
diff --git a/lldb/tools/lldb-vscode/lldb-vscode.cpp b/lldb/tools/lldb-vscode/lldb-vscode.cpp
@@ -1062,8 +1062,9 @@ void request_completions(const llvm::json::Object &request) {
     text = text.substr(1);
     actual_column--;
   } else {
-    text = "p " + text;
-    actual_column += 2;
+    char command[] = "expression -- ";
+    text = command + text;
+    actual_column += strlen(command);
   }
   lldb::SBStringList matches;
   lldb::SBStringList descriptions;
