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

172–262

The best home for this is probably the FrontendTool library.

[craig.topper]

lib/Basic/DiagnosticIDs.cpp

27–28

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

73

Did this static_assert stuff get lost?

tools/driver/cc1_main.cpp

211

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?

examples/clang-interpreter/CMakeLists.txt

add_dependencies(clang-interpreter
   )
 
 target_link_libraries(clang-interpreter
   PRIVATE
   clangBasic
   clangCodeGen
   clangDriver
   clangFrontend
+  clangFrontendTool
   )
 
 export_executable_symbols(clang-interpreter)
 
 if (MSVC)
   # Is this a CMake bug that even with export_executable_symbols, Windows
   # needs to explictly export the type_info vtable
   set_property(TARGET clang-interpreter

examples/clang-interpreter/main.cpp

 //===-- examples/clang-interpreter/main.cpp - Clang C Interpreter Example -===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Invoke.h"
 #include "Manager.h"
 
-#include "clang/CodeGen/CodeGenAction.h"
 #include "clang/Basic/DiagnosticOptions.h"
+#include "clang/CodeGen/CodeGenAction.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/MCJIT.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"

 } // namespace interpreter
 
 int main(int argc, const char **argv, char * const *envp) {
   // This just needs to be some symbol in the binary; C++ doesn't
   // allow taking the address of ::main however.
   void *MainAddr = (void*) (intptr_t) interpreter::GetExecutablePath;
   std::string Path = interpreter::GetExecutablePath(argv[0], MainAddr);
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID =
+      AllDiagnostics();
   TextDiagnosticPrinter *DiagClient =
-    new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
+      new TextDiagnosticPrinter(llvm::errs(), DiagID, &*DiagOpts);
 
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
 
   const std::string TripleStr = llvm::sys::getProcessTriple();
   llvm::Triple T(TripleStr);
 
   // Use ELF on Windows-32 and MingW for now.
 #ifndef CLANG_INTERPRETER_COFF_FORMAT
   if (T.isOSBinFormatCOFF())
#endif
 
   // FIXME: This is copied from cc1_main.cpp; simplify and eliminate.
 
   // Create a compiler instance to handle the actual work.
   CompilerInstance Clang;
   Clang.setInvocation(std::move(CI));
 
   // Create the compilers actual diagnostics engine.
-  Clang.createDiagnostics();
+  Clang.createDiagnostics(DiagID);
   if (!Clang.hasDiagnostics())
     return 1;
 
   // Infer the builtin include path if unspecified.
   if (Clang.getHeaderSearchOpts().UseBuiltinIncludes &&
       Clang.getHeaderSearchOpts().ResourceDir.empty())
     Clang.getHeaderSearchOpts().ResourceDir =
       CompilerInvocation::GetResourcesPath(argv[0], MainAddr);

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/Diagnostic.h

public:
     void setMapping(diag::kind Diag, DiagnosticMapping Info) {
       DiagMap[Diag] = Info;
     }
 
     DiagnosticMapping lookupMapping(diag::kind Diag) const {
       return DiagMap.lookup(Diag);
     }
 
-    DiagnosticMapping &getOrAddMapping(diag::kind Diag);
+    DiagnosticMapping &getOrAddMapping(diag::kind Diag,
+                                       const DiagnosticIDs &IDs);
 
     const_iterator begin() const { return DiagMap.begin(); }
     const_iterator end() const { return DiagMap.end(); }
   };
 
   /// \brief Keeps and automatically disposes all DiagStates that we create.
   std::list<DiagState> DiagStates;
 

include/clang/Basic/DiagnosticCommonKinds.td

 def err_seh___except_filter : Error<
   "%0 only allowed in __except filter expression">;
 def err_seh___finally_block : Error<
   "%0 only allowed in __finally block">;
 
 // Sema && AST
 def note_invalid_subexpr_in_const_expr : Note<
   "subexpression not valid in a constant expression">;
+def err_unavailable : Error<"%0 is unavailable">;
+def err_unavailable_message : Error<"%0 is unavailable: %1">;
 
 // Targets
 
 def err_target_unknown_triple : Error<
   "unknown target triple '%0', please use -triple or -arch">;
 def err_target_unknown_cpu : Error<"unknown target CPU '%0'">;
 def note_valid_options : Note<"valid target CPU values are: %0">;
 def err_target_unsupported_cpu_for_micromips : Error<

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; }
+  };
+
+  struct WarningOption {
+    uint16_t NameOffset;
+    uint16_t Members;
+    uint16_t SubGroups;
+
+    // String is stored with a pascal-style length byte.
+    StringRef getName(const char *DiagGroupNames) const {
+      return StringRef(DiagGroupNames + NameOffset + 1,
+                       DiagGroupNames[NameOffset]);
+    }
+  };
+
+  struct CategoryRec {
+    const char *NameStr;
+    uint8_t NameLen;
+
+    StringRef getName() const { return StringRef(NameStr, NameLen); }
+  };
+
 private:
   /// \brief Information for uniquing and looking up custom diags.
-  diag::CustomDiagInfo *CustomDiagInfo;
+  diag::CustomDiagInfo *CustomDiagInfo = nullptr;
+  ArrayRef<DiagInfoRec> DiagInfo;
+  const char *DiagGroupNames;
+  ArrayRef<CategoryRec> CategoryNameTable;
+
+  ArrayRef<WarningOption> OptionTable;
+  const int16_t *XDiagArrays;
+  const int16_t *XDiagSubGroups;
+
+  std::function<const DiagInfoRec *(unsigned)> GetDiagInfo;
 
 public:
-  DiagnosticIDs();
+  DiagnosticIDs(ArrayRef<DiagInfoRec> DiagInfo, const char *DiagGroupNames,
+                ArrayRef<CategoryRec> CategoryNameTable,
+                ArrayRef<WarningOption> OptionTable, const int16_t *XDiagArrays,
+                const int16_t *XDiagSubGroups,
+                std::function<const DiagInfoRec *(unsigned)> 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,
-                                std::vector<diag::kind> &Diags);
+  void getAllDiagnostics(diag::Flavor Flavor, std::vector<diag::kind> &Diags);
 
   /// \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.
   ///
private:
   /// \brief Used to emit a diagnostic that is finally fully formed,
   /// ignoring suppression.
   void EmitDiag(DiagnosticsEngine &Diag, Level DiagLevel) const;
 
   /// \brief Whether the diagnostic may leave the AST in a state where some
   /// invariants can break.
   bool isUnrecoverable(unsigned DiagID) const;
 
+  DiagnosticMapping GetDefaultDiagMapping(unsigned DiagID) const;
+  unsigned getBuiltinDiagClass(unsigned DiagID) const;
+
   friend class DiagnosticsEngine;
 };
 
 }  // end namespace clang
 
 #endif

include/clang/Basic/DiagnosticSemaKinds.td

def warn_deprecated_fwdclass_message : Warning<
     "%0 may be deprecated because the receiver type is unknown">,
     InGroup<DeprecatedDeclarations>;
 def warn_deprecated_def : Warning<
   "implementing deprecated %select{method|class|category}0">,
   InGroup<DeprecatedImplementations>, DefaultIgnore;
 def warn_unavailable_def : Warning<
   "implementing unavailable method">,
   InGroup<DeprecatedImplementations>, DefaultIgnore;
-def err_unavailable : Error<"%0 is unavailable">;
 def err_property_method_unavailable :
     Error<"property access is using %0 method which is unavailable">;
-def err_unavailable_message : Error<"%0 is unavailable: %1">;
 def warn_unavailable_fwdclass_message : Warning<
     "%0 may be unavailable because the receiver type is unknown">,
     InGroup<UnavailableDeclarations>;
 def note_availability_specified_here : Note<
   "%0 has been explicitly marked "
   "%select{unavailable|deleted|deprecated|partial}1 here">;
 def note_implicitly_deleted : Note<
   "explicitly defaulted function was implicitly deleted here">;

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/CompilerInstance.h

public:
   /// allocating one if one is not provided.
   ///
   /// \param Client If non-NULL, a diagnostic client that will be
   /// attached to (and, then, owned by) the DiagnosticsEngine inside this AST
   /// unit.
   ///
   /// \param ShouldOwnClient If Client is non-NULL, specifies whether 
   /// the diagnostic object should take ownership of the client.
