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

[clementval]

Summary

This is the first patch of a serie to move FIR types to TableGen format as suggested in D96172.
This patch is setting up the files for FIR types and move the ShapeType to TableGen.

As discussed with @schweitz, I'm taking over this task to help the FIR upstreaming effort.

[clementval]

Add summary to type

[mehdi_amini]

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

47

Parser methods are usually chained like this:

int rank;
if ($_parser.parseLess() || $_parser.parseInteger(rank) || $_parser.parseGreater())
    return Type();

[clementval]

Update parser

[clementval]

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

47

Sure it looks cleaner. I just updated the patch before landing it.

flang/include/flang/Optimizer/Dialect/CMakeLists.txt

 # This replicates part of the add_mlir_dialect cmake function from MLIR that
 # cannot be used her because it expects to be run inside MLIR directory which
 # is not the case for FIR.
 set(LLVM_TARGET_DEFINITIONS FIROps.td)
 mlir_tablegen(FIROps.h.inc -gen-op-decls)
 mlir_tablegen(FIROps.cpp.inc -gen-op-defs)
+mlir_tablegen(FIROpsTypes.h.inc --gen-typedef-decls)
+mlir_tablegen(FIROpsTypes.cpp.inc --gen-typedef-defs)
 add_public_tablegen_target(FIROpsIncGen)
 
 add_custom_target(flang-doc)
 set(dialect_doc_filename "FIRLangRef")
 
 set(LLVM_TARGET_DEFINITIONS FIROps.td)
 tablegen(MLIR ${dialect_doc_filename}.md -gen-op-doc "-I${MLIR_MAIN_SRC_DIR}" "-I${MLIR_INCLUDE_DIR}")
 set(GEN_DOC_FILE ${FLANG_BINARY_DIR}/docs/Dialect/${dialect_doc_filename}.md)
 add_custom_command(
         OUTPUT ${GEN_DOC_FILE}
         COMMAND ${CMAKE_COMMAND} -E copy
                 ${CMAKE_CURRENT_BINARY_DIR}/${dialect_doc_filename}.md
                 ${GEN_DOC_FILE}
         DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${dialect_doc_filename}.md)
 add_custom_target(${dialect_doc_filename}DocGen DEPENDS ${GEN_DOC_FILE})
 add_dependencies(flang-doc ${dialect_doc_filename}DocGen)

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

 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def fir_Dialect : Dialect {
   let name = "fir";
   let cppNamespace = "::fir";
 }
 
+include "flang/Optimizer/Dialect/FIRTypes.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 AnyBoxLike : TypeConstraint<Or<[fir_BoxType.predicate,
     fir_BoxCharType.predicate, fir_BoxProcType.predicate]>, "any box">;
 
 def AnyRefOrBox : TypeConstraint<Or<[fir_ReferenceType.predicate,
     fir_HeapType.predicate, fir_PointerType.predicate, fir_BoxType.predicate]>,
     "any reference or box">;
 
-def fir_ShapeType : Type<CPred<"$_self.isa<fir::ShapeType>()">, "shape type">;
 def fir_ShapeShiftType : Type<CPred<"$_self.isa<fir::ShapeShiftType>()">,
     "shape shift type">;
