[flang] Pass SemanticsContext to the LoweringBridge

[clementval]

Summary

The SemanticsContext is needed to analyze expression later in the
lowering for directive languages. This patch allows to keep a reference of
the SemanticsContext in the LoweringBridge.

Building block for D131765

flang/include/flang/Lower/Bridge.h

 
 /// The lowering bridge converts the front-end parse trees and semantics
 /// checking residual to MLIR (FIR dialect) code.
 class LoweringBridge {
 public:
   /// Create a lowering bridge instance.
   static LoweringBridge
   create(mlir::MLIRContext &ctx,
+         Fortran::semantics::SemanticsContext &semanticsContext,
          const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
          const Fortran::evaluate::IntrinsicProcTable &intrinsics,
          const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
          const Fortran::parser::AllCookedSources &allCooked,
          llvm::StringRef triple, fir::KindMapping &kindMap,
          const Fortran::lower::LoweringOptions &loweringOptions) {
-    return LoweringBridge(ctx, defaultKinds, intrinsics, targetCharacteristics,
-                          allCooked, triple, kindMap, loweringOptions);
+    return LoweringBridge(ctx, semanticsContext, defaultKinds, intrinsics,
+                          targetCharacteristics, allCooked, triple, kindMap,
+                          loweringOptions);
   }
 
   //===--------------------------------------------------------------------===//
   // Getters
   //===--------------------------------------------------------------------===//
 
   mlir::MLIRContext &getMLIRContext() { return context; }
 
public:
 
   const Fortran::lower::LoweringOptions &getLoweringOptions() const {
     return loweringOptions;
   }
 
   /// Create a folding context. Careful: this is very expensive.
   Fortran::evaluate::FoldingContext createFoldingContext() const;
 
+  Fortran::semantics::SemanticsContext &getSemanticsContext() const {
+    return semanticsContext;
+  }
+
   bool validModule() { return getModule(); }
 
   //===--------------------------------------------------------------------===//
   // Perform the creation of an mlir::ModuleOp
   //===--------------------------------------------------------------------===//
 
   /// Read in an MLIR input file rather than lowering Fortran sources.
   /// This is intended to be used for testing.
   void parseSourceFile(llvm::SourceMgr &);
 
   /// Cross the bridge from the Fortran parse-tree, etc. to MLIR dialects
   void lower(const Fortran::parser::Program &program,
              const Fortran::semantics::SemanticsContext &semanticsContext);
 
 private:
   explicit LoweringBridge(
       mlir::MLIRContext &ctx,
+      Fortran::semantics::SemanticsContext &semanticsContext,
       const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
       const Fortran::evaluate::IntrinsicProcTable &intrinsics,
       const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
       const Fortran::parser::AllCookedSources &cooked, llvm::StringRef triple,
       fir::KindMapping &kindMap,
       const Fortran::lower::LoweringOptions &loweringOptions);
   LoweringBridge() = delete;
   LoweringBridge(const LoweringBridge &) = delete;
 
+  Fortran::semantics::SemanticsContext &semanticsContext;
   const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds;
   const Fortran::evaluate::IntrinsicProcTable &intrinsics;
   const Fortran::evaluate::TargetCharacteristics &targetCharacteristics;
   const Fortran::parser::AllCookedSources *cooked;
   mlir::MLIRContext &context;
   std::unique_ptr<mlir::ModuleOp> module;
   fir::KindMapping &kindMap;
   const Fortran::lower::LoweringOptions &loweringOptions;
 };
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_BRIDGE_H

flang/lib/Frontend/FrontendActions.cpp

