[lldb] type category name common completion

[MrHate]

Summary

1. Added a new common completion TypeCategoryNames to provide a list of category names for completion;
2. Applied the completion to these commands: type category delete/enable/disable/list/define;
3. Added a related test case;

4.Bound the completion to the arguments of the type 'eArgTypeName'.

[MrHate]

• Applied completion to type category define.

[MrHate]

• Bound the completion to the arguments of the type 'eArgTypeName', so that options like type filter add -w can be completed.

[teemperor]

LGTM, thanks!

lldb/include/lldb/Interpreter/CommandCompletions.h

enum CommonCompletionTypes {
     eBreakpointNameCompletion = (1u << 11),
     eProcessPluginCompletion = (1u << 12),
     eProcessIDCompletion = (1u << 13),
     eFrameIndexCompletion = (1u << 14),
     eThreadIndexCompletion = (1u << 15),
     eWatchPointIDCompletion = (1u << 16),
     eModuleUUIDCompletion = (1u << 17),
     eStopHookIDCompletion = (1u << 18),
+    eTypeCategoryNameCompletion = (1u << 19),
     // 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 << 19)
+    eCustomCompletion = (1u << 20)
   };
 
   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 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);
+
+  static void TypeCategoryNames(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/DataFormatters/DataVisualization.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"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
const CommonCompletionElement common_completions[] = {
       {eBreakpointCompletion, CommandCompletions::Breakpoints},
       {eBreakpointNameCompletion, CommandCompletions::BreakpointNames},
       {eProcessPluginCompletion, CommandCompletions::ProcessPluginNames},
       {eProcessIDCompletion, CommandCompletions::ProcessIDs},
       {eFrameIndexCompletion, CommandCompletions::FrameIndexes},
       {eThreadIndexCompletion, CommandCompletions::ThreadIndexes},
       {eWatchPointIDCompletion, CommandCompletions::WatchPointIDs},
       {eStopHookIDCompletion, CommandCompletions::StopHookIDs},
+      {eTypeCategoryNameCompletion, CommandCompletions::TypeCategoryNames},
       {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 &&
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());
   }
 }
+
+void CommandCompletions::TypeCategoryNames(CommandInterpreter &interpreter,
+                                           CompletionRequest &request,
+                                           SearchFilter *searcher) {
+  DataVisualization::Categories::ForEach(
+      [&request](const lldb::TypeCategoryImplSP &category_sp) {
+        request.TryCompleteCurrentArg(category_sp->GetName(),
+                                      category_sp->GetDescription());
+        return true;
+      });
+}

lldb/source/Commands/CommandObjectType.cpp

CommandObjectTypeCategoryEnable(CommandInterpreter &interpreter)
 
     type_arg.push_back(type_style_arg);
 
     m_arguments.push_back(type_arg);
   }
 
   ~CommandObjectTypeCategoryEnable() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(),
+        CommandCompletions::eTypeCategoryNameCompletion, request, nullptr);
+  }
+
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
 
     if (argc < 1 && m_options.m_language == lldb::eLanguageTypeUnknown) {
       result.AppendErrorWithFormat("%s takes arguments and/or a language",
                                    m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
CommandObjectTypeCategoryDelete(CommandInterpreter &interpreter)
 
     type_arg.push_back(type_style_arg);
 
     m_arguments.push_back(type_arg);
   }
 
   ~CommandObjectTypeCategoryDelete() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(),
+        CommandCompletions::eTypeCategoryNameCompletion, request, nullptr);
+  }
+
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
 
     if (argc < 1) {
       result.AppendErrorWithFormat("%s takes 1 or more arg.\n",
                                    m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
CommandObjectTypeCategoryDisable(CommandInterpreter &interpreter)
 
     type_arg.push_back(type_style_arg);
 
     m_arguments.push_back(type_arg);
   }
 
   ~CommandObjectTypeCategoryDisable() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(),
+        CommandCompletions::eTypeCategoryNameCompletion, request, nullptr);
+  }
+
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
 
     if (argc < 1 && m_options.m_language == lldb::eLanguageTypeUnknown) {
       result.AppendErrorWithFormat("%s takes arguments and/or a language",
                                    m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
CommandObjectTypeCategoryList(CommandInterpreter &interpreter)
 
     type_arg.push_back(type_style_arg);
 
     m_arguments.push_back(type_arg);
   }
 
   ~CommandObjectTypeCategoryList() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    if (request.GetCursorIndex())
+      return;
+    CommandCompletions::InvokeCommonCompletionCallbacks(
+        GetCommandInterpreter(),
+        CommandCompletions::eTypeCategoryNameCompletion, request, nullptr);
+  }
+
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
 
     std::unique_ptr<RegularExpression> regex;
 
     if (argc == 1) {
       const char *arg = command.GetArgumentAtIndex(0);

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

def test_common_completion_thread_index(self):
 
         self.build()
         lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp"))
 
         # At least we have the thread at the index of 1 now.
         for subcommand in subcommands:
             self.complete_from_to('thread ' + subcommand + ' ', ['1'])
 
+    def test_common_completion_type_category_name(self):
+        subcommands = ['delete', 'list', 'enable', 'disable']
+        for subcommand in subcommands:
+            self.complete_from_to('type category ' + subcommand + ' ', ['default'])
+
     def test_command_argument_completion(self):
         """Test completion of command arguments"""
         self.complete_from_to("watchpoint set variable -", ["-w", "-s"])
         self.complete_from_to('watchpoint set variable -w', 'watchpoint set variable -w ')
         self.complete_from_to("watchpoint set variable --", ["--watch", "--size"])
         self.complete_from_to("watchpoint set variable --w", "watchpoint set variable --watch")
         self.complete_from_to('watchpoint set variable -w ', ['read', 'write', 'read_write'])
         self.complete_from_to("watchpoint set variable --watch ", ["read", "write", "read_write"])