Frontend: Add CompilerInvocation and DiagnosticsEngine to the builder

[dexonsmith]

Summary

Add CompilerInvocation and DiagnosticsEngine to the new builder,
replacing a number of no-longer-needed CompilerInstance mutators.
These are in the same commit because the construction of a
CompilerInvocation and a DiagnosticsEngine is interestingly
entangled, since they each can depend on the other. When the dependency
is truly cyclic, a temporary DiagnosticsEngine is used to construct
the CompilerInvocation, then the latter to construct the "real"
DiagnosticsEngine and the former's diagnostics are replayed.

clang-tools-extra/clang-include-fixer/IncludeFixer.cpp

 bool IncludeFixerActionFactory::runInvocation(
     std::shared_ptr<clang::CompilerInvocation> Invocation,
     clang::FileManager *Files,
     std::shared_ptr<clang::PCHContainerOperations> PCHContainerOps,
     clang::DiagnosticConsumer *Diagnostics) {
   assert(Invocation->getFrontendOpts().Inputs.size() == 1);
 
   // Set up Clang.
-  clang::CompilerInstance Compiler(PCHContainerOps);
-  Compiler.setInvocation(std::move(Invocation));
+  clang::CompilerInstance Compiler(CompilerInstanceBuilder()
+                                       .pchContainerOps(PCHContainerOps)
+                                       .invocation(std::move(Invocation))
+                                       .diags<IgnoringDiagConsumer>());
   Compiler.setFileManager(Files);
 
-  // Create the compiler's actual diagnostics engine. We want to drop all
-  // diagnostics here.
-  Compiler.createDiagnostics(new clang::IgnoringDiagConsumer,
-                             /*ShouldOwnClient=*/true);
   Compiler.createSourceManager(*Files);
 
   // We abort on fatal errors so don't let a large number of errors become
   // fatal. A missing #include can cause thousands of errors.
   Compiler.getDiagnostics().setErrorLimit(0);
 
   // Run the parser, gather missing includes.
   auto ScopedToolAction =

clang-tools-extra/clangd/Compiler.cpp

prepareCompilerInstance(std::unique_ptr<clang::CompilerInvocation> CI,
   if (Preamble) {
     Preamble->OverridePreamble(*CI, VFS, Buffer.get());
   } else {
     CI->getPreprocessorOpts().addRemappedFile(
         CI->getFrontendOpts().Inputs[0].getFile(), Buffer.get());
   }
 
   auto Clang = llvm::make_unique<CompilerInstance>(
-      std::make_shared<PCHContainerOperations>());
-  Clang->setInvocation(std::move(CI));
-  Clang->createDiagnostics(&DiagsClient, false);
+      CompilerInstanceBuilder().invocation(std::move(CI)).diags(DiagsClient));
 
   if (auto VFSWithRemapping = createVFSFromCompilerInvocation(
           Clang->getInvocation(), Clang->getDiagnostics(), VFS))
     VFS = VFSWithRemapping;
   Clang->createFileManager(VFS);
 
   Clang->setTarget(TargetInfo::CreateTargetInfo(
       Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));

clang/examples/clang-interpreter/main.cpp

#endif
   const driver::Command &Cmd = cast<driver::Command>(*Jobs.begin());
   if (llvm::StringRef(Cmd.getCreator().getName()) != "clang") {
     Diags.Report(diag::err_fe_expected_clang_command);
     return 1;
   }
 
   // Initialize a compiler invocation object from the clang (-cc1) arguments.
   const llvm::opt::ArgStringList &CCArgs = Cmd.getArguments();
-  std::unique_ptr<CompilerInvocation> CI(new CompilerInvocation);
-  CompilerInvocation::CreateFromArgs(*CI,
-                                     const_cast<const char **>(CCArgs.data()),
-                                     const_cast<const char **>(CCArgs.data()) +
-                                       CCArgs.size(),
-                                     Diags);
+
+  // FIXME: This is copied from cc1_main.cpp; simplify and eliminate.
+
+  // Create a compiler instance to handle the actual work.
+  CompilerInstance Clang(
+      CompilerInstanceBuilder()
+          .invocation(const_cast<const char **>(CCArgs.data()),
+                      const_cast<const char **>(CCArgs.data()) + CCArgs.size())
+          .inferResourceDir(argv[0], MainAddr));
 
   // Show the invocation, with -v.
-  if (CI->getHeaderSearchOpts().Verbose) {
+  if (Clang.getHeaderSearchOpts().Verbose) {
     llvm::errs() << "clang invocation:\n";
     Jobs.Print(llvm::errs(), "\n", true);
     llvm::errs() << "\n";
   }
 
-  // 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();
-  if (!Clang.hasDiagnostics())
+  if (Clang.getInvocation().hasError())
     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);
-
   // Create and execute the frontend to generate an LLVM bitcode module.
   std::unique_ptr<CodeGenAction> Act(new EmitLLVMOnlyAction());
   if (!Clang.ExecuteAction(*Act))
     return 1;
 
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
 

clang/include/clang/Frontend/CompilerInstance.h

public:
 
   bool hasInvocation() const { return Invocation != nullptr; }
 
   CompilerInvocation &getInvocation() {
     assert(Invocation && "Compiler instance has no invocation!");
     return *Invocation;
   }
 
-  /// setInvocation - Replace the current invocation.
-  void setInvocation(std::shared_ptr<CompilerInvocation> Value);
+  /// Drop the invocation.
+  void resetInvocation() { Invocation.reset(); }
 
   /// Indicates whether we should (re)build the global module index.
   bool shouldBuildGlobalModuleIndex() const;
 
   /// Set the flag indicating whether we should (re)build the global
   /// module index.
   void setBuildGlobalModuleIndex(bool Build) {
     BuildGlobalModuleIndex = Build;
public:
   bool hasDiagnostics() const { return Diagnostics != nullptr; }
 
   /// Get the current diagnostics engine.
   DiagnosticsEngine &getDiagnostics() const {
     assert(Diagnostics && "Compiler instance has no diagnostics!");
     return *Diagnostics;
   }
 
-  /// setDiagnostics - Replace the current diagnostics engine.
-  void setDiagnostics(DiagnosticsEngine *Value);
-
   DiagnosticConsumer &getDiagnosticClient() const {
     assert(Diagnostics && Diagnostics->getClient() &&
            "Compiler instance has no diagnostic client!");
     return *Diagnostics->getClient();
   }
 
   /// }
   /// @name Target Info
public:
   /// streams must have been closed beforehand.
   ///
   /// \param EraseFiles - If true, attempt to erase the files from disk.
   void clearOutputFiles(bool EraseFiles);
 
   /// }
   /// @name Construction Utility Methods
   /// {
-
-  /// Create the diagnostics engine using the invocation's diagnostic options
-  /// and replace any existing one with it.
-  ///
-  /// Note that this routine also replaces the diagnostic client,
-  /// 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,
-                         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

clang/include/clang/Frontend/CompilerInstanceBuilder.h

 //===- CompilerInstanceBuilder.h - CompilerInstance Builder -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_FRONTEND_COMPILERINSTANCEBUILDER_H_
 #define LLVM_CLANG_FRONTEND_COMPILERINSTANCEBUILDER_H_
 
 namespace clang {
 
+class CompilerInvocation;
 class InMemoryModuleCache;
 class PCHContainerOperations;
 
 class CompilerInstanceBuilder {
+  bool MakeDiags = false;
+  bool MakeInvocation = false;
+  bool MakeInvocationFromDriver = false;
+  bool DidInitDiagsAndInvocation = false;
+  bool ShouldInferResourceDir = false;
+  const char *Argv0 = nullptr;
+  void *MainAddr = nullptr;
+  ArrayRef<const char *> Args;
+  DiagnosticConsumer *DiagsClient = nullptr;
+  std::unique_ptr<DiagnosticConsumer> OwnedDiagsClient;
   InMemoryModuleCache *SharedModuleCache = nullptr;
   std::shared_ptr<PCHContainerOperations> PCHContainerOps;
+  std::shared_ptr<CompilerInvocation> Invocation;
+  IntrusiveRefCntPtr<DiagnosticsEngine> Diags;
+  IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS; // For the driver.
 
 public:
   CompilerInstanceBuilder() = default;
   CompilerInstanceBuilder(CompilerInstanceBuilder &&) = default;
   CompilerInstanceBuilder(const CompilerInstanceBuilder &) = delete;
 
+  CompilerInstanceBuilder &&diags(DiagnosticsEngine &Diags) && {
+    // Own the consumer.
+    assert(!MakeDiags && "Already built diagnostics engine?");
+    assert(!this->Diags && "Already has diagnostics engine?");
+    this->Diags = &Diags;
+    return std::move(*this);
+  }
+
+  CompilerInstanceBuilder &&
+  diags(std::unique_ptr<DiagnosticConsumer> DiagsClient) && {
+    // Own the consumer.
+    assert(!MakeDiags && "Already built diagnostics engine?");
+    assert(!Diags && "Already has diagnostics engine?");
+    MakeDiags = true;
+    this->OwnedDiagsClient = std::move(DiagsClient);
+    return std::move(*this);
+  }
+
+  template <class DiagClientT, class... ArgsT>
+  CompilerInstanceBuilder &&diags(ArgsT &&... args) && {
+    // Own the consumer.
+    assert(!MakeDiags && "Already built diagnostics engine?");
+    assert(!Diags && "Already has diagnostics engine?");
+    MakeDiags = true;
+    this->OwnedDiagsClient =
+        llvm::make_unique<DiagClientT>(std::forward<ArgsT>(args)...);
+    return std::move(*this);
+  }
+
+  CompilerInstanceBuilder &&diags(DiagnosticConsumer &DiagsClient) && {
+    // Don't own the consumer.
+    assert(!MakeDiags && "Already built diagnostics engine?");
+    assert(!Diags && "Already has diagnostics engine?");
+    MakeDiags = true;
+    this->DiagsClient = &DiagsClient;
+    return std::move(*this);
+  }
+
+  CompilerInstanceBuilder &&
+  invocation(std::shared_ptr<CompilerInvocation> Invocation) && {
+    assert(!this->Invocation && "Already has an invocation?");
+    assert(!this->MakeInvocation && "Already built an invocation?");
+    this->Invocation = std::move(Invocation);
+    return std::move(*this);
+  }
+
+  CompilerInstanceBuilder &&invocationFromDriver(
+      ArrayRef<const char *> Args,
+      IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS = nullptr) && {
+    assert(!this->Invocation && "Already has an invocation?");
+    assert(!this->MakeInvocation && "Already built an invocation?");
+    this->Args = Args;
+    this->MakeInvocation = true;
+    this->MakeInvocationFromDriver = true;
+    return std::move(*this);
+  }
+
+  CompilerInstanceBuilder &&invocation(ArrayRef<const char *> Args) && {
+    assert(!this->Invocation && "Already has an invocation?");
+    assert(!this->MakeInvocation && "Already built an invocation?");
+    this->Args = Args;
+    this->MakeInvocation = true;
+    return std::move(*this);
+  }
+
+  CompilerInstanceBuilder &&invocation(const char *const *ArgBegin,
+                                       const char *const *ArgEnd) && {
+    return std::move(*this).invocation(
+        ArrayRef<const char *>(ArgBegin, ArgEnd));
+  }
+
+  CompilerInstanceBuilder &&inferResourceDir(const char *Argv0,
+                                             void *MainAddr) && {
+    assert(MakeInvocation && "Expected to be making an invocation?");
+    assert(!MakeInvocationFromDriver && "Expected a -cc1?");
+    ShouldInferResourceDir = true;
+    this->Argv0 = Argv0;
+    this->MainAddr = MainAddr;
+    return std::move(*this);
+  }
+
   CompilerInstanceBuilder &&
   pchContainerOps(std::shared_ptr<PCHContainerOperations> PCHContainerOps) && {
     this->PCHContainerOps = std::move(PCHContainerOps);
     return std::move(*this);
   }
 
   CompilerInstanceBuilder &&
   moduleCache(InMemoryModuleCache &SharedModuleCache) && {
     this->SharedModuleCache = &SharedModuleCache;
     return std::move(*this);
   }
 
 private:
   friend class CompilerInstance;
 
   // Deprecated, for CompilerInstance's current constructor.
   CompilerInstanceBuilder &&
   sharedModuleCache(InMemoryModuleCache *SharedModuleCache) && {
     this->SharedModuleCache = SharedModuleCache;
     return std::move(*this);
   }
 
   IntrusiveRefCntPtr<InMemoryModuleCache> getModuleCache();
   std::shared_ptr<PCHContainerOperations> getPCHContainerOps();
+  std::shared_ptr<CompilerInvocation> getInvocation();
+  IntrusiveRefCntPtr<DiagnosticsEngine> getDiags();
   bool isBuildingModule();
+  void initDiagsAndInvocation();
 };
 
 } // end namespace clang
 
 #endif

clang/include/clang/Frontend/CompilerInvocation.h

class CompilerInvocation : public CompilerInvocationBase {
   FileSystemOptions FileSystemOpts;
 
   /// Options controlling the frontend itself.
   FrontendOptions FrontendOpts;
 
   /// Options controlling preprocessed output.
   PreprocessorOutputOptions PreprocessorOutputOpts;
 
+  /// Track whether there was an error during creation.
+  bool HasError = false;
+
 public:
   CompilerInvocation() : AnalyzerOpts(new AnalyzerOptions()) {}
 
   /// @name Utility Methods
   /// @{
 
   /// Create a compiler invocation from a list of input options.
-  /// \returns true on success.
+  /// \returns true on success; otherwise Res.hasError() returns
+  /// false.
   ///
   /// \param [out] Res - The resulting invocation.
   /// \param ArgBegin - The first element in the argument vector.
   /// \param ArgEnd - The last element in the argument vector.
   /// \param Diags - The diagnostic engine to use for errors.
   static bool CreateFromArgs(CompilerInvocation &Res,
                              const char* const *ArgBegin,
                              const char* const *ArgEnd,
                              DiagnosticsEngine &Diags);
 
+  bool hasError() const { return HasError; }
+  void setError() { HasError = true; }
+
   /// Get the directory where the compiler headers
   /// reside, relative to the compiler binary (found by the passed in
   /// arguments).
   ///
   /// \param Argv0 - The program path (from argv[0]), for finding the builtin
   /// compiler path.
   /// \param MainAddr - The address of main (or some other function in the main
   /// executable), for finding the builtin compiler path.

clang/lib/Frontend/ASTUnit.cpp

if (OverrideMainBuffer) {
     assert(Preamble &&
            "No preamble was built, but OverrideMainBuffer is not null");
     Preamble->AddImplicitPreamble(*CCInvocation, VFS, OverrideMainBuffer.get());
     // VFS may have changed...
   }
 
   // Create the compiler instance to use for building the AST.
   std::unique_ptr<CompilerInstance> Clang(
-      new CompilerInstance(std::move(PCHContainerOps)));
+      new CompilerInstance(CompilerInstanceBuilder()
+                               .pchContainerOps(std::move(PCHContainerOps))
+                               .invocation(CCInvocation)
+                               .diags(getDiagnostics())));
 
   // Ensure that Clang has a FileManager with the right VFS, which may have
   // changed above in AddImplicitPreamble.  If VFS is nullptr, rely on
   // createFileManager to create one.
   if (VFS && FileMgr && &FileMgr->getVirtualFileSystem() == VFS)
     Clang->setFileManager(&*FileMgr);
   else
     FileMgr = Clang->createFileManager(std::move(VFS));
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
     CICleanup(Clang.get());
 
-  Clang->setInvocation(CCInvocation);
   OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
 
-  // Set up diagnostics, capturing any diagnostics that would
-  // otherwise be dropped.
-  Clang->setDiagnostics(&getDiagnostics());
-
   // Create the target instance.
   Clang->setTarget(TargetInfo::CreateTargetInfo(
       Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
   if (!Clang->hasTarget())
     return true;
 
   // Inform the target of the language options.
   //
ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(
 
   // We'll manage file buffers ourselves.
   CI->getPreprocessorOpts().RetainRemappedFileBuffers = true;
   CI->getFrontendOpts().DisableFree = false;
   ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts());
 
   // Create the compiler instance to use for building the AST.
   std::unique_ptr<CompilerInstance> Clang(
-      new CompilerInstance(std::move(PCHContainerOps)));
+      new CompilerInstance(CompilerInstanceBuilder()
+                               .pchContainerOps(std::move(PCHContainerOps))
+                               .invocation(std::move(CI))
+                               .diags(AST->getDiagnostics())));
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
     CICleanup(Clang.get());
 
-  Clang->setInvocation(std::move(CI));
   AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
 
-  // Set up diagnostics, capturing any diagnostics that would
-  // otherwise be dropped.
-  Clang->setDiagnostics(&AST->getDiagnostics());
-
   // Create the target instance.
   Clang->setTarget(TargetInfo::CreateTargetInfo(
       Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
   if (!Clang->hasTarget())
     return nullptr;
 
   // Inform the target of the language options.
   //
void ASTUnit::CodeComplete(
 
   // Set the language options appropriately.
   LangOpts = *CCInvocation->getLangOpts();
 
   // Spell-checking and warnings are wasteful during code-completion.
   LangOpts.SpellChecking = false;
   CCInvocation->getDiagnosticOpts().IgnoreWarnings = true;
 
+  auto &Inv = *CCInvocation;
   std::unique_ptr<CompilerInstance> Clang(
-      new CompilerInstance(PCHContainerOps));
+      new CompilerInstance(CompilerInstanceBuilder()
+                               .pchContainerOps(PCHContainerOps)
+                               .invocation(std::move(CCInvocation))
+                               .diags(Diag)));
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
     CICleanup(Clang.get());
 
-  auto &Inv = *CCInvocation;
-  Clang->setInvocation(std::move(CCInvocation));
   OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
 
   // Set up diagnostics, capturing any diagnostics produced.
-  Clang->setDiagnostics(&Diag);
   CaptureDroppedDiagnostics Capture(true,
                                     Clang->getDiagnostics(),
                                     &StoredDiagnostics, nullptr);
   ProcessWarningOptions(Diag, Inv.getDiagnosticOpts());
 
   // Create the target instance.
   Clang->setTarget(TargetInfo::CreateTargetInfo(
       Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
   if (!Clang->hasTarget()) {
-    Clang->setInvocation(nullptr);
+    Clang->resetInvocation();
     return;
   }
 
   // Inform the target of the language options.
   //
   // FIXME: We shouldn't need to do this, the target should be immutable once
   // created. This complexity should be lifted elsewhere.
   Clang->getTarget().adjust(Clang->getLangOpts());

clang/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<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());
+    std::unique_ptr<CompilerInstance> Clang(new CompilerInstance(
+        CompilerInstanceBuilder()
+            .pchContainerOps(CI.getPCHContainerOperations())
+            .invocation(std::move(CInvok))
+            .diags<TextDiagnosticPrinter>(llvm::errs(),
+                                          new DiagnosticOptions)));
     Clang->setTarget(TargetInfo::CreateTargetInfo(
         Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
     Clang->createFileManager();
     Clang->createSourceManager(Clang->getFileManager());
     Clang->createPreprocessor(TU_Prefix);
     Clang->getDiagnosticClient().BeginSourceFile(Clang->getLangOpts(),
                                                  &Clang->getPreprocessor());
     Clang->createASTContext();

clang/lib/Frontend/CompilerInstance.cpp

 #include "clang/Basic/Version.h"
 #include "clang/Config/config.h"
 #include "clang/Frontend/ChainedDiagnosticConsumer.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/LogDiagnosticPrinter.h"
 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
+#include "clang/Frontend/TextDiagnosticBuffer.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/Sema.h"

 }
 
 std::shared_ptr<PCHContainerOperations>
 CompilerInstanceBuilder::getPCHContainerOps() {
   return PCHContainerOps ? PCHContainerOps
                          : std::make_shared<PCHContainerOperations>();
 }
 
+void CompilerInstanceBuilder::initDiagsAndInvocation() {
+  if (DidInitDiagsAndInvocation)
+    return;
+
+  DidInitDiagsAndInvocation = true;
+
+  // Creating an invocation without a diagnostics engine requires storing the
+  // diagnostics in a temporary buffer and replaying them later.
+  std::unique_ptr<TextDiagnosticBuffer> DiagsBuffer;
+  if (!Diags && MakeInvocation) {
+    // Create a temporary diagnostics engine.
+    IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+    DiagsBuffer.reset(new TextDiagnosticBuffer);
+    Diags = new DiagnosticsEngine(new DiagnosticIDs, new DiagnosticOptions,
+                                  DiagsBuffer.get(),
+                                  /*ShouldOwnClient=*/false);
+  }
+
+  if (MakeInvocationFromDriver) {
+    // Create an invocation from a command-line.
+    Invocation = createInvocationFromCommandLine(Args, Diags, VFS);
+    if (!Invocation) {
+      Invocation = std::make_shared<CompilerInvocation>();
+      Invocation->setError();
+    }
+  } else if (MakeInvocation) {
+    // Create an invocation from a command-line.
+    Invocation = std::make_shared<CompilerInvocation>();
+    CompilerInvocation::CreateFromArgs(*Invocation, Args.begin(), Args.end(),
+                                       *Diags);
+
+    // Infer the builtin include path if unspecified.
+    if (ShouldInferResourceDir &&
+        Invocation->getHeaderSearchOpts().UseBuiltinIncludes &&
+        Invocation->getHeaderSearchOpts().ResourceDir.empty())
+      Invocation->getHeaderSearchOpts().ResourceDir =
+          CompilerInvocation::GetResourcesPath(Argv0, MainAddr);
+  } else if (!Invocation) {
+    Invocation = std::make_shared<CompilerInvocation>();
+  }
+
+  if (!Diags || DiagsBuffer) {
+    // Create a diagnostics engine using the compiler invocation.  If we
+    // created a temporary engine above, this will destroy it.
+    bool IsClientOwned = OwnedDiagsClient.get();
+    Diags = CompilerInstance::createDiagnostics(
+        &Invocation->getDiagnosticOpts(),
+        IsClientOwned ? OwnedDiagsClient.release() : DiagsClient, IsClientOwned,
+        &Invocation->getCodeGenOpts());
+  }
+
+  if (DiagsBuffer)
+    DiagsBuffer->FlushDiagnostics(*Diags);
+}
+
+std::shared_ptr<CompilerInvocation> CompilerInstanceBuilder::getInvocation() {
+  initDiagsAndInvocation();
+  return std::move(Invocation);
+}
+
+IntrusiveRefCntPtr<DiagnosticsEngine> CompilerInstanceBuilder::getDiags() {
+  initDiagsAndInvocation();
+  return std::move(Diags);
+}
+
 bool CompilerInstanceBuilder::isBuildingModule() { return SharedModuleCache; }
 
 CompilerInstance::CompilerInstance(CompilerInstanceBuilder Builder)
     : ModuleLoader(Builder.isBuildingModule()),
-      Invocation(new CompilerInvocation()),
+      Invocation(Builder.getInvocation()), Diagnostics(Builder.getDiags()),
       ModuleCache(Builder.getModuleCache()),
       ThePCHContainerOperations(Builder.getPCHContainerOps()) {}
 
 CompilerInstance::CompilerInstance(
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     InMemoryModuleCache *SharedModuleCache)
     : CompilerInstance(CompilerInstanceBuilder()
                            .sharedModuleCache(SharedModuleCache)
                            .pchContainerOps(PCHContainerOps)) {}
 
 CompilerInstance::~CompilerInstance() {
   assert(OutputFiles.empty() && "Still output files in flight?");
 }
 
-void CompilerInstance::setInvocation(
-    std::shared_ptr<CompilerInvocation> Value) {
-  Invocation = std::move(Value);
-}
-
 bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
   return (BuildGlobalModuleIndex ||
           (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
            getFrontendOpts().GenerateGlobalModuleIndex)) &&
          !ModuleBuildFailed;
 }
 
-void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
-  Diagnostics = Value;
-}
-
 void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
 void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
 
 void CompilerInstance::setFileManager(FileManager *Value) {
   FileMgr = Value;
 }
 
 void CompilerInstance::setSourceManager(SourceManager *Value) {
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());
-}
-
 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));
compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
   assert(ImportingInstance.getInvocation().getModuleHash() ==
          Invocation->getModuleHash() && "Module hash mismatch!");
 
   // Construct a compiler instance that will be used to actually create the
   // module.  Since we're sharing an in-memory module cache,
   // CompilerInstance::CompilerInstance is responsible for finalizing the
   // buffers to prevent use-after-frees.
-  CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
-                            &ImportingInstance.getModuleCache());
   auto &Inv = *Invocation;
-  Instance.setInvocation(std::move(Invocation));
-
-  Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
-                                   ImportingInstance.getDiagnosticClient()),
-                             /*ShouldOwnClient=*/true);
+  CompilerInstance Instance(
+      CompilerInstanceBuilder()
+          .pchContainerOps(ImportingInstance.getPCHContainerOperations())
+          .moduleCache(ImportingInstance.getModuleCache())
+          .invocation(std::move(Invocation))
+          .diags<ForwardingDiagnosticConsumer>(
+              ImportingInstance.getDiagnosticClient()));
 
   // 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();
   SourceMgr.setModuleBuildStack(
     ImportingInstance.getSourceManager().getModuleBuildStack());

