Make aliases from a raw command that isn't a top-level command work

[jingham]

Summary

When we went to alias a raw command, we look up the command and pass that to HandleAliasingRawCommand. But then there is a check to make sure that we aren't using a nested alias, which we do by re-looking up the command object by name. Note, the command object's name is just its individual name, not the full path. That's appropriate for checking aliases since at present you can only alias TO a top-level command.

But if that lookup failed we return an error. That lookup will fail for anything that's not a top-level command, since this is just the node name not the path. So we should then look up the full command, but fortunately we don't have to do that because we already have the command passed in. So if it isn't an alias to be resolved, we can just use it directly.

I had to add enable_shared_from_this to CommandObject. We pass CommandObject *'s around in the command parsing code when we probably should be passing Shared Pointers, but trying to fix that ended up being a lot of change for not much benefit, and shared_from_this solves this neatly.

lldb/include/lldb/Interpreter/CommandObject.h

 //===-- CommandObject.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_INTERPRETER_COMMANDOBJECT_H
 #define LLDB_INTERPRETER_COMMANDOBJECT_H
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "lldb/Utility/Flags.h"
 
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Target/ExecutionContext.h"
size_t FindLongestCommandWord(std::map<std::string, ValueType> &dict) {
   for (auto pos = dict.begin(); pos != end; ++pos) {
     size_t len = pos->first.size();
     if (max_len < len)
       max_len = len;
   }
   return max_len;
 }
 
-class CommandObject {
+class CommandObject : public std::enable_shared_from_this<CommandObject> {
 public:
   typedef llvm::StringRef(ArgumentHelpCallbackFunction)();
 
   struct ArgumentHelpCallback {
     ArgumentHelpCallbackFunction *help_callback;
     bool self_formatting;
 
     llvm::StringRef operator()() const { return (*help_callback)(); }

lldb/source/Commands/CommandObjectCommands.cpp

bool HandleAliasingRawCommand(llvm::StringRef alias_command,
                                 CommandObject &cmd_obj,
                                 CommandReturnObject &result) {
     // Verify & handle any options/arguments passed to the alias command
 
     OptionArgVectorSP option_arg_vector_sp =
         OptionArgVectorSP(new OptionArgVector);
 
     const bool include_aliases = true;
-    if (CommandObjectSP cmd_obj_sp = m_interpreter.GetCommandSPExact(
-            cmd_obj.GetCommandName(), include_aliases)) {
-      if (m_interpreter.AliasExists(alias_command) ||
-          m_interpreter.UserCommandExists(alias_command)) {
-        result.AppendWarningWithFormat(
-            "Overwriting existing definition for '%s'.\n",
-            alias_command.str().c_str());
-      }
-      if (CommandAlias *alias = m_interpreter.AddAlias(
-              alias_command, cmd_obj_sp, raw_command_string)) {
-        if (m_command_options.m_help.OptionWasSet())
-          alias->SetHelp(m_command_options.m_help.GetCurrentValue());
-        if (m_command_options.m_long_help.OptionWasSet())
-          alias->SetHelpLong(m_command_options.m_long_help.GetCurrentValue());
-        result.SetStatus(eReturnStatusSuccessFinishNoResult);
-      } else {
-        result.AppendError("Unable to create requested alias.\n");
-      }
-
-    } else {
-      result.AppendError("Unable to create requested alias.\n");
-    }
-
+    // Look up the command using command's name first.  This is to resolve
+    // aliases when you are making nested aliases.  But if you don't find
+    // it that way, then it wasn't an alias and we can just use the object
+    // we were passed in.
+    CommandObjectSP cmd_obj_sp = m_interpreter.GetCommandSPExact(
+            cmd_obj.GetCommandName(), include_aliases);
+    if (!cmd_obj_sp)
+      cmd_obj_sp = cmd_obj.shared_from_this();
+
     return result.Succeeded();
   }
 
   bool HandleAliasingNormalCommand(Args &args, CommandReturnObject &result) {
     size_t argc = args.GetArgumentCount();
 
     if (argc < 2) {
       result.AppendError("'command alias' requires at least two arguments");

lldb/test/API/commands/command/container/TestContainerCommands.py

def container_add(self):
         self.expect("help test-multi test-multi-sub", "Listing subcommands works",
                     substrs=["A test container sub-command", "welcome -- Just a docstring for Welcome"])
         self.expect("help test-multi test-multi-sub welcome", "Subcommand help works",
                     substrs=["Just a docstring for Welcome"])
         # And make sure it actually works:
         self.expect("test-multi test-multi-sub welcome friend", "Test command works",
                     substrs=["Hello friend, welcome to LLDB"])
 
+        # Make sure we can make an alias to this:
+        self.runCmd("command alias my-welcome test-multi test-multi-sub welcome", "We can make an alias to multi-word")
+        self.expect("my-welcome friend", "Test command works",
+                    substrs=["Hello friend, welcome to LLDB"])
+        self.runCmd("command unalias my-welcome")
+        
         # Make sure overwriting works on the leaf command.  First using the
         # explicit option so we should not be able to remove extant commands by default:
 
         self.expect("command script add -c welcome.WelcomeCommand2 test-multi test-multi-sub welcome",
                     "overwrite command w/o -o",
                     substrs=["cannot add command: sub-command already exists"], error=True)
         # But we can with the -o option:
         self.runCmd("command script add -c welcome.WelcomeCommand2 -o test-multi test-multi-sub welcome")