Remove unused code related to CPlusPlusLanguage::FindEquivalentNames

[scott.smith]

Summary

It is simply unused, and the header for it is private, so there should be no external dependencies.

[jingham]

This was used at some point. I'd be happier deleting if if I understood the reason why it is no longer needed.

[tberghammer]

I looked into the history of this code once and my understanding is that Enrico added this code in https://github.com/llvm-mirror/lldb/commit/bad9753828b6e0e415e38094bb9627e41d57874c but it have never been used (at least in upstream). The original commit message also indicates this.

[scott.smith]

In D32503#737953, @tberghammer wrote:

I looked into the history of this code once and my understanding is that Enrico added this code in https://github.com/llvm-mirror/lldb/commit/bad9753828b6e0e415e38094bb9627e41d57874c but it have never been used (at least in upstream). The original commit message also indicates this.

That was four years ago! So we have code that is unused, has no tests, and is not visible via a library (since this header is not in include/lldb/*). The code is also short enough that it can be rewritten if anyone wants it. Ok to delete?

[tberghammer]

I am fully support deleting it (and pretty much any unused code). If we need it in the future then we will still have it in the svn history.

[zturner]

Code is still present in history, if someone needs this again in the future they can do some git archaeology to dig it up.

[scott.smith]

Can someone please commit this for me? I don't have access. Thank you!

[scott.smith]

In D32503#738274, @scott.smith wrote:

Can someone please commit this for me? I don't have access. Thank you!

Ping - please commit for me!

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

public:
   // If the name fails the heuristic matching for a qualified or unqualified
   // C/C++ identifier, then it will return false
   // and identifier and context will be unchanged.
 
   static bool ExtractContextAndIdentifier(const char *name,
                                           llvm::StringRef &context,
                                           llvm::StringRef &identifier);
 
-  // in some cases, compilers will output different names for one same type.
-  // when that happens, it might be impossible
-  // to construct SBType objects for a valid type, because the name that is
-  // available is not the same as the name that
-  // can be used as a search key in FindTypes(). the equivalents map here is
-  // meant to return possible alternative names
-  // for a type through which a search can be conducted. Currently, this is only
-  // enabled for C++ but can be extended
-  // to ObjC or other languages if necessary
-  static uint32_t FindEquivalentNames(ConstString type_name,
-                                      std::vector<ConstString> &equivalents);
-
   // Given a mangled function name, calculates some alternative manglings since
   // the compiler mangling may not line up with the symbol we are expecting
   static uint32_t
   FindAlternateFunctionManglings(const ConstString mangled,
                                  std::set<ConstString> &candidates);
 
   //------------------------------------------------------------------
   // PluginInterface protocol

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

bool CPlusPlusLanguage::ExtractContextAndIdentifier(
   if (auto full_name = parser.ParseAsFullName()) {
     identifier = full_name.getValue().basename;
     context = full_name.getValue().context;
     return true;
   }
   return false;
 }
 
-class CPPRuntimeEquivalents {
-public:
-  CPPRuntimeEquivalents() {
-    m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, "
-                              "std::allocator<char> >")
-                      .GetStringRef(),
-                  ConstString("basic_string<char>"));
-
-    // these two (with a prefixed std::) occur when c++stdlib string class
-    // occurs as a template argument in some STL container
-    m_impl.Append(ConstString("std::basic_string<char, std::char_traits<char>, "
-                              "std::allocator<char> >")
-                      .GetStringRef(),
-                  ConstString("std::basic_string<char>"));
-
-    m_impl.Sort();
-  }
-
-  void Add(ConstString &type_name, ConstString &type_equivalent) {
-    m_impl.Insert(type_name.GetStringRef(), type_equivalent);
-  }
-
-  uint32_t FindExactMatches(ConstString &type_name,
-                            std::vector<ConstString> &equivalents) {
-    uint32_t count = 0;
-
-    for (ImplData match =
-             m_impl.FindFirstValueForName(type_name.GetStringRef());
-         match != nullptr; match = m_impl.FindNextValueForName(match)) {
-      equivalents.push_back(match->value);
-      count++;
-    }
-
-    return count;
-  }
-
-  // partial matches can occur when a name with equivalents is a template
-  // argument.
-  // e.g. we may have "class Foo" be a match for "struct Bar". if we have a
-  // typename
-  // such as "class Templatized<class Foo, Anything>" we want this to be
-  // replaced with
-  // "class Templatized<struct Bar, Anything>". Since partial matching is time
-  // consuming
-  // once we get a partial match, we add it to the exact matches list for faster
-  // retrieval
-  uint32_t FindPartialMatches(ConstString &type_name,
-                              std::vector<ConstString> &equivalents) {
-    uint32_t count = 0;
-
-    llvm::StringRef type_name_cstr = type_name.GetStringRef();
-
-    size_t items_count = m_impl.GetSize();
-
-    for (size_t item = 0; item < items_count; item++) {
-      llvm::StringRef key_cstr = m_impl.GetCStringAtIndex(item);
-      if (type_name_cstr.contains(key_cstr)) {
-        count += AppendReplacements(type_name_cstr, key_cstr, equivalents);
-      }
-    }
-
-    return count;
-  }
-
-private:
-  std::string &replace(std::string &target, std::string &pattern,
-                       std::string &with) {
-    size_t pos;
-    size_t pattern_len = pattern.size();
-
-    while ((pos = target.find(pattern)) != std::string::npos)
-      target.replace(pos, pattern_len, with);
-
-    return target;
-  }
-
-  uint32_t AppendReplacements(llvm::StringRef original,
-                              llvm::StringRef matching_key,
-                              std::vector<ConstString> &equivalents) {
-    std::string matching_key_str(matching_key);
-    ConstString original_const(original);
-
-    uint32_t count = 0;
-
-    for (ImplData match = m_impl.FindFirstValueForName(matching_key);
-         match != nullptr; match = m_impl.FindNextValueForName(match)) {
-      std::string target(original);
-      std::string equiv_class(match->value.AsCString());
-
-      replace(target, matching_key_str, equiv_class);
-
-      ConstString target_const(target.c_str());
-
-// you will most probably want to leave this off since it might make this map
-// grow indefinitely
-#ifdef ENABLE_CPP_EQUIVALENTS_MAP_TO_GROW
-      Add(original_const, target_const);
-#endif
-      equivalents.push_back(target_const);
-
-      count++;
-    }
-
-    return count;
-  }
-
-  typedef UniqueCStringMap<ConstString> Impl;
-  typedef const Impl::Entry *ImplData;
-  Impl m_impl;
-};
-
-static CPPRuntimeEquivalents &GetEquivalentsMap() {
-  static CPPRuntimeEquivalents g_equivalents_map;
-  return g_equivalents_map;
-}
-
-uint32_t
-CPlusPlusLanguage::FindEquivalentNames(ConstString type_name,
-                                       std::vector<ConstString> &equivalents) {
-  uint32_t count = GetEquivalentsMap().FindExactMatches(type_name, equivalents);
-
-  bool might_have_partials =
-      (count == 0) // if we have a full name match just use it
-      && (strchr(type_name.AsCString(), '<') !=
-              nullptr // we should only have partial matches when templates are
-                      // involved, check that we have
-          && strchr(type_name.AsCString(), '>') != nullptr); // angle brackets
-                                                             // in the type_name
-                                                             // before trying to
-                                                             // scan for partial
-                                                             // matches
-
-  if (might_have_partials)
-    count = GetEquivalentsMap().FindPartialMatches(type_name, equivalents);
-
-  return count;
-}
-
 /// Given a mangled function `mangled`, replace all the primitive function type
 /// arguments of `search` with type `replace`.
 static ConstString SubsPrimitiveParmItanium(llvm::StringRef mangled,
                                             llvm::StringRef search,
                                             llvm::StringRef replace) {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE);
 
   const size_t max_len =