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

[clementval]

Summary

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

[clementval]

Add printer

[mehdi_amini]

LGTM

All these type refactoring to table gen are fairly mechanical, I'm fine if you just push them with post-commit review. Or you could migrate all of them at once and sent one revision. Whatever works best.

[clementval]

In D96610#2560660, @mehdi_amini wrote:

LGTM

All these type refactoring to table gen are fairly mechanical, I'm fine if you just push them with post-commit review. Or you could migrate all of them at once and sent one revision. Whatever works best.

Thanks. I'll make a final patch with the remaining types to be moved.

[clementval]

Keep fir_ prefix

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

def AnyEmboxLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
     Index.predicate, fir_IntegerType.predicate]>,
     "any legal embox argument type">;
 def AnyEmboxArg : Type<AnyEmboxLike.predicate, "embox argument type">;
 
 // A type descriptor's type
 def fir_TypeDescType : Type<CPred<"$_self.isa<fir::TypeDescType>()">,
     "type desc type">;
 
-// A field (in a RecordType) argument's type
-def fir_FieldType : Type<CPred<"$_self.isa<fir::FieldType>()">, "field type">;
-
 // A LEN parameter (in a RecordType) argument's type
 def fir_LenType : Type<CPred<"$_self.isa<fir::LenType>()">,
     "LEN parameter type">;
 
 def AnyComponentLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
     Index.predicate, fir_IntegerType.predicate, fir_FieldType.predicate]>,
     "any coordinate index">;
 def AnyComponentType : Type<AnyComponentLike.predicate, "coordinate type">;

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

 
 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;
 struct RealTypeStorage;
 struct RecordTypeStorage;
 struct ReferenceTypeStorage;

 class SliceType : public mlir::Type::TypeBase<SliceType, mlir::Type,
                                               detail::SliceTypeStorage> {
 public:
   using Base::Base;
   static SliceType get(mlir::MLIRContext *ctx, unsigned rank);
   unsigned getRank() const;
 };
 
-/// The type of a field name. Implementations may defer the layout of a Fortran
-/// derived type until runtime. This implies that the runtime must be able to
-/// determine the offset of fields within the entity.
-class FieldType : public mlir::Type::TypeBase<FieldType, mlir::Type,
-                                              detail::FieldTypeStorage> {
-public:
-  using Base::Base;
-  static FieldType get(mlir::MLIRContext *ctxt);
-};
-
 /// The type of a heap pointer. Fortran entities with the ALLOCATABLE attribute
 /// may be allocated on the heap at runtime. These pointers are explicitly
 /// distinguished to disallow the composition of multiple levels of
 /// indirection. For example, an ALLOCATABLE POINTER is invalid.
 class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
                                              detail::HeapTypeStorage> {
 public:
   using Base::Base;

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

static BoxType get(mlir::Type eleTy, mlir::AffineMapAttr map = {}) {
       return get(eleTy.getContext(), eleTy, map);
     }
   }];
 
   let genAccessors = 1;
   let genVerifyInvariantsDecl = 1;
 }
 
+def fir_FieldType : FIR_Type<"Field", "field"> {
+  let summary = "A field (in a RecordType) argument's type";
+
+  let description = [{
+    The type of a field name. Implementations may defer the layout of a Fortran
+    derived type until runtime. This implies that the runtime must be able to
+    determine the offset of fields within the entity.
+  }];
+
+  let printer = [{
+    $_printer << "field";
+  }];
+
+  let parser = [{
+    return get(context);
+  }];
+
+}
+
 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
     multidimensional array object. The vector is the extents of each array
     dimension. The rank of a ShapeType must be at least 1.
   }];

flang/lib/Optimizer/Dialect/FIRType.cpp

fir::ComplexType parseComplex(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<fir::ComplexType>(parser);
 }
 
 // `slice` `<` rank `>`
 SliceType parseSlice(mlir::DialectAsmParser &parser) {
   return parseRankSingleton<SliceType>(parser);
 }
 
-// `field`
-FieldType parseField(mlir::DialectAsmParser &parser) {
-  return FieldType::get(parser.getBuilder().getContext());
-}
-
 // `heap` `<` type `>`
 HeapType parseHeap(mlir::DialectAsmParser &parser, mlir::Location loc) {
   return parseTypeSingleton<HeapType>(parser, loc);
 }
 
 // `int` `<` kind `>`
 fir::IntegerType parseInteger(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<fir::IntegerType>(parser);
if (typeNameLit == "boxchar")
     return parseBoxChar(parser);
   if (typeNameLit == "boxproc")
     return parseBoxProc(parser, loc);
   if (typeNameLit == "char")
     return parseCharacter(parser);
   if (typeNameLit == "complex")
     return parseComplex(parser);
   if (typeNameLit == "field")
-    return parseField(parser);
+    return generatedTypeParser(dialect->getContext(), parser, typeNameLit);
   if (typeNameLit == "heap")
     return parseHeap(parser, loc);
   if (typeNameLit == "int")
     return parseInteger(parser);
   if (typeNameLit == "len")
     return parseLen(parser);
   if (typeNameLit == "logical")
     return parseLogical(parser);

 protected:
   unsigned rank;
 
 private:
   SliceTypeStorage() = delete;
   explicit SliceTypeStorage(unsigned rank) : rank{rank} {}
 };
 
-/// The type of a derived type part reference
-struct FieldTypeStorage : public mlir::TypeStorage {
-  using KeyTy = KindTy;
-
-  static unsigned hashKey(const KeyTy &) { return llvm::hash_combine(0); }
-
-  bool operator==(const KeyTy &) const { return true; }
-
-  static FieldTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                     KindTy) {
-    auto *storage = allocator.allocate<FieldTypeStorage>();
-    return new (storage) FieldTypeStorage{0};
-  }
-
-private:
-  FieldTypeStorage() = delete;
-  explicit FieldTypeStorage(KindTy) {}
-};
-
 /// The type of a derived type LEN parameter reference
 struct LenTypeStorage : public mlir::TypeStorage {
   using KeyTy = KindTy;
 
   static unsigned hashKey(const KeyTy &) { return llvm::hash_combine(0); }
 
   bool operator==(const KeyTy &) const { return true; }
 

 }
 
 KindTy fir::CharacterType::getFKind() const { return getImpl()->getFKind(); }
 
 CharacterType::LenType fir::CharacterType::getLen() const {
   return getImpl()->getLen();
 }
 
-// Field
-
-FieldType fir::FieldType::get(mlir::MLIRContext *ctxt) {
-  return Base::get(ctxt, 0);
-}
-
 // Len
 
 LenType fir::LenType::get(mlir::MLIRContext *ctxt) {
   return Base::get(ctxt, 0);
 }
 
 // LOGICAL
 
if (auto type = ty.dyn_cast<RecordType>()) {
     }
     os << '>';
     return;
   }
   if (auto type = ty.dyn_cast<SliceType>()) {
     os << "slice<" << type.getRank() << '>';
     return;
   }
-  if (ty.isa<FieldType>()) {
-    os << "field";
-    return;
-  }
   if (auto type = ty.dyn_cast<HeapType>()) {
     os << "heap<";
     p.printType(type.getEleTy());
     os << '>';
     return;
   }
   if (auto type = ty.dyn_cast<fir::IntegerType>()) {
     // Fortran intrinsic type INTEGER