clang/lib/Frontend/CompilerInvocation.cpp

 #include "clang/Serialization/ModuleFileExtension.h"
 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/Linker/Linker.h"
static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args,
   }
 }
 
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
                                         const char *const *ArgBegin,
                                         const char *const *ArgEnd,
                                         DiagnosticsEngine &Diags) {
   bool Success = true;
+  auto SaveErrorOnExit =
+      llvm::make_scope_exit([&]() { Res.HasError = !Success; });
 
   // Parse the arguments.
   std::unique_ptr<OptTable> Opts = createDriverOptTable();
   const unsigned IncludedFlagsBitmask = options::CC1Option;
   unsigned MissingArgIndex, MissingArgCount;
   InputArgList Args =
       Opts->ParseArgs(llvm::makeArrayRef(ArgBegin, ArgEnd), MissingArgIndex,
                       MissingArgCount, IncludedFlagsBitmask);

clang/lib/Frontend/PrecompiledPreamble.cpp

FrontendOpts.OutputFile = StoreInMemory ? getInMemoryPreamblePath()
                                           : Storage.asFile().getFilePath();
   PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
   PreprocessorOpts.PrecompiledPreambleBytes.second = false;
   // Inform preprocessor to record conditional stack when building the preamble.
   PreprocessorOpts.GeneratePreamble = true;
 
   // Create the compiler instance to use for building the precompiled preamble.
   std::unique_ptr<CompilerInstance> Clang(
-      new CompilerInstance(std::move(PCHContainerOps)));
+      new CompilerInstance(CompilerInstanceBuilder()
+                               .pchContainerOps(std::move(PCHContainerOps))
+                               .invocation(std::move(PreambleInvocation))
+                               .diags(Diagnostics)));
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> CICleanup(
       Clang.get());
 
