[lldb] type language common completion

[MrHate]

Summary

1. Added a new common completion TypeLanguages to provide a list of supporting languages;
2. Bound the completion to eArgTypeLanguage;
3. Added a related test case.

[JDevlieghere]

LGTM modulo my inline comment.

lldb/source/Commands/CommandCompletions.cpp

753

Please use static_cast<lldb::LanguageTyp> instead of a C-style cast.

[MrHate]

• Use static_cast<lldb::LanguageType>(bit) instead of C-style cast.

[teemperor]

Landed as 3ce57e012110519c1d3a49fc98959a64634d5d8f

lldb/include/lldb/Interpreter/CommandCompletions.h

enum CommonCompletionTypes {
     eProcessPluginCompletion = (1u << 12),
     eProcessIDCompletion = (1u << 13),
     eFrameIndexCompletion = (1u << 14),
     eThreadIndexCompletion = (1u << 15),
     eWatchPointIDCompletion = (1u << 16),
     eModuleUUIDCompletion = (1u << 17),
     eStopHookIDCompletion = (1u << 18),
     eTypeCategoryNameCompletion = (1u << 19),
+    eTypeLanguageCompletion = (1u << 20),
     // 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 << 20)
+    eCustomCompletion = (1u << 21)
   };
 
   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 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);
+
+  static void TypeLanguages(CommandInterpreter &interpreter,
+                            CompletionRequest &request, SearchFilter *searcher);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_COMMANDCOMPLETIONS_H

lldb/source/Commands/CommandCompletions.cpp

 #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/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/TildeExpressionResolver.h"
 
 #include "llvm/Support/FileSystem.h"
const CommonCompletionElement common_completions[] = {
       {eBreakpointNameCompletion, CommandCompletions::BreakpointNames},
       {eProcessPluginCompletion, CommandCompletions::ProcessPluginNames},
       {eProcessIDCompletion, CommandCompletions::ProcessIDs},
       {eFrameIndexCompletion, CommandCompletions::FrameIndexes},
       {eThreadIndexCompletion, CommandCompletions::ThreadIndexes},
       {eWatchPointIDCompletion, CommandCompletions::WatchPointIDs},
       {eStopHookIDCompletion, CommandCompletions::StopHookIDs},
       {eTypeCategoryNameCompletion, CommandCompletions::TypeCategoryNames},
+      {eTypeLanguageCompletion, CommandCompletions::TypeLanguages},
       {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::TypeCategoryNames(CommandInterpreter &interpreter,
                                            SearchFilter *searcher) {
   DataVisualization::Categories::ForEach(
       [&request](const lldb::TypeCategoryImplSP &category_sp) {
         request.TryCompleteCurrentArg(category_sp->GetName(),
                                       category_sp->GetDescription());
         return true;
       });
 }
+
+void CommandCompletions::TypeLanguages(CommandInterpreter &interpreter,
+                                       CompletionRequest &request,
+                                       SearchFilter *searcher) {
+  for (int bit :
+       Language::GetLanguagesSupportingTypeSystems().bitvector.set_bits()) {
+    request.TryCompleteCurrentArg(
+        Language::GetNameForLanguageType(static_cast<lldb::LanguageType>(bit)));
+  }
+}

lldb/source/Interpreter/CommandObject.cpp

CommandObject::ArgumentTableEntry CommandObject::g_arguments_data[] = {
     { eArgTypeFormat, "format", CommandCompletions::eNoCompletion, { FormatHelpTextCallback, true }, nullptr },
     { eArgTypeFrameIndex, "frame-index", CommandCompletions::eFrameIndexCompletion, { nullptr, false }, "Index into a thread's list of frames." },
     { eArgTypeFullName, "fullname", CommandCompletions::eNoCompletion, { nullptr, false }, "Help text goes here." },
     { eArgTypeFunctionName, "function-name", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of a function." },
     { eArgTypeFunctionOrSymbol, "function-or-symbol", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of a function or symbol." },
     { eArgTypeGDBFormat, "gdb-format", CommandCompletions::eNoCompletion, { GDBFormatHelpTextCallback, true }, nullptr },
     { eArgTypeHelpText, "help-text", CommandCompletions::eNoCompletion, { nullptr, false }, "Text to be used as help for some other entity in LLDB" },
     { eArgTypeIndex, "index", CommandCompletions::eNoCompletion, { nullptr, false }, "An index into a list." },
-    { eArgTypeLanguage, "source-language", CommandCompletions::eNoCompletion, { LanguageTypeHelpTextCallback, true }, nullptr },
+    { eArgTypeLanguage, "source-language", CommandCompletions::eTypeLanguageCompletion, { LanguageTypeHelpTextCallback, true }, nullptr },
     { eArgTypeLineNum, "linenum", CommandCompletions::eNoCompletion, { nullptr, false }, "Line number in a source file." },
     { eArgTypeLogCategory, "log-category", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of a category within a log channel, e.g. all (try \"log list\" to see a list of all channels and their categories." },
     { eArgTypeLogChannel, "log-channel", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of a log channel, e.g. process.gdb-remote (try \"log list\" to see a list of all channels and their categories)." },
     { eArgTypeMethod, "method", CommandCompletions::eNoCompletion, { nullptr, false }, "A C++ method name." },
     { eArgTypeName, "name", CommandCompletions::eTypeCategoryNameCompletion, { nullptr, false }, "Help text goes here." },
     { eArgTypeNewPathPrefix, "new-path-prefix", CommandCompletions::eNoCompletion, { nullptr, false }, "Help text goes here." },
     { eArgTypeNumLines, "num-lines", CommandCompletions::eNoCompletion, { nullptr, false }, "The number of lines to use." },
     { eArgTypeNumberPerLine, "number-per-line", CommandCompletions::eNoCompletion, { nullptr, false }, "The number of items per line to display." },

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

def test_common_completion_thread_index(self):
             self.complete_from_to('thread ' + subcommand + ' ', ['1'])
 
     def test_common_completion_type_category_name(self):
         subcommands = ['delete', 'list', 'enable', 'disable', 'define']
         for subcommand in subcommands:
             self.complete_from_to('type category ' + subcommand + ' ', ['default'])
         self.complete_from_to('type filter add -w ', ['default'])
 
+    def test_common_completion_type_language(self):
+        self.complete_from_to('type category -l ', ['c'])
+
     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"])