[clang][AST] Refactoring ASTNameGenerator to use pimpl pattern (NFC).

[plotfi]

Summary

So something I realized when trying to port clang interface stubs to using ASTNameGenerator instead of CodegenNameGenerator is that the original pimpl pattern used between CodegenNameGenerator and CodegenNameGeneratorImpl did a good job of hiding DataLayout making it so that users of CodegenNameGenerator did not need to link with llvm core. This is an NFC change to wrap ASTNameGenerator in a pimpl.

[plotfi]

moving datalayout.h

[plotfi]

full context

[plotfi]

clang/lib/AST/Mangle.cpp

343 ↗

(On Diff #205729)

@aaron.ballman I can move this down to the private section in a subsequent NFC if you'd like.

[compnerd]

clang/lib/AST/Mangle.cpp

343 ↗

(On Diff #205729)

The implementation is never leaked to the user. This means that this is effectively private.

416 ↗

(On Diff #205729)

Don't think that it really matters to make this private or public really. The implementation is fully private.

473 ↗

(On Diff #205729)

llvm::make_unique would be nicer.

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;
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);
+  ~ASTNameGenerator();
   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);
+  class Implementation;
+  std::unique_ptr<Implementation> Impl;
 };
 }
 
 #endif

cfe/trunk/lib/AST/Mangle.cpp

 #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/DataLayout.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()) {}
+class ASTNameGenerator::Implementation {
+  std::unique_ptr<MangleContext> MC;
+  llvm::DataLayout DL;
 
-bool ASTNameGenerator::writeName(const Decl *D, raw_ostream &OS) {
+public:
+  explicit 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 ASTNameGenerator::getName(const Decl *D) {
+  std::string 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) {
+  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> ASTNameGenerator::getAllManglings(const Decl *D) {
+  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;
   }
 
-bool ASTNameGenerator::writeFuncOrVarName(const NamedDecl *D, raw_ostream &OS) {
+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 ASTNameGenerator::writeObjCClassName(const ObjCInterfaceDecl *D,
-                                          raw_ostream &OS) {
+  void 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 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 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();
   }
+};
+
+ASTNameGenerator::ASTNameGenerator(ASTContext &Ctx)
+    : Impl(llvm::make_unique<Implementation>(Ctx)) {}
+
+ASTNameGenerator::~ASTNameGenerator() {}
+
+bool ASTNameGenerator::writeName(const Decl *D, raw_ostream &OS) {
+  return Impl->writeName(D, OS);
+}
+
+std::string ASTNameGenerator::getName(const Decl *D) {
+  return Impl->getName(D);
+}
+
+std::vector<std::string> ASTNameGenerator::getAllManglings(const Decl *D) {
+  return Impl->getAllManglings(D);
+}