[lldb] Remove Expression's dependency on CPlusPlusLanguagePlugin

[bulbazord]

Summary

This change accomplishes the following:

• Moves IRExecutionUnit::FindBestAlternateMangledName to Language.
• Renames FindBestAlternateMangledName to FindBestAlternateFunctionMangledName
• Changes the first parameter of said method from a ConstString representing a demangled name to a Mangled.

This allows us to remove the use of CPlusPlusLanguage from Expression

[JDevlieghere]

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

524–530

I know you just copied this, but else after a return?

[bulbazord]

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

524–530

I think there's a lot of opportunity to refactor this method. Think I should do it in this change or would a follow-up be more reasonable?

[JDevlieghere]

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

524–530

If you're planning more changes then a follow-up sounds like the best course of action.

[bulbazord]

Rebasing

[bulbazord]

friendly ping! :)

[jingham]

I'm fine with this, but I'll defer to Jonas since he had the last significant comments.

[JDevlieghere]

LGTM with a followup

[bulbazord]

385b2189cc44

lldb/include/lldb/Target/Language.h

 #ifndef LLDB_TARGET_LANGUAGE_H
 #define LLDB_TARGET_LANGUAGE_H
 
 #include <functional>
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "lldb/Core/Highlighter.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
 #include "lldb/DataFormatters/FormatClasses.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-public.h"
 
public:
 
   // Given a mangled function name, calculates some alternative manglings since
   // the compiler mangling may not line up with the symbol we are expecting.
   virtual std::vector<ConstString>
   GenerateAlternateFunctionManglings(const ConstString mangled) const {
     return std::vector<ConstString>();
   }
 
+  virtual ConstString
+  FindBestAlternateFunctionMangledName(const Mangled mangled,
+                                       const SymbolContext &sym_ctx) const {
+    return ConstString();
+  }
+
 protected:
   // Classes that inherit from Language can see and modify these
 
   Language();
 
 private:
   Language(const Language &) = delete;
   const Language &operator=(const Language &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_LANGUAGE_H

lldb/source/Expression/CMakeLists.txt

add_lldb_library(lldbExpression
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbInterpreter
     lldbSymbol
     lldbTarget
     lldbUtility
-    lldbPluginCPlusPlusLanguage
     lldbPluginObjectFileJIT
 
   LINK_COMPONENTS
     Core
     ExecutionEngine
     Support
   )

lldb/source/Expression/IRExecutionUnit.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DiagnosticHandler.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Language.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 
-#include "lldb/../../source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "lldb/../../source/Plugins/ObjectFile/JIT/ObjectFileJIT.h"
 
 using namespace lldb_private;
 
 IRExecutionUnit::IRExecutionUnit(std::unique_ptr<llvm::LLVMContext> &context_up,
                                  std::unique_ptr<llvm::Module> &module_up,
                                  ConstString &name,
                                  const lldb::TargetSP &target_sp,
lldb::ProcessSP process_sp =
         m_parent.GetBestExecutionContextScope()->CalculateProcess();
 
     m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back());
   }
 
   return return_value;
 }
 
