Revert "[LLDB] Refactored CPlusPlusLanguage::MethodName to break lldb-server dependencies" (llvm#134995)

Reverts llvm#132274

Broke a test on LLDB Widows on Arm:
https://lab.llvm.org/buildbot/#/builders/141/builds/7726
```
FAIL: test_dwarf (lldbsuite.test.lldbtest.TestExternCSymbols.test_dwarf)
<...>
    self.assertTrue(self.res.Succeeded(), msg + output)

AssertionError: False is not true : Command 'expression -- foo()' did not return successfully

Error output:

error: Couldn't look up symbols:

  int foo(void)

Hint: The expression tried to call a function that is not present in the target, perhaps because it was optimized out by the compiler.
```

Author: DavidSpickett

lldb/include/lldb/Core/Mangled.h

@@ -246,8 +246,6 @@ class Mangled {
   ///     for s, otherwise the enumerator for the mangling scheme detected.
   static Mangled::ManglingScheme GetManglingScheme(llvm::StringRef const name);
 
-  static bool IsMangledName(llvm::StringRef name);
-
   /// Decode a serialized version of this object from data.
   ///
   /// \param data

lldb/include/lldb/Core/RichManglingContext.h

@@ -12,7 +12,6 @@
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
 
-#include "lldb/Target/Language.h"
 #include "lldb/Utility/ConstString.h"
 
 #include "llvm/ADT/Any.h"
@@ -68,7 +67,11 @@ class RichManglingContext {
   char *m_ipd_buf;
   size_t m_ipd_buf_size = 2048;
 
-  std::unique_ptr<Language::MethodName> m_cxx_method_parser;
+  /// Members for PluginCxxLanguage
+  /// Cannot forward declare inner class CPlusPlusLanguage::MethodName. The
+  /// respective header is in Plugins and including it from here causes cyclic
+  /// dependency. Instead keep a llvm::Any and cast it on-access in the cpp.
+  llvm::Any m_cxx_method_parser;
 
   /// Clean up memory when using PluginCxxLanguage
   void ResetCxxMethodParser();
@@ -78,6 +81,15 @@ class RichManglingContext {
 
   /// Uniform handling of string buffers for ItaniumPartialDemangler.
   llvm::StringRef processIPDStrResult(char *ipd_res, size_t res_len);
+
+  /// Cast the given parser to the given type. Ideally we would have a type
+  /// trait to deduce \a ParserT from a given InfoProvider, but unfortunately we
+  /// can't access CPlusPlusLanguage::MethodName from within the header.
+  template <class ParserT> static ParserT *get(llvm::Any parser) {
+    assert(parser.has_value());
+    assert(llvm::any_cast<ParserT *>(&parser));
+    return *llvm::any_cast<ParserT *>(&parser);
+  }
 };
 
 } // namespace lldb_private

lldb/include/lldb/Target/Language.h

@@ -214,104 +214,6 @@ class Language : public PluginInterface {
     return std::vector<Language::MethodNameVariant>();
   };
 
-  class MethodName {
-  public:
-    MethodName() {}
-
-    MethodName(ConstString full)
-        : m_full(full), m_basename(), m_context(), m_arguments(),
-          m_qualifiers(), m_return_type(), m_scope_qualified(), m_parsed(false),
-          m_parse_error(false) {}
-
-    virtual ~MethodName() {};
-
-    void Clear() {
-      m_full.Clear();
-      m_basename = llvm::StringRef();
-      m_context = llvm::StringRef();
-      m_arguments = llvm::StringRef();
-      m_qualifiers = llvm::StringRef();
-      m_return_type = llvm::StringRef();
-      m_scope_qualified.clear();
-      m_parsed = false;
-      m_parse_error = false;
-    }
-
-    bool IsValid() {
-      if (!m_parsed)
-        Parse();
-      if (m_parse_error)
-        return false;
-      return (bool)m_full;
-    }
-
-    ConstString GetFullName() const { return m_full; }
-
-    llvm::StringRef GetBasename() {
-      if (!m_parsed)
-        Parse();
-      return m_basename;
-    }
-
-    llvm::StringRef GetContext() {
-      if (!m_parsed)
-        Parse();
-      return m_context;
-    }
-
-    llvm::StringRef GetArguments() {
-      if (!m_parsed)
-        Parse();
-      return m_arguments;
-    }
-
-    llvm::StringRef GetQualifiers() {
-      if (!m_parsed)
-        Parse();
-      return m_qualifiers;
-    }
-
-    llvm::StringRef GetReturnType() {
-      if (!m_parsed)
-        Parse();
-      return m_return_type;
-    }
-
-    std::string GetScopeQualifiedName() {
-      if (!m_parsed)
-        Parse();
-      return m_scope_qualified;
-    }
-
-  protected:
-    virtual void Parse() {
-      m_parsed = true;
-      m_parse_error = true;
-    }
-
-    ConstString m_full; // Full name:
-                        // "size_t lldb::SBTarget::GetBreakpointAtIndex(unsigned
-                        // int) const"
-    llvm::StringRef m_basename;    // Basename:     "GetBreakpointAtIndex"
-    llvm::StringRef m_context;     // Decl context: "lldb::SBTarget"
-    llvm::StringRef m_arguments;   // Arguments:    "(unsigned int)"
-    llvm::StringRef m_qualifiers;  // Qualifiers:   "const"
-    llvm::StringRef m_return_type; // Return type:  "size_t"
-    std::string m_scope_qualified;
-    bool m_parsed = false;
-    bool m_parse_error = false;
-  };
-
-  virtual std::unique_ptr<Language::MethodName>
-  GetMethodName(ConstString name) const {
-    return std::make_unique<Language::MethodName>(name);
-  };
-
-  virtual std::pair<lldb::FunctionNameType, llvm::StringRef>
-  GetFunctionNameInfo(ConstString name) const {
-    return std::pair{lldb::eFunctionNameTypeNone, llvm::StringRef()};
-  };
-
   /// Returns true iff the given symbol name is compatible with the mangling
   /// scheme of this language.
   ///

lldb/source/Core/CMakeLists.txt

@@ -16,7 +16,8 @@ if (LLDB_ENABLE_CURSES)
   endif()
 endif()
 
-add_lldb_library(lldbCore NO_PLUGIN_DEPENDENCIES
+# TODO: Add property `NO_PLUGIN_DEPENDENCIES` to lldbCore
+add_lldb_library(lldbCore
   Address.cpp
   AddressRange.cpp
   AddressRangeListImpl.cpp
@@ -70,6 +71,8 @@ add_lldb_library(lldbCore NO_PLUGIN_DEPENDENCIES
     lldbUtility
     lldbValueObject
     lldbVersion
+    lldbPluginCPlusPlusLanguage
+    lldbPluginObjCLanguage
     ${LLDB_CURSES_LIBS}
 
   CLANG_LIBS

lldb/source/Core/Mangled.cpp

@@ -33,12 +33,12 @@
 #include <cstring>
 using namespace lldb_private;
 
-#pragma mark Mangled
-
-bool Mangled::IsMangledName(llvm::StringRef name) {
-  return Mangled::GetManglingScheme(name) != Mangled::eManglingSchemeNone;
+static inline bool cstring_is_mangled(llvm::StringRef s) {
+  return Mangled::GetManglingScheme(s) != Mangled::eManglingSchemeNone;
 }
 
+#pragma mark Mangled
+
 Mangled::ManglingScheme Mangled::GetManglingScheme(llvm::StringRef const name) {
   if (name.empty())
     return Mangled::eManglingSchemeNone;
@@ -121,7 +121,7 @@ int Mangled::Compare(const Mangled &a, const Mangled &b) {
 
 void Mangled::SetValue(ConstString name) {
   if (name) {
-    if (IsMangledName(name.GetStringRef())) {
+    if (cstring_is_mangled(name.GetStringRef())) {
       m_demangled.Clear();
       m_mangled = name;
     } else {