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

#ifdef GET_TYPEDEF_CLASSES
#undef GET_TYPEDEF_CLASSES


namespace mlir {
class DialectAsmParser;
class DialectAsmPrinter;
} // namespace mlir
namespace mlir {
  class BFloat16Type;
  class ComplexType;
  class Float128Type;
  class Float16Type;
  class Float32Type;
  class Float64Type;
  class Float80Type;
  class FunctionType;
  class IndexType;
  class IntegerType;
  class NoneType;
  class OpaqueType;
  class TupleType;

  class BFloat16Type : public ::mlir::Type::TypeBase<BFloat16Type, ::mlir::FloatType, ::mlir::TypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;


    static BFloat16Type get(MLIRContext *context);
  
  };

  namespace detail {
    struct ComplexTypeStorage;
  } // end namespace detail
  class ComplexType : public ::mlir::Type::TypeBase<ComplexType, ::mlir::Type,
                                         detail::ComplexTypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;

    static ComplexType get(Type elementType);
    static ComplexType getChecked(::mlir::Location loc, Type elementType);

    static ::mlir::LogicalResult verifyConstructionInvariants(::mlir::Location loc, Type elementType);
    Type getElementType() const;
  };

  class Float128Type : public ::mlir::Type::TypeBase<Float128Type, ::mlir::FloatType, ::mlir::TypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;


    static Float128Type get(MLIRContext *context);
  
  };

  class Float16Type : public ::mlir::Type::TypeBase<Float16Type, ::mlir::FloatType, ::mlir::TypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;


    static Float16Type get(MLIRContext *context);
  
  };

  class Float32Type : public ::mlir::Type::TypeBase<Float32Type, ::mlir::FloatType, ::mlir::TypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;


    static Float32Type get(MLIRContext *context);
  
  };

  class Float64Type : public ::mlir::Type::TypeBase<Float64Type, ::mlir::FloatType, ::mlir::TypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;


    static Float64Type get(MLIRContext *context);
  
  };

  class Float80Type : public ::mlir::Type::TypeBase<Float80Type, ::mlir::FloatType, ::mlir::TypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;


    static Float80Type get(MLIRContext *context);
  
  };

  namespace detail {
    struct FunctionTypeStorage;
  } // end namespace detail
  class FunctionType : public ::mlir::Type::TypeBase<FunctionType, ::mlir::Type,
                                         detail::FunctionTypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;


    /// Input types.
    unsigned getNumInputs() const;
    Type getInput(unsigned i) const { return getInputs()[i]; }

    /// Result types.
    unsigned getNumResults() const;
    Type getResult(unsigned i) const { return getResults()[i]; }

    /// Returns a new function type without the specified arguments and results.
    FunctionType getWithoutArgsAndResults(ArrayRef<unsigned> argIndices,
                                          ArrayRef<unsigned> resultIndices);
  
    static FunctionType get(::mlir::MLIRContext *context, TypeRange inputs, TypeRange results);
    ArrayRef<Type> getInputs() const;
    ArrayRef<Type> getResults() const;
  };

  class IndexType : public ::mlir::Type::TypeBase<IndexType, ::mlir::Type, ::mlir::TypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;


    static IndexType get(MLIRContext *context);

    /// Storage bit width used for IndexType by internal compiler data
    /// structures.
    static constexpr unsigned kInternalStorageBitWidth = 64;
  
  };

  namespace detail {
    struct IntegerTypeStorage;
  } // end namespace detail
  class IntegerType : public ::mlir::Type::TypeBase<IntegerType, ::mlir::Type,
                                         detail::IntegerTypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;


    /// Signedness semantics.
    enum SignednessSemantics : uint32_t {
      Signless, /// No signedness semantics
      Signed,   /// Signed integer
      Unsigned, /// Unsigned integer
    };

    /// Return true if this is a signless integer type.
    bool isSignless() const { return getSignedness() == Signless; }
    /// Return true if this is a signed integer type.
    bool isSigned() const { return getSignedness() == Signed; }
    /// Return true if this is an unsigned integer type.
    bool isUnsigned() const { return getSignedness() == Unsigned; }

    /// Get or create a new IntegerType with the same signedness as `this` and a
    /// bitwidth scaled by `scale`.
    /// Return null if the scaled element type cannot be represented.
    IntegerType scaleElementBitwidth(unsigned scale);

    /// Integer representation maximal bitwidth.
    /// Note: This is aligned with the maximum width of llvm::IntegerType.
    static constexpr unsigned kMaxWidth = (1 << 24) - 1;
  
    static IntegerType get(::mlir::MLIRContext *context, unsigned width, SignednessSemantics signedness = Signless);
    static IntegerType getChecked(::mlir::Location loc, unsigned width, SignednessSemantics signedness = Signless);

    static ::mlir::LogicalResult verifyConstructionInvariants(::mlir::Location loc, unsigned width, SignednessSemantics signedness);
    unsigned getWidth() const;
    SignednessSemantics getSignedness() const;
  };

  class NoneType : public ::mlir::Type::TypeBase<NoneType, ::mlir::Type, ::mlir::TypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;


    static NoneType get(MLIRContext *context);
  
  };

  namespace detail {
    struct OpaqueTypeStorage;
  } // end namespace detail
  class OpaqueType : public ::mlir::Type::TypeBase<OpaqueType, ::mlir::Type,
                                         detail::OpaqueTypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;

    static OpaqueType get(::mlir::MLIRContext *context, Identifier dialectNamespace, ::llvm::StringRef typeData);
    static OpaqueType getChecked(::mlir::Location loc, Identifier dialectNamespace, ::llvm::StringRef typeData);

    static ::mlir::LogicalResult verifyConstructionInvariants(::mlir::Location loc, Identifier dialectNamespace, ::llvm::StringRef typeData);
    Identifier getDialectNamespace() const;
    ::llvm::StringRef getTypeData() const;
  };

  namespace detail {
    struct TupleTypeStorage;
  } // end namespace detail
  class TupleType : public ::mlir::Type::TypeBase<TupleType, ::mlir::Type,
                                         detail::TupleTypeStorage> {
  public:
    /// Inherit some necessary constructors from 'TypeBase'.
    using Base::Base;


    /// Accumulate the types contained in this tuple and tuples nested within
    /// it. Note that this only flattens nested tuples, not any other container
    /// type, e.g. a tuple<i32, tensor<i32>, tuple<f32, tuple<i64>>> is
    /// flattened to (i32, tensor<i32>, f32, i64)
    void getFlattenedTypes(SmallVectorImpl<Type> &types);

    /// Return the number of held types.
    size_t size() const;

    /// Iterate over the held elements.
    using iterator = ArrayRef<Type>::iterator;
    iterator begin() const { return getTypes().begin(); }
    iterator end() const { return getTypes().end(); }

    /// Return the element type at index 'index'.
    Type getType(size_t index) const {
      assert(index < size() && "invalid index for tuple type");
      return getTypes()[index];
    }
  
    static TupleType get(::mlir::MLIRContext *context, TypeRange elementTypes);
    static TupleType get(::mlir::MLIRContext *context);
    ArrayRef<Type> getTypes() const;
  };
} // namespace mlir

#endif  // GET_TYPEDEF_CLASSES