-  void createDiagnostics(DiagnosticConsumer *Client = nullptr,
+  void createDiagnostics(IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs,
+                         DiagnosticConsumer *Client = nullptr,
                          bool ShouldOwnClient = true);
 
   /// Create a DiagnosticsEngine object with a the TextDiagnosticPrinter.
   ///
   /// If no diagnostic client is provided, this creates a
   /// DiagnosticConsumer that is owned by the returned diagnostic
   /// object, if using directly the caller is responsible for
   /// releasing the returned DiagnosticsEngine's client eventually.
   ///
   /// \param Opts - The diagnostic options; note that the created text
   /// diagnostic object contains a reference to these options.
   ///
   /// \param Client If non-NULL, a diagnostic client that will be
   /// attached to (and, then, owned by) the returned DiagnosticsEngine
   /// object.
   ///
   /// \param CodeGenOpts If non-NULL, the code gen options in use, which may be
   /// used by some diagnostics printers (for logging purposes only).
   ///
   /// \return The new object on success, or null on failure.
-  static IntrusiveRefCntPtr<DiagnosticsEngine>
-  createDiagnostics(DiagnosticOptions *Opts,
-                    DiagnosticConsumer *Client = nullptr,
-                    bool ShouldOwnClient = true,
-                    const CodeGenOptions *CodeGenOpts = nullptr);
+  static IntrusiveRefCntPtr<DiagnosticsEngine> createDiagnostics(
+      IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs, DiagnosticOptions *Optns,
+      DiagnosticConsumer *Client = nullptr, bool ShouldOwnClient = true,
 
   /// Create the file manager and replace any existing one with it.
   ///
   /// \return The new file manager on success, or null on failure.
   FileManager *createFileManager();
 
   /// Create the source manager and replace any existing one with it.
   void createSourceManager(FileManager &FileMgr);

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

include/clang/Frontend/Utils.h

createChainedIncludesSource(CompilerInstance &CI,
                             IntrusiveRefCntPtr<ExternalSemaSource> &Reader);
 
 /// createInvocationFromCommandLine - Construct a compiler invocation object for
 /// a command line argument vector.
 ///
 /// \return A CompilerInvocation, or 0 if none was built for the given
 /// argument vector.
 std::unique_ptr<CompilerInvocation> createInvocationFromCommandLine(
-    ArrayRef<const char *> Args,
-    IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
-        IntrusiveRefCntPtr<DiagnosticsEngine>(),
+    ArrayRef<const char *> Args, IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
     IntrusiveRefCntPtr<vfs::FileSystem> VFS = nullptr);
 
 /// Return the value of the last argument as an integer, or a default. If Diags
 /// is non-null, emits an error if the argument is given, but non-integral.
 int getLastArgIntValue(const llvm::opt::ArgList &Args,
                        llvm::opt::OptSpecifier Id, int Default,
                        DiagnosticsEngine *Diags = nullptr);
 

include/clang/FrontendTool/AllDiagnostics.h

 //===--- AllDiagnostics.h - Aggregate Diagnostic headers --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Includes all the separate Diagnostic headers & some related helpers.
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_BASIC_ALLDIAGNOSTICS_H
-#define LLVM_CLANG_BASIC_ALLDIAGNOSTICS_H
+#ifndef LLVM_CLANG_FRONTENDTOOL_ALLDIAGNOSTICS_H
+#define LLVM_CLANG_FRONTENDTOOL_ALLDIAGNOSTICS_H
 
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/CommentDiagnostic.h"
 #include "clang/Analysis/AnalysisDiagnostic.h"
 #include "clang/CrossTU/CrossTUDiagnostic.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Lex/LexDiagnostic.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "clang/Serialization/SerializationDiagnostic.h"
 #include "clang/Tooling/Refactoring/RefactoringDiagnostic.h"
 
 namespace clang {
 template <size_t SizeOfStr, typename FieldType>
 class StringSizerHelper {
   static_assert(SizeOfStr <= FieldType(~0U), "Field too small!");
 public:
   enum { Size = SizeOfStr };
 };
-} // end namespace clang 
+} // end namespace clang
 
-#define STR_SIZE(str, fieldTy) clang::StringSizerHelper<sizeof(str)-1, \
-                                                        fieldTy>::Size 
+#define STR_SIZE(str, fieldTy)                                                 \
+  clang::StringSizerHelper<sizeof(str) - 1, fieldTy>::Size
 
 #endif

include/clang/FrontendTool/DiagnosticTable.h

+#include "clang/Basic/DiagnosticIDs.h"
+
+namespace clang {
+DiagnosticIDs *AllDiagnostics();
+// const DiagnosticIDs::DiagInfoRec *GetDiagInfo(unsigned DiagID);
+// ArrayRef<DiagnosticIDs::DiagInfoRec> GetDiagInfoTable();
+}

include/clang/module.modulemap

 module Clang_CodeGen { requires cplusplus umbrella "CodeGen" module * { export * } }
 module Clang_Config { requires cplusplus umbrella "Config" module * { export * } }
 
 // Files for diagnostic groups are spread all over the include/clang/ tree, but
 // logically form a single module.
 module Clang_Diagnostics {
   requires cplusplus
 
-  module All { header "Basic/AllDiagnostics.h" export * }
+  module All { header "FrontendTool/AllDiagnostics.h" export * }
   module Analysis { header "Analysis/AnalysisDiagnostic.h" export * }
   module AST { header "AST/ASTDiagnostic.h" export * }
   module Comment { header "AST/CommentDiagnostic.h" export * }
   module Driver { header "Driver/DriverDiagnostic.h" export * }
   module Frontend { header "Frontend/FrontendDiagnostic.h" export * }
   module Lex { header "Lex/LexDiagnostic.h" export * }
   module Parse { header "Parse/ParseDiagnostic.h" export * }
   module Sema { header "Sema/SemaDiagnostic.h" export * }

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

 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Edit/Commit.h"
 #include "clang/Edit/EditedSource.h"
 #include "clang/Edit/EditsReceiver.h"
 #include "clang/Edit/Rewriters.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/MultiplexConsumer.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/PPConditionalDirectiveRecord.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/StaticAnalyzer/Checkers/ObjCRetainCount.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
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 = AllDiagnostics();
   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

for (DiagStatePoint &Transition : File.StateTransitions) {
         llvm::errs() << ": state " << Transition.State << ":\n";
       };
 
       if (DiagName.empty())
         PrintInnerHeading();
 
       for (auto &Mapping : *Transition.State) {
         StringRef Option =
-            DiagnosticIDs::getWarningOptionForDiag(Mapping.first);
+            SrcMgr.getDiagnostics().getDiagnosticIDs()->getWarningOptionForDiag(
+                Mapping.first);
         if (!DiagName.empty() && DiagName != Option)
           continue;
 
         PrintInnerHeading();
         llvm::errs() << "    ";
         if (Option.empty())
           llvm::errs() << "<unknown " << Mapping.first << ">";
         else
void DiagnosticsEngine::setSeverity(diag::kind Diag, diag::Severity Map,
   assert((Diags->isBuiltinWarningOrExtension(Diag) ||
           (Map == diag::Severity::Fatal || Map == diag::Severity::Error)) &&
          "Cannot map errors into warnings!");
   assert((L.isInvalid() || SourceMgr) && "No SourceMgr for valid location");
 
   // Don't allow a mapping to a warning override an error/fatal mapping.
   bool WasUpgradedFromWarning = false;
   if (Map == diag::Severity::Warning) {
-    DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag);
+    DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag, *Diags);
     if (Info.getSeverity() == diag::Severity::Error ||
         Info.getSeverity() == diag::Severity::Fatal) {
       Map = Info.getSeverity();
       WasUpgradedFromWarning = true;
     }
   }
   DiagnosticMapping Mapping = makeUserMapping(Map, L);
   Mapping.setUpgradedFromWarning(WasUpgradedFromWarning);
bool DiagnosticsEngine::setDiagnosticGroupWarningAsError(StringRef Group,
   // Get the diagnostics in this group.
   SmallVector<diag::kind, 8> GroupDiags;
   if (Diags->getDiagnosticsInGroup(diag::Flavor::WarningOrError, Group,
                                    GroupDiags))
     return true;
 
   // Perform the mapping change.
   for (diag::kind Diag : GroupDiags) {
-    DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag);
+    DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag, *Diags);
 
     if (Info.getSeverity() == diag::Severity::Error ||
         Info.getSeverity() == diag::Severity::Fatal)
       Info.setSeverity(diag::Severity::Warning);
 
     Info.setNoWarningAsError(true);
   }
 
bool DiagnosticsEngine::setDiagnosticGroupErrorAsFatal(StringRef Group,
   // Get the diagnostics in this group.
   SmallVector<diag::kind, 8> GroupDiags;
   if (Diags->getDiagnosticsInGroup(diag::Flavor::WarningOrError, Group,
                                    GroupDiags))
     return true;
 
   // Perform the mapping change.
   for (diag::kind Diag : GroupDiags) {
-    DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag);
+    DiagnosticMapping &Info = GetCurDiagState()->getOrAddMapping(Diag, *Diags);
 
     if (Info.getSeverity() == diag::Severity::Fatal)
       Info.setSeverity(diag::Severity::Error);
 
     Info.setNoErrorAsFatal(true);
   }
 
   return false;
 }
 
 void DiagnosticsEngine::setSeverityForAll(diag::Flavor Flavor,
                                           diag::Severity Map,
                                           SourceLocation Loc) {
   // Get all the diagnostics.
   std::vector<diag::kind> 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

 //===--- DiagnosticIDs.cpp - Diagnostic IDs Handling ----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements the Diagnostic IDs-related interfaces.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/DiagnosticIDs.h"
-#include "clang/Basic/AllDiagnostics.h"
+#include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticCategories.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #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[] = {
-#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       \
-  }                                                                            \
-  ,
-#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);
+DiagnosticIDs::DiagnosticIDs(
+    ArrayRef<DiagInfoRec> DiagInfo, const char *DiagGroupNames,
+    ArrayRef<CategoryRec> CategoryNameTable,
+    ArrayRef<WarningOption> OptionTable, const int16_t *XDiagArrays,
+    const int16_t *XDiagSubGroups,
+    std::function<const DiagInfoRec *(unsigned)> GetDiagInfo)
+    : DiagInfo(DiagInfo), DiagGroupNames(DiagGroupNames),
+      CategoryNameTable(CategoryNameTable), OptionTable(OptionTable),
+      XDiagArrays(XDiagArrays), XDiagSubGroups(XDiagSubGroups),
+      GetDiagInfo(std::move(GetDiagInfo)) {}
 
-/// GetDiagInfo - Return the StaticDiagInfoRec entry for the specified DiagID,
-/// or null if the ID is invalid.
-static const StaticDiagInfoRec *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
-
-  // Avoid out of bounds reads.
-  if (ID + Offset >= StaticDiagInfoSize)
-    return nullptr;
-
-  assert(ID < StaticDiagInfoSize && Offset < StaticDiagInfoSize);
-
-  const StaticDiagInfoRec *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 DiagnosticIDs::GetDefaultDiagMapping(unsigned DiagID) const {
   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;
     uint8_t NameLen;
 
     StringRef getName() const {
       return StringRef(NameStr, NameLen);
     }
   };
 }
 
 // Unfortunately, the split between DiagnosticIDs and Diagnostic is not
 // particularly clean, but for now we just implement this method here so we can
 // access GetDefaultDiagMapping.
 DiagnosticMapping &
