[clang] Add BeforeExecute method to PrecompiledPreamble

[Nebiroth]

Summary

Adds BeforeExecute method to PrecompiledPreamble to be called before Execute(). This method can be overriden.

[ilya-biryukov]

include/clang/Frontend/PrecompiledPreamble.h

249

The comment seems a bit too specific.
Maybe change it to something like "can be used to store references to various CompilerInstance fields (e.g. SourceManager) that may be interesting to the consumers of other callbacks"

lib/Frontend/PrecompiledPreamble.cpp

345

We should probably call it here, right before Execute.
Or maybe right before BeginSourceFile if we can receive the callbacks while executing BeginSourceFile. We should make sure to update the comment if you decide to call it before BeginSourceFile.

[Nebiroth]

Modified comment
Changed where BeforeExecute is called

[ilya-biryukov]

LGTM modulo the comment. Should I land this for you?

include/clang/Frontend/PrecompiledPreamble.h

247

Please add that the following information to the comment:

/// Called before FrontendAction::BeginSourceFile .
/// Can be used ....

[Nebiroth]

Updated BeforeExecute comment

[Nebiroth]

Yes please land this.

[ilya-biryukov]

LG

include/clang/Frontend/PrecompiledPreamble.h

private:
   bool PreambleEndsAtStartOfLine;
 };
 
 /// A set of callbacks to gather useful information while building a preamble.
 class PreambleCallbacks {
 public:
   virtual ~PreambleCallbacks() = default;
 
+  /// Called before FrontendAction::BeginSourceFile.
+  /// Can be used to store references to various CompilerInstance fields
+  /// (e.g. SourceManager) that may be interesting to the consumers of other callbacks.
+  virtual void BeforeExecute(CompilerInstance &CI);
   /// Called after FrontendAction::Execute(), but before
   /// FrontendAction::EndSourceFile(). Can be used to transfer ownership of
   /// various CompilerInstance fields before they are destroyed.
   virtual void AfterExecute(CompilerInstance &CI);
   /// Called after PCH has been emitted. \p Writer may be used to retrieve
   /// information about AST, serialized in PCH.
   virtual void AfterPCHEmitted(ASTWriter &Writer);
   /// Called for each TopLevelDecl.

lib/Frontend/PrecompiledPreamble.cpp

if (PreprocessorOpts.RetainRemappedFileBuffers) {
     // BeginSourceFile, so we call release() to avoid double deletion.
     PreprocessorOpts.addRemappedFile(MainFilePath,
                                      PreambleInputBuffer.release());
   }
 
   std::unique_ptr<PrecompilePreambleAction> Act;
   Act.reset(new PrecompilePreambleAction(
       StoreInMemory ? &Storage.asMemory().Data : nullptr, Callbacks));
+  Callbacks.BeforeExecute(*Clang);
   if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0]))
     return BuildPreambleError::BeginSourceFileFailed;
 
   std::unique_ptr<PPCallbacks> DelegatedPPCallbacks =
       Callbacks.createPPCallbacks();
   if (DelegatedPPCallbacks)
     Clang->getPreprocessor().addPPCallbacks(std::move(DelegatedPPCallbacks));
 
   Act->Execute();
 
   // Run the callbacks.
   Callbacks.AfterExecute(*Clang);
 
   Act->EndSourceFile();
 
   if (!Act->hasEmittedPreamblePCH())
     return BuildPreambleError::CouldntEmitPCH;
if (Storage.getKind() == PCHStorage::Kind::TempFile) {
     StringRef PCHPath = getInMemoryPreamblePath();
     PreprocessorOpts.ImplicitPCHInclude = PCHPath;
 
     auto Buf = llvm::MemoryBuffer::getMemBuffer(Storage.asMemory().Data);
     VFS = createVFSOverlayForPreamblePCH(PCHPath, std::move(Buf), VFS);
   }
 }
 
+void PreambleCallbacks::BeforeExecute(CompilerInstance &CI) {}
 void PreambleCallbacks::AfterExecute(CompilerInstance &CI) {}
 void PreambleCallbacks::AfterPCHEmitted(ASTWriter &Writer) {}
 void PreambleCallbacks::HandleTopLevelDecl(DeclGroupRef DG) {}
 std::unique_ptr<PPCallbacks> PreambleCallbacks::createPPCallbacks() {
   return nullptr;
 }
 
 std::error_code clang::make_error_code(BuildPreambleError Error) {