Add some basic extra support for C++ unity building

(Unity building here called "jumbo" because it is called that in the
context of the Chromium project.)

This adds an example plugin named `JumboSupport` that adds a pragma
named `jumbo`, which signals that the main source file is a jumbo
compilation unit that will include other source files. After each
include into the main source file, the contents of all anonymous
namespace declarations in the included source file are hidden, so
that the anonymous namespace remains local to source files. It also
undefines all macros defined in the included source file.

Some (intentionally) minimal changes to clang is implemented to
make it possible to implement this functionality in the plugin.

Author: makslevental

clang/examples/CMakeLists.txt

@@ -11,3 +11,4 @@ if(CLANG_PLUGIN_SUPPORT)
   add_subdirectory(CallSuperAttribute)
   add_subdirectory(PluginsOrder)
 endif()
+add_subdirectory(JumboSupport)

clang/examples/JumboSupport/CMakeLists.txt

@@ -0,0 +1,14 @@
+add_llvm_library(JumboSupport MODULE JumboSupport.cpp PLUGIN_TOOL clang)
+
+if(LLVM_ENABLE_PLUGINS AND (WIN32 OR CYGWIN))
+  set(LLVM_LINK_COMPONENTS
+    Support
+  )
+  clang_target_link_libraries(JumboSupport PRIVATE
+    clangAST
+    clangBasic
+    clangFrontend
+    clangLex
+    LLVMSupport
+    )
+endif()

clang/examples/JumboSupport/JumboSupport.cpp

@@ -0,0 +1,165 @@
+//===- ResetAnonymousNamespace.cpp ----------------------------------------===//
+//
+// Clang plugin that adds
+//
+//   #pragma reset_anonymous_namespace
+//
+// which resets the anonymous namespace, as if a new translation unit was being
+// processed.
+//
+//===----------------------------------------------------------------------===//
+
+#include <set>
+#include <string>
+
+#include "clang/AST/AST.h"
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Frontend/FrontendPluginRegistry.h"
+#include "clang/Lex/LexDiagnostic.h"
+#include "clang/Lex/Preprocessor.h"
+
+namespace {
+
+bool IsLocationInFile(clang::SourceManager &SM, clang::SourceLocation Loc,
+                      const clang::FileEntry *File) {
+  clang::FileID FID = SM.getFileID(SM.getSpellingLoc(Loc));
+  return FID.isValid() && SM.getFileEntryForID(FID) == File;
+}
+
+class DisableTaggedNamespaceDecls
+    : public clang::RecursiveASTVisitor<DisableTaggedNamespaceDecls> {
+private:
+  clang::SourceManager &SM;
+  const clang::FileEntry *File;
+
+public:
+  DisableTaggedNamespaceDecls(clang::SourceManager &SM,
+                              const clang::FileEntry *File)
+      : SM(SM), File(File) {}
+
+  bool VisitNamespaceDecl(clang::NamespaceDecl *NS) {
+    if (NS->isAnonymousNamespace())
+      if (IsLocationInFile(SM, NS->getBeginLoc(), File))
+        NS->setDisabled();
+    return true;
+  }
+};
+
+class ASTConsumer : public clang::ASTConsumer {
+  clang::ASTContext *Context;
+
+public:
+  static ASTConsumer *Instance;
+
+  ASTConsumer() { Instance = this; }
+
+  void Initialize(clang::ASTContext &Ctx) override { Context = &Ctx; }
+
+  clang::ASTContext *getASTContext() { return Context; }
+};
+
+ASTConsumer *ASTConsumer::Instance = nullptr;
+
+class PPCallbacks : public clang::PPCallbacks {
+  clang::Preprocessor &PP;
+  clang::SourceManager &SM;
+
+  const clang::FileEntry *CurrentFile;
+
+  std::set<std::string> DefinedMacros;
+
+public:
+  PPCallbacks(clang::Preprocessor &PP) : PP(PP), SM(PP.getSourceManager()) {}
+
+  static void Register(clang::Preprocessor &PP) {
+    PP.addPPCallbacks(std::make_unique<PPCallbacks>(PP));
+  }
+
+  void
+  InclusionDirective(clang::SourceLocation HashLoc,
+                     const clang::Token &IncludeTok, llvm::StringRef FileName,
+                     bool IsAngled, clang::CharSourceRange FilenameRange,
+                     clang::OptionalFileEntryRef File,
+                     llvm::StringRef SearchPath, llvm::StringRef RelativePath,
+                     const clang::Module *SuggestedModule, bool ModuleImported,
+                     clang::SrcMgr::CharacteristicKind FileType) override {
+    if (SM.isInMainFile(HashLoc))
+      CurrentFile = &File->getFileEntry();
+  }
+
+  void FileChanged(clang::SourceLocation Loc, FileChangeReason Reason,
+                   clang::SrcMgr::CharacteristicKind,
+                   clang::FileID PrevFID) override {
+    if (SM.isInMainFile(Loc)) {
+      auto Context = ASTConsumer::Instance->getASTContext();
+
+      DisableTaggedNamespaceDecls Visitor(SM, CurrentFile);
+      Visitor.TraverseDecl(Context->getTranslationUnitDecl());
+
+      llvm::BumpPtrAllocator &Allocator = PP.getPreprocessorAllocator();
+      for (auto Name : DefinedMacros) {
+        clang::IdentifierInfo *II = PP.getIdentifierInfo(Name);
+        PP.appendMacroDirective(II, new (Allocator)
+                                        clang::UndefMacroDirective(Loc));
+      }
+
+      CurrentFile = nullptr;
+      DefinedMacros.clear();
+    }
+  }
+
+  void MacroDefined(const clang::Token &Name,
+                    const clang::MacroDirective *MD) override {
+    if (CurrentFile && IsLocationInFile(SM, Name.getLocation(), CurrentFile))
+      DefinedMacros.emplace(Name.getIdentifierInfo()->getName().str());
+  }
+
+  void MacroUndefined(const clang::Token &Name,
+                      const clang::MacroDefinition &MD,
+                      const clang::MacroDirective *Undef) override {
+    if (CurrentFile && IsLocationInFile(SM, Name.getLocation(), CurrentFile))
+      DefinedMacros.erase(Name.getIdentifierInfo()->getName().str());
+  }
+};
+
+class JumboFrontendAction : public clang::PluginASTAction {
+public:
+  std::unique_ptr<clang::ASTConsumer>
+  CreateASTConsumer(clang::CompilerInstance &CI, llvm::StringRef) override {
+    return std::make_unique<ASTConsumer>();
+  }
+
+  bool ParseArgs(const clang::CompilerInstance &CI,
+                 const std::vector<std::string> &args) override {
+    return true;
+  }
+};
+
+class PragmaJumbo : public clang::PragmaHandler {
+public:
+  PragmaJumbo() : clang::PragmaHandler("jumbo") {}
+
+  void HandlePragma(clang::Preprocessor &PP, clang::PragmaIntroducer Introducer,
+                    clang::Token &PragmaTok) override {
+    clang::Token Tok;
+    PP.LexUnexpandedToken(Tok);
+    if (Tok.isNot(clang::tok::eod))
+      PP.Diag(Tok, clang::diag::ext_pp_extra_tokens_at_eol) << "pragma unity";
+
+    if (!ASTConsumer::Instance) {
+      // Plugin not enabled.
+      return;
+    }
+
+    PPCallbacks::Register(PP);
+  }
+};
+
+} // namespace
+
+static clang::FrontendPluginRegistry::Add<JumboFrontendAction>
+    X("jumbo-support", "jumbo compilation support tools");
+
+static clang::PragmaHandlerRegistry::Add<PragmaJumbo>
+    P1("jumbo", "begin treating top-level includes as jumbo includes");

