[flang][NFC] Rename complex type.

[schweitz]

Summary

This change renames the CplxType class to ComplexType.

[mehdi_amini]

LG, thanks!

[schweitz]

Commit message fumbled. Submitted as 59186902555546b9d864065d03eb1c79cb041409

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::CplxType>()">,
+def fir_ComplexType : Type<CPred<"$_self.isa<fir::ComplexType>()">,
     "FIR complex type">;
 def fir_IntegerType : Type<CPred<"$_self.isa<fir::IntType>()">,
     "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">;
 
let printer = [{
     auto f2 = (*this)->getAttr(imagAttrName()).cast<mlir::FloatAttr>();
     auto i2 = f2.getValue().bitcastToAPInt();
     p.getStream().write_hex(i2.getZExtValue());
     p << ") : ";
     p.printType(getType());
   }];
 
   let verifier = [{
-    if (!getType().isa<fir::CplxType>())
+    if (!getType().isa<fir::ComplexType>())
       return emitOpError("must be a !fir.complex type");
     return mlir::success();
   }];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef realAttrName() { return "real"; }
     static constexpr llvm::StringRef imagAttrName() { return "imaginary"; }
 
let extraClassDeclaration = [{
     static bool isIntegerCompatible(mlir::Type ty);
     static bool isFloatCompatible(mlir::Type ty);
     static bool isPointerCompatible(mlir::Type ty);
   }];
 }
 
 def FortranTypeAttr : Attr<And<[CPred<"$_self.isa<TypeAttr>()">,
     Or<[CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::CharacterType>()">,
-        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::CplxType>()">,
+        CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::ComplexType>()">,
         CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::IntType>()">,
         CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::LogicalType>()">,
         CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::RealType>()">,
         CPred<"$_self.cast<TypeAttr>().getValue().isa<fir::RecordType>()">]>]>,
     "Fortran surface type"> {
   let storageType = [{ TypeAttr }];
   let returnType = "Type";
   let convertFromStorage = "$_self.getValue().cast<Type>()";

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

 
 using KindTy = int;
 
 namespace detail {
 struct BoxTypeStorage;
 struct BoxCharTypeStorage;
 struct BoxProcTypeStorage;
 struct CharacterTypeStorage;
-struct CplxTypeStorage;
+struct ComplexTypeStorage;
 struct DimsTypeStorage;
 struct FieldTypeStorage;
 struct HeapTypeStorage;
 struct IntTypeStorage;
 struct LenTypeStorage;
 struct LogicalTypeStorage;
 struct PointerTypeStorage;
 struct RealTypeStorage;
public:
   using Base::Base;
   static CharacterType get(mlir::MLIRContext *ctxt, KindTy kind);
   KindTy getFKind() 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 CplxType : public mlir::Type::TypeBase<CplxType, mlir::Type,
-                                             detail::CplxTypeStorage> {
+class ComplexType : public mlir::Type::TypeBase<fir::ComplexType, mlir::Type,
+                                                detail::ComplexTypeStorage> {
 public:
   using Base::Base;
-  static CplxType get(mlir::MLIRContext *ctxt, KindTy kind);
+  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 IntType
     : public mlir::Type::TypeBase<IntType, mlir::Type, detail::IntTypeStorage> {
 public:
   using Base::Base;
   static IntType get(mlir::MLIRContext *ctxt, KindTy kind);
   KindTy getFKind() const;
 };
 
 /// Model of a Fortran LOGICAL intrinsic type, including the KIND type
 /// parameter.
-class LogicalType
-    : public mlir::Type::TypeBase<LogicalType, mlir::Type,
+class LogicalType : public mlir::Type::TypeBase<LogicalType, mlir::Type,
                                                 detail::LogicalTypeStorage> {
 public:
   using Base::Base;
   static LogicalType get(mlir::MLIRContext *ctxt, KindTy kind);
   KindTy getFKind() const;
 };
 
 /// Model of a Fortran REAL (and DOUBLE PRECISION) intrinsic type, including the
 /// KIND type parameter.

 /// Is `t` an integral type?
 inline bool isa_integer(mlir::Type t) {
   return t.isa<mlir::IndexType>() || t.isa<mlir::IntegerType>() ||
          t.isa<fir::IntType>();
 }
 
 /// Is `t` a FIR or MLIR Complex type?
 inline bool isa_complex(mlir::Type t) {
-  return t.isa<fir::CplxType>() || t.isa<mlir::ComplexType>();
+  return t.isa<fir::ComplexType>() || t.isa<mlir::ComplexType>();
 }
 
 } // namespace fir
 
 #endif // OPTIMIZER_DIALECT_FIRTYPE_H

flang/lib/Lower/ComplexExpr.cpp

 
 //===----------------------------------------------------------------------===//
 // ComplexExprHelper implementation
 //===----------------------------------------------------------------------===//
 
 mlir::Type
 Fortran::lower::ComplexExprHelper::getComplexPartType(mlir::Type complexType) {
   return Fortran::lower::convertReal(
-      builder.getContext(), complexType.cast<fir::CplxType>().getFKind());
+      builder.getContext(), complexType.cast<fir::ComplexType>().getFKind());
 }
 
 mlir::Type
 Fortran::lower::ComplexExprHelper::getComplexPartType(mlir::Value cplx) {
   return getComplexPartType(cplx.getType());
 }
 
 mlir::Value Fortran::lower::ComplexExprHelper::createComplex(fir::KindTy kind,
                                                              mlir::Value real,
                                                              mlir::Value imag) {
-  auto complexTy = fir::CplxType::get(builder.getContext(), kind);
+  auto complexTy = fir::ComplexType::get(builder.getContext(), kind);
   mlir::Value und = builder.create<fir::UndefOp>(loc, complexTy);
   return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
 }
 
 mlir::Value Fortran::lower::ComplexExprHelper::createComplex(mlir::Type cplxTy,
                                                              mlir::Value real,
                                                              mlir::Value imag) {
   mlir::Value und = builder.create<fir::UndefOp>(loc, cplxTy);

flang/lib/Lower/ConvertType.cpp

 }
 
 template <>
 mlir::Type
 genFIRType<Fortran::common::TypeCategory::Complex>(mlir::MLIRContext *context,
                                                    int KIND) {
   if (Fortran::evaluate::IsValidKindOfIntrinsicType(
           Fortran::common::TypeCategory::Complex, KIND))
-    return fir::CplxType::get(context, KIND);
+    return fir::ComplexType::get(context, KIND);
   return {};
 }
 
 namespace {
 
 /// Discover the type of an Fortran::evaluate::Expr<T> and convert it to an
 /// mlir::Type. The type returned may be an MLIR standard or FIR type.
 class TypeBuilder {

flang/lib/Lower/FIRBuilder.cpp

mlir::Value Fortran::lower::FirOpBuilder::convertWithSemantics(
   // FIXME: add a fir::is_integer() test
   ComplexExprHelper helper{*this, loc};
   if ((fir::isa_real(fromTy) || fromTy.isSignlessInteger()) &&
       fir::isa_complex(toTy)) {
     // imaginary part is zero
     auto eleTy = helper.getComplexPartType(toTy);
     auto cast = createConvert(loc, eleTy, val);
     llvm::APFloat zero{
-        kindMap.getFloatSemantics(toTy.cast<fir::CplxType>().getFKind()), 0};
+        kindMap.getFloatSemantics(toTy.cast<fir::ComplexType>().getFKind()), 0};
     auto imag = createRealConstant(loc, eleTy, zero);
     return helper.createComplex(toTy, cast, imag);
   }
   // FIXME: add a fir::is_integer() test
   if (fir::isa_complex(fromTy) &&
       (toTy.isSignlessInteger() || fir::isa_real(toTy))) {
     // drop the imaginary part
     auto rp = helper.extractComplexPart(val, /*isImagPart=*/false);

flang/lib/Lower/IO.cpp

static mlir::FuncOp getOutputFunc(mlir::Location loc,
   if (auto ty = type.dyn_cast<mlir::IntegerType>())
     return ty.getWidth() == 1
                ? getIORuntimeFunc<mkIOKey(OutputLogical)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(OutputInteger64)>(loc, builder);
   if (auto ty = type.dyn_cast<mlir::FloatType>())
     return ty.getWidth() <= 32
                ? getIORuntimeFunc<mkIOKey(OutputReal32)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(OutputReal64)>(loc, builder);
-  if (auto ty = type.dyn_cast<fir::CplxType>())
+  if (auto ty = type.dyn_cast<fir::ComplexType>())
     return ty.getFKind() <= 4
                ? getIORuntimeFunc<mkIOKey(OutputComplex32)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(OutputComplex64)>(loc, builder);
   if (type.isa<fir::LogicalType>())
     return getIORuntimeFunc<mkIOKey(OutputLogical)>(loc, builder);
   if (type.isa<fir::BoxType>())
     return getIORuntimeFunc<mkIOKey(OutputDescriptor)>(loc, builder);
   if (Fortran::lower::CharacterExprHelper::isCharacter(type))
static mlir::FuncOp getInputFunc(mlir::Location loc,
   if (auto ty = type.dyn_cast<mlir::IntegerType>())
     return ty.getWidth() == 1
                ? getIORuntimeFunc<mkIOKey(InputLogical)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(InputInteger)>(loc, builder);
   if (auto ty = type.dyn_cast<mlir::FloatType>())
     return ty.getWidth() <= 32
                ? getIORuntimeFunc<mkIOKey(InputReal32)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(InputReal64)>(loc, builder);
-  if (auto ty = type.dyn_cast<fir::CplxType>())
+  if (auto ty = type.dyn_cast<fir::ComplexType>())
     return ty.getFKind() <= 4
                ? getIORuntimeFunc<mkIOKey(InputReal32)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(InputReal64)>(loc, builder);
   if (type.isa<fir::LogicalType>())
     return getIORuntimeFunc<mkIOKey(InputLogical)>(loc, builder);
   if (type.isa<fir::BoxType>())
     return getIORuntimeFunc<mkIOKey(InputDescriptor)>(loc, builder);
   if (Fortran::lower::CharacterExprHelper::isCharacter(type))
makeNextConditionalOn(builder, loc, insertPt, checkResult, ok,
                           inIterWhileLoop);
     auto itemAddr =
         converter.genExprAddr(Fortran::semantics::GetExpr(pVar), loc);
     auto itemType = itemAddr.getType().cast<fir::ReferenceType>().getEleTy();
     auto inputFunc = getInputFunc(loc, builder, itemType);
     auto argType = inputFunc.getType().getInput(1);
     auto originalItemAddr = itemAddr;
     mlir::Type complexPartType;
-    if (itemType.isa<fir::CplxType>())
+    if (itemType.isa<fir::ComplexType>())
       complexPartType = builder.getRefType(
           Fortran::lower::ComplexExprHelper{builder, loc}.getComplexPartType(
               itemType));
     auto complexPartAddr = [&](int index) {
       return builder.create<fir::CoordinateOp>(
           loc, complexPartType, originalItemAddr,
           llvm::SmallVector<mlir::Value, 1>{builder.create<mlir::ConstantOp>(
               loc, builder.getI32IntegerAttr(index))});

flang/lib/Lower/IntrinsicCall.cpp

private:
   static unsigned getFloatingPointWidth(mlir::Type t) {
     if (auto f{t.dyn_cast<mlir::FloatType>()})
       return f.getWidth();
     // FIXME: Get width another way for fir.real/complex
     // - use fir/KindMapping.h and llvm::Type
     // - or use evaluate/type.h
     if (auto r{t.dyn_cast<fir::RealType>()})
       return r.getFKind() * 4;
-    if (auto cplx{t.dyn_cast<fir::CplxType>()})
+    if (auto cplx{t.dyn_cast<fir::ComplexType>()})
       return cplx.getFKind() * 4;
     llvm_unreachable("not a floating-point type");
   }
 
   static Conversion conversionBetweenTypes(mlir::Type from, mlir::Type to) {
     if (from == to) {
       return Conversion::None;
     }
     if (auto fromIntTy{from.dyn_cast<mlir::IntegerType>()}) {
       if (auto toIntTy{to.dyn_cast<mlir::IntegerType>()}) {
         return fromIntTy.getWidth() > toIntTy.getWidth() ? Conversion::Narrow
                                                          : Conversion::Extend;
       }
     }
     if (fir::isa_real(from) && fir::isa_real(to)) {
       return getFloatingPointWidth(from) > getFloatingPointWidth(to)
                  ? Conversion::Narrow
                  : Conversion::Extend;
     }
-    if (auto fromCplxTy{from.dyn_cast<fir::CplxType>()}) {
-      if (auto toCplxTy{to.dyn_cast<fir::CplxType>()}) {
+    if (auto fromCplxTy{from.dyn_cast<fir::ComplexType>()}) {
+      if (auto toCplxTy{to.dyn_cast<fir::ComplexType>()}) {
         return getFloatingPointWidth(fromCplxTy) >
                        getFloatingPointWidth(toCplxTy)
                    ? Conversion::Narrow
                    : Conversion::Extend;
       }
     }
     // Notes:
     // - No conversion between character types, specialization of runtime

flang/lib/Lower/Mangler.cpp

 /// Note: mlir has Type::dump(ostream) methods but it may add "!" that is not
 /// suitable for function names.
 static std::string typeToString(mlir::Type t) {
   if (auto refT{t.dyn_cast<fir::ReferenceType>()})
     return "ref_" + typeToString(refT.getEleTy());
   if (auto i{t.dyn_cast<mlir::IntegerType>()}) {
     return "i" + std::to_string(i.getWidth());
   }
-  if (auto cplx{t.dyn_cast<fir::CplxType>()}) {
+  if (auto cplx{t.dyn_cast<fir::ComplexType>()}) {
     return "z" + std::to_string(cplx.getFKind());
   }
   if (auto real{t.dyn_cast<fir::RealType>()}) {
     return "r" + std::to_string(real.getFKind());
   }
   if (auto f{t.dyn_cast<mlir::FloatType>()}) {
     return "f" + std::to_string(f.getWidth());
   }

flang/lib/Optimizer/Dialect/FIRDialect.cpp

 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 
 using namespace fir;
 
 fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
     : mlir::Dialect("fir", ctx, mlir::TypeID::get<FIROpsDialect>()) {
-  addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, CplxType, DimsType,
-           FieldType, HeapType, IntType, LenType, LogicalType, PointerType,
-           RealType, RecordType, ReferenceType, SequenceType, TypeDescType>();
+  addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, fir::ComplexType,
+           DimsType, FieldType, HeapType, IntType, LenType, LogicalType,
+           PointerType, RealType, RecordType, ReferenceType, SequenceType,
+           TypeDescType>();
   addAttributes<ClosedIntervalAttr, ExactTypeAttr, LowerBoundAttr,
                 PointIntervalAttr, RealAttr, SubclassAttr, UpperBoundAttr>();
   addOperations<
 #define GET_OP_LIST
 #include "flang/Optimizer/Dialect/FIROps.cpp.inc"
       >();
 }
 

flang/lib/Optimizer/Dialect/FIRType.cpp

 }
 
 // `char` `<` kind `>`
 CharacterType parseCharacter(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<CharacterType>(parser);
 }
 
 // `complex` `<` kind `>`
-CplxType parseComplex(mlir::DialectAsmParser &parser) {
-  return parseKindSingleton<CplxType>(parser);
+fir::ComplexType parseComplex(mlir::DialectAsmParser &parser) {
+  return parseKindSingleton<fir::ComplexType>(parser);
 }
 
 // `dims` `<` rank `>`
 DimsType parseDims(mlir::DialectAsmParser &parser) {
   return parseRankSingleton<DimsType>(parser);
 }
 
 // `field`
protected:
   KindTy kind;
 
 private:
   IntTypeStorage() = delete;
   explicit IntTypeStorage(KindTy kind) : kind{kind} {}
 };
 
 /// `COMPLEX` storage
-struct CplxTypeStorage : public mlir::TypeStorage {
+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 CplxTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
+  static ComplexTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
                                        KindTy kind) {
-    auto *storage = allocator.allocate<CplxTypeStorage>();
-    return new (storage) CplxTypeStorage{kind};
+    auto *storage = allocator.allocate<ComplexTypeStorage>();
+    return new (storage) ComplexTypeStorage{kind};
   }
 
   KindTy getFKind() const { return kind; }
 
 protected:
   KindTy kind;
 
 private:
-  CplxTypeStorage() = delete;
-  explicit CplxTypeStorage(KindTy kind) : kind{kind} {}
+  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 isa_std_type(mlir::Type t) {
   return t.getDialect().getNamespace().empty();
 }
 
 bool isa_fir_or_std_type(mlir::Type t) {
   if (auto funcType = t.dyn_cast<mlir::FunctionType>())
-    return llvm::all_of(funcType.getInputs(), isa_fir_or_std_type) &&  
+    return llvm::all_of(funcType.getInputs(), isa_fir_or_std_type) &&
            llvm::all_of(funcType.getResults(), isa_fir_or_std_type);
   return isa_fir_type(t) || isa_std_type(t);
 }
 
 bool isa_ref_type(mlir::Type t) {
   return t.isa<ReferenceType>() || t.isa<PointerType>() || t.isa<HeapType>();
 }
 
 bool isa_box_type(mlir::Type t) {

 IntType fir::IntType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, kind);
 }
 
 int fir::IntType::getFKind() const { return getImpl()->getFKind(); }
 
 // COMPLEX
 
-CplxType fir::CplxType::get(mlir::MLIRContext *ctxt, KindTy kind) {
+fir::ComplexType fir::ComplexType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, kind);
 }
 
-mlir::Type fir::CplxType::getElementType() const {
+mlir::Type fir::ComplexType::getElementType() const {
   return fir::RealType::get(getContext(), getFKind());
 }
 
-KindTy fir::CplxType::getFKind() const { return getImpl()->getFKind(); }
+KindTy fir::ComplexType::getFKind() const { return getImpl()->getFKind(); }
 
 // REAL
 
 RealType fir::RealType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, kind);
 }
 
 int fir::RealType::getFKind() const { return getImpl()->getFKind(); }
if (auto type = ty.dyn_cast<BoxProcType>()) {
     p.printType(type.getEleTy());
     os << '>';
     return;
   }
   if (auto type = ty.dyn_cast<CharacterType>()) {
     os << "char<" << type.getFKind() << '>';
     return;
   }
-  if (auto type = ty.dyn_cast<CplxType>()) {
+  if (auto type = ty.dyn_cast<fir::ComplexType>()) {
     os << "complex<" << type.getFKind() << '>';
     return;
   }
   if (auto type = ty.dyn_cast<RecordType>()) {
     os << "type<" << type.getName();
     if (!recordTypeVisited.count(type.uniqueKey())) {
       recordTypeVisited.insert(type.uniqueKey());
       if (type.getLenParamList().size()) {