[Demangle] remove itaniumFindTypesInMangledName

[labath]

Summary

This (very specialized) function was added to enable an LLDB use case.
Now that a more generic interface (overriding of parser functions -
D52992) is available, and LLDB has been converted to use that (D54074),
the function is unused and can be removed.

[sgraenitz]

Basically reverts https://reviews.llvm.org/D50586. Thanks for cleaning this up! LGTM

libcxxabi/src/demangle/ItaniumDemangle.h

template <typename Derived, typename Alloc> struct AbstractManglingParser {
   // This has a smaller size compared to Subs and Names because it can be
   // stored on the stack.
   PODSmallVector<Node *, 8> TemplateParams;
 
   // Set of unresolved forward <template-param> references. These can occur in a
   // conversion operator's type, and are resolved in the enclosing <encoding>.
   PODSmallVector<ForwardTemplateReference *, 4> ForwardTemplateRefs;
 
-  void (*TypeCallback)(void *, const char *) = nullptr;
-  void *TypeCallbackContext = nullptr;
-
   bool TryToParseTemplateArgs = true;
   bool PermitForwardTemplateReferences = false;
   bool ParsingLambdaParams = false;
 
   Alloc ASTAllocator;
 
   AbstractManglingParser(const char *First_, const char *Last_)
       : First(First_), Last(Last_) {}

 // extension   ::= <vector-type> # <vector-type> starts with Dv
 //
 // <objc-name> ::= <k0 number> objcproto <k1 number> <identifier>  # k0 = 9 + <number of digits in k1> + k1
 // <objc-type> ::= <source-name>  # PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-name>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseType() {
   Node *Result = nullptr;
 
-  if (TypeCallback != nullptr)
-    TypeCallback(TypeCallbackContext, First);
-
   switch (look()) {
   //             ::= <qualified-type>
   case 'r':
   case 'V':
   case 'K': {
     unsigned AfterQuals = 0;
     if (look(AfterQuals) == 'r') ++AfterQuals;
     if (look(AfterQuals) == 'V') ++AfterQuals;

llvm/include/llvm/Demangle/Demangle.h

enum : int {
   demangle_invalid_mangled_name = -2,
   demangle_memory_alloc_failure = -1,
   demangle_success = 0,
 };
 
 char *itaniumDemangle(const char *mangled_name, char *buf, size_t *n,
                       int *status);
 
-/// Calls the callback \c Callback with \c Ctx as an argument whenever a type is
-/// encountered. Returns true if \c MangledName couldn't be parsed.
-bool itaniumFindTypesInMangledName(const char *MangledName, void *Ctx,
-                                   void (*Callback)(void *, const char *));
-
 
 enum MSDemangleFlags { MSDF_None = 0, MSDF_DumpBackrefs = 1 << 0 };
 char *microsoftDemangle(const char *mangled_name, char *buf, size_t *n,
                         int *status, MSDemangleFlags Flags = MSDF_None);
 
 /// "Partial" demangler. This supports demangling a string into an AST
 /// (typically an intermediate stage in itaniumDemangle) and querying certain
 /// properties or partially printing the demangled name.

llvm/include/llvm/Demangle/ItaniumDemangle.h

template <typename Derived, typename Alloc> struct AbstractManglingParser {
   // This has a smaller size compared to Subs and Names because it can be
   // stored on the stack.
   PODSmallVector<Node *, 8> TemplateParams;
 
   // Set of unresolved forward <template-param> references. These can occur in a
   // conversion operator's type, and are resolved in the enclosing <encoding>.
   PODSmallVector<ForwardTemplateReference *, 4> ForwardTemplateRefs;
 
-  void (*TypeCallback)(void *, const char *) = nullptr;
-  void *TypeCallbackContext = nullptr;
-
   bool TryToParseTemplateArgs = true;
   bool PermitForwardTemplateReferences = false;
   bool ParsingLambdaParams = false;
 
   Alloc ASTAllocator;
 
   AbstractManglingParser(const char *First_, const char *Last_)
       : First(First_), Last(Last_) {}

 // extension   ::= <vector-type> # <vector-type> starts with Dv
 //
 // <objc-name> ::= <k0 number> objcproto <k1 number> <identifier>  # k0 = 9 + <number of digits in k1> + k1
 // <objc-type> ::= <source-name>  # PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-name>
 template <typename Derived, typename Alloc>
 Node *AbstractManglingParser<Derived, Alloc>::parseType() {
   Node *Result = nullptr;
 
-  if (TypeCallback != nullptr)
-    TypeCallback(TypeCallbackContext, First);
-
   switch (look()) {
   //             ::= <qualified-type>
   case 'r':
   case 'V':
   case 'K': {
     unsigned AfterQuals = 0;
     if (look(AfterQuals) == 'r') ++AfterQuals;
     if (look(AfterQuals) == 'V') ++AfterQuals;

llvm/lib/Demangle/ItaniumDemangle.cpp

else {
     Buf = S.getBuffer();
   }
 
   if (Status)
     *Status = InternalStatus;
   return InternalStatus == demangle_success ? Buf : nullptr;
 }
 
-bool llvm::itaniumFindTypesInMangledName(const char *MangledName, void *Ctx,
-                                         void (*Callback)(void *,
-                                                          const char *)) {
-  Demangler Parser(MangledName, MangledName + std::strlen(MangledName));
-  Parser.TypeCallback = Callback;
-  Parser.TypeCallbackContext = Ctx;
-  return Parser.parse() == nullptr;
-}
-
 ItaniumPartialDemangler::ItaniumPartialDemangler()
     : RootNode(nullptr), Context(new Demangler{nullptr, nullptr}) {}
 
 ItaniumPartialDemangler::~ItaniumPartialDemangler() {
   delete static_cast<Demangler *>(Context);
 }
 
 ItaniumPartialDemangler::ItaniumPartialDemangler(

llvm/unittests/Demangle/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Demangle
   Support
 )
 
 add_llvm_unittest(DemangleTests
   ItaniumDemangleTest.cpp
   PartialDemangleTest.cpp
-  FindTypesInMangledNameTest.cpp
 )

llvm/unittests/Demangle/FindTypesInMangledNameTest.cpp

-//===------------------ FindTypesInMangledNameTest.cpp --------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include <cstdlib>
-#include <vector>
-#include "llvm/Demangle/Demangle.h"
-#include "gtest/gtest.h"
-
-TEST(FindTypesInMangledNameTest, Test) {
-  std::vector<const char *> Types;
-  const char *Mangled = "_Z1fiv";
-  EXPECT_FALSE(llvm::itaniumFindTypesInMangledName(
-      Mangled, static_cast<void *>(&Types), [](void *Ty, const char *P) {
-        static_cast<std::vector<const char *> *>(Ty)->push_back(P);
-      }));
-  EXPECT_EQ(Types.size(), size_t(2));
-  EXPECT_EQ(Mangled + 4, Types.front());
-  EXPECT_EQ(Mangled + 5, Types.back());
-
-  EXPECT_TRUE(llvm::itaniumFindTypesInMangledName(
-      "Not a mangled name!", nullptr, [](void *, const char *) {}));
-
-  int TC = 0;
-  EXPECT_FALSE(llvm::itaniumFindTypesInMangledName(
-      "_Z1fPRic", static_cast<void *>(&TC),
-      [](void *Ctx, const char *) { ++*static_cast<int *>(Ctx); }));
-  EXPECT_EQ(TC, 4); // pointer, reference, int, char.
-}