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

Reverts llvm/llvm-project#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.
```

1 files changed, 76 insertions, 52 deletions

diff --git a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
index 89c2a52..4b045d1 100644
--- a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
+++ b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp
@@ -62,44 +62,9 @@ void CPlusPlusLanguage::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
-std::unique_ptr<Language::MethodName>
-CPlusPlusLanguage::GetMethodName(ConstString full_name) const {
-  std::unique_ptr<CPlusPlusLanguage::CPPMethodName> cpp_method =
-      std::make_unique<CPlusPlusLanguage::CPPMethodName>(full_name);
-  cpp_method->IsValid();
-  return cpp_method;
-}
-
-std::pair<FunctionNameType, llvm::StringRef>
-CPlusPlusLanguage::GetFunctionNameInfo(ConstString name) const {
-  if (Mangled::IsMangledName(name.GetCString()))
-    return {eFunctionNameTypeFull, llvm::StringRef()};
-
-  FunctionNameType func_name_type = eFunctionNameTypeNone;
-  CPlusPlusLanguage::CPPMethodName method(name);
-  llvm::StringRef basename = method.GetBasename();
-  if (basename.empty()) {
-    llvm::StringRef context;
-    func_name_type |=
-        (ExtractContextAndIdentifier(name.GetCString(), context, basename)
-             ? (eFunctionNameTypeMethod | eFunctionNameTypeBase)
-             : eFunctionNameTypeFull);
-  } else {
-    func_name_type |= (eFunctionNameTypeMethod | eFunctionNameTypeBase);
-  }
-
-  if (!method.GetQualifiers().empty()) {
-    // There is a 'const' or other qualifier following the end of the function
-    // parens, this can't be a eFunctionNameTypeBase.
-    func_name_type &= ~eFunctionNameTypeBase;
-  }
-
-  return {func_name_type, basename};
-}
-
 bool CPlusPlusLanguage::SymbolNameFitsToLanguage(Mangled mangled) const {
   const char *mangled_name = mangled.GetMangledName().GetCString();
-  return mangled_name && Mangled::IsMangledName(mangled_name);
+  return mangled_name && CPlusPlusLanguage::IsCPPMangledName(mangled_name);
 }
 
 ConstString CPlusPlusLanguage::GetDemangledFunctionNameWithoutArguments(
@@ -116,7 +81,7 @@ ConstString CPlusPlusLanguage::GetDemangledFunctionNameWithoutArguments(
                                         // eventually handle eSymbolTypeData,
                                         // we will want this back)
     {
-      CPlusPlusLanguage::CPPMethodName cxx_method(demangled_name);
+      CPlusPlusLanguage::MethodName cxx_method(demangled_name);
       if (!cxx_method.GetBasename().empty()) {
         std::string shortname;
         if (!cxx_method.GetContext().empty())
@@ -141,6 +106,17 @@ Language *CPlusPlusLanguage::CreateInstance(lldb::LanguageType language) {
   return nullptr;
 }
 
+void CPlusPlusLanguage::MethodName::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_parsed = false;
+  m_parse_error = false;
+}
+
 static bool ReverseFindMatchingChars(const llvm::StringRef &s,
                                      const llvm::StringRef &left_right_chars,
                                      size_t &left_pos, size_t &right_pos,
@@ -205,7 +181,7 @@ static bool PrettyPrintFunctionNameWithArgs(Stream &out_stream,
                                             char const *full_name,
                                             ExecutionContextScope *exe_scope,
                                             VariableList const &args) {
-  CPlusPlusLanguage::CPPMethodName cpp_method{ConstString(full_name)};
+  CPlusPlusLanguage::MethodName cpp_method{ConstString(full_name)};
 
   if (!cpp_method.IsValid())
     return false;
@@ -232,7 +208,7 @@ static bool PrettyPrintFunctionNameWithArgs(Stream &out_stream,
   return true;
 }
 
-bool CPlusPlusLanguage::CPPMethodName::TrySimplifiedParse() {
+bool CPlusPlusLanguage::MethodName::TrySimplifiedParse() {
   // This method tries to parse simple method definitions which are presumably
   // most comman in user programs. Definitions that can be parsed by this
   // function don't have return types and templates in the name.
@@ -275,7 +251,7 @@ bool CPlusPlusLanguage::CPPMethodName::TrySimplifiedParse() {
   return false;
 }
 
-void CPlusPlusLanguage::CPPMethodName::Parse() {
+void CPlusPlusLanguage::MethodName::Parse() {
   if (!m_parsed && m_full) {
     if (TrySimplifiedParse()) {
       m_parse_error = false;
@@ -292,19 +268,55 @@ void CPlusPlusLanguage::CPPMethodName::Parse() {
         m_parse_error = true;
       }
     }
-    if (m_context.empty()) {
-      m_scope_qualified = std::string(m_basename);
-    } else {
-      m_scope_qualified = m_context;
-      m_scope_qualified += "::";
-      m_scope_qualified += m_basename;
-    }
     m_parsed = true;
   }
 }
 
+llvm::StringRef CPlusPlusLanguage::MethodName::GetBasename() {
+  if (!m_parsed)
+    Parse();
+  return m_basename;
+}
+
+llvm::StringRef CPlusPlusLanguage::MethodName::GetContext() {
+  if (!m_parsed)
+    Parse();
+  return m_context;
+}
+
+llvm::StringRef CPlusPlusLanguage::MethodName::GetArguments() {
+  if (!m_parsed)
+    Parse();
+  return m_arguments;
+}
+
+llvm::StringRef CPlusPlusLanguage::MethodName::GetQualifiers() {
+  if (!m_parsed)
+    Parse();
+  return m_qualifiers;
+}
+
+llvm::StringRef CPlusPlusLanguage::MethodName::GetReturnType() {
+  if (!m_parsed)
+    Parse();
+  return m_return_type;
+}
+
+std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() {
+  if (!m_parsed)
+    Parse();
+  if (m_context.empty())
+    return std::string(m_basename);
+
+  std::string res;
+  res += m_context;
+  res += "::";
+  res += m_basename;
+  return res;
+}
+
 llvm::StringRef
-CPlusPlusLanguage::CPPMethodName::GetBasenameNoTemplateParameters() {
+CPlusPlusLanguage::MethodName::GetBasenameNoTemplateParameters() {
   llvm::StringRef basename = GetBasename();
   size_t arg_start, arg_end;
   llvm::StringRef parens("<>", 2);
@@ -314,7 +326,7 @@ CPlusPlusLanguage::CPPMethodName::GetBasenameNoTemplateParameters() {
   return basename;
 }
 
-bool CPlusPlusLanguage::CPPMethodName::ContainsPath(llvm::StringRef path) {
+bool CPlusPlusLanguage::MethodName::ContainsPath(llvm::StringRef path) {
   if (!m_parsed)
     Parse();
 
@@ -363,9 +375,21 @@ bool CPlusPlusLanguage::CPPMethodName::ContainsPath(llvm::StringRef path) {
   return false;
 }
 
+bool CPlusPlusLanguage::IsCPPMangledName(llvm::StringRef name) {
+  // FIXME!! we should really run through all the known C++ Language plugins
+  // and ask each one if this is a C++ mangled name
+
+  Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name);
+
+  if (scheme == Mangled::eManglingSchemeNone)
+    return false;
+
+  return true;
+}
+
 bool CPlusPlusLanguage::DemangledNameContainsPath(llvm::StringRef path,
                                                   ConstString demangled) const {
-  CPPMethodName demangled_name(demangled);
+  MethodName demangled_name(demangled);
   return demangled_name.ContainsPath(path);
 }
 
@@ -564,7 +588,7 @@ ConstString CPlusPlusLanguage::FindBestAlternateFunctionMangledName(
   if (!demangled)
     return ConstString();
 
-  CPlusPlusLanguage::CPPMethodName cpp_name(demangled);
+  CPlusPlusLanguage::MethodName cpp_name(demangled);
   std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
 
   if (!scope_qualified_name.size())
@@ -587,7 +611,7 @@ ConstString CPlusPlusLanguage::FindBestAlternateFunctionMangledName(
     Mangled mangled(alternate_mangled_name);
     ConstString demangled = mangled.GetDemangledName();
 
-    CPlusPlusLanguage::CPPMethodName alternate_cpp_name(demangled);
+    CPlusPlusLanguage::MethodName alternate_cpp_name(demangled);
     if (!cpp_name.IsValid())
       continue;