-DiagnosticsEngine::DiagState::getOrAddMapping(diag::kind Diag) {
+DiagnosticsEngine::DiagState::getOrAddMapping(diag::kind Diag,
+                                              const DiagnosticIDs &IDs) {
   std::pair<iterator, bool> Result =
       DiagMap.insert(std::make_pair(Diag, DiagnosticMapping()));
 
   // Initialize the entry if we added it.
   if (Result.second)
-    Result.first->second = GetDefaultDiagMapping(Diag);
+    Result.first->second = IDs.GetDefaultDiagMapping(Diag);
 
   return Result.first->second;
 }
 
-static const StaticDiagCategoryRec CategoryNameTable[] = {
-#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() {
-  return llvm::array_lengthof(CategoryNameTable) - 1;
+unsigned DiagnosticIDs::getNumberOfCategories() const {
+  return CategoryNameTable.size();
 }
 
 /// 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))
+unsigned DiagnosticIDs::getBuiltinDiagClass(unsigned DiagID) const {
+  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() {
   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:
DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc,
   assert(getBuiltinDiagClass(DiagID) != CLASS_NOTE);
 
   // Specific non-error diagnostics may be mapped to various levels from ignored
   // to error.  Errors can only be mapped to fatal.
   diag::Severity Result = diag::Severity::Fatal;
 
   // Get the mapping information, or compute it lazily.
   DiagnosticsEngine::DiagState *State = Diag.GetDiagStateForLoc(Loc);
-  DiagnosticMapping &Mapping = State->getOrAddMapping((diag::kind)DiagID);
+  DiagnosticMapping &Mapping =
+      State->getOrAddMapping((diag::kind)DiagID, *this);
 
   // TODO: Can a null severity really get here?
   if (Mapping.getSeverity() != diag::Severity())
     Result = Mapping.getSeverity();
 
   // Upgrade ignored diagnostics if -Weverything is enabled.
   if (State->EnableAllWarnings && Result == diag::Severity::Ignored &&
       !Mapping.isUser() && getBuiltinDiagClass(DiagID) != CLASS_REMARK)
DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc,
   if (State->SuppressSystemWarnings && !ShowInSystemHeader && Loc.isValid() &&
       Diag.getSourceManager().isInSystemHeader(
           Diag.getSourceManager().getExpansionLoc(Loc)))
     return diag::Severity::Ignored;
 
   return Result;
 }
 
-#define GET_DIAG_ARRAYS
-#include "clang/Basic/DiagnosticGroups.inc"
-#undef GET_DIAG_ARRAYS
-
-namespace {
-  struct WarningOption {
-    uint16_t NameOffset;
-    uint16_t Members;
-    uint16_t SubGroups;
-
-    // String is stored with a pascal-style length byte.
-    StringRef getName() const {
-      return StringRef(DiagGroupNames + NameOffset + 1,
-                       DiagGroupNames[NameOffset]);
-    }
-  };
-}
-
-// Second the table of options, sorted by name for fast binary lookup.
-static const WarningOption OptionTable[] = {
-#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))
-    return OptionTable[Info->getOptionGroupIndex()].getName();
+StringRef DiagnosticIDs::getWarningOptionForDiag(unsigned DiagID) const {
+  if (const DiagInfoRec *Info = GetDiagInfo(DiagID))
+    return OptionTable[Info->getOptionGroupIndex()].getName(DiagGroupNames);
   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);
   }
 
   return Res;
 }
 
 /// Return \c true if any diagnostics were found in this group, even if they
 /// were filtered out due to having the wrong flavor.
-static bool getDiagnosticsInGroup(diag::Flavor Flavor,
-                                  const WarningOption *Group,
-                                  SmallVectorImpl<diag::kind> &Diags) {
+static bool getDiagnosticsInGroup(
+    diag::Flavor Flavor, const DiagnosticIDs::WarningOption *Group,
+    SmallVectorImpl<diag::kind> &Diags,
+    llvm::function_ref<const clang::DiagnosticIDs::DiagInfoRec *(unsigned)>
+        GetDiagInfo,
+    ArrayRef<DiagnosticIDs::WarningOption> OptionTable,
+    const int16_t *XDiagArrays, const int16_t *XDiagSubGroups) {
   // An empty group is considered to be a warning group: we have empty groups
   // for GCC compatibility, and GCC does not have remarks.
   if (!Group->Members && !Group->SubGroups)
     return Flavor == diag::Flavor::Remark;
 
   bool NotFound = true;
 
   // Add the members of the option diagnostic set.
-  const int16_t *Member = DiagArrays + Group->Members;
+  const int16_t *Member = XDiagArrays + Group->Members;
   for (; *Member != -1; ++Member) {
     if (GetDiagInfo(*Member)->getFlavor() == Flavor) {
       NotFound = false;
       Diags.push_back(*Member);
     }
   }
 
   // Add the members of the subgroups.
-  const int16_t *SubGroups = DiagSubGroups + Group->SubGroups;
+  const int16_t *SubGroups = XDiagSubGroups + Group->SubGroups;
   for (; *SubGroups != (int16_t)-1; ++SubGroups)
     NotFound &= getDiagnosticsInGroup(Flavor, &OptionTable[(short)*SubGroups],
-                                      Diags);
+                                      Diags, GetDiagInfo, OptionTable,
+                                      XDiagArrays, XDiagSubGroups);
 
   return NotFound;
 }
 
 bool
 DiagnosticIDs::getDiagnosticsInGroup(diag::Flavor Flavor, StringRef Group,
                                      SmallVectorImpl<diag::kind> &Diags) const {
-  auto Found = std::lower_bound(std::begin(OptionTable), std::end(OptionTable),
-                                Group,
-                                [](const WarningOption &LHS, StringRef RHS) {
-                                  return LHS.getName() < RHS;
-                                });
-  if (Found == std::end(OptionTable) || Found->getName() != Group)
+  auto Found =
+      std::lower_bound(std::begin(OptionTable), std::end(OptionTable), Group,
+                       [&](const WarningOption &LHS, StringRef RHS) {
+                         return LHS.getName(DiagGroupNames) < RHS;
+  if (Found == std::end(OptionTable) || Found->getName(DiagGroupNames) != Group)
     return true; // Option not found.
 
-  return ::getDiagnosticsInGroup(Flavor, Found, Diags);
+  return ::getDiagnosticsInGroup(Flavor, Found, Diags, GetDiagInfo, OptionTable,
+                                 XDiagArrays, XDiagSubGroups);
 }
 
 void DiagnosticIDs::getAllDiagnostics(diag::Flavor Flavor,
                                       std::vector<diag::kind> &Diags) {
-  for (unsigned i = 0; i != StaticDiagInfoSize; ++i)
-    if (StaticDiagInfo[i].getFlavor() == Flavor)
-      Diags.push_back(StaticDiagInfo[i].DiagID);
+  for (const auto &Diag : DiagInfo)
+    if (Diag.getFlavor() == Flavor)
+      Diags.push_back(Diag.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);
+    unsigned Distance =
+        O.getName(DiagGroupNames).edit_distance(Group, true, BestDistance);
     if (Distance > BestDistance)
       continue;
 
     // Don't suggest groups that are not of this kind.
     llvm::SmallVector<diag::kind, 8> Diags;
-    if (::getDiagnosticsInGroup(Flavor, &O, Diags) || Diags.empty())
+    if (::getDiagnosticsInGroup(Flavor, &O, Diags, GetDiagInfo, OptionTable,
+                                XDiagArrays, XDiagSubGroups) ||
+        Diags.empty())
       continue;
 
     if (Distance == BestDistance) {
       // Two matches with the same distance, don't prefer one over the other.
       Best = "";
     } else if (Distance < BestDistance) {
       // This is a better match.
-      Best = O.getName();
+      Best = O.getName(DiagGroupNames);
       BestDistance = Distance;
     }
   }
 
   return Best;
 }
 
 /// ProcessDiag - This is the method used to report a diagnostic that is
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

 // -Werror and -Wfatal-errors.
 //
 // Each warning option controls any number of actual warnings.
 // Given a warning option 'foo', the following are valid:
 //    -Wfoo, -Wno-foo, -Werror=foo, -Wfatal-errors=foo
 //
 // Remark options are also handled here, analogously, except that they are much
 // simpler because a remark can't be promoted to an error.
-#include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Frontend/FrontendDiagnostic.h"
 #include <algorithm>
 #include <cstring>
 #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 {
 
   // If configuration file was used, print its path.
   if (!ConfigFile.empty())
     OS << "Configuration file: " << ConfigFile << '\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 {
   if (PassedFlags == "")
     return;
   // Print out all options that start with a given argument. This is used for
   // shell autocompletion.
   std::vector<std::string> SuggestedCompletions;
if (SuggestedCompletions.empty()) {
     // 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(Cur, 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(Cur))
         SuggestedCompletions.push_back(S);
   }
 
   // Sort the autocomplete candidates so that shells print them out in a
   // deterministic order. We could sort in any way, but we chose
   // case-insensitive sorting for consistency with the -help option
   // which prints out options in the case-insensitive alphabetical order.
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/Format/CMakeLists.txt

add_clang_library(clangFormat
   UnwrappedLineFormatter.cpp
   UnwrappedLineParser.cpp
   UsingDeclarationsSorter.cpp
   WhitespaceManager.cpp
 
   LINK_LIBS
   clangBasic
   clangLex
+  clangFrontendTool
   clangToolingCore
   )

lib/Format/TokenAnalyzer.cpp

 #include "FormatTokenLexer.h"
 #include "TokenAnnotator.h"
 #include "UnwrappedLineParser.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Format/Format.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "format-formatter"
 
 namespace clang {
 namespace format {
 
Environment::CreateVirtualEnvironment(StringRef Code, StringRef FileName,
   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   // This is passed to `SM` as reference, so the pointer has to be referenced
   // in `Environment` so that `FileMgr` can out-live this function scope.
   std::unique_ptr<FileManager> FileMgr(
       new FileManager(FileSystemOptions(), InMemoryFileSystem));
   // This is passed to `SM` as reference, so the pointer has to be referenced
   // by `Environment` due to the same reason above.
-  std::unique_ptr<DiagnosticsEngine> Diagnostics(new DiagnosticsEngine(
-      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
-      new DiagnosticOptions));
+  std::unique_ptr<DiagnosticsEngine> Diagnostics(
+      new DiagnosticsEngine(AllDiagnostics(), new DiagnosticOptions));
   // This will be stored as reference, so the pointer has to be stored in
   // due to the same reason above.
   std::unique_ptr<SourceManager> VirtualSM(
       new SourceManager(*Diagnostics, *FileMgr));
   InMemoryFileSystem->addFile(
       FileName, 0,
       llvm::MemoryBuffer::getMemBuffer(Code, FileName,
                                        /*RequiresNullTerminator=*/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());
+    IntrusiveRefCntPtr<DiagnosticIDs> DiagID =
+        CI.getDiagnostics().getDiagnosticIDs();
+    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)));
   }
 }
 
-void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
-                                         bool ShouldOwnClient) {
-  Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
-                                  ShouldOwnClient, &getCodeGenOpts());
+void CompilerInstance::createDiagnostics(
+    IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs, DiagnosticConsumer *Client,
+  Diagnostics = createDiagnostics(std::move(DiagIDs), &getDiagnosticOpts(),
+                                  Client, ShouldOwnClient, &getCodeGenOpts());
 }
 
-IntrusiveRefCntPtr<DiagnosticsEngine>
-CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
-                                    DiagnosticConsumer *Client,
-                                    bool ShouldOwnClient,
-                                    const CodeGenOptions *CodeGenOpts) {
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
-  IntrusiveRefCntPtr<DiagnosticsEngine>
-      Diags(new DiagnosticsEngine(DiagID, Opts));
+IntrusiveRefCntPtr<DiagnosticsEngine> CompilerInstance::createDiagnostics(
+    IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs, DiagnosticOptions *Opts,
+    DiagnosticConsumer *Client, bool ShouldOwnClient,
+  IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
+      new DiagnosticsEngine(DiagIDs, 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(), std::move(DiagIDs), 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);

 
 /// \brief Compile a module file for the given module, using the options 
 /// provided by the importing compiler instance. Returns true if the module
 /// was built without errors.
 static bool
 compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
                   StringRef ModuleName, FrontendInputFile Input,
                   StringRef OriginalModuleMapFile, StringRef ModuleFileName,
+                  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs,
                   llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
                       [](CompilerInstance &) {},
                   llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
                       [](CompilerInstance &) {}) {
   // Construct a compiler invocation for creating this module.
   auto Invocation =
       std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
 
compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
   // module.  Since we're sharing a PCMCache,
   // CompilerInstance::CompilerInstance is responsible for finalizing the
   // buffers to prevent use-after-frees.
   CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
                             &ImportingInstance.getPreprocessor().getPCMCache());
   auto &Inv = *Invocation;
   Instance.setInvocation(std::move(Invocation));
 
-  Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
-                                   ImportingInstance.getDiagnosticClient()),
-                             /*ShouldOwnClient=*/true);
+  Instance.createDiagnostics(
+      std::move(DiagIDs),
+      new ForwardingDiagnosticConsumer(ImportingInstance.getDiagnosticClient()),
 
   Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
 
   // Note that this module is part of the module build stack, so that we
   // can detect cycles in the module graph.
   Instance.setFileManager(&ImportingInstance.getFileManager());
   Instance.createSourceManager(Instance.getFileManager());
   SourceManager &SourceMgr = Instance.getSourceManager();
compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
 
   return !Instance.getDiagnostics().hasErrorOccurred();
 }
 
 /// \brief Compile a module file for the given module, using the options 
 /// provided by the importing compiler instance. Returns true if the module
 /// was built without errors.
 static bool compileModuleImpl(CompilerInstance &ImportingInstance,
-                              SourceLocation ImportLoc,
-                              Module *Module,
-                              StringRef ModuleFileName) {
+                              SourceLocation ImportLoc, Module *Module,
+                              StringRef ModuleFileName,
+                              IntrusiveRefCntPtr<DiagnosticIDs> Diags) {
   InputKind IK(getLanguageFromOptions(ImportingInstance.getLangOpts()),
                InputKind::ModuleMap);
 
   // Get or create the module map that we'll use to build this module.
   ModuleMap &ModMap 
     = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
   bool Result;
   if (const FileEntry *ModuleMapFile =
           ModMap.getContainingModuleMapFile(Module)) {
     // Use the module map where this module resides.
     Result = compileModuleImpl(
         ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
         FrontendInputFile(ModuleMapFile->getName(), IK, +Module->IsSystem),
-        ModMap.getModuleMapFileForUniquing(Module)->getName(),
-        ModuleFileName);
+        ModMap.getModuleMapFileForUniquing(Module)->getName(), ModuleFileName,
+        std::move(Diags));
   } else {
     // FIXME: We only need to fake up an input file here as a way of
     // transporting the module's directory to the module map parser. We should
     // be able to do that more directly, and parse from a memory buffer without
     // inventing this file.
     SmallString<128> FakeModuleMapFile(Module->Directory->getName());
     llvm::sys::path::append(FakeModuleMapFile, "__inferred_module.map");
 
     std::string InferredModuleMapContent;
     llvm::raw_string_ostream OS(InferredModuleMapContent);
     Module->print(OS);
     OS.flush();
 
     Result = compileModuleImpl(
         ImportingInstance, ImportLoc, Module->getTopLevelModuleName(),
         FrontendInputFile(FakeModuleMapFile, IK, +Module->IsSystem),
-        ModMap.getModuleMapFileForUniquing(Module)->getName(),
-        ModuleFileName,
-        [&](CompilerInstance &Instance) {
+        ModMap.getModuleMapFileForUniquing(Module)->getName(), ModuleFileName,
+        std::move(Diags), [&](CompilerInstance &Instance) {
           std::unique_ptr<llvm::MemoryBuffer> ModuleMapBuffer =
               llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
           ModuleMapFile = Instance.getFileManager().getVirtualFile(
               FakeModuleMapFile, InferredModuleMapContent.size(), 0);
           Instance.getSourceManager().overrideFileContents(
               ModuleMapFile, std::move(ModuleMapBuffer));
         });
   }
 
   // We've rebuilt a module. If we're allowed to generate or update the global
   // module index, record that fact in the importing compiler instance.
   if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
     ImportingInstance.setBuildGlobalModuleIndex(true);
   }
 
case llvm::LockFileManager::LFS_Error:
       Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure)
           << Module->Name << Locked.getErrorMessage();
       // Clear out any potential leftover.
       Locked.unsafeRemoveLockFile();
       // FALLTHROUGH
     case llvm::LockFileManager::LFS_Owned:
       // We're responsible for building the module ourselves.
       if (!compileModuleImpl(ImportingInstance, ModuleNameLoc, Module,
-                             ModuleFileName)) {
+                             ModuleFileName, Diags.getDiagnosticIDs())) {
         diagnoseBuildFailure();
         return false;
       }
       break;
 
     case llvm::LockFileManager::LFS_Shared:
       // Someone else is responsible for building the module. Wait for them to
       // finish.
void CompilerInstance::loadModuleFromSource(SourceLocation ImportLoc,
   };
 
   auto PostBuildStep = [this](CompilerInstance &Other) {
     BuiltModules = std::move(Other.BuiltModules);
   };
 
   // Build the module, inheriting any modules that we've built locally.
   if (compileModuleImpl(*this, ImportLoc, ModuleName, Input, StringRef(),
-                        ModuleFileName, PreBuildStep, PostBuildStep)) {
+                        ModuleFileName, Diagnostics->getDiagnosticIDs(),
+                        PreBuildStep, PostBuildStep)) {
     BuiltModules[ModuleName] = ModuleFileName.str();
     llvm::sys::RemoveFileOnSignal(ModuleFileName);
   }
 }
 
 void CompilerInstance::makeModuleVisible(Module *Mod,
                                          Module::NameVisibilityKind Visibility,
                                          SourceLocation ImportLoc) {

lib/Frontend/CreateInvocationFromCommandLine.cpp

 /// createInvocationFromCommandLine - Construct a compiler invocation object for
 /// a command line argument vector.
 ///
 /// \return A CompilerInvocation, or 0 if none was built for the given
 /// argument vector.
 std::unique_ptr<CompilerInvocation> clang::createInvocationFromCommandLine(
     ArrayRef<const char *> ArgList, IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
     IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
-  if (!Diags.get()) {
-    // No diagnostics engine was provided, so create our own diagnostics object
-    // with the default options.
-    Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions);
-  }
-
   SmallVector<const char *, 16> Args(ArgList.begin(), ArgList.end());
 
   // FIXME: Find a cleaner way to force the driver into restricted modes.
   Args.push_back("-fsyntax-only");
 
   // FIXME: We shouldn't have to pass in the path info.
   driver::Driver TheDriver(Args[0], llvm::sys::getDefaultTargetTriple(),
                            *Diags, VFS);

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/Rewrite/FrontendActions.cpp

void visitModuleFile(StringRef Filename,
     (*OS) << '\n';
 
     // Rewrite the contents of the module in a separate compiler instance.
     CompilerInstance Instance(CI.getPCHContainerOperations(),
                               &CI.getPreprocessor().getPCMCache());
     Instance.setInvocation(
         std::make_shared<CompilerInvocation>(CI.getInvocation()));
     Instance.createDiagnostics(
+        CI.getDiagnostics().getDiagnosticIDs(),
         new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()),
         /*ShouldOwnClient=*/true);
     Instance.getFrontendOpts().DisableFree = false;
     Instance.getFrontendOpts().Inputs.clear();
     Instance.getFrontendOpts().Inputs.emplace_back(
         Filename, InputKind(InputKind::Unknown, InputKind::Precompiled));
     Instance.getFrontendOpts().ModuleFiles.clear();
     Instance.getFrontendOpts().ModuleMapFiles.clear();

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() {
   //    rework ChainedDiagnosticsConsumer and teach the engine about multiple
   //    consumers, which is difficult today because most APIs interface with
   //    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());
+    auto Client = new TextDiagnosticPrinter(llvm::errs(), State->DiagIDs,
+                                            State->DiagOpts.get());
     State->MetaDiagnostics = llvm::make_unique<DiagnosticsEngine>(
-        IDs, State->DiagOpts.get(), Client);
+        State->DiagIDs, State->DiagOpts.get(), Client);
   }
   return State->MetaDiagnostics.get();
 }
 
 void SDiagsWriter::RemoveOldDiagnostics() {
   if (!llvm::sys::fs::remove(State->OutputFile))
     return;
 

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/FrontendTool/CMakeLists.txt

 if(CLANG_ENABLE_STATIC_ANALYZER)
   list(APPEND link_libs
     clangStaticAnalyzerFrontend
     )
 endif()
 
 add_clang_library(clangFrontendTool
   ExecuteCompilerInvocation.cpp
+  DiagnosticTable.cpp
 
   DEPENDS
   ClangDriverOptions
 
   LINK_LIBS
   ${link_libs}
   )

lib/FrontendTool/DiagnosticTable.cpp

+#include "clang/FrontendTool/DiagnosticTable.h"
+#include "clang/FrontendTool/AllDiagnostics.h"
+#include <cstdint>
+
+using namespace clang;
+
+#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
+
+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
+};
+
+static ArrayRef<DiagnosticIDs::DiagInfoRec> GetDiagInfoTable() {
+  return StaticDiagInfo;
+}
+
+/// GetDiagInfo - Return the DiagInfoRec 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 = GetDiagInfoTable();
+
+  // 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;
+}
+
+static const DiagnosticIDs::CategoryRec CategoryNameTable[] = {
+#define GET_CATEGORY_TABLE
+#define CATEGORY(X, ENUM) {X, STR_SIZE(X, uint8_t)},
+#include "clang/Basic/DiagnosticGroups.inc"
+#undef GET_CATEGORY_TABLE
+};
+
+#define GET_DIAG_ARRAYS
+#include "clang/Basic/DiagnosticGroups.inc"
+#undef GET_DIAG_ARRAYS
+
+// Second the table of options, sorted by name for fast binary lookup.
+static const clang::DiagnosticIDs::WarningOption OptionTable[] = {
+#define GET_DIAG_TABLE
+#include "clang/Basic/DiagnosticGroups.inc"
+#undef GET_DIAG_TABLE
+};
+
+DiagnosticIDs *clang::AllDiagnostics() {
+  return new DiagnosticIDs(GetDiagInfoTable(), DiagGroupNames,
+                           CategoryNameTable, OptionTable, DiagArrays,
+                           DiagSubGroups, GetDiagInfo);
+}

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/Serialization/ASTReader.cpp

