[lldb] tab completion for `disassemble -F`

[MrHate]

Summary

1. Added a new common completion DisassemblyFlavors;
2. Bound DisassemblyFlavors to argument of type eArgTypeDisassemblyFlavor in CommandObject.cpp;
3. Added a related test case.

[teemperor]

Landed as 8a5e296975b3da5d5d849ae8185ef3d98ca77795

lldb/include/lldb/Interpreter/CommandCompletions.h

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

lldb/source/Commands/CommandCompletions.cpp

const CommonCompletionElement common_completions[] = {
       {eProcessPluginCompletion, CommandCompletions::ProcessPluginNames},
       {eProcessIDCompletion, CommandCompletions::ProcessIDs},
       {eFrameIndexCompletion, CommandCompletions::FrameIndexes},
       {eThreadIndexCompletion, CommandCompletions::ThreadIndexes},
       {eWatchPointIDCompletion, CommandCompletions::WatchPointIDs},
       {eStopHookIDCompletion, CommandCompletions::StopHookIDs},
       {eTypeCategoryNameCompletion, CommandCompletions::TypeCategoryNames},
       {eTypeLanguageCompletion, CommandCompletions::TypeLanguages},
+      {eDisassemblyFlavorCompletion, CommandCompletions::DisassemblyFlavors},
       {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::TypeLanguages(CommandInterpreter &interpreter,
                                        CompletionRequest &request,
                                        SearchFilter *searcher) {
   for (int bit :
        Language::GetLanguagesSupportingTypeSystems().bitvector.set_bits()) {
     request.TryCompleteCurrentArg(
         Language::GetNameForLanguageType((lldb::LanguageType)bit));
   }
 }
+
+void CommandCompletions::DisassemblyFlavors(CommandInterpreter &interpreter,
+                                            CompletionRequest &request,
+                                            SearchFilter *searcher) {
+  // Currently the only valid options for disassemble -F are default, and for
+  // Intel architectures, att and intel.
+  static const char *flavors[] = {"default", "att", "intel"};
+  for (const char *flavor : flavors) {
+    request.TryCompleteCurrentArg(flavor);
+  }
+}

lldb/source/Interpreter/CommandObject.cpp

CommandObject::ArgumentTableEntry CommandObject::g_arguments_data[] = {
     { eArgTypeBreakpointID, "breakpt-id", CommandCompletions::eNoCompletion, { BreakpointIDHelpTextCallback, false }, nullptr },
     { eArgTypeBreakpointIDRange, "breakpt-id-list", CommandCompletions::eNoCompletion, { BreakpointIDRangeHelpTextCallback, false }, nullptr },
     { eArgTypeBreakpointName, "breakpoint-name", CommandCompletions::eBreakpointNameCompletion, { BreakpointNameHelpTextCallback, false }, nullptr },
     { eArgTypeByteSize, "byte-size", CommandCompletions::eNoCompletion, { nullptr, false }, "Number of bytes to use." },
     { eArgTypeClassName, "class-name", CommandCompletions::eNoCompletion, { nullptr, false }, "Then name of a class from the debug information in the program." },
     { eArgTypeCommandName, "cmd-name", CommandCompletions::eNoCompletion, { nullptr, false }, "A debugger command (may be multiple words), without any options or arguments." },
     { eArgTypeCount, "count", CommandCompletions::eNoCompletion, { nullptr, false }, "An unsigned integer." },
     { eArgTypeDirectoryName, "directory", CommandCompletions::eDiskDirectoryCompletion, { nullptr, false }, "A directory name." },
-    { eArgTypeDisassemblyFlavor, "disassembly-flavor", CommandCompletions::eNoCompletion, { nullptr, false }, "A disassembly flavor recognized by your disassembly plugin.  Currently the only valid options are \"att\" and \"intel\" for Intel targets" },
+    { eArgTypeDisassemblyFlavor, "disassembly-flavor", CommandCompletions::eDisassemblyFlavorCompletion, { nullptr, false }, "A disassembly flavor recognized by your disassembly plugin.  Currently the only valid options are \"att\" and \"intel\" for Intel targets" },
     { eArgTypeDescriptionVerbosity, "description-verbosity", CommandCompletions::eNoCompletion, { nullptr, false }, "How verbose the output of 'po' should be." },
     { eArgTypeEndAddress, "end-address", CommandCompletions::eNoCompletion, { nullptr, false }, "Help text goes here." },
     { eArgTypeExpression, "expr", CommandCompletions::eNoCompletion, { nullptr, false }, "Help text goes here." },
     { eArgTypeExpressionPath, "expr-path", CommandCompletions::eNoCompletion, { ExprPathHelpTextCallback, true }, nullptr },
     { eArgTypeExprFormat, "expression-format", CommandCompletions::eNoCompletion, { nullptr, false }, "[ [bool|b] | [bin] | [char|c] | [oct|o] | [dec|i|d|u] | [hex|x] | [float|f] | [cstr|s] ]" },
     { eArgTypeFilename, "filename", CommandCompletions::eDiskFileCompletion, { nullptr, false }, "The name of a file (can include path)." },
     { eArgTypeFormat, "format", CommandCompletions::eNoCompletion, { FormatHelpTextCallback, true }, nullptr },
     { eArgTypeFrameIndex, "frame-index", CommandCompletions::eFrameIndexCompletion, { nullptr, false }, "Index into a thread's list of frames." },

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

def test_process_signal(self):
                                'SIGALRM'])
 
     def test_ambiguous_long_opt(self):
         self.completions_match('breakpoint modify --th',
                                ['--thread-id',
                                 '--thread-index',
                                 '--thread-name'])
 
+    def test_disassemble_dash_f(self):
+        self.completions_match('disassemble -F ',
+                               ['default',
+                                'intel',
+                                'att'])
+
     def test_plugin_load(self):
         self.complete_from_to('plugin load ', [])
 
     def test_log_enable(self):
         self.complete_from_to('log enable ll', ['lldb'])
         self.complete_from_to('log enable dw', ['dwarf'])
         self.complete_from_to('log enable lldb al', ['all'])
         self.complete_from_to('log enable lldb sym', ['symbol'])