[flang][driver] Move fixed/free from detection out of FrontendAction API

[awarzynski]

Summary

All Fortran options should be set in CompilerInvocation before any of
FrontendActions is entered - that's the job of the driver. However, this
is a bit tricky with fixed and....free from detection introduced in
https://reviews.llvm.org/D94228.

Basically, fixed-free form detection needs to happen:

• separately for every input file (we might be compiling multiple Fortran files, some in free form, some in fixed form)
• before any frontend action (we need to specify isFixedForm in Fortran::parser::Options first)

In other words, we need this to happen early (before any
FrontendAction), but not too early (we need to know what the current
input file is). Ideally we would be able to set all Fortran options in
one place, but currently that's not possible.

All changes in this patch are NFCs (hence no new tests). Below is a

• move fixed/free form detection from FrontendAction::ExecuteAction to CompilerInstance::ExecuteAction
• add a bool flag in FrontendInputFile to mark a file as fixed/free form
• updated a few comments

[FarisRehman]

Thanks for working on this @awarzynski

LGTM!

flang/include/flang/Frontend/FrontendOptions.h

class FrontendInputFile {
   /// The input, if it comes from a buffer rather than a file. This object
   /// does not own the buffer, and the caller is responsible for ensuring
   /// that it outlives any users.
   const llvm::MemoryBuffer *buffer_ = nullptr;
 
   /// The kind of input, atm it contains language
   InputKind kind_;
 
+  /// Is this input file in fixed-form format? This is simply derived from the
+  /// file extension and should not be altered by consumers. For input from
+  /// stdin this is never modified.
+  bool isFixedForm_ = false;
+
 public:
   FrontendInputFile() = default;
   FrontendInputFile(llvm::StringRef file, InputKind kind)
-      : file_(file.str()), kind_(kind) {}
+      : file_(file.str()), kind_(kind) {
+
+    // Based on the extension, decide whether this is a fixed or free form
+    // file.
+    auto pathDotIndex{file.rfind(".")};
+    std::string pathSuffix{file.substr(pathDotIndex + 1)};
+    isFixedForm_ = isFixedFormSuffix(pathSuffix);
+  }
   FrontendInputFile(const llvm::MemoryBuffer *buffer, InputKind kind)
       : buffer_(buffer), kind_(kind) {}
 
   InputKind kind() const { return kind_; }
 
   bool IsEmpty() const { return file_.empty() && buffer_ == nullptr; }
   bool IsFile() const { return !IsBuffer(); }
   bool IsBuffer() const { return buffer_ != nullptr; }
+  bool IsFixedForm() const { return isFixedForm_; }
 
   llvm::StringRef file() const {
     assert(IsFile());
     return file_;
   }
 
   const llvm::MemoryBuffer *buffer() const {
     assert(IsBuffer() && "Requested buffer_, but it is empty!");

flang/lib/Frontend/CompilerInstance.cpp

for (OutputFile &of : outputFiles_)
     if (!of.filename_.empty() && eraseFiles)
       llvm::sys::fs::remove(of.filename_);
 
   outputFiles_.clear();
   nonSeekStream_.reset();
 }
 
 bool CompilerInstance::ExecuteAction(FrontendAction &act) {
+  auto &invoc = this->invocation();
+
   // Set some sane defaults for the frontend.
-  // TODO: Instead of defaults we should be setting these options based on the
-  // user input.
-  this->invocation().SetDefaultFortranOpts();
-  // Set the fortran options to user-based input.
-  this->invocation().setFortranOpts();
+  invoc.SetDefaultFortranOpts();
+  // Update the fortran options based on user-based input.
+  invoc.setFortranOpts();
 
-  // Connect Input to a CompileInstance
+  // 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

 
 llvm::Error FrontendAction::Execute() {
   CompilerInstance &ci = this->instance();
 
   std::string currentInputPath{GetCurrentFileOrBufferName()};
 
   Fortran::parser::Options parserOptions =
       this->instance().invocation().fortranOpts();
-  // Set the fixed form flag based on the file extension
-  auto pathDotIndex{currentInputPath.rfind(".")};
-  if (pathDotIndex != std::string::npos) {
-    std::string pathSuffix{currentInputPath.substr(pathDotIndex + 1)};
-    parserOptions.isFixedForm = isFixedFormSuffix(pathSuffix);
-  }
 
   // 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();