-  Clang->setInvocation(std::move(PreambleInvocation));
-  Clang->setDiagnostics(&Diagnostics);
-
   // Create the target instance.
   Clang->setTarget(TargetInfo::CreateTargetInfo(
       Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
   if (!Clang->hasTarget())
     return BuildPreambleError::CouldntCreateTargetInfo;
 
   // Inform the target of the language options.
   //

clang/lib/Frontend/Rewrite/FrontendActions.cpp

void visitModuleFile(StringRef Filename,
     else {
       (*OS) << '"';
       OS->write_escaped(MF->ModuleName);
       (*OS) << '"';
     }
     (*OS) << '\n';
 
     // Rewrite the contents of the module in a separate compiler instance.
-    CompilerInstance Instance(CI.getPCHContainerOperations(),
-                              &CI.getModuleCache());
-    Instance.setInvocation(
-        std::make_shared<CompilerInvocation>(CI.getInvocation()));
-    Instance.createDiagnostics(
-        new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()),
-        /*ShouldOwnClient=*/true);
+    CompilerInstance Instance(
+        CompilerInstanceBuilder()
+            .pchContainerOps(CI.getPCHContainerOperations())
+            .moduleCache(CI.getModuleCache())
+            .invocation(
+                std::make_shared<CompilerInvocation>(CI.getInvocation()))
+            .diags<ForwardingDiagnosticConsumer>(CI.getDiagnosticClient()));
     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();
     // Don't recursively rewrite imports. We handle them all at the top level.
     Instance.getPreprocessorOutputOpts().RewriteImports = false;

clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp

void ModelInjector::onBodySynthesis(const NamedDecl *D) {
   FrontendOpts.Inputs.clear();
   FrontendOpts.Inputs.emplace_back(fileName, IK);
   FrontendOpts.DisableFree = true;
 
   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(
-      new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()),
-      /*ShouldOwnClient=*/true);
+  CompilerInstance Instance(
+      CompilerInstanceBuilder()
+          .pchContainerOps(CI.getPCHContainerOperations())
+          .invocation(std::move(Invocation))
+          .diags<ForwardingDiagnosticConsumer>(CI.getDiagnosticClient()));
 
   Instance.getDiagnostics().setSourceManager(&SM);
 
   // The instance wants to take ownership, however DisableFree frontend option
   // is set to true to avoid double free issues
   Instance.setFileManager(&CI.getFileManager());
   Instance.setSourceManager(&SM);
   Instance.setPreprocessor(CI.getPreprocessorPtr());

clang/lib/Tooling/Tooling.cpp

return Action->runInvocation(std::move(Invocation), Files,
                                std::move(PCHContainerOps), DiagConsumer);
 }
 
 bool FrontendActionFactory::runInvocation(
     std::shared_ptr<CompilerInvocation> Invocation, FileManager *Files,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     DiagnosticConsumer *DiagConsumer) {
   // Create a compiler instance to handle the actual work.
-  CompilerInstance Compiler(std::move(PCHContainerOps));
-  Compiler.setInvocation(std::move(Invocation));
+  CompilerInstance Compiler(CompilerInstanceBuilder()
+                                .pchContainerOps(std::move(PCHContainerOps))
+                                .invocation(std::move(Invocation))
+                                .diags(*DiagConsumer));
   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);
   if (!Compiler.hasDiagnostics())
     return false;
 
   Compiler.createSourceManager(*Files);
 
   const bool Success = Compiler.ExecuteAction(*ScopedToolAction);
 
   Files->clearStatCache();

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

if (Info.hasSourceManager() && LangOpts) {
         }
       }
     }
     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);