auto ReadDiagState =
              "Invalid data, not enough diag/map pairs");
       while (Size--) {
         unsigned DiagID = Record[Idx++];
         DiagnosticMapping NewMapping =
             DiagnosticMapping::deserialize(Record[Idx++]);
         if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
           continue;
 
-        DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
+        DiagnosticMapping &Mapping =
+            NewState->getOrAddMapping(DiagID, *Diag.getDiagnosticIDs());
 
         // If this mapping was specified as a warning but the severity was
         // upgraded due to diagnostic settings, simulate the current diagnostic
         // settings (and use a warning).
         if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
           NewMapping.setSeverity(diag::Severity::Warning);
           NewMapping.setUpgradedFromWarning(false);
         }

lib/StaticAnalyzer/Core/CallEvent.cpp

RuntimeDefinition AnyFunctionCall::getRuntimeDefinition() const {
 
   // Try to get CTU definition only if CTUDir is provided.
   if (!Opts.naiveCTUEnabled())
     return RuntimeDefinition();
 
   cross_tu::CrossTranslationUnitContext &CTUCtx =
       *Engine->getCrossTranslationUnitContext();
   llvm::Expected<const FunctionDecl *> CTUDeclOrError =
-      CTUCtx.getCrossTUDefinition(FD, Opts.getCTUDir(), Opts.getCTUIndexName());
+      CTUCtx.getCrossTUDefinition(
+          FD, Opts.getCTUDir(), Opts.getCTUIndexName(),
+          Engine->getAnalysisManager().getDiagnostic().getDiagnosticIDs());
 
   if (!CTUDeclOrError) {
     handleAllErrors(CTUDeclOrError.takeError(),
                     [&](const cross_tu::IndexError &IE) {
                       CTUCtx.emitCrossTUDiagnostics(IE);
                     });
     return {};
   }

lib/StaticAnalyzer/Frontend/ModelInjector.cpp

void ModelInjector::onBodySynthesis(const NamedDecl *D) {
 
   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
 
   // Modules are parsed by a separate CompilerInstance, so this code mimics that
   // behavior for models
   CompilerInstance Instance(CI.getPCHContainerOperations());
   Instance.setInvocation(std::move(Invocation));
   Instance.createDiagnostics(
+      CI.getDiagnostics().getDiagnosticIDs(),
       new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()),
       /*ShouldOwnClient=*/true);
 
   Instance.getDiagnostics().setSourceManager(&SM);
 
   Instance.setVirtualFileSystem(&CI.getVirtualFileSystem());
 
   // The instance wants to take ownership, however DisableFree frontend option

lib/Tooling/CMakeLists.txt

add_clang_library(clangTooling
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangDriver
   clangFormat
   clangFrontend
+  clangFrontendTool
   clangLex
   clangRewrite
   clangToolingCore
   )

lib/Tooling/CompilationDatabase.cpp

 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Driver/Action.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Job.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Tooling/CompilationDatabasePluginRegistry.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"

 ///          \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(
+      AllDiagnostics());
+  TextDiagnosticPrinter DiagnosticPrinter(Output, DiagIDs, &*DiagOpts);
   UnusedInputDiagConsumer DiagClient(DiagnosticPrinter);
-  DiagnosticsEngine Diagnostics(
-      IntrusiveRefCntPtr<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/Core/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangToolingCore
   Lookup.cpp
   Replacement.cpp
   Diagnostic.cpp
 
   LINK_LIBS
   clangAST
   clangBasic
   clangLex
   clangRewrite
+  clangFrontendTool
   )

lib/Tooling/Core/Replacement.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemOptions.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/VirtualFileSystem.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Rewrite/Core/RewriteBuffer.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"

 llvm::Expected<std::string> applyAllReplacements(StringRef Code,
                                                 const Replacements &Replaces) {
   if (Replaces.empty())
     return Code.str();
 
   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   FileManager Files(FileSystemOptions(), InMemoryFileSystem);
-  DiagnosticsEngine Diagnostics(
-      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
-      new DiagnosticOptions);
+  DiagnosticsEngine Diagnostics(AllDiagnostics(), new DiagnosticOptions);
   SourceManager SourceMgr(Diagnostics, Files);
   Rewriter Rewrite(SourceMgr, LangOptions());
   InMemoryFileSystem->addFile(
       "<stdin>", 0, llvm::MemoryBuffer::getMemBuffer(Code, "<stdin>"));
   FileID ID = SourceMgr.createFileID(Files.getFile("<stdin>"), SourceLocation(),
                                      clang::SrcMgr::C_User);
   for (auto I = Replaces.rbegin(), E = Replaces.rend(); I != E; ++I) {
     Replacement Replace("<stdin>", I->getOffset(), I->getLength(),

lib/Tooling/Refactoring.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Format/Format.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_os_ostream.h"
 
 namespace clang {
 namespace tooling {
 
 RefactoringTool::RefactoringTool(
     const CompilationDatabase &Compilations, ArrayRef<std::string> SourcePaths,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps)
     : ClangTool(Compilations, SourcePaths, std::move(PCHContainerOps)) {}
 
 std::map<std::string, Replacements> &RefactoringTool::getReplacements() {
   return FileToReplaces;
 }
 
 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(
+      AllDiagnostics());
+  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

 #include "clang/Driver/Tool.h"
 #include "clang/Driver/ToolChain.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/FrontendOptions.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
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<DiagnosticIDs> DiagIDs =
+      AllDiagnostics();
+  TextDiagnosticPrinter DiagnosticPrinter(llvm::errs(), DiagIDs, &*DiagOpts);
   DiagnosticsEngine Diagnostics(
-      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
+      std::move(DiagIDs), &*DiagOpts,
       DiagConsumer ? DiagConsumer : &DiagnosticPrinter, false);
 
   const std::unique_ptr<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<driver::Compilation> Compilation(
       Driver->BuildCompilation(llvm::makeArrayRef(Argv)));
bool FrontendActionFactory::runInvocation(
   Compiler.setFileManager(Files);
 
   // The FrontendAction can have lifetime requirements for Compiler or its
   // members, and we need to ensure it's deleted earlier than Compiler. So we
   // pass it to an std::unique_ptr declared after the Compiler variable.
   std::unique_ptr<FrontendAction> ScopedToolAction(create());
 
   // Create the compiler's actual diagnostics engine.
-  Compiler.createDiagnostics(DiagConsumer, /*ShouldOwnClient=*/false);
+  Compiler.createDiagnostics(
+      AllDiagnostics(), DiagConsumer,
+      /*ShouldOwnClient=*/false);
   if (!Compiler.hasDiagnostics())
     return false;
 
   Compiler.createSourceManager(*Files);
 
   const bool Success = Compiler.ExecuteAction(*ScopedToolAction);
 
   Files->clearStatCaches();

 
 public:
   ASTBuilderAction(std::vector<std::unique_ptr<ASTUnit>> &ASTs) : ASTs(ASTs) {}
 
   bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
                      FileManager *Files,
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                      DiagnosticConsumer *DiagConsumer) override {
+
     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(
         Invocation, std::move(PCHContainerOps),
-        CompilerInstance::createDiagnostics(&Invocation->getDiagnosticOpts(),
-                                            DiagConsumer,
-                                            /*ShouldOwnClient=*/false),
+        CompilerInstance::createDiagnostics(
+            AllDiagnostics(),
+            &Invocation->getDiagnosticOpts(), DiagConsumer,
         Files);
     if (!AST)
       return false;
 
     ASTs.push_back(std::move(AST));
     return true;
   }
 };

tools/arcmt-test/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   support
   )
 
 add_clang_executable(arcmt-test
   arcmt-test.cpp
   )
 
 target_link_libraries(arcmt-test
   PRIVATE
   clangARCMigrate
   clangBasic
   clangFrontend
+  clangFrontendTool
   clangLex
   )

tools/arcmt-test/arcmt-test.cpp

 //===-- arcmt-test.cpp - ARC Migration Tool testbed -----------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/ARCMigrate/ARCMT.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/Frontend/PCHContainerOperations.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Signals.h"
 #include <system_error>
 
public:
   }
 };
 
 } // anonymous namespace
 
 static bool checkForMigration(StringRef resourcesPath,
                               ArrayRef<const char *> Args) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID = AllDiagnostics();
   DiagnosticConsumer *DiagClient =
-    new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+      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();
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID = AllDiagnostics();
   DiagnosticConsumer *DiagClient =
-    new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+      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/c-index-test/CMakeLists.txt

 else()
   target_link_libraries(c-index-test
     PRIVATE
     libclang
     clangAST
     clangBasic
     clangCodeGen
     clangFrontend
+    clangFrontendTool
     clangIndex
     clangSerialization
   )
 endif()
 
 set_target_properties(c-index-test
   PROPERTIES
   LINKER_LANGUAGE CXX)

tools/c-index-test/core_main.cpp

 //===-- core_main.cpp - Core Index Tool testbed ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendAction.h"
-#include "clang/Index/IndexingAction.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
+#include "clang/Index/CodegenNameGenerator.h"
 #include "clang/Index/IndexDataConsumer.h"
+#include "clang/Index/IndexingAction.h"
 #include "clang/Index/USRGeneration.h"
-#include "clang/Index/CodegenNameGenerator.h"
 #include "clang/Serialization/ASTReader.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Support/PrettyStackTrace.h"
 
 using namespace clang;
 using namespace clang::index;
 using namespace llvm;
 
 extern "C" int indextest_core_main(int argc, const char **argv);
 
 namespace {

 }
 
 static bool printSourceSymbols(ArrayRef<const char *> Args,
                                bool dumpModuleImports,
                                bool indexLocals) {
   SmallVector<const char *, 4> ArgsWithProgName;
   ArgsWithProgName.push_back("clang");
   ArgsWithProgName.append(Args.begin(), Args.end());
-  IntrusiveRefCntPtr<DiagnosticsEngine>
-    Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions));
+  IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
+      CompilerInstance::createDiagnostics(AllDiagnostics(),
+                                          new DiagnosticOptions);
   auto CInvok = createInvocationFromCommandLine(ArgsWithProgName, Diags);
   if (!CInvok)
     return true;
 
   raw_ostream &OS = outs();
   auto DataConsumer = std::make_shared<PrintIndexDataConsumer>(OS);
   IndexingOptions IndexOpts;
   IndexOpts.IndexFunctionLocals = indexLocals;
