WIP: Fix Diagnostic layering, moving diagnostics out of Basic

[dblaikie]

Summary

This goes part-way down the path of moving the actual diagnostics out of Clang's Basic library into the respective libraries that use those diagnostics. The end goal would be that a client program calling into those libraries would be responsible for building the necessary table containing all diagnostics from all components they're calling into (so a clang refactoring tool wouldn't need to pull in the codegen diagnostics, for example).

But I ran out of momentum a bit & looking for some sanity checking/help/encouragement/direction.

The basic idea has been to make the static APIs of DiagnosticIDs non-static, then give DiagnosticIDs a ctor that takes the table of diagnostics - as an intermediate step, I've left the no-arg ctor in, and dabbled with making it a bool ctor just as a way to find the places that still use it and clean them up while leaving a handful of correct uses of DiagnosticIDs construction to flesh out (build the table from the desired diagnostics, etc) later.

Partly wondering if this is the right general direction, if some of these changes are worth committing incrementally as I plumb through DiagnosticIDs objects through more APIs.

I remember you, Richard, pointing out that having a generic way to build the diagnostics table based on each different clients needs of different subsets of all diagnostics wasn't going to be pretty owing to the inability to use the preprocessor to conditionally/dynamically #include things in different contexts (I'm sure I'm doing a bad job of explaining that - but I'm understanding what you meant, that there wouldn't be a quick few lines of "define diagnostics table containing these 3 subcomponents" because you'd have to include those 3 subcomponents diagnostic tables in several different contexts to build up several different data structures/subtables/etc... ). & maybe I need to dig into that more, look at how that could end up, see if it's reasonable/good before doing much more here, rather than putting that off until the end.

[rsmith]

Yes, I think this is the right general direction -- in general, moving towards making clang's diagnostic infrastructure a reusable component that isn't tied to a particular diagnostics table, and in particular moving the knowledge of the complete set of diagnostics and diagnostic groups out of the diagnostics infrastructure and into the frontend tool.

tools/driver/cc1_main.cpp

171–261

The best home for this is probably the FrontendTool library.

[craig.topper]

lib/Basic/DiagnosticIDs.cpp

58

This comment is out of date with the struct being renamed.

73

Did this static_assert stuff get lost?

tools/driver/cc1_main.cpp

210

StaticDiagInfoRec was renamed.

[dblaikie]

Mostly done (functionally, various tidying up possible)

[dblaikie]

One possible solution - skipping BasicOnly & having everything depend on FrontendTool.

[dblaikie]

Address Craig Topper's feedback (StaticDiagInfoRec -> DiagInfoRec and VALIDATE_DIAG_SIZE)

[dblaikie]

Actually move AllDiagnostics.h from Basic to FrontendTool and deal with the fallout for that.

[dblaikie]

Updated with a functional implementation - a few points:

• Some tests could use only the Common diagnostics (see one of the intermediate changes where I moved those tests over to use all diagnostics) except for the tablegen required for the diagnostic groups makes that a bit heavier - though doing so would help reduce dependencies.
• Naming (of the "DiagnosticTable" header, and the functions/entities contained there) could be improved - open to ideas
• API (currently passing in like 6 different raw arrays and ArrayRefs to DiagnosticIDs) could be improved - open to ideas

[dblaikie]

Finish functional prototype - this now does remove the dependency from Basic to the various other libraries.

There are still constants defining the range of each category of diagnostics that remain in Basic - not sure those can be removed, though.

[dblaikie]

I've pushed this further - it builds now & has no fallback in libBasic to the old behavior/table.

One remaining thing I'm unsure about is the table of DIAG_START_* values. Do you think this is OK/good to leave hardcoded in diagnostics? Should I somehow remove the need for that global knowledge (dynamically allocating the start ranges of each grouping?)? Or go the other way & decide this global information renders this direction questionable and just sink all the diagnostics into Basic explicitly/properly?

include/clang/ARCMigrate/ARCMT.h

 #ifndef LLVM_CLANG_ARCMIGRATE_ARCMT_H
 #define LLVM_CLANG_ARCMIGRATE_ARCMT_H
 
 #include "clang/ARCMigrate/FileRemapper.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Frontend/CompilerInvocation.h"
 
 namespace clang {
-  class ASTContext;
-  class DiagnosticConsumer;
-  class PCHContainerOperations;
+class DiagnosticIDs;
 
 namespace arcmt {
-  class MigrationPass;
 
 /// \brief Creates an AST with the provided CompilerInvocation but with these
 /// changes:
 ///   -if a PCH/PTH is set, the original header is used instead
 ///   -Automatic Reference Counting mode is enabled
 ///
 /// It then checks the AST and produces errors/warning for ARC migration issues
 /// that the user needs to handle manually.
 ///
 /// \param emitPremigrationARCErrors if true all ARC errors will get emitted
 /// even if the migrator can fix them, but the function will still return false
 /// if all ARC errors can be fixed.
 ///
 /// \param plistOut if non-empty, it is the file path to store the plist with
 /// the pre-migration ARC diagnostics.
 ///
 /// \returns false if no error is produced, true otherwise.
-bool
-checkForManualIssues(CompilerInvocation &CI, const FrontendInputFile &Input,
-                     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-                     DiagnosticConsumer *DiagClient,
-                     bool emitPremigrationARCErrors = false,
-                     StringRef plistOut = StringRef());
+bool checkForManualIssues(
+    CompilerInvocation &CI, const FrontendInputFile &Input,
+    DiagnosticsEngine &Diags, bool emitPremigrationARCErrors = false,
 
 /// \brief Works similar to checkForManualIssues but instead of checking, it
 /// applies automatic modifications to source files to conform to ARC.
 ///
 /// \returns false if no error is produced, true otherwise.
-bool
-applyTransformations(CompilerInvocation &origCI,
-                     const FrontendInputFile &Input,
-                     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-                     DiagnosticConsumer *DiagClient);
+bool applyTransformations(
+    CompilerInvocation &origCI, const FrontendInputFile &Input,
+    DiagnosticsEngine &Diags);
 
 /// \brief Applies automatic modifications and produces temporary files
 /// and metadata into the \p outputDir path.
 ///
 /// \param emitPremigrationARCErrors if true all ARC errors will get emitted
-/// even if the migrator can fix them, but the function will still return false
-/// if all ARC errors can be fixed.
+/// even if the migrator can fix them, but the function will still return
+/// false if all ARC errors can be fixed.
 ///
 /// \param plistOut if non-empty, it is the file path to store the plist with
 /// the pre-migration ARC diagnostics.
 ///
 /// \returns false if no error is produced, true otherwise.
 bool migrateWithTemporaryFiles(
     CompilerInvocation &origCI, const FrontendInputFile &Input,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-    DiagnosticConsumer *DiagClient, StringRef outputDir,
+    DiagnosticsEngine &Diags, StringRef outputDir,
     bool emitPremigrationARCErrors, StringRef plistOut);
 
 /// \brief Get the set of file remappings from the \p outputDir path that
 /// migrateWithTemporaryFiles produced.
 ///
 /// \returns false if no error is produced, true otherwise.
-bool getFileRemappings(std::vector<std::pair<std::string,std::string> > &remap,
-                       StringRef outputDir,
-                       DiagnosticConsumer *DiagClient);
+bool getFileRemappings(std::vector<std::pair<std::string, std::string>> &remap,
+                       StringRef outputDir, DiagnosticConsumer *DiagClient,
+                       IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs);
 
 /// \brief Get the set of file remappings from a list of files with remapping
 /// info.
 ///
 /// \returns false if no error is produced, true otherwise.
 bool getFileRemappingsFromFileList(
-                        std::vector<std::pair<std::string,std::string> > &remap,
-                        ArrayRef<StringRef> remapFiles,
-                        DiagnosticConsumer *DiagClient);
+    std::vector<std::pair<std::string, std::string>> &remap,
+    ArrayRef<StringRef> remapFiles, DiagnosticConsumer *DiagClient);
 
 typedef void (*TransformFn)(MigrationPass &pass);
 
 std::vector<TransformFn> getAllTransformations(LangOptions::GCMode OrigGCMode,
                                                bool NoFinalizeRemoval);
 
 class MigrationProcess {
   CompilerInvocation OrigCI;
   std::shared_ptr<PCHContainerOperations> PCHContainerOps;
-  DiagnosticConsumer *DiagClient;
+  DiagnosticsEngine &OriginalDiags;
   FileRemapper Remapper;
 
 public:
   bool HadARCErrors;
 
   MigrationProcess(const CompilerInvocation &CI,
                    std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-                   DiagnosticConsumer *diagClient,
+                   DiagnosticsEngine &OriginalDiags,
                    StringRef outputDir = StringRef());
 
   class RewriteListener {
   public:
     virtual ~RewriteListener();
 
-    virtual void start(ASTContext &Ctx) { }
-    virtual void finish() { }
+    virtual void start(ASTContext &Ctx) {}
+    virtual void finish() {}
 
-    virtual void insert(SourceLocation loc, StringRef text) { }
-    virtual void remove(CharSourceRange range) { }
+    virtual void insert(SourceLocation loc, StringRef text) {}
+    virtual void remove(CharSourceRange range) {}
   };
 
   bool applyTransform(TransformFn trans, RewriteListener *listener = nullptr);
 
   FileRemapper &getRemapper() { return Remapper; }
 };
 
 } // end namespace arcmt
 
 }  // end namespace clang
 
 #endif

include/clang/Basic/DiagnosticIDs.h

 /// \brief Defines the Diagnostic IDs-related interfaces.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_DIAGNOSTICIDS_H
 #define LLVM_CLANG_BASIC_DIAGNOSTICIDS_H
 
 #include "clang/Basic/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/StringRef.h"
 #include <vector>
 
 namespace clang {
   class DiagnosticsEngine;
   class SourceLocation;
 

 /// Can be used and shared by multiple Diagnostics for multiple translation units.
 class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> {
 public:
   /// \brief The level of the diagnostic, after it has been through mapping.
   enum Level {
     Ignored, Note, Remark, Warning, Error, Fatal
   };
 
+  // Diagnostic classes.
+  enum {
+    CLASS_NOTE = 0x01,
+    CLASS_REMARK = 0x02,
+    CLASS_WARNING = 0x03,
+    CLASS_EXTENSION = 0x04,
+    CLASS_ERROR = 0x05
+  };
+
+  struct DiagInfoRec {
+    uint16_t DiagID;
+    unsigned DefaultSeverity : 3;
+    unsigned Class : 3;
+    unsigned SFINAE : 2;
+    unsigned WarnNoWerror : 1;
+    unsigned WarnShowInSystemHeader : 1;
+    unsigned Category : 6;
+
+    uint16_t OptionGroupIndex;
+
+    uint16_t DescriptionLen;
+    const char *DescriptionStr;
+
+    unsigned getOptionGroupIndex() const { return OptionGroupIndex; }
+
+    StringRef getDescription() const {
+      return StringRef(DescriptionStr, DescriptionLen);
+    }
+
+    diag::Flavor getFlavor() const {
+      return Class == CLASS_REMARK ? diag::Flavor::Remark
+                                   : diag::Flavor::WarningOrError;
+    }
+
+    bool operator<(const DiagInfoRec &RHS) const { return DiagID < RHS.DiagID; }
+  };
+
 private:
   /// \brief Information for uniquing and looking up custom diags.
-  diag::CustomDiagInfo *CustomDiagInfo;
+  diag::CustomDiagInfo *CustomDiagInfo = nullptr;
+  ArrayRef<DiagInfoRec> DiagInfo;
+  std::function<const DiagInfoRec *(unsigned)> GetDiagInfo;
 
 public:
-  DiagnosticIDs();
+  DiagnosticIDs(bool);
+  DiagnosticIDs(ArrayRef<DiagInfoRec> DiagInfo,
+                std::function<const DiagInfoRec *(unsigned)> GetDiagInfo)
+      : DiagInfo(DiagInfo), GetDiagInfo(GetDiagInfo) {}
   ~DiagnosticIDs();
 
   /// \brief Return an ID for a diagnostic with the specified format string and
   /// level.
   ///
   /// If this is the first request for this diagnostic, it is registered and
   /// created, otherwise the existing ID is returned.
 
public:
   /// \brief Given a diagnostic ID, return a description of the issue.
   StringRef getDescription(unsigned DiagID) const;
 
   /// \brief Return true if the unmapped diagnostic levelof the specified
   /// diagnostic ID is a Warning or Extension.
   ///
   /// This only works on builtin diagnostics, not custom ones, and is not
   /// legal to call on NOTEs.
-  static bool isBuiltinWarningOrExtension(unsigned DiagID);
+  bool isBuiltinWarningOrExtension(unsigned DiagID) const;
 
   /// \brief Return true if the specified diagnostic is mapped to errors by
   /// default.
-  static bool isDefaultMappingAsError(unsigned DiagID);
+  bool isDefaultMappingAsError(unsigned DiagID) const;
 
   /// \brief Determine whether the given built-in diagnostic ID is a Note.
-  static bool isBuiltinNote(unsigned DiagID);
+  bool isBuiltinNote(unsigned DiagID) const;
 
   /// \brief Determine whether the given built-in diagnostic ID is for an
   /// extension of some sort.
-  static bool isBuiltinExtensionDiag(unsigned DiagID) {
+  bool isBuiltinExtensionDiag(unsigned DiagID) const {
     bool ignored;
     return isBuiltinExtensionDiag(DiagID, ignored);
   }
   
   /// \brief Determine whether the given built-in diagnostic ID is for an
   /// extension of some sort, and whether it is enabled by default.
   ///
   /// This also returns EnabledByDefault, which is set to indicate whether the
   /// diagnostic is ignored by default (in which case -pedantic enables it) or
   /// treated as a warning/error by default.
   ///
-  static bool isBuiltinExtensionDiag(unsigned DiagID, bool &EnabledByDefault);
-  
+  bool isBuiltinExtensionDiag(unsigned DiagID, bool &EnabledByDefault) const;
 
   /// \brief Return the lowest-level warning option that enables the specified
   /// diagnostic.
   ///
   /// If there is no -Wfoo flag that controls the diagnostic, this returns null.
-  static StringRef getWarningOptionForDiag(unsigned DiagID);
-  
+  StringRef getWarningOptionForDiag(unsigned DiagID) const;
   /// \brief Return the category number that a specified \p DiagID belongs to,
   /// or 0 if no category.
-  static unsigned getCategoryNumberForDiag(unsigned DiagID);
+  unsigned getCategoryNumberForDiag(unsigned DiagID) const;
 
   /// \brief Return the number of diagnostic categories.
-  static unsigned getNumberOfCategories();
+  unsigned getNumberOfCategories() const;
 
   /// \brief Given a category ID, return the name of the category.
-  static StringRef getCategoryNameFromID(unsigned CategoryID);
-  
+  StringRef getCategoryNameFromID(unsigned CategoryID) const;
   /// \brief Return true if a given diagnostic falls into an ARC diagnostic
   /// category.
-  static bool isARCDiagnostic(unsigned DiagID);
+  bool isARCDiagnostic(unsigned DiagID) const;
 
   /// \brief Enumeration describing how the emission of a diagnostic should
   /// be treated when it occurs during C++ template argument deduction.
   enum SFINAEResponse {
     /// \brief The diagnostic should not be reported, but it should cause
     /// template argument deduction to fail.
     ///
     /// The vast majority of errors that occur during template argument 
public:
   /// \brief Determines whether the given built-in diagnostic ID is
   /// for an error that is suppressed if it occurs during C++ template
   /// argument deduction.
   ///
   /// When an error is suppressed due to SFINAE, the template argument
   /// deduction fails but no diagnostic is emitted. Certain classes of
   /// errors, such as those errors that involve C++ access control,
   /// are not SFINAE errors.
-  static SFINAEResponse getDiagnosticSFINAEResponse(unsigned DiagID);
+  SFINAEResponse getDiagnosticSFINAEResponse(unsigned DiagID) const;
 
   /// \brief Get the string of all diagnostic flags.
   ///
   /// \returns A list of all diagnostics flags as they would be written in a
   /// command line invocation including their `no-` variants. For example:
   /// `{"-Wempty-body", "-Wno-empty-body", ...}`
-  static std::vector<std::string> getDiagnosticFlags();
+  std::vector<std::string> getDiagnosticFlags() const;
 
   /// \brief Get the set of all diagnostic IDs in the group with the given name.
   ///
   /// \param[out] Diags - On return, the diagnostics in the group.
   /// \returns \c true if the given group is unknown, \c false otherwise.
   bool getDiagnosticsInGroup(diag::Flavor Flavor, StringRef Group,
                              SmallVectorImpl<diag::kind> &Diags) const;
 
   /// \brief Get the set of all diagnostic IDs.
-  static void getAllDiagnostics(diag::Flavor Flavor,
-                                SmallVectorImpl<diag::kind> &Diags);
+  void getAllDiagnostics(diag::Flavor Flavor,
+                         SmallVectorImpl<diag::kind> &Diags) const;
 
   /// \brief Get the diagnostic option with the closest edit distance to the
   /// given group name.
-  static StringRef getNearestOption(diag::Flavor Flavor, StringRef Group);
+  StringRef getNearestOption(diag::Flavor Flavor, StringRef Group) const;
 
 private:
   /// \brief Classify the specified diagnostic ID into a Level, consumable by
   /// the DiagnosticClient.
   /// 
   /// The classification is based on the way the client configured the
   /// DiagnosticsEngine object.
   ///

include/clang/CrossTU/CrossTranslationUnit.h

 //  feature can be utilized for tools that require cross translation unit
 //  support.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_CROSSTU_CROSSTRANSLATIONUNIT_H
 #define LLVM_CLANG_CROSSTU_CROSSTRANSLATIONUNIT_H
 
 #include "clang/Basic/LLVM.h"
+#include "clang/Frontend/CompilerInstance.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Error.h"
 
 namespace clang {
 class CompilerInstance;
 class ASTContext;
 class ASTImporter;
 class ASTUnit;
 class DeclContext;
+class DiagnosticIDs;
 class FunctionDecl;
 class NamedDecl;
 class TranslationUnitDecl;
 
 namespace cross_tu {
 
 enum class index_error_code {
   unspecified = 1,
public:
   ///
   /// \return The declaration with the definition will be returned.
   /// If no suitable definition is found in the index file or multiple
   /// definitions found error will be returned.
   ///
   /// Note that the AST files should also be in the \p CrossTUDir.
   llvm::Expected<const FunctionDecl *>
   getCrossTUDefinition(const FunctionDecl *FD, StringRef CrossTUDir,
-                       StringRef IndexName);
+                       StringRef IndexName,
+                       const IntrusiveRefCntPtr<DiagnosticIDs> &DiagIDs);
 
   /// \brief This function loads a function definition from an external AST
   ///        file.
   ///
   /// A function definition with the same declaration will be looked up in the
   /// index file which should be in the \p CrossTUDir directory, called
   /// \p IndexName. In case the declaration is found in the index the
   /// corresponding AST file will be loaded.
   ///
   /// \return Returns an ASTUnit that contains the definition of the looked up
   /// function.
   ///
   /// Note that the AST files should also be in the \p CrossTUDir.
-  llvm::Expected<ASTUnit *> loadExternalAST(StringRef LookupName,
-                                            StringRef CrossTUDir,
-                                            StringRef IndexName);
+  llvm::Expected<ASTUnit *>
+  loadExternalAST(StringRef LookupName, StringRef CrossTUDir,
+                  StringRef IndexName,
+                  const IntrusiveRefCntPtr<DiagnosticIDs> &DiagIDs);
 
   /// \brief This function merges a definition from a separate AST Unit into
   ///        the current one which was created by the compiler instance that
   ///        was passed to the constructor.
   ///
   /// \return Returns the resulting definition or an error.
   llvm::Expected<const FunctionDecl *> importDefinition(const FunctionDecl *FD);
 
   /// \brief Get a name to identify a function.
   static std::string getLookupName(const NamedDecl *ND);
 
   /// \brief Emit diagnostics for the user for potential configuration errors.
   void emitCrossTUDiagnostics(const IndexError &IE);
 
+  CompilerInstance &getCompilerInstance() { return CI; }
+
 private:
   ASTImporter &getOrCreateASTImporter(ASTContext &From);
   const FunctionDecl *findFunctionInDeclContext(const DeclContext *DC,
                                                 StringRef LookupFnName);
 
   llvm::StringMap<std::unique_ptr<clang::ASTUnit>> FileASTUnitMap;
   llvm::StringMap<clang::ASTUnit *> FunctionASTUnitMap;
   llvm::StringMap<std::string> FunctionFileMap;

include/clang/Frontend/LogDiagnosticPrinter.h

void EmitDiagEntry(llvm::raw_ostream &OS,
                      const LogDiagnosticPrinter::DiagEntry &DE);
 
   // Conditional ownership (when StreamOwner is non-null, it's keeping OS
   // alive). We might want to replace this with a wrapper for conditional
   // ownership eventually - it seems to pop up often enough.
   raw_ostream &OS;
   std::unique_ptr<raw_ostream> StreamOwner;
   const LangOptions *LangOpts;
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
 
   SourceLocation LastWarningLoc;
   FullSourceLoc LastLoc;
 
   SmallVector<DiagEntry, 8> Entries;
 
   std::string MainFilename;
   std::string DwarfDebugFlags;
 
 public:
-  LogDiagnosticPrinter(raw_ostream &OS, DiagnosticOptions *Diags,
+  LogDiagnosticPrinter(raw_ostream &OS,
+                       IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs,
+                       DiagnosticOptions *Diags,
                        std::unique_ptr<raw_ostream> StreamOwner);
 
   void setDwarfDebugFlags(StringRef Value) {
     DwarfDebugFlags = Value;
   }
 
   void BeginSourceFile(const LangOptions &LO, const Preprocessor *PP) override {
     LangOpts = &LO;

include/clang/Frontend/SerializedDiagnosticPrinter.h

 
 namespace llvm {
 class raw_ostream;
 }
 
 namespace clang {
 class DiagnosticConsumer;
 class DiagnosticsEngine;
+class DiagnosticIDs;
 class DiagnosticOptions;
 
 namespace serialized_diags {
 
 /// \brief Returns a DiagnosticConsumer that serializes diagnostics to
 ///  a bitcode file.
 ///
 /// The created DiagnosticConsumer is designed for quick and lightweight
 /// transfer of of diagnostics to the enclosing build system (e.g., an IDE).
 /// This allows wrapper tools for Clang to get diagnostics from Clang
 /// (via libclang) without needing to parse Clang's command line output.
 ///
-std::unique_ptr<DiagnosticConsumer> create(StringRef OutputFile,
-                                           DiagnosticOptions *Diags,
-                                           bool MergeChildRecords = false);
+std::unique_ptr<DiagnosticConsumer>
+create(StringRef OutputFile, DiagnosticOptions *Diags,
+       IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs,
 
 } // end serialized_diags namespace
 } // end clang namespace
 
 #endif

include/clang/Frontend/TextDiagnosticPrinter.h

 
 namespace clang {
 class DiagnosticOptions;
 class LangOptions;
 class TextDiagnostic;
 
 class TextDiagnosticPrinter : public DiagnosticConsumer {
   raw_ostream &OS;
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
 
   /// \brief Handle to the currently active text diagnostic emitter.
   std::unique_ptr<TextDiagnostic> TextDiag;
 
   /// A string to prefix to error messages.
   std::string Prefix;
 
   unsigned OwnsOutputStream : 1;
 
 public:
-  TextDiagnosticPrinter(raw_ostream &os, DiagnosticOptions *diags,
+  TextDiagnosticPrinter(raw_ostream &os,
+                        IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs,
+                        DiagnosticOptions *diags,
                         bool OwnsOutputStream = false);
   ~TextDiagnosticPrinter() override;
 
   /// setPrefix - Set the diagnostic printer prefix string, which will be
   /// printed at the start of any diagnostics. If empty, no prefix string is
   /// used.
   void setPrefix(std::string Value) { Prefix = std::move(Value); }
+  const IntrusiveRefCntPtr<DiagnosticIDs> &getDiagIDs() { return DiagIDs; }
 
-  void BeginSourceFile(const LangOptions &LO, const Preprocessor *PP) override;
+  void BeginSourceFile(const LangOptions &LO,
+                       const Preprocessor *PP = nullptr) override;
   void EndSourceFile() override;
   void HandleDiagnostic(DiagnosticsEngine::Level Level,
                         const Diagnostic &Info) override;
 };
 
 } // end namespace clang
 
 #endif

lib/ARCMigrate/ARCMT.cpp

public:
   }
 
   ~CaptureDiagnosticConsumer() override {
     assert(!HasBegunSourceFile && "FinishCapture not called!");
   }
 
   void HandleDiagnostic(DiagnosticsEngine::Level level,
                         const Diagnostic &Info) override {
-    if (DiagnosticIDs::isARCDiagnostic(Info.getID()) ||
+    if (Diags.getDiagnosticIDs()->isARCDiagnostic(Info.getID()) ||
         level >= DiagnosticsEngine::Error || level == DiagnosticsEngine::Note) {
       if (Info.getLocation().isValid())
         CapturedDiags.push_back(StoredDiagnostic(level, Info));
       return;
     }
 
     // Non-ARC warnings are ignored.
     Diags.setLastDiagnosticIgnored();
if (triple.getOS() == llvm::Triple::MacOSX) {
     triple.getOSVersion(Major, Minor, Micro);
     return Major > 10 || (Major == 10 && Minor >= 7);
   }
 
   return false;
 }
 
 static CompilerInvocation *
-createInvocationForMigration(CompilerInvocation &origCI,
+createInvocationForMigration(const IntrusiveRefCntPtr<DiagnosticIDs> &DiagID,
+                             CompilerInvocation &origCI,
                              const PCHContainerReader &PCHContainerRdr) {
   std::unique_ptr<CompilerInvocation> CInvok;
   CInvok.reset(new CompilerInvocation(origCI));
   PreprocessorOptions &PPOpts = CInvok->getPreprocessorOpts();
   if (!PPOpts.ImplicitPCHInclude.empty()) {
     // We can't use a PCH because it was likely built in non-ARC mode and we
     // want to parse in ARC. Include the original header.
     FileManager FileMgr(origCI.getFileSystemOpts());
-    IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
-    IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
-        new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(),
-                              new IgnoringDiagConsumer()));
+    IntrusiveRefCntPtr<DiagnosticsEngine> Diags(new DiagnosticsEngine(
+        DiagID, &origCI.getDiagnosticOpts(), new IgnoringDiagConsumer()));
     std::string OriginalFile = ASTReader::getOriginalSourceFile(
         PPOpts.ImplicitPCHInclude, FileMgr, PCHContainerRdr, *Diags);
     if (!OriginalFile.empty())
       PPOpts.Includes.insert(PPOpts.Includes.begin(), OriginalFile);
     PPOpts.ImplicitPCHInclude.clear();
   }
   // FIXME: Get the original header of a PTH as well.
   CInvok->getPreprocessorOpts().ImplicitPTHInclude.clear();
createInvocationForMigration(const IntrusiveRefCntPtr<DiagnosticIDs> &DiagID,
   CInvok->getLangOpts()->ObjCWeak = CInvok->getLangOpts()->ObjCWeakRuntime;
 
   return CInvok.release();
 }
 
 static void emitPremigrationErrors(const CapturedDiagList &arcDiags,
                                    DiagnosticOptions *diagOpts,
                                    Preprocessor &PP) {
-  TextDiagnosticPrinter printer(llvm::errs(), diagOpts);
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
-  IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
-      new DiagnosticsEngine(DiagID, diagOpts, &printer,
-                            /*ShouldOwnClient=*/false));
+  TextDiagnosticPrinter printer(
+      llvm::errs(), PP.getDiagnostics().getDiagnosticIDs(), diagOpts);
+  IntrusiveRefCntPtr<DiagnosticsEngine> Diags(new DiagnosticsEngine(
+      PP.getDiagnostics().getDiagnosticIDs(), diagOpts, &printer,
   Diags->setSourceManager(&PP.getSourceManager());
   
   printer.BeginSourceFile(PP.getLangOpts(), &PP);
   arcDiags.reportDiagnostics(*Diags);
   printer.EndSourceFile();
 }
 
 //===----------------------------------------------------------------------===//
 // checkForManualIssues.
 //===----------------------------------------------------------------------===//
 
 bool arcmt::checkForManualIssues(
     CompilerInvocation &origCI, const FrontendInputFile &Input,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-    DiagnosticConsumer *DiagClient, bool emitPremigrationARCErrors,
+    DiagnosticsEngine &OriginalDiags, bool emitPremigrationARCErrors,
     StringRef plistOut) {
   if (!origCI.getLangOpts()->ObjC1)
     return false;
 
   LangOptions::GCMode OrigGCMode = origCI.getLangOpts()->getGC();
   bool NoNSAllocReallocError = origCI.getMigratorOpts().NoNSAllocReallocError;
   bool NoFinalizeRemoval = origCI.getMigratorOpts().NoFinalizeRemoval;
 
   std::vector<TransformFn> transforms = arcmt::getAllTransformations(OrigGCMode,
                                                                      NoFinalizeRemoval);
   assert(!transforms.empty());
 
   std::unique_ptr<CompilerInvocation> CInvok;
-  CInvok.reset(
-      createInvocationForMigration(origCI, PCHContainerOps->getRawReader()));
+  CInvok.reset(createInvocationForMigration(OriginalDiags.getDiagnosticIDs(),
+                                            origCI,
+                                            PCHContainerOps->getRawReader()));
   CInvok->getFrontendOpts().Inputs.clear();
   CInvok->getFrontendOpts().Inputs.push_back(Input);
 
   CapturedDiagList capturedDiags;
 
+  auto *DiagClient = OriginalDiags.getClient();
   assert(DiagClient);
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
-  IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
-      new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(),
-                            DiagClient, /*ShouldOwnClient=*/false));
+  IntrusiveRefCntPtr<DiagnosticsEngine> Diags(new DiagnosticsEngine(
+      OriginalDiags.getDiagnosticIDs(), &origCI.getDiagnosticOpts(), DiagClient,
+      /*ShouldOwnClient=*/false));
 
   // Filter of all diagnostics.
   CaptureDiagnosticConsumer errRec(*Diags, *DiagClient, capturedDiags);
   Diags->setClient(&errRec, /*ShouldOwnClient=*/false);
 
   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
       std::move(CInvok), PCHContainerOps, Diags));
   if (!Unit) {
bool arcmt::checkForManualIssues(
   if (emitPremigrationARCErrors)
     emitPremigrationErrors(capturedDiags, &origCI.getDiagnosticOpts(),
                            Unit->getPreprocessor());
   if (!plistOut.empty()) {
     SmallVector<StoredDiagnostic, 8> arcDiags;
     for (CapturedDiagList::iterator
            I = capturedDiags.begin(), E = capturedDiags.end(); I != E; ++I)
       arcDiags.push_back(*I);
-    writeARCDiagsToPlist(plistOut, arcDiags,
-                         Ctx.getSourceManager(), Ctx.getLangOpts());
+    writeARCDiagsToPlist(plistOut, arcDiags, Ctx.getSourceManager(),
+                         Ctx.getLangOpts(), *OriginalDiags.getDiagnosticIDs());
   }
 
   // After parsing of source files ended, we want to reuse the
   // diagnostics objects to emit further diagnostics.
   // We call BeginSourceFile because DiagnosticConsumer requires that 
   // diagnostics with source range information are emitted only in between
   // BeginSourceFile() and EndSourceFile().
   DiagClient->BeginSourceFile(Ctx.getLangOpts(), &Unit->getPreprocessor());

 
 //===----------------------------------------------------------------------===//
 // applyTransformations.
 //===----------------------------------------------------------------------===//
 
 static bool
 applyTransforms(CompilerInvocation &origCI, const FrontendInputFile &Input,
                 std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-                DiagnosticConsumer *DiagClient, StringRef outputDir,
+                DiagnosticsEngine &Diags, StringRef outputDir,
                 bool emitPremigrationARCErrors, StringRef plistOut) {
   if (!origCI.getLangOpts()->ObjC1)
     return false;
 
   LangOptions::GCMode OrigGCMode = origCI.getLangOpts()->getGC();
 
   // Make sure checking is successful first.
   CompilerInvocation CInvokForCheck(origCI);
-  if (arcmt::checkForManualIssues(CInvokForCheck, Input, PCHContainerOps,
-                                  DiagClient, emitPremigrationARCErrors,
-                                  plistOut))
+  if (arcmt::checkForManualIssues(CInvokForCheck, Input, PCHContainerOps, Diags,
+                                  emitPremigrationARCErrors, plistOut))
     return true;
 
   CompilerInvocation CInvok(origCI);
   CInvok.getFrontendOpts().Inputs.clear();
   CInvok.getFrontendOpts().Inputs.push_back(Input);
 
-  MigrationProcess migration(CInvok, PCHContainerOps, DiagClient, outputDir);
+  MigrationProcess migration(CInvok, PCHContainerOps, Diags, outputDir);
   bool NoFinalizeRemoval = origCI.getMigratorOpts().NoFinalizeRemoval;
 
   std::vector<TransformFn> transforms = arcmt::getAllTransformations(OrigGCMode,
                                                                      NoFinalizeRemoval);
   assert(!transforms.empty());
 
   for (unsigned i=0, e = transforms.size(); i != e; ++i) {
     bool err = migration.applyTransform(transforms[i]);
     if (err) return true;
   }
 
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
-  IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
-      new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(),
-                            DiagClient, /*ShouldOwnClient=*/false));
-
   if (outputDir.empty()) {
     origCI.getLangOpts()->ObjCAutoRefCount = true;
-    return migration.getRemapper().overwriteOriginal(*Diags);
+    return migration.getRemapper().overwriteOriginal(Diags);
   } else {
-    return migration.getRemapper().flushToDisk(outputDir, *Diags);
+    return migration.getRemapper().flushToDisk(outputDir, Diags);
   }
 }
 
 bool arcmt::applyTransformations(
     CompilerInvocation &origCI, const FrontendInputFile &Input,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-    DiagnosticConsumer *DiagClient) {
-  return applyTransforms(origCI, Input, PCHContainerOps, DiagClient,
-                         StringRef(), false, StringRef());
+    DiagnosticsEngine &Diags) {
+  return applyTransforms(origCI, Input, PCHContainerOps, Diags, StringRef(),
+                         false, StringRef());
 }
 
 bool arcmt::migrateWithTemporaryFiles(
     CompilerInvocation &origCI, const FrontendInputFile &Input,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-    DiagnosticConsumer *DiagClient, StringRef outputDir,
+    DiagnosticsEngine &Diags, StringRef outputDir,
     bool emitPremigrationARCErrors, StringRef plistOut) {
   assert(!outputDir.empty() && "Expected output directory path");
-  return applyTransforms(origCI, Input, PCHContainerOps, DiagClient, outputDir,
+  return applyTransforms(origCI, Input, PCHContainerOps, Diags, outputDir,
                          emitPremigrationARCErrors, plistOut);
 }
 
-bool arcmt::getFileRemappings(std::vector<std::pair<std::string,std::string> > &
-                                  remap,
-                              StringRef outputDir,
-                              DiagnosticConsumer *DiagClient) {
+bool arcmt::getFileRemappings(
+    std::vector<std::pair<std::string, std::string>> &remap,
+    StringRef outputDir, DiagnosticConsumer *DiagClient,
+    IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs) {
   assert(!outputDir.empty());
 
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
-      new DiagnosticsEngine(DiagID, new DiagnosticOptions,
+      new DiagnosticsEngine(std::move(DiagIDs), new DiagnosticOptions,
                             DiagClient, /*ShouldOwnClient=*/false));
 
   FileRemapper remapper;
   bool err = remapper.initFromDisk(outputDir, *Diags,
                                    /*ignoreIfFilesChanged=*/true);
   if (err)
     return true;
 

 } // end anonymous namespace.
 
 /// \brief Anchor for VTable.
 MigrationProcess::RewriteListener::~RewriteListener() { }
 
 MigrationProcess::MigrationProcess(
     const CompilerInvocation &CI,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-    DiagnosticConsumer *diagClient, StringRef outputDir)
+    DiagnosticsEngine &OriginalDiags, StringRef outputDir)
     : OrigCI(CI), PCHContainerOps(std::move(PCHContainerOps)),
-      DiagClient(diagClient), HadARCErrors(false) {
+      OriginalDiags(OriginalDiags), HadARCErrors(false) {
   if (!outputDir.empty()) {
-    IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
-    IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
-      new DiagnosticsEngine(DiagID, &CI.getDiagnosticOpts(),
-                            DiagClient, /*ShouldOwnClient=*/false));
+    IntrusiveRefCntPtr<DiagnosticsEngine> Diags(new DiagnosticsEngine(
+        OriginalDiags.getDiagnosticIDs(), &CI.getDiagnosticOpts(),
+        OriginalDiags.getClient(), /*ShouldOwnClient=*/false));
     Remapper.initFromDisk(outputDir, *Diags, /*ignoreIfFilesChanges=*/true);
   }
 }
 
 bool MigrationProcess::applyTransform(TransformFn trans,
                                       RewriteListener *listener) {
   std::unique_ptr<CompilerInvocation> CInvok;
-  CInvok.reset(
-      createInvocationForMigration(OrigCI, PCHContainerOps->getRawReader()));
+  CInvok.reset(createInvocationForMigration(OriginalDiags.getDiagnosticIDs(),
+                                            OrigCI,
+                                            PCHContainerOps->getRawReader()));
   CInvok->getDiagnosticOpts().IgnoreWarnings = true;
 
   Remapper.applyMappings(CInvok->getPreprocessorOpts());
 
   CapturedDiagList capturedDiags;
   std::vector<SourceLocation> ARCMTMacroLocs;
 
-  assert(DiagClient);
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
-  IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
-      new DiagnosticsEngine(DiagID, new DiagnosticOptions,
-                            DiagClient, /*ShouldOwnClient=*/false));
+  auto *DiagClient = OriginalDiags.getClient();
+  assert(OriginalDiags.getClient());
+  IntrusiveRefCntPtr<DiagnosticsEngine> Diags(new DiagnosticsEngine(
+      OriginalDiags.getDiagnosticIDs(), new DiagnosticOptions, DiagClient,
+      /*ShouldOwnClient=*/false));
 
   // Filter of all diagnostics.
   CaptureDiagnosticConsumer errRec(*Diags, *DiagClient, capturedDiags);
   Diags->setClient(&errRec, /*ShouldOwnClient=*/false);
 
   std::unique_ptr<ARCMTMacroTrackerAction> ASTAction;
   ASTAction.reset(new ARCMTMacroTrackerAction(ARCMTMacroLocs));
 

lib/ARCMigrate/ARCMTActions.cpp

 #include "clang/Frontend/CompilerInstance.h"
 
 using namespace clang;
 using namespace arcmt;
 
 bool CheckAction::BeginInvocation(CompilerInstance &CI) {
   if (arcmt::checkForManualIssues(CI.getInvocation(), getCurrentInput(),
                                   CI.getPCHContainerOperations(),
-                                  CI.getDiagnostics().getClient()))
+                                  CI.getDiagnostics()))
     return false; // errors, stop the action.
 
   // We only want to see warnings reported from arcmt::checkForManualIssues.
   CI.getDiagnostics().setIgnoreAllWarnings(true);
   return true;
 }
 
 CheckAction::CheckAction(std::unique_ptr<FrontendAction> WrappedAction)
   : WrapperFrontendAction(std::move(WrappedAction)) {}
 
 bool ModifyAction::BeginInvocation(CompilerInstance &CI) {
   return !arcmt::applyTransformations(CI.getInvocation(), getCurrentInput(),
                                       CI.getPCHContainerOperations(),
-                                      CI.getDiagnostics().getClient());
+                                      CI.getDiagnostics());
 }
 
 ModifyAction::ModifyAction(std::unique_ptr<FrontendAction> WrappedAction)
   : WrapperFrontendAction(std::move(WrappedAction)) {}
 
 bool MigrateAction::BeginInvocation(CompilerInstance &CI) {
   if (arcmt::migrateWithTemporaryFiles(
           CI.getInvocation(), getCurrentInput(), CI.getPCHContainerOperations(),
-          CI.getDiagnostics().getClient(), MigrateDir, EmitPremigrationARCErros,
-          PlistOut))
+          CI.getDiagnostics(), MigrateDir, EmitPremigrationARCErros, PlistOut))
     return false; // errors, stop the action.
 
   // We only want to see diagnostics emitted by migrateWithTemporaryFiles.
   CI.getDiagnostics().setIgnoreAllWarnings(true);
   return true;
 }
 
 MigrateAction::MigrateAction(std::unique_ptr<FrontendAction> WrappedAction,
                              StringRef migrateDir,
                              StringRef plistOut,
                              bool emitPremigrationARCErrors)
   : WrapperFrontendAction(std::move(WrappedAction)), MigrateDir(migrateDir),
     PlistOut(plistOut), EmitPremigrationARCErros(emitPremigrationARCErrors) {
   if (MigrateDir.empty())
     MigrateDir = "."; // user current directory if none is given.
 }

lib/ARCMigrate/Internals.h

public:
   bool hasErrors() const;
 
   typedef ListTy::const_iterator iterator;
   iterator begin() const { return List.begin(); }
   iterator end()   const { return List.end();   }
 };
 
 void writeARCDiagsToPlist(const std::string &outPath,
-                          ArrayRef<StoredDiagnostic> diags,
-                          SourceManager &SM, const LangOptions &LangOpts);
+                          ArrayRef<StoredDiagnostic> diags, SourceManager &SM,
+                          const LangOptions &LangOpts,
+                          const DiagnosticIDs &DiagIDs);
 
 class TransformActions {
   DiagnosticsEngine &Diags;
   CapturedDiagList &CapturedDiags;
   void *Impl; // TransformActionsImpl.
 
 public:
   TransformActions(DiagnosticsEngine &diag, CapturedDiagList &capturedDiags,

lib/ARCMigrate/ObjCMT.cpp

bool arcmt::getFileRemappingsFromFileList(
                         ArrayRef<StringRef> remapFiles,
                         DiagnosticConsumer *DiagClient) {
   bool hasErrorOccurred = false;
 
   FileSystemOptions FSOpts;
   FileManager FileMgr(FSOpts);
   RemapFileParser Parser(FileMgr);
 
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs(true));
   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
       new DiagnosticsEngine(DiagID, new DiagnosticOptions,
                             DiagClient, /*ShouldOwnClient=*/false));
 
   typedef llvm::DenseMap<const FileEntry *, std::vector<EditEntry> >
       FileEditEntriesTy;
   FileEditEntriesTy FileEditEntries;
 

lib/ARCMigrate/PlistReporter.cpp

static StringRef getLevelName(DiagnosticsEngine::Level Level) {
   case DiagnosticsEngine::Error:
     return "error";
   }
   llvm_unreachable("Invalid DiagnosticsEngine level!");
 }
 
 void arcmt::writeARCDiagsToPlist(const std::string &outPath,
                                  ArrayRef<StoredDiagnostic> diags,
-                                 SourceManager &SM,
-                                 const LangOptions &LangOpts) {
-  DiagnosticIDs DiagIDs;
+                                 SourceManager &SM, const LangOptions &LangOpts,
+                                 const DiagnosticIDs &DiagIDs) {
 
   // Build up a set of FIDs that we use by scanning the locations and
   // ranges of the diagnostics.
   FIDMap FM;
   SmallVector<FileID, 10> Fids;
 
   for (ArrayRef<StoredDiagnostic>::iterator
          I = diags.begin(), E = diags.end(); I != E; ++I) {

lib/Basic/Diagnostic.cpp

bool DiagnosticsEngine::setDiagnosticGroupErrorAsFatal(StringRef Group,
   return false;
 }
 
 void DiagnosticsEngine::setSeverityForAll(diag::Flavor Flavor,
                                           diag::Severity Map,
                                           SourceLocation Loc) {
   // Get all the diagnostics.
   SmallVector<diag::kind, 64> AllDiags;
-  DiagnosticIDs::getAllDiagnostics(Flavor, AllDiags);
+  Diags->getAllDiagnostics(Flavor, AllDiags);
 
   // Set the mapping.
   for (diag::kind Diag : AllDiags)
     if (Diags->isBuiltinWarningOrExtension(Diag))
       setSeverity(Diag, Map, Loc);
 }
 
 void DiagnosticsEngine::Report(const StoredDiagnostic &storedDiag) {

lib/Basic/DiagnosticIDs.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include <map>
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
 // Builtin Diagnostic information
 //===----------------------------------------------------------------------===//
 
-namespace {
-
-// Diagnostic classes.
-enum {
-  CLASS_NOTE       = 0x01,
-  CLASS_REMARK     = 0x02,
-  CLASS_WARNING    = 0x03,
-  CLASS_EXTENSION  = 0x04,
-  CLASS_ERROR      = 0x05
-};
-
-struct StaticDiagInfoRec {
-  uint16_t DiagID;
-  unsigned DefaultSeverity : 3;
-  unsigned Class : 3;
-  unsigned SFINAE : 2;
-  unsigned WarnNoWerror : 1;
-  unsigned WarnShowInSystemHeader : 1;
-  unsigned Category : 6;
-
-  uint16_t OptionGroupIndex;
-
-  uint16_t DescriptionLen;
-  const char *DescriptionStr;
-
-  unsigned getOptionGroupIndex() const {
-    return OptionGroupIndex;
-  }
-
-  StringRef getDescription() const {
-    return StringRef(DescriptionStr, DescriptionLen);
-  }
-
-  diag::Flavor getFlavor() const {
-    return Class == CLASS_REMARK ? diag::Flavor::Remark
-                                 : diag::Flavor::WarningOrError;
-  }
-
-  bool operator<(const StaticDiagInfoRec &RHS) const {
-    return DiagID < RHS.DiagID;
-  }
-};
-
-#define STRINGIFY_NAME(NAME) #NAME
-#define VALIDATE_DIAG_SIZE(NAME)                                               \
-  static_assert(                                                               \
-      static_cast<unsigned>(diag::NUM_BUILTIN_##NAME##_DIAGNOSTICS) <          \
-          static_cast<unsigned>(diag::DIAG_START_##NAME) +                     \
-              static_cast<unsigned>(diag::DIAG_SIZE_##NAME),                   \
-      STRINGIFY_NAME(                                                          \
-          DIAG_SIZE_##NAME) " is insufficient to contain all "                 \
-                            "diagnostics, it may need to be made larger in "   \
-                            "DiagnosticIDs.h.");
-VALIDATE_DIAG_SIZE(COMMON)
-VALIDATE_DIAG_SIZE(DRIVER)
-VALIDATE_DIAG_SIZE(FRONTEND)
-VALIDATE_DIAG_SIZE(SERIALIZATION)
-VALIDATE_DIAG_SIZE(LEX)
-VALIDATE_DIAG_SIZE(PARSE)
-VALIDATE_DIAG_SIZE(AST)
-VALIDATE_DIAG_SIZE(COMMENT)
-VALIDATE_DIAG_SIZE(SEMA)
-VALIDATE_DIAG_SIZE(ANALYSIS)
-VALIDATE_DIAG_SIZE(REFACTORING)
-#undef VALIDATE_DIAG_SIZE
-#undef STRINGIFY_NAME
-
-} // namespace anonymous
-
-static const StaticDiagInfoRec StaticDiagInfo[] = {
+static const DiagnosticIDs::DiagInfoRec StaticDiagInfo[] = {
 #define DIAG(ENUM, CLASS, DEFAULT_SEVERITY, DESC, GROUP, SFINAE, NOWERROR,     \
              SHOWINSYSHEADER, CATEGORY)                                        \
-  {                                                                            \
-    diag::ENUM, DEFAULT_SEVERITY, CLASS, DiagnosticIDs::SFINAE, NOWERROR,      \
-        SHOWINSYSHEADER, CATEGORY, GROUP, STR_SIZE(DESC, uint16_t), DESC       \
-  }                                                                            \
-  ,
+  {diag::ENUM,                                                                 \
+   DEFAULT_SEVERITY,                                                           \
+   DiagnosticIDs::CLASS,                                                       \
+   DiagnosticIDs::SFINAE,                                                      \
+   NOWERROR,                                                                   \
+   SHOWINSYSHEADER,                                                            \
+   CATEGORY,                                                                   \
+   GROUP,                                                                      \
+   STR_SIZE(DESC, uint16_t),                                                   \
+   DESC},
 #include "clang/Basic/DiagnosticCommonKinds.inc"
 #include "clang/Basic/DiagnosticDriverKinds.inc"
 #include "clang/Basic/DiagnosticFrontendKinds.inc"
 #include "clang/Basic/DiagnosticSerializationKinds.inc"
 #include "clang/Basic/DiagnosticLexKinds.inc"
 #include "clang/Basic/DiagnosticParseKinds.inc"
 #include "clang/Basic/DiagnosticASTKinds.inc"
 #include "clang/Basic/DiagnosticCommentKinds.inc"
 #include "clang/Basic/DiagnosticCrossTUKinds.inc"
 #include "clang/Basic/DiagnosticSemaKinds.inc"
 #include "clang/Basic/DiagnosticAnalysisKinds.inc"
 #include "clang/Basic/DiagnosticRefactoringKinds.inc"
 #undef DIAG
 };
 
 static const unsigned StaticDiagInfoSize = llvm::array_lengthof(StaticDiagInfo);
 
 /// GetDiagInfo - Return the StaticDiagInfoRec entry for the specified DiagID,
 /// or null if the ID is invalid.
-static const StaticDiagInfoRec *GetDiagInfo(unsigned DiagID) {
+static const DiagnosticIDs::DiagInfoRec *GetDiagInfo(unsigned DiagID) {
   // Out of bounds diag. Can't be in the table.
   using namespace diag;
   if (DiagID >= DIAG_UPPER_LIMIT || DiagID <= DIAG_START_COMMON)
     return nullptr;
 
   // Compute the index of the requested diagnostic in the static table.
   // 1. Add the number of diagnostics in each category preceding the
   //    diagnostic and of the category the diagnostic is in. This gives us

 #undef CATEGORY
 
   // Avoid out of bounds reads.
   if (ID + Offset >= StaticDiagInfoSize)
     return nullptr;
 
   assert(ID < StaticDiagInfoSize && Offset < StaticDiagInfoSize);
 
-  const StaticDiagInfoRec *Found = &StaticDiagInfo[ID + Offset];
+  const auto *Found = &StaticDiagInfo[ID + Offset];
   // If the diag id doesn't match we found a different diag, abort. This can
   // happen when this function is called with an ID that points into a hole in
   // the diagID space.
   if (Found->DiagID != DiagID)
     return nullptr;
   return Found;
 }
 
 static DiagnosticMapping GetDefaultDiagMapping(unsigned DiagID) {
   DiagnosticMapping Info = DiagnosticMapping::Make(
       diag::Severity::Fatal, /*IsUser=*/false, /*IsPragma=*/false);
 
-  if (const StaticDiagInfoRec *StaticInfo = GetDiagInfo(DiagID)) {
+  if (const auto *StaticInfo = GetDiagInfo(DiagID)) {
     Info.setSeverity((diag::Severity)StaticInfo->DefaultSeverity);
 
     if (StaticInfo->WarnNoWerror) {
       assert(Info.getSeverity() == diag::Severity::Warning &&
              "Unexpected mapping with no-Werror bit!");
       Info.setNoWarningAsError(true);
     }
   }
 
   return Info;
 }
 
 /// getCategoryNumberForDiag - Return the category number that a specified
 /// DiagID belongs to, or 0 if no category.
-unsigned DiagnosticIDs::getCategoryNumberForDiag(unsigned DiagID) {
-  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
+unsigned DiagnosticIDs::getCategoryNumberForDiag(unsigned DiagID) const {
+  if (const auto *Info = ::GetDiagInfo(DiagID))
     return Info->Category;
   return 0;
 }
 
 namespace {
   // The diagnostic category names.
   struct StaticDiagCategoryRec {
     const char *NameStr;

 #define GET_CATEGORY_TABLE
 #define CATEGORY(X, ENUM) { X, STR_SIZE(X, uint8_t) },
 #include "clang/Basic/DiagnosticGroups.inc"
 #undef GET_CATEGORY_TABLE
   { nullptr, 0 }
 };
 
 /// getNumberOfCategories - Return the number of categories
-unsigned DiagnosticIDs::getNumberOfCategories() {
+unsigned DiagnosticIDs::getNumberOfCategories() const {
   return llvm::array_lengthof(CategoryNameTable) - 1;
 }
 
 /// getCategoryNameFromID - Given a category ID, return the name of the
 /// category, an empty string if CategoryID is zero, or null if CategoryID is
 /// invalid.
-StringRef DiagnosticIDs::getCategoryNameFromID(unsigned CategoryID) {
+StringRef DiagnosticIDs::getCategoryNameFromID(unsigned CategoryID) const {
   if (CategoryID >= getNumberOfCategories())
    return StringRef();
   return CategoryNameTable[CategoryID].getName();
 }
 
-
-
 DiagnosticIDs::SFINAEResponse
-DiagnosticIDs::getDiagnosticSFINAEResponse(unsigned DiagID) {
-  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
+DiagnosticIDs::getDiagnosticSFINAEResponse(unsigned DiagID) const {
+  if (const auto *Info = GetDiagInfo(DiagID))
     return static_cast<DiagnosticIDs::SFINAEResponse>(Info->SFINAE);
   return SFINAE_Report;
 }
 
 /// getBuiltinDiagClass - Return the class field of the diagnostic.
 ///
 static unsigned getBuiltinDiagClass(unsigned DiagID) {
-  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
+  if (const auto *Info = GetDiagInfo(DiagID))
     return Info->Class;
   return ~0U;
 }
 
 //===----------------------------------------------------------------------===//
 // Custom Diagnostic information
 //===----------------------------------------------------------------------===//
 
namespace clang {
   } // end diag namespace
 } // end clang namespace
 
 
 //===----------------------------------------------------------------------===//
 // Common Diagnostic implementation
 //===----------------------------------------------------------------------===//
 
-DiagnosticIDs::DiagnosticIDs() { CustomDiagInfo = nullptr; }
+DiagnosticIDs::DiagnosticIDs(bool)
+    : DiagInfo(StaticDiagInfo), GetDiagInfo(&::GetDiagInfo) {}
 
 DiagnosticIDs::~DiagnosticIDs() {
   delete CustomDiagInfo;
 }
 
 /// getCustomDiagID - Return an ID for a diagnostic with the specified message
 /// and level.  If this is the first request for this diagnostic, it is
 /// registered and created, otherwise the existing ID is returned.
 ///
 /// \param FormatString A fixed diagnostic format string that will be hashed and
 /// mapped to a unique DiagID.
 unsigned DiagnosticIDs::getCustomDiagID(Level L, StringRef FormatString) {
   if (!CustomDiagInfo)
     CustomDiagInfo = new diag::CustomDiagInfo();
   return CustomDiagInfo->getOrCreateDiagID(L, FormatString, *this);
 }
 
 
 /// isBuiltinWarningOrExtension - Return true if the unmapped diagnostic
 /// level of the specified diagnostic ID is a Warning or Extension.
 /// This only works on builtin diagnostics, not custom ones, and is not legal to
 /// call on NOTEs.
-bool DiagnosticIDs::isBuiltinWarningOrExtension(unsigned DiagID) {
+bool DiagnosticIDs::isBuiltinWarningOrExtension(unsigned DiagID) const {
   return DiagID < diag::DIAG_UPPER_LIMIT &&
          getBuiltinDiagClass(DiagID) != CLASS_ERROR;
 }
 
 /// \brief Determine whether the given built-in diagnostic ID is a
 /// Note.
-bool DiagnosticIDs::isBuiltinNote(unsigned DiagID) {
+bool DiagnosticIDs::isBuiltinNote(unsigned DiagID) const {
   return DiagID < diag::DIAG_UPPER_LIMIT &&
     getBuiltinDiagClass(DiagID) == CLASS_NOTE;
 }
 
 /// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic
 /// ID is for an extension of some sort.  This also returns EnabledByDefault,
 /// which is set to indicate whether the diagnostic is ignored by default (in
 /// which case -pedantic enables it) or treated as a warning/error by default.
 ///
 bool DiagnosticIDs::isBuiltinExtensionDiag(unsigned DiagID,
-                                        bool &EnabledByDefault) {
+                                           bool &EnabledByDefault) const {
   if (DiagID >= diag::DIAG_UPPER_LIMIT ||
       getBuiltinDiagClass(DiagID) != CLASS_EXTENSION)
     return false;
 
   EnabledByDefault =
       GetDefaultDiagMapping(DiagID).getSeverity() != diag::Severity::Ignored;
   return true;
 }
 
-bool DiagnosticIDs::isDefaultMappingAsError(unsigned DiagID) {
+bool DiagnosticIDs::isDefaultMappingAsError(unsigned DiagID) const {
   if (DiagID >= diag::DIAG_UPPER_LIMIT)
     return false;
 
   return GetDefaultDiagMapping(DiagID).getSeverity() >= diag::Severity::Error;
 }
 
 /// getDescription - Given a diagnostic ID, return a description of the
 /// issue.
 StringRef DiagnosticIDs::getDescription(unsigned DiagID) const {
-  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
+  if (const DiagInfoRec *Info = GetDiagInfo(DiagID))
     return Info->getDescription();
   assert(CustomDiagInfo && "Invalid CustomDiagInfo");
   return CustomDiagInfo->getDescription(DiagID);
 }
 
 static DiagnosticIDs::Level toLevel(diag::Severity SV) {
   switch (SV) {
   case diag::Severity::Ignored:

 #define GET_DIAG_TABLE
 #include "clang/Basic/DiagnosticGroups.inc"
 #undef GET_DIAG_TABLE
 };
 
 /// getWarningOptionForDiag - Return the lowest-level warning option that
 /// enables the specified diagnostic.  If there is no -Wfoo flag that controls
 /// the diagnostic, this returns null.
-StringRef DiagnosticIDs::getWarningOptionForDiag(unsigned DiagID) {
-  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
+StringRef DiagnosticIDs::getWarningOptionForDiag(unsigned DiagID) const {
+  if (const DiagInfoRec *Info = GetDiagInfo(DiagID))
     return OptionTable[Info->getOptionGroupIndex()].getName();
   return StringRef();
 }
 
-std::vector<std::string> DiagnosticIDs::getDiagnosticFlags() {
+std::vector<std::string> DiagnosticIDs::getDiagnosticFlags() const {
   std::vector<std::string> Res;
   for (size_t I = 1; DiagGroupNames[I] != '\0';) {
     std::string Diag(DiagGroupNames + I + 1, DiagGroupNames[I]);
     I += DiagGroupNames[I] + 1;
     Res.push_back("-W" + Diag);
     Res.push_back("-Wno-" + Diag);
   }
 
auto Found = std::lower_bound(std::begin(OptionTable), std::end(OptionTable),
                                   return LHS.getName() < RHS;
                                 });
   if (Found == std::end(OptionTable) || Found->getName() != Group)
     return true; // Option not found.
 
   return ::getDiagnosticsInGroup(Flavor, Found, Diags);
 }
 
-void DiagnosticIDs::getAllDiagnostics(diag::Flavor Flavor,
-                                      SmallVectorImpl<diag::kind> &Diags) {
+void DiagnosticIDs::getAllDiagnostics(
+    diag::Flavor Flavor, SmallVectorImpl<diag::kind> &Diags) const {
   for (unsigned i = 0; i != StaticDiagInfoSize; ++i)
     if (StaticDiagInfo[i].getFlavor() == Flavor)
       Diags.push_back(StaticDiagInfo[i].DiagID);
 }
 
 StringRef DiagnosticIDs::getNearestOption(diag::Flavor Flavor,
-                                          StringRef Group) {
+                                          StringRef Group) const {
   StringRef Best;
   unsigned BestDistance = Group.size() + 1; // Sanity threshold.
   for (const WarningOption &O : OptionTable) {
     // Don't suggest ignored warning flags.
     if (!O.Members && !O.SubGroups)
       continue;
 
     unsigned Distance = O.getName().edit_distance(Group, true, BestDistance);
bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const {
 
   // Currently we consider all ARC errors as recoverable.
   if (isARCDiagnostic(DiagID))
     return false;
 
   return true;
 }
 
-bool DiagnosticIDs::isARCDiagnostic(unsigned DiagID) {
+bool DiagnosticIDs::isARCDiagnostic(unsigned DiagID) const {
   unsigned cat = getCategoryNumberForDiag(DiagID);
   return DiagnosticIDs::getCategoryNameFromID(cat).startswith("ARC ");
 }

lib/Basic/Warnings.cpp

 #include <utility>
 using namespace clang;
 
 // EmitUnknownDiagWarning - Emit a warning and typo hint for unknown warning
 // opts
 static void EmitUnknownDiagWarning(DiagnosticsEngine &Diags,
                                    diag::Flavor Flavor, StringRef Prefix,
                                    StringRef Opt) {
-  StringRef Suggestion = DiagnosticIDs::getNearestOption(Flavor, Opt);
+  StringRef Suggestion =
+      Diags.getDiagnosticIDs()->getNearestOption(Flavor, Opt);
   Diags.Report(diag::warn_unknown_diag_option)
     << (Flavor == diag::Flavor::WarningOrError ? 0 : 1) << (Prefix.str() += Opt)
     << !Suggestion.empty() << (Prefix.str() += Suggestion);
 }
 
 void clang::ProcessWarningOptions(DiagnosticsEngine &Diags,
                                   const DiagnosticOptions &Opts,
                                   bool ReportDiags) {

lib/CrossTU/CrossTranslationUnit.cpp

for (const Decl *D : DC->decls()) {
     if (getLookupName(ResultDecl) != LookupFnName)
       continue;
     return ResultDecl;
   }
   return nullptr;
 }
 
 llvm::Expected<const FunctionDecl *>
-CrossTranslationUnitContext::getCrossTUDefinition(const FunctionDecl *FD,
-                                                  StringRef CrossTUDir,
-                                                  StringRef IndexName) {
+CrossTranslationUnitContext::getCrossTUDefinition(
+    const FunctionDecl *FD, StringRef CrossTUDir, StringRef IndexName,
+    const IntrusiveRefCntPtr<DiagnosticIDs> &DiagIDs) {
   assert(!FD->hasBody() && "FD has a definition in current translation unit!");
   const std::string LookupFnName = getLookupName(FD);
   if (LookupFnName.empty())
     return llvm::make_error<IndexError>(
         index_error_code::failed_to_generate_usr);
   llvm::Expected<ASTUnit *> ASTUnitOrError =
-      loadExternalAST(LookupFnName, CrossTUDir, IndexName);
+      loadExternalAST(LookupFnName, CrossTUDir, IndexName, DiagIDs);
   if (!ASTUnitOrError)
     return ASTUnitOrError.takeError();
   ASTUnit *Unit = *ASTUnitOrError;
   if (!Unit)
     return llvm::make_error<IndexError>(
         index_error_code::failed_to_get_external_ast);
   assert(&Unit->getFileManager() ==
          &Unit->getASTContext().getSourceManager().getFileManager());
Context.getDiagnostics().Report(diag::err_multiple_def_index)
         << IE.getLineNum();
     break;
   default:
     break;
   }
 }
 
 llvm::Expected<ASTUnit *> CrossTranslationUnitContext::loadExternalAST(
-    StringRef LookupName, StringRef CrossTUDir, StringRef IndexName) {
+    StringRef LookupName, StringRef CrossTUDir, StringRef IndexName,
+    const IntrusiveRefCntPtr<DiagnosticIDs> &DiagIDs) {
   // FIXME: The current implementation only supports loading functions with
   //        a lookup name from a single translation unit. If multiple
   //        translation units contains functions with the same lookup name an
   //        error will be returned.
   ASTUnit *Unit = nullptr;
   auto FnUnitCacheEntry = FunctionASTUnitMap.find(LookupName);
   if (FnUnitCacheEntry == FunctionASTUnitMap.end()) {
     if (FunctionFileMap.empty()) {
if (FnUnitCacheEntry == FunctionASTUnitMap.end()) {
     auto It = FunctionFileMap.find(LookupName);
     if (It == FunctionFileMap.end())
       return llvm::make_error<IndexError>(index_error_code::missing_definition);
     StringRef ASTFileName = It->second;
     auto ASTCacheEntry = FileASTUnitMap.find(ASTFileName);
     if (ASTCacheEntry == FileASTUnitMap.end()) {
       IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
       TextDiagnosticPrinter *DiagClient =
-          new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
-      IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+          new TextDiagnosticPrinter(llvm::errs(), DiagIDs, &*DiagOpts);
       IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
-          new DiagnosticsEngine(DiagID, &*DiagOpts, DiagClient));
+          new DiagnosticsEngine(DiagIDs, &*DiagOpts, DiagClient));
 
       std::unique_ptr<ASTUnit> LoadedUnit(ASTUnit::LoadFromASTFile(
           ASTFileName, CI.getPCHContainerOperations()->getRawReader(),
           ASTUnit::LoadEverything, Diags, CI.getFileSystemOpts()));
       Unit = LoadedUnit.get();
       FileASTUnitMap[ASTFileName] = std::move(LoadedUnit);
     } else {
       Unit = ASTCacheEntry->second.get();

lib/Driver/Driver.cpp

void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
   OS << '\n';
 
   // Print out the install directory.
   OS << "InstalledDir: " << InstalledDir << '\n';
 }
 
 /// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
 /// option.
-static void PrintDiagnosticCategories(raw_ostream &OS) {
+static void PrintDiagnosticCategories(const DiagnosticIDs &IDs,
+                                      raw_ostream &OS) {
   // Skip the empty category.
-  for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories(); i != max;
-       ++i)
-    OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n';
+  for (unsigned i = 1, max = IDs.getNumberOfCategories(); i != max; ++i)
+    OS << i << ',' << IDs.getCategoryNameFromID(i) << '\n';
 }
 
 void Driver::handleAutocompletions(StringRef PassedFlags) const {
   // Print out all options that start with a given argument. This is used for
   // shell autocompletion.
   std::vector<std::string> SuggestedCompletions;
 
   unsigned short DisableFlags =
if (PassedFlags.find(',') == StringRef::npos) {
     // If the flag is in the form of "--autocomplete=-foo",
     // we were requested to print out all option names that start with "-foo".
     // For example, "--autocomplete=-fsyn" is expanded to "-fsyntax-only".
     SuggestedCompletions = Opts->findByPrefix(PassedFlags, DisableFlags);
 
     // We have to query the -W flags manually as they're not in the OptTable.
     // TODO: Find a good way to add them to OptTable instead and them remove
     // this code.
-    for (StringRef S : DiagnosticIDs::getDiagnosticFlags())
+    for (StringRef S : Diags.getDiagnosticIDs()->getDiagnosticFlags())
       if (S.startswith(PassedFlags))
         SuggestedCompletions.push_back(S);
   } else {
     // If the flag is in the form of "--autocomplete=foo,bar", we were
     // requested to print out all option values for "-foo" that start with
     // "bar". For example,
     // "--autocomplete=-stdlib=,l" is expanded to "libc++" and "libstdc++".
     StringRef Option, Arg;
if (C.getArgs().hasArg(options::OPT_dumpversion)) {
     // If we want to return a more correct answer some day, then we should
     // introduce a non-pedantically GCC compatible mode to Clang in which we
     // provide sensible definitions for -dumpversion, __VERSION__, etc.
     llvm::outs() << "4.2.1\n";
     return false;
   }
 
   if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
-    PrintDiagnosticCategories(llvm::outs());
+    PrintDiagnosticCategories(*Diags.getDiagnosticIDs(), llvm::outs());
     return false;
   }
 
   if (C.getArgs().hasArg(options::OPT_help) ||
       C.getArgs().hasArg(options::OPT__help_hidden)) {
     PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
     return false;
   }

lib/Frontend/ChainedIncludesSource.cpp

for (unsigned i = 0, e = includes.size(); i != e; ++i) {
     CInvok->getPreprocessorOpts().Includes.clear();
     CInvok->getPreprocessorOpts().MacroIncludes.clear();
     CInvok->getPreprocessorOpts().Macros.clear();
     
     CInvok->getFrontendOpts().Inputs.clear();
     FrontendInputFile InputFile(includes[i], IK);
     CInvok->getFrontendOpts().Inputs.push_back(InputFile);
 
-    TextDiagnosticPrinter *DiagClient =
-      new TextDiagnosticPrinter(llvm::errs(), new DiagnosticOptions());
     IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+    TextDiagnosticPrinter *DiagClient = new TextDiagnosticPrinter(
+        llvm::errs(), DiagID, new DiagnosticOptions());
     IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
         new DiagnosticsEngine(DiagID, &CI.getDiagnosticOpts(), DiagClient));
 
     std::unique_ptr<CompilerInstance> Clang(
         new CompilerInstance(CI.getPCHContainerOperations()));
     Clang->setInvocation(std::move(CInvok));
     Clang->setDiagnostics(Diags.get());
     Clang->setTarget(TargetInfo::CreateTargetInfo(

lib/Frontend/CompilerInstance.cpp

if (DiagOpts->DiagnosticLogFile != "-") {
     } else {
       FileOS->SetUnbuffered();
       OS = FileOS.get();
       StreamOwner = std::move(FileOS);
     }
   }
 
   // Chain in the diagnostic client which will log the diagnostics.
-  auto Logger = llvm::make_unique<LogDiagnosticPrinter>(*OS, DiagOpts,
-                                                        std::move(StreamOwner));
+  auto Logger = llvm::make_unique<LogDiagnosticPrinter>(
+      *OS, Diags.getDiagnosticIDs(), DiagOpts, std::move(StreamOwner));
   if (CodeGenOpts)
     Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
   assert(Diags.ownsClient());
   Diags.setClient(
       new ChainedDiagnosticConsumer(Diags.takeClient(), std::move(Logger)));
 }
 
 static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
                                        DiagnosticsEngine &Diags,
                                        StringRef OutputFile) {
-  auto SerializedConsumer =
-      clang::serialized_diags::create(OutputFile, DiagOpts);
+  auto SerializedConsumer = clang::serialized_diags::create(
+      OutputFile, DiagOpts, Diags.getDiagnosticIDs());
 
   if (Diags.ownsClient()) {
     Diags.setClient(new ChainedDiagnosticConsumer(
         Diags.takeClient(), std::move(SerializedConsumer)));
   } else {
     Diags.setClient(new ChainedDiagnosticConsumer(
         Diags.getClient(), std::move(SerializedConsumer)));
   }
CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
   IntrusiveRefCntPtr<DiagnosticsEngine>
       Diags(new DiagnosticsEngine(DiagID, Opts));
 
   // Create the diagnostic client for reporting errors or for
   // implementing -verify.
   if (Client) {
     Diags->setClient(Client, ShouldOwnClient);
   } else
-    Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
+    Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), DiagID, Opts));
 
   // Chain in -verify checker, if requested.
   if (Opts->VerifyDiagnostics)
     Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
 
   // Chain in -diagnostic-log-file dumper, if requested.
   if (!Opts->DiagnosticLogFile.empty())
     SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);

lib/Frontend/LogDiagnosticPrinter.cpp

 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace clang;
 using namespace markup;
 
 LogDiagnosticPrinter::LogDiagnosticPrinter(
-    raw_ostream &os, DiagnosticOptions *diags,
-    std::unique_ptr<raw_ostream> StreamOwner)
+    raw_ostream &os, IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs,
+    DiagnosticOptions *diags, std::unique_ptr<raw_ostream> StreamOwner)
     : OS(os), StreamOwner(std::move(StreamOwner)), LangOpts(nullptr),
-      DiagOpts(diags) {}
+      DiagIDs(std::move(DiagIDs)), DiagOpts(diags) {}
 
 static StringRef getLevelName(DiagnosticsEngine::Level Level) {
   switch (Level) {
   case DiagnosticsEngine::Ignored: return "ignored";
   case DiagnosticsEngine::Remark:  return "remark";
   case DiagnosticsEngine::Note:    return "note";
   case DiagnosticsEngine::Warning: return "warning";
   case DiagnosticsEngine::Error:   return "error";
if (MainFilename.empty() && Info.hasSourceManager()) {
     }
   }
 
   // Create the diag entry.
   DiagEntry DE;
   DE.DiagnosticID = Info.getID();
   DE.DiagnosticLevel = Level;
 
-  DE.WarningOption = DiagnosticIDs::getWarningOptionForDiag(DE.DiagnosticID);
+  DE.WarningOption = DiagIDs->getWarningOptionForDiag(DE.DiagnosticID);
 
   // Format the message.
   SmallString<100> MessageStr;
   Info.FormatDiagnostic(MessageStr);
   DE.Message = MessageStr.str();
 
   // Set the location information.
   DE.Filename = "";

lib/Frontend/SerializedDiagnosticPrinter.cpp

class SDiagsWriter : public DiagnosticConsumer {
 
   struct SharedState;
 
   explicit SDiagsWriter(std::shared_ptr<SharedState> State)
       : LangOpts(nullptr), OriginalInstance(false), MergeChildRecords(false),
         State(std::move(State)) {}
 
 public:
-  SDiagsWriter(StringRef File, DiagnosticOptions *Diags, bool MergeChildRecords)
+  SDiagsWriter(StringRef File, DiagnosticOptions *Diags,
+               IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs,
+               bool MergeChildRecords)
       : LangOpts(nullptr), OriginalInstance(true),
         MergeChildRecords(MergeChildRecords),
-        State(std::make_shared<SharedState>(File, Diags)) {
+        State(std::make_shared<SharedState>(File, Diags, std::move(DiagIDs))) {
     if (MergeChildRecords)
       RemoveOldDiagnostics();
     EmitPreamble();
   }
 
   ~SDiagsWriter() override {}
 
   void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
private:
 
   /// \brief Whether this instance should aggregate diagnostics that are
   /// generated from child processes.
   bool MergeChildRecords;
 
   /// \brief State that is shared among the various clones of this diagnostic
   /// consumer.
   struct SharedState {
-    SharedState(StringRef File, DiagnosticOptions *Diags)
-        : DiagOpts(Diags), Stream(Buffer), OutputFile(File.str()),
-          EmittedAnyDiagBlocks(false) {}
+    SharedState(StringRef File, DiagnosticOptions *Diags,
+                IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs)
+        : DiagOpts(Diags), DiagIDs(std::move(DiagIDs)), Stream(Buffer),
+          OutputFile(File.str()), EmittedAnyDiagBlocks(false) {}
 
     /// \brief Diagnostic options.
     IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
+    IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs;
 
     /// \brief The byte buffer for the serialized content.
     SmallString<1024> Buffer;
 
     /// \brief The BitStreamWriter for the serialized diagnostics.
     llvm::BitstreamWriter Stream;
 
     /// \brief The name of the diagnostics file.
private:
   /// \brief State shared among the various clones of this diagnostic consumer.
   std::shared_ptr<SharedState> State;
 };
 } // end anonymous namespace
 
 namespace clang {
 namespace serialized_diags {
 std::unique_ptr<DiagnosticConsumer>
-create(StringRef OutputFile, DiagnosticOptions *Diags, bool MergeChildRecords) {
-  return llvm::make_unique<SDiagsWriter>(OutputFile, Diags, MergeChildRecords);
+create(StringRef OutputFile, DiagnosticOptions *Diags,
+       IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs, bool MergeChildRecords) {
+  return llvm::make_unique<SDiagsWriter>(OutputFile, Diags, std::move(DiagIDs),
+                                         MergeChildRecords);
 }
 
 } // end namespace serialized_diags
 } // end namespace clang
 
 //===----------------------------------------------------------------------===//
 // Serialization methods.
 //===----------------------------------------------------------------------===//

 }
 
 unsigned SDiagsWriter::getEmitCategory(unsigned int category) {
   if (!State->Categories.insert(category).second)
     return category;
 
   // We use a local version of 'Record' so that we can be generating
   // another record when we lazily generate one for the category entry.
-  StringRef catName = DiagnosticIDs::getCategoryNameFromID(category);
+  StringRef catName = State->DiagIDs->getCategoryNameFromID(category);
   RecordData::value_type Record[] = {RECORD_CATEGORY, category, catName.size()};
   State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), Record,
                                    catName);
   
   return category;
 }
 
 unsigned SDiagsWriter::getEmitDiagnosticFlag(DiagnosticsEngine::Level DiagLevel,
                                              unsigned DiagID) {
   if (DiagLevel == DiagnosticsEngine::Note)
     return 0; // No flag for notes.
-  
-  StringRef FlagName = DiagnosticIDs::getWarningOptionForDiag(DiagID);
+  StringRef FlagName = State->DiagIDs->getWarningOptionForDiag(DiagID);
   return getEmitDiagnosticFlag(FlagName);
 }
 
 unsigned SDiagsWriter::getEmitDiagnosticFlag(StringRef FlagName) {
   if (FlagName.empty())
     return 0;
 
   // Here we assume that FlagName points to static data whose pointer
void SDiagsWriter::EmitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
   // Emit the RECORD_DIAG record.
   Record.clear();
   Record.push_back(RECORD_DIAG);
   Record.push_back(getStableLevel(Level));
   AddLocToRecord(Loc, PLoc, Record);
 
   if (const Diagnostic *Info = D.dyn_cast<const Diagnostic*>()) {
     // Emit the category string lazily and get the category ID.
-    unsigned DiagID = DiagnosticIDs::getCategoryNumberForDiag(Info->getID());
+    unsigned DiagID = State->DiagIDs->getCategoryNumberForDiag(Info->getID());
     Record.push_back(getEmitCategory(DiagID));
     // Emit the diagnostic flag string lazily and get the mapped ID.
     Record.push_back(getEmitDiagnosticFlag(Level, Info->getID()));
   } else {
     Record.push_back(getEmitCategory());
     Record.push_back(getEmitDiagnosticFlag(Level));
   }
 
DiagnosticsEngine *SDiagsWriter::getMetaDiags() {
   //    consumers rather than the engine itself.
   //
   // 2. Pass a DiagnosticsEngine to SDiagsWriter on creation - this would need
   //    to be distinct from the engine the writer was being added to and would
   //    normally not be used.
   if (!State->MetaDiagnostics) {
     IntrusiveRefCntPtr<DiagnosticIDs> IDs(new DiagnosticIDs());
     auto Client =
-        new TextDiagnosticPrinter(llvm::errs(), State->DiagOpts.get());
+        new TextDiagnosticPrinter(llvm::errs(), IDs, State->DiagOpts.get());
     State->MetaDiagnostics = llvm::make_unique<DiagnosticsEngine>(
         IDs, State->DiagOpts.get(), Client);
   }
   return State->MetaDiagnostics.get();
 }
 
 void SDiagsWriter::RemoveOldDiagnostics() {
   if (!llvm::sys::fs::remove(State->OutputFile))

lib/Frontend/TextDiagnosticPrinter.cpp

 #include "clang/Frontend/TextDiagnostic.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 using namespace clang;
 
-TextDiagnosticPrinter::TextDiagnosticPrinter(raw_ostream &os,
-                                             DiagnosticOptions *diags,
-                                             bool _OwnsOutputStream)
-  : OS(os), DiagOpts(diags),
-    OwnsOutputStream(_OwnsOutputStream) {
-}
+TextDiagnosticPrinter::TextDiagnosticPrinter(
+    raw_ostream &os, IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs,
+    DiagnosticOptions *diags, bool _OwnsOutputStream)
+    : OS(os), DiagIDs(std::move(DiagIDs)), DiagOpts(diags),
+      OwnsOutputStream(_OwnsOutputStream) {}
 
 TextDiagnosticPrinter::~TextDiagnosticPrinter() {
   if (OwnsOutputStream)
     delete &OS;
 }
 
 void TextDiagnosticPrinter::BeginSourceFile(const LangOptions &LO,
                                             const Preprocessor *PP) {
   // Build the TextDiagnostic utility.
   TextDiag.reset(new TextDiagnostic(OS, LO, &*DiagOpts));
 }
 
 void TextDiagnosticPrinter::EndSourceFile() {
   TextDiag.reset();
 }
 
 /// \brief Print any diagnostic option information to a raw_ostream.
 ///
 /// This implements all of the logic for adding diagnostic options to a message
 /// (via OS). Each relevant option is comma separated and all are enclosed in
 /// the standard bracketing: " [...]".
 static void printDiagnosticOptions(raw_ostream &OS,
                                    DiagnosticsEngine::Level Level,
                                    const Diagnostic &Info,
-                                   const DiagnosticOptions &DiagOpts) {
+                                   const DiagnosticOptions &DiagOpts,
+                                   const DiagnosticIDs &DiagIDs) {
   bool Started = false;
   if (DiagOpts.ShowOptionNames) {
     // Handle special cases for non-warnings early.
     if (Info.getID() == diag::fatal_too_many_errors) {
       OS << " [-ferror-limit=]";
       return;
     }
 
     // The code below is somewhat fragile because we are essentially trying to
     // report to the user what happened by inferring what the diagnostic engine
     // did. Eventually it might make more sense to have the diagnostic engine
     // include some "why" information in the diagnostic.
 
     // If this is a warning which has been mapped to an error by the user (as
     // inferred by checking whether the default mapping is to an error) then
     // flag it as such. Note that diagnostics could also have been mapped by a
     // pragma, but we don't currently have a way to distinguish this.
     if (Level == DiagnosticsEngine::Error &&
-        DiagnosticIDs::isBuiltinWarningOrExtension(Info.getID()) &&
-        !DiagnosticIDs::isDefaultMappingAsError(Info.getID())) {
+        DiagIDs.isBuiltinWarningOrExtension(Info.getID()) &&
+        !DiagIDs.isDefaultMappingAsError(Info.getID())) {
       OS << " [-Werror";
       Started = true;
     }
 
-    StringRef Opt = DiagnosticIDs::getWarningOptionForDiag(Info.getID());
+    StringRef Opt = DiagIDs.getWarningOptionForDiag(Info.getID());
     if (!Opt.empty()) {
       OS << (Started ? "," : " [")
          << (Level == DiagnosticsEngine::Remark ? "-R" : "-W") << Opt;
       StringRef OptValue = Info.getDiags()->getFlagValue();
       if (!OptValue.empty())
         OS << "=" << OptValue;
       Started = true;
     }
   }
 
   // If the user wants to see category information, include it too.
   if (DiagOpts.ShowCategories) {
-    unsigned DiagCategory =
-      DiagnosticIDs::getCategoryNumberForDiag(Info.getID());
+    unsigned DiagCategory = DiagIDs.getCategoryNumberForDiag(Info.getID());
     if (DiagCategory) {
       OS << (Started ? "," : " [");
       Started = true;
       if (DiagOpts.ShowCategories == 1)
         OS << DiagCategory;
       else {
         assert(DiagOpts.ShowCategories == 2 && "Invalid ShowCategories value");
-        OS << DiagnosticIDs::getCategoryNameFromID(DiagCategory);
+        OS << DiagIDs.getCategoryNameFromID(DiagCategory);
       }
     }
   }
   if (Started)
     OS << ']';
 }
 
 void TextDiagnosticPrinter::HandleDiagnostic(DiagnosticsEngine::Level Level,
                                              const Diagnostic &Info) {
   // Default implementation (Warnings/errors count).
   DiagnosticConsumer::HandleDiagnostic(Level, Info);
 
   // Render the diagnostic message into a temporary buffer eagerly. We'll use
   // this later as we print out the diagnostic to the terminal.
   SmallString<100> OutStr;
   Info.FormatDiagnostic(OutStr);
 
   llvm::raw_svector_ostream DiagMessageStream(OutStr);
-  printDiagnosticOptions(DiagMessageStream, Level, Info, *DiagOpts);
+  printDiagnosticOptions(DiagMessageStream, Level, Info, *DiagOpts, *DiagIDs);
 
   // Keeps track of the starting position of the location
   // information (e.g., "foo.c:10:4:") that precedes the error
   // message. We use this information to determine how long the
   // file+line+column number prefix is.
   uint64_t StartOfLocationInfo = OS.tell();
 
   if (!Prefix.empty())

lib/Sema/Sema.cpp

void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
   // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
   // and yet we also use the current diag ID on the DiagnosticsEngine. This has
   // been made more painfully obvious by the refactor that introduced this
   // function, but it is possible that the incoming argument can be
   // eliminated. If it truly cannot be (for example, there is some reentrancy
   // issue I am not seeing yet), then there should at least be a clarifying
   // comment somewhere.
   if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
-    switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
-              Diags.getCurrentDiagID())) {
+    switch (Diags.getDiagnosticIDs()->getDiagnosticSFINAEResponse(
     case DiagnosticIDs::SFINAE_Report:
       // We'll report the diagnostic below.
       break;
 
     case DiagnosticIDs::SFINAE_SubstitutionFailure:
       // Count this failure so that we know that template argument deduction
       // has failed.
       ++NumSFINAEErrors;
void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
   // Emit the diagnostic.
   if (!Diags.EmitCurrentDiagnostic())
     return;
 
   // If this is not a note, and we're in a template instantiation
   // that is different from the last template instantiation where
   // we emitted an error, print a template instantiation
   // backtrace.
-  if (!DiagnosticIDs::isBuiltinNote(DiagID))
+  if (!Diags.getDiagnosticIDs()->isBuiltinNote(DiagID))
     PrintContextStack();
 }
 
 Sema::SemaDiagnosticBuilder
 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
   SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
   PD.Emit(Builder);
 

lib/Tooling/CompilationDatabase.cpp

 ///          \li true if successful.
 ///          \li false if \c Args cannot be used for compilation jobs (e.g.
 ///          contains an option like -E or -version).
 static bool stripPositionalArgs(std::vector<const char *> Args,
                                 std::vector<std::string> &Result,
                                 std::string &ErrorMsg) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   llvm::raw_string_ostream Output(ErrorMsg);
-  TextDiagnosticPrinter DiagnosticPrinter(Output, &*DiagOpts);
+  IntrusiveRefCntPtr<clang::DiagnosticIDs> DiagIDs(new DiagnosticIDs());
+  TextDiagnosticPrinter DiagnosticPrinter(Output, DiagIDs, &*DiagOpts);
   UnusedInputDiagConsumer DiagClient(DiagnosticPrinter);
-  DiagnosticsEngine Diagnostics(
-      IntrusiveRefCntPtr<clang::DiagnosticIDs>(new DiagnosticIDs()),
-      &*DiagOpts, &DiagClient, false);
+  DiagnosticsEngine Diagnostics(std::move(DiagIDs), &*DiagOpts, &DiagClient,
+                                false);
 
   // The clang executable path isn't required since the jobs the driver builds
   // will not be executed.
   std::unique_ptr<driver::Driver> NewDriver(new driver::Driver(
       /* ClangExecutable= */ "", llvm::sys::getDefaultTargetTriple(),
       Diagnostics));
   NewDriver->setCheckInputsExist(false);
 

lib/Tooling/Refactoring.cpp

 
 int RefactoringTool::runAndSave(FrontendActionFactory *ActionFactory) {
   if (int Result = run(ActionFactory)) {
     return Result;
   }
 
   LangOptions DefaultLangOptions;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
-  TextDiagnosticPrinter DiagnosticPrinter(llvm::errs(), &*DiagOpts);
-  DiagnosticsEngine Diagnostics(
-      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()),
-      &*DiagOpts, &DiagnosticPrinter, false);
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(new DiagnosticIDs());
+  TextDiagnosticPrinter DiagnosticPrinter(llvm::errs(), DiagIDs, &*DiagOpts);
+  DiagnosticsEngine Diagnostics(std::move(DiagIDs), &*DiagOpts,
+                                &DiagnosticPrinter, false);
   SourceManager Sources(Diagnostics, getFiles());
   Rewriter Rewrite(Sources, DefaultLangOptions);
 
   if (!applyAllReplacements(Rewrite)) {
     llvm::errs() << "Skipped some replacements.\n";
   }
 
   return saveRewrittenFiles(Rewrite);

lib/Tooling/Tooling.cpp

for (const std::string &Str : CommandLine)
     Argv.push_back(Str.c_str());
   const char *const BinaryName = Argv[0];
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   unsigned MissingArgIndex, MissingArgCount;
   std::unique_ptr<llvm::opt::OptTable> Opts = driver::createDriverOptTable();
   llvm::opt::InputArgList ParsedArgs = Opts->ParseArgs(
       ArrayRef<const char *>(Argv).slice(1), MissingArgIndex, MissingArgCount);
   ParseDiagnosticArgs(*DiagOpts, ParsedArgs);
-  TextDiagnosticPrinter DiagnosticPrinter(
-      llvm::errs(), &*DiagOpts);
+  IntrusiveRefCntPtr<clang::DiagnosticIDs> DiagIDs(new DiagnosticIDs());
+  TextDiagnosticPrinter DiagnosticPrinter(llvm::errs(), DiagIDs, &*DiagOpts);
   DiagnosticsEngine Diagnostics(
-      IntrusiveRefCntPtr<clang::DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
+      std::move(DiagIDs), &*DiagOpts,
       DiagConsumer ? DiagConsumer : &DiagnosticPrinter, false);
 
   const std::unique_ptr<clang::driver::Driver> Driver(
       newDriver(&Diagnostics, BinaryName, Files->getVirtualFileSystem()));
   // Since the input might only be virtual, don't check whether it exists.
   Driver->setCheckInputsExist(false);
   const std::unique_ptr<clang::driver::Compilation> Compilation(
       Driver->BuildCompilation(llvm::makeArrayRef(Argv)));

tools/arcmt-test/arcmt-test.cpp

public:
   }
 };
 
 } // anonymous namespace
 
 static bool checkForMigration(StringRef resourcesPath,
                               ArrayRef<const char *> Args) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
-  DiagnosticConsumer *DiagClient =
-    new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  DiagnosticConsumer *DiagClient =
+      new TextDiagnosticPrinter(llvm::errs(), DiagID, &*DiagOpts);
   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
       new DiagnosticsEngine(DiagID, &*DiagOpts, DiagClient));
   // Chain in -verify checker, if requested.
   VerifyDiagnosticConsumer *verifyDiag = nullptr;
   if (VerifyDiags) {
     verifyDiag = new VerifyDiagnosticConsumer(*Diags);
     Diags->setClient(verifyDiag);
   }
 
   CompilerInvocation CI;
   if (!CompilerInvocation::CreateFromArgs(CI, Args.begin(), Args.end(), *Diags))
     return true;
 
   if (CI.getFrontendOpts().Inputs.empty()) {
     llvm::errs() << "error: no input files\n";
     return true;
   }
 
   if (!CI.getLangOpts()->ObjC1)
     return false;
 
   arcmt::checkForManualIssues(CI, CI.getFrontendOpts().Inputs[0],
                               std::make_shared<PCHContainerOperations>(),
-                              Diags->getClient());
+                              *Diags);
   return Diags->getClient()->getNumErrors() > 0;
 }
 
 static void printResult(FileRemapper &remapper, raw_ostream &OS) {
   PreprocessorOptions PPOpts;
   remapper.applyMappings(PPOpts);
   // The changed files will be in memory buffers, print them.
   for (const auto &RB : PPOpts.RemappedFileBuffers)
     OS << RB.second->getBuffer();
 }
 
 static bool performTransformations(StringRef resourcesPath,
                                    ArrayRef<const char *> Args) {
   // Check first.
   if (checkForMigration(resourcesPath, Args))
     return true;
 
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
-  DiagnosticConsumer *DiagClient =
-    new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  DiagnosticConsumer *DiagClient =
+      new TextDiagnosticPrinter(llvm::errs(), DiagID, &*DiagOpts);
   IntrusiveRefCntPtr<DiagnosticsEngine> TopDiags(
       new DiagnosticsEngine(DiagID, &*DiagOpts, &*DiagClient));
 
   CompilerInvocation origCI;
   if (!CompilerInvocation::CreateFromArgs(origCI, Args.begin(), Args.end(),
                                      *TopDiags))
     return true;
 
   if (origCI.getFrontendOpts().Inputs.empty()) {
     llvm::errs() << "error: no input files\n";
     return true;
   }
 
   if (!origCI.getLangOpts()->ObjC1)
     return false;
 
   MigrationProcess migration(origCI, std::make_shared<PCHContainerOperations>(),
-                             DiagClient);
+                             *TopDiags);
 
   std::vector<TransformFn>
     transforms = arcmt::getAllTransformations(origCI.getLangOpts()->getGC(),
                                  origCI.getMigratorOpts().NoFinalizeRemoval);
   assert(!transforms.empty());
 
   std::unique_ptr<PrintTransforms> transformPrinter;
   if (OutputTransformations)

tools/clang-rename/ClangRename.cpp

if (!ExportFixes.empty()) {
       return 0;
     }
 
     // Write every file to stdout. Right now we just barf the files without any
     // indication of which files start where, other than that we print the files
     // in the same order we see them.
     LangOptions DefaultLangOptions;
     IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
-    TextDiagnosticPrinter DiagnosticPrinter(errs(), &*DiagOpts);
-    DiagnosticsEngine Diagnostics(
-        IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
+    IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(new DiagnosticIDs());
+    TextDiagnosticPrinter DiagnosticPrinter(errs(), DiagIDs, &*DiagOpts);
+    DiagnosticsEngine Diagnostics(std::move(DiagIDs), &*DiagOpts,
                                   &DiagnosticPrinter, false);
     auto &FileMgr = Tool.getFiles();
     SourceManager Sources(Diagnostics, FileMgr);
     Rewriter Rewrite(Sources, DefaultLangOptions);
 
     Tool.applyAllReplacements(Rewrite);
     for (const auto &File : Files) {
       const auto *Entry = FileMgr.getFile(File);
       const auto ID = Sources.getOrCreateFileID(Entry, SrcMgr::C_User);
       Rewrite.getEditBuffer(ID).write(outs());
     }
   }
 
   return ExitCode;
 }

tools/diagtool/ListWarnings.cpp

for (const Entry &E : entries) {
     out << '\n';
   }
 }
 
 int ListWarnings::run(unsigned int argc, char **argv, llvm::raw_ostream &out) {
   std::vector<Entry> Flagged, Unflagged;
   llvm::StringMap<std::vector<unsigned> > flagHistogram;
 
+  DiagnosticIDs IDs;
+
   for (const DiagnosticRecord &DR : getBuiltinDiagnosticsByName()) {
     const unsigned diagID = DR.DiagID;
 
-    if (DiagnosticIDs::isBuiltinNote(diagID))
+    if (IDs.isBuiltinNote(diagID))
       continue;
 
-    if (!DiagnosticIDs::isBuiltinWarningOrExtension(diagID))
+    if (!IDs.isBuiltinWarningOrExtension(diagID))
       continue;
 
-    Entry entry(DR.getName(), DiagnosticIDs::getWarningOptionForDiag(diagID));
+    Entry entry(DR.getName(), IDs.getWarningOptionForDiag(diagID));
 
     if (entry.Flag.empty())
       Unflagged.push_back(entry);
     else {
       Flagged.push_back(entry);
       flagHistogram[entry.Flag].push_back(diagID);
     }
   }

tools/diagtool/ShowEnabledWarnings.cpp

static char getCharForLevel(DiagnosticsEngine::Level Level) {
   case DiagnosticsEngine::Error:   return 'E';
   case DiagnosticsEngine::Fatal:   return 'F';
   }
 
   llvm_unreachable("Unknown diagnostic level");
 }
 
 static IntrusiveRefCntPtr<DiagnosticsEngine>
-createDiagnostics(unsigned int argc, char **argv) {
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(new DiagnosticIDs());
-
+createDiagnostics(unsigned int argc, char **argv,
+                  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs) {
   // Buffer diagnostics from argument parsing so that we can output them using a
   // well formed diagnostic object.
   TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
   IntrusiveRefCntPtr<DiagnosticsEngine> InterimDiags(
     new DiagnosticsEngine(DiagIDs, new DiagnosticOptions(), DiagsBuffer));
 
   // Try to build a CompilerInvocation.
   SmallVector<const char *, 4> Args;
if (FirstArg.equals("--no-levels")) {
       ++argv;
     } else if (FirstArg.equals("--levels")) {
       ShouldShowLevels = true;
       --argc;
       ++argv;
     }
   }
 
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(new DiagnosticIDs());
+
   // Create the diagnostic engine.
-  IntrusiveRefCntPtr<DiagnosticsEngine> Diags = createDiagnostics(argc, argv);
+  IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
+      createDiagnostics(argc, argv, DiagIDs);
   if (!Diags) {
     printUsage();
     return EXIT_FAILURE;
   }
 
   // Now we have our diagnostics. Iterate through EVERY diagnostic and see
   // which ones are turned on.
   // FIXME: It would be very nice to print which flags are turning on which
   // diagnostics, but this can be done with a diff.
   std::vector<PrettyDiag> Active;
 
   for (const DiagnosticRecord &DR : getBuiltinDiagnosticsByName()) {
     unsigned DiagID = DR.DiagID;
 
-    if (DiagnosticIDs::isBuiltinNote(DiagID))
+    if (DiagIDs->isBuiltinNote(DiagID))
       continue;
 
-    if (!DiagnosticIDs::isBuiltinWarningOrExtension(DiagID))
+    if (!DiagIDs->isBuiltinWarningOrExtension(DiagID))
       continue;
 
     DiagnosticsEngine::Level DiagLevel =
       Diags->getDiagnosticLevel(DiagID, SourceLocation());
     if (DiagLevel == DiagnosticsEngine::Ignored)
       continue;
 
-    StringRef WarningOpt = DiagnosticIDs::getWarningOptionForDiag(DiagID);
+    StringRef WarningOpt = DiagIDs->getWarningOptionForDiag(DiagID);
     Active.push_back(PrettyDiag(DR.getName(), WarningOpt, DiagLevel));
   }
 
   // Print them all out.
   for (const PrettyDiag &PD : Active) {
     if (ShouldShowLevels)
       Out << getCharForLevel(PD.Level) << "  ";
     Out << PD.Name;
     if (!PD.Flag.empty())
       Out << " [-W" << PD.Flag << "]";
     Out << '\n';
   }
 
   return EXIT_SUCCESS;
 }

tools/driver/cc1_main.cpp

 //===-- cc1_main.cpp - Clang CC1 Compiler Frontend ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the entry point to the clang -cc1 functionality, which implements the
 // core compiler functionality along with a number of additional tools for
 // demonstration and testing purposes.
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Option/Arg.h"
+#include "clang/Basic/AllDiagnostics.h"
 #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/TextDiagnosticBuffer.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/FrontendTool/Utils.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/LinkAllPasses.h"
+#include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Timer.h"
static void ensureSufficientStack() {
   // We should now have a stack of size at least kSufficientStack. Ensure
   // that we can actually use that much, if necessary.
   ensureStackAddressSpace();
 }
 #else
 static void ensureSufficientStack() {}
 #endif
 
+static const DiagnosticIDs::DiagInfoRec StaticDiagInfo[] = {
+#define DIAG(ENUM, CLASS, DEFAULT_SEVERITY, DESC, GROUP, SFINAE, NOWERROR,     \
+             SHOWINSYSHEADER, CATEGORY)                                        \
+  {diag::ENUM,                                                                 \
+   DEFAULT_SEVERITY,                                                           \
+   DiagnosticIDs::CLASS,                                                       \
+   DiagnosticIDs::SFINAE,                                                      \
+   NOWERROR,                                                                   \
+   SHOWINSYSHEADER,                                                            \
+   CATEGORY,                                                                   \
+   GROUP,                                                                      \
+   STR_SIZE(DESC, uint16_t),                                                   \
+   DESC},
+#include "clang/Basic/DiagnosticCommonKinds.inc"
+
+#include "clang/Basic/DiagnosticDriverKinds.inc"
+
+#include "clang/Basic/DiagnosticFrontendKinds.inc"
+
+#include "clang/Basic/DiagnosticSerializationKinds.inc"
+
+#include "clang/Basic/DiagnosticLexKinds.inc"
+
+#include "clang/Basic/DiagnosticParseKinds.inc"
+
+#include "clang/Basic/DiagnosticASTKinds.inc"
+
+#include "clang/Basic/DiagnosticCommentKinds.inc"
+
+#include "clang/Basic/DiagnosticCrossTUKinds.inc"
+
+#include "clang/Basic/DiagnosticSemaKinds.inc"
+
+#include "clang/Basic/DiagnosticAnalysisKinds.inc"
+
+#include "clang/Basic/DiagnosticRefactoringKinds.inc"
+#undef DIAG
+};
+
+/// GetDiagInfo - Return the StaticDiagInfoRec entry for the specified DiagID,
+/// or null if the ID is invalid.
+static const DiagnosticIDs::DiagInfoRec *GetDiagInfo(unsigned DiagID) {
+  // Out of bounds diag. Can't be in the table.
+  using namespace diag;
+  if (DiagID >= DIAG_UPPER_LIMIT || DiagID <= DIAG_START_COMMON)
+    return nullptr;
+
+  // Compute the index of the requested diagnostic in the static table.
+  // 1. Add the number of diagnostics in each category preceding the
+  //    diagnostic and of the category the diagnostic is in. This gives us
+  //    the offset of the category in the table.
+  // 2. Subtract the number of IDs in each category from our ID. This gives us
+  //    the offset of the diagnostic in the category.
+  // This is cheaper than a binary search on the table as it doesn't touch
+  // memory at all.
+  unsigned Offset = 0;
+  unsigned ID = DiagID - DIAG_START_COMMON - 1;
+#define CATEGORY(NAME, PREV)                                                   \
+  if (DiagID > DIAG_START_##NAME) {                                            \
+    Offset += NUM_BUILTIN_##PREV##_DIAGNOSTICS - DIAG_START_##PREV - 1;        \
+    ID -= DIAG_START_##NAME - DIAG_START_##PREV;                               \
+  }
+  CATEGORY(DRIVER, COMMON)
+  CATEGORY(FRONTEND, DRIVER)
+  CATEGORY(SERIALIZATION, FRONTEND)
+  CATEGORY(LEX, SERIALIZATION)
+  CATEGORY(PARSE, LEX)
+  CATEGORY(AST, PARSE)
+  CATEGORY(COMMENT, AST)
+  CATEGORY(CROSSTU, COMMENT)
+  CATEGORY(SEMA, CROSSTU)
+  CATEGORY(ANALYSIS, SEMA)
+  CATEGORY(REFACTORING, ANALYSIS)
+#undef CATEGORY
+
+  auto DiagInfoArr = llvm::makeArrayRef(StaticDiagInfo);
+
+  // Avoid out of bounds reads.
+  if (ID + Offset >= DiagInfoArr.size())
+    return nullptr;
+
+  assert(ID < DiagInfoArr.size() && Offset < DiagInfoArr.size());
+
+  const auto *Found = &DiagInfoArr[ID + Offset];
+  // If the diag id doesn't match we found a different diag, abort. This can
+  // happen when this function is called with an ID that points into a hole in
+  // the diagID space.
+  if (Found->DiagID != DiagID)
+    return nullptr;
+  return Found;
+}
+
 int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   ensureSufficientStack();
 
   std::unique_ptr<CompilerInstance> Clang(new CompilerInstance());
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID =
+      new DiagnosticIDs(StaticDiagInfo, &GetDiagInfo);
 
   // Register the support for object-file-wrapped Clang modules.
   auto PCHOps = Clang->getPCHContainerOperations();
   PCHOps->registerWriter(llvm::make_unique<ObjectFilePCHContainerWriter>());
   PCHOps->registerReader(llvm::make_unique<ObjectFilePCHContainerReader>());
 
   // Initialize targets first, so that --version shows registered targets.
   llvm::InitializeAllTargets();

tools/driver/cc1as_main.cpp

 int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   // Initialize targets and assembly printers/parsers.
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllAsmParsers();
 
   // Construct our diagnostic client.
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
-  TextDiagnosticPrinter *DiagClient
-    = new TextDiagnosticPrinter(errs(), &*DiagOpts);
-  DiagClient->setPrefix("clang -cc1as");
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  TextDiagnosticPrinter *DiagClient =
+      new TextDiagnosticPrinter(errs(), DiagID, &*DiagOpts);
+  DiagClient->setPrefix("clang -cc1as");
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
 
   // Set an error handler, so that any LLVM backend diagnostics go through our
   // error handler.
   ScopedFatalErrorHandler FatalErrorHandler
     (LLVMErrorHandler, static_cast<void*>(&Diags));
 
   // Parse the arguments.

tools/driver/driver.cpp

if (const char *OverrideStr = ::getenv("CCC_OVERRIDE_OPTIONS")) {
     ApplyQAOverride(argv, OverrideStr, SavedStrings);
   }
 
   std::string Path = GetExecutablePath(argv[0], CanonicalPrefixes);
 
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts =
       CreateAndPopulateDiagOpts(argv);
 
-  TextDiagnosticPrinter *DiagClient
-    = new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
-  FixupDiagPrefixExeName(DiagClient, Path);
-
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
 
+  TextDiagnosticPrinter *DiagClient =
+      new TextDiagnosticPrinter(llvm::errs(), DiagID, &*DiagOpts);
+  FixupDiagPrefixExeName(DiagClient, Path);
+
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
 
   if (!DiagOpts->DiagnosticSerializationFile.empty()) {
-    auto SerializedConsumer =
-        clang::serialized_diags::create(DiagOpts->DiagnosticSerializationFile,
-                                        &*DiagOpts, /*MergeChildRecords=*/true);
+    auto SerializedConsumer = clang::serialized_diags::create(
+        DiagOpts->DiagnosticSerializationFile, &*DiagOpts, DiagID,
+        /*MergeChildRecords=*/true);
     Diags.setClient(new ChainedDiagnosticConsumer(
         Diags.takeClient(), std::move(SerializedConsumer)));
   }
 
   ProcessWarningOptions(Diags, *DiagOpts, /*ReportDiags=*/false);
 
   Driver TheDriver(Path, llvm::sys::getDefaultTargetTriple(), Diags);
   SetInstallDir(argv, TheDriver, CanonicalPrefixes);

tools/libclang/ARCMigrate.cpp

if (Logging) {
       llvm::errs() << "Error by clang_getRemappings(\"" << migrate_dir_path
                    << "\")\n";
       llvm::errs() << "\"" << migrate_dir_path << "\" does not exist\n";
     }
     return nullptr;
   }
 
   TextDiagnosticBuffer diagBuffer;
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs = new DiagnosticIDs(true);
   std::unique_ptr<Remap> remap(new Remap());
 
-  bool err = arcmt::getFileRemappings(remap->Vec, migrate_dir_path,&diagBuffer);
+  bool err = arcmt::getFileRemappings(remap->Vec, migrate_dir_path, &diagBuffer,
+                                      DiagIDs);
 
   if (err) {
     if (Logging) {
       llvm::errs() << "Error by clang_getRemappings(\"" << migrate_dir_path
                    << "\")\n";
       for (TextDiagnosticBuffer::const_iterator
              I = diagBuffer.err_begin(), E = diagBuffer.err_end(); I != E; ++I)
         llvm::errs() << I->second << '\n';

tools/libclang/CIndex.cpp

CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx,
   return D;
 }
 
 bool cxtu::isASTReadError(ASTUnit *AU) {
   for (ASTUnit::stored_diag_iterator D = AU->stored_diag_begin(),
                                      DEnd = AU->stored_diag_end();
        D != DEnd; ++D) {
     if (D->getLevel() >= DiagnosticsEngine::Error &&
-        DiagnosticIDs::getCategoryNumberForDiag(D->getID()) ==
-            diag::DiagCat_AST_Deserialization_Issue)
+        AU->getDiagnostics().getDiagnosticIDs()->getCategoryNumberForDiag(
+            D->getID()) == diag::DiagCat_AST_Deserialization_Issue)
       return true;
   }
   return false;
 }
 
 cxtu::CXTUOwner::~CXTUOwner() {
   if (TU)
     clang_disposeTranslationUnit(TU);

tools/libclang/CIndexDiagnostic.cpp

 unsigned clang_getDiagnosticCategory(CXDiagnostic Diag) {
   if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
     return D->getCategory();
   return 0;
 }
   
 CXString clang_getDiagnosticCategoryName(unsigned Category) {
   // Kept for backward compatibility.
-  return cxstring::createRef(DiagnosticIDs::getCategoryNameFromID(Category));
+  return cxstring::createRef(DiagnosticIDs().getCategoryNameFromID(Category));
 }
   
 CXString clang_getDiagnosticCategoryText(CXDiagnostic Diag) {
   if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
     return D->getCategoryText();
   return cxstring::createEmpty();
 }
   

tools/libclang/CXStoredDiagnostic.cpp

 }
 
 CXString CXStoredDiagnostic::getSpelling() const {
   return cxstring::createRef(Diag.getMessage());
 }
 
 CXString CXStoredDiagnostic::getDiagnosticOption(CXString *Disable) const {
   unsigned ID = Diag.getID();
-  StringRef Option = DiagnosticIDs::getWarningOptionForDiag(ID);
+  StringRef Option = DiagnosticIDs().getWarningOptionForDiag(ID);
   if (!Option.empty()) {
     if (Disable)
       *Disable = cxstring::createDup((Twine("-Wno-") + Option).str());
     return cxstring::createDup((Twine("-W") + Option).str());
   }
   
   if (ID == diag::fatal_too_many_errors) {
     if (Disable)
       *Disable = cxstring::createRef("-ferror-limit=0");
     return cxstring::createRef("-ferror-limit=");
   }
 
   return cxstring::createEmpty();
 }
 
 unsigned CXStoredDiagnostic::getCategory() const {
-  return DiagnosticIDs::getCategoryNumberForDiag(Diag.getID());
+  return DiagnosticIDs().getCategoryNumberForDiag(Diag.getID());
 }
 
 CXString CXStoredDiagnostic::getCategoryText() const {
-  unsigned catID = DiagnosticIDs::getCategoryNumberForDiag(Diag.getID());
-  return cxstring::createRef(DiagnosticIDs::getCategoryNameFromID(catID));
+  DiagnosticIDs IDs;
+  unsigned catID = IDs.getCategoryNumberForDiag(Diag.getID());
+  return cxstring::createRef(IDs.getCategoryNameFromID(catID));
 }
 
 unsigned CXStoredDiagnostic::getNumRanges() const {
   if (Diag.getLocation().isInvalid())
     return 0;
   
   return Diag.range_size();
 }

unittests/CrossTU/CrossTranslationUnitTest.cpp

void HandleTranslationUnit(ASTContext &Ctx) {
 
     std::unique_ptr<ASTUnit> ASTWithDefinition =
         tooling::buildASTFromCode(SourceText, SourceFileName);
     ASTWithDefinition->Save(ASTFileName.str());
     EXPECT_TRUE(llvm::sys::fs::exists(ASTFileName));
 
     // Load the definition from the AST file.
     llvm::Expected<const FunctionDecl *> NewFDorError =
-        CTU.getCrossTUDefinition(FD, "", IndexFileName);
+        CTU.getCrossTUDefinition(
+            FD, "", IndexFileName,
+            CTU.getCompilerInstance().getDiagnostics().getDiagnosticIDs());
     EXPECT_TRUE((bool)NewFDorError);
     const FunctionDecl *NewFD = *NewFDorError;
 
     *Success = NewFD && NewFD->hasBody() && !OrigFDHasBody;
   }
 
 private:
   CrossTranslationUnitContext CTU;

unittests/Tooling/RewriterTestContext.h

 /// of a Rewriter with default values for testing and provides convenience
 /// methods, which help with writing tests that change files.
 class RewriterTestContext {
  public:
    RewriterTestContext()
        : DiagOpts(new DiagnosticOptions()),
          Diagnostics(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
                      &*DiagOpts),
-         DiagnosticPrinter(llvm::outs(), &*DiagOpts),
+         DiagnosticPrinter(llvm::outs(), Diagnostics.getDiagnosticIDs(),
+                           &*DiagOpts),
          InMemoryFileSystem(new vfs::InMemoryFileSystem),
          OverlayFileSystem(
              new vfs::OverlayFileSystem(vfs::getRealFileSystem())),
          Files(FileSystemOptions(), OverlayFileSystem),
          Sources(Diagnostics, Files), Rewrite(Sources, Options) {
      Diagnostics.setClient(&DiagnosticPrinter, false);
      // FIXME: To make these tests truly in-memory, we need to overlay the
      // builtin headers.
      OverlayFileSystem->pushOverlay(InMemoryFileSystem);
   }
 
   ~RewriterTestContext() {}
 
   FileID createInMemoryFile(StringRef Name, StringRef Content) {
     std::unique_ptr<llvm::MemoryBuffer> Source =
         llvm::MemoryBuffer::getMemBuffer(Content);
     InMemoryFileSystem->addFile(Name, 0, std::move(Source));