[lldb] Tab completion for process plugin name

[MrHate]

Summary

1. Added tab completion to process launch -p, process attach -P, process connect -p;
2. Bound the plugin name common completion as the default completion for eArgTypePlugin arguments.

[teemperor]

I think the two completions here are not related to each other? If yes, I think this should be two reviews/commits. Especially since the plugin completions is good to go, but the PID test should probably test that we get *some* pid back (so that test requires some small changes).

lldb/source/Commands/CommandObjectProcess.cpp

377

Nit: We don't usually do empty lines after case: I think.

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

84

This is just testing that this isn't crashing, but not that we get some pid back. You could just take the pid of the current process and see that we find that (we know that the current process PID exists, so that should be safe).

[MrHate]

In D79929#2050728, @teemperor wrote:

I think the two completions here are not related to each other? If yes, I think this should be two reviews/commits. Especially since the plugin completions is good to go, but the PID test should probably test that we get *some* pid back (so that test requires some small changes).

The reason I put them together is because the command process attach will be provided with both the PID completion and the plugin name completion. So I think there should be a little relationship between these two completions.

[MrHate]

1. Removed PID completion from this patch;
2. Removed the first empty lines for cases;
3. Modified the title and the summary.

[teemperor]

LGTM

[jingham]

This change makes the eArgTypePlugin be the completion for process plugins. Shouldn't we change the enum name and completion name to indicate that?

[MrHate]

That does make sense. I will split it into eArgTypeProcessPlugin and eArgTypeDisassemblePlugin along with the corresponding completion function names at the time I implement the disassemble related completion function.

[jingham]

In D79929#2058939, @MrHate wrote:

That does make sense. I will split it into eArgTypeProcessPlugin and eArgTypeDisassemblePlugin along with the corresponding completion function names at the time I implement the disassemble related completion function.

Excellent, thanks!

lldb/include/lldb/Core/PluginManager.h

public:
 
   static ProcessCreateInstance
   GetProcessCreateCallbackForPluginName(ConstString name);
 
   static const char *GetProcessPluginNameAtIndex(uint32_t idx);
 
   static const char *GetProcessPluginDescriptionAtIndex(uint32_t idx);
 
+  static void AutoCompleteProcessName(llvm::StringRef partial_name,
+                                      CompletionRequest &request);
+
   // ScriptInterpreter
   static bool RegisterPlugin(ConstString name, const char *description,
                              lldb::ScriptLanguage script_lang,
                              ScriptInterpreterCreateInstance create_callback);
 
   static bool UnregisterPlugin(ScriptInterpreterCreateInstance create_callback);
 
   static ScriptInterpreterCreateInstance

lldb/include/lldb/Interpreter/CommandCompletions.h

enum CommonCompletionTypes {
     eSymbolCompletion = (1u << 3),
     eModuleCompletion = (1u << 4),
     eSettingsNameCompletion = (1u << 5),
     ePlatformPluginCompletion = (1u << 6),
     eArchitectureCompletion = (1u << 7),
     eVariablePathCompletion = (1u << 8),
     eRegisterCompletion = (1u << 9),
     eBreakpointCompletion = (1u << 10),
+    eProcessPluginCompletion = (1u << 11),
     // 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 << 11)
+    eCustomCompletion = (1u << 12)
   };
 
   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 VariablePath(CommandInterpreter &interpreter,
                            CompletionRequest &request, SearchFilter *searcher);
 
   static void Registers(CommandInterpreter &interpreter,
                         CompletionRequest &request, SearchFilter *searcher);
 
   static void Breakpoints(CommandInterpreter &interpreter,
                           CompletionRequest &request, SearchFilter *searcher);
+
+  static void ProcessPluginNames(CommandInterpreter &interpreter,
+                                 CompletionRequest &request,
+                                 SearchFilter *searcher);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_COMMANDCOMPLETIONS_H

lldb/source/Commands/CommandCompletions.cpp

const CommonCompletionElement common_completions[] = {
       {eSymbolCompletion, CommandCompletions::Symbols},
       {eModuleCompletion, CommandCompletions::Modules},
       {eSettingsNameCompletion, CommandCompletions::SettingsNames},
       {ePlatformPluginCompletion, CommandCompletions::PlatformPluginNames},
       {eArchitectureCompletion, CommandCompletions::ArchitectureNames},
       {eVariablePathCompletion, CommandCompletions::VariablePath},
       {eRegisterCompletion, CommandCompletions::Registers},
       {eBreakpointCompletion, CommandCompletions::Breakpoints},
+      {eProcessPluginCompletion, CommandCompletions::ProcessPluginNames},
       {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 i = 0; i < num_breakpoints; ++i) {
 
     const size_t colon_pos = bp_info.find_first_of(':');
     if (colon_pos != llvm::StringRef::npos)
       bp_info = bp_info.drop_front(colon_pos + 2);
 
     request.TryCompleteCurrentArg(std::to_string(bp->GetID()), bp_info);
   }
 }
+
+void CommandCompletions::ProcessPluginNames(CommandInterpreter &interpreter,
+                                            CompletionRequest &request,
+                                            SearchFilter *searcher) {
+  PluginManager::AutoCompleteProcessName(request.GetCursorArgumentPrefix(),
+                                         request);
+}
 No newline at end of file

lldb/source/Commands/CommandObjectProcess.cpp

public:
     }
 
     void HandleOptionArgumentCompletion(
         CompletionRequest &request, OptionElementVector &opt_element_vector,
         int opt_element_index, CommandInterpreter &interpreter) override {
       int opt_arg_pos = opt_element_vector[opt_element_index].opt_arg_pos;
       int opt_defs_index = opt_element_vector[opt_element_index].opt_defs_index;
 
-      // We are only completing the name option for now...
-
-      // Are we in the name?
-      if (GetDefinitions()[opt_defs_index].short_option != 'n')
-        return;
-
+      switch (GetDefinitions()[opt_defs_index].short_option) {
+      case 'n': {
         // Look to see if there is a -P argument provided, and if so use that
         // plugin, otherwise use the default plugin.
 
         const char *partial_name = nullptr;
         partial_name = request.GetParsedLine().GetArgumentAtIndex(opt_arg_pos);
 
         PlatformSP platform_sp(interpreter.GetPlatform(true));
         if (!platform_sp)
           return;
         ProcessInstanceInfoList process_infos;
         ProcessInstanceInfoMatch match_info;
         if (partial_name) {
           match_info.GetProcessInfo().GetExecutableFile().SetFile(
               partial_name, FileSpec::Style::native);
           match_info.SetNameMatchType(NameMatch::StartsWith);
         }
         platform_sp->FindProcesses(match_info, process_infos);
         const size_t num_matches = process_infos.size();
         if (num_matches == 0)
           return;
         for (size_t i = 0; i < num_matches; ++i) {
           request.AddCompletion(process_infos[i].GetNameAsStringRef());
         }
+      } break;
+
+      case 'P':
+        CommandCompletions::InvokeCommonCompletionCallbacks(
+            interpreter, CommandCompletions::eProcessPluginCompletion, request,
+            nullptr);
+        break;
+      }
     }
 
     // Instance variables to hold the values for command options.
 
     ProcessAttachInfo attach_info;
   };
 
   CommandObjectProcessAttach(CommandInterpreter &interpreter)
       : CommandObjectProcessLaunchOrAttach(
             interpreter, "process attach", "Attach to a process.",
             "process attach <cmd-options>", 0, "attach"),
         m_options() {}
 
   ~CommandObjectProcessAttach() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     PlatformSP platform_sp(
         GetDebugger().GetPlatformList().GetSelectedPlatform());
 
     Target *target = GetDebugger().GetSelectedTarget().get();
     // N.B. The attach should be synchronous.  It doesn't help much to get the
     // prompt back between initiating the attach and the target actually

lldb/source/Core/PluginManager.cpp

PluginManager::GetProcessCreateCallbackAtIndex(uint32_t idx) {
   return GetProcessInstances().GetCallbackAtIndex(idx);
 }
 
 ProcessCreateInstance
 PluginManager::GetProcessCreateCallbackForPluginName(ConstString name) {
   return GetProcessInstances().GetCallbackForName(name);
 }
 
+void PluginManager::AutoCompleteProcessName(llvm::StringRef name,
+                                            CompletionRequest &request) {
+  for (const auto &instance : GetProcessInstances().GetInstances()) {
+    if (instance.name.GetStringRef().startswith(name))
+      request.AddCompletion(instance.name.GetCString(), instance.description);
+  }
+}
+
 #pragma mark ScriptInterpreter
 
 struct ScriptInterpreterInstance
     : public PluginInstance<ScriptInterpreterCreateInstance> {
   ScriptInterpreterInstance(ConstString name, std::string description,
                             CallbackType create_callback,
                             lldb::ScriptLanguage language)
       : PluginInstance<ScriptInterpreterCreateInstance>(

lldb/source/Interpreter/CommandObject.cpp

CommandObject::ArgumentTableEntry CommandObject::g_arguments_data[] = {
     { eArgTypeNumberPerLine, "number-per-line", CommandCompletions::eNoCompletion, { nullptr, false }, "The number of items per line to display." },
     { eArgTypeOffset, "offset", CommandCompletions::eNoCompletion, { nullptr, false }, "Help text goes here." },
     { eArgTypeOldPathPrefix, "old-path-prefix", CommandCompletions::eNoCompletion, { nullptr, false }, "Help text goes here." },
     { eArgTypeOneLiner, "one-line-command", CommandCompletions::eNoCompletion, { nullptr, false }, "A command that is entered as a single line of text." },
     { eArgTypePath, "path", CommandCompletions::eDiskFileCompletion, { nullptr, false }, "Path." },
     { eArgTypePermissionsNumber, "perms-numeric", CommandCompletions::eNoCompletion, { nullptr, false }, "Permissions given as an octal number (e.g. 755)." },
     { eArgTypePermissionsString, "perms=string", CommandCompletions::eNoCompletion, { nullptr, false }, "Permissions given as a string value (e.g. rw-r-xr--)." },
     { eArgTypePid, "pid", CommandCompletions::eNoCompletion, { nullptr, false }, "The process ID number." },
-    { eArgTypePlugin, "plugin", CommandCompletions::eNoCompletion, { nullptr, false }, "Help text goes here." },
+    { eArgTypePlugin, "plugin", CommandCompletions::eProcessPluginCompletion, { nullptr, false }, "Help text goes here." },
     { eArgTypeProcessName, "process-name", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of the process." },
     { eArgTypePythonClass, "python-class", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of a Python class." },
     { eArgTypePythonFunction, "python-function", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of a Python function." },
     { eArgTypePythonScript, "python-script", CommandCompletions::eNoCompletion, { nullptr, false }, "Source code written in Python." },
     { eArgTypeQueueName, "queue-name", CommandCompletions::eNoCompletion, { nullptr, false }, "The name of the thread queue." },
     { eArgTypeRegisterName, "register-name", CommandCompletions::eNoCompletion, { RegisterNameHelpTextCallback, true }, nullptr },
     { eArgTypeRegularExpression, "regular-expression", CommandCompletions::eNoCompletion, { nullptr, false }, "A POSIX-compliant extended regular expression." },
     { eArgTypeRunArgs, "run-args", CommandCompletions::eNoCompletion, { nullptr, false }, "Arguments to be passed to the target program when it starts executing." },

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

class CommandLineCompletionTestCase(TestBase):
 
     def test_process_attach_dash_dash_con(self):
         """Test that 'process attach --con' completes to 'process attach --continue '."""
         self.complete_from_to(
             'process attach --con',
             'process attach --continue ')
 
     def test_process_launch_arch(self):
         self.complete_from_to('process launch --arch ',
                               ['mips',
                                'arm64'])
 
+    def test_process_plugin_completion(self):
+        subcommands = ['attach -P', 'connect -p', 'launch -p']
+
+        for subcommand in subcommands:
+            self.complete_from_to('process ' + subcommand + ' mac',
+                                  'process ' + subcommand + ' mach-o-core')
+
     def test_process_signal(self):
         # The tab completion for "process signal"  won't work without a running process.
         self.complete_from_to('process signal ',
                               'process signal ')
 
         # Test with a running process.
         self.build()
         self.main_source = "main.cpp"