/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* TypeDef Definitions                                                        *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef GET_TYPEDEF_LIST
#undef GET_TYPEDEF_LIST

::fir::BoxCharType,
::fir::BoxProcType,
::fir::BoxType,
::fir::CharacterType,
::fir::ComplexType,
::fir::FieldType,
::fir::HeapType,
::fir::IntegerType,
::fir::LenType,
::fir::LogicalType,
::fir::PointerType,
::fir::RealType,
::fir::RecordType,
::fir::ReferenceType,
::fir::SequenceType,
::fir::ShapeShiftType,
::fir::ShapeType,
::fir::ShiftType,
::fir::SliceType,
::fir::TypeDescType,
::fir::VectorType,
::fir::VoidType

#endif  // GET_TYPEDEF_LIST

#ifdef GET_TYPEDEF_CLASSES
#undef GET_TYPEDEF_CLASSES


static ::mlir::OptionalParseResult generatedTypeParser(::mlir::MLIRContext *context,
                                      ::mlir::DialectAsmParser &parser,
                                      ::llvm::StringRef mnemonic,
                                      ::mlir::Type &value) {
  if (mnemonic == ::fir::BoxCharType::getMnemonic()) { 
    value = ::fir::BoxCharType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::BoxProcType::getMnemonic()) { 
    value = ::fir::BoxProcType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::BoxType::getMnemonic()) { 
    value = ::fir::BoxType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::CharacterType::getMnemonic()) { 
    value = ::fir::CharacterType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::ComplexType::getMnemonic()) { 
    value = ::fir::ComplexType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::FieldType::getMnemonic()) { 
    value = ::fir::FieldType::get(context);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::HeapType::getMnemonic()) { 
    value = ::fir::HeapType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::IntegerType::getMnemonic()) { 
    value = ::fir::IntegerType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::LenType::getMnemonic()) { 
    value = ::fir::LenType::get(context);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::LogicalType::getMnemonic()) { 
    value = ::fir::LogicalType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::PointerType::getMnemonic()) { 
    value = ::fir::PointerType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::RealType::getMnemonic()) { 
    value = ::fir::RealType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::RecordType::getMnemonic()) { 
    value = ::fir::RecordType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::ReferenceType::getMnemonic()) { 
    value = ::fir::ReferenceType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::SequenceType::getMnemonic()) { 
    value = ::fir::SequenceType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::ShapeShiftType::getMnemonic()) { 
    value = ::fir::ShapeShiftType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::ShapeType::getMnemonic()) { 
    value = ::fir::ShapeType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::ShiftType::getMnemonic()) { 
    value = ::fir::ShiftType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::SliceType::getMnemonic()) { 
    value = ::fir::SliceType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::TypeDescType::getMnemonic()) { 
    value = ::fir::TypeDescType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::VectorType::getMnemonic()) { 
    value = ::fir::VectorType::parse(context, parser);
    return ::mlir::success(!!value);
  }
  if (mnemonic == ::fir::VoidType::getMnemonic()) { 
    value = ::fir::VoidType::get(context);
    return ::mlir::success(!!value);
  }
  return {};
}


