[flang][fir][NFC] Move BoxProcType to TableGen type definition

[clementval]

Summary

This patch is a follow up of D96422 and move BoxProcType to TableGen.

[clementval]

Rebase

[mehdi_amini]

flang/lib/Optimizer/Dialect/FIRType.cpp

1392

I didn't ask on the previous revision, but do we already have test coverage on all these? The refactoring could be an opportunity to check this if you can :)

[schweitz]

flang/lib/Optimizer/Dialect/FIRType.cpp

1392

Still trying to get enough code upstreamed to add the tool to do that. Chicken-and-egg situation.

[mehdi_amini]

flang/lib/Optimizer/Dialect/FIRType.cpp

1392

I don't understand the chicken and egg?
Adding a fir-opt tool *first* seems trivial to me, let me send a patch.

[clementval]

flang/lib/Optimizer/Dialect/FIRType.cpp

1392

We have a fir-opt tool ready in fir-dev. I can send a patch. https://reviews.llvm.org/D96535

[clementval]

Keep fir_ prefix

[clementval]

Rebase

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

 // Reference types
 def AnyReferenceLike : TypeConstraint<Or<[fir_ReferenceType.predicate,
     fir_HeapType.predicate, fir_PointerType.predicate]>, "any reference">;
 
 // CHARACTER type descriptor. A pair of a data reference and a LEN value.
 def fir_BoxCharType : Type<CPred<"$_self.isa<fir::BoxCharType>()">,
     "box character type">;
 
-// PROCEDURE POINTER descriptor. A pair that can capture a host closure.
-def fir_BoxProcType : Type<CPred<"$_self.isa<fir::BoxProcType>()">,
-    "box procedure type">;
-
 def AnyBoxLike : TypeConstraint<Or<[BoxType.predicate,
-    fir_BoxCharType.predicate, fir_BoxProcType.predicate]>, "any box">;
+    fir_BoxCharType.predicate, BoxProcType.predicate]>, "any box">;
 
 def AnyRefOrBox : TypeConstraint<Or<[fir_ReferenceType.predicate,
     fir_HeapType.predicate, fir_PointerType.predicate, BoxType.predicate]>,
     "any reference or box">;
 
 def AnyShapeLike : TypeConstraint<Or<[ShapeType.predicate,
     ShapeShiftType.predicate]>, "any legal shape type">;
 def AnyShapeType : Type<AnyShapeLike.predicate, "any legal shape type">;
let description = [{
     ```mlir
       %4 = ... : !fir.ref<tuple<i32, i32>>
       %5 = fir.emboxproc @g, %4 : ((i32) -> i32, !fir.ref<tuple<i32, i32>>) -> !fir.boxproc<(i32) -> i32>
     ```
   }];
 
   let arguments = (ins SymbolRefAttr:$funcname, AnyReferenceLike:$host);
 
-  let results = (outs fir_BoxProcType);
+  let results = (outs BoxProcType);
 
   let parser = [{
     mlir::SymbolRefAttr procRef;
     if (parser.parseAttribute(procRef, "funcname", result.attributes))
       return mlir::failure();
     bool hasTuple = false;
     mlir::OpAsmParser::OperandType tupleRef;
     if (!parser.parseOptionalComma()) {
def fir_UnboxProcOp : fir_SimpleOp<"unboxproc", [NoSideEffect]> {
 
   let verifier = [{
     if (auto eleTy = fir::dyn_cast_ptrEleTy(refTuple().getType()))
       if (eleTy.isa<mlir::TupleType>())
         return mlir::success();
     return emitOpError("second output argument has bad type");
   }];
 
-  let arguments = (ins fir_BoxProcType:$boxproc);
+  let arguments = (ins BoxProcType:$boxproc);
 
   let results = (outs FunctionType, fir_ReferenceType:$refTuple);
 }
 
 def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]> {
   let summary = "return a memory reference to the boxed value";
 
   let description = [{
let description = [{
     ```
 
     In the example, the reference to the closure over the host procedure's
     variables is returned. This allows an internal procedure to access the
     host's variables. It is up to lowering to determine the contract between
     the host and the internal procedure.
   }];
 
-  let arguments = (ins fir_BoxProcType:$val);
+  let arguments = (ins BoxProcType:$val);
 
   let results = (outs fir_ReferenceType);
 }
 
 def fir_BoxRankOp : fir_SimpleOneResultOp<"box_rank", [NoSideEffect]> {
   let summary = "return the number of dimensions for the boxed value";
 
   let description = [{

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

 namespace fir {
 
 class FIROpsDialect;
 
 using KindTy = unsigned;
 
 namespace detail {
 struct BoxCharTypeStorage;
-struct BoxProcTypeStorage;
 struct CharacterTypeStorage;
 struct ComplexTypeStorage;
 struct FieldTypeStorage;
 struct HeapTypeStorage;
 struct IntegerTypeStorage;
 struct LenTypeStorage;
 struct LogicalTypeStorage;
 struct PointerTypeStorage;

 class BoxCharType : public mlir::Type::TypeBase<BoxCharType, mlir::Type,
                                                 detail::BoxCharTypeStorage> {
 public:
   using Base::Base;
   static BoxCharType get(mlir::MLIRContext *ctxt, KindTy kind);
   CharacterType getEleTy() const;
 };
 
-/// The type of a pair that describes a PROCEDURE reference. Pointers to
-/// internal procedures must carry an additional reference to the host's
-/// variables that are referenced.
-class BoxProcType : public mlir::Type::TypeBase<BoxProcType, mlir::Type,
-                                                detail::BoxProcTypeStorage> {
-public:
-  using Base::Base;
-  static BoxProcType get(mlir::Type eleTy);
-  mlir::Type getEleTy() const;
-
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          mlir::Type eleTy);
-};
-
 /// Type of a vector that represents an array slice operation on an array.
 /// Fortran slices are triples of lower bound, upper bound, and stride. The rank
 /// of a SliceType must be at least 1.
 class SliceType : public mlir::Type::TypeBase<SliceType, mlir::Type,
                                               detail::SliceTypeStorage> {
 public:
   using Base::Base;
   static SliceType get(mlir::MLIRContext *ctx, unsigned rank);

flang/include/flang/Optimizer/Dialect/FIRTypes.td

 //===----------------------------------------------------------------------===//
 // FIR Types
 //===----------------------------------------------------------------------===//
 
 class FIR_Type<string name, string typeMnemonic> : TypeDef<fir_Dialect, name> {
   let mnemonic = typeMnemonic;
 }
 
+def BoxProcType : FIR_Type<"BoxProc", "boxproc"> {
+  let summary = "";
+
+  let description = [{
+    The type of a pair that describes a PROCEDURE reference. Pointers to
+    internal procedures must carry an additional reference to the host's
+    variables that are referenced.
+  }];
+
+  let parameters = (ins "mlir::Type":$eleTy);
+
+  let printer = [{
+    $_printer << "boxproc<";
+    $_printer.printType(getEleTy());
+    $_printer << '>';
+  }];
+
+  let genAccessors = 1;
+
+  let genVerifyInvariantsDecl = 1;
+}
+
 def BoxType : FIR_Type<"Box", "box"> {
   let summary = "The type of a Fortran descriptor";
 
   let description = [{
     Descriptors are tuples of information that describe an entity being passed
     from a calling context. This information might include (but is not limited
     to) whether the entity is an array, its size, or what type it has.
   }];
 
   let parameters = (ins "mlir::Type":$eleTy, "mlir::AffineMapAttr":$map);
 
   let extraClassDeclaration = [{
     mlir::Type getElementType() const { return getEleTy(); }
     mlir::AffineMapAttr getLayoutMap() const { return getMap(); }
     static BoxType get(mlir::Type eleTy, mlir::AffineMapAttr map = {}) {
       return get(eleTy, map);
     }
   }];
 
   let genAccessors = 1;
+
   let genVerifyInvariantsDecl = 1;
 }
 
 def ShapeType : FIR_Type<"Shape", "shape"> {
   let summary = "shape of a multidimensional array object";
 
   let description = [{
     Type of a vector of runtime values that define the shape of a

flang/lib/Optimizer/Dialect/FIRType.cpp

TYPE parseTypeSingleton(mlir::DialectAsmParser &parser, mlir::Location) {
   return TYPE::get(ty);
 }
 
 // `boxchar` `<` kind `>`
 BoxCharType parseBoxChar(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<BoxCharType>(parser);
 }
 
-// `boxproc` `<` return-type `>`
-BoxProcType parseBoxProc(mlir::DialectAsmParser &parser, mlir::Location loc) {
-  return parseTypeSingleton<BoxProcType>(parser, loc);
-}
-
 // `char` `<` kind [`,` `len`] `>`
 CharacterType parseCharacter(mlir::DialectAsmParser &parser) {
   int kind = 0;
   if (parser.parseLess() || parser.parseInteger(kind)) {
     parser.emitError(parser.getCurrentLocation(), "kind value expected");
     return {};
   }
   CharacterType::LenType len = 1;
mlir::Type fir::parseFirType(FIROpsDialect *dialect,
   auto loc = parser.getEncodedSourceLoc(parser.getNameLoc());
   if (typeNameLit == "array")
     return parseSequence(parser, loc);
   if (typeNameLit == "box")
     return generatedTypeParser(dialect->getContext(), parser, typeNameLit);
   if (typeNameLit == "boxchar")
     return parseBoxChar(parser);
   if (typeNameLit == "boxproc")
-    return parseBoxProc(parser, loc);
+    return generatedTypeParser(dialect->getContext(), parser, typeNameLit);
   if (typeNameLit == "char")
     return parseCharacter(parser);
   if (typeNameLit == "complex")
     return parseComplex(parser);
   if (typeNameLit == "field")
     return parseField(parser);
   if (typeNameLit == "heap")
     return parseHeap(parser, loc);

 protected:
   KindTy kind;
 
 private:
   BoxCharTypeStorage() = delete;
   explicit BoxCharTypeStorage(KindTy kind) : kind{kind} {}
 };
 
-/// Boxed PROCEDURE POINTER object type
-struct BoxProcTypeStorage : public mlir::TypeStorage {
-  using KeyTy = mlir::Type;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getElementType(); }
-
-  static BoxProcTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                       mlir::Type eleTy) {
-    assert(eleTy && "element type is null");
-    auto *storage = allocator.allocate<BoxProcTypeStorage>();
-    return new (storage) BoxProcTypeStorage{eleTy};
-  }
-
-  mlir::Type getElementType() const { return eleTy; }
-
-protected:
-  mlir::Type eleTy;
-
-private:
-  BoxProcTypeStorage() = delete;
-  explicit BoxProcTypeStorage(mlir::Type eleTy) : eleTy{eleTy} {}
-};
-
 /// Pointer-like object storage
 struct ReferenceTypeStorage : public mlir::TypeStorage {
   using KeyTy = mlir::Type;
 
   static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getElementType(); }
 

 BoxCharType fir::BoxCharType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, kind);
 }
 
 CharacterType fir::BoxCharType::getEleTy() const {
   return getImpl()->getElementType(getContext());
 }
 
-// BoxProc<T>
-
-BoxProcType fir::BoxProcType::get(mlir::Type elementType) {
-  return Base::get(elementType.getContext(), elementType);
-}
-
-mlir::Type fir::BoxProcType::getEleTy() const {
-  return getImpl()->getElementType();
-}
-
-mlir::LogicalResult
-fir::BoxProcType::verifyConstructionInvariants(mlir::Location loc,
-                                               mlir::Type eleTy) {
-  if (eleTy.isa<mlir::FunctionType>())
-    return mlir::success();
-  if (auto refTy = eleTy.dyn_cast<ReferenceType>())
-    if (refTy.isa<mlir::FunctionType>())
-      return mlir::success();
-  return mlir::emitError(loc, "invalid type for boxproc") << eleTy << '\n';
-}
-
 // Reference<T>
 
 ReferenceType fir::ReferenceType::get(mlir::Type elementType) {
   return Base::get(elementType.getContext(), elementType);
 }
 
 mlir::Type fir::ReferenceType::getEleTy() const {
   return getImpl()->getElementType();

 void fir::printFirType(FIROpsDialect *, mlir::Type ty,
                        mlir::DialectAsmPrinter &p) {
   auto &os = p.getStream();
   if (auto type = ty.dyn_cast<BoxCharType>()) {
     os << "boxchar<" << type.getEleTy().cast<fir::CharacterType>().getFKind()
        << '>';
     return;
   }
-  if (auto type = ty.dyn_cast<BoxProcType>()) {
-    os << "boxproc<";
-    p.printType(type.getEleTy());
-    os << '>';
-    return;
-  }
   if (auto chTy = ty.dyn_cast<CharacterType>()) {
     // Fortran intrinsic type CHARACTER
     os << "char<" << chTy.getFKind();
     auto len = chTy.getLen();
     if (len != fir::CharacterType::singleton()) {
       os << ',';
       if (len == fir::CharacterType::unknownLen())
         os << '?';
if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>())
         return true;
   }
   return false;
 }
 
 namespace fir {
 
 //===----------------------------------------------------------------------===//
+// BoxProcType
+//===----------------------------------------------------------------------===//
+
+// `boxproc` `<` return-type `>`
+mlir::Type BoxProcType::parse(mlir::MLIRContext *context,
+                              mlir::DialectAsmParser &parser) {
+  mlir::Type ty;
+  if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater()) {
+    parser.emitError(parser.getCurrentLocation(), "type expected");
+    return Type();
+  }
+  return get(context, ty);
+}
+
+mlir::LogicalResult
+BoxProcType::verifyConstructionInvariants(mlir::Location loc,
+                                          mlir::Type eleTy) {
+  if (eleTy.isa<mlir::FunctionType>())
+    return mlir::success();
+  if (auto refTy = eleTy.dyn_cast<ReferenceType>())
+    if (refTy.isa<mlir::FunctionType>())
+      return mlir::success();
+  return mlir::emitError(loc, "invalid type for boxproc") << eleTy << '\n';
+}
+
+//===----------------------------------------------------------------------===//
 // BoxType
 //===----------------------------------------------------------------------===//
 
 // `box` `<` type (',' affine-map)? `>`
 mlir::Type BoxType::parse(mlir::MLIRContext *context,
                           mlir::DialectAsmParser &parser) {
   mlir::Type ofTy;
   if (parser.parseLess() || parser.parseType(ofTy)) {