[flang][driver] Add PrescanAction frontend action (nfc)

[awarzynski]

Summary

This new action encapsulates all actions that require the prescanner to
be run before proceeding with other processing. By adding this new
action, we are better equipped to control which actions _do_ run the
prescanner and which _do not_.

The following actions that require the prescanner are refactored to
inherit from PrescanAction:

• PrintPreprocessedAction
• ParseSyntaxOnlyAction .

New virtual method is introduced to facilitate all this:

• BeginSourceFileAction

Like in Clang, this method is run inside BeginSrouceFile. In other
words, it is invoked before ExecuteAction for the corresponding
frontend action is run. This method allows us to:

• carry out any processing that is always required by the action (e.g. run the prescanner)
• fine tune the settings/options on a file-by-file basis (e.g. to decide between fixed-form and free-form based on file extension)

This patch implements non-functional-changes.

[FarisRehman]

Thanks for working on this @awarzynski, this patch allows actions that do not need to run the prescanner to not do so.
I've left a nit, but otherwise LRTM!

flang/lib/Frontend/FrontendActions.cpp

29

[nit] Update this comment to reflect the move of this line from the loop into this method, e.g. removing mention of the loop like Ideally we should have all Fortran options set before processing any input files.?

flang/include/flang/Frontend/FrontendAction.h

 //===- FrontendAction.h -----------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Defines the flang::FrontendAction interface.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_FLANG_FRONTEND_FRONTENDACTION_H
 #define LLVM_FLANG_FRONTEND_FRONTENDACTION_H
 
 #include "flang/Frontend/FrontendOptions.h"
 #include "llvm/Support/Error.h"
 
 namespace Fortran::frontend {
 class CompilerInstance;
 
 /// Abstract base class for actions which can be performed by the frontend.
 class FrontendAction {
   FrontendInputFile currentInput_;
   CompilerInstance *instance_;
 
 protected:
   /// @name Implementation Action Interface
   /// @{
 
   /// Callback to run the program action, using the initialized
   /// compiler instance.
   virtual void ExecuteAction() = 0;
 
   /// Callback at the end of processing a single input, to determine
   /// if the output files should be erased or not.
   ///
   /// By default it returns true if a compiler error occurred.
   virtual bool ShouldEraseOutputFiles();
 
+  /// Callback at the start of processing a single input.
+  ///
+  /// \return True on success; on failure ExecutionAction() and
+  /// EndSourceFileAction() will not be called.
+  virtual bool BeginSourceFileAction(CompilerInstance &ci) { return true; }
+
   /// @}
 
 public:
   FrontendAction() : instance_(nullptr) {}
   virtual ~FrontendAction() = default;
 
   /// @name Compiler Instance Access
   /// @{
llvm::StringRef GetCurrentFileOrBufferName() const {
     return currentInput_.IsFile()
         ? currentInput_.file()
         : currentInput_.buffer()->getBufferIdentifier();
   }
   void set_currentInput(const FrontendInputFile &currentInput);
 
   /// @}
   /// @name Public Action Interface
-  /// @}
+  /// @{
 
   /// Prepare the action for processing the input file \p input.
   ///
   /// This is run after the options and frontend have been initialized,
   /// but prior to executing any per-file processing.
   /// \param ci - The compiler instance this action is being run from. The
   /// action may store and use this object.
   /// \param input - The input filename and kind.

flang/include/flang/Frontend/FrontendActions.h

 //===- FrontendActions.h -----------------------------------------*- 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_FLANG_FRONTEND_FRONTENDACTIONS_H
 #define LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H
 
 #include "flang/Frontend/FrontendAction.h"
 
 namespace Fortran::frontend {
 
 //===----------------------------------------------------------------------===//
 // Custom Consumer Actions
 //===----------------------------------------------------------------------===//
 
 class InputOutputTestAction : public FrontendAction {
   void ExecuteAction() override;
 };
 
-class PrintPreprocessedAction : public FrontendAction {
+class EmitObjAction : public FrontendAction {
   void ExecuteAction() override;
 };
 
-class ParseSyntaxOnlyAction : public FrontendAction {
+//===----------------------------------------------------------------------===//
+// Prescan Actions
+//===----------------------------------------------------------------------===//
+class PrescanAction : public FrontendAction {
   void ExecuteAction() override;
+  bool BeginSourceFileAction(CompilerInstance &ci) override;
 };
 
-class EmitObjAction : public FrontendAction {
+class PrintPreprocessedAction : public PrescanAction {
+  void ExecuteAction() override;
+};
+
+class ParseSyntaxOnlyAction : public PrescanAction {
   void ExecuteAction() override;
 };
 
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H

flang/lib/Frontend/CompilerInstance.cpp

bool CompilerInstance::ExecuteAction(FrontendAction &act) {
   // Set some sane defaults for the frontend.
   invoc.SetDefaultFortranOpts();
   // Update the fortran options based on user-based input.
   invoc.setFortranOpts();
 
   // Run the frontend action `act` for every input file.
   for (const FrontendInputFile &fif : frontendOpts().inputs_) {
     if (act.BeginSourceFile(*this, fif)) {
-      // Switch between fixed and free form format based on the input file
-      // extension. Ideally we should have all Fortran options set before
-      // entering this loop (i.e. processing any input files). However, we
-      // can't decide between fixed and free form based on the file extension
-      // earlier than this.
-      invoc.fortranOpts().isFixedForm = fif.IsFixedForm();
       if (llvm::Error err = act.Execute()) {
         consumeError(std::move(err));
       }
       act.EndSourceFile();
     }
   }
   return !diagnostics().getClient()->getNumErrors();
 }

flang/lib/Frontend/FrontendAction.cpp

 //===--- FrontendAction.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/FrontendAction.h"
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/FrontendActions.h"
 #include "flang/Frontend/FrontendOptions.h"
 #include "flang/FrontendTool/Utils.h"
 #include "llvm/Support/Errc.h"
 
 using namespace Fortran::frontend;
 

 bool FrontendAction::BeginSourceFile(
     CompilerInstance &ci, const FrontendInputFile &realInput) {
 
   FrontendInputFile input(realInput);
   assert(!instance_ && "Already processing a source file!");
   assert(!realInput.IsEmpty() && "Unexpected empty filename!");
   set_currentInput(realInput);
   set_instance(&ci);
+
   if (!ci.HasAllSources()) {
     BeginSourceFileCleanUp(*this, ci);
     return false;
   }
+
+  if (!BeginSourceFileAction(ci)) {
+    BeginSourceFileCleanUp(*this, ci);
+    return false;
+  }
+
   return true;
 }
 
 bool FrontendAction::ShouldEraseOutputFiles() {
   return instance().diagnostics().hasErrorOccurred();
 }
 
 llvm::Error FrontendAction::Execute() {
-  CompilerInstance &ci = this->instance();
-
-  std::string currentInputPath{GetCurrentFileOrBufferName()};
-
-  Fortran::parser::Options parserOptions =
-      this->instance().invocation().fortranOpts();
-
-  // Prescan. In case of failure, report and return.
-  ci.parsing().Prescan(currentInputPath, parserOptions);
-
-  if (ci.parsing().messages().AnyFatalError()) {
-    const unsigned diagID = ci.diagnostics().getCustomDiagID(
-        clang::DiagnosticsEngine::Error, "Could not scan %0");
-    ci.diagnostics().Report(diagID) << GetCurrentFileOrBufferName();
-    ci.parsing().messages().Emit(llvm::errs(), ci.allCookedSources());
-
-    return llvm::Error::success();
-  }
-
   ExecuteAction();
 
   return llvm::Error::success();
 }
 
 void FrontendAction::EndSourceFile() {
   CompilerInstance &ci = instance();
 
   // Cleanup the output streams, and erase the output files if instructed by the
   // FrontendAction.
   ci.ClearOutputFiles(/*EraseFiles=*/ShouldEraseOutputFiles());
 
   set_instance(nullptr);
   set_currentInput(FrontendInputFile());
 }

flang/lib/Frontend/FrontendActions.cpp

 //===--- FrontendActions.cpp ----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/FrontendActions.h"
 #include "flang/Common/default-kinds.h"
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Parser/provenance.h"
 #include "flang/Parser/source.h"
 #include "flang/Semantics/semantics.h"
 
 using namespace Fortran::frontend;
 
-void InputOutputTestAction::ExecuteAction() {
+bool PrescanAction::BeginSourceFileAction(CompilerInstance &c1) {
+  CompilerInstance &ci = this->instance();
+
+  std::string currentInputPath{GetCurrentFileOrBufferName()};
+
+  Fortran::parser::Options parserOptions =
+      this->instance().invocation().fortranOpts();
 
+  // Switch between fixed and free form format based on the input file
+  // extension. Ideally we should have all Fortran options set before
+  // entering this loop (i.e. processing any input files). However, we
+  // can't decide between fixed and free form based on the file extension
+  // earlier than this.
+  parserOptions.isFixedForm = currentInput().IsFixedForm();
+
+  // Prescan. In case of failure, report and return.
+  ci.parsing().Prescan(currentInputPath, parserOptions);
+
+  if (ci.parsing().messages().AnyFatalError()) {
+    const unsigned diagID = ci.diagnostics().getCustomDiagID(
+        clang::DiagnosticsEngine::Error, "Could not scan %0");
+    ci.diagnostics().Report(diagID) << GetCurrentFileOrBufferName();
+    ci.parsing().messages().Emit(llvm::errs(), ci.allCookedSources());
+
+    return false;
+  }
+
+  return true;
+}
+
+void InputOutputTestAction::ExecuteAction() {
   // Get the name of the file from FrontendInputFile current.
   std::string path{GetCurrentFileOrBufferName()};
   std::string buf;
   llvm::raw_string_ostream error_stream{buf};
   bool binaryMode = true;
 
   // Set/store input file info into CompilerInstance.
   CompilerInstance &ci = instance();