[flang] Update fir.select_type op to fit design document

[clementval]

Summary

Update the already existing fir.select_type operation to
reflect decisions made in the polymorphic entities design document.
The verifier is updated to check that the select is polymorphic.
The case attributes name are changed and some tests are added.

[jeanPerier]

Looks good

flang/include/flang/Optimizer/Dialect/FIRAttr.h

 
 class ExactTypeAttr
     : public mlir::Attribute::AttrBase<ExactTypeAttr, mlir::Attribute,
                                        detail::TypeAttributeStorage> {
 public:
   using Base::Base;
   using ValueType = mlir::Type;
 
-  static constexpr llvm::StringRef getAttrName() { return "instance"; }
+  static constexpr llvm::StringRef getAttrName() { return "type_is"; }
   static ExactTypeAttr get(mlir::Type value);
 
   mlir::Type getType() const;
 };
 
 class SubclassAttr
     : public mlir::Attribute::AttrBase<SubclassAttr, mlir::Attribute,
                                        detail::TypeAttributeStorage> {
 public:
   using Base::Base;
   using ValueType = mlir::Type;
 
-  static constexpr llvm::StringRef getAttrName() { return "subsumed"; }
+  static constexpr llvm::StringRef getAttrName() { return "class_is"; }
   static SubclassAttr get(mlir::Type value);
 
   mlir::Type getType() const;
 };
 
 // Attributes for building SELECT CASE multiway branches
 
 /// A closed interval (including the bound values) is an interval with both an

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

