[lldb][NFC] Use Language plugins in Mangled::GuessLanguage

[teemperor]

Summary

This removes the direct dependency to the ObjC and C++ plugins.

[bulbazord]

This is about what I thought needed to be done as well. Thanks for taking care of this!

[teemperor]

Cool! We have a few other similar patterns where we should just ask the Language plugins, so I'll probably just do the same for them when I find a few free minutes.

[shafik]

This comment was removed by shafik.

lldb/include/lldb/Target/Language.h

public:
   // If a language can have more than one possible name for a method, this
   // function can be used to enumerate them. This is useful when doing name
   // lookups.
   virtual std::vector<ConstString>
   GetMethodNameVariants(ConstString method_name) const {
     return std::vector<ConstString>();
   };
 
+  /// Returns true iff the given symbol name is compatible with the mangling
+  /// scheme of this language.
+  ///
+  /// This function should only return true if there is a high confidence
+  /// that the name actually belongs to this language.
+  virtual bool SymbolNameFitsToLanguage(Mangled name) const { return false; }
+
   // if an individual data formatter can apply to several types and cross a
   // language boundary it makes sense for individual languages to want to
   // customize the printing of values of that type by appending proper
   // prefix/suffix information in language-specific ways
   virtual bool GetFormatterPrefixSuffix(ValueObject &valobj,
                                         ConstString type_hint,
                                         std::string &prefix,
                                         std::string &suffix);

lldb/source/Core/Mangled.cpp

 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
-#include "Plugins/Language/ObjC/ObjCLanguage.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/Compiler.h"
 
 #include <mutex>
 #include <string>
 #include <utility>

 
 // We "guess" the language because we can't determine a symbol's language from
 // it's name.  For example, a Pascal symbol can be mangled using the C++
 // Itanium scheme, and defined in a compilation unit within the same module as
 // other C++ units.  In addition, different targets could have different ways
 // of mangling names from a given language, likewise the compilation units
 // within those targets.
 lldb::LanguageType Mangled::GuessLanguage() const {
-  ConstString mangled = GetMangledName();
-
-  if (mangled) {
-    const char *mangled_name = mangled.GetCString();
-    if (CPlusPlusLanguage::IsCPPMangledName(mangled_name))
-      return lldb::eLanguageTypeC_plus_plus;
-  } else {
-    // ObjC names aren't really mangled, so they won't necessarily be in the
-    // mangled name slot.
-    ConstString demangled_name = GetDemangledName();
-    if (demangled_name 
-        && ObjCLanguage::IsPossibleObjCMethodName(demangled_name.GetCString()))
-      return lldb::eLanguageTypeObjC;
-  
+  lldb::LanguageType result = lldb::eLanguageTypeUnknown;
+  // Ask each language plugin to check if the mangled name belongs to it.
+  Language::ForEach([this, &result](Language *l) {
+    if (l->SymbolNameFitsToLanguage(*this)) {
+      result = l->GetLanguageType();
+      return false;
     }
-  return lldb::eLanguageTypeUnknown;
+    return true;
+  });
+  return result;
 }
 
 // Dump OBJ to the supplied stream S.
 Stream &operator<<(Stream &s, const Mangled &obj) {
   if (obj.GetMangledName())
     s << "mangled = '" << obj.GetMangledName() << "'";
 
   ConstString demangled = obj.GetDemangledName();
   if (demangled)
     s << ", demangled = '" << demangled << '\'';
   else
     s << ", demangled = <error>";
   return s;
 }

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

public:
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::Language *CreateInstance(lldb::LanguageType language);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
+  bool SymbolNameFitsToLanguage(Mangled mangled) const override;
+
   static bool IsCPPMangledName(llvm::StringRef name);
 
   // Extract C++ context and identifier from a string using heuristic matching
   // (as opposed to
   // CPlusPlusLanguage::MethodName which has to have a fully qualified C++ name
   // with parens and arguments.
   // If the name is a lone C identifier (e.g. C) or a qualified C identifier
   // (e.g. A::B::C) it will return true,

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

void CPlusPlusLanguage::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 lldb_private::ConstString CPlusPlusLanguage::GetPluginNameStatic() {
   static ConstString g_name("cplusplus");
   return g_name;
 }
 
+bool CPlusPlusLanguage::SymbolNameFitsToLanguage(Mangled mangled) const {
+  const char *mangled_name = mangled.GetMangledName().GetCString();
+  return mangled_name && CPlusPlusLanguage::IsCPPMangledName(mangled_name);
+}
+
 // PluginInterface protocol
 
 lldb_private::ConstString CPlusPlusLanguage::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t CPlusPlusLanguage::GetPluginVersion() { return 1; }
 

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

public:
   // "[NSString(my_additions) myStringWithCString:]"
   //  variant_names[0] => "+[NSString(my_additions) myStringWithCString:]"
   //  variant_names[1] => "-[NSString(my_additions) myStringWithCString:]"
   //  variant_names[2] => "+[NSString myStringWithCString:]"
   //  variant_names[3] => "-[NSString myStringWithCString:]"
   std::vector<ConstString>
   GetMethodNameVariants(ConstString method_name) const override;
 
+  bool SymbolNameFitsToLanguage(Mangled mangled) const override;
+
   lldb::TypeCategoryImplSP GetFormatters() override;
 
   std::vector<ConstString>
   GetPossibleFormattersMatches(ValueObject &valobj,
                                lldb::DynamicValueType use_dynamic) override;
 
   std::unique_ptr<TypeScavenger> GetTypeScavenger() override;
 

lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp

if (name_sans_category) {
       strm.Printf("-%s", name_sans_category.GetCString());
       variant_names.emplace_back(strm.GetString());
     }
   }
 
   return variant_names;
 }
 
+bool ObjCLanguage::SymbolNameFitsToLanguage(Mangled mangled) const {
+  ConstString demangled_name = mangled.GetDemangledName();
+  if (!demangled_name)
+    return false;
+  return ObjCLanguage::IsPossibleObjCMethodName(demangled_name.GetCString());
+}
+
 static void LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) {
   if (!objc_category_sp)
     return;
 
   TypeSummaryImpl::Flags objc_flags;
   objc_flags.SetCascades(false)
       .SetSkipPointers(true)
       .SetSkipReferences(true)