[CommandInterpreter] Implement UserCommandExists

[wallace]

Summary

I don't have an immediate use for this, but I had already implemented
it, so I better make a diff for this.

[wallace]

.

[wallace]

Improve some names

[labath]

I don't have a hard objection to this, but if we're don't have a use for it, I don't see a need for adding it right now.
Particularly as it sounds weird to me that "user commands" are not a subset of "commands". I know that is how the underlying api works, but the underlying api looks weird to me too. However, that one (unlike the SB version) can be changed whenever we want.

As for the test, the same remarks I made on the other review apply here too.

[shafik]

I agree, if we don't have an immediate use then I don't think we should add it now.

[teemperor]

I think the part of the patch that adds documentation to the existing method should go in (In general all patches that just add documentation have my blanket approval, so please just commit those).

For the additional function: If you just change that CommandExists also checks user commands, I think that seems reasonable to me.

[labath]

In D77582#1966962, @teemperor wrote:

I think the part of the patch that adds documentation to the existing method should go in (In general all patches that just add documentation have my blanket approval, so please just commit those).

About that... the existing practice has been to attach documentation to the python versions of these interfaces (bindings/interface/*.i). Now we started to add it to the c++ headers too. More documentation is always better, but OTOH repetition creates maintenance problems and increases the risk of it going stale. Should choose one of the two interfaces and put all documentation there (and maybe have a way to auto-generate the other one) ?

[jingham]

In D77582#1967031, @labath wrote:

In D77582#1966962, @teemperor wrote:

I think the part of the patch that adds documentation to the existing method should go in (In general all patches that just add documentation have my blanket approval, so please just commit those).

About that... the existing practice has been to attach documentation to the python versions of these interfaces (bindings/interface/*.i). Now we started to add it to the c++ headers too. More documentation is always better, but OTOH repetition creates maintenance problems and increases the risk of it going stale. Should choose one of the two interfaces and put all documentation there (and maybe have a way to auto-generate the other one) ?

We need to keep the documentation in the interface files, that's what produces the python and online doc help. That's where the vast majority of users of the API will go to find help for it. But the C++ docs do go into the C++ API docs on the website so they also have some (if not as much) value. Having a way to salt one from the other would be ideal, though sometimes the Python API needs a little extra color so this isn't entirely trivial.

[wallace]

Will revisit it whenever I need it

lldb/bindings/interface/SBCommandInterpreter.i

public:
 
     void
     ResolveCommand(const char *command_line, SBCommandReturnObject &result);
 
     bool
     CommandExists (const char *cmd);
 
     bool
+    UserCommandExists (const char *cmd);
+
+    bool
     AliasExists (const char *cmd);
 
     lldb::SBBroadcaster
     GetBroadcaster ();
 
     static const char *
     GetBroadcasterClass ();
 

lldb/include/lldb/API/SBCommandInterpreter.h

 //===-- SBCommandInterpreter.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
 //
 //===----------------------------------------------------------------------===//
 
public:
   GetArgumentDescriptionAsCString(const lldb::CommandArgumentType arg_type);
 
   static bool EventIsCommandInterpreterEvent(const lldb::SBEvent &event);
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
+  /// Determine whether a command exists in this CommandInterpreter.
+  ///
+  /// For commands registered using the LLDB API, see UserCommandExists
+  ///
+  /// \param[in] cmd
+  ///     The command to look up.
+  ///
+  /// \return
+  ///     \b true if the provided command exists, \b false otherwise.
   bool CommandExists(const char *cmd);
 
+  /// Determine whether a user command exists in this CommandInterpreter.
+  /// Users commands are the ones registered using the LLDB API and are not
+  /// provided by default in LLDB.
+  ///
+  /// \param[in] cmd
+  ///     The command to look up.
+  ///
+  /// \return
+  ///     \b true if the provided command exists, \b false otherwise.
+  bool UserCommandExists(const char *cmd);
+
   bool AliasExists(const char *cmd);
 
   lldb::SBBroadcaster GetBroadcaster();
 
   static const char *GetBroadcasterClass();
 
   bool HasCommands();
 

lldb/source/API/SBCommandInterpreter.cpp

 //===-- SBCommandInterpreter.cpp ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 

 bool SBCommandInterpreter::CommandExists(const char *cmd) {
   LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *),
                      cmd);
 
   return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd)
                                           : false);
 }
 
+bool SBCommandInterpreter::UserCommandExists(const char *cmd) {
+  LLDB_RECORD_METHOD(bool, SBCommandInterpreter, UserCommandExists,
+                     (const char *), cmd);
+
+  return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->UserCommandExists(cmd)
+                                          : false);
+}
+
 bool SBCommandInterpreter::AliasExists(const char *cmd) {
   LLDB_RECORD_METHOD(bool, SBCommandInterpreter, AliasExists, (const char *),
                      cmd);
 
   return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->AliasExists(cmd)
                                           : false);
 }
 
LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
                             (const lldb::SBCommandInterpreter &));
   LLDB_REGISTER_METHOD(
       const lldb::SBCommandInterpreter &,
       SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ());
   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
                        (const char *));
+  LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, UserCommandExists,
+                       (const char *));
   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
                        (const char *));
   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
   LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter,
                        GetIOHandlerControlSequence, (char));
   LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandInterpreter,
                        HandleCommand,

lldb/unittests/Interpreter/CMakeLists.txt

 add_lldb_unittest(InterpreterTests
   TestCompletion.cpp
   TestOptionArgParser.cpp
+  TestUserCommand.cpp
 
   LINK_LIBS
+    liblldb
     lldbInterpreter
     lldbUtilityHelpers
   )

lldb/unittests/Interpreter/TestUserCommand.cpp

+//===-- TestUserCommand.cpp ----------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===/
+
+#include "gtest/gtest.h"
+
+#include "lldb/API/SBCommandInterpreter.h"
+#include "lldb/API/SBCommandReturnObject.h"
+#include "lldb/API/SBDebugger.h"
+
+#include <cassert>
+#include <cstring>
+#include <string>
+
+using namespace lldb;
+
+class DummyCommand : public SBCommandPluginInterface {
+public:
+  bool DoExecute(SBDebugger dbg, char **command,
+                 SBCommandReturnObject &result) {
+    result.PutCString("It works");
+    result.SetStatus(eReturnStatusSuccessFinishResult);
+    return result.Succeeded();
+  }
+};
+
+TEST(TestUserCommand, TestSimpleCommand) {
+  SBDebugger::Initialize();
+  SBDebugger dbg = SBDebugger::Create(false /*source_init_files*/);
+  SBCommandInterpreter interp = dbg.GetCommandInterpreter();
+
+  DummyCommand command;
+  interp.AddCommand("dummy", &command, nullptr /*help*/);
+
+  EXPECT_TRUE(interp.UserCommandExists("dummy"));
+
+  SBCommandReturnObject result;
+  interp.HandleCommand("dummy", result, true /*add_to_history*/);
+  EXPECT_TRUE(result.Succeeded());
+  EXPECT_STREQ(result.GetOutput(), "It works\n");
+}