let description = [{
     Similar to `select`, `select_type` provides a way to express Fortran's
     SELECT TYPE construct.  In this case, the type of the selector value
     is matched against a list of type descriptors.  The structure is the
     same as `select`, but `select_type` determines the type of the selector
     variable at runtime to determine the best match.
 
     ```mlir
       fir.select_type %arg : !fir.box<()> [
-          #fir.instance<!fir.type<type1>>, ^bb1(%0 : i32),
-          #fir.instance<!fir.type<type2>>, ^bb2(%2 : i32),
-          #fir.subsumed<!fir.type<type3>>, ^bb3(%2 : i32),
-          #fir.instance<!fir.type<type4>>, ^bb4(%1,%3 : i32,f32),
+          #fir.type_is<!fir.type<type1>>, ^bb1(%0 : i32),
+          #fir.type_is<!fir.type<type2>>, ^bb2(%2 : i32),
+          #fir.class_is<!fir.type<type3>>, ^bb3(%2 : i32),
+          #fir.type_is<!fir.type<type4>>, ^bb4(%1,%3 : i32,f32),
           unit, ^bb5]
     ```
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [OpBuilder<(ins "mlir::Value":$selector,
     "llvm::ArrayRef<mlir::Attribute>":$typeOperands,
     "llvm::ArrayRef<mlir::Block *>":$destinations,

flang/lib/Optimizer/Dialect/FIROps.cpp

void fir::SelectTypeOp::print(mlir::OpAsmPrinter &p) {
   p << ']';
   p.printOptionalAttrDict(getOperation()->getAttrs(),
                           {getCasesAttr(), getCompareOffsetAttr(),
                            getTargetOffsetAttr(),
                            fir::SelectTypeOp::getOperandSegmentSizeAttr()});
 }
 
 mlir::LogicalResult fir::SelectTypeOp::verify() {
-  if (!(getSelector().getType().isa<fir::BoxType>()))
-    return emitOpError("must be a boxed type");
+  if (!(getSelector().getType().isa<fir::BaseBoxType>()))
+    return emitOpError("must be a fir.class or fir.box type");
+  if (auto boxType = getSelector().getType().dyn_cast<fir::BoxType>())
+    if (!boxType.getEleTy().isa<mlir::NoneType>())
+      return emitOpError("selector must be polymorphic");
   auto cases =
       getOperation()->getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
   auto count = getNumDest();
   if (count == 0)
     return emitOpError("must have at least one successor");
   if (getNumConditions() != count)
     return emitOpError("number of conditions and successors don't match");
   if (targetOffsetSize() != count)

flang/test/Fir/convert-to-llvm-invalid.fir

func.func @shape_shift_not_dead(%arg0: !fir.ref<!fir.array<?x?xf32>>, %i: index, %j: index) {
   return
 }
 
 // -----
 
 // Test `fir.select_type` conversion to llvm.
 // Should have been converted.
 
-func.func @bar_select_type(%arg : !fir.box<!fir.ref<f32>>) -> i32 {
+func.func @bar_select_type(%arg : !fir.class<!fir.type<derivedst{a:f32}>>) -> i32 {
   %0 = arith.constant 1 : i32
   %2 = arith.constant 3 : i32
   // expected-error@+2{{fir.select_type should have already been converted}}
   // expected-error@+1{{failed to legalize operation 'fir.select_type'}}
-  fir.select_type %arg : !fir.box<!fir.ref<f32>> [
-    #fir.instance<!fir.int<4>>,^bb1(%0:i32),
-    #fir.instance<!fir.int<8>>,^bb2(%2:i32),
+  fir.select_type %arg : !fir.class<!fir.type<derivedst{a:f32}>> [
+    #fir.type_is<!fir.int<4>>,^bb1(%0:i32),
+    #fir.type_is<!fir.int<8>>,^bb2(%2:i32),
     unit,^bb5 ]
 ^bb1(%a : i32) :
   return %a : i32
 ^bb2(%b : i32) :
   return %b : i32
 ^bb5 :
   %zero = arith.constant 0 : i32
   return %zero : i32

flang/test/Fir/fir-ops.fir

^bb5 :
   fir.dispatch "method"(%7 : !fir.class<!fir.type<derived3{f:f32}>>)
 
 // CHECK: return [[VAL_99]] : i32
 // CHECK: }
   return %zero : i32
 }
 
 // CHECK-LABEL: func @bar_select_type(
-// CHECK-SAME: [[VAL_101:%.*]]: !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
-func.func @bar_select_type(%arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
+// CHECK-SAME: [[VAL_101:%.*]]: !fir.class<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
+func.func @bar_select_type(%arg : !fir.class<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {
 
 // CHECK: [[VAL_102:%.*]] = arith.constant 1 : i32
 // CHECK: [[VAL_103:%.*]] = arith.constant 2 : i32
 // CHECK: [[VAL_104:%.*]] = arith.constant 3 : i32
 // CHECK: [[VAL_105:%.*]] = arith.constant 4 : i32
   %0 = arith.constant 1 : i32
   %1 = arith.constant 2 : i32
   %2 = arith.constant 3 : i32
   %3 = arith.constant 4 : i32
 
-// CHECK: fir.select_type [[VAL_101]] : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [#fir.instance<!fir.int<4>>, ^bb1([[VAL_102]] : i32), #fir.instance<!fir.int<8>>, ^bb2([[VAL_104]] : i32), #fir.subsumed<!fir.int<2>>, ^bb3([[VAL_104]] : i32), #fir.instance<!fir.int<1>>, ^bb4([[VAL_103]] : i32), unit, ^bb5]
-  fir.select_type %arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.instance<!fir.int<4>>,^bb1(%0:i32), #fir.instance<!fir.int<8>>,^bb2(%2:i32), #fir.subsumed<!fir.int<2>>,^bb3(%2:i32), #fir.instance<!fir.int<1>>,^bb4(%1:i32), unit,^bb5 ]
+// CHECK: fir.select_type [[VAL_101]] : !fir.class<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [#fir.type_is<!fir.int<4>>, ^bb1([[VAL_102]] : i32), #fir.type_is<!fir.int<8>>, ^bb2([[VAL_104]] : i32), #fir.class_is<!fir.int<2>>, ^bb3([[VAL_104]] : i32), #fir.type_is<!fir.int<1>>, ^bb4([[VAL_103]] : i32), unit, ^bb5]
+  fir.select_type %arg : !fir.class<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.type_is<!fir.int<4>>,^bb1(%0:i32), #fir.type_is<!fir.int<8>>,^bb2(%2:i32), #fir.class_is<!fir.int<2>>,^bb3(%2:i32), #fir.type_is<!fir.int<1>>,^bb4(%1:i32), unit,^bb5 ]
 
 // CHECK: ^bb1([[VAL_106:%.*]]: i32):
 // CHECK: return [[VAL_106]] : i32
 // CHECK: ^bb2([[VAL_107:%.*]]: i32):
 // CHECK: return [[VAL_107]] : i32
 // CHECK: ^bb3([[VAL_108:%.*]]: i32):
 // CHECK: return [[VAL_108]] : i32
 // CHECK: ^bb4([[VAL_109:%.*]]: i32):

flang/test/Fir/invalid.fir

 func.func @bad_array_declare_unlimited_polymorphic_boxaddr(%arg0: !fir.ref<!fir.class<!fir.ptr<!fir.array<?x?xnone>>>>) {
   %c1 = arith.constant 1 : index
   %c2 = arith.constant 2 : index
   %shape = fir.shift %c1, %c2 : (index, index) -> !fir.shift<2>
   // expected-error@+1 {{'fir.declare' op for box address must not have a shape operand}}
   %0 = fir.declare %arg0(%shape) {uniq_name = "x"} : (!fir.ref<!fir.class<!fir.ptr<!fir.array<?x?xnone>>>>, !fir.shift<2>) -> !fir.ref<!fir.class<!fir.ptr<!fir.array<?x?xnone>>>>
   return
 }
+
+// -----
+
+func.func @invalid_selector(%arg : !fir.box<!fir.ref<i32>>) -> i32 {
+  %0 = arith.constant 1 : i32
+  %2 = arith.constant 3 : i32
+  // expected-error@+1{{'fir.select_type' op selector must be polymorphic}}
+  fir.select_type %arg : !fir.box<!fir.ref<i32>> [
+    #fir.type_is<!fir.int<4>>,^bb1(%0:i32),
+    #fir.type_is<!fir.int<8>>,^bb2(%2:i32),
+    unit,^bb5 ]
+^bb1(%a : i32) :
+  return %a : i32
+^bb2(%b : i32) :
+  return %b : i32
+^bb5 :
+  %zero = arith.constant 0 : i32
+  return %zero : i32
+}