static bool printSourceSymbolsFromModule(StringRef modulePath,
   pchContOps->registerReader(llvm::make_unique<ObjectFilePCHContainerReader>());
   auto pchRdr = pchContOps->getReaderOrNull(format);
   if (!pchRdr) {
     errs() << "unknown module format: " << format << '\n';
     return true;
   }
 
   IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
-      CompilerInstance::createDiagnostics(new DiagnosticOptions());
+      CompilerInstance::createDiagnostics(AllDiagnostics(),
+                                          new DiagnosticOptions());
   std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
       modulePath, *pchRdr, ASTUnit::LoadASTOnly, Diags,
       FileSystemOpts, /*UseDebugInfo=*/false,
       /*OnlyLocalDecls=*/true, None,
       /*CaptureDiagnostics=*/false,
       /*AllowPCHWithCompilerErrors=*/true,
       /*UserFilesAreVolatile=*/false);
   if (!AU) {

tools/clang-check/CMakeLists.txt

 set( LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   Option
   Support
   )
 
 add_clang_executable(clang-check
   ClangCheck.cpp
   )
 
 target_link_libraries(clang-check
   PRIVATE
   clangAST
   clangBasic
   clangDriver
   clangFrontend
+  clangFrontendTool
   clangRewriteFrontend
   clangStaticAnalyzerFrontend
   clangTooling
   )
 
 install(TARGETS clang-check
   RUNTIME DESTINATION bin)

tools/clang-format/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_tool(clang-format
   ClangFormat.cpp
   )
 
 set(CLANG_FORMAT_LIB_DEPS
   clangBasic
   clangFormat
   clangRewrite
   clangToolingCore
+  clangFrontendTool
   )
 
 target_link_libraries(clang-format
   PRIVATE
   ${CLANG_FORMAT_LIB_DEPS}
   )
 
 if( LLVM_LIB_FUZZING_ENGINE OR LLVM_USE_SANITIZE_COVERAGE )

tools/clang-format/ClangFormat.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Version.h"
 #include "clang/Format/Format.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 
 using namespace llvm;
 using clang::tooling::Replacements;
return LineRange.first.getAsInteger(0, FromLine) ||
          LineRange.second.getAsInteger(0, ToLine);
 }
 
 static bool fillRanges(MemoryBuffer *Code,
                        std::vector<tooling::Range> &Ranges) {
   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   FileManager Files(FileSystemOptions(), InMemoryFileSystem);
-  DiagnosticsEngine Diagnostics(
-      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
-      new DiagnosticOptions);
+  DiagnosticsEngine Diagnostics(AllDiagnostics(), new DiagnosticOptions);
   SourceManager Sources(Diagnostics, Files);
   FileID ID = createInMemoryFile("<irrelevant>", Code, Sources, Files,
                                  InMemoryFileSystem.get());
   if (!LineRanges.empty()) {
     if (!Offsets.empty() || !Lengths.empty()) {
       errs() << "error: cannot use -lines with -offset/-length\n";
       return true;
     }
if (Cursor.getNumOccurrences() != 0)
              << "</cursor>\n";
 
     outputReplacementsXML(Replaces);
     outs() << "</replacements>\n";
   } else {
     IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
         new vfs::InMemoryFileSystem);
     FileManager Files(FileSystemOptions(), InMemoryFileSystem);
-    DiagnosticsEngine Diagnostics(
-        IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
-        new DiagnosticOptions);
+    DiagnosticsEngine Diagnostics(AllDiagnostics(), new DiagnosticOptions);
     SourceManager Sources(Diagnostics, Files);
     FileID ID = createInMemoryFile(AssumedFileName, Code.get(), Sources, Files,
                                    InMemoryFileSystem.get());
     Rewriter Rewrite(Sources, LangOptions());
     tooling::applyAllReplacements(Replaces, Rewrite);
     if (Inplace) {
       if (Rewrite.overwriteChangedFiles())
         return true;

tools/clang-fuzzer/handle-cxx/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS ${LLVM_TARGETS_TO_BUILD} Support)
 
 add_clang_library(clangHandleCXX
   handle_cxx.cpp
 
   LINK_LIBS
   clangBasic
   clangCodeGen
   clangFrontend
+  clangFrontendTool
   clangLex
   clangTooling
   )

tools/clang-fuzzer/handle-cxx/handle_cxx.cpp

 // Implements HandleCXX for use by the Clang fuzzers.
 //
 //===----------------------------------------------------------------------===//
 
 #include "handle_cxx.h"
 
 #include "clang/CodeGen/CodeGenAction.h"
 #include "clang/Frontend/CompilerInstance.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/TargetSelect.h"
 
 using namespace clang;
 
 void clang_fuzzer::HandleCXX(const std::string &S,
                              const std::vector<const char *> &ExtraArgs) {
   llvm::InitializeAllTargets();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllAsmParsers();
 
   llvm::opt::ArgStringList CC1Args;
   CC1Args.push_back("-cc1");
   for (auto &A : ExtraArgs)
     CC1Args.push_back(A);
   CC1Args.push_back("./test.cc");
 
   llvm::IntrusiveRefCntPtr<FileManager> Files(
       new FileManager(FileSystemOptions()));
   IgnoringDiagConsumer Diags;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
-  DiagnosticsEngine Diagnostics(
-      IntrusiveRefCntPtr<clang::DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
-      &Diags, false);
+  DiagnosticsEngine Diagnostics(AllDiagnostics(), &*DiagOpts, &Diags, false);
   std::unique_ptr<clang::CompilerInvocation> Invocation(
       tooling::newInvocation(&Diagnostics, CC1Args));
   std::unique_ptr<llvm::MemoryBuffer> Input =
       llvm::MemoryBuffer::getMemBuffer(S);
   Invocation->getPreprocessorOpts().addRemappedFile("./test.cc",
                                                     Input.release());
   std::unique_ptr<tooling::ToolAction> action(
       tooling::newFrontendActionFactory<clang::EmitObjAction>());
   std::shared_ptr<PCHContainerOperations> PCHContainerOps =
       std::make_shared<PCHContainerOperations>();
   action->runInvocation(std::move(Invocation), Files.get(), PCHContainerOps,
                         &Diags);
 }
 

tools/clang-import-test/CMakeLists.txt

add_clang_tool(clang-import-test
   )
 
 set(CLANG_IMPORT_TEST_LIB_DEPS
   clangAST
   clangBasic
   clangCodeGen
   clangDriver
   clangFrontend
+  clangFrontendTool
   clangLex
   clangParse
   )
 
 target_link_libraries(clang-import-test
   PRIVATE
   ${CLANG_IMPORT_TEST_LIB_DEPS}
   )

tools/clang-import-test/clang-import-test.cpp

 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Driver/Types.h"
 #include "clang/Frontend/ASTConsumers.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Frontend/TextDiagnosticBuffer.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Parse/ParseAST.h"
 
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
     DiagnosticConsumer::HandleDiagnostic(DiagLevel, Info);
   }
 };
 
 std::unique_ptr<CompilerInstance> BuildCompilerInstance() {
   auto Ins = llvm::make_unique<CompilerInstance>();
   auto DC = llvm::make_unique<TestDiagnosticConsumer>();
   const bool ShouldOwnClient = true;
-  Ins->createDiagnostics(DC.release(), ShouldOwnClient);
+  Ins->createDiagnostics(AllDiagnostics(), DC.release(), ShouldOwnClient);
 
   auto Inv = llvm::make_unique<CompilerInvocation>();
 
   std::vector<const char *> ClangArgv(ClangArgs.size());
   std::transform(ClangArgs.begin(), ClangArgs.end(), ClangArgv.begin(),
                  [](const std::string &s) -> const char * { return s.data(); });
   CompilerInvocation::CreateFromArgs(*Inv, ClangArgv.data(),
                                      &ClangArgv.data()[ClangArgv.size()],

tools/clang-rename/ClangRename.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Refactoring/Rename/RenamingAction.h"
 #include "clang/Tooling/Refactoring/Rename/USRFindingAction.h"
 #include "clang/Tooling/ReplacementsYaml.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
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 = AllDiagnostics();
+    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/CMakeLists.txt

add_clang_executable(diagtool
   ShowEnabledWarnings.cpp
   TreeView.cpp
 )
 
 target_link_libraries(diagtool
   PRIVATE
   clangBasic
   clangFrontend
+  clangFrontendTool
   )
 
 if(UNIX)
   set(CLANGXX_LINK_OR_COPY create_symlink)
 else()
   set(CLANGXX_LINK_OR_COPY copy)
 endif()

tools/diagtool/DiagnosticNames.cpp

 //===- DiagnosticNames.cpp - Defines a table of all builtin diagnostics ----==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DiagnosticNames.h"
-#include "clang/Basic/AllDiagnostics.h"
+#include "clang/FrontendTool/AllDiagnostics.h"
 #include "llvm/ADT/STLExtras.h"
 
 using namespace clang;
 using namespace diagtool;
 
 static const DiagnosticRecord BuiltinDiagnosticsByName[] = {
 #define DIAG_NAME_INDEX(ENUM) { #ENUM, diag::ENUM, STR_SIZE(#ENUM, uint8_t) },
 #include "clang/Basic/DiagnosticIndexName.inc"

tools/diagtool/FindDiagnosticID.cpp

 //===- FindDiagnosticID.cpp - diagtool tool for finding diagnostic id -----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DiagTool.h"
 #include "DiagnosticNames.h"
-#include "clang/Basic/AllDiagnostics.h"
+#include "clang/FrontendTool/AllDiagnostics.h"
 #include "llvm/Support/CommandLine.h"
 
 DEF_DIAGTOOL("find-diagnostic-id", "Print the id of the given diagnostic",
              FindDiagnosticID)
 
 using namespace clang;
 using namespace diagtool;
 

tools/diagtool/ListWarnings.cpp

 // This file provides a diagtool tool that displays warning flags for
 // diagnostics.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DiagTool.h"
 #include "DiagnosticNames.h"
 #include "clang/AST/ASTDiagnostic.h"
-#include "clang/Basic/AllDiagnostics.h"
+#include "clang/FrontendTool/AllDiagnostics.h"
 #include "clang/Basic/Diagnostic.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Format.h"
 
 DEF_DIAGTOOL("list-warnings",
              "List warnings and their corresponding flags",
              ListWarnings)
 
 using namespace clang;
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;
 
+  std::unique_ptr<DiagnosticIDs> IDs(AllDiagnostics());
+
   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

 //===- ShowEnabledWarnings - diagtool tool for printing enabled flags -----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DiagTool.h"
 #include "DiagnosticNames.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/TextDiagnosticBuffer.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/Support/TargetSelect.h"
 
 DEF_DIAGTOOL("show-enabled",
              "Show which warnings are enabled for a given command line",
              ShowEnabledWarnings)
 
 using namespace clang;
 using namespace diagtool;
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;
   Args.push_back("diagtool");
   Args.append(argv, argv + argc);
   std::unique_ptr<CompilerInvocation> Invocation =
       createInvocationFromCommandLine(Args, InterimDiags);
   if (!Invocation)
     return nullptr;
 
   // Build the diagnostics parser
   IntrusiveRefCntPtr<DiagnosticsEngine> FinalDiags =
-    CompilerInstance::createDiagnostics(&Invocation->getDiagnosticOpts());
+      CompilerInstance::createDiagnostics(DiagIDs,
+                                          &Invocation->getDiagnosticOpts());
   if (!FinalDiags)
     return nullptr;
 
   // Flush any errors created when initializing everything. This could happen
   // for invalid command lines, which will probably give non-sensical results.
   DiagsBuffer->FlushDiagnostics(*FinalDiags);
 
   return FinalDiags;
if (FirstArg.equals("--no-levels")) {
       ++argv;
     } else if (FirstArg.equals("--levels")) {
       ShouldShowLevels = true;
       --argc;
       ++argv;
     }
   }
 
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs = AllDiagnostics();
+
   // 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/diagtool/TreeView.cpp

 //===- TreeView.cpp - diagtool tool for printing warning flags ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DiagTool.h"
 #include "DiagnosticNames.h"
 #include "clang/AST/ASTDiagnostic.h"
-#include "clang/Basic/AllDiagnostics.h"
+#include "clang/FrontendTool/AllDiagnostics.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Process.h"
 
 DEF_DIAGTOOL("tree", "Show warning flags in a tree view", TreeView)
 
 using namespace clang;
 using namespace diagtool;
public:
 
   void resetColor() {
     if (ShowColors)
       out << llvm::sys::Process::ResetColor();
   }
 
   static bool isIgnored(unsigned DiagID) {
     // FIXME: This feels like a hack.
-    static clang::DiagnosticsEngine Diags(new DiagnosticIDs,
+    static clang::DiagnosticsEngine Diags(AllDiagnostics(),
                                           new DiagnosticOptions);
     return Diags.isIgnored(DiagID, SourceLocation());
   }
 
   static bool enabledByDefault(const GroupRecord &Group) {
     for (const DiagnosticRecord &DR : Group.diagnostics()) {
       if (isIgnored(DR.DiagID))
         return false;

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/FrontendTool/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/DiagnosticTable.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
 
 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 =
+      AllDiagnostics();
 
   // 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();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllAsmParsers();
 
 #ifdef LINK_POLLY_INTO_TOOLS
   llvm::PassRegistry &Registry = *llvm::PassRegistry::getPassRegistry();
   polly::initializePollyPasses(Registry);
 #endif
 
   // Buffer diagnostics from argument parsing so that we can output them using a
   // well formed diagnostic object.
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
   bool Success = CompilerInvocation::CreateFromArgs(
       Clang->getInvocation(), Argv.begin(), Argv.end(), Diags);
 
   // Infer the builtin include path if unspecified.
   if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
       Clang->getHeaderSearchOpts().ResourceDir.empty())
     Clang->getHeaderSearchOpts().ResourceDir =
       CompilerInvocation::GetResourcesPath(Argv0, MainAddr);
 
   // Create the actual diagnostics engine.
-  Clang->createDiagnostics();
+  Clang->createDiagnostics(DiagID);
   if (!Clang->hasDiagnostics())
     return 1;
 
   // Set an error handler, so that any LLVM backend diagnostics go through our
   // error handler.
   llvm::install_fatal_error_handler(LLVMErrorHandler,
                                   static_cast<void*>(&Clang->getDiagnostics()));
 
   DiagsBuffer->FlushDiagnostics(Clang->getDiagnostics());
   if (!Success)
     return 1;
 
   // Execute the frontend actions.
   Success = ExecuteCompilerInvocation(Clang.get());
 
   // If any timers were active but haven't been destroyed yet, print their
   // results now.  This happens in -disable-free mode.
   llvm::TimerGroup::printAll(llvm::errs());
 
   // Our error handler depends on the Diagnostics object, which we're
   // potentially about to delete. Uninstall the handler now so that any
   // later errors use the default handling behavior instead.
   llvm::remove_fatal_error_handler();
 
   // When running with -disable-free, don't do any destruction or shutdown.
   if (Clang->getFrontendOpts().DisableFree) {
     BuryPointer(std::move(Clang));
     return !Success;
   }
 
   return !Success;
 }

tools/driver/cc1as_main.cpp

 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"

 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);
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID =
+      AllDiagnostics();
+  TextDiagnosticPrinter *DiagClient =
+      new TextDiagnosticPrinter(errs(), DiagID, &*DiagOpts);
   DiagClient->setPrefix("clang -cc1as");
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   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/cc1gen_reproducer_main.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/VirtualFileSystem.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;

 static llvm::Optional<driver::Driver::CompilationDiagnosticReport>
 generateReproducerForInvocationArguments(ArrayRef<const char *> Argv,
                                          const ClangInvocationInfo &Info) {
   using namespace driver;
   auto TargetAndMode = ToolChain::getTargetAndModeFromProgramName(Argv[0]);
 
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions;
 
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID = AllDiagnostics();
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new IgnoringDiagConsumer());
   ProcessWarningOptions(Diags, *DiagOpts, /*ReportDiags=*/false);
   Driver TheDriver(Argv[0], llvm::sys::getDefaultTargetTriple(), Diags);
   TheDriver.setTargetAndMode(TargetAndMode);
 
   std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(Argv));
   if (C && !C->containsError()) {
     for (const auto &J : C->getJobs()) {

tools/driver/driver.cpp

 //===-- driver.cpp - Clang GCC-Compatible Driver --------------------------===//
 //
 //                     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 driver; it is a thin wrapper
 // for functionality in the Driver clang library.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Driver/Driver.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/Compilation.h"
-#include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/ToolChain.h"
 #include "clang/Frontend/ChainedDiagnosticConsumer.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
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 =
+      AllDiagnostics();
 
-  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

 //===- ARCMigrate.cpp - Clang-C ARC Migration Library ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the main API hooks in the Clang-C ARC Migration library.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang-c/Index.h"
 #include "CXString.h"
+#include "clang-c/Index.h"
 #include "clang/ARCMigrate/ARCMT.h"
 #include "clang/Config/config.h"
 #include "clang/Frontend/TextDiagnosticBuffer.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/Support/FileSystem.h"
 
 using namespace clang;
 using namespace arcmt;
 
 namespace {
 
 struct Remap {
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 = AllDiagnostics();
   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

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticCategories.h"
 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Version.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Index/CodegenNameGenerator.h"
 #include "clang/Index/CommentToXML.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/PreprocessingRecord.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Serialization/SerializationDiagnostic.h"
 #include "llvm/ADT/Optional.h"
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);
enum CXErrorCode clang_createTranslationUnit2(CXIndex CIdx,
   LOG_FUNC_SECTION {
     *Log << ast_filename;
   }
 
   CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
   FileSystemOptions FileSystemOpts;
 
   IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
-      CompilerInstance::createDiagnostics(new DiagnosticOptions());
+      CompilerInstance::createDiagnostics(AllDiagnostics(),
+                                          new DiagnosticOptions());
   std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
       ast_filename, CXXIdx->getPCHContainerOperations()->getRawReader(),
       ASTUnit::LoadEverything, Diags,
       FileSystemOpts, /*UseDebugInfo=*/false,
       CXXIdx->getOnlyLocalDecls(), None,
       /*CaptureDiagnostics=*/true,
       /*AllowPCHWithCompilerErrors=*/true,
       /*UserFilesAreVolatile=*/true);
bool CacheCodeCompletionResults
     = options & CXTranslationUnit_CacheCompletionResults;
   bool IncludeBriefCommentsInCodeCompletion
     = options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion;
   bool SkipFunctionBodies = options & CXTranslationUnit_SkipFunctionBodies;
   bool SingleFileParse = options & CXTranslationUnit_SingleFileParse;
   bool ForSerialization = options & CXTranslationUnit_ForSerialization;
 
   // Configure the diagnostics.
-  IntrusiveRefCntPtr<DiagnosticsEngine>
-    Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions));
+  IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
+      CompilerInstance::createDiagnostics(AllDiagnostics(),
+                                          new DiagnosticOptions));
 
   if (options & CXTranslationUnit_KeepGoing)
     Diags->setSuppressAfterFatalError(false);
 
   // Recover resources if we crash before exiting this function.
   llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
     llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
     DiagCleanup(Diags.get());

tools/libclang/CIndexCodeCompletion.cpp

 //===- CIndexCodeCompletion.cpp - Code Completion API hooks ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Clang-C Source Indexing library hooks for
 // code completion.
 //
 //===----------------------------------------------------------------------===//
 
-#include "CIndexer.h"
 #include "CIndexDiagnostic.h"
+#include "CIndexer.h"
 #include "CLog.h"
 #include "CXCursor.h"
 #include "CXString.h"
 #include "CXTranslationUnit.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <atomic>
 #include <cstdio>
 #include <cstdlib>
 #include <string>
 
-
 #ifdef UDP_CODE_COMPLETION_LOGGER
 #include "clang/Basic/Version.h"
 #include <arpa/inet.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
 #endif
 

 /// currently active.
 ///
 /// Used for debugging purposes only.
 static std::atomic<unsigned> CodeCompletionResultObjects;
 
 AllocatedCXCodeCompleteResults::AllocatedCXCodeCompleteResults(
     IntrusiveRefCntPtr<FileManager> FileMgr)
     : CXCodeCompleteResults(), DiagOpts(new DiagnosticOptions),
-      Diag(new DiagnosticsEngine(
-          IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts)),
+      Diag(new DiagnosticsEngine(AllDiagnostics(), &*DiagOpts)),
       FileMgr(std::move(FileMgr)),
       SourceMgr(new SourceManager(*Diag, *this->FileMgr)),
       CodeCompletionAllocator(
           std::make_shared<clang::GlobalCodeCompletionAllocator>()),
       Contexts(CXCompletionContext_Unknown),
       ContainerKind(CXCursor_InvalidCode), ContainerIsIncomplete(1) {
   if (getenv("LIBCLANG_OBJTRACKING"))
     fprintf(stderr, "+++ %u completion results\n",

tools/libclang/CIndexDiagnostic.cpp

 #include "CXTranslationUnit.h"
 #include "CXSourceLocation.h"
 #include "CXString.h"
 
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/DiagnosticRenderer.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 using namespace clang::cxloc;
 using namespace clang::cxdiag;
 using namespace llvm;
 

 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));
+  std::unique_ptr<DiagnosticIDs> Diags(AllDiagnostics());
+  return cxstring::createRef(Diags->getCategoryNameFromID(Category));
 }
   
 CXString clang_getDiagnosticCategoryText(CXDiagnostic Diag) {
   if (CXDiagnosticImpl *D = static_cast<CXDiagnosticImpl *>(Diag))
     return D->getCategoryText();
   return cxstring::createEmpty();
 }
   

