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

[clementval]

Summary

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

[clementval]

Keep fir_ prefix

[clementval]

Rebase

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

 // Types and predicates
 
 def fir_Type : Type<CPred<"fir::isa_fir_or_std_type($_self)">,
     "FIR dialect type">;
 
 // Fortran intrinsic types
 def fir_CharacterType : Type<CPred<"$_self.isa<fir::CharacterType>()">,
     "FIR character type">;
-def fir_ComplexType : Type<CPred<"$_self.isa<fir::ComplexType>()">,
-    "FIR complex type">;
 def fir_IntegerType : Type<CPred<"$_self.isa<fir::IntegerType>()">,
     "FIR integer type">;
 def fir_LogicalType : Type<CPred<"$_self.isa<fir::LogicalType>()">,
     "FIR logical type">;
 def fir_RealType : Type<CPred<"$_self.isa<fir::RealType>()">,
     "FIR real type">;
 def fir_VectorType : Type<CPred<"$_self.isa<fir::VectorType>()">,
     "FIR vector type">;
def fir_RecordType : Type<CPred<"$_self.isa<fir::RecordType>()">,
     "FIR derived type">;
 
 // Fortran array attribute
 def fir_SequenceType : Type<CPred<"$_self.isa<fir::SequenceType>()">,
     "array type">;
 
 // Composable types
 def AnyCompositeLike : TypeConstraint<Or<[fir_RecordType.predicate,
-    fir_SequenceType.predicate, fir_ComplexType.predicate,
+    fir_SequenceType.predicate, ComplexType.predicate,
     fir_VectorType.predicate, IsTupleTypePred]>, "any composite">;
 
 // Reference to an entity type
 def fir_ReferenceType : Type<CPred<"$_self.isa<fir::ReferenceType>()">,
     "reference type">;
 
 // Reference to an ALLOCATABLE attribute type
 def fir_HeapType : Type<CPred<"$_self.isa<fir::HeapType>()">,
def fir_ConstcOp : fir_Op<"constc", [NoSideEffect]> {
   let summary = "create a complex constant";
 
   let description = [{
     A complex constant. Similar to the standard dialect complex type, but this
     extension allows constants with APFloat values that are not supported in
     the standard dialect.
   }];
 
-  let results = (outs fir_ComplexType);
+  let results = (outs ComplexType);
 
   let parser = [{
     fir::RealAttr realp;
     fir::RealAttr imagp;
     mlir::Type type;
     if (parser.parseLParen() ||
         parser.parseAttribute(realp, realAttrName(), result.attributes) ||
         parser.parseComma() ||
let extraClassDeclaration = [{
 
     mlir::Attribute getReal() { return (*this)->getAttr(realAttrName()); }
     mlir::Attribute getImaginary() { return (*this)->getAttr(imagAttrName()); }
   }];
 }
 
 class ComplexUnaryArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
       fir_UnaryArithmeticOp<mnemonic, traits>,
-      Arguments<(ins fir_ComplexType:$operand)>;
+      Arguments<(ins ComplexType:$operand)>;
 
 def fir_NegcOp : ComplexUnaryArithmeticOp<"negc">;
 
 class ComplexArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
       fir_ArithmeticOp<mnemonic, traits>,
-      Arguments<(ins fir_ComplexType:$lhs, fir_ComplexType:$rhs)>;
+      Arguments<(ins ComplexType:$lhs, ComplexType:$rhs)>;
 
 def fir_AddcOp : ComplexArithmeticOp<"addc", [Commutative]>;
 def fir_SubcOp : ComplexArithmeticOp<"subc">;
 def fir_MulcOp : ComplexArithmeticOp<"mulc", [Commutative]>;
 def fir_DivcOp : ComplexArithmeticOp<"divc">;
 // Pow is a builtin call and not a primitive
 
 def fir_CmpcOp : fir_Op<"cmpc",
     [NoSideEffect, SameTypeOperands, SameOperandsAndResultShape]> {
   let summary = "complex floating-point comparison operator";
 
   let description = [{
     A complex comparison to handle complex types found in FIR.
   }];
 
-  let arguments = (ins fir_ComplexType:$lhs, fir_ComplexType:$rhs);
+  let arguments = (ins ComplexType:$lhs, ComplexType:$rhs);
 
   let results = (outs AnyLogicalLike);
 
   let parser = "return parseCmpcOp(parser, result);";
 
   let printer = "printCmpcOp(p, *this);";
 
   let builders = [

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

 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;
 struct RealTypeStorage;
 struct RecordTypeStorage;
public:
   static constexpr LenType singleton() { return 1; }
   /// CHARACTER has an unknown LEN property.
   static constexpr LenType unknownLen() { return -1; }
 
   /// Access to a CHARACTER's LEN property. Defaults to 1.
   LenType getLen() const;
 };
 
-/// Model of a Fortran COMPLEX intrinsic type, including the KIND type
-/// parameter. COMPLEX is a floating point type with a real and imaginary
-/// member.
-class ComplexType : public mlir::Type::TypeBase<fir::ComplexType, mlir::Type,
-                                                detail::ComplexTypeStorage> {
-public:
-  using Base::Base;
-  static fir::ComplexType get(mlir::MLIRContext *ctxt, KindTy kind);
-
-  /// Get the corresponding fir.real<k> type.
-  mlir::Type getElementType() const;
-
-  KindTy getFKind() const;
-};
-
 /// Model of a Fortran INTEGER intrinsic type, including the KIND type
 /// parameter.
 class IntegerType : public mlir::Type::TypeBase<fir::IntegerType, mlir::Type,
                                                 detail::IntegerTypeStorage> {
 public:
   using Base::Base;
   static fir::IntegerType get(mlir::MLIRContext *ctxt, KindTy kind);
   KindTy getFKind() const;

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 ComplexType : FIR_Type<"Complex", "complex"> {
+  let summary = "Complex type";
+
+  let description = [{
+    Model of a Fortran COMPLEX intrinsic type, including the KIND type
+    parameter. COMPLEX is a floating point type with a real and imaginary
+    member.
+  }];
+
+  let parameters = (ins "KindTy":$kind);
+
+  let printer = [{
+    $_printer << "complex<" << getFKind() << '>';
+  }];
+
+  let genAccessors = 1;
+
+  let extraClassDeclaration = [{
+    using KindTy = unsigned;
+
+    KindTy getFKind() const { return getKind(); }
+
+    mlir::Type getElementType() const;
+  }];
+}
+
 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

if (mlir::succeeded(parser.parseOptionalQuestion())) {
       return {};
     }
   }
   if (parser.parseGreater())
     return {};
   return CharacterType::get(parser.getBuilder().getContext(), kind, len);
 }
 
-// `complex` `<` kind `>`
-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());
if (typeNameLit == "box")
     return generatedTypeParser(dialect->getContext(), parser, typeNameLit);
   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);
+    return generatedTypeParser(dialect->getContext(), parser, typeNameLit);
   if (typeNameLit == "field")
     return parseField(parser);
   if (typeNameLit == "heap")
     return parseHeap(parser, loc);
   if (typeNameLit == "int")
     return parseInteger(parser);
   if (typeNameLit == "len")
     return parseLen(parser);

 protected:
   KindTy kind;
 
 private:
   IntegerTypeStorage() = delete;
   explicit IntegerTypeStorage(KindTy kind) : kind{kind} {}
 };
 
