[Frontend] Flip default of CreateInvocationOptions::ProbePrecompiled to false

[sammccall]

Summary

This is generally a better default for tools other than the compiler, which
shouldn't assume a PCH file on disk is something they can consume.

Preserve the old behavior in places associated with libclang/c-index-test
(including ASTUnit) as there are tests relying on it and most important
consumers are out-of-tree. It's unclear whether the tests are specifically
trying to test this functionality, and what the downstream implications of
removing it are. Hopefully someone more familiar can clean this up in future.

clang/include/clang/Frontend/Utils.h

struct CreateInvocationOptions {
   /// Whether to attempt to produce a non-null (possibly incorrect) invocation
   /// if any errors were encountered.
   /// By default, always return null on errors.
   bool RecoverOnError = false;
   /// Allow the driver to probe the filesystem for PCH files.
   /// This is used to replace -include with -include-pch in the cc1 args.
   /// FIXME: ProbePrecompiled=true is a poor, historical default.
   /// It misbehaves if the PCH file is from GCC, has the wrong version, etc.
-  bool ProbePrecompiled = true;
+  bool ProbePrecompiled = false;
   /// If set, the target is populated with the cc1 args produced by the driver.
   /// This may be populated even if createInvocation returns nullptr.
   std::vector<std::string> *CC1Args = nullptr;
 };
 
 /// Interpret clang arguments in preparation to parse a file.
 ///
 /// This simulates a number of steps Clang takes when its driver is invoked:

clang/lib/Frontend/ASTUnit.cpp

ASTUnit *ASTUnit::LoadFromCommandLine(
 
   {
     CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags,
                                       &StoredDiagnostics, nullptr);
 
     CreateInvocationOptions CIOpts;
     CIOpts.VFS = VFS;
     CIOpts.Diags = Diags;
+    CIOpts.ProbePrecompiled = true; // FIXME: historical default. Needed?
     CI = createInvocation(llvm::makeArrayRef(ArgBegin, ArgEnd),
                           std::move(CIOpts));
     if (!CI)
       return nullptr;
   }
 
   // Override any files that need remapping
   for (const auto &RemappedFile : RemappedFiles) {

clang/tools/c-index-test/core_main.cpp

static bool printSourceSymbols(const char *Executable,
                                bool ignoreMacros) {
   SmallVector<const char *, 4> ArgsWithProgName;
   ArgsWithProgName.push_back(Executable);
   ArgsWithProgName.append(Args.begin(), Args.end());
   IntrusiveRefCntPtr<DiagnosticsEngine>
     Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions));
   CreateInvocationOptions CIOpts;
   CIOpts.Diags = Diags;
+  CIOpts.ProbePrecompiled = true; // FIXME: historical default. Needed?
   auto CInvok = createInvocation(ArgsWithProgName, std::move(CIOpts));
   if (!CInvok)
     return true;
 
   raw_ostream &OS = outs();
   auto DataConsumer = std::make_shared<PrintIndexDataConsumer>(OS);
   IndexingOptions IndexOpts;
   IndexOpts.IndexFunctionLocals = indexLocals;

clang/tools/libclang/Indexing.cpp

static CXErrorCode clang_indexSourceFile_Impl(
   // in the actual argument list.
   // Put the source file after command_line_args otherwise if '-x' flag is
   // present it will be unused.
   if (source_filename)
     Args->push_back(source_filename);
 
   CreateInvocationOptions CIOpts;
   CIOpts.Diags = Diags;
+  CIOpts.ProbePrecompiled = true; // FIXME: historical default. Needed?
   std::shared_ptr<CompilerInvocation> CInvok =
       createInvocation(*Args, std::move(CIOpts));
 
   if (!CInvok)
     return CXError_Failure;
 
   // Recover resources if we crash before exiting this function.
   llvm::CrashRecoveryContextCleanupRegistrar<

clang/unittests/Frontend/UtilsTest.cpp

TEST(BuildCompilerInvocationTest, ProbePrecompiled) {
   auto FS = llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();
   FS->addFile("foo.h", 0, llvm::MemoryBuffer::getMemBuffer(""));
   FS->addFile("foo.h.pch", 0, llvm::MemoryBuffer::getMemBuffer(""));
 
   clang::IgnoringDiagConsumer D;
   llvm::IntrusiveRefCntPtr<DiagnosticsEngine> CommandLineDiagsEngine =
       clang::CompilerInstance::createDiagnostics(new DiagnosticOptions, &D,
                                                  false);
-  // Default: ProbePrecompiled is true.
+  // Default: ProbePrecompiled=false
   CreateInvocationOptions CIOpts;
   CIOpts.Diags = CommandLineDiagsEngine;
   CIOpts.VFS = FS;
   std::unique_ptr<CompilerInvocation> CI = createInvocation(Args, CIOpts);
   ASSERT_TRUE(CI);
-  EXPECT_THAT(CI->getPreprocessorOpts().Includes, ElementsAre());
-  EXPECT_EQ(CI->getPreprocessorOpts().ImplicitPCHInclude, "foo.h.pch");
+  EXPECT_THAT(CI->getPreprocessorOpts().Includes, ElementsAre("foo.h"));
+  EXPECT_EQ(CI->getPreprocessorOpts().ImplicitPCHInclude, "");
 
-  CIOpts.ProbePrecompiled = false;
+  CIOpts.ProbePrecompiled = true;
   CI = createInvocation(Args, CIOpts);
   ASSERT_TRUE(CI);
-  EXPECT_THAT(CI->getPreprocessorOpts().Includes, ElementsAre("foo.h"));
-  EXPECT_EQ(CI->getPreprocessorOpts().ImplicitPCHInclude, "");
+  EXPECT_THAT(CI->getPreprocessorOpts().Includes, ElementsAre());
+  EXPECT_EQ(CI->getPreprocessorOpts().ImplicitPCHInclude, "foo.h.pch");
 }
 
 } // namespace
 } // namespace clang