[fir] Restrict array type on fir.insert_on_range

[clementval]

Summary

Sequence type had no restriction on the insert_on_range operation.
This patch adds a restriction for the type to have constant shape
and size.

[mehdi_amini]

flang/lib/Optimizer/Dialect/FIROps.cpp

1392

Isn't this second check already covered by hasDynamicSize?
The code there starts with:

if (auto arr = t.dyn_cast<fir::SequenceType>()) {
   if (sequenceWithNonConstantShape(arr))
     return true;

LG otherwise

1392

Oh also please update the doc for the op in the ODS definition

[clementval]

ddress review comments

[clementval]

flang/lib/Optimizer/Dialect/FIROps.cpp

1392

Yes sequenceWithNonConstantShape is included in hasDynamicSize.

ODS definition updated.

flang/include/flang/Optimizer/Dialect/FIROps.td

def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]> {
 
   let hasCanonicalizer = 1;
 }
 
 def fir_InsertOnRangeOp : fir_OneResultOp<"insert_on_range", [NoSideEffect]> {
   let summary = "insert sub-value into a range on an existing sequence";
 
   let description = [{
-    Insert copies of a value into an entity with an array type.
+    Insert copies of a value into an entity with an array type of constant shape
+    and size.
     Returns a new ssa value with the same type as the original entity.
     The values are inserted at a contiguous range of indices in Fortran
     row-to-column element order as specified by lower and upper bound
     coordinates.
 
     ```mlir
       %a = fir.undefined !fir.array<10x10xf32>
       %c = arith.constant 3.0 : f32

flang/lib/Optimizer/Dialect/FIROps.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // InsertOnRangeOp
 //===----------------------------------------------------------------------===//
 
 /// Range bounds must be nonnegative, and the range must not be empty.
 static mlir::LogicalResult verify(fir::InsertOnRangeOp op) {
+  if (fir::hasDynamicSize(op.seq().getType()))
+    return op.emitOpError("must have constant shape and size");
   if (op.coor().size() < 2 || op.coor().size() % 2 != 0)
     return op.emitOpError("has uneven number of values in ranges");
   bool rangeIsKnownToBeNonempty = false;
   for (auto i = op.coor().end(), b = op.coor().begin(); i != b;) {
     int64_t ub = (*--i).cast<IntegerAttr>().getInt();
     int64_t lb = (*--i).cast<IntegerAttr>().getInt();
     if (lb < 0 || ub < 0)
       return op.emitOpError("negative range bound");
     if (rangeIsKnownToBeNonempty)

flang/test/Fir/invalid.fir

fir.global internal @_QEmultiarray : !fir.array<32x32xi32> {
   %0 = fir.undefined !fir.array<32x32xi32>
   // expected-error@+1 {{'fir.insert_on_range' op empty range}}
   %2 = fir.insert_on_range %0, %c0_i32, [10 : index, 9 : index] : (!fir.array<32x32xi32>, i32) -> !fir.array<32x32xi32>
   fir.has_value %2 : !fir.array<32x32xi32>
 }
 
 // -----
 
+fir.global internal @_QEmultiarray : !fir.array<?xi32> {
+  %c0_i32 = arith.constant 1 : i32
+  %0 = fir.undefined !fir.array<?xi32>
+  // expected-error@+1 {{'fir.insert_on_range' op must have constant shape and size}}
+  %2 = fir.insert_on_range %0, %c0_i32, [0 : index, 10 : index] : (!fir.array<?xi32>, i32) -> !fir.array<?xi32>
+  fir.has_value %2 : !fir.array<?xi32>
+}
+
+// -----
+
+fir.global internal @_QEmultiarray : !fir.array<*:i32> {
+  %c0_i32 = arith.constant 1 : i32
+  %0 = fir.undefined !fir.array<*:i32>
+  // expected-error@+1 {{'fir.insert_on_range' op must have constant shape and size}}
+  %2 = fir.insert_on_range %0, %c0_i32, [0 : index, 10 : index] : (!fir.array<*:i32>, i32) -> !fir.array<*:i32>
+  fir.has_value %2 : !fir.array<*:i32>
+}
+
+// -----
+
 func @bad_save_result(%buffer : !fir.ref<!fir.array<?xf64>>, %n :index) {
   %res = fir.call @array_func() : () -> !fir.array<?xf32>
   %shape = fir.shape %n : (index) -> !fir.shape<1>
   // expected-error@+1 {{'fir.save_result' op value type must match memory reference type}}
   fir.save_result %res to %buffer(%shape) : !fir.array<?xf32>, !fir.ref<!fir.array<?xf64>>, !fir.shape<1>
   return
 }