tools/libclang/CMakeLists.txt

set(SOURCES
   Index_Internal.h
   ../../include/clang-c/Index.h
   )
 
 set(LIBS
   clangAST
   clangBasic
   clangFrontend
+  clangFrontendTool
   clangIndex
   clangLex
   clangSema
   clangTooling
 )
 
 if (CLANG_ENABLE_ARCMT)
   list(APPEND LIBS clangARCMigrate)

tools/libclang/CXStoredDiagnostic.cpp

 #include "CIndexDiagnostic.h"
 #include "CIndexer.h"
 #include "CXTranslationUnit.h"
 #include "CXSourceLocation.h"
 #include "CXString.h"
 
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/ADT/Twine.h"
 
 using namespace clang;
 using namespace clang::cxloc;
 
 CXDiagnosticSeverity CXStoredDiagnostic::getSeverity() const {
   switch (Diag.getLevel()) {
     case DiagnosticsEngine::Ignored: return CXDiagnostic_Ignored;

 }
 
 CXString CXStoredDiagnostic::getSpelling() const {
   return cxstring::createRef(Diag.getMessage());
 }
 
 CXString CXStoredDiagnostic::getDiagnosticOption(CXString *Disable) const {
   unsigned ID = Diag.getID();
-  StringRef Option = DiagnosticIDs::getWarningOptionForDiag(ID);
+  std::unique_ptr<DiagnosticIDs> IDs(AllDiagnostics());
+  StringRef Option = IDs->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());
+  std::unique_ptr<DiagnosticIDs> IDs(AllDiagnostics());
+  return IDs->getCategoryNumberForDiag(Diag.getID());
 }
 
 CXString CXStoredDiagnostic::getCategoryText() const {
-  unsigned catID = DiagnosticIDs::getCategoryNumberForDiag(Diag.getID());
-  return cxstring::createRef(DiagnosticIDs::getCategoryNameFromID(catID));
+  std::unique_ptr<DiagnosticIDs> IDs(AllDiagnostics());
+  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();
 }

tools/libclang/Indexing.cpp

 #include "CXString.h"
 #include "CXTranslationUnit.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/Utils.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Index/IndexingAction.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/PPConditionalDirectiveRecord.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/MemoryBuffer.h"
static CXErrorCode clang_indexSourceFile_Impl(
 
   bool CaptureDiagnostics = !Logger::isLoggingEnabled();
 
   CaptureDiagnosticConsumer *CaptureDiag = nullptr;
   if (CaptureDiagnostics)
     CaptureDiag = new CaptureDiagnosticConsumer();
 
   // Configure the diagnostics.
-  IntrusiveRefCntPtr<DiagnosticsEngine>
-    Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions,
-                                              CaptureDiag,
-                                              /*ShouldOwnClient=*/true));
+  IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
+      CompilerInstance::createDiagnostics(AllDiagnostics(),
+                                          new DiagnosticOptions, CaptureDiag,
+                                          /*ShouldOwnClient=*/true);
 
   // Recover resources if we crash before exiting this function.
   llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
     llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
     DiagCleanup(Diags.get());
 
   std::unique_ptr<std::vector<const char *>> Args(
       new std::vector<const char *>());

unittests/AST/ASTVectorTest.cpp

 //===- unittests/AST/DeclTest.cpp --- Declaration tests -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Unit tests for the ASTVector container.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTVector.h"
