[WIP][clang] Move deep copy into CompilerInvocation::clone

[jansvoboda11]

Summary

The copy constructor of CompilerInvocation performs a deep copy of the reference-counted pointers stored in its base class.

This behaviour might be surprising, since it doesn't follow the default semantics of std::shared_ptr and llvm::IntrusiveRefCntPtr.

In this patch, the copy constructor is declared private and the clone() method is introduced, making the behaviour obvious.

Depends on D100473.

WIP: Before landing this and advertising the deep copy functionality, we should clear up ownership of PreprocessorOptions::RemappedFileBuffers.

[jansvoboda11]

Rebase

[jansvoboda11]

Rebase

[jansvoboda11]

Rebase, delete RefBase copy assignment

clang-tools-extra/clangd/TUScheduler.cpp

if (!LatestBuild || Inputs.ForceRebuild) {
     return;
   } else {
     vlog("Rebuilding invalidated preamble for {0} version {1} (previous was "
          "version {2})",
          FileName, Inputs.Version, LatestBuild->Version);
   }
 
   LatestBuild = clang::clangd::buildPreamble(
-      FileName, *Req.CI, Inputs, StoreInMemory,
+      FileName, Req.CI->clone(), Inputs, StoreInMemory,
       [this, Version(Inputs.Version)](ASTContext &Ctx,
                                       std::shared_ptr<clang::Preprocessor> PP,
                                       const CanonicalIncludes &CanonIncludes) {
         Callbacks.onPreambleAST(FileName, Version, Ctx, std::move(PP),
                                 CanonIncludes);
       });
   if (LatestBuild && isReliable(LatestBuild->CompileCommand))
     HeaderIncluders.update(FileName, LatestBuild->Includes.allHeaders());

clang-tools-extra/clangd/tool/Check.cpp

