[lldb] Provide tab completion for target select/delete

[teemperor]

Summary

Select and delete are similar enough to implement/test this in one batch.

Completion looks like this:

(lldb) target select 
Available completions:
	0 -- /Users/me/test/foo ( arch=x86_64-apple-macosx10.14.0, platform=host, pid=65449, state=stopped )
	1 -- /Users/me/test/basic ( arch=x86_64-apple-macosx10.14.0, platform=host )

[JDevlieghere]

lldb/source/Commands/CommandObjectTarget.cpp

63

Can we convert these boolean flags with a new enum or struct TargetInfoDumpOptions?

[kwk]

Why don't we always print the target index? Wouldn't that be much simpler?

lldb/source/Commands/CommandObjectTarget.cpp

76

Happy New Years! For the rest of file and in particular for the target properties (e.g. arch, platform), we use a one line strm.Printf. But I can understand that you don't want to introduce a ?: for every argument of the Printf. However why don't we always print the target index? Wouldn't that be much simpler?

lldb/packages/Python/lldbsuite/test/functionalities/completion/TestCompletion.py

def test_symbol_name(self):
         self.build()
         self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.complete_from_to('breakpoint set -n Fo',
                               'breakpoint set -n Foo::Bar(int,\\ int)',
                               turn_off_re_match=True)
         # No completion for Qu because the candidate is
         # (anonymous namespace)::Quux().
         self.complete_from_to('breakpoint set -n Qu', '')
+
+    def test_target_select_and_delete(self):
+        self.build()
+        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+
+        self.complete_from_to('target select ',
+                              ['0',
+                               '1',
+                               '2'])
+
+        self.complete_from_to('target select 0 ',
+                              [])
+
+        self.complete_from_to('target delete ',
+                              ['0',
+                               '1',
+                               '2'])
+
+        self.complete_from_to('target delete 1 ',
+                              ['0',
+                               '1',
+                               '2'])

lldb/source/Commands/CommandObjectTarget.cpp

 
 #include <cerrno>
 
 using namespace lldb;
 using namespace lldb_private;
 
 static void DumpTargetInfo(uint32_t target_idx, Target *target,
                            const char *prefix_cstr,
-                           bool show_stopped_process_status, Stream &strm) {
+                           bool show_stopped_process_status,
+                           bool print_target_index, Stream &strm) {
   const ArchSpec &target_arch = target->GetArchitecture();
 
   Module *exe_module = target->GetExecutableModulePointer();
   char exe_path[PATH_MAX];
   bool exe_valid = false;
   if (exe_module)
     exe_valid = exe_module->GetFileSpec().GetPath(exe_path, sizeof(exe_path));
 
   if (!exe_valid)
     ::strcpy(exe_path, "<none>");
 
-  strm.Printf("%starget #%u: %s", prefix_cstr ? prefix_cstr : "", target_idx,
-              exe_path);
+  if (prefix_cstr)
+    strm << prefix_cstr;
+
+  if (print_target_index)
+    strm.Printf("target #%u: ", target_idx);
+
+  strm << exe_path;
 
   uint32_t properties = 0;
   if (target_arch.IsValid()) {
     strm.Printf("%sarch=", properties++ > 0 ? ", " : " ( ");
     target_arch.DumpTriple(strm);
     properties++;
   }
   PlatformSP platform_sp(target->GetPlatform());
static uint32_t DumpTargetList(TargetList &target_list,
   const uint32_t num_targets = target_list.GetNumTargets();
   if (num_targets) {
     TargetSP selected_target_sp(target_list.GetSelectedTarget());
     strm.PutCString("Current targets:\n");
     for (uint32_t i = 0; i < num_targets; ++i) {
       TargetSP target_sp(target_list.GetTargetAtIndex(i));
       if (target_sp) {
         bool is_selected = target_sp.get() == selected_target_sp.get();
+        bool print_target_index = true;
         DumpTargetInfo(i, target_sp.get(), is_selected ? "* " : "  ",
-                       show_stopped_process_status, strm);
+                       show_stopped_process_status, print_target_index, strm);
       }
     }
   }
   return num_targets;
 }
 
+static void CompleteTargetIndex(CompletionRequest &request,
+                                Debugger &debugger) {
+  TargetList &target_list = debugger.GetTargetList();
+  size_t number_of_targets = target_list.GetNumTargets();
+  for (size_t target_i = 0; target_i < number_of_targets; ++target_i) {
+    // The completion is only the target index.
+    std::string completion = std::to_string(target_i);
+
+    // Generate the description.
+    TargetSP target_sp(target_list.GetTargetAtIndex(target_i));
+    StreamString stream;
+    bool show_stopped_process_status = false;
+    bool print_thread_index = false;
+    DumpTargetInfo(target_i, target_sp.get(), "", show_stopped_process_status,
+                   print_thread_index, stream);
+    llvm::StringRef description = stream.GetString().rtrim();
+
+    request.TryCompleteCurrentArg(completion, description);
+  }
+}
+
 // Note that the negation in the argument name causes a slightly confusing
 // mapping of the enum values.
 static constexpr OptionEnumValueElement g_dependents_enumaration[] = {
     {
         eLoadDependentsDefault,
         "default",
         "Only load dependents when the target is an executable.",
     },
public:
   CommandObjectTargetSelect(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "target select",
             "Select a target as the current target by target index.", nullptr) {
   }
 
   ~CommandObjectTargetSelect() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    if (request.GetCursorIndex() != 0)
+      return;
+    CompleteTargetIndex(request, GetDebugger());
+  }
+
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     if (args.GetArgumentCount() == 1) {
       bool success = false;
       const char *target_idx_arg = args.GetArgumentAtIndex(0);
       uint32_t target_idx =
           StringConvert::ToUInt32(target_idx_arg, UINT32_MAX, 0, &success);
       if (success) {
CommandObjectTargetDelete(CommandInterpreter &interpreter)
     m_option_group.Append(&m_cleanup_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Finalize();
   }
 
   ~CommandObjectTargetDelete() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    CompleteTargetIndex(request, GetDebugger());
+  }
+
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     const size_t argc = args.GetArgumentCount();
     std::vector<TargetSP> delete_target_list;
     TargetList &target_list = GetDebugger().GetTargetList();
     TargetSP target_sp;
 
     if (m_all_option.GetOptionValue()) {