-def AnyShapeLike : TypeConstraint<Or<[fir_ShapeType.predicate,
+def AnyShapeLike : TypeConstraint<Or<[ShapeType.predicate,
     fir_ShapeShiftType.predicate]>, "any legal shape type">;
 def AnyShapeType : Type<AnyShapeLike.predicate, "any legal shape type">;
 def fir_SliceType : Type<CPred<"$_self.isa<fir::SliceType>()">, "slice type">;
 
 def AnyEmboxLike : TypeConstraint<Or<[AnySignlessInteger.predicate,
     Index.predicate, fir_IntegerType.predicate]>,
     "any legal embox argument type">;
 def AnyEmboxArg : Type<AnyEmboxLike.predicate, "embox argument type">;

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

 
 #ifndef OPTIMIZER_DIALECT_FIRTYPE_H
 #define OPTIMIZER_DIALECT_FIRTYPE_H
 
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "llvm/ADT/SmallVector.h"
 
+#define GET_TYPEDEF_CLASSES
+#include "flang/Optimizer/Dialect/FIROpsTypes.h.inc"
+
 namespace llvm {
 class raw_ostream;
 class StringRef;
 template <typename>
 class ArrayRef;
 class hash_code;
 } // namespace llvm
 

 struct IntegerTypeStorage;
 struct LenTypeStorage;
 struct LogicalTypeStorage;
 struct PointerTypeStorage;
 struct RealTypeStorage;
 struct RecordTypeStorage;
 struct ReferenceTypeStorage;
 struct SequenceTypeStorage;
-struct ShapeTypeStorage;
 struct ShapeShiftTypeStorage;
 struct SliceTypeStorage;
 struct TypeDescTypeStorage;
 struct VectorTypeStorage;
 } // namespace detail
 
 // These isa_ routines follow the precedent of llvm::isa_or_null<>
 
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 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.
-class ShapeType : public mlir::Type::TypeBase<ShapeType, mlir::Type,
-                                              detail::ShapeTypeStorage> {
-public:
-  using Base::Base;
-  static ShapeType get(mlir::MLIRContext *ctx, unsigned rank);
-  unsigned getRank() const;
-};
 
 /// Type of a vector of runtime values that define the shape and the origin of a
 /// multidimensional array object. The vector is of pairs, origin offset and
 /// extent, of each array dimension. The rank of a ShapeShiftType must be at
 /// least 1.
 class ShapeShiftType
     : public mlir::Type::TypeBase<ShapeShiftType, mlir::Type,
                                   detail::ShapeShiftTypeStorage> {

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

+//===- FIRTypes.td - FIR types -----------------------------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the FIR dialect types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FIR_DIALECT_FIR_TYPES
+#define FIR_DIALECT_FIR_TYPES
+
+//===----------------------------------------------------------------------===//
+// FIR Types
+//===----------------------------------------------------------------------===//
+
+class FIR_Type<string name, string typeMnemonic> : TypeDef<fir_Dialect, name> {
+  let mnemonic = typeMnemonic;
+}
+
+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.
+  }];
+
+  let parameters = (ins "unsigned":$rank);
+
+  let printer = [{
+    $_printer << "shape<" << getImpl()->rank << ">";
+  }];
+
+  let parser = [{
+    int rank;
+    if ($_parser.parseLess() || $_parser.parseInteger(rank) ||
+        $_parser.parseGreater())
+      return Type();
+    return get(context, rank);
+  }];
+}
+
+#endif // FIR_DIALECT_FIR_TYPES

flang/lib/Optimizer/Dialect/FIRType.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/ErrorHandling.h"
 