static ::mlir::LogicalResult generatedTypePrinter(
                         ::mlir::Type def, ::mlir::DialectAsmPrinter &printer) {
  return ::llvm::TypeSwitch<::mlir::Type, ::mlir::LogicalResult>(def)
    .Case<::fir::BoxCharType>([&](::fir::BoxCharType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::BoxProcType>([&](::fir::BoxProcType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::BoxType>([&](::fir::BoxType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::CharacterType>([&](::fir::CharacterType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::ComplexType>([&](::fir::ComplexType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::FieldType>([&](::fir::FieldType t) {
      printer << ::fir::FieldType::getMnemonic();
      return ::mlir::success();
    })
    .Case<::fir::HeapType>([&](::fir::HeapType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::IntegerType>([&](::fir::IntegerType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::LenType>([&](::fir::LenType t) {
      printer << ::fir::LenType::getMnemonic();
      return ::mlir::success();
    })
    .Case<::fir::LogicalType>([&](::fir::LogicalType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::PointerType>([&](::fir::PointerType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::RealType>([&](::fir::RealType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::RecordType>([&](::fir::RecordType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::ReferenceType>([&](::fir::ReferenceType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::SequenceType>([&](::fir::SequenceType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::ShapeShiftType>([&](::fir::ShapeShiftType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::ShapeType>([&](::fir::ShapeType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::ShiftType>([&](::fir::ShiftType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::SliceType>([&](::fir::SliceType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::TypeDescType>([&](::fir::TypeDescType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::VectorType>([&](::fir::VectorType t) {
      t.print(printer);
      return ::mlir::success();
    })
    .Case<::fir::VoidType>([&](::fir::VoidType t) {
      printer << ::fir::VoidType::getMnemonic();
      return ::mlir::success();
    })
    .Default([](::mlir::Type) { return ::mlir::failure(); });
}

namespace fir {

namespace detail {
  struct BoxCharTypeStorage : public ::mlir::TypeStorage {
    BoxCharTypeStorage (KindTy kind)
      : kind(kind) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<KindTy>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(kind == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static BoxCharTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto kind = std::get<0>(tblgenKey);

      return new (allocator.allocate<BoxCharTypeStorage>())
          BoxCharTypeStorage(kind);
    }
      KindTy kind;
  };
} // namespace detail
BoxCharType BoxCharType::get(::mlir::MLIRContext *context, KindTy kind) {
  return Base::get(context, kind);
}
KindTy BoxCharType::getKind() const { return getImpl()->kind; }
} // namespace fir
namespace fir {

namespace detail {
  struct BoxProcTypeStorage : public ::mlir::TypeStorage {
    BoxProcTypeStorage (mlir::Type eleTy)
      : eleTy(eleTy) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<mlir::Type>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(eleTy == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static BoxProcTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto eleTy = std::get<0>(tblgenKey);

      return new (allocator.allocate<BoxProcTypeStorage>())
          BoxProcTypeStorage(eleTy);
    }
      mlir::Type eleTy;
  };
} // namespace detail
BoxProcType BoxProcType::get(::mlir::MLIRContext *context, mlir::Type eleTy) {
  return Base::get(context, eleTy);
}
BoxProcType BoxProcType::getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, mlir::Type eleTy) {
  return Base::getChecked(emitError, context, eleTy);
}
mlir::Type BoxProcType::getEleTy() const { return getImpl()->eleTy; }
} // namespace fir
namespace fir {

namespace detail {
  struct BoxTypeStorage : public ::mlir::TypeStorage {
    BoxTypeStorage (mlir::Type eleTy, mlir::AffineMapAttr map)
      : eleTy(eleTy), map(map) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<mlir::Type, mlir::AffineMapAttr>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(eleTy == std::get<0>(tblgenKey)))
      return false;
    if (!(map == std::get<1>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey), std::get<1>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static BoxTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto eleTy = std::get<0>(tblgenKey);
      auto map = std::get<1>(tblgenKey);

      return new (allocator.allocate<BoxTypeStorage>())
          BoxTypeStorage(eleTy, map);
    }
      mlir::Type eleTy;
      mlir::AffineMapAttr map;
  };
} // namespace detail
BoxType BoxType::get(mlir::Type eleTy, mlir::AffineMapAttr map) {
  
      return Base::get(eleTy.getContext(), eleTy, map);
    ;
}
BoxType BoxType::getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitErrorFn, mlir::Type eleTy, mlir::AffineMapAttr map) {
  
      return Base::get(eleTy.getContext(), eleTy, map);
    ;
}
mlir::Type BoxType::getEleTy() const { return getImpl()->eleTy; }
mlir::AffineMapAttr BoxType::getMap() const { return getImpl()->map; }
} // namespace fir
namespace fir {

namespace detail {
  struct CharacterTypeStorage : public ::mlir::TypeStorage {
    CharacterTypeStorage (KindTy FKind, CharacterType::LenType len)
      : FKind(FKind), len(len) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<KindTy, CharacterType::LenType>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(FKind == std::get<0>(tblgenKey)))
      return false;
    if (!(len == std::get<1>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey), std::get<1>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static CharacterTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto FKind = std::get<0>(tblgenKey);
      auto len = std::get<1>(tblgenKey);

      return new (allocator.allocate<CharacterTypeStorage>())
          CharacterTypeStorage(FKind, len);
    }
      KindTy FKind;
      CharacterType::LenType len;
  };
} // namespace detail
CharacterType CharacterType::get(::mlir::MLIRContext *context, KindTy FKind, CharacterType::LenType len) {
  return Base::get(context, FKind, len);
}
KindTy CharacterType::getFKind() const { return getImpl()->FKind; }
CharacterType::LenType CharacterType::getLen() const { return getImpl()->len; }
} // namespace fir
namespace fir {

namespace detail {
  struct ComplexTypeStorage : public ::mlir::TypeStorage {
    ComplexTypeStorage (KindTy fKind)
      : fKind(fKind) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<KindTy>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(fKind == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static ComplexTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto fKind = std::get<0>(tblgenKey);

      return new (allocator.allocate<ComplexTypeStorage>())
          ComplexTypeStorage(fKind);
    }
      KindTy fKind;
  };
} // namespace detail
ComplexType ComplexType::get(::mlir::MLIRContext *context, KindTy fKind) {
  return Base::get(context, fKind);
}
KindTy ComplexType::getFKind() const { return getImpl()->fKind; }
} // namespace fir
namespace fir {
} // namespace fir
namespace fir {

namespace detail {
  struct HeapTypeStorage : public ::mlir::TypeStorage {
    HeapTypeStorage (mlir::Type eleTy)
      : eleTy(eleTy) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<mlir::Type>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(eleTy == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static HeapTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto eleTy = std::get<0>(tblgenKey);

      return new (allocator.allocate<HeapTypeStorage>())
          HeapTypeStorage(eleTy);
    }
      mlir::Type eleTy;
  };
} // namespace detail
HeapType HeapType::get(mlir::Type elementType) {
  
      assert(singleIndirectionLevel(elementType) && "invalid element type");
      return Base::get(elementType.getContext(), elementType);
    ;
}
HeapType HeapType::getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitErrorFn, mlir::Type elementType) {
  
      assert(singleIndirectionLevel(elementType) && "invalid element type");
      return Base::get(elementType.getContext(), elementType);
    ;
}
mlir::Type HeapType::getEleTy() const { return getImpl()->eleTy; }
} // namespace fir
namespace fir {

namespace detail {
  struct IntegerTypeStorage : public ::mlir::TypeStorage {
    IntegerTypeStorage (KindTy fKind)
      : fKind(fKind) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<KindTy>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(fKind == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static IntegerTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto fKind = std::get<0>(tblgenKey);

      return new (allocator.allocate<IntegerTypeStorage>())
          IntegerTypeStorage(fKind);
    }
      KindTy fKind;
  };
} // namespace detail
IntegerType IntegerType::get(::mlir::MLIRContext *context, KindTy fKind) {
  return Base::get(context, fKind);
}
KindTy IntegerType::getFKind() const { return getImpl()->fKind; }
} // namespace fir
namespace fir {
} // namespace fir
namespace fir {

namespace detail {
  struct LogicalTypeStorage : public ::mlir::TypeStorage {
    LogicalTypeStorage (KindTy fKind)
      : fKind(fKind) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<KindTy>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(fKind == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static LogicalTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto fKind = std::get<0>(tblgenKey);

      return new (allocator.allocate<LogicalTypeStorage>())
          LogicalTypeStorage(fKind);
    }
      KindTy fKind;
  };
} // namespace detail
LogicalType LogicalType::get(::mlir::MLIRContext *context, KindTy fKind) {
  return Base::get(context, fKind);
}
KindTy LogicalType::getFKind() const { return getImpl()->fKind; }
} // namespace fir
namespace fir {

namespace detail {
  struct PointerTypeStorage : public ::mlir::TypeStorage {
    PointerTypeStorage (mlir::Type eleTy)
      : eleTy(eleTy) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<mlir::Type>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(eleTy == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static PointerTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto eleTy = std::get<0>(tblgenKey);

      return new (allocator.allocate<PointerTypeStorage>())
          PointerTypeStorage(eleTy);
    }
      mlir::Type eleTy;
  };
} // namespace detail
PointerType PointerType::get(mlir::Type elementType) {
  
      assert(singleIndirectionLevel(elementType) && "invalid element type");
      return Base::get(elementType.getContext(), elementType);
    ;
}
PointerType PointerType::getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitErrorFn, mlir::Type elementType) {
  
      assert(singleIndirectionLevel(elementType) && "invalid element type");
      return Base::get(elementType.getContext(), elementType);
    ;
}
mlir::Type PointerType::getEleTy() const { return getImpl()->eleTy; }
} // namespace fir
namespace fir {

namespace detail {
  struct RealTypeStorage : public ::mlir::TypeStorage {
    RealTypeStorage (KindTy fKind)
      : fKind(fKind) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<KindTy>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(fKind == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static RealTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto fKind = std::get<0>(tblgenKey);

      return new (allocator.allocate<RealTypeStorage>())
          RealTypeStorage(fKind);
    }
      KindTy fKind;
  };
} // namespace detail
RealType RealType::get(::mlir::MLIRContext *context, KindTy fKind) {
  return Base::get(context, fKind);
}
RealType RealType::getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, KindTy fKind) {
  return Base::getChecked(emitError, context, fKind);
}
KindTy RealType::getFKind() const { return getImpl()->fKind; }
} // namespace fir
namespace fir {
RecordType RecordType::get(::mlir::MLIRContext *context, ::llvm::StringRef name) {
  return Base::get(context, name);
}
RecordType RecordType::getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::llvm::StringRef name) {
  return Base::getChecked(emitError, context, name);
}
} // namespace fir
namespace fir {

namespace detail {
  struct ReferenceTypeStorage : public ::mlir::TypeStorage {
    ReferenceTypeStorage (mlir::Type eleTy)
      : eleTy(eleTy) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<mlir::Type>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(eleTy == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static ReferenceTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto eleTy = std::get<0>(tblgenKey);

      return new (allocator.allocate<ReferenceTypeStorage>())
          ReferenceTypeStorage(eleTy);
    }
      mlir::Type eleTy;
  };
} // namespace detail
ReferenceType ReferenceType::get(mlir::Type elementType) {
  
      return Base::get(elementType.getContext(), elementType);
    ;
}
ReferenceType ReferenceType::getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitErrorFn, mlir::Type elementType) {
  
      return Base::get(elementType.getContext(), elementType);
    ;
}
mlir::Type ReferenceType::getEleTy() const { return getImpl()->eleTy; }
} // namespace fir
namespace fir {

namespace detail {
  struct SequenceTypeStorage : public ::mlir::TypeStorage {
    SequenceTypeStorage (::llvm::ArrayRef<int64_t> shape, mlir::Type eleTy, mlir::AffineMapAttr layoutMap)
      : shape(shape), eleTy(eleTy), layoutMap(layoutMap) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<::llvm::ArrayRef<int64_t>, mlir::Type, mlir::AffineMapAttr>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(shape == std::get<0>(tblgenKey)))
      return false;
    if (!(eleTy == std::get<1>(tblgenKey)))
      return false;
    if (!(layoutMap == std::get<2>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey), std::get<1>(tblgenKey), std::get<2>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static SequenceTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto shape = std::get<0>(tblgenKey);
      auto eleTy = std::get<1>(tblgenKey);
      auto layoutMap = std::get<2>(tblgenKey);
      shape = allocator.copyInto(shape);

      return new (allocator.allocate<SequenceTypeStorage>())
          SequenceTypeStorage(shape, eleTy, layoutMap);
    }
      ::llvm::ArrayRef<int64_t> shape;
      mlir::Type eleTy;
      mlir::AffineMapAttr layoutMap;
  };
} // namespace detail
SequenceType SequenceType::get(::mlir::MLIRContext *context, ::llvm::ArrayRef<int64_t> shape, mlir::Type eleTy, mlir::AffineMapAttr layoutMap) {
  return Base::get(context, shape, eleTy, layoutMap);
}
SequenceType SequenceType::getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::llvm::ArrayRef<int64_t> shape, mlir::Type eleTy, mlir::AffineMapAttr layoutMap) {
  return Base::getChecked(emitError, context, shape, eleTy, layoutMap);
}
SequenceType SequenceType::get(llvm::ArrayRef<int64_t> shape, mlir::Type eleTy) {
  
      return get(eleTy.getContext(), shape, eleTy, {});
    ;
}
SequenceType SequenceType::getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitErrorFn, llvm::ArrayRef<int64_t> shape, mlir::Type eleTy) {
  
      return get(eleTy.getContext(), shape, eleTy, {});
    ;
}
::llvm::ArrayRef<int64_t> SequenceType::getShape() const { return getImpl()->shape; }
mlir::Type SequenceType::getEleTy() const { return getImpl()->eleTy; }
mlir::AffineMapAttr SequenceType::getLayoutMap() const { return getImpl()->layoutMap; }
} // namespace fir
namespace fir {

namespace detail {
  struct ShapeShiftTypeStorage : public ::mlir::TypeStorage {
    ShapeShiftTypeStorage (unsigned rank)
      : rank(rank) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<unsigned>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(rank == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static ShapeShiftTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto rank = std::get<0>(tblgenKey);

      return new (allocator.allocate<ShapeShiftTypeStorage>())
          ShapeShiftTypeStorage(rank);
    }
      unsigned rank;
  };
} // namespace detail
ShapeShiftType ShapeShiftType::get(::mlir::MLIRContext *context, unsigned rank) {
  return Base::get(context, rank);
}
unsigned ShapeShiftType::getRank() const { return getImpl()->rank; }
} // namespace fir
namespace fir {

namespace detail {
  struct ShapeTypeStorage : public ::mlir::TypeStorage {
    ShapeTypeStorage (unsigned rank)
      : rank(rank) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<unsigned>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(rank == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static ShapeTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto rank = std::get<0>(tblgenKey);

      return new (allocator.allocate<ShapeTypeStorage>())
          ShapeTypeStorage(rank);
    }
      unsigned rank;
  };
} // namespace detail
ShapeType ShapeType::get(::mlir::MLIRContext *context, unsigned rank) {
  return Base::get(context, rank);
}
unsigned ShapeType::getRank() const { return getImpl()->rank; }
} // namespace fir
namespace fir {

namespace detail {
  struct ShiftTypeStorage : public ::mlir::TypeStorage {
    ShiftTypeStorage (unsigned rank)
      : rank(rank) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<unsigned>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(rank == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static ShiftTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto rank = std::get<0>(tblgenKey);

      return new (allocator.allocate<ShiftTypeStorage>())
          ShiftTypeStorage(rank);
    }
      unsigned rank;
  };
} // namespace detail
ShiftType ShiftType::get(::mlir::MLIRContext *context, unsigned rank) {
  return Base::get(context, rank);
}
unsigned ShiftType::getRank() const { return getImpl()->rank; }
} // namespace fir
namespace fir {

namespace detail {
  struct SliceTypeStorage : public ::mlir::TypeStorage {
    SliceTypeStorage (unsigned rank)
      : rank(rank) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<unsigned>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(rank == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static SliceTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto rank = std::get<0>(tblgenKey);

      return new (allocator.allocate<SliceTypeStorage>())
          SliceTypeStorage(rank);
    }
      unsigned rank;
  };
} // namespace detail
SliceType SliceType::get(::mlir::MLIRContext *context, unsigned rank) {
  return Base::get(context, rank);
}
unsigned SliceType::getRank() const { return getImpl()->rank; }
} // namespace fir
namespace fir {

namespace detail {
  struct TypeDescTypeStorage : public ::mlir::TypeStorage {
    TypeDescTypeStorage (mlir::Type ofTy)
      : ofTy(ofTy) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<mlir::Type>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(ofTy == std::get<0>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static TypeDescTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto ofTy = std::get<0>(tblgenKey);

      return new (allocator.allocate<TypeDescTypeStorage>())
          TypeDescTypeStorage(ofTy);
    }
      mlir::Type ofTy;
  };
} // namespace detail
TypeDescType TypeDescType::get(mlir::Type elementType) {
  
      return Base::get(elementType.getContext(), elementType);
    ;
}
TypeDescType TypeDescType::getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitErrorFn, mlir::Type elementType) {
  
      return Base::get(elementType.getContext(), elementType);
    ;
}
mlir::Type TypeDescType::getOfTy() const { return getImpl()->ofTy; }
} // namespace fir
namespace fir {

namespace detail {
  struct VectorTypeStorage : public ::mlir::TypeStorage {
    VectorTypeStorage (uint64_t len, mlir::Type eleTy)
      : len(len), eleTy(eleTy) { }

    /// The hash key is a tuple of the parameter types.
    using KeyTy = std::tuple<uint64_t, mlir::Type>;
  bool operator==(const KeyTy &tblgenKey) const {
    if (!(len == std::get<0>(tblgenKey)))
      return false;
    if (!(eleTy == std::get<1>(tblgenKey)))
      return false;
    return true;
  }
  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
      return ::llvm::hash_combine(std::get<0>(tblgenKey), std::get<1>(tblgenKey));
    }

    /// Define a construction method for creating a new instance of this
    /// storage.
    static VectorTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                          const KeyTy &tblgenKey) {
      auto len = std::get<0>(tblgenKey);
      auto eleTy = std::get<1>(tblgenKey);

      return new (allocator.allocate<VectorTypeStorage>())
          VectorTypeStorage(len, eleTy);
    }
      uint64_t len;
      mlir::Type eleTy;
  };
} // namespace detail
VectorType VectorType::get(uint64_t len, mlir::Type eleTy) {
  
      return Base::get(eleTy.getContext(), len, eleTy);
    ;
}
VectorType VectorType::getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitErrorFn, uint64_t len, mlir::Type eleTy) {
  
      return Base::get(eleTy.getContext(), len, eleTy);
    ;
}
uint64_t VectorType::getLen() const { return getImpl()->len; }
mlir::Type VectorType::getEleTy() const { return getImpl()->eleTy; }
} // namespace fir
namespace fir {
} // namespace fir

#endif  // GET_TYPEDEF_CLASSES