clang/include/clang/AST/Decl.h

@@ -579,6 +579,10 @@ class NamespaceDecl : public NamedDecl,
   /// The unnamed namespace that inhabits this namespace, if any.
   NamespaceDecl *AnonymousNamespace = nullptr;
 
+  /// Names in this specific namespace declaration should not be included in
+  /// lookups.
+  bool IsDisabled = false;
+
   NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
                 SourceLocation StartLoc, SourceLocation IdLoc,
                 IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested);
@@ -681,6 +685,9 @@ class NamespaceDecl : public NamedDecl,
   static NamespaceDecl *castFromDeclContext(const DeclContext *DC) {
     return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));
   }
+
+  bool isDisabled() const { return IsDisabled; }
+  void setDisabled() { IsDisabled = true; }
 };
 
 class VarDecl;

clang/lib/AST/ItaniumMangle.cpp

@@ -24,6 +24,7 @@
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprConcepts.h"
+#include "clang/Basic/SourceManager.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/Mangle.h"
 #include "clang/AST/TypeLoc.h"
@@ -1578,8 +1579,23 @@ void CXXNameMangler::mangleUnqualifiedName(
 
     if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
       if (NS->isAnonymousNamespace()) {
+#if 0
         // This is how gcc mangles these names.
         Out << "12_GLOBAL__N_1";
+#endif
+
+#if 1
+        // Add a per-file unique key for the source file containing
+        // the declaration.
+        // FIXME: This should be controlled by a flag.
+        SourceManager &SM = Context.getASTContext().getSourceManager();
+        SourceLocation Loc = SM.getSpellingLoc(NS->getBeginLoc());
+
+        std::string Name("__anonymous_");
+        Name.append(std::to_string(SM.getFileID(Loc).getHashValue()));
+
+        Out << Name.size() << Name;
+#endif
         break;
       }
     }

clang/lib/Sema/SemaLookup.cpp

@@ -1137,6 +1137,12 @@ static bool LookupDirect(Sema &S, LookupResult &R, const DeclContext *DC) {
   // Perform lookup into this declaration context.
   DeclContext::lookup_result DR = DC->lookup(R.getLookupName());
   for (NamedDecl *D : DR) {
+    DeclContext *DCtx = D->getDeclContext();
+    if (EnumDecl *ED = dyn_cast<EnumDecl>(DCtx))
+      DCtx = ED->getDeclContext();
+    if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(DCtx))
+      if (NS->isDisabled())
+        continue;
     if ((D = R.getAcceptableDecl(D))) {
       R.addDecl(D);
       Found = true;