+#define GET_TYPEDEF_CLASSES
+#include "flang/Optimizer/Dialect/FIROpsTypes.cpp.inc"
+
 using namespace fir;
 
 namespace {
 
 template <typename TYPE>
 TYPE parseIntSingleton(mlir::DialectAsmParser &parser) {
   int kind = 0;
   if (parser.parseLess() || parser.parseInteger(kind) ||
CharacterType parseCharacter(mlir::DialectAsmParser &parser) {
   return CharacterType::get(parser.getBuilder().getContext(), kind, len);
 }
 
 // `complex` `<` kind `>`
 fir::ComplexType parseComplex(mlir::DialectAsmParser &parser) {
   return parseKindSingleton<fir::ComplexType>(parser);
 }
 
-// `shape` `<` rank `>`
-ShapeType parseShape(mlir::DialectAsmParser &parser) {
-  return parseRankSingleton<ShapeType>(parser);
-}
-
 // `shapeshift` `<` rank `>`
 ShapeShiftType parseShapeShift(mlir::DialectAsmParser &parser) {
   return parseRankSingleton<ShapeShiftType>(parser);
 }
 
 // `slice` `<` rank `>`
 SliceType parseSlice(mlir::DialectAsmParser &parser) {
   return parseRankSingleton<SliceType>(parser);
inline bool singleIndirectionLevel(mlir::Type ty) {
   return !fir::isa_ref_type(ty);
 }
 #endif
 
 } // namespace
 
 // Implementation of the thin interface from dialect to type parser
 
-mlir::Type fir::parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser) {
+mlir::Type fir::parseFirType(FIROpsDialect *dialect,
+                             mlir::DialectAsmParser &parser) {
   llvm::StringRef typeNameLit;
   if (mlir::failed(parser.parseKeyword(&typeNameLit)))
     return {};
 
   auto loc = parser.getEncodedSourceLoc(parser.getNameLoc());
   if (typeNameLit == "array")
     return parseSequence(parser, loc);
   if (typeNameLit == "box")
if (typeNameLit == "logical")
     return parseLogical(parser);
   if (typeNameLit == "ptr")
     return parsePointer(parser, loc);
   if (typeNameLit == "real")
     return parseReal(parser);
   if (typeNameLit == "ref")
     return parseReference(parser, loc);
   if (typeNameLit == "shape")
-    return parseShape(parser);
+    // TODO move to generatedTypeParser when all types have been moved
+    return ShapeType::parse(dialect->getContext(), parser);
   if (typeNameLit == "shapeshift")
     return parseShapeShift(parser);
   if (typeNameLit == "slice")
     return parseSlice(parser);
   if (typeNameLit == "tdesc")
     return parseTypeDesc(parser, loc);
   if (typeNameLit == "type")
     return parseDerived(parser, loc);
protected:
   CharacterType::LenType len;
 
 private:
   CharacterTypeStorage() = delete;
   explicit CharacterTypeStorage(KindTy kind, CharacterType::LenType len)
       : kind{kind}, len{len} {}
 };
 
-struct ShapeTypeStorage : public mlir::TypeStorage {
-  using KeyTy = unsigned;
-
-  static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
-
-  bool operator==(const KeyTy &key) const { return key == getRank(); }
-
-  static ShapeTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
-                                     unsigned rank) {
-    auto *storage = allocator.allocate<ShapeTypeStorage>();
-    return new (storage) ShapeTypeStorage{rank};
-  }
-
-  unsigned getRank() const { return rank; }
-
-protected:
-  unsigned rank;
-
-private:
-  ShapeTypeStorage() = delete;
-  explicit ShapeTypeStorage(unsigned rank) : rank{rank} {}
-};
-
 struct ShapeShiftTypeStorage : public mlir::TypeStorage {
   using KeyTy = unsigned;
 
   static unsigned hashKey(const KeyTy &key) { return llvm::hash_combine(key); }
 
   bool operator==(const KeyTy &key) const { return key == getRank(); }
 
   static ShapeShiftTypeStorage *construct(mlir::TypeStorageAllocator &allocator,

 // compute the hash of a Shape
 llvm::hash_code fir::hash_value(const SequenceType::Shape &sh) {
   if (sh.size()) {
     return llvm::hash_combine_range(sh.begin(), sh.end());
   }
   return llvm::hash_combine(0);
 }
 
-// Shape
-
-ShapeType fir::ShapeType::get(mlir::MLIRContext *ctxt, unsigned rank) {
-  return Base::get(ctxt, rank);
-}
-
-unsigned fir::ShapeType::getRank() const { return getImpl()->getRank(); }
-
 // Shapeshift
 
 ShapeShiftType fir::ShapeShiftType::get(mlir::MLIRContext *ctxt,
                                         unsigned rank) {
   return Base::get(ctxt, rank);
 }
 
 unsigned fir::ShapeShiftType::getRank() const { return getImpl()->getRank(); }
if (!recordTypeVisited.count(type.uniqueKey())) {
         os << '}';
       }
       recordTypeVisited.erase(type.uniqueKey());
     }
     os << '>';
     return;
   }
   if (auto type = ty.dyn_cast<ShapeType>()) {
-    os << "shape<" << type.getRank() << '>';
+    // TODO when all type are moved to TableGen can be replaced by
+    // generatedTypePrinter
+    type.print(p);
     return;
   }
   if (auto type = ty.dyn_cast<ShapeShiftType>()) {
     os << "shapeshift<" << type.getRank() << '>';
     return;
   }
   if (auto type = ty.dyn_cast<SliceType>()) {
     os << "slice<" << type.getRank() << '>';