[lldb] Compute fully qualified command names in FindCommandsForApropos

[kastiglione]

Summary

Fixes incomplete command names in apropos results.

The full command names given by apropos have come from command name string
literals given to CommandObject constructors. For most commands, this has
been accurate, but some commands have incorrect strings. This results in
apropos output that doesn't tell the user the full command name they might
want learn more about. These strings can be fixed.

There's a seperate issue that can't be fixed as easily: plugin commands. With
the way they're implemented, plugin commands have to exclude the root command
from their command name string. To illustrate, the language objc subcommand
has to set its command name string to "objc", which results in apropos printing
results as objc ... instead of language objc ....

To fix both of these issues, this commit changes FindCommandsForApropos to
derive the fully qualified command name using the keys of subcommand maps.

[kastiglione]

Use std::move

[JDevlieghere]

lldb/source/Interpreter/CommandInterpreter.cpp

2866

It's not obvious what type qualified_name is. I would either do:

std::string qualified_name = (command_name + " " + subcommand_name).str();

or

auto qualified_name = std::string(command_name + " " + subcommand_name);

[kastiglione]

lldb/source/Interpreter/CommandInterpreter.cpp

2866

As you've given feedback on use of auto before, should we document some standards around auto? It seems to vary in the code, and from person to person.

I'm cool with explicit std::string, but I think a few bits of context here do indicate it's a string type (ex use of .str(), use of + and a string literal, being passed to AppendString()). I'm thinking that some of these could be documented as either sufficient or insufficient for auto.

Somewhat separately, what do you think about adding AppendString(const Twine&) (D116682) and then making this:

commands_found.AppendString(command_name + " " + subcommand_name);

[JDevlieghere]

lldb/source/Interpreter/CommandInterpreter.cpp

2866

The LLVM Coding Standards have a section on auto: https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable.

If it were any other type, I might agree with your argument, but we have a bunch of "string" types (std::string, llvm::StringRef and lldb_private::ConstString being the usual suspects) making it non-obvious.

[augusto2112]

I liked the small cleanups in the code as well!

[kastiglione]

lldb/source/Interpreter/CommandInterpreter.cpp

2866

from the doc:

or other places where the type is already obvious from the context.

I find this leaves a lot of room for interpretation, ideally it would be more precise. In the mean time I will switch to string but I bet this isn't our last conversation.

[kastiglione]

explicit std::string type

[JDevlieghere]

Thanks!

lldb/include/lldb/Interpreter/CommandInterpreter.h

private:
   // Completely resolves aliases and abbreviations, returning a pointer to the
   // final command object and updating command_line to the fully substituted
   // and translated command.
   CommandObject *ResolveCommandImpl(std::string &command_line,
                                     CommandReturnObject &result);
 
   void FindCommandsForApropos(llvm::StringRef word, StringList &commands_found,
                               StringList &commands_help,
-                              CommandObject::CommandMap &command_map);
+                              const CommandObject::CommandMap &command_map);
 
   // An interruptible wrapper around the stream output
   void PrintCommandOutput(Stream &stream, llvm::StringRef str);
 
   bool EchoCommandNonInteractive(llvm::StringRef line,
                                  const Flags &io_handler_flags) const;
 
   // A very simple state machine which models the command handling transitions

lldb/source/Interpreter/CommandInterpreter.cpp

void CommandInterpreter::OutputHelpText(Stream &strm, llvm::StringRef word_text,
   }
 
   strm.EOL();
   strm.IndentLess(indent_size);
 }
 
 void CommandInterpreter::FindCommandsForApropos(
     llvm::StringRef search_word, StringList &commands_found,
-    StringList &commands_help, CommandObject::CommandMap &command_map) {
-  CommandObject::CommandMap::const_iterator pos;
-
-  for (pos = command_map.begin(); pos != command_map.end(); ++pos) {
-    llvm::StringRef command_name = pos->first;
-    CommandObject *cmd_obj = pos->second.get();
+    StringList &commands_help, const CommandObject::CommandMap &command_map) {
+  for (const auto &pair : command_map) {
+    llvm::StringRef command_name = pair.first;
+    CommandObject *cmd_obj = pair.second.get();
 
     const bool search_short_help = true;
     const bool search_long_help = false;
     const bool search_syntax = false;
     const bool search_options = false;
     if (command_name.contains_insensitive(search_word) ||
         cmd_obj->HelpTextContainsWord(search_word, search_short_help,
                                       search_long_help, search_syntax,
                                       search_options)) {
-      commands_found.AppendString(cmd_obj->GetCommandName());
+      commands_found.AppendString(command_name);
       commands_help.AppendString(cmd_obj->GetHelp());
     }
 
-    if (cmd_obj->IsMultiwordObject()) {
-      CommandObjectMultiword *cmd_multiword = cmd_obj->GetAsMultiwordCommand();
-      FindCommandsForApropos(search_word, commands_found, commands_help,
-                             cmd_multiword->GetSubcommandDictionary());
+    if (auto *multiword_cmd = cmd_obj->GetAsMultiwordCommand()) {
+      StringList subcommands_found;
+      FindCommandsForApropos(search_word, subcommands_found, commands_help,
+                             multiword_cmd->GetSubcommandDictionary());
+      for (const auto &subcommand_name : subcommands_found) {
+        std::string qualified_name =
+            (command_name + " " + subcommand_name).str();
+        commands_found.AppendString(qualified_name);
+      }
     }
   }
 }
 
 void CommandInterpreter::FindCommandsForApropos(llvm::StringRef search_word,
                                                 StringList &commands_found,
                                                 StringList &commands_help,
                                                 bool search_builtin_commands,