[lldb] stop-hook ID common completion for commands `target stop-hook enable/disable/delete'

[MrHate]

Summary

1. Added a common completion StopHookIDs to provide completion with a list of stop hook ids;
2. Applied the common completion to commands: `target stop-hook delete/enable/disable';
3. Added an related test case.

[teemperor]

lldb/source/Commands/CommandCompletions.cpp

724

Where is that '11' coming from? That seems like it would deserve a comment how that got calculated.

[MrHate]

lldb/source/Commands/CommandCompletions.cpp

724

That's the offset to make the descriptions of the completion result look better. The value was got after tests.

[MrHate]

• Added a comment to describe that 11 indent value.

lldb/include/lldb/Interpreter/CommandCompletions.h

enum CommonCompletionTypes {
     eBreakpointCompletion = (1u << 10),
     eBreakpointNameCompletion = (1u << 11),
     eProcessPluginCompletion = (1u << 12),
     eProcessIDCompletion = (1u << 13),
     eFrameIndexCompletion = (1u << 14),
     eThreadIndexCompletion = (1u << 15),
     eWatchPointIDCompletion = (1u << 16),
     eModuleUUIDCompletion = (1u << 17),
+    eStopHookIDCompletion = (1u << 18),
     // This item serves two purposes.  It is the last element in the enum, so
     // you can add custom enums starting from here in your Option class. Also
     // if you & in this bit the base code will not process the option.
-    eCustomCompletion = (1u << 18)
+    eCustomCompletion = (1u << 19)
   };
 
   static bool InvokeCommonCompletionCallbacks(
       CommandInterpreter &interpreter, uint32_t completion_mask,
       lldb_private::CompletionRequest &request, SearchFilter *searcher);
 
   // These are the generic completer functions:
   static void DiskFiles(CommandInterpreter &interpreter,
public:
   static void FrameIndexes(CommandInterpreter &interpreter,
                            CompletionRequest &request, SearchFilter *searcher);
 
   static void ThreadIndexes(CommandInterpreter &interpreter,
                             CompletionRequest &request, SearchFilter *searcher);
 
   static void WatchPointIDs(CommandInterpreter &interpreter,
                             CompletionRequest &request, SearchFilter *searcher);
+
+  static void StopHookIDs(CommandInterpreter &interpreter,
+                          CompletionRequest &request, SearchFilter *searcher);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_COMMANDCOMPLETIONS_H

lldb/source/Commands/CommandCompletions.cpp

const CommonCompletionElement common_completions[] = {
       {eRegisterCompletion, CommandCompletions::Registers},
       {eBreakpointCompletion, CommandCompletions::Breakpoints},
       {eBreakpointNameCompletion, CommandCompletions::BreakpointNames},
       {eProcessPluginCompletion, CommandCompletions::ProcessPluginNames},
       {eProcessIDCompletion, CommandCompletions::ProcessIDs},
       {eFrameIndexCompletion, CommandCompletions::FrameIndexes},
       {eThreadIndexCompletion, CommandCompletions::ThreadIndexes},
       {eWatchPointIDCompletion, CommandCompletions::WatchPointIDs},
+      {eStopHookIDCompletion, CommandCompletions::StopHookIDs},
       {eNoCompletion, nullptr} // This one has to be last in the list.
   };
 
   for (int i = 0;; i++) {
     if (common_completions[i].type == eNoCompletion)
       break;
     else if ((common_completions[i].type & completion_mask) ==
                  common_completions[i].type &&
void CommandCompletions::WatchPointIDs(CommandInterpreter &interpreter,
   for (size_t idx = 0; idx < wp_num; ++idx) {
     const lldb::WatchpointSP wp_sp = wp_list.GetByIndex(idx);
     StreamString strm;
     wp_sp->Dump(&strm);
     request.TryCompleteCurrentArg(std::to_string(wp_sp->GetID()),
                                   strm.GetString());
   }
 }
+
+void CommandCompletions::StopHookIDs(CommandInterpreter &interpreter,
+                                     CompletionRequest &request,
+                                     SearchFilter *searcher) {
+  const lldb::TargetSP target_sp =
+      interpreter.GetExecutionContext().GetTargetSP();
+  if (!target_sp)
+    return;
+
+  const size_t num = target_sp->GetNumStopHooks();
+  for (size_t idx = 0; idx < num; ++idx) {
+    StreamString strm;
+    strm.SetIndentLevel(11);
+    const Target::StopHookSP stophook_sp = target_sp->GetStopHookAtIndex(idx);
+    stophook_sp->GetDescription(&strm, lldb::eDescriptionLevelInitial);
+    request.TryCompleteCurrentArg(std::to_string(stophook_sp->GetID()),
+                                  strm.GetString());
+  }
+}

lldb/source/Commands/CommandObjectTarget.cpp

 public:
   CommandObjectTargetStopHookDelete(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "target stop-hook delete",
                             "Delete a stop-hook.",
                             "target stop-hook delete [<idx>]") {}
 
   ~CommandObjectTargetStopHookDelete() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    if (request.GetCursorIndex())
+      return;
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(), CommandCompletions::eStopHookIDCompletion,
+        request, nullptr);
+  }
+
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target &target = GetSelectedOrDummyTarget();
     // FIXME: see if we can use the breakpoint id style parser?
     size_t num_args = command.GetArgumentCount();
     if (num_args == 0) {
       if (!m_interpreter.Confirm("Delete all stop hooks?", true)) {
         result.SetStatus(eReturnStatusFailed);
public:
   CommandObjectTargetStopHookEnableDisable(CommandInterpreter &interpreter,
                                            bool enable, const char *name,
                                            const char *help, const char *syntax)
       : CommandObjectParsed(interpreter, name, help, syntax), m_enable(enable) {
   }
 
   ~CommandObjectTargetStopHookEnableDisable() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    if (request.GetCursorIndex())
+      return;
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(), CommandCompletions::eStopHookIDCompletion,
+        request, nullptr);
+  }
+
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target &target = GetSelectedOrDummyTarget();
     // FIXME: see if we can use the breakpoint id style parser?
     size_t num_args = command.GetArgumentCount();
     bool success;
 
     if (num_args == 0) {

lldb/test/API/functionalities/completion/TestCompletion.py

class CommandLineCompletionTestCase(TestBase):
     def test_target_create_dash_co(self):
         """Test that 'target create --co' completes to 'target variable --core '."""
         self.complete_from_to('target create --co', 'target create --core ')
 
     def test_target_va(self):
         """Test that 'target va' completes to 'target variable '."""
         self.complete_from_to('target va', 'target variable ')
 
+    def test_common_completion_target_stophook_ids(self):
+        subcommands = ['delete', 'enable', 'disable']
+
+        for subcommand in subcommands:
+            self.complete_from_to('target stop-hook ' + subcommand + ' ',
+                                  'target stop-hook ' + subcommand + ' ')
+
+        self.build()
+        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.runCmd('target stop-hook add test DONE')
+
+        for subcommand in subcommands:
+            self.complete_from_to('target stop-hook ' + subcommand + ' ',
+                                  'target stop-hook ' + subcommand + ' 1')
+
+        # Completion should work only on the first argument.
+        for subcommand in subcommands:
+            self.complete_from_to('target stop-hook ' + subcommand + ' 1 ',
+                                  'target stop-hook ' + subcommand + ' 1 ')
+
     def test_common_completion_thread_index(self):
         subcommands = ['continue', 'info', 'exception', 'select',
                        'step-in', 'step-inst', 'step-inst-over', 'step-out', 'step-over', 'step-script']
 
         # Completion should not work without threads.
         for subcommand in subcommands:
             self.complete_from_to('thread ' + subcommand + ' ',
                                   'thread ' + subcommand + ' ')