[lldb] tab completion for `target modules load -u`

[MrHate]

Summary

1. Added a common completion ModuleUUIDs to provide a list of the UUIDs of modules for completion;
2. Added a new enumeration item eArgTypeModuleUUID to CommandArgumentType which is set as the option argument type of OptionGroupUUID;
3. Applied the module UUID completion to the argument of the type eArgTypeModuleUUID in lldb/source/Interpreter/CommandObject.cpp;
4. Added an related test case in lldb/test/API/functionalities/completion/TestCompletion.py.

[teemperor]

LGTM, thanks!

[teemperor]

Landed as 419f1be7b54ef2c285050c24e4b4c333cb108cfc

lldb/include/lldb/Interpreter/CommandCompletions.h

enum CommonCompletionTypes {
     eRegisterCompletion = (1u << 9),
     eBreakpointCompletion = (1u << 10),
     eBreakpointNameCompletion = (1u << 11),
     eProcessPluginCompletion = (1u << 12),
     eProcessIDCompletion = (1u << 13),
     eFrameIndexCompletion = (1u << 14),
     eThreadIndexCompletion = (1u << 15),
     eWatchPointIDCompletion = (1u << 16),
+    eModuleUUIDCompletion = (1u << 17),
     // 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 << 17)
+    eCustomCompletion = (1u << 18)
   };
 
   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,
static void DiskDirectories(const llvm::Twine &partial_file_name,
                               TildeExpressionResolver &Resolver);
 
   static void SourceFiles(CommandInterpreter &interpreter,
                           CompletionRequest &request, SearchFilter *searcher);
 
   static void Modules(CommandInterpreter &interpreter,
                       CompletionRequest &request, SearchFilter *searcher);
 