bool buildInvocation(const ThreadsafeFS &TFS,
 
     return true;
   }
 
   // Build preamble and AST, and index them.
   bool buildAST() {
     log("Building preamble...");
     Preamble =
-        buildPreamble(File, *Invocation, Inputs, /*StoreInMemory=*/true,
+        buildPreamble(File, Invocation->clone(), Inputs, /*StoreInMemory=*/true,
                       [&](ASTContext &Ctx, std::shared_ptr<Preprocessor> PP,
                           const CanonicalIncludes &Includes) {
                         if (!Opts.BuildDynamicSymbolIndex)
                           return;
                         log("Indexing headers...");
                         Index.updatePreamble(File, /*Version=*/"null", Ctx,
                                              std::move(PP), Includes);
                       });

clang/include/clang/Frontend/CompilerInvocation.h

public:
   std::shared_ptr<PreprocessorOptions> PreprocessorOpts;
 
   /// Options controlling the static analyzer.
   AnalyzerOptionsRef AnalyzerOpts;
 
   CompilerInvocationRefBase();
   CompilerInvocationRefBase(const CompilerInvocationRefBase &X);
   CompilerInvocationRefBase(CompilerInvocationRefBase &&X);
-  CompilerInvocationRefBase &operator=(CompilerInvocationRefBase X);
+  CompilerInvocationRefBase &
+  operator=(const CompilerInvocationRefBase &) = delete;
   CompilerInvocationRefBase &operator=(CompilerInvocationRefBase &&X);
   ~CompilerInvocationRefBase();
 
   LangOptions *getLangOpts() { return LangOpts.get(); }
   const LangOptions *getLangOpts() const { return LangOpts.get(); }
 
   TargetOptions &getTargetOpts() { return *TargetOpts.get(); }
   const TargetOptions &getTargetOpts() const { return *TargetOpts.get(); }

 
 /// Helper class for holding the data necessary to invoke the compiler.
 ///
 /// This class is designed to represent an abstract "invocation" of the
 /// compiler, including data such as the include paths, the code generation
 /// options, the warning flags, and so on.
 class CompilerInvocation : public CompilerInvocationRefBase,
                            public CompilerInvocationValueBase {
+  /// Implementation detail of clone().
+  CompilerInvocation(const CompilerInvocation &) = default;
+
 public:
+  CompilerInvocation() = default;
+  CompilerInvocation(CompilerInvocation &&) = default;
+  CompilerInvocation &operator=(CompilerInvocation &&) = default;
+  CompilerInvocation &operator=(const CompilerInvocation &) = delete;
+
+  /// Create a deep copy.
+  /// Also copies CompilerInvocationRefBase and its members behind
+  /// reference-counted pointers.
+  CompilerInvocation clone() const { return CompilerInvocation(*this); }
+
   /// Create a compiler invocation from a list of input options.
   /// \returns true on success.
   ///
   /// \returns false if an error was encountered while parsing the arguments
   /// and attempts to recover and continue parsing the rest of the arguments.
   /// The recovery is best-effort and only guarantees that \p Res will end up in
   /// one of the vaild-to-access (albeit arbitrary) states.
   ///

clang/lib/ARCMigrate/ARCMT.cpp

static bool HasARCRuntime(CompilerInvocation &origCI) {
   }
 
   return false;
 }
 
 static CompilerInvocation *
 createInvocationForMigration(CompilerInvocation &origCI,
                              const PCHContainerReader &PCHContainerRdr) {
-  std::unique_ptr<CompilerInvocation> CInvok;
-  CInvok.reset(new CompilerInvocation(origCI));
+  auto CInvok = std::make_unique<CompilerInvocation>(origCI.clone());
   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(),
applyTransforms(CompilerInvocation &origCI, const FrontendInputFile &Input,
                 DiagnosticConsumer *DiagClient, StringRef outputDir,
                 bool emitPremigrationARCErrors, StringRef plistOut) {
   if (!origCI.getLangOpts()->ObjC)
     return false;
 
   LangOptions::GCMode OrigGCMode = origCI.getLangOpts()->getGC();
 
   // Make sure checking is successful first.
-  CompilerInvocation CInvokForCheck(origCI);
+  CompilerInvocation CInvokForCheck(origCI.clone());
   if (arcmt::checkForManualIssues(CInvokForCheck, Input, PCHContainerOps,
                                   DiagClient, emitPremigrationARCErrors,
                                   plistOut))
     return true;
 
-  CompilerInvocation CInvok(origCI);
+  CompilerInvocation CInvok(origCI.clone());
   CInvok.getFrontendOpts().Inputs.clear();
   CInvok.getFrontendOpts().Inputs.push_back(Input);
 
   MigrationProcess migration(CInvok, PCHContainerOps, DiagClient, outputDir);
   bool NoFinalizeRemoval = origCI.getMigratorOpts().NoFinalizeRemoval;
 
   std::vector<TransformFn> transforms = arcmt::getAllTransformations(OrigGCMode,
                                                                      NoFinalizeRemoval);

 
 /// Anchor for VTable.
 MigrationProcess::RewriteListener::~RewriteListener() { }
 
 MigrationProcess::MigrationProcess(
     const CompilerInvocation &CI,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     DiagnosticConsumer *diagClient, StringRef outputDir)
-    : OrigCI(CI), PCHContainerOps(std::move(PCHContainerOps)),
+    : OrigCI(CI.clone()), PCHContainerOps(std::move(PCHContainerOps)),
       DiagClient(diagClient), HadARCErrors(false) {
   if (!outputDir.empty()) {
     IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
     IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
       new DiagnosticsEngine(DiagID, &CI.getDiagnosticOpts(),
                             DiagClient, /*ShouldOwnClient=*/false));
     Remapper.initFromDisk(outputDir, *Diags, /*ignoreIfFilesChanged=*/true);
   }

clang/lib/Frontend/ASTUnit.cpp

bool ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
                     IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {
   if (!Invocation)
     return true;
 
   if (VFS && FileMgr)
     assert(VFS == &FileMgr->getVirtualFileSystem() &&
            "VFS passed to Parse and VFS in FileMgr are different");
 
-  auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
+  auto CCInvocation = std::make_shared<CompilerInvocation>(Invocation->clone());
   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.
void ASTUnit::CodeComplete(
     SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers) {
   if (!Invocation)
     return;
 
   SimpleTimer CompletionTimer(WantTiming);
   CompletionTimer.setOutput("Code completion @ " + File + ":" +
                             Twine(Line) + ":" + Twine(Column));
 
-  auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation);
+  auto CCInvocation = std::make_shared<CompilerInvocation>(Invocation->clone());
 
   FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts();
   CodeCompleteOptions &CodeCompleteOpts = FrontendOpts.CodeCompleteOpts;
   PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts();
 
   CodeCompleteOpts.IncludeMacros = IncludeMacros &&
                                    CachedCompletionResults.empty();
   CodeCompleteOpts.IncludeCodePatterns = IncludeCodePatterns;

clang/lib/Frontend/ChainedIncludesSource.cpp

IntrusiveRefCntPtr<ExternalSemaSource> clang::createChainedIncludesSource(
   std::vector<std::unique_ptr<CompilerInstance>> CIs;
   InputKind IK = CI.getFrontendOpts().Inputs[0].getKind();
 
   SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 4> SerialBufs;
   SmallVector<std::string, 4> serialBufNames;
 
   for (unsigned i = 0, e = includes.size(); i != e; ++i) {
     bool firstInclude = (i == 0);
-    std::unique_ptr<CompilerInvocation> CInvok;
-    CInvok.reset(new CompilerInvocation(CI.getInvocation()));
+    auto CInvok =
+        std::make_unique<CompilerInvocation>(CI.getInvocation().clone());
 
     CInvok->getPreprocessorOpts().ChainedIncludes.clear();
     CInvok->getPreprocessorOpts().ImplicitPCHInclude.clear();
     CInvok->getPreprocessorOpts().DisablePCHOrModuleValidation =
         DisableValidationForModuleKind::PCH;
     CInvok->getPreprocessorOpts().Includes.clear();
     CInvok->getPreprocessorOpts().MacroIncludes.clear();
     CInvok->getPreprocessorOpts().Macros.clear();

clang/lib/Frontend/CompilerInstance.cpp

compileModuleImpl(CompilerInstance &ImportingInstance, SourceLocation ImportLoc,
                   StringRef OriginalModuleMapFile, StringRef ModuleFileName,
                   llvm::function_ref<void(CompilerInstance &)> PreBuildStep =
                       [](CompilerInstance &) {},
                   llvm::function_ref<void(CompilerInstance &)> PostBuildStep =
                       [](CompilerInstance &) {}) {
   llvm::TimeTraceScope TimeScope("Module Compile", ModuleName);
 
   // Construct a compiler invocation for creating this module.
-  auto Invocation =
-      std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation());
+  auto Invocation = std::make_shared<CompilerInvocation>(
+      ImportingInstance.getInvocation().clone());
 
   PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
 
   // For any options that aren't intended to affect how a module is built,
   // reset them to their default values.
   Invocation->getLangOpts()->resetNonModularOptions();
   PPOpts.resetNonModularOptions();
 

clang/lib/Frontend/CompilerInvocation.cpp

: LangOpts(new LangOptions(*X.getLangOpts())),
       HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
       PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())),
       AnalyzerOpts(new AnalyzerOptions(*X.getAnalyzerOpts())) {}
 
 CompilerInvocationRefBase::CompilerInvocationRefBase(
     CompilerInvocationRefBase &&X) = default;
 
 CompilerInvocationRefBase &
-CompilerInvocationRefBase::operator=(CompilerInvocationRefBase X) {
-  LangOpts.swap(X.LangOpts);
-  TargetOpts.swap(X.TargetOpts);
-  DiagnosticOpts.swap(X.DiagnosticOpts);
-  HeaderSearchOpts.swap(X.HeaderSearchOpts);
-  PreprocessorOpts.swap(X.PreprocessorOpts);
-  AnalyzerOpts.swap(X.AnalyzerOpts);
-  return *this;
-}
-
-CompilerInvocationRefBase &
 CompilerInvocationRefBase::operator=(CompilerInvocationRefBase &&X) = default;
 
 CompilerInvocationRefBase::~CompilerInvocationRefBase() = default;
 
 //===----------------------------------------------------------------------===//
 // Normalizers
 //===----------------------------------------------------------------------===//
 

clang/lib/Frontend/PrecompiledPreamble.cpp

llvm::ErrorOr<PrecompiledPreamble> PrecompiledPreamble::Build(
     const CompilerInvocation &Invocation,
     const llvm::MemoryBuffer *MainFileBuffer, PreambleBounds Bounds,
     DiagnosticsEngine &Diagnostics,
     IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps, bool StoreInMemory,
     PreambleCallbacks &Callbacks) {
   assert(VFS && "VFS is null");
 
-  auto PreambleInvocation = std::make_shared<CompilerInvocation>(Invocation);
+  auto PreambleInvocation =
+      std::make_shared<CompilerInvocation>(Invocation.clone());
   FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts();
   PreprocessorOptions &PreprocessorOpts =
       PreambleInvocation->getPreprocessorOpts();
 
   llvm::Optional<TempPCHFile> TempFile;
   if (!StoreInMemory) {
     // Create a temporary file for the precompiled preamble. In rare
     // circumstances, this can fail.
bool PrecompiledPreamble::CanReuse(const CompilerInvocation &Invocation,
                                    const llvm::MemoryBufferRef &MainFileBuffer,
                                    PreambleBounds Bounds,
                                    llvm::vfs::FileSystem &VFS) const {
 
   assert(
       Bounds.Size <= MainFileBuffer.getBufferSize() &&
       "Buffer is too large. Bounds were calculated from a different buffer?");
 
-  auto PreambleInvocation = std::make_shared<CompilerInvocation>(Invocation);
+  auto PreambleInvocation =
+      std::make_shared<CompilerInvocation>(Invocation.clone());
   PreprocessorOptions &PreprocessorOpts =
       PreambleInvocation->getPreprocessorOpts();
 
   // We've previously computed a preamble. Check whether we have the same
   // preamble now that we did before, and that there's enough space in
   // the main-file buffer within the precompiled preamble to fit the
   // new main file.
   if (PreambleBytes.size() != Bounds.Size ||

clang/lib/Frontend/Rewrite/FrontendActions.cpp

else {
       (*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()));
+        std::make_shared<CompilerInvocation>(CI.getInvocation().clone()));
     Instance.createDiagnostics(
         new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()),
         /*ShouldOwnClient=*/true);
     Instance.getFrontendOpts().DisableFree = false;
     Instance.getFrontendOpts().Inputs.clear();
     Instance.getFrontendOpts().Inputs.emplace_back(
         Filename, InputKind(Language::Unknown, InputKind::Precompiled));
     Instance.getFrontendOpts().ModuleFiles.clear();

clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp

void ModelInjector::onBodySynthesis(const NamedDecl *D) {
   else
     fileName = llvm::StringRef(D->getName().str() + ".model");
 
   if (!llvm::sys::fs::exists(fileName.str())) {
     Bodies[D->getName()] = nullptr;
     return;
   }
 
-  auto Invocation = std::make_shared<CompilerInvocation>(CI.getInvocation());
+  auto Invocation =
+      std::make_shared<CompilerInvocation>(CI.getInvocation().clone());
 
   FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
   InputKind IK = Language::CXX; // FIXME
   FrontendOpts.Inputs.clear();
   FrontendOpts.Inputs.emplace_back(fileName, IK);
   FrontendOpts.DisableFree = true;
 
   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;

clang/lib/Tooling/DependencyScanning/ModuleDepCollector.cpp

 
 using namespace clang;
 using namespace tooling;
 using namespace dependencies;
 
 static CompilerInvocation
 makeInvocationForModuleBuildWithoutPaths(const ModuleDeps &Deps) {
   // Make a deep copy of the invocation.
-  CompilerInvocation CI(*Deps.Invocation);
+  CompilerInvocation CI(Deps.Invocation->clone());
 
   // Remove options incompatible with explicit module build.
   CI.getFrontendOpts().Inputs.clear();
   CI.getFrontendOpts().OutputFile.clear();
 
   CI.getFrontendOpts().ProgramAction = frontend::GenerateModule;
   CI.getLangOpts()->ModuleName = Deps.ID.ModuleName;
   CI.getFrontendOpts().IsSystemModule = Deps.IsSystem;

clang/unittests/Frontend/CompilerInvocationTest.cpp

 TEST(ContainsN, Two) {
   const char *Array[] = {"x", "a", "b", "x"};
 
   ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 0)));
   ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 1)));
   ASSERT_THAT(Array, ContainsN(StrEq("x"), 2));
 }
 
-// Copy constructor/assignment perform deep copy of reference-counted pointers.
+// Clone performs deep copy of reference-counted pointers.
 
-TEST(CompilerInvocationTest, DeepCopyConstructor) {
+TEST(CompilerInvocationTest, CloneWithMoveConstructor) {
   CompilerInvocation A;
   A.getAnalyzerOpts()->Config["Key"] = "Old";
 
-  CompilerInvocation B(A);
+  CompilerInvocation B(A.clone());
   B.getAnalyzerOpts()->Config["Key"] = "New";
 
   ASSERT_EQ(A.getAnalyzerOpts()->Config["Key"], "Old");
 }
 
-TEST(CompilerInvocationTest, DeepCopyAssignment) {
+TEST(CompilerInvocationTest, CloneWithMoveAssignment) {
   CompilerInvocation A;
   A.getAnalyzerOpts()->Config["Key"] = "Old";
 
   CompilerInvocation B;
-  B = A;
+  B = A.clone();
   B.getAnalyzerOpts()->Config["Key"] = "New";
 
   ASSERT_EQ(A.getAnalyzerOpts()->Config["Key"], "Old");
 }
 
+TEST(CompilerInvocationTest, NotCopyConstructibleNorAssignable) {
+  ASSERT_FALSE(std::is_copy_constructible<CompilerInvocation>::value);
+  ASSERT_FALSE(std::is_copy_assignable<CompilerInvocation>::value);
+}
+
 // Boolean option with a keypath that defaults to true.
 // The only flag with a negative spelling can set the keypath to false.
 
 TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagNotPresent) {
   const char *Args[] = {""};
 
   ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
   ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary);