[lldb] watchpoint ID common completion for commands `watchpoint delete/enable/disable/modify/ignore`

[MrHate]

Summary

1. Added a common completion WatchPointIDs to complete with a list of the IDs of the current watchpoints;
2. Applied the completion to these commands: watchpoint delete/enable/disable/modify/ignore;
3. Added a correlated test case.

[teemperor]

LGTM

lldb/include/lldb/Interpreter/CommandCompletions.h

enum CommonCompletionTypes {
     eBreakpointCompletion = (1u << 10),
     eProcessPluginCompletion = (1u << 11),
     eDisassemblyFlavorCompletion = (1u << 12),
     eTypeLanguageCompletion = (1u << 13),
     eFrameIndexCompletion = (1u << 14),
     eModuleUUIDCompletion = (1u << 15),
     eStopHookIDCompletion = (1u << 16),
     eThreadIndexCompletion = (1u << 17),
+    eWatchPointIDCompletion = (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 StopHookIDs(CommandInterpreter &interpreter,
                           CompletionRequest &request, SearchFilter *searcher);
 
   static void ThreadIndexes(CommandInterpreter &interpreter,
                             CompletionRequest &request, SearchFilter *searcher);
+
+  static void WatchPointIDs(CommandInterpreter &interpreter,
+                            CompletionRequest &request, SearchFilter *searcher);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_COMMANDCOMPLETIONS_H

lldb/source/Commands/CommandCompletions.cpp

 //===-- CommandCompletions.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSet.h"
 
+#include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/CompileUnit.h"
const CommonCompletionElement common_completions[] = {
       {eRegisterCompletion, CommandCompletions::Registers},
       {eBreakpointCompletion, CommandCompletions::Breakpoints},
       {eProcessPluginCompletion, CommandCompletions::ProcessPluginNames},
       {eDisassemblyFlavorCompletion, CommandCompletions::DisassemblyFlavors},
       {eTypeLanguageCompletion, CommandCompletions::TypeLanguages},
       {eFrameIndexCompletion, CommandCompletions::FrameIndexes},
       {eStopHookIDCompletion, CommandCompletions::StopHookIDs},
       {eThreadIndexCompletion, CommandCompletions::ThreadIndexes},
+      {eWatchPointIDCompletion, CommandCompletions::WatchPointIDs},
       {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::ThreadIndexes(CommandInterpreter &interpreter,
   lldb::ThreadSP thread_sp;
   for (uint32_t idx = 0; (thread_sp = threads.GetThreadAtIndex(idx)); ++idx) {
     StreamString strm;
     thread_sp->GetStatus(strm, 0, 1, 1, true);
     request.TryCompleteCurrentArg(std::to_string(thread_sp->GetIndexID()),
                                   strm.GetString());
   }
 }
+
+void CommandCompletions::WatchPointIDs(CommandInterpreter &interpreter,
+                                       CompletionRequest &request,
+                                       SearchFilter *searcher) {
+  const ExecutionContext &exe_ctx = interpreter.GetExecutionContext();
+  if (!exe_ctx.HasTargetScope())
+    return;
+
+  const WatchpointList &wp_list = exe_ctx.GetTargetPtr()->GetWatchpointList();
+  const size_t wp_num = wp_list.GetSize();
+  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());
+  }
+}

lldb/source/Commands/CommandObjectWatchpoint.cpp

CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
     // Add the entry for the first argument for this command to the object's
     // arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointEnable() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(), CommandCompletions::eWatchPointIDCompletion,
+        request, nullptr);
+  }
+
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = &GetSelectedTarget();
     if (!CheckTargetForWatchpointOperations(target, result))
       return false;
 
     std::unique_lock<std::recursive_mutex> lock;
     target->GetWatchpointList().GetListMutex(lock);
CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
     // Add the entry for the first argument for this command to the object's
     // arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointDisable() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(), CommandCompletions::eWatchPointIDCompletion,
+        request, nullptr);
+  }
+
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = &GetSelectedTarget();
     if (!CheckTargetForWatchpointOperations(target, result))
       return false;
 
     std::unique_lock<std::recursive_mutex> lock;
     target->GetWatchpointList().GetListMutex(lock);
CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
     // Add the entry for the first argument for this command to the object's
     // arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointDelete() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(), CommandCompletions::eWatchPointIDCompletion,
+        request, nullptr);
+  }
+
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options(), m_force(false) {}
 
     ~CommandOptions() override = default;
 
CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
     // Add the entry for the first argument for this command to the object's
     // arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointIgnore() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(), CommandCompletions::eWatchPointIDCompletion,
+        request, nullptr);
+  }
+
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options(), m_ignore_count(0) {}
 
     ~CommandOptions() override = default;
 
CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
                                       eArgTypeWatchpointIDRange);
     // Add the entry for the first argument for this command to the object's
     // arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectWatchpointModify() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(), CommandCompletions::eWatchPointIDCompletion,
+        request, nullptr);
+  }
+
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options(), m_condition(), m_condition_passed(false) {}
 
     ~CommandOptions() override = default;
 

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

def test_help_fi(self):
         self.complete_from_to(
             'help fi', [
                 'file', 'finish'])
 
     def test_help_watchpoint_s(self):
         """Test that 'help watchpoint s' completes to 'help watchpoint set '."""
         self.complete_from_to('help watchpoint s', 'help watchpoint set ')
 
+    def test_common_complete_watchpoint_ids(self):
+        subcommands = ['enable', 'disable', 'delete', 'modify', 'ignore']
+
+        # Completion should not work without a target.
+        for subcommand in subcommands:
+            self.complete_from_to('watchpoint ' + subcommand + ' ',
+                                  'watchpoint ' + subcommand + ' ')
+
+        # Create a process to provide a target and enable watchpoint setting.
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp"))
+
+        self.runCmd('watchpoint set variable ptr_fooo')
+        for subcommand in subcommands:
+            self.complete_from_to('watchpoint ' + subcommand + ' ', ['1'])
+
     def test_settings_append_target_er(self):
         """Test that 'settings append target.er' completes to 'settings append target.error-path'."""
         self.complete_from_to(
             'settings append target.er',
             'settings append target.error-path')
 
     def test_settings_insert_after_target_en(self):
         """Test that 'settings insert-after target.env' completes to 'settings insert-after target.env-vars'."""