+  auto Ins = llvm::make_unique<CompilerInstance>(
+      CompilerInstanceBuilder().diags<TestDiagnosticConsumer>());
 
-  auto Inv = llvm::make_unique<CompilerInvocation>();
+  auto *Inv = &Ins->getInvocation();
 
   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()],
                                      Ins->getDiagnostics());
 
std::unique_ptr<CompilerInstance> BuildCompilerInstance() {
   Inv->getLangOpts()->DollarIdents = true;
   Inv->getLangOpts()->Exceptions = true;
   Inv->getLangOpts()->CXXExceptions = true;
   // Needed for testing dynamic_cast.
   Inv->getLangOpts()->RTTI = true;
   Inv->getCodeGenOpts().setDebugInfo(codegenoptions::FullDebugInfo);
   Inv->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();
 
-  Ins->setInvocation(std::move(Inv));
-
   TargetInfo *TI = TargetInfo::CreateTargetInfo(
       Ins->getDiagnostics(), Ins->getInvocation().TargetOpts);
   Ins->setTarget(TI);
   Ins->getTarget().adjust(Ins->getLangOpts());
   Ins->createFileManager();
   Ins->createSourceManager(Ins->getFileManager());
   Ins->createPreprocessor(TU_Complete);
 

clang/tools/driver/cc1_main.cpp

 #include "clang/Basic/Stack.h"
 #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
-#include "clang/Frontend/TextDiagnosticBuffer.h"
-#include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/FrontendTool/Utils.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/LinkAllPasses.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"

 }
 #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());
