[lldb][NFCI] Remove unused LanguageType parameters

These parameters are unused in these methods, and some of them only had a
LanguageType parameter to pipe to other methods that don't use it
either.

lldb/include/lldb/Core/Mangled.h

@@ -132,13 +132,13 @@ public:
   ///
   /// \return
   ///     A const reference to the demangled name string object.
-  ConstString GetDemangledName(lldb::LanguageType language) const;
+  ConstString GetDemangledName() const;
 
   /// Display demangled name get accessor.
   ///
   /// \return
   ///     A const reference to the display demangled name string object.
-  ConstString GetDisplayDemangledName(lldb::LanguageType language) const;
+  ConstString GetDisplayDemangledName() const;
 
   void SetDemangledName(ConstString name) { m_demangled = name; }
 
@@ -165,8 +165,7 @@ public:
   ///     A const reference to the preferred name string object if this
   ///     object has a valid name of that kind, else a const reference to the
   ///     other name is returned.
-  ConstString GetName(lldb::LanguageType language,
-                      NamePreference preference = ePreferDemangled) const;
+  ConstString GetName(NamePreference preference = ePreferDemangled) const;
 
   /// Check if "name" matches either the mangled or demangled name.
   ///
@@ -175,13 +174,12 @@ public:
   ///
   /// \return
   ///     \b True if \a name matches either name, \b false otherwise.
-  bool NameMatches(ConstString name, lldb::LanguageType language) const {
+  bool NameMatches(ConstString name) const {
     if (m_mangled == name)
       return true;
-    return GetDemangledName(language) == name;
+    return GetDemangledName() == name;
   }
-  bool NameMatches(const RegularExpression &regex,
-                   lldb::LanguageType language) const;
+  bool NameMatches(const RegularExpression &regex) const;
 
   /// Get the memory cost of this object.
   ///

lldb/include/lldb/Symbol/Function.h

@@ -199,11 +199,11 @@ public:
   ///     The stream to which to dump the object description.
   void Dump(Stream *s, bool show_fullpaths) const;
 
-  void DumpStopContext(Stream *s, lldb::LanguageType language) const;
+  void DumpStopContext(Stream *s) const;
 
-  ConstString GetName(lldb::LanguageType language) const;
+  ConstString GetName() const;
 
-  ConstString GetDisplayName(lldb::LanguageType language) const;
+  ConstString GetDisplayName() const;
 
   /// Get accessor for the call site declaration information.
   ///

lldb/source/API/SBBlock.cpp

@@ -71,13 +71,7 @@ const char *SBBlock::GetInlinedName() const {
     const InlineFunctionInfo *inlined_info =
         m_opaque_ptr->GetInlinedFunctionInfo();
     if (inlined_info) {
-      Function *function = m_opaque_ptr->CalculateSymbolContextFunction();
-      LanguageType language;
-      if (function)
-        language = function->GetLanguage();
-      else
-        language = lldb::eLanguageTypeUnknown;
-      return inlined_info->GetName(language).AsCString(nullptr);
+      return inlined_info->GetName().AsCString(nullptr);
     }
   }
   return nullptr;

lldb/source/API/SBFrame.cpp

@@ -1225,8 +1225,7 @@ const char *SBFrame::GetFunctionName() const {
           if (inlined_block) {
             const InlineFunctionInfo *inlined_info =
                 inlined_block->GetInlinedFunctionInfo();
-            name =
-                inlined_info->GetName(sc.function->GetLanguage()).AsCString();
+            name = inlined_info->GetName().AsCString();
           }
         }
 
@@ -1269,8 +1268,7 @@ const char *SBFrame::GetDisplayFunctionName() {
           if (inlined_block) {
             const InlineFunctionInfo *inlined_info =
                 inlined_block->GetInlinedFunctionInfo();
-            name = inlined_info->GetDisplayName(sc.function->GetLanguage())
-                       .AsCString();
+            name = inlined_info->GetDisplayName().AsCString();
           }
         }
 

lldb/source/API/SBFunction.cpp

@@ -69,9 +69,7 @@ const char *SBFunction::GetDisplayName() const {
 
   const char *cstr = nullptr;
   if (m_opaque_ptr)
-    cstr = m_opaque_ptr->GetMangled()
-               .GetDisplayDemangledName(m_opaque_ptr->GetLanguage())
-               .AsCString();
+    cstr = m_opaque_ptr->GetMangled().GetDisplayDemangledName().AsCString();
 
   return cstr;
 }

lldb/source/API/SBSymbol.cpp

@@ -68,9 +68,7 @@ const char *SBSymbol::GetDisplayName() const {
 
   const char *name = nullptr;
   if (m_opaque_ptr)
-    name = m_opaque_ptr->GetMangled()
-               .GetDisplayDemangledName(m_opaque_ptr->GetLanguage())
-               .AsCString();
+    name = m_opaque_ptr->GetMangled().GetDisplayDemangledName().AsCString();
 
   return name;
 }

lldb/source/API/SBType.cpp

@@ -802,7 +802,7 @@ const char *SBTypeMemberFunction::GetDemangledName() {
     ConstString mangled_str = m_opaque_sp->GetMangledName();
     if (mangled_str) {
       Mangled mangled(mangled_str);
-      return mangled.GetDemangledName(mangled.GuessLanguage()).GetCString();
+      return mangled.GetDemangledName().GetCString();
     }
   }
   return nullptr;

lldb/source/Core/FormatEntity.cpp

@@ -1544,7 +1544,7 @@ bool FormatEntity::Format(const Entry &entry, Stream &s,
                 sc->block->GetInlinedFunctionInfo();
             if (inline_info) {
               s.PutCString(" [inlined] ");
-              inline_info->GetName(sc->function->GetLanguage()).Dump(&s);
+              inline_info->GetName().Dump(&s);
             }
           }
         }