bool CodeGenAction::beginSourceFileAction() {
   bool res = runPrescan() && runParse() && runSemanticChecks() &&
              generateRtTypeTables();
   if (!res)
     return res;
 
   // Create a LoweringBridge
   const common::IntrinsicTypeDefaultKinds &defKinds =
       ci.getInvocation().getSemanticsContext().defaultKinds();
-  fir::KindMapping kindMap(mlirCtx.get(),
-      llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
+  fir::KindMapping kindMap(mlirCtx.get(), llvm::ArrayRef<fir::KindTy>{
+                                              fir::fromDefaultKinds(defKinds)});
   lower::LoweringBridge lb = Fortran::lower::LoweringBridge::create(
-      *mlirCtx, defKinds, ci.getInvocation().getSemanticsContext().intrinsics(),
+      *mlirCtx, ci.getInvocation().getSemanticsContext(), defKinds,
+      ci.getInvocation().getSemanticsContext().intrinsics(),
       ci.getInvocation().getSemanticsContext().targetCharacteristics(),
       ci.getParsing().allCooked(), ci.getInvocation().getTargetOpts().triple,
       kindMap, ci.getInvocation().getLoweringOpts());
 
   // Create a parse tree and lower it to FIR
   Fortran::parser::Program &parseTree{*ci.getParsing().parseTree()};
   lb.lower(parseTree, ci.getInvocation().getSemanticsContext());
   mlirModule = std::make_unique<mlir::ModuleOp>(lb.getModule());
if (reportFatalSemanticErrors()) {
     return;
   }
 
   parser::AllCookedSources &cs = ci.getAllCookedSources();
   unsigned diagID = ci.getDiagnostics().getCustomDiagID(
       clang::DiagnosticsEngine::Error, "Symbol not found");
 
   auto gdv = ci.getInvocation().getFrontendOpts().getDefVals;
-  auto charBlock{cs.GetCharBlockFromLineAndColumns(
-      gdv.line, gdv.startColumn, gdv.endColumn)};
+  auto charBlock{cs.GetCharBlockFromLineAndColumns(gdv.line, gdv.startColumn,
+                                                   gdv.endColumn)};
   if (!charBlock) {
     ci.getDiagnostics().Report(diagID);
     return;
   }
 
   llvm::outs() << "String range: >" << charBlock->ToString() << "<\n";
 
   auto *symbol{ci.getInvocation()

flang/lib/Lower/Bridge.cpp

void Fortran::lower::LoweringBridge::parseSourceFile(llvm::SourceMgr &srcMgr) {
   mlir::OwningOpRef<mlir::ModuleOp> owningRef =
       mlir::parseSourceFile<mlir::ModuleOp>(srcMgr, &context);
   module.reset(new mlir::ModuleOp(owningRef.get().getOperation()));
   owningRef.release();
 }
 
 Fortran::lower::LoweringBridge::LoweringBridge(
     mlir::MLIRContext &context,
+    Fortran::semantics::SemanticsContext &semanticsContext,
     const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds,
     const Fortran::evaluate::IntrinsicProcTable &intrinsics,
     const Fortran::evaluate::TargetCharacteristics &targetCharacteristics,
     const Fortran::parser::AllCookedSources &cooked, llvm::StringRef triple,
     fir::KindMapping &kindMap,
     const Fortran::lower::LoweringOptions &loweringOptions)
-    : defaultKinds{defaultKinds}, intrinsics{intrinsics},
-      targetCharacteristics{targetCharacteristics}, cooked{&cooked},
-      context{context}, kindMap{kindMap}, loweringOptions{loweringOptions} {
+    : semanticsContext{semanticsContext}, defaultKinds{defaultKinds},
+      intrinsics{intrinsics}, targetCharacteristics{targetCharacteristics},
+      cooked{&cooked}, context{context}, kindMap{kindMap},
+      loweringOptions{loweringOptions} {
   // Register the diagnostic handler.
   context.getDiagEngine().registerHandler([](mlir::Diagnostic &diag) {
     llvm::raw_ostream &os = llvm::errs();
     switch (diag.getSeverity()) {
     case mlir::DiagnosticSeverity::Error:
       os << "error: ";
       break;
     case mlir::DiagnosticSeverity::Remark:

flang/tools/bbc/bbc.cpp

static mlir::LogicalResult convertFortranSourceToMLIR(
   mlir::MLIRContext ctx(registry);
   fir::support::loadNonCodegenDialects(ctx);
   auto &defKinds = semanticsContext.defaultKinds();
   fir::KindMapping kindMap(
       &ctx, llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
   // Use default lowering options for bbc.
   Fortran::lower::LoweringOptions loweringOptions{};
   auto burnside = Fortran::lower::LoweringBridge::create(
-      ctx, defKinds, semanticsContext.intrinsics(),
+      ctx, semanticsContext, defKinds, semanticsContext.intrinsics(),
       semanticsContext.targetCharacteristics(), parsing.allCooked(), "",
       kindMap, loweringOptions);
   burnside.lower(parseTree, semanticsContext);
   mlir::ModuleOp mlirModule = burnside.getModule();
   std::error_code ec;
   std::string outputName = outputFilename;
   if (!outputName.size())
     outputName = llvm::sys::path::stem(inputFilename).str().append(".mlir");