[clang][AST] ASTNameGenerator: A refactoring of CodegenNameGeneratorImpl (NFC).

[plotfi]

Summary

CodegenNameGeneratorImpl is the most complete implementation of name mangling but it is in clang::Index. This makes it very difficult to use it elsewhere in clang. This is just a NFC refactoring of CodegenNameGeneratorImpl into a class called ASTNameGenerator. Other than the name and placement change there is no functional change.

[compnerd]

clang/include/clang/AST/Mangle.h

19 ↗

(On Diff #205500)

Move these into the implementation, forward declarations should be sufficient.

21 ↗

(On Diff #205500)

This isn't used, it belongs in the implementation.

25 ↗

(On Diff #205500)

Is Mangler used in the header? I think this can be in the implementation.

253 ↗

(On Diff #205500)

I think I prefer ASTNameGenerator or even ASTNameMangler (though I am partial to Microsoft's term: "decoration").

[plotfi]

Addressing @compnerd's feedback.

[aaron.ballman]

clang/include/clang/AST/Mangle.h

249–250 ↗

(On Diff #205625)

Do these still need to be public members? Back when this class was an implementation detail, that didn't matter as much, but I'd prefer a cleaner public interface before we expose this to other consumers.

[compnerd]

clang/include/clang/AST/Mangle.h

248 ↗

(On Diff #205625)

Please make this a class and hide the members, exposing just the constructor and the 3 methods as @aaron.ballman pointed out that this is a struct not a class! I missed that.

[plotfi]

clang/include/clang/AST/Mangle.h

249–250 ↗

(On Diff #205625)

Good catch! This was a struct when it was CodegenNameGeneratorImpl but these were hidden by the mere fact that they were inside the .cpp file and not in a header. Thanks!

[plotfi]

Update to address @aaron.ballman's catch that ASTNameGenerator was not private enough.

[aaron.ballman]

LGTM with a few nits.

clang/include/clang/AST/Mangle.h

253 ↗

(On Diff #205643)

Slight preference to make this constructor explicit since it only accepts a single argument and I can't imagine wanting a converting constructor there.

clang/lib/AST/Mangle.cpp

25 ↗

(On Diff #205643)

Do we have to link in any new libraries in CMake for this new dependency?

[plotfi]

clang/lib/AST/Mangle.cpp

25 ↗

(On Diff #205643)

I don't believe so. It builds and make check-clangs. I will try a shared lib build too. It looks like AST things are already included, and LLVM things are already included so I doubt any new library dep change is needed at all.

cfe/trunk/include/clang/AST/Mangle.h

 
 #ifndef LLVM_CLANG_AST_MANGLE_H
 #define LLVM_CLANG_AST_MANGLE_H
 
 #include "clang/AST/Decl.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/ABI.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/IR/DataLayout.h"
 #include "llvm/Support/Casting.h"
 
 namespace llvm {
   class raw_ostream;
 }
 
 namespace clang {
   class ASTContext;
public:
 
   static bool classof(const MangleContext *C) {
     return C->getKind() == MK_Microsoft;
   }
 
   static MicrosoftMangleContext *create(ASTContext &Context,
                                         DiagnosticsEngine &Diags);
 };
+
+class ASTNameGenerator {
+  std::unique_ptr<MangleContext> MC;
+  llvm::DataLayout DL;
+
+public:
+  explicit ASTNameGenerator(ASTContext &Ctx);
+  bool writeName(const Decl *D, raw_ostream &OS);
+  std::string getName(const Decl *D);
+  std::vector<std::string> getAllManglings(const Decl *D);
+
+private:
+  std::vector<std::string> getAllManglings(const ObjCContainerDecl *OCD);
+  bool writeFuncOrVarName(const NamedDecl *D, raw_ostream &OS);
+  void writeObjCClassName(const ObjCInterfaceDecl *D, raw_ostream &OS);
+  std::string getMangledStructor(const NamedDecl *ND, unsigned StructorType);
+  std::string getMangledThunk(const CXXMethodDecl *MD, const ThunkInfo &T);
+};
 }
 
 #endif

cfe/trunk/include/clang/Index/CodegenNameGenerator.h

 //===- CodegenNameGenerator.h - Codegen name generation -------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Determines the name that the symbol will get for code generation.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_INDEX_CODEGENNAMEGENERATOR_H
 #define LLVM_CLANG_INDEX_CODEGENNAMEGENERATOR_H
 
+#include "clang/AST/Mangle.h"
 #include "clang/Basic/LLVM.h"
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace clang {
   class ASTContext;
   class Decl;
public:
   std::string getName(const Decl *D);
 
   /// This can return multiple mangled names when applicable, e.g. for C++
   /// constructors/destructors.
   std::vector<std::string> getAllManglings(const Decl *D);
 
 private:
   struct Implementation;
-  std::unique_ptr<Implementation> Impl;
+  std::unique_ptr<ASTNameGenerator> Impl;
 };
 
 } // namespace index
 } // namespace clang
 
 #endif // LLVM_CLANG_INDEX_CODEGENNAMEGENERATOR_H

cfe/trunk/lib/AST/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   BinaryFormat
+  Core
   Support
   )
 
 add_clang_library(clangAST
   APValue.cpp
   ASTConsumer.cpp
   ASTContext.cpp
   ASTDiagnostic.cpp

cfe/trunk/lib/AST/Mangle.cpp

 #include "clang/AST/Attr.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/Mangle.h"
+#include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/ABI.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/IR/Mangler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 
 // FIXME: For blocks we currently mimic GCC's mangling scheme, which leaves
 // much to be desired. Come up with a better mangling scheme.
 

 void MangleContext::mangleObjCMethodName(const ObjCMethodDecl *MD,
                                          raw_ostream &Out) {
   SmallString<64> Name;
   llvm::raw_svector_ostream OS(Name);
 
   mangleObjCMethodNameWithoutSize(MD, OS);
   Out << OS.str().size() << OS.str();
 }
+
+ASTNameGenerator::ASTNameGenerator(ASTContext &Ctx)
+    : MC(Ctx.createMangleContext()), DL(Ctx.getTargetInfo().getDataLayout()) {}
+
+bool ASTNameGenerator::writeName(const Decl *D, raw_ostream &OS) {
+  // First apply frontend mangling.
+  SmallString<128> FrontendBuf;
+  llvm::raw_svector_ostream FrontendBufOS(FrontendBuf);
+  if (auto *FD = dyn_cast<FunctionDecl>(D)) {
+    if (FD->isDependentContext())
+      return true;
+    if (writeFuncOrVarName(FD, FrontendBufOS))
+      return true;
+  } else if (auto *VD = dyn_cast<VarDecl>(D)) {
+    if (writeFuncOrVarName(VD, FrontendBufOS))
+      return true;
+  } else if (auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
+    MC->mangleObjCMethodNameWithoutSize(MD, OS);
+    return false;
+  } else if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
+    writeObjCClassName(ID, FrontendBufOS);
+  } else {
+    return true;
+  }
+
+  // Now apply backend mangling.
+  llvm::Mangler::getNameWithPrefix(OS, FrontendBufOS.str(), DL);
+  return false;
+}
+
+std::string ASTNameGenerator::getName(const Decl *D) {
+  std::string Name;
+  {
+    llvm::raw_string_ostream OS(Name);
+    writeName(D, OS);
+  }
+  return Name;
+}
+
+enum ObjCKind {
+  ObjCClass,
+  ObjCMetaclass,
+};
+
+static StringRef getClassSymbolPrefix(ObjCKind Kind,
+                                      const ASTContext &Context) {
+  if (Context.getLangOpts().ObjCRuntime.isGNUFamily())
+    return Kind == ObjCMetaclass ? "_OBJC_METACLASS_" : "_OBJC_CLASS_";
+  return Kind == ObjCMetaclass ? "OBJC_METACLASS_$_" : "OBJC_CLASS_$_";
+}
+
+std::vector<std::string>
+ASTNameGenerator::getAllManglings(const ObjCContainerDecl *OCD) {
+  StringRef ClassName;
+  if (const auto *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
+    ClassName = OID->getObjCRuntimeNameAsString();
+  else if (const auto *OID = dyn_cast<ObjCImplementationDecl>(OCD))
+    ClassName = OID->getObjCRuntimeNameAsString();
+
+  if (ClassName.empty())
+    return {};
+
+  auto Mangle = [&](ObjCKind Kind, StringRef ClassName) -> std::string {
+    SmallString<40> Mangled;
+    auto Prefix = getClassSymbolPrefix(Kind, OCD->getASTContext());
+    llvm::Mangler::getNameWithPrefix(Mangled, Prefix + ClassName, DL);
+    return Mangled.str();
+  };
+
+  return {
+      Mangle(ObjCClass, ClassName),
+      Mangle(ObjCMetaclass, ClassName),
+  };
+}
+
+std::vector<std::string> ASTNameGenerator::getAllManglings(const Decl *D) {
+  if (const auto *OCD = dyn_cast<ObjCContainerDecl>(D))
+    return getAllManglings(OCD);
+
+  if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D)))
+    return {};
+
+  const NamedDecl *ND = cast<NamedDecl>(D);
+
+  ASTContext &Ctx = ND->getASTContext();
+  std::unique_ptr<MangleContext> M(Ctx.createMangleContext());
+
+  std::vector<std::string> Manglings;
+
+  auto hasDefaultCXXMethodCC = [](ASTContext &C, const CXXMethodDecl *MD) {
+    auto DefaultCC = C.getDefaultCallingConvention(/*IsVariadic=*/false,
+                                                   /*IsCSSMethod=*/true);
+    auto CC = MD->getType()->getAs<FunctionProtoType>()->getCallConv();
+    return CC == DefaultCC;
+  };
+
+  if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND)) {
+    Manglings.emplace_back(getMangledStructor(CD, Ctor_Base));
+
+    if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily())
+      if (!CD->getParent()->isAbstract())
+        Manglings.emplace_back(getMangledStructor(CD, Ctor_Complete));
+
+    if (Ctx.getTargetInfo().getCXXABI().isMicrosoft())
+      if (CD->hasAttr<DLLExportAttr>() && CD->isDefaultConstructor())
+        if (!(hasDefaultCXXMethodCC(Ctx, CD) && CD->getNumParams() == 0))
+          Manglings.emplace_back(getMangledStructor(CD, Ctor_DefaultClosure));
+  } else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND)) {
+    Manglings.emplace_back(getMangledStructor(DD, Dtor_Base));
+    if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily()) {
+      Manglings.emplace_back(getMangledStructor(DD, Dtor_Complete));
+      if (DD->isVirtual())
+        Manglings.emplace_back(getMangledStructor(DD, Dtor_Deleting));
+    }
+  } else if (const auto *MD = dyn_cast_or_null<CXXMethodDecl>(ND)) {
+    Manglings.emplace_back(getName(ND));
+    if (MD->isVirtual())
+      if (const auto *TIV = Ctx.getVTableContext()->getThunkInfo(MD))
+        for (const auto &T : *TIV)
+          Manglings.emplace_back(getMangledThunk(MD, T));
+  }
+
+  return Manglings;
+}
+
+bool ASTNameGenerator::writeFuncOrVarName(const NamedDecl *D, raw_ostream &OS) {
+  if (MC->shouldMangleDeclName(D)) {
+    if (const auto *CtorD = dyn_cast<CXXConstructorDecl>(D))
+      MC->mangleCXXCtor(CtorD, Ctor_Complete, OS);
+    else if (const auto *DtorD = dyn_cast<CXXDestructorDecl>(D))
+      MC->mangleCXXDtor(DtorD, Dtor_Complete, OS);
+    else
+      MC->mangleName(D, OS);
+    return false;
+  } else {
+    IdentifierInfo *II = D->getIdentifier();
+    if (!II)
+      return true;
+    OS << II->getName();
+    return false;
+  }
+}
+
+void ASTNameGenerator::writeObjCClassName(const ObjCInterfaceDecl *D,
+                                          raw_ostream &OS) {
+  OS << getClassSymbolPrefix(ObjCClass, D->getASTContext());
+  OS << D->getObjCRuntimeNameAsString();
+}
+
+std::string ASTNameGenerator::getMangledStructor(const NamedDecl *ND,
+                                                 unsigned StructorType) {
+  std::string FrontendBuf;
+  llvm::raw_string_ostream FOS(FrontendBuf);
+
+  if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND))
+    MC->mangleCXXCtor(CD, static_cast<CXXCtorType>(StructorType), FOS);
+  else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND))
+    MC->mangleCXXDtor(DD, static_cast<CXXDtorType>(StructorType), FOS);
+
+  std::string BackendBuf;
+  llvm::raw_string_ostream BOS(BackendBuf);
+
+  llvm::Mangler::getNameWithPrefix(BOS, FOS.str(), DL);
+
+  return BOS.str();
+}
+
+std::string ASTNameGenerator::getMangledThunk(const CXXMethodDecl *MD,
+                                              const ThunkInfo &T) {
+  std::string FrontendBuf;
+  llvm::raw_string_ostream FOS(FrontendBuf);
+
+  MC->mangleThunk(MD, T, FOS);
+
+  std::string BackendBuf;
+  llvm::raw_string_ostream BOS(BackendBuf);
+
+  llvm::Mangler::getNameWithPrefix(BOS, FOS.str(), DL);
+
+  return BOS.str();
+}

cfe/trunk/lib/Index/CodegenNameGenerator.cpp

 //===- CodegenNameGenerator.cpp - Codegen name generation -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Determines the name that the symbol will get for code generation.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Index/CodegenNameGenerator.h"
 #include "clang/AST/ASTContext.h"
-#include "clang/AST/DeclCXX.h"
-#include "clang/AST/DeclObjC.h"
-#include "clang/AST/Mangle.h"
-#include "clang/AST/VTableBuilder.h"
-#include "clang/Basic/TargetInfo.h"
-#include "llvm/IR/DataLayout.h"
-#include "llvm/IR/Mangler.h"
-#include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace clang::index;
 
-struct CodegenNameGenerator::Implementation {
-  std::unique_ptr<MangleContext> MC;
-  llvm::DataLayout DL;
-
-  Implementation(ASTContext &Ctx)
-    : MC(Ctx.createMangleContext()),
-      DL(Ctx.getTargetInfo().getDataLayout()) {}
-
-  bool writeName(const Decl *D, raw_ostream &OS) {
-    // First apply frontend mangling.
-    SmallString<128> FrontendBuf;
-    llvm::raw_svector_ostream FrontendBufOS(FrontendBuf);
-    if (auto *FD = dyn_cast<FunctionDecl>(D)) {
-      if (FD->isDependentContext())
-        return true;
-      if (writeFuncOrVarName(FD, FrontendBufOS))
-        return true;
-    } else if (auto *VD = dyn_cast<VarDecl>(D)) {
-      if (writeFuncOrVarName(VD, FrontendBufOS))
-        return true;
-    } else if (auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
-      MC->mangleObjCMethodNameWithoutSize(MD, OS);
-      return false;
-    } else if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
-      writeObjCClassName(ID, FrontendBufOS);
-    } else {
-      return true;
-    }
-
-    // Now apply backend mangling.
-    llvm::Mangler::getNameWithPrefix(OS, FrontendBufOS.str(), DL);
-    return false;
-  }
-
-  std::string getName(const Decl *D) {
-    std::string Name;
-    {
-      llvm::raw_string_ostream OS(Name);
-      writeName(D, OS);
-    }
-    return Name;
-  }
-
-  enum ObjCKind {
-    ObjCClass,
-    ObjCMetaclass,
-  };
-
-  std::vector<std::string> getAllManglings(const ObjCContainerDecl *OCD) {
-    StringRef ClassName;
-    if (const auto *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
-      ClassName = OID->getObjCRuntimeNameAsString();
-    else if (const auto *OID = dyn_cast<ObjCImplementationDecl>(OCD))
-      ClassName = OID->getObjCRuntimeNameAsString();
-
-    if (ClassName.empty())
-      return {};
-
-    auto Mangle = [&](ObjCKind Kind, StringRef ClassName) -> std::string {
-      SmallString<40> Mangled;
-      auto Prefix = getClassSymbolPrefix(Kind, OCD->getASTContext());
-      llvm::Mangler::getNameWithPrefix(Mangled, Prefix + ClassName, DL);
-      return Mangled.str();
-    };
-
-    return {
-      Mangle(ObjCClass, ClassName),
-      Mangle(ObjCMetaclass, ClassName),
-    };
-  }
-
-  std::vector<std::string> getAllManglings(const Decl *D) {
-    if (const auto *OCD = dyn_cast<ObjCContainerDecl>(D))
-      return getAllManglings(OCD);
-
-    if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D)))
-      return {};
-
-    const NamedDecl *ND = cast<NamedDecl>(D);
-
-    ASTContext &Ctx = ND->getASTContext();
-    std::unique_ptr<MangleContext> M(Ctx.createMangleContext());
-
-    std::vector<std::string> Manglings;
-
-    auto hasDefaultCXXMethodCC = [](ASTContext &C, const CXXMethodDecl *MD) {
-      auto DefaultCC = C.getDefaultCallingConvention(/*IsVariadic=*/false,
-                                                     /*IsCSSMethod=*/true);
-      auto CC = MD->getType()->getAs<FunctionProtoType>()->getCallConv();
-      return CC == DefaultCC;
-    };
-
-    if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND)) {
-      Manglings.emplace_back(getMangledStructor(CD, Ctor_Base));
-
-      if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily())
-        if (!CD->getParent()->isAbstract())
-          Manglings.emplace_back(getMangledStructor(CD, Ctor_Complete));
-
-      if (Ctx.getTargetInfo().getCXXABI().isMicrosoft())
-        if (CD->hasAttr<DLLExportAttr>() && CD->isDefaultConstructor())
-          if (!(hasDefaultCXXMethodCC(Ctx, CD) && CD->getNumParams() == 0))
-            Manglings.emplace_back(getMangledStructor(CD, Ctor_DefaultClosure));
-    } else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND)) {
-      Manglings.emplace_back(getMangledStructor(DD, Dtor_Base));
-      if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily()) {
-        Manglings.emplace_back(getMangledStructor(DD, Dtor_Complete));
-        if (DD->isVirtual())
-          Manglings.emplace_back(getMangledStructor(DD, Dtor_Deleting));
-      }
-    } else if (const auto *MD = dyn_cast_or_null<CXXMethodDecl>(ND)) {
-      Manglings.emplace_back(getName(ND));
-      if (MD->isVirtual())
-        if (const auto *TIV = Ctx.getVTableContext()->getThunkInfo(MD))
-          for (const auto &T : *TIV)
-            Manglings.emplace_back(getMangledThunk(MD, T));
-    }
-
-    return Manglings;
-  }
-
-private:
-  bool writeFuncOrVarName(const NamedDecl *D, raw_ostream &OS) {
-    if (MC->shouldMangleDeclName(D)) {
-      if (const auto *CtorD = dyn_cast<CXXConstructorDecl>(D))
-        MC->mangleCXXCtor(CtorD, Ctor_Complete, OS);
-      else if (const auto *DtorD = dyn_cast<CXXDestructorDecl>(D))
-        MC->mangleCXXDtor(DtorD, Dtor_Complete, OS);
-      else
-        MC->mangleName(D, OS);
-      return false;
-    } else {
-      IdentifierInfo *II = D->getIdentifier();
-      if (!II)
-        return true;
-      OS << II->getName();
-      return false;
-    }
-  }
-
-  void writeObjCClassName(const ObjCInterfaceDecl *D, raw_ostream &OS) {
-    OS << getClassSymbolPrefix(ObjCClass, D->getASTContext());
-    OS << D->getObjCRuntimeNameAsString();
-  }
-
-  static StringRef getClassSymbolPrefix(ObjCKind Kind, const ASTContext &Context) {
-    if (Context.getLangOpts().ObjCRuntime.isGNUFamily())
-      return Kind == ObjCMetaclass ? "_OBJC_METACLASS_" : "_OBJC_CLASS_";
-    return Kind == ObjCMetaclass ? "OBJC_METACLASS_$_" : "OBJC_CLASS_$_";
-  }
-
-  std::string getMangledStructor(const NamedDecl *ND, unsigned StructorType) {
-    std::string FrontendBuf;
-    llvm::raw_string_ostream FOS(FrontendBuf);
-
-    if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND))
-      MC->mangleCXXCtor(CD, static_cast<CXXCtorType>(StructorType), FOS);
-    else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND))
-      MC->mangleCXXDtor(DD, static_cast<CXXDtorType>(StructorType), FOS);
-
-    std::string BackendBuf;
-    llvm::raw_string_ostream BOS(BackendBuf);
-
-    llvm::Mangler::getNameWithPrefix(BOS, FOS.str(), DL);
-
-    return BOS.str();
-  }
-
-  std::string getMangledThunk(const CXXMethodDecl *MD, const ThunkInfo &T) {
-    std::string FrontendBuf;
-    llvm::raw_string_ostream FOS(FrontendBuf);
-
-    MC->mangleThunk(MD, T, FOS);
-
-    std::string BackendBuf;
-    llvm::raw_string_ostream BOS(BackendBuf);
-
-    llvm::Mangler::getNameWithPrefix(BOS, FOS.str(), DL);
-
-    return BOS.str();
-  }
-};
-
 CodegenNameGenerator::CodegenNameGenerator(ASTContext &Ctx)
-  : Impl(new Implementation(Ctx)) {
+  : Impl(new ASTNameGenerator(Ctx)) {
 }
 
 CodegenNameGenerator::~CodegenNameGenerator() {
 }
 
 bool CodegenNameGenerator::writeName(const Decl *D, raw_ostream &OS) {
   return Impl->writeName(D, OS);
 }
 
 std::string CodegenNameGenerator::getName(const Decl *D) {
   return Impl->getName(D);
 }
 
 std::vector<std::string> CodegenNameGenerator::getAllManglings(const Decl *D) {
   return Impl->getAllManglings(D);
 }