Frontend: Create basic CompilerInstanceBuilder

[dexonsmith]

Summary

This sketches out the beginning of a CompilerInstanceBuilder. For now
it just handles PCHContainerOps and InMemoryModuleCache, which are
already handled by the CompilerInstance constructor.

Subsequent commits will incrementally replace CompilerInstance::set*
and CompilerInstance::create* mutators with builder methods,
simplifying construction and possibly clarifying some lifetimes.

[dexonsmith]

@rsmith ping -- Besides rebasing, any concerns about this? Alternatively, any more follow-ups on this thread from last year?

• thread: http://lists.llvm.org/pipermail/cfe-dev/2019-May/062369.html

clang/include/clang/Frontend/CompilerInstance.h

 //===-- CompilerInstance.h - Clang Compiler Instance ------------*- 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_COMPILERINSTANCE_H_
 #define LLVM_CLANG_FRONTEND_COMPILERINSTANCE_H_
 
 #include "clang/AST/ASTConsumer.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Frontend/CompilerInstanceBuilder.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Frontend/PCHContainerOperations.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/ModuleLoader.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
class CompilerInstance : public ModuleLoader {
   std::list<OutputFile> OutputFiles;
 
   /// Force an output buffer.
   std::unique_ptr<llvm::raw_pwrite_stream> OutputStream;
 
   CompilerInstance(const CompilerInstance &) = delete;
   void operator=(const CompilerInstance &) = delete;
 public:
+  explicit CompilerInstance(CompilerInstanceBuilder Builder);
   explicit CompilerInstance(
       std::shared_ptr<PCHContainerOperations> PCHContainerOps =
           std::make_shared<PCHContainerOperations>(),
       InMemoryModuleCache *SharedModuleCache = nullptr);
   ~CompilerInstance() override;
 
   /// @name High-Level Operations
   /// {

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 InMemoryModuleCache;
+class PCHContainerOperations;
+
+class CompilerInstanceBuilder {
+  InMemoryModuleCache *SharedModuleCache = nullptr;
+  std::shared_ptr<PCHContainerOperations> PCHContainerOps;
+
+public:
+  CompilerInstanceBuilder() = default;
+  CompilerInstanceBuilder(CompilerInstanceBuilder &&) = default;
+  CompilerInstanceBuilder(const CompilerInstanceBuilder &) = delete;
+
+  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();
+  bool isBuildingModule();
+};
+
+} // end namespace clang
+
+#endif

clang/lib/Frontend/CompilerInstance.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <sys/stat.h>
 #include <system_error>
 #include <time.h>
 #include <utility>
 
 using namespace clang;
 
+IntrusiveRefCntPtr<InMemoryModuleCache>
+CompilerInstanceBuilder::getModuleCache() {
+  return SharedModuleCache ? SharedModuleCache : new InMemoryModuleCache();
+}
+
+std::shared_ptr<PCHContainerOperations>
+CompilerInstanceBuilder::getPCHContainerOps() {
+  return PCHContainerOps ? PCHContainerOps
+                         : std::make_shared<PCHContainerOperations>();
+}
+
+bool CompilerInstanceBuilder::isBuildingModule() { return SharedModuleCache; }
+
+CompilerInstance::CompilerInstance(CompilerInstanceBuilder Builder)
+    : ModuleLoader(Builder.isBuildingModule()),
+      Invocation(new CompilerInvocation()),
+      ModuleCache(Builder.getModuleCache()),
+      ThePCHContainerOperations(Builder.getPCHContainerOps()) {}
+
 CompilerInstance::CompilerInstance(
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     InMemoryModuleCache *SharedModuleCache)
-    : ModuleLoader(/* BuildingModule = */ SharedModuleCache),
-      Invocation(new CompilerInvocation()),
-      ModuleCache(SharedModuleCache ? SharedModuleCache
-                                    : new InMemoryModuleCache),
-      ThePCHContainerOperations(std::move(PCHContainerOps)) {}
+    : 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);