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

#ifdef GET_TYPEDEF_LIST
#undef GET_TYPEDEF_LIST

::mlir::BFloat16Type,
::mlir::ComplexType,
::mlir::Float128Type,
::mlir::Float16Type,
::mlir::Float32Type,
::mlir::Float64Type,
::mlir::Float80Type,
::mlir::FunctionType,
::mlir::IndexType,
::mlir::IntegerType,
::mlir::NoneType,
::mlir::OpaqueType,
::mlir::TupleType

#endif  // GET_TYPEDEF_LIST

#ifdef GET_TYPEDEF_CLASSES
#undef GET_TYPEDEF_CLASSES

namespace mlir {
} // namespace mlir
namespace mlir {

namespace detail {
  struct ComplexTypeStorage : public ::mlir::TypeStorage {
    ComplexTypeStorage (Type elementType)
      : elementType(elementType) { }

    /// The hash key for this storage is a pair of the integer and type params.
    using KeyTy = std::tuple<Type>;

    /// Define the comparison function for the key type.
    bool operator==(const KeyTy &key) const {
      return key == KeyTy(elementType);
    }
  static ::llvm::hash_code hashKey(const KeyTy &key) {
      const auto &elementType = std::get<0>(key);
      return ::llvm::hash_combine(elementType);
    }

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

      return new (allocator.allocate<ComplexTypeStorage>())
          ComplexTypeStorage(elementType);
    }
      Type elementType;
  };
} // namespace detail
ComplexType ComplexType::get(Type elementType) {
  
      return Base::get(elementType.getContext(), elementType);
    ;
}
ComplexType ComplexType::getChecked(::mlir::Location loc, Type elementType) {
  
      return Base::getChecked(loc, elementType);
    ;
}
Type ComplexType::getElementType() const { return getImpl()->elementType; }
} // namespace mlir
namespace mlir {
} // namespace mlir
namespace mlir {
} // namespace mlir
namespace mlir {
} // namespace mlir
namespace mlir {
} // namespace mlir
namespace mlir {
} // namespace mlir
namespace mlir {
FunctionType FunctionType::get(::mlir::MLIRContext *context, TypeRange inputs, TypeRange results) {
  
      return Base::get(context, inputs, results);
    ;
}
} // namespace mlir
namespace mlir {
} // namespace mlir
namespace mlir {
} // namespace mlir
namespace mlir {
} // namespace mlir
namespace mlir {

namespace detail {
  struct OpaqueTypeStorage : public ::mlir::TypeStorage {
    OpaqueTypeStorage (Identifier dialectNamespace, ::llvm::StringRef typeData)
      : dialectNamespace(dialectNamespace), typeData(typeData) { }

    /// The hash key for this storage is a pair of the integer and type params.
    using KeyTy = std::tuple<Identifier, ::llvm::StringRef>;

    /// Define the comparison function for the key type.
    bool operator==(const KeyTy &key) const {
      return key == KeyTy(dialectNamespace, typeData);
    }
  static ::llvm::hash_code hashKey(const KeyTy &key) {
      const auto &dialectNamespace = std::get<0>(key);
      const auto &typeData = std::get<1>(key);
      return ::llvm::hash_combine(dialectNamespace, typeData);
    }

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

      return new (allocator.allocate<OpaqueTypeStorage>())
          OpaqueTypeStorage(dialectNamespace, typeData);
    }
      Identifier dialectNamespace;
      ::llvm::StringRef typeData;
  };
} // namespace detail
OpaqueType OpaqueType::get(::mlir::MLIRContext *context, Identifier dialectNamespace, ::llvm::StringRef typeData) {
  return Base::get(context, dialectNamespace, typeData);
}
OpaqueType OpaqueType::getChecked(::mlir::Location loc, Identifier dialectNamespace, ::llvm::StringRef typeData) {
  return Base::getChecked(loc, dialectNamespace, typeData);
}
Identifier OpaqueType::getDialectNamespace() const { return getImpl()->dialectNamespace; }
::llvm::StringRef OpaqueType::getTypeData() const { return getImpl()->typeData; }
} // namespace mlir
namespace mlir {
TupleType TupleType::get(::mlir::MLIRContext *context, TypeRange elementTypes) {
  
      return Base::get(context, elementTypes);
    ;
}
TupleType TupleType::get(::mlir::MLIRContext *context) {
  
      return Base::get(context, TypeRange());
    ;
}
} // namespace mlir

#endif  // GET_TYPEDEF_CLASSES

