[clang] Change ordering of PreableCallbacks to make sure PP can be referenced in them

[kbobyrev]

Summary

Currently, BeforeExecute is called before BeginSourceFile which does not allow
using PP in the callbacks. Change the ordering to ensure it is possible.
This is a prerequisite for D114370.

Originated from a discussion with @kadircet.

[kadircet]

As discussed offline this definitely LGTM, let me summarize the reasoning here.

The original review was in https://reviews.llvm.org/D41365. It's unclear why they went with before BeginSourceFile. In theory having the callback issued before BeginSourceFile allows setting various options that'll effect parsing, but today there's only one user (at least in the upstream) of this callback, clangd, which uses the callack to stash some state from CompilerIntance rather than mutating it.
If we ever have users that'll need to mutate the CompilerIntance before BeginSourceFile, I think we should have a particular callback for that use case then.

Will still wait for feedback from @sammccall as he might have some historical context.

[sammccall]

Yeah this change definitely looks safe:

• we've moving it across BeginSourceFile only, which doesn't seem to do anything for the usual parse that we'd use when building preambles.
• BeforeExecute isn't widely used

Also it seems saner: Before/AfterExecute are now consistently nested inside Begin/EndSourceFile.

I don't have particular insight into the original motivation, but I guess it was just driven by what was needed: why go for the "more powerful" thing if we only needed to inspect the CompilerInstance?

clang/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.
+  /// Called before FrontendAction::Execute.
   /// 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.
   /// NOTE: To allow more flexibility a custom ASTConsumer could probably be
   /// used instead, but having only this method allows a simpler API.
   virtual void HandleTopLevelDecl(DeclGroupRef DG);
   /// Creates wrapper class for PPCallbacks so we can also process information
-  /// about includes that are inside of a preamble
+  /// about includes that are inside of a preamble. Called after BeforeExecute.
   virtual std::unique_ptr<PPCallbacks> createPPCallbacks();
   /// The returned CommentHandler will be added to the preprocessor if not null.
   virtual CommentHandler *getCommentHandler();
   /// Determines which function bodies are parsed, by default skips everything.
   /// Only used if FrontendOpts::SkipFunctionBodies is true.
   /// See ASTConsumer::shouldSkipFunctionBody.
   virtual bool shouldSkipFunctionBody(Decl *D) { return true; }
 };

clang/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;
 
+  // Performed after BeginSourceFile to ensure Clang->Preprocessor can be
+  // referenced in the callback.
+  Callbacks.BeforeExecute(*Clang);
+
   std::unique_ptr<PPCallbacks> DelegatedPPCallbacks =
       Callbacks.createPPCallbacks();
   if (DelegatedPPCallbacks)
     Clang->getPreprocessor().addPPCallbacks(std::move(DelegatedPPCallbacks));
   if (auto CommentHandler = Callbacks.getCommentHandler())
     Clang->getPreprocessor().addCommentHandler(CommentHandler);
   llvm::StringSet<> MissingFiles;
   Clang->getPreprocessor().addPPCallbacks(