[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

@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

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

416

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

473

llvm::make_unique would be nicer.

clang/include/clang/AST/Mangle.h

 };
 
 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;
 };
 }
 

clang/lib/AST/Mangle.cpp

   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) {
-  // 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))
+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;
-  } else if (auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
-    MC->mangleObjCMethodNameWithoutSize(MD, OS);
+    }
+
+    // Now apply backend mangling.
+    llvm::Mangler::getNameWithPrefix(OS, FrontendBufOS.str(), DL);
     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);
+  std::string getName(const Decl *D) {
+    std::string Name;
+    {
+      llvm::raw_string_ostream OS(Name);
+      writeName(D, OS);
+    }
+    return Name;
   }
-  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();
-  };
+  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),
+    };
+  }
 
-  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);
 
-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 {};
 
-  if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D)))
-    return {};
+    const NamedDecl *ND = cast<NamedDecl>(D);
 
-  const NamedDecl *ND = cast<NamedDecl>(D);
+    ASTContext &Ctx = ND->getASTContext();
+    std::unique_ptr<MangleContext> M(Ctx.createMangleContext());
 
-  ASTContext &Ctx = ND->getASTContext();
-  std::unique_ptr<MangleContext> M(Ctx.createMangleContext());
+    std::vector<std::string> Manglings;
 
-  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;
+    };
 
-  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 (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));
+      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));
     }
-  } 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;
   }
 
-  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;
+    }
+  }
 
-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 writeObjCClassName(const ObjCInterfaceDecl *D, raw_ostream &OS) {
+    OS << getClassSymbolPrefix(ObjCClass, D->getASTContext());
+    OS << D->getObjCRuntimeNameAsString();
   }
-}
 
-void ASTNameGenerator::writeObjCClassName(const ObjCInterfaceDecl *D,
-                                          raw_ostream &OS) {
-  OS << getClassSymbolPrefix(ObjCClass, D->getASTContext());
-  OS << D->getObjCRuntimeNameAsString();
-}
+  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 ASTNameGenerator::getMangledStructor(const NamedDecl *ND,
-                                                 unsigned StructorType) {
-  std::string FrontendBuf;
-  llvm::raw_string_ostream FOS(FrontendBuf);
+    std::string BackendBuf;
+    llvm::raw_string_ostream BOS(BackendBuf);
 
-  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);
+    llvm::Mangler::getNameWithPrefix(BOS, FOS.str(), DL);
 
-  std::string BackendBuf;
-  llvm::raw_string_ostream BOS(BackendBuf);
+    return BOS.str();
+  }
 
-  llvm::Mangler::getNameWithPrefix(BOS, FOS.str(), DL);
+  std::string getMangledThunk(const CXXMethodDecl *MD, const ThunkInfo &T) {
+    std::string FrontendBuf;
+    llvm::raw_string_ostream FOS(FrontendBuf);
 
-  return BOS.str();
-}
+    MC->mangleThunk(MD, T, FOS);
 
-std::string ASTNameGenerator::getMangledThunk(const CXXMethodDecl *MD,
-                                              const ThunkInfo &T) {
-  std::string FrontendBuf;
-  llvm::raw_string_ostream FOS(FrontendBuf);
+    std::string BackendBuf;
+    llvm::raw_string_ostream BOS(BackendBuf);
 
-  MC->mangleThunk(MD, T, FOS);
+    llvm::Mangler::getNameWithPrefix(BOS, FOS.str(), DL);
 
-  std::string BackendBuf;
-  llvm::raw_string_ostream BOS(BackendBuf);
+    return BOS.str();
+  }
+};
 
-  llvm::Mangler::getNameWithPrefix(BOS, FOS.str(), DL);
+ASTNameGenerator::ASTNameGenerator(ASTContext &Ctx)
+    : Impl(new Implementation(Ctx)) {}
+
+ASTNameGenerator::~ASTNameGenerator() {}
 
-  return BOS.str();
+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);
 }