-
-  // 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);
-
+  std::unique_ptr<CompilerInstance> Clang(new CompilerInstance(
+      CompilerInstanceBuilder().invocation(Argv).inferResourceDir(Argv0,
+                                                                  MainAddr)));
   if (Clang->getFrontendOpts().TimeTrace)
     llvm::timeTraceProfilerInitialize();
 
-  // 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();
-  if (!Clang->hasDiagnostics())
+  // Check for an error creating the compiler invocation.
+  if (Clang->getInvocation().hasError())
     return 1;
 
+  // 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>());
+
   // 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.
+  bool Success;
   {
     llvm::TimeTraceScope TimeScope("ExecuteCompiler", StringRef(""));
     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());

clang/unittests/AST/ExternalASTSourceTest.cpp

std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
     return llvm::make_unique<ASTConsumer>();
   }
 
   IntrusiveRefCntPtr<ExternalASTSource> Source;
 };
 
 bool testExternalASTSource(ExternalASTSource *Source,
                            StringRef FileContents) {
-  CompilerInstance Compiler;
-  Compiler.createDiagnostics();
-
-  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());
-  Compiler.setInvocation(std::move(Invocation));
+  CompilerInstance Compiler(CompilerInstanceBuilder().invocation(Args));
+  Compiler.getInvocation().getPreprocessorOpts().addRemappedFile(
+      "test.cc", MemoryBuffer::getMemBuffer(FileContents).release());
 
   TestFrontendAction Action(Source);
   return Compiler.ExecuteAction(Action);
 }
 
 
 // Ensure that a failed name lookup into an external source only occurs once.
 TEST(ExternalASTSourceTest, FailedLookupOccursOnce) {

clang/unittests/CodeGen/BufferSourceTest.cpp

const char TestProgram[] =
     "   EmitCXXGlobalInitFunc() {}  "
     "};                             "
     "EmitCXXGlobalInitFunc test;    ";
 
 TEST(BufferSourceTest, EmitCXXGlobalInitFunc) {
     LLVMContext Context;
     CompilerInstance compiler;
 
-    compiler.createDiagnostics();
     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>(

clang/unittests/CodeGen/CodeGenExternalTest.cpp

static void test_codegen_fns(MyASTConsumer *my) {
 
   test_codegen_fns_ran = true;
 }
 
 TEST(CodeGenExternalTest, CodeGenExternalTest) {
     LLVMContext Context;
     CompilerInstance compiler;
 
-    compiler.createDiagnostics();
     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>(

clang/unittests/CodeGen/IncrementalProcessingTest.cpp

const Function* getGlobalInit(llvm::Module& M) {
 
   return nullptr;
 }
 
 TEST(IncrementalProcessing, EmitCXXGlobalInitFunc) {
     LLVMContext Context;
     CompilerInstance compiler;
 
-    compiler.createDiagnostics();
     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>(

clang/unittests/CodeGen/TBAAMetadataTest.cpp

 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.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);

clang/unittests/Frontend/CodeGenActionTest.cpp

TEST(CodeGenTest, TestNullCodeGen) {
   auto Invocation = std::make_shared<CompilerInvocation>();
   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();
+  CompilerInstance Compiler(
+      CompilerInstanceBuilder().invocation(std::move(Invocation)));
   EXPECT_TRUE(Compiler.hasDiagnostics());
 
   std::unique_ptr<FrontendAction> Act(new NullCodeGenAction);
   bool Success = Compiler.ExecuteAction(*Act);
   EXPECT_TRUE(Success);
 }
 
 }

clang/unittests/Frontend/CompilerInstanceTest.cpp

const char *VFSYaml = "{ 'version': 0, 'roots': [\n"
                         "]}\n";
   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());
-
-  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).
-  CompilerInstance Instance;
-  Instance.setDiagnostics(Diags.get());
-  Instance.setInvocation(CInvok);
+  CompilerInstance Instance(
+      CompilerInstanceBuilder().invocationFromDriver(Args));
+
+  if (Instance.getInvocation().hasError())
+    FAIL() << "could not create compiler invocation";
   Instance.createFileManager();
 
   // Check if the virtual file exists which means that our VFS is used by the
   // CompilerInstance.
   ASSERT_TRUE(Instance.getFileManager().getFile("vfs-virtual.file"));
 }
 
 } // anonymous namespace

clang/unittests/Frontend/FrontendActionTest.cpp

TEST(ASTFrontendAction, Sanity) {
   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();
+  CompilerInstance compiler(
+      CompilerInstanceBuilder().invocation(std::move(invocation)));
 
   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();
+  CompilerInstance compiler(
+      CompilerInstanceBuilder().invocation(std::move(invocation)));
 
   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(ASTFrontendAction, LateTemplateIncrementalParsing) {
   auto invocation = std::make_shared<CompilerInvocation>();
   invocation->getLangOpts()->CPlusPlus = true;
   invocation->getLangOpts()->DelayedTemplateParsing = true;
   invocation->getPreprocessorOpts().addRemappedFile(
     "test.cc", MemoryBuffer::getMemBuffer(
       "template<typename T> struct A { A(T); T data; };\n"
       "template<typename T> struct B: public A<T> {\n"
       "  B();\n"
       "  B(B const& b): A<T>(b.data) {}\n"
       "};\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();
+  CompilerInstance compiler(
+      CompilerInstanceBuilder().invocation(std::move(invocation)));
 
   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]);
 }
TEST(PreprocessorFrontendAction, EndSourceFile) {
   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();
+  CompilerInstance Compiler(
+      CompilerInstanceBuilder().invocation(std::move(Invocation)));
 
   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);
TEST(ASTFrontendAction, ExternalSemaSource) {
   Invocation->getPreprocessorOpts().addRemappedFile(
       "test.cc", MemoryBuffer::getMemBuffer("void fooo();\n"
                                             "int main() { foo(); }")
                      .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);
+  TypoDiagnosticConsumer TDC;
+  CompilerInstance Compiler(
+      CompilerInstanceBuilder().invocation(std::move(Invocation)).diags(TDC));
   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());
+            TDC.Error.str().str());
+  EXPECT_EQ("This is a note", TDC.Note.str().str());
 }
 
 TEST(GeneratePCHFrontendAction, CacheGeneratedPCH) {
   // Create a temporary file for writing out the PCH that will be cleaned up.
   int PCHFD;
   llvm::SmallString<128> PCHFilename;
   ASSERT_FALSE(
       llvm::sys::fs::createTemporaryFile("test.h", "pch", PCHFD, PCHFilename));
   llvm::ToolOutputFile PCHFile(PCHFilename, PCHFD);
 
   for (bool ShouldCache : {false, true}) {
     auto Invocation = std::make_shared<CompilerInvocation>();
     Invocation->getLangOpts()->CacheGeneratedPCH = ShouldCache;
     Invocation->getPreprocessorOpts().addRemappedFile(
         "test.h",
         MemoryBuffer::getMemBuffer("int foo(void) { return 1; }\n").release());
     Invocation->getFrontendOpts().Inputs.push_back(
         FrontendInputFile("test.h", InputKind::C));
     Invocation->getFrontendOpts().OutputFile = StringRef(PCHFilename);
     Invocation->getFrontendOpts().ProgramAction = frontend::GeneratePCH;
     Invocation->getTargetOpts().Triple = "x86_64-apple-darwin19.0.0";
-    CompilerInstance Compiler;
-    Compiler.setInvocation(std::move(Invocation));
-    Compiler.createDiagnostics();
+    CompilerInstance Compiler(
+        CompilerInstanceBuilder().invocation(std::move(Invocation)));
 
     GeneratePCHAction TestAction;
     ASSERT_TRUE(Compiler.ExecuteAction(TestAction));
 
     // Check whether the PCH was cached.
     if (ShouldCache)
       EXPECT_EQ(InMemoryModuleCache::Final,
                 Compiler.getModuleCache().getPCMState(PCHFilename));
     else
       EXPECT_EQ(InMemoryModuleCache::Unknown,
                 Compiler.getModuleCache().getPCMState(PCHFilename));
   }
 }
 
 } // anonymous namespace