@@ -1628,8 +1628,7 @@ bool FormatEntity::Format(const Entry &entry, Stream &s,
           if (inline_info) {
             s.PutCString(cstr);
             s.PutCString(" [inlined] ");
-            cstr =
-                inline_info->GetName(sc->function->GetLanguage()).GetCString();
+            cstr = inline_info->GetName().GetCString();
           }
 
           VariableList args;
@@ -1750,12 +1749,11 @@ bool FormatEntity::Format(const Entry &entry, Stream &s,
   case Entry::Type::FunctionMangledName: {
     const char *name = nullptr;
     if (sc->symbol)
-      name = sc->symbol->GetMangled()
-                 .GetName(sc->symbol->GetLanguage(), Mangled::ePreferMangled)
-                 .AsCString();
+      name =
+          sc->symbol->GetMangled().GetName(Mangled::ePreferMangled).AsCString();
     else if (sc->function)
       name = sc->function->GetMangled()
-                 .GetName(sc->symbol->GetLanguage(), Mangled::ePreferMangled)
+                 .GetName(Mangled::ePreferMangled)
                  .AsCString();
 
     if (!name)
@@ -1766,7 +1764,7 @@ bool FormatEntity::Format(const Entry &entry, Stream &s,
       if (const InlineFunctionInfo *inline_info =
               sc->block->GetInlinedFunctionInfo()) {
         s.PutCString(" [inlined] ");
-        inline_info->GetName(sc->function->GetLanguage()).Dump(&s);
+        inline_info->GetName().Dump(&s);
       }
     }
     return true;

lldb/source/Core/Mangled.cpp

@@ -142,9 +142,8 @@ void Mangled::Clear() {
 
 // Compare the string values.
 int Mangled::Compare(const Mangled &a, const Mangled &b) {
-  return ConstString::Compare(
-      a.GetName(lldb::eLanguageTypeUnknown, ePreferMangled),
-      b.GetName(lldb::eLanguageTypeUnknown, ePreferMangled));
+  return ConstString::Compare(a.GetName(ePreferMangled),
+                              b.GetName(ePreferMangled));
 }
 
 // Set the string value in this objects. If "mangled" is true, then the mangled
@@ -295,8 +294,7 @@ bool Mangled::DemangleWithRichManglingInfo(
 // class will need to use this accessor if it wishes to decode the demangled
 // name. The result is cached and will be kept until a new string value is
 // supplied to this object, or until the end of the object's lifetime.
-ConstString 
-Mangled::GetDemangledName(lldb::LanguageType language) const {
+ConstString Mangled::GetDemangledName() const {
   // Check to make sure we have a valid mangled name and that we haven't
   // already decoded our mangled name.
   if (m_mangled && m_demangled.IsNull()) {
@@ -341,26 +339,24 @@ Mangled::GetDemangledName(lldb::LanguageType language) const {
 }
 
 ConstString
-Mangled::GetDisplayDemangledName(lldb::LanguageType language) const {
-  return GetDemangledName(language);
+Mangled::GetDisplayDemangledName() const {
+  return GetDemangledName();
 }
 
-bool Mangled::NameMatches(const RegularExpression &regex,
-                          lldb::LanguageType language) const {
+bool Mangled::NameMatches(const RegularExpression &regex) const {
   if (m_mangled && regex.Execute(m_mangled.AsCString()))
     return true;
 
-  ConstString demangled = GetDemangledName(language);
+  ConstString demangled = GetDemangledName();
   return demangled && regex.Execute(demangled.AsCString());
 }
 
 // Get the demangled name if there is one, else return the mangled name.
-ConstString Mangled::GetName(lldb::LanguageType language,
-                             Mangled::NamePreference preference) const {
+ConstString Mangled::GetName(Mangled::NamePreference preference) const {
   if (preference == ePreferMangled && m_mangled)
     return m_mangled;
 
-  ConstString demangled = GetDemangledName(language);
+  ConstString demangled = GetDemangledName();
 
   if (preference == ePreferDemangledWithoutArguments) {
     return get_demangled_name_without_arguments(m_mangled, demangled);
@@ -422,7 +418,7 @@ lldb::LanguageType Mangled::GuessLanguage() const {
   } else {
     // ObjC names aren't really mangled, so they won't necessarily be in the
     // mangled name slot.
-    ConstString demangled_name = GetDemangledName(lldb::eLanguageTypeUnknown);
+    ConstString demangled_name = GetDemangledName();
     if (demangled_name 
         && ObjCLanguage::IsPossibleObjCMethodName(demangled_name.GetCString()))
       return lldb::eLanguageTypeObjC;
@@ -436,8 +432,7 @@ Stream &operator<<(Stream &s, const Mangled &obj) {
   if (obj.GetMangledName())
     s << "mangled = '" << obj.GetMangledName() << "'";
 
-  ConstString demangled =
-      obj.GetDemangledName(lldb::eLanguageTypeUnknown);
+  ConstString demangled = obj.GetDemangledName();
   if (demangled)
     s << ", demangled = '" << demangled << '\'';
   else

lldb/source/Expression/ExpressionVariable.cpp

@@ -69,7 +69,7 @@ void PersistentExpressionState::RegisterExecutionUnit(
       // of the demangled name will find the mangled one (needed for looking up
       // metadata pointers.)
       Mangled mangler(global_var.m_name);
-      mangler.GetDemangledName(lldb::eLanguageTypeUnknown);
+      mangler.GetDemangledName();
       m_symbol_map[global_var.m_name.GetCString()] = global_var.m_remote_addr;
       LLDB_LOGF(log, "  Symbol: %s at 0x%" PRIx64 ".",
                 global_var.m_name.GetCString(), global_var.m_remote_addr);

lldb/source/Expression/IRExecutionUnit.cpp

@@ -404,9 +404,7 @@ void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr,
         ss.PutCString("\n");
       emitNewLine = true;
       ss.PutCString("  ");
-      ss.PutCString(Mangled(failed_lookup)
-                        .GetDemangledName(lldb::eLanguageTypeObjC_plus_plus)
-                        .AsCString());
+      ss.PutCString(Mangled(failed_lookup).GetDemangledName().AsCString());
     }
 
     m_failed_lookups.clear();
@@ -645,10 +643,8 @@ uint8_t *IRExecutionUnit::MemoryManager::allocateDataSection(
   return return_value;
 }
 
-static ConstString
-FindBestAlternateMangledName(ConstString demangled,
-                             const lldb::LanguageType &lang_type,
-                             const SymbolContext &sym_ctx) {
+static ConstString FindBestAlternateMangledName(ConstString demangled,
+                                                const SymbolContext &sym_ctx) {
   CPlusPlusLanguage::MethodName cpp_name(demangled);
   std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
 
@@ -670,7 +666,7 @@ FindBestAlternateMangledName(ConstString demangled,
   for (size_t i = 0; i < alternates.size(); i++) {
     ConstString alternate_mangled_name = alternates[i];
     Mangled mangled(alternate_mangled_name);
-    ConstString demangled = mangled.GetDemangledName(lang_type);
+    ConstString demangled = mangled.GetDemangledName();
 
     CPlusPlusLanguage::MethodName alternate_cpp_name(demangled);
     if (!cpp_name.IsValid())
@@ -718,12 +714,11 @@ void IRExecutionUnit::CollectCandidateCPlusPlusNames(
 
     if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
       Mangled mangled(name);
-      ConstString demangled =
-          mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
+      ConstString demangled = mangled.GetDemangledName();
 
       if (demangled) {
-        ConstString best_alternate_mangled_name = FindBestAlternateMangledName(
-            demangled, lldb::eLanguageTypeC_plus_plus, sc);
+        ConstString best_alternate_mangled_name =
+            FindBestAlternateMangledName(demangled, sc);
 
         if (best_alternate_mangled_name) {
           CPP_specs.push_back(best_alternate_mangled_name);
@@ -748,8 +743,7 @@ void IRExecutionUnit::CollectFallbackNames(
 
     if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
       Mangled mangled_name(name);
-      ConstString demangled_name =
-          mangled_name.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
+      ConstString demangled_name = mangled_name.GetDemangledName();
       if (!demangled_name.IsEmpty()) {
         const char *demangled_cstr = demangled_name.AsCString();
         const char *lparen_loc = strchr(demangled_cstr, '(');

lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

@@ -418,8 +418,8 @@ DynamicLoaderHexagonDYLD::GetStepThroughTrampolinePlan(Thread &thread,
   if (sym == nullptr || !sym->IsTrampoline())
     return thread_plan_sp;
 
-  const ConstString sym_name = sym->GetMangled().GetName(
-      lldb::eLanguageTypeUnknown, Mangled::ePreferMangled);
+  const ConstString sym_name =
+      sym->GetMangled().GetName(Mangled::ePreferMangled);
   if (!sym_name)
     return thread_plan_sp;
 

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

@@ -839,8 +839,8 @@ DynamicLoaderDarwin::GetStepThroughTrampolinePlan(Thread &thread,
     std::vector<Address> addresses;
 
     if (current_symbol->IsTrampoline()) {
-      ConstString trampoline_name = current_symbol->GetMangled().GetName(
-          current_symbol->GetLanguage(), Mangled::ePreferMangled);
+      ConstString trampoline_name =
+          current_symbol->GetMangled().GetName(Mangled::ePreferMangled);
 
       if (trampoline_name) {
         const ModuleList &images = target_sp->GetImages();
@@ -981,8 +981,8 @@ DynamicLoaderDarwin::GetStepThroughTrampolinePlan(Thread &thread,
 void DynamicLoaderDarwin::FindEquivalentSymbols(
     lldb_private::Symbol *original_symbol, lldb_private::ModuleList &images,
     lldb_private::SymbolContextList &equivalent_symbols) {
-  ConstString trampoline_name = original_symbol->GetMangled().GetName(
-      original_symbol->GetLanguage(), Mangled::ePreferMangled);
+  ConstString trampoline_name =
+      original_symbol->GetMangled().GetName(Mangled::ePreferMangled);
   if (!trampoline_name)
     return;
 

lldb/source/Plugins/InstrumentationRuntime/TSan/InstrumentationRuntimeTSan.cpp

@@ -564,8 +564,7 @@ static void GetSymbolDeclarationFromAddress(ProcessSP process_sp, addr_t addr,
   if (!symbol)
     return;
 
-  ConstString sym_name = symbol->GetMangled().GetName(
-      lldb::eLanguageTypeUnknown, Mangled::ePreferMangled);
+  ConstString sym_name = symbol->GetMangled().GetName(Mangled::ePreferMangled);
 
   ModuleSP module = symbol->CalculateSymbolContextModule();
   if (!module)

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

@@ -902,8 +902,7 @@ bool lldb_private::formatters::ObjCClassSummaryProvider(
   if (class_name.IsEmpty())
     return false;
 
-  if (ConstString cs =
-          Mangled(class_name).GetDemangledName(lldb::eLanguageTypeUnknown))
+  if (ConstString cs = Mangled(class_name).GetDemangledName())
     class_name = cs;
 
   stream.Printf("%s", class_name.AsCString("<unknown class>"));

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

@@ -72,9 +72,7 @@ TypeAndOrName ItaniumABILanguageRuntime::GetTypeInfoFromVTableAddress(
         Symbol *symbol = sc.symbol;
         if (symbol != nullptr) {
           const char *name =
-              symbol->GetMangled()
-                  .GetDemangledName(lldb::eLanguageTypeC_plus_plus)
-                  .AsCString();
+              symbol->GetMangled().GetDemangledName().AsCString();
           if (name && strstr(name, vtable_demangled_prefix) == name) {
             Log *log(
                 lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
@@ -357,8 +355,7 @@ protected:
 
       Mangled mangled(name);
       if (mangled.GuessLanguage() == lldb::eLanguageTypeC_plus_plus) {
-        ConstString demangled(
-            mangled.GetDisplayDemangledName(lldb::eLanguageTypeC_plus_plus));
+        ConstString demangled(mangled.GetDisplayDemangledName());
         demangled_any = true;
         result.AppendMessageWithFormat("%s ---> %s\n", entry.c_str(),
                                        demangled.GetCString());

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

@@ -2230,8 +2230,7 @@ unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id,
       if (!mangled_name.empty())
         mangled.SetMangledName(ConstString((mangled_name + suffix).str()));
 
-      ConstString demangled =
-          mangled.GetDemangledName(lldb::eLanguageTypeUnknown);
+      ConstString demangled = mangled.GetDemangledName();
       llvm::StringRef demangled_name = demangled.GetStringRef();
       if (!demangled_name.empty())
         mangled.SetDemangledName(ConstString((demangled_name + suffix).str()));

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

@@ -3902,10 +3902,7 @@ size_t ObjectFileMachO::ParseSymtab() {
               // filename, so here we combine it with the first one if we are
               // minimizing the symbol table
               const char *so_path =
-                  sym[sym_idx - 1]
-                      .GetMangled()
-                      .GetDemangledName(lldb::eLanguageTypeUnknown)
-                      .AsCString();
+                  sym[sym_idx - 1].GetMangled().GetDemangledName().AsCString();
               if (so_path && so_path[0]) {
                 std::string full_so_path(so_path);
                 const size_t double_slash_pos = full_so_path.find("//");
@@ -4297,11 +4294,10 @@ size_t ObjectFileMachO::ParseSymtab() {
       }
 
       if (is_gsym) {
-        const char *gsym_name =
-            sym[sym_idx]
-                .GetMangled()
-                .GetName(lldb::eLanguageTypeUnknown, Mangled::ePreferMangled)
-                .GetCString();
+        const char *gsym_name = sym[sym_idx]
+                                    .GetMangled()
+                                    .GetName(Mangled::ePreferMangled)
+                                    .GetCString();
         if (gsym_name)
           N_GSYM_name_to_sym_idx[gsym_name] = sym_idx;
       }
@@ -4365,10 +4361,9 @@ size_t ObjectFileMachO::ParseSymtab() {
           if (range.first != range.second) {
             for (ValueToSymbolIndexMap::const_iterator pos = range.first;
                  pos != range.second; ++pos) {
-              if (sym[sym_idx].GetMangled().GetName(lldb::eLanguageTypeUnknown,
-                                                    Mangled::ePreferMangled) ==
+              if (sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled) ==
                   sym[pos->second].GetMangled().GetName(
-                      lldb::eLanguageTypeUnknown, Mangled::ePreferMangled)) {
+                      Mangled::ePreferMangled)) {
                 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
                 // We just need the flags from the linker symbol, so put these
                 // flags into the N_FUN flags to avoid duplicate symbols in the
@@ -4401,10 +4396,9 @@ size_t ObjectFileMachO::ParseSymtab() {
           if (range.first != range.second) {
             for (ValueToSymbolIndexMap::const_iterator pos = range.first;
                  pos != range.second; ++pos) {
-              if (sym[sym_idx].GetMangled().GetName(lldb::eLanguageTypeUnknown,
-                                                    Mangled::ePreferMangled) ==
+              if (sym[sym_idx].GetMangled().GetName(Mangled::ePreferMangled) ==
                   sym[pos->second].GetMangled().GetName(
-                      lldb::eLanguageTypeUnknown, Mangled::ePreferMangled)) {
+                      Mangled::ePreferMangled)) {
                 m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
                 // We just need the flags from the linker symbol, so put these
                 // flags into the N_STSYM flags to avoid duplicate symbols in
@@ -4419,8 +4413,7 @@ size_t ObjectFileMachO::ParseSymtab() {
             // Combine N_GSYM stab entries with the non stab symbol.
             const char *gsym_name = sym[sym_idx]
                                         .GetMangled()
-                                        .GetName(lldb::eLanguageTypeUnknown,
-                                                 Mangled::ePreferMangled)
+                                        .GetName(Mangled::ePreferMangled)
                                         .GetCString();
             if (gsym_name) {
               ConstNameToSymbolIndexMap::const_iterator pos =

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

@@ -108,8 +108,7 @@ SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap(
 
             // First we find the original symbol in the .o file's symbol table
             Symbol *oso_fun_symbol = oso_symtab->FindFirstSymbolWithNameAndType(
-                exe_symbol->GetMangled().GetName(lldb::eLanguageTypeUnknown,
-                                                 Mangled::ePreferMangled),
+                exe_symbol->GetMangled().GetName(Mangled::ePreferMangled),
                 eSymbolTypeCode, Symtab::eDebugNo, Symtab::eVisibilityAny);
             if (oso_fun_symbol) {
               // Add the inverse OSO file address to debug map entry mapping
@@ -139,8 +138,7 @@ SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap(
             // in the .o file
             Symbol *oso_gsym_symbol =
                 oso_symtab->FindFirstSymbolWithNameAndType(
-                    exe_symbol->GetMangled().GetName(lldb::eLanguageTypeUnknown,
-                                                     Mangled::ePreferMangled),
+                    exe_symbol->GetMangled().GetName(Mangled::ePreferMangled),
                     eSymbolTypeData, Symtab::eDebugNo, Symtab::eVisibilityAny);
             if (exe_symbol && oso_gsym_symbol && exe_symbol->ValueIsAddress() &&
                 oso_gsym_symbol->ValueIsAddress()) {

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

@@ -1950,8 +1950,7 @@ SymbolFilePDB::GetMangledForPDBFunc(const llvm::pdb::PDBSymbolFunc &pdb_func) {
     // here for the same symbol:
     //   non-empty undecorated name from PDB
     //   empty undecorated name from LLDB
-    if (!func_undecorated_name.empty() &&
-        mangled.GetDemangledName(mangled.GuessLanguage()).IsEmpty())
+    if (!func_undecorated_name.empty() && mangled.GetDemangledName().IsEmpty())
       mangled.SetDemangledName(ConstString(func_undecorated_name));
 
     // LLDB uses several flags to control how a C++ decorated name is
@@ -1960,8 +1959,7 @@ SymbolFilePDB::GetMangledForPDBFunc(const llvm::pdb::PDBSymbolFunc &pdb_func) {
     // PDB source unless we also apply same flags in getting undecorated
     // name through PDBSymbolFunc::getUndecoratedNameEx method.
     if (!func_undecorated_name.empty() &&
-        mangled.GetDemangledName(mangled.GuessLanguage()) !=
-            ConstString(func_undecorated_name))
+        mangled.GetDemangledName() != ConstString(func_undecorated_name))
       mangled.SetDemangledName(ConstString(func_undecorated_name));
   } else if (!func_undecorated_name.empty()) {
     mangled.SetDemangledName(ConstString(func_undecorated_name));

lldb/source/Symbol/Function.cpp

@@ -82,25 +82,24 @@ void InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const {
     m_mangled.Dump(s);
 }
 
-void InlineFunctionInfo::DumpStopContext(Stream *s,
-                                         LanguageType language) const {
+void InlineFunctionInfo::DumpStopContext(Stream *s) const {
   //    s->Indent("[inlined] ");
   s->Indent();
   if (m_mangled)
-    s->PutCString(m_mangled.GetName(language).AsCString());
+    s->PutCString(m_mangled.GetName().AsCString());
   else
     s->PutCString(m_name.AsCString());
 }
 
-ConstString InlineFunctionInfo::GetName(LanguageType language) const {
+ConstString InlineFunctionInfo::GetName() const {
   if (m_mangled)
-    return m_mangled.GetName(language);
+    return m_mangled.GetName();
   return m_name;
 }
 
-ConstString InlineFunctionInfo::GetDisplayName(LanguageType language) const {
+ConstString InlineFunctionInfo::GetDisplayName() const {
   if (m_mangled)
-    return m_mangled.GetDisplayDemangledName(language);
+    return m_mangled.GetDisplayDemangledName();
   return m_name;
 }
 
@@ -482,7 +481,7 @@ bool Function::IsTopLevelFunction() {
 }
 
 ConstString Function::GetDisplayName() const {
-  return m_mangled.GetDisplayDemangledName(GetLanguage());
+  return m_mangled.GetDisplayDemangledName();
 }
 
 CompilerDeclContext Function::GetDeclContext() {
@@ -650,15 +649,9 @@ lldb::LanguageType Function::GetLanguage() const {
 }
 
 ConstString Function::GetName() const {
-  LanguageType language = lldb::eLanguageTypeUnknown;
-  if (m_comp_unit)
-    language = m_comp_unit->GetLanguage();
-  return m_mangled.GetName(language);
+  return m_mangled.GetName();
 }
 
 ConstString Function::GetNameNoArguments() const {
-  LanguageType language = lldb::eLanguageTypeUnknown;
-  if (m_comp_unit)
-    language = m_comp_unit->GetLanguage();
-  return m_mangled.GetName(language, Mangled::ePreferDemangledWithoutArguments);
+  return m_mangled.GetName(Mangled::ePreferDemangledWithoutArguments);
 }

lldb/source/Symbol/Symbol.cpp

@@ -120,7 +120,7 @@ bool Symbol::ValueIsAddress() const {
 }
 
 ConstString Symbol::GetDisplayName() const {
-  return m_mangled.GetDisplayDemangledName(GetLanguage());
+  return m_mangled.GetDisplayDemangledName();
 }
 
 ConstString Symbol::GetReExportedSymbolName() const {
@@ -203,7 +203,7 @@ void Symbol::GetDescription(Stream *s, lldb::DescriptionLevel level,
       s->Printf(", value = 0x%16.16" PRIx64,
                 m_addr_range.GetBaseAddress().GetOffset());
   }
-  ConstString demangled = m_mangled.GetDemangledName(GetLanguage());
+  ConstString demangled = m_mangled.GetDemangledName();
   if (demangled)
     s->Printf(", name=\"%s\"", demangled.AsCString());
   if (m_mangled.GetMangledName())
@@ -219,7 +219,7 @@ void Symbol::Dump(Stream *s, Target *target, uint32_t index,
   // Make sure the size of the symbol is up to date before dumping
   GetByteSize();
 
-  ConstString name = m_mangled.GetName(GetLanguage(), name_preference);
+  ConstString name = m_mangled.GetName(name_preference);
   if (ValueIsAddress()) {
     if (!m_addr_range.GetBaseAddress().Dump(s, nullptr,
                                             Address::DumpStyleFileAddress))
@@ -333,7 +333,7 @@ uint32_t Symbol::GetPrologueByteSize() {
 bool Symbol::Compare(ConstString name, SymbolType type) const {
   if (type == eSymbolTypeAny || m_type == type)
     return m_mangled.GetMangledName() == name ||
-           m_mangled.GetDemangledName(GetLanguage()) == name;
+           m_mangled.GetDemangledName() == name;
   return false;
 }
 
@@ -496,11 +496,10 @@ lldb::addr_t Symbol::GetLoadAddress(Target *target) const {
     return LLDB_INVALID_ADDRESS;
 }
 
-ConstString Symbol::GetName() const { return m_mangled.GetName(GetLanguage()); }
+ConstString Symbol::GetName() const { return m_mangled.GetName(); }
 
 ConstString Symbol::GetNameNoArguments() const {
-  return m_mangled.GetName(GetLanguage(),
-                           Mangled::ePreferDemangledWithoutArguments);
+  return m_mangled.GetName(Mangled::ePreferDemangledWithoutArguments);
 }
 
 lldb::addr_t Symbol::ResolveCallableAddress(Target &target) const {

lldb/source/Symbol/SymbolContext.cpp

@@ -117,9 +117,7 @@ bool SymbolContext::DumpStopContext(Stream *s, ExecutionContextScope *exe_scope,
       Block *inlined_block = block->GetContainingInlinedBlock();
       const InlineFunctionInfo *inlined_block_info =
           inlined_block->GetInlinedFunctionInfo();
-      s->Printf(
-          " [inlined] %s",
-          inlined_block_info->GetName(function->GetLanguage()).GetCString());
+      s->Printf(" [inlined] %s", inlined_block_info->GetName().GetCString());
 
       lldb_private::AddressRange block_range;
       if (inlined_block->GetRangeContainingAddress(addr, block_range)) {
@@ -657,12 +655,12 @@ SymbolContext::GetFunctionName(Mangled::NamePreference preference) const {
         const InlineFunctionInfo *inline_info =
             inlined_block->GetInlinedFunctionInfo();
         if (inline_info)
-          return inline_info->GetName(function->GetLanguage());
+          return inline_info->GetName();
       }
     }
-    return function->GetMangled().GetName(function->GetLanguage(), preference);
+    return function->GetMangled().GetName(preference);
   } else if (symbol && symbol->ValueIsAddress()) {
-    return symbol->GetMangled().GetName(symbol->GetLanguage(), preference);
+    return symbol->GetMangled().GetName(preference);
   } else {
     // No function, return an empty string.
     return ConstString();
@@ -1076,19 +1074,17 @@ bool SymbolContextSpecifier::SymbolContextMatches(SymbolContext &sc) {
       if (inline_info != nullptr) {
         was_inlined = true;
         const Mangled &name = inline_info->GetMangled();
-        if (!name.NameMatches(func_name, sc.function->GetLanguage()))
+        if (!name.NameMatches(func_name))
           return false;
       }
     }
     //  If it wasn't inlined, check the name in the function or symbol:
     if (!was_inlined) {
       if (sc.function != nullptr) {
-        if (!sc.function->GetMangled().NameMatches(func_name,
-                                                   sc.function->GetLanguage()))
+        if (!sc.function->GetMangled().NameMatches(func_name))
           return false;
       } else if (sc.symbol != nullptr) {
-        if (!sc.symbol->GetMangled().NameMatches(func_name,
-                                                 sc.symbol->GetLanguage()))
+        if (!sc.symbol->GetMangled().NameMatches(func_name))
           return false;
       }
     }

lldb/source/Symbol/Symtab.cpp

@@ -299,7 +299,7 @@ void Symtab::InitNameIndexes() {
 
       // Symbol name strings that didn't match a Mangled::ManglingScheme, are
       // stored in the demangled field.
-      if (ConstString name = mangled.GetDemangledName(symbol->GetLanguage())) {
+      if (ConstString name = mangled.GetDemangledName()) {
         m_name_to_index.Append(name, value);
 
         if (symbol->ContainsLinkerAnnotations()) {
@@ -425,7 +425,7 @@ void Symtab::AppendSymbolNamesToMap(const IndexCollection &indexes,
 
       const Mangled &mangled = symbol->GetMangled();
       if (add_demangled) {
-        if (ConstString name = mangled.GetDemangledName(symbol->GetLanguage()))
+        if (ConstString name = mangled.GetDemangledName())
           name_to_index_map.Append(name, value);
       }
 

lldb/source/Symbol/Variable.cpp

@@ -68,7 +68,7 @@ lldb::LanguageType Variable::GetLanguage() const {
 }
 
 ConstString Variable::GetName() const {
-  ConstString name = m_mangled.GetName(GetLanguage());
+  ConstString name = m_mangled.GetName();
   if (name)
     return name;
   return m_name;
@@ -82,16 +82,13 @@ bool Variable::NameMatches(ConstString name) const {
   SymbolContext variable_sc;
   m_owner_scope->CalculateSymbolContext(&variable_sc);
 
-  LanguageType language = eLanguageTypeUnknown;
-  if (variable_sc.comp_unit)
-    language = variable_sc.comp_unit->GetLanguage();
-  return m_mangled.NameMatches(name, language);
+  return m_mangled.NameMatches(name);
 }
 bool Variable::NameMatches(const RegularExpression &regex) const {
   if (regex.Execute(m_name.AsCString()))
     return true;
   if (m_mangled)
-    return m_mangled.NameMatches(regex, GetLanguage());
+    return m_mangled.NameMatches(regex);
   return false;
 }
 

lldb/source/Target/ThreadPlanStepOverRange.cpp

@@ -390,11 +390,7 @@ bool ThreadPlanStepOverRange::DoWillResume(lldb::StateType resume_state,
                   frame_block->GetInlinedFunctionInfo();
               const char *name;
               if (inline_info)
-                name =
-                    inline_info
-                        ->GetName(frame_block->CalculateSymbolContextFunction()
-                                      ->GetLanguage())
-                        .AsCString();
+                name = inline_info->GetName().AsCString();
               else
                 name = "<unknown-notinlined>";
 

lldb/unittests/Core/MangledTest.cpp

@@ -31,8 +31,7 @@ using namespace lldb_private;
 TEST(MangledTest, ResultForValidName) {
   ConstString MangledName("_ZN1a1b1cIiiiEEvm");
   Mangled TheMangled(MangledName);
-  ConstString TheDemangled =
-      TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
+  ConstString TheDemangled = TheMangled.GetDemangledName();
 
   ConstString ExpectedResult("void a::b::c<int, int, int>(unsigned long)");
   EXPECT_STREQ(ExpectedResult.GetCString(), TheDemangled.GetCString());
@@ -41,8 +40,7 @@ TEST(MangledTest, ResultForValidName) {
 TEST(MangledTest, ResultForBlockInvocation) {
   ConstString MangledName("___Z1fU13block_pointerFviE_block_invoke");
   Mangled TheMangled(MangledName);
-  ConstString TheDemangled =
-      TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
+  ConstString TheDemangled = TheMangled.GetDemangledName();
 
   ConstString ExpectedResult(
       "invocation function for block in f(void (int) block_pointer)");
@@ -52,8 +50,7 @@ TEST(MangledTest, ResultForBlockInvocation) {
 TEST(MangledTest, EmptyForInvalidName) {
   ConstString MangledName("_ZN1a1b1cmxktpEEvm");
   Mangled TheMangled(MangledName);
-  ConstString TheDemangled =
-      TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
+  ConstString TheDemangled = TheMangled.GetDemangledName();
 
   EXPECT_STREQ("", TheDemangled.GetCString());
 }