+#include "clang/AST/ASTContext.h"
 #include "clang/Basic/Builtins.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 
 namespace clang {
 namespace ast {
 
 namespace {
 class ASTVectorTest : public ::testing::Test {
 protected:
   ASTVectorTest()
-      : FileMgr(FileMgrOpts), DiagID(new DiagnosticIDs()),
+      : FileMgr(FileMgrOpts), DiagID(AllDiagnostics()),
         Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
         SourceMgr(Diags, FileMgr), Idents(LangOpts, nullptr),
         Ctxt(LangOpts, SourceMgr, Idents, Sels, Builtins) {}
 
   FileSystemOptions FileMgrOpts;
   FileManager FileMgr;
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
   DiagnosticsEngine Diags;

unittests/AST/CommentLexer.cpp

 //===- unittests/AST/CommentLexer.cpp ------ Comment lexer tests ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/CommentLexer.h"
 #include "clang/AST/CommentCommandTraits.h"
 #include "clang/Basic/CommentOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/ADT/STLExtras.h"
 #include "gtest/gtest.h"
 #include <vector>
 
 using namespace llvm;
 using namespace clang;
 
 namespace clang {
 namespace comments {
 
 namespace {
 class CommentLexerTest : public ::testing::Test {
 protected:
   CommentLexerTest()
     : FileMgr(FileMgrOpts),
-      DiagID(new DiagnosticIDs()),
+      DiagID(AllDiagnostics()),
       Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
       SourceMgr(Diags, FileMgr),
       Traits(Allocator, CommentOptions()) {
   }
 
   FileSystemOptions FileMgrOpts;
   FileManager FileMgr;
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;

unittests/AST/CommentParser.cpp

 #include "clang/AST/CommentCommandTraits.h"
 #include "clang/AST/CommentLexer.h"
 #include "clang/AST/CommentSema.h"
 #include "clang/Basic/CommentOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Allocator.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace clang;
 
 namespace clang {
 namespace comments {
 
 namespace {
 
 const bool DEBUG = true;
 
 class CommentParserTest : public ::testing::Test {
 protected:
   CommentParserTest()
     : FileMgr(FileMgrOpts),
-      DiagID(new DiagnosticIDs()),
+      DiagID(AllDiagnostics()),
       Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
       SourceMgr(Diags, FileMgr),
       Traits(Allocator, CommentOptions()) {
   }
 
   FileSystemOptions FileMgrOpts;
   FileManager FileMgr;
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;

unittests/AST/ExternalASTSourceTest.cpp

 //===- unittest/AST/ExternalASTSourceTest.cpp -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains tests for Clang's ExternalASTSource.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
-#include "clang/AST/ExternalASTSource.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendActions.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace llvm;
 
 
 class TestFrontendAction : public ASTFrontendAction {
private:
   }
 
   IntrusiveRefCntPtr<ExternalASTSource> Source;
 };
 
 bool testExternalASTSource(ExternalASTSource *Source,
                            StringRef FileContents) {
   CompilerInstance Compiler;
-  Compiler.createDiagnostics();
+  Compiler.createDiagnostics(AllDiagnostics());
 
   auto Invocation = std::make_shared<CompilerInvocation>();
   Invocation->getPreprocessorOpts().addRemappedFile(
       "test.cc", MemoryBuffer::getMemBuffer(FileContents).release());
   const char *Args[] = { "test.cc" };
   CompilerInvocation::CreateFromArgs(*Invocation, Args,
                                      Args + array_lengthof(Args),
                                      Compiler.getDiagnostics());

unittests/Basic/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(BasicTests
   CharInfoTest.cpp
   DiagnosticTest.cpp
   FileManagerTest.cpp
   MemoryBufferCacheTest.cpp
   SourceManagerTest.cpp
   VirtualFileSystemTest.cpp
   )
 
 target_link_libraries(BasicTests
   PRIVATE
   clangBasic
+  clangFrontendTool
   clangLex
   )

unittests/Basic/DiagnosticTest.cpp

 //===- unittests/Basic/DiagnosticTest.cpp -- Diagnostic engine tests ------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticError.h"
 #include "clang/Basic/DiagnosticIDs.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace clang;
 
 namespace {
 
 // Check that DiagnosticErrorTrap works with SuppressAllDiagnostics.
 TEST(DiagnosticTest, suppressAndTrap) {
-  DiagnosticsEngine Diags(new DiagnosticIDs(),
+  DiagnosticsEngine Diags(AllDiagnostics(),
                           new DiagnosticOptions,
                           new IgnoringDiagConsumer());
   Diags.setSuppressAllDiagnostics(true);
 
   {
     DiagnosticErrorTrap trap(Diags);
 
     // Diag that would set UncompilableErrorOccurred and ErrorOccurred.
TEST(DiagnosticTest, suppressAndTrap) {
   EXPECT_FALSE(Diags.hasFatalErrorOccurred());
   EXPECT_FALSE(Diags.hasUncompilableErrorOccurred());
   EXPECT_FALSE(Diags.hasUnrecoverableErrorOccurred());
 }
 
 // Check that SuppressAfterFatalError works as intended
 TEST(DiagnosticTest, suppressAfterFatalError) {
   for (unsigned Suppress = 0; Suppress != 2; ++Suppress) {
-    DiagnosticsEngine Diags(new DiagnosticIDs(),
+    DiagnosticsEngine Diags(AllDiagnostics(),
                             new DiagnosticOptions,
                             new IgnoringDiagConsumer());
     Diags.setSuppressAfterFatalError(Suppress);
 
     // Diag that would set UnrecoverableErrorOccurred and ErrorOccurred.
     Diags.Report(diag::err_cannot_open_file) << "file" << "error";
 
     // Diag that would set FatalErrorOccurred
     // (via non-note following a fatal error).
     Diags.Report(diag::warn_mt_message) << "warning";
 
     EXPECT_TRUE(Diags.hasErrorOccurred());
     EXPECT_TRUE(Diags.hasFatalErrorOccurred());
     EXPECT_TRUE(Diags.hasUncompilableErrorOccurred());
     EXPECT_TRUE(Diags.hasUnrecoverableErrorOccurred());
 
     // The warning should be emitted and counted only if we're not suppressing
     // after fatal errors.
     EXPECT_EQ(Diags.getNumWarnings(), Suppress ? 0u : 1u);
   }
 }
 
 TEST(DiagnosticTest, diagnosticError) {
-  DiagnosticsEngine Diags(new DiagnosticIDs(), new DiagnosticOptions,
+  DiagnosticsEngine Diags(AllDiagnostics(), new DiagnosticOptions,
                           new IgnoringDiagConsumer());
   PartialDiagnostic::StorageAllocator Alloc;
   llvm::Expected<std::pair<int, int>> Value = DiagnosticError::create(
       SourceLocation(), PartialDiagnostic(diag::err_cannot_open_file, Alloc)
                             << "file"
                             << "error");
   ASSERT_TRUE(!Value);
   llvm::Error Err = Value.takeError();

unittests/Basic/SourceManagerTest.cpp

 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/MemoryBufferCache.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/ModuleLoader.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Config/llvm-config.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 
 namespace {
 
 // The test fixture.
 class SourceManagerTest : public ::testing::Test {
 protected:
   SourceManagerTest()
     : FileMgr(FileMgrOpts),
-      DiagID(new DiagnosticIDs()),
+      DiagID(AllDiagnostics()),
       Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
       SourceMgr(Diags, FileMgr),
       TargetOpts(new TargetOptions) {
     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
     Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
   }
 
   FileSystemOptions FileMgrOpts;

unittests/CodeGen/BufferSourceTest.cpp

 //===- unittests/CodeGen/BufferSourceTest.cpp - MemoryBuffer source tests -===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Frontend/CompilerInstance.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Parse/ParseAST.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "gtest/gtest.h"
const char TestProgram[] =
     "   EmitCXXGlobalInitFunc() {}  "
     "};                             "
     "EmitCXXGlobalInitFunc test;    ";
 
 TEST(BufferSourceTest, EmitCXXGlobalInitFunc) {
     LLVMContext Context;
     CompilerInstance compiler;
 
-    compiler.createDiagnostics();
+    compiler.createDiagnostics(AllDiagnostics());
     compiler.getLangOpts().CPlusPlus = 1;
     compiler.getLangOpts().CPlusPlus11 = 1;
 
     compiler.getTargetOpts().Triple = llvm::Triple::normalize(
         llvm::sys::getProcessTriple());
     compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
       compiler.getDiagnostics(),
       std::make_shared<clang::TargetOptions>(

unittests/CodeGen/CMakeLists.txt

add_clang_unittest(ClangCodeGenTests
   )
 
 target_link_libraries(ClangCodeGenTests
   PRIVATE
   clangAST
   clangBasic
   clangCodeGen
   clangFrontend
+  clangFrontendTool
   clangLex
   clangParse
   )

unittests/CodeGen/CodeGenExternalTest.cpp

 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/GlobalDecl.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/CodeGenABITypes.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Frontend/CompilerInstance.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Parse/ParseAST.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Host.h"
static void test_codegen_fns(MyASTConsumer *my) {
 
   test_codegen_fns_ran = true;
 }
 
 TEST(CodeGenExternalTest, CodeGenExternalTest) {
     LLVMContext Context;
     CompilerInstance compiler;
 
-    compiler.createDiagnostics();
+    compiler.createDiagnostics(AllDiagnostics());
     compiler.getLangOpts().CPlusPlus = 1;
     compiler.getLangOpts().CPlusPlus11 = 1;
 
     compiler.getTargetOpts().Triple = llvm::Triple::normalize(
         llvm::sys::getProcessTriple());
     compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
       compiler.getDiagnostics(),
       std::make_shared<clang::TargetOptions>(

unittests/CodeGen/IncrementalProcessingTest.cpp

 //=== unittests/CodeGen/IncrementalProcessingTest.cpp - IncrementalCodeGen ===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Frontend/CompilerInstance.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
const Function* getGlobalInit(llvm::Module& M) {
 
   return nullptr;
 }
 
 TEST(IncrementalProcessing, EmitCXXGlobalInitFunc) {
     LLVMContext Context;
     CompilerInstance compiler;
 
-    compiler.createDiagnostics();
+    compiler.createDiagnostics(AllDiagnostics());
     compiler.getLangOpts().CPlusPlus = 1;
     compiler.getLangOpts().CPlusPlus11 = 1;
 
     compiler.getTargetOpts().Triple = llvm::Triple::normalize(
         llvm::sys::getProcessTriple());
     compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
       compiler.getDiagnostics(),
       std::make_shared<clang::TargetOptions>(

unittests/CodeGen/TBAAMetadataTest.cpp

 //=== unittests/CodeGen/TBAAMetadataTest.cpp - Checks metadata generation -===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IRMatchers.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Frontend/CompilerInstance.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Parse/ParseAST.h"
 #include "llvm/ADT/Triple.h"
-#include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "gtest/gtest.h"
 #include <memory>
 
 using namespace llvm;
 
 namespace {
 
 struct TestCompiler {
   LLVMContext Context;
   clang::CompilerInstance compiler;
   clang::CodeGenerator *CG = nullptr;
   llvm::Module *M = nullptr;
   unsigned PtrSize = 0;
 
   void init(const char *TestProgram) {
-    compiler.createDiagnostics();
+    compiler.createDiagnostics(clang::AllDiagnostics());
     compiler.getCodeGenOpts().StructPathTBAA = 1;
     compiler.getCodeGenOpts().OptimizationLevel = 1;
 
     std::string TrStr = llvm::Triple::normalize(llvm::sys::getProcessTriple());
     llvm::Triple Tr(TrStr);
     Tr.setOS(Triple::Linux);
     Tr.setVendor(Triple::VendorType::UnknownVendor);
     Tr.setEnvironment(Triple::EnvironmentType::UnknownEnvironment);

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/Driver/CMakeLists.txt

add_clang_unittest(ClangDriverTests
   ModuleCacheTest.cpp
   MultilibTest.cpp
   )
 
 target_link_libraries(ClangDriverTests
   PRIVATE
   clangDriver
   clangBasic
+  clangFrontendTool
   )

unittests/Driver/ToolChainTest.cpp

 
 #include "clang/Driver/ToolChain.h"
 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/VirtualFileSystem.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 using namespace clang;
 using namespace clang::driver;
 
 namespace {
 
 TEST(ToolChainTest, VFSGCCInstallation) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID = AllDiagnostics();
   struct TestDiagnosticConsumer : public DiagnosticConsumer {};
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   Driver TheDriver("/bin/clang", "arm-linux-gnueabihf", Diags,
                    InMemoryFileSystem);
 
   const char *EmptyFiles[] = {
EXPECT_EQ(
       "Candidate multilib: .;@m32\n"
       "Selected multilib: .;@m32\n",
       S);
 }
 
 TEST(ToolChainTest, VFSGCCInstallationRelativeDir) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID = AllDiagnostics();
   struct TestDiagnosticConsumer : public DiagnosticConsumer {};
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
   Driver TheDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
                    InMemoryFileSystem);
 
   const char *EmptyFiles[] = {
EXPECT_EQ("Found candidate GCC installation: "
             "Candidate multilib: .;@m32\n"
             "Selected multilib: .;@m32\n",
             S);
 }
 
 TEST(ToolChainTest, DefaultDriverMode) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID = AllDiagnostics();
   struct TestDiagnosticConsumer : public DiagnosticConsumer {};
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
       new vfs::InMemoryFileSystem);
 
   Driver CCDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
                   InMemoryFileSystem);
   CCDriver.setCheckInputsExist(false);
TEST(ToolChainTest, DefaultDriverMode) {
   EXPECT_TRUE(CC);
   EXPECT_TRUE(CXX);
   EXPECT_TRUE(CL);
   EXPECT_TRUE(CCDriver.CCCIsCC());
   EXPECT_TRUE(CXXDriver.CCCIsCXX());
   EXPECT_TRUE(CLDriver.IsCLMode());
 }
 TEST(ToolChainTest, InvalidArgument) {
-  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID = AllDiagnostics();
   struct TestDiagnosticConsumer : public DiagnosticConsumer {};
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
   Driver TheDriver("/bin/clang", "arm-linux-gnueabihf", Diags);
   std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
       {"-fsyntax-only", "-fan-unknown-option", "foo.cpp"}));
   EXPECT_TRUE(C);
   EXPECT_TRUE(C->containsError());

unittests/Format/CMakeLists.txt

add_clang_unittest(FormatTests
   UsingDeclarationsSorterTest.cpp
   )
 
 target_link_libraries(FormatTests
   PRIVATE
   clangBasic
   clangFormat
   clangFrontend
+  clangFrontendTool
   clangRewrite
   clangToolingCore
   )

unittests/Frontend/ASTUnitTest.cpp

 //===- unittests/Frontend/ASTUnitTest.cpp - ASTUnit tests -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <fstream>
 
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/PCHContainerOperations.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace clang;
 
TEST(ASTUnit, SaveLoadPreservesLangOptionsInPrintingPolicy) {
   llvm::SmallString<256> InputFileName;
   ASSERT_FALSE(llvm::sys::fs::createTemporaryFile("ast-unit", "cpp", FD, InputFileName));
   ToolOutputFile input_file(InputFileName, FD);
   input_file.os() << "";
 
   const char* Args[] = {"clang", "-xc++", InputFileName.c_str()};
 
   IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
-      CompilerInstance::createDiagnostics(new DiagnosticOptions());
+      CompilerInstance::createDiagnostics(AllDiagnostics(),
+                                          new DiagnosticOptions());
 
   std::shared_ptr<CompilerInvocation> CInvok =
       createInvocationFromCommandLine(Args, Diags);
 
   if (!CInvok)
     FAIL() << "could not create compiler invocation";
 
   FileManager *FileMgr =

unittests/Frontend/CodeGenActionTest.cpp

 //===- unittests/Frontend/CodeGenActionTest.cpp --- FrontendAction tests --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Unit tests for CodeGenAction.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/CodeGen/BackendUtil.h"
 #include "clang/CodeGen/CodeGenAction.h"
+#include "clang/CodeGen/BackendUtil.h"
 #include "clang/Frontend/CompilerInstance.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace clang;
 using namespace clang::frontend;
 
 namespace {
Invocation->getPreprocessorOpts().addRemappedFile(
       "test.cc",
       MemoryBuffer::getMemBuffer("").release());
   Invocation->getFrontendOpts().Inputs.push_back(
       FrontendInputFile("test.cc", InputKind::CXX));
   Invocation->getFrontendOpts().ProgramAction = EmitLLVM;
   Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
   CompilerInstance Compiler;
   Compiler.setInvocation(std::move(Invocation));
-  Compiler.createDiagnostics();
+  Compiler.createDiagnostics(AllDiagnostics());
   EXPECT_TRUE(Compiler.hasDiagnostics());
 
   std::unique_ptr<FrontendAction> Act(new NullCodeGenAction);
   bool Success = Compiler.ExecuteAction(*Act);
   EXPECT_TRUE(Success);
 }
 
 }

unittests/Frontend/CompilerInstanceTest.cpp

 //===- unittests/Frontend/CompilerInstanceTest.cpp - CI tests -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace clang;
 
TEST(CompilerInstance, DefaultVFSOverlayFromInvocation) {
   File.os() << format(VFSYaml, CurrentPathStr.c_str(), FileName.c_str());
   File.os().flush();
 
   // Create a CompilerInvocation that uses this overlay file.
   const std::string VFSArg = "-ivfsoverlay" + FileNameStr;
   const char *Args[] = {"clang", VFSArg.c_str(), "-xc++", "-"};
 
   IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
-      CompilerInstance::createDiagnostics(new DiagnosticOptions());
+      CompilerInstance::createDiagnostics(AllDiagnostics(),
+                                          new DiagnosticOptions());
 
   std::shared_ptr<CompilerInvocation> CInvok =
       createInvocationFromCommandLine(Args, Diags);
 
   if (!CInvok)
     FAIL() << "could not create compiler invocation";
   // Create a minimal CompilerInstance which should use the VFS we specified
   // in the CompilerInvocation (as we don't explicitly set our own).

unittests/Frontend/FrontendActionTest.cpp

 //===- unittests/Frontend/FrontendActionTest.cpp - FrontendAction tests ---===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Frontend/FrontendAction.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
-#include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/FrontendActions.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
invocation->getPreprocessorOpts().addRemappedFile(
       "test.cc",
       MemoryBuffer::getMemBuffer("int main() { float x; }").release());
   invocation->getFrontendOpts().Inputs.push_back(
       FrontendInputFile("test.cc", InputKind::CXX));
   invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
   invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
   CompilerInstance compiler;
   compiler.setInvocation(std::move(invocation));
-  compiler.createDiagnostics();
+  compiler.createDiagnostics(AllDiagnostics());
 
   TestASTFrontendAction test_action;
   ASSERT_TRUE(compiler.ExecuteAction(test_action));
   ASSERT_EQ(2U, test_action.decl_names.size());
   EXPECT_EQ("main", test_action.decl_names[0]);
   EXPECT_EQ("x", test_action.decl_names[1]);
 }
 
 TEST(ASTFrontendAction, IncrementalParsing) {
   auto invocation = std::make_shared<CompilerInvocation>();
   invocation->getPreprocessorOpts().addRemappedFile(
       "test.cc",
       MemoryBuffer::getMemBuffer("int main() { float x; }").release());
   invocation->getFrontendOpts().Inputs.push_back(
       FrontendInputFile("test.cc", InputKind::CXX));
   invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
   invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
   CompilerInstance compiler;
   compiler.setInvocation(std::move(invocation));
-  compiler.createDiagnostics();
+  compiler.createDiagnostics(AllDiagnostics());
 
   TestASTFrontendAction test_action(/*enableIncrementalProcessing=*/true);
   ASSERT_TRUE(compiler.ExecuteAction(test_action));
   ASSERT_EQ(2U, test_action.decl_names.size());
   EXPECT_EQ("main", test_action.decl_names[0]);
   EXPECT_EQ("x", test_action.decl_names[1]);
 }
 
"test.cc", MemoryBuffer::getMemBuffer(
       "};\n"
       "B<char> c() { return B<char>(); }\n").release());
   invocation->getFrontendOpts().Inputs.push_back(
       FrontendInputFile("test.cc", InputKind::CXX));
   invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
   invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
   CompilerInstance compiler;
   compiler.setInvocation(std::move(invocation));
-  compiler.createDiagnostics();
+  compiler.createDiagnostics(AllDiagnostics());
 
   TestASTFrontendAction test_action(/*enableIncrementalProcessing=*/true,
                                     /*actOnEndOfTranslationUnit=*/true);
   ASSERT_TRUE(compiler.ExecuteAction(test_action));
   ASSERT_EQ(13U, test_action.decl_names.size());
   EXPECT_EQ("A", test_action.decl_names[0]);
   EXPECT_EQ("c", test_action.decl_names[12]);
 }
Invocation->getPreprocessorOpts().addRemappedFile(
       "test.cc",
       MemoryBuffer::getMemBuffer("int main() { float x; }").release());
   Invocation->getFrontendOpts().Inputs.push_back(
       FrontendInputFile("test.cc", InputKind::CXX));
   Invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
   Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
   CompilerInstance Compiler;
   Compiler.setInvocation(std::move(Invocation));
-  Compiler.createDiagnostics();
+  Compiler.createDiagnostics(AllDiagnostics());
 
   TestPPCallbacks *Callbacks = new TestPPCallbacks;
   TestPPCallbacksFrontendAction TestAction(Callbacks);
   ASSERT_FALSE(Callbacks->SeenEnd);
   ASSERT_FALSE(TestAction.SeenEnd);
   ASSERT_TRUE(Compiler.ExecuteAction(TestAction));
   // Check that EndOfMainFile was called before EndSourceFileAction.
   ASSERT_TRUE(TestAction.SeenEnd);
Invocation->getPreprocessorOpts().addRemappedFile(
                      .release());
   Invocation->getFrontendOpts().Inputs.push_back(
       FrontendInputFile("test.cc", InputKind::CXX));
   Invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
   Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
   CompilerInstance Compiler;
   Compiler.setInvocation(std::move(Invocation));
   auto *TDC = new TypoDiagnosticConsumer;
-  Compiler.createDiagnostics(TDC, /*ShouldOwnClient=*/true);
+  Compiler.createDiagnostics(
+      AllDiagnostics(), TDC,
+      /*ShouldOwnClient=*/true);
   Compiler.setExternalSemaSource(new TypoExternalSemaSource(Compiler));
 
   SyntaxOnlyAction TestAction;
   ASSERT_TRUE(Compiler.ExecuteAction(TestAction));
   // There should be one error correcting to 'moo' and a note attached to it.
   EXPECT_EQ("use of undeclared identifier 'foo'; did you mean 'moo'?",
             TDC->Error.str().str());
   EXPECT_EQ("This is a note", TDC->Note.str().str());
 }
 
 } // anonymous namespace

unittests/Frontend/OutputStreamTest.cpp

 //===- unittests/Frontend/OutputStreamTest.cpp --- FrontendAction tests --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/CodeGen/BackendUtil.h"
 #include "clang/CodeGen/CodeGenAction.h"
 #include "clang/Frontend/CompilerInstance.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/FrontendTool/Utils.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace clang;
 using namespace clang::frontend;
 
TEST(FrontendOutputTests, TestOutputStream) {
   CompilerInstance Compiler;
 
   SmallVector<char, 256> IRBuffer;
   std::unique_ptr<raw_pwrite_stream> IRStream(
       new raw_svector_ostream(IRBuffer));
 
   Compiler.setOutputStream(std::move(IRStream));
   Compiler.setInvocation(std::move(Invocation));
-  Compiler.createDiagnostics();
+  Compiler.createDiagnostics(AllDiagnostics());
 
   bool Success = ExecuteCompilerInvocation(&Compiler);
   EXPECT_TRUE(Success);
   EXPECT_TRUE(!IRBuffer.empty());
   EXPECT_TRUE(StringRef(IRBuffer.data()).startswith("BC"));
 }
 }

unittests/Frontend/PCHPreambleTest.cpp

 //====-- unittests/Frontend/PCHPreambleTest.cpp - FrontendAction tests ---====//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/FileManager.h"
 #include "clang/Frontend/ASTUnit.h"
-#include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/FrontendOptions.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/PreprocessorOptions.h"
-#include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/FileManager.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace clang;
 
std::unique_ptr<ASTUnit> ParseAST(const std::string &EntryFile) {
 
     CI->getTargetOpts().Triple = "i386-unknown-linux-gnu";
 
     CI->getPreprocessorOpts().RemappedFileBuffers = GetRemappedFiles();
 
     PreprocessorOptions &PPOpts = CI->getPreprocessorOpts();
     PPOpts.RemappedFilesKeepOriginalName = true;
 
-    IntrusiveRefCntPtr<DiagnosticsEngine>
-      Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions, new DiagnosticConsumer));
+    IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
+        CompilerInstance::createDiagnostics(
+            AllDiagnostics(), new DiagnosticOptions, new DiagnosticConsumer));
 
     FileManager *FileMgr = new FileManager(FSOpts, VFS);
 
     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(
       CI, PCHContainerOpts, Diags, FileMgr, false, false,
       /*PrecompilePreambleAfterNParses=*/1);
     return AST;
   }

unittests/Lex/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(LexTests
   HeaderMapTest.cpp
   HeaderSearchTest.cpp
   LexerTest.cpp
   PPCallbacksTest.cpp
   PPConditionalDirectiveRecordTest.cpp
   )
 
 target_link_libraries(LexTests
   PRIVATE
   clangAST
   clangBasic
+  clangFrontendTool
   clangLex
   clangParse
   clangSema
   )

unittests/Lex/HeaderSearchTest.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/MemoryBufferCache.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace {
 
 // The test fixture.
 class HeaderSearchTest : public ::testing::Test {
 protected:
   HeaderSearchTest()
       : VFS(new vfs::InMemoryFileSystem), FileMgr(FileMgrOpts, VFS),
-        DiagID(new DiagnosticIDs()),
+        DiagID(AllDiagnostics()),
         Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
         SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions),
         Search(std::make_shared<HeaderSearchOptions>(), SourceMgr, Diags,
                LangOpts, Target.get()) {
     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
     Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
   }
 

unittests/Lex/LexerTest.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/MemoryBufferCache.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/MacroArgs.h"
 #include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/ModuleLoader.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 
 namespace {
 
 // The test fixture.
 class LexerTest : public ::testing::Test {
 protected:
   LexerTest()
     : FileMgr(FileMgrOpts),
-      DiagID(new DiagnosticIDs()),
+      DiagID(AllDiagnostics()),
       Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
       SourceMgr(Diags, FileMgr),
       TargetOpts(new TargetOptions)
   {
     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
     Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
   }
 

unittests/Lex/PPCallbacksTest.cpp

 //===- unittests/Lex/PPCallbacksTest.cpp - PPCallbacks tests ------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===--------------------------------------------------------------===//
 
-#include "clang/Lex/Preprocessor.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/MemoryBufferCache.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/ModuleLoader.h"
+#include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Path.h"
 #include "gtest/gtest.h"
 
 using namespace clang;

 };
 
 // PPCallbacks test fixture.
 class PPCallbacksTest : public ::testing::Test {
 protected:
   PPCallbacksTest()
       : InMemoryFileSystem(new vfs::InMemoryFileSystem),
         FileMgr(FileSystemOptions(), InMemoryFileSystem),
-        DiagID(new DiagnosticIDs()), DiagOpts(new DiagnosticOptions()),
+        DiagID(AllDiagnostics()), DiagOpts(new DiagnosticOptions()),
         Diags(DiagID, DiagOpts.get(), new IgnoringDiagConsumer()),
         SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions()) {
     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
     Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
   }
 
   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem;
   FileManager FileMgr;

unittests/Lex/PPConditionalDirectiveRecordTest.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/MemoryBufferCache.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/ModuleLoader.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 
 namespace {
 
 // The test fixture.
 class PPConditionalDirectiveRecordTest : public ::testing::Test {
 protected:
   PPConditionalDirectiveRecordTest()
     : FileMgr(FileMgrOpts),
-      DiagID(new DiagnosticIDs()),
+      DiagID(AllDiagnostics()),
       Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
       SourceMgr(Diags, FileMgr),
       TargetOpts(new TargetOptions)
   {
     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
     Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
   }
 

unittests/Rename/CMakeLists.txt

 
 target_link_libraries(ClangRenameTests
   PRIVATE
   clangAST
   clangASTMatchers
   clangBasic
   clangFormat
   clangFrontend
+  clangFrontendTool
   clangRewrite
   clangTooling
   clangToolingCore
   clangToolingRefactor
   )

unittests/Tooling/CMakeLists.txt

 
 target_link_libraries(ToolingTests
   PRIVATE
   clangAST
   clangASTMatchers
   clangBasic
   clangFormat
   clangFrontend
+  clangFrontendTool
   clangLex
   clangRewrite
   clangTooling
   clangToolingCore
   clangToolingRefactor
   )

unittests/Tooling/RewriterTestContext.h

 #define LLVM_CLANG_UNITTESTS_TOOLING_REWRITERTESTCONTEXT_H
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/FrontendTool/DiagnosticTable.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 
 /// \brief A class that sets up a ready to use Rewriter.
 ///
 /// Useful in unit tests that need a Rewriter. Creates all dependencies
 /// 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),
+         Diagnostics(AllDiagnostics(), &*DiagOpts),
+         DiagnosticPrinter(llvm::outs(), Diagnostics.getDiagnosticIDs(),
                            &*DiagOpts),
-         DiagnosticPrinter(llvm::outs(), &*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));