clang/unittests/Frontend/OutputStreamTest.cpp

 TEST(FrontendOutputTests, TestOutputStream) {
   auto Invocation = std::make_shared<CompilerInvocation>();
   Invocation->getPreprocessorOpts().addRemappedFile(
       "test.cc", MemoryBuffer::getMemBuffer("").release());
   Invocation->getFrontendOpts().Inputs.push_back(
       FrontendInputFile("test.cc", InputKind::CXX));
   Invocation->getFrontendOpts().ProgramAction = EmitBC;
   Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
-  CompilerInstance Compiler;
+  CompilerInstance Compiler(
+      CompilerInstanceBuilder().invocation(std::move(Invocation)));
 
   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();
 
   bool Success = ExecuteCompilerInvocation(&Compiler);
   EXPECT_TRUE(Success);
   EXPECT_TRUE(!IRBuffer.empty());
   EXPECT_TRUE(StringRef(IRBuffer.data()).startswith("BC"));
 }
 }

clang/unittests/Tooling/Syntax/TokensTest.cpp

void recordTokens(llvm::StringRef Code) {
 
     constexpr const char *FileName = "./input.cpp";
     FS->addFile(FileName, time_t(), llvm::MemoryBuffer::getMemBufferCopy(""));
     // Prepare to run a compiler.
     if (!Diags->getClient())
       Diags->setClient(new IgnoringDiagConsumer);
     std::vector<const char *> Args = {"tok-test", "-std=c++03", "-fsyntax-only",
                                       FileName};
-    auto CI = createInvocationFromCommandLine(Args, Diags, FS);
-    assert(CI);
-    CI->getFrontendOpts().DisableFree = false;
-    CI->getPreprocessorOpts().addRemappedFile(
+    CompilerInstance Compiler(
+        CompilerInstanceBuilder().diags(*Diags).invocationFromDriver(Args, FS));
+    CompilerInvocation &CI = Compiler.getInvocation();
+    CI.getFrontendOpts().DisableFree = false;
+    CI.getPreprocessorOpts().addRemappedFile(
         FileName, llvm::MemoryBuffer::getMemBufferCopy(Code).release());
-    CompilerInstance Compiler;
-    Compiler.setInvocation(std::move(CI));
-    Compiler.setDiagnostics(Diags.get());
     Compiler.setFileManager(FileMgr.get());
     Compiler.setSourceManager(SourceMgr.get());
 
     this->Buffer = TokenBuffer(*SourceMgr);
     RecordTokens Recorder(this->Buffer);
     ASSERT_TRUE(Compiler.ExecuteAction(Recorder))
         << "failed to run the frontend";
   }

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

if (log && log->GetVerbose()) {
       LLDB_LOGV(log, "FPMath: '{0}'", opts.FPMath);
       LLDB_LOGV(log, "ABI: '{0}'", opts.ABI);
       LLDB_LOGV(log, "LinkerVersion: '{0}'", opts.LinkerVersion);
       StringList::LogDump(log, opts.FeaturesAsWritten, "FeaturesAsWritten");
       StringList::LogDump(log, opts.Features, "Features");
     }
 
   // 4. Create and install the target on the compiler.
-  m_compiler->createDiagnostics();
   auto target_info = TargetInfo::CreateTargetInfo(
       m_compiler->getDiagnostics(), m_compiler->getInvocation().TargetOpts);
   if (log) {
     log->Printf("Using SIMD alignment: %d", target_info->getSimdDefaultAlign());
     log->Printf("Target datalayout string: '%s'",
                 target_info->getDataLayout().getStringRepresentation().c_str());
     log->Printf("Target ABI: '%s'", target_info->getABI().str().c_str());
     log->Printf("Target vector alignment: %d",

lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

ClangModulesDeclVendor::Create(Target &target) {
   std::unique_ptr<llvm::MemoryBuffer> source_buffer =
       llvm::MemoryBuffer::getMemBuffer(
           "extern int __lldb __attribute__((unavailable));",
           ModuleImportBufferName);
 
   invocation->getPreprocessorOpts().addRemappedFile(ModuleImportBufferName,
                                                     source_buffer.release());
 
-  std::unique_ptr<clang::CompilerInstance> instance(
-      new clang::CompilerInstance);
+  std::unique_ptr<clang::CompilerInstance> instance =
+      llvm::make_unique<clang::CompilerInstance>(
+          clang::CompilerInstanceBuilder()
+              .invocation(invocation)
+              .diags(*diagnostics_engine));
 
   // When capturing a reproducer, hook up the file collector with clang to
   // collector modules and headers.
   if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) {
     repro::FileProvider &fp = g->GetOrCreate<repro::FileProvider>();
     instance->setModuleDepCollector(
         std::make_shared<ModuleDependencyCollectorAdaptor>(
             fp.GetFileCollector()));
     clang::DependencyOutputOptions &opts = instance->getDependencyOutputOpts();
     opts.IncludeSystemHeaders = true;
     opts.IncludeModuleFiles = true;
   }
 
   // Make sure clang uses the same VFS as LLDB.
   instance->createFileManager(FileSystem::Instance().GetVirtualFileSystem());
-  instance->setDiagnostics(diagnostics_engine.get());
-  instance->setInvocation(invocation);
 
   std::unique_ptr<clang::FrontendAction> action(new clang::SyntaxOnlyAction);
 
   instance->setTarget(clang::TargetInfo::CreateTargetInfo(
       *diagnostics_engine, instance->getInvocation().TargetOpts));
 
   if (!instance->hasTarget())
     return nullptr;