-static ConstString FindBestAlternateMangledName(ConstString demangled,
-                                                const SymbolContext &sym_ctx) {
-  CPlusPlusLanguage::MethodName cpp_name(demangled);
-  std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
-
-  if (!scope_qualified_name.size())
-    return ConstString();
-
-  if (!sym_ctx.module_sp)
-    return ConstString();
-
-  lldb_private::SymbolFile *sym_file = sym_ctx.module_sp->GetSymbolFile();
-  if (!sym_file)
-    return ConstString();
-
-  std::vector<ConstString> alternates;
-  sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates);
-
-  std::vector<ConstString> param_and_qual_matches;
-  std::vector<ConstString> param_matches;
-  for (size_t i = 0; i < alternates.size(); i++) {
-    ConstString alternate_mangled_name = alternates[i];
-    Mangled mangled(alternate_mangled_name);
-    ConstString demangled = mangled.GetDemangledName();
-
-    CPlusPlusLanguage::MethodName alternate_cpp_name(demangled);
-    if (!cpp_name.IsValid())
-      continue;
-
-    if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments()) {
-      if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers())
-        param_and_qual_matches.push_back(alternate_mangled_name);
-      else
-        param_matches.push_back(alternate_mangled_name);
-    }
-  }
-
-  if (param_and_qual_matches.size())
-    return param_and_qual_matches[0]; // It is assumed that there will be only
-                                      // one!
-  else if (param_matches.size())
-    return param_matches[0]; // Return one of them as a best match
-  else
-    return ConstString();
-}
-
 void IRExecutionUnit::CollectCandidateCNames(std::vector<ConstString> &C_names,
                                              ConstString name) {
   if (m_strip_underscore && name.AsCString()[0] == '_')
     C_names.insert(C_names.begin(), ConstString(&name.AsCString()[1]));
   C_names.push_back(name);
 }
 
 void IRExecutionUnit::CollectCandidateCPlusPlusNames(
     std::vector<ConstString> &CPP_names,
     const std::vector<ConstString> &C_names, const SymbolContext &sc) {
   if (auto *cpp_lang = Language::FindPlugin(lldb::eLanguageTypeC_plus_plus)) {
     for (const ConstString &name : C_names) {
       Mangled mangled(name);
       if (cpp_lang->SymbolNameFitsToLanguage(mangled)) {
-        if (ConstString demangled = mangled.GetDemangledName()) {
-          if (ConstString best_alternate_mangled_name =
-                  FindBestAlternateMangledName(demangled, sc))
-            CPP_names.push_back(best_alternate_mangled_name);
+        if (ConstString best_alternate =
+                cpp_lang->FindBestAlternateFunctionMangledName(mangled, sc)) {
+          CPP_names.push_back(best_alternate);
         }
       }
 
       std::vector<ConstString> alternates =
           cpp_lang->GenerateAlternateFunctionManglings(name);
       CPP_names.insert(CPP_names.end(), alternates.begin(), alternates.end());
 
       // As a last-ditch fallback, try the base name for C++ names.  It's

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

 //===-- CPlusPlusLanguage.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_SOURCE_PLUGINS_LANGUAGE_CPLUSPLUS_CPLUSPLUSLANGUAGE_H
 #define LLDB_SOURCE_PLUGINS_LANGUAGE_CPLUSPLUS_CPLUSPLUSLANGUAGE_H
 
 #include <set>
 #include <vector>
 
 #include "llvm/ADT/StringRef.h"
 
 #include "Plugins/Language/ClangCommon/ClangHighlighter.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class CPlusPlusLanguage : public Language {
   ClangHighlighter m_highlighter;
public:
 
   static bool ExtractContextAndIdentifier(const char *name,
                                           llvm::StringRef &context,
                                           llvm::StringRef &identifier);
 
   std::vector<ConstString>
   GenerateAlternateFunctionManglings(const ConstString mangled) const override;
 
+  ConstString FindBestAlternateFunctionMangledName(
+      const Mangled mangled, const SymbolContext &sym_ctx) const override;
+
   // PluginInterface protocol
   ConstString GetPluginName() override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGE_CPLUSPLUS_CPLUSPLUSLANGUAGE_H

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

 #include <memory>
 #include <mutex>
 #include <set>
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Demangle/ItaniumDemangle.h"
 
 #include "lldb/Core/Mangled.h"
+#include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/DataFormatters/CXXFunctionPointer.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/VectorType.h"
+#include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 
 #include "BlockPointer.h"
 #include "CPlusPlusNameParser.h"
 #include "CxxStringTypes.h"
 #include "LibCxx.h"
std::vector<ConstString> CPlusPlusLanguage::GenerateAlternateFunctionManglings(
 
   if (ConstString ctor_fixup =
           CtorDtorSubstitutor().substitute(mangled_name.GetStringRef()))
     alternates.push_back(ctor_fixup);
 
   return alternates;
 }
 
+ConstString CPlusPlusLanguage::FindBestAlternateFunctionMangledName(
+    const Mangled mangled, const SymbolContext &sym_ctx) const {
+  ConstString demangled = mangled.GetDemangledName();
+  if (!demangled)
+    return ConstString();
+
+  CPlusPlusLanguage::MethodName cpp_name(demangled);
+  std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
+
+  if (!scope_qualified_name.size())
+    return ConstString();
+
+  if (!sym_ctx.module_sp)
+    return ConstString();
+
+  lldb_private::SymbolFile *sym_file = sym_ctx.module_sp->GetSymbolFile();
+  if (!sym_file)
+    return ConstString();
+
+  std::vector<ConstString> alternates;
+  sym_file->GetMangledNamesForFunction(scope_qualified_name, alternates);
+
+  std::vector<ConstString> param_and_qual_matches;
+  std::vector<ConstString> param_matches;
+  for (size_t i = 0; i < alternates.size(); i++) {
+    ConstString alternate_mangled_name = alternates[i];
+    Mangled mangled(alternate_mangled_name);
+    ConstString demangled = mangled.GetDemangledName();
+
+    CPlusPlusLanguage::MethodName alternate_cpp_name(demangled);
+    if (!cpp_name.IsValid())
+      continue;
+
+    if (alternate_cpp_name.GetArguments() == cpp_name.GetArguments()) {
+      if (alternate_cpp_name.GetQualifiers() == cpp_name.GetQualifiers())
+        param_and_qual_matches.push_back(alternate_mangled_name);
+      else
+        param_matches.push_back(alternate_mangled_name);
+    }
+  }
+
+  if (param_and_qual_matches.size())
+    return param_and_qual_matches[0]; // It is assumed that there will be only
+                                      // one!
+  else if (param_matches.size())
+    return param_matches[0]; // Return one of them as a best match
+  else
+    return ConstString();
+}
+
 static void LoadLibCxxFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
   if (!cpp_category_sp)
     return;
 
   TypeSummaryImpl::Flags stl_summary_flags;
   stl_summary_flags.SetCascades(true)
       .SetSkipPointers(false)
       .SetSkipReferences(false)