FORALL lowering

This is a major restructuring of how FORALL loops are lowered in the bridge from
parse trees to FIR. Previously, FORALL loops had been lowered like any other
structured control-flow loops and then as a more dynamic form of array
expression.

This refactoring is a middle road approach where the FORALL context is analyzed
and then lowered in the bridge. This allows lowering to create loop nests that
correctly deal with impure expressions and pure masking expressions, which were
not aligned with array expressions.  Lowering of assignment statements in the
FORALL context is then done within the pre-built context by expression lowering.
Secondly, expression lowering is refactored into a new "scalar array" traversal
and code gen that works with array values as instantiated by the bridge in the
earlier loop generation phase.

Switching to this structure allows the array expression framework to be
simplified since it no longer is required to deal with "special" scalar
expressions and try to raise them into an array form.

Allocatable arrays and pointer assignments are supported.

User-defined ASSIGNMENT in (scalar) FORALL contexts is supported.

This also introduces several correctness fixes.

This does not correct known problems with arrays of CHARACTER, incomplete
information with respect to derived types, elemental user-defined ASSIGNMENT in
array expressions, PDTs, etc.

Author: schweitzpgi

flang/include/flang/Lower/ConvertExpr.h

@@ -19,6 +19,7 @@
 
 #include "flang/Evaluate/shape.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
 
 namespace mlir {
 class Location;
@@ -176,6 +177,14 @@ createSomeArrayBox(AbstractConverter &converter,
                    const evaluate::Expr<evaluate::SomeType> &expr,
                    SymMap &symMap, StatementContext &stmtCtx);
 
+// Attribute for an alloca that is a trivial adaptor for converting a value to
+// pass-by-ref semantics for a VALUE parameter. The optimizer may be able to
+// eliminate these.
+inline mlir::NamedAttribute getAdaptToByRefAttr(fir::FirOpBuilder &builder) {
+  return {mlir::Identifier::get("adapt.valuebyref", builder.getContext()),
+          builder.getUnitAttr()};
+}
+
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_CONVERTEXPR_H

flang/include/flang/Optimizer/Builder/FIRBuilder.h

@@ -338,7 +338,7 @@ class FirOpBuilder : public mlir::OpBuilder {
   mlir::Value genIsNotNull(mlir::Location loc, mlir::Value addr);
 
 private:
-  const fir::KindMapping &kindMap;
+  const KindMapping &kindMap;
 };
 
 } // namespace fir

flang/include/flang/Optimizer/Dialect/FIRType.h

@@ -163,6 +163,12 @@ inline mlir::Type unwrapSequenceType(mlir::Type t) {
   return t;
 }
 
+inline mlir::Type unwrapRefType(mlir::Type t) {
+  if (auto eleTy = dyn_cast_ptrEleTy(t))
+    return eleTy;
+  return t;
+}
+
 /// If `t` conforms with a pass-by-reference type (box, ref, ptr, etc.) then
 /// return the element type of `t`. Otherwise, return `t`.
 inline mlir::Type unwrapPassByRefType(mlir::Type t) {
@@ -193,6 +199,13 @@ bool isUnlimitedPolymorphicType(mlir::Type ty);
 /// Return true iff `ty` is a RecordType with members that are allocatable.
 bool isRecordWithAllocatableMember(mlir::Type ty);
 
+/// Return true iff `ty` is a RecordType with type parameters.
+inline bool isRecordWithTypeParameters(mlir::Type ty) {
+  if (auto recTy = ty.dyn_cast_or_null<fir::RecordType>())
+    return recTy.getNumLenParams() != 0;
+  return false;
+}
+
 /// Apply the components specified by `path` to `rootTy` to determine the type
 /// of the resulting component element. `rootTy` should be an aggregate type.
 /// Returns null on error.

flang/include/flang/Optimizer/Transforms/Factory.h

@@ -27,6 +27,10 @@ class Value;
 
 namespace fir::factory {
 
+constexpr llvm::StringRef attrFortranArrayOffsets() {
+  return "Fortran.offsets";
+}
+
 /// Generate a character copy with optimized forms.
 ///
 /// If the lengths are constant and equal, use load/store rather than a loop.
@@ -137,14 +141,27 @@ void genCharacterCopy(mlir::Value src, mlir::Value srcLen, mlir::Value dst,
   builder.restoreInsertionPoint(insPt);
 }
 
+/// Get extents from fir.shape/fir.shape_shift op. Empty result if
+/// \p shapeVal is empty or is a fir.shift.
+inline std::vector<mlir::Value> getExtents(mlir::Value shapeVal) {
+  if (shapeVal)
+    if (auto *shapeOp = shapeVal.getDefiningOp()) {
+      if (auto shOp = mlir::dyn_cast<fir::ShapeOp>(shapeOp))
+        return shOp.getExtents();
+      if (auto shOp = mlir::dyn_cast<fir::ShapeShiftOp>(shapeOp))
+        return shOp.getExtents();
+    }
+  return {};
+}
+
 /// Get origins from fir.shape_shift/fir.shift op. Empty result if
 /// \p shapeVal is empty or is a fir.shape.
 inline std::vector<mlir::Value> getOrigins(mlir::Value shapeVal) {
   if (shapeVal)
     if (auto *shapeOp = shapeVal.getDefiningOp()) {
       if (auto shOp = mlir::dyn_cast<fir::ShapeShiftOp>(shapeOp))
         return shOp.getOrigins();
-      else if (auto shOp = mlir::dyn_cast<fir::ShiftOp>(shapeOp))
+      if (auto shOp = mlir::dyn_cast<fir::ShiftOp>(shapeOp))
         return shOp.getOrigins();
     }
   return {};