+  static void ModuleUUIDs(CommandInterpreter &interpreter,
+                          CompletionRequest &request, SearchFilter *searcher);
+
   static void Symbols(CommandInterpreter &interpreter,
                       CompletionRequest &request, SearchFilter *searcher);
 
   static void SettingsNames(CommandInterpreter &interpreter,
                             CompletionRequest &request, SearchFilter *searcher);
 
   static void PlatformPluginNames(CommandInterpreter &interpreter,
                                   CompletionRequest &request,

lldb/include/lldb/lldb-enumerations.h

enum CommandArgumentType {
   eArgTypeNone,
   eArgTypePlatform,
   eArgTypeWatchpointID,
   eArgTypeWatchpointIDRange,
   eArgTypeWatchType,
   eArgRawInput,
   eArgTypeCommand,
   eArgTypeColumnNum,
+  eArgTypeModuleUUID,
   eArgTypeLastArg // Always keep this entry as the last entry in this
                   // enumeration!!
 };
 
 /// Symbol types.
 // Symbol holds the SymbolType in a 6-bit field (m_type), so if you get over 63
 // entries you will have to resize that field.
 enum SymbolType {

lldb/source/Commands/CommandCompletions.cpp

bool CommandCompletions::InvokeCommonCompletionCallbacks(
   bool handled = false;
 
   const CommonCompletionElement common_completions[] = {
       {eSourceFileCompletion, CommandCompletions::SourceFiles},
       {eDiskFileCompletion, CommandCompletions::DiskFiles},
       {eDiskDirectoryCompletion, CommandCompletions::DiskDirectories},
       {eSymbolCompletion, CommandCompletions::Symbols},
       {eModuleCompletion, CommandCompletions::Modules},
+      {eModuleUUIDCompletion, CommandCompletions::ModuleUUIDs},
       {eSettingsNameCompletion, CommandCompletions::SettingsNames},
       {ePlatformPluginCompletion, CommandCompletions::PlatformPluginNames},
       {eArchitectureCompletion, CommandCompletions::ArchitectureNames},
       {eVariablePathCompletion, CommandCompletions::VariablePath},
       {eRegisterCompletion, CommandCompletions::Registers},
       {eBreakpointCompletion, CommandCompletions::Breakpoints},
       {eBreakpointNameCompletion, CommandCompletions::BreakpointNames},
       {eProcessPluginCompletion, CommandCompletions::ProcessPluginNames},
if (searcher == nullptr) {
     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
     completer.DoCompletion(&null_searcher);
   } else {
     completer.DoCompletion(searcher);
   }
 }
 
+void CommandCompletions::ModuleUUIDs(CommandInterpreter &interpreter,
+                                     CompletionRequest &request,
+                                     SearchFilter *searcher) {
+  const ExecutionContext &exe_ctx = interpreter.GetExecutionContext();
+  if (!exe_ctx.HasTargetScope())
+    return;
+
+  exe_ctx.GetTargetPtr()->GetImages().ForEach(
+      [&request](const lldb::ModuleSP &module) {
+        StreamString strm;
+        module->GetDescription(strm.AsRawOstream(),
+                               lldb::eDescriptionLevelInitial);
+        request.TryCompleteCurrentArg(module->GetUUID().GetAsString(),
+                                      strm.GetString());
+        return true;
+      });
+}
+
 void CommandCompletions::Symbols(CommandInterpreter &interpreter,
                                  CompletionRequest &request,
                                  SearchFilter *searcher) {
   SymbolCompleter completer(interpreter, request);
 
   if (searcher == nullptr) {
     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
     SearchFilterForUnconstrainedSearches null_searcher(target_sp);

lldb/source/Interpreter/CommandObject.cpp

CommandObject::ArgumentTableEntry CommandObject::g_arguments_data[] = {
     { eArgTypeWidth, "width", CommandCompletions::eNoCompletion, { nullptr, false }, "Help text goes here." },
     { eArgTypeNone, "none", CommandCompletions::eNoCompletion, { nullptr, false }, "No help available for this." },
     { eArgTypePlatform, "platform-name", CommandCompletions::ePlatformPluginCompletion, { nullptr, false }, "The name of an installed platform plug-in . Type 'platform list' to see a complete list of installed platforms." },
     { eArgTypeWatchpointID, "watchpt-id", CommandCompletions::eNoCompletion, { nullptr, false }, "Watchpoint IDs are positive integers." },
     { eArgTypeWatchpointIDRange, "watchpt-id-list", CommandCompletions::eNoCompletion, { nullptr, false }, "For example, '1-3' or '1 to 3'." },
     { eArgTypeWatchType, "watch-type", CommandCompletions::eNoCompletion, { nullptr, false }, "Specify the type for a watchpoint." },
     { eArgRawInput, "raw-input", CommandCompletions::eNoCompletion, { nullptr, false }, "Free-form text passed to a command without prior interpretation, allowing spaces without requiring quotes.  To pass arguments and free form text put two dashes ' -- ' between the last argument and any raw input." },
     { eArgTypeCommand, "command", CommandCompletions::eNoCompletion, { nullptr, false }, "An LLDB Command line command." },
-    { eArgTypeColumnNum, "column", CommandCompletions::eNoCompletion, { nullptr, false }, "Column number in a source file." }
+    { eArgTypeColumnNum, "column", CommandCompletions::eNoCompletion, { nullptr, false }, "Column number in a source file." },
+    { eArgTypeModuleUUID, "module-uuid", CommandCompletions::eModuleUUIDCompletion, { nullptr, false }, "A module UUID value." }
     // clang-format on
 };
 
 const CommandObject::ArgumentTableEntry *CommandObject::GetArgumentTable() {
   // If this assertion fires, then the table above is out of date with the
   // CommandArgumentType enumeration
   static_assert((sizeof(CommandObject::g_arguments_data) /
                  sizeof(CommandObject::ArgumentTableEntry)) == eArgTypeLastArg,
                 "");
   return CommandObject::g_arguments_data;
 }

lldb/source/Interpreter/OptionGroupUUID.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 OptionGroupUUID::OptionGroupUUID() : m_uuid() {}
 
 OptionGroupUUID::~OptionGroupUUID() {}
 
 static constexpr OptionDefinition g_option_table[] = {
-    {LLDB_OPT_SET_1, false, "uuid", 'u', OptionParser::eRequiredArgument,
-     nullptr, {}, 0, eArgTypeNone, "A module UUID value."},
+    {LLDB_OPT_SET_1,
+     false,
+     "uuid",
+     'u',
+     OptionParser::eRequiredArgument,
+     nullptr,
+     {},
+     0,
+     eArgTypeModuleUUID,
+     "A module UUID value."},
 };
 
 llvm::ArrayRef<OptionDefinition> OptionGroupUUID::GetDefinitions() {
   return llvm::makeArrayRef(g_option_table);
 }
 
 Status OptionGroupUUID::SetOptionValue(uint32_t option_idx,
                                        llvm::StringRef option_arg,

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

class CommandLineCompletionTestCase(TestBase):
 
     def test_target_modules_load_aout(self):
         """Tests modules completion by completing the target modules load argument."""
         self.build()
         self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.complete_from_to('target modules load a.ou',
                               ['a.out'])
 
+    def test_target_modules_load_dash_u(self):
+        self.build()
+        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.complete_from_to('target modules load -u ', [target.GetModuleAtIndex(0).GetUUIDString()])
+
     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 ')