-/// `COMPLEX` storage
-struct ComplexTypeStorage : public mlir::TypeStorage {
-  using KeyTy = KindTy;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getFKind(); }
-
-  static ComplexTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                       KindTy kind) {
-    auto *storage = allocator.allocate<ComplexTypeStorage>();
-    return new (storage) ComplexTypeStorage{kind};
-  }
-
-  KindTy getFKind() const { return kind; }
-
-protected:
-  KindTy kind;
-
-private:
-  ComplexTypeStorage() = delete;
-  explicit ComplexTypeStorage(KindTy kind) : kind{kind} {}
-};
-
 /// `REAL` storage (for reals of unsupported sizes)
 struct RealTypeStorage : public mlir::TypeStorage {
   using KeyTy = KindTy;
 
   static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getFKind(); }
 

 // INTEGER
 
 fir::IntegerType fir::IntegerType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, kind);
 }
 
 KindTy fir::IntegerType::getFKind() const { return getImpl()->getFKind(); }
 
-// COMPLEX
-
-fir::ComplexType fir::ComplexType::get(mlir::MLIRContext *ctxt, KindTy kind) {
-  return Base::get(ctxt, kind);
-}
-
-mlir::Type fir::ComplexType::getElementType() const {
-  return fir::RealType::get(getContext(), getFKind());
-}
-
-KindTy fir::ComplexType::getFKind() const { return getImpl()->getFKind(); }
-
 // REAL
 
 RealType fir::RealType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, kind);
 }
 
 KindTy fir::RealType::getFKind() const { return getImpl()->getFKind(); }
 
if (len != fir::CharacterType::singleton()) {
       if (len == fir::CharacterType::unknownLen())
         os << '?';
       else
         os << len;
     }
     os << '>';
     return;
   }
-  if (auto type = ty.dyn_cast<fir::ComplexType>()) {
-    // Fortran intrinsic type COMPLEX
-    os << "complex<" << type.getFKind() << '>';
-    return;
-  }
   if (auto type = ty.dyn_cast<RecordType>()) {
     // Fortran derived type
     os << "type<" << type.getName();
     if (!recordTypeVisited.count(type.uniqueKey())) {
       recordTypeVisited.insert(type.uniqueKey());
       if (type.getLenParamList().size()) {
         char ch = '(';
         for (auto p : type.getLenParamList()) {
void BoxType::print(::mlir::DialectAsmPrinter &printer) const {
   printer.printType(getEleTy());
   if (auto map = getLayoutMap()) {
     printer << ", ";
     printer.printAttribute(map);
   }
   printer << '>';
 }
 
+//===----------------------------------------------------------------------===//
+// ComplexType
+//===----------------------------------------------------------------------===//
+
+mlir::Type ComplexType::parse(mlir::MLIRContext *context,
+                              mlir::DialectAsmParser &parser) {
+  return parseKindSingleton<fir::ComplexType>(parser);
+}
+
+mlir::Type ComplexType::getElementType() const {
+  return fir::RealType::get(getContext(), getFKind());
+}
+
 } // namespace fir