TestAttrDefs.cpp.inc | Explore in Territory

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

#ifdef GET_ATTRDEF_LIST
#undef GET_ATTRDEF_LIST

::test::SimpleAAttr,
::test::CompoundAAttr,
::test::CompoundAttrNestedAttr,
::test::AttrWithSelfTypeParamAttr,
::test::AttrWithTypeBuilderAttr,
::test::AttrWithTraitAttr,
::test::TestDecimalShapeAttr,
::test::TestI64ElementsAttr,
::test::TestSubElementsAccessAttr,
::test::CompoundNestedInnerAttr,
::test::CompoundNestedOuterAttr,
::test::CompoundNestedOuterQualAttr,
::test::TestAttrWithFormatAttr,
::test::TestAttrWithOptionalSignedAttr,
::test::TestAttrWithOptionalUnsignedAttr,
::test::TestAttrUglyAttr,
::test::TestAttrParamsAttr,
::test::TestAttrWithTypeParamAttr,
::test::TestAttrSelfTypeParameterFormatAttr,
::test::TestAttrSelfTypeParameterStructFormatAttr,
::test::TestOverrideBuilderAttr,
::test::TestExtern1DI64ElementsAttr,
::test::ArrayOfUglyAttrsAttr,
::test::ArrayOfIntsAttr,
::test::SimpleEnumAttr,
::test::ArrayOfEnumsAttr,
::test::TestCustomAnchorAttr,
::test::IteratorTypeAttr,
::test::TestCopyCountAttr,
::test::TestConditionalAliasAttr,
::test::TestCustomFloatAttr,
::test::NestedPolynomialAttrAttr,
::test::NestedPolynomialAttr2Attr,
::test::TestEnumAttr,
::test::TestBitEnumAttr,
::test::TestBitEnumVerticalBarAttr

#endif  // GET_ATTRDEF_LIST

#ifdef GET_ATTRDEF_CLASSES
#undef GET_ATTRDEF_CLASSES

static ::mlir::OptionalParseResult generatedAttributeParser(::mlir::AsmParser &parser, ::llvm::StringRef *mnemonic, ::mlir::Type type, ::mlir::Attribute &value) { … }

static ::llvm::LogicalResult generatedAttributePrinter(::mlir::Attribute def, ::mlir::AsmPrinter &printer) { … }

namespace test {
} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::SimpleAAttr)
namespace test {
namespace detail {
struct CompoundAAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
CompoundAAttr CompoundAAttr::get(::mlir::MLIRContext *context, int widthOfSomething, ::mlir::Type oneType, ::llvm::ArrayRef<int> arrayOfInts) { … }

int CompoundAAttr::getWidthOfSomething() const { … }

::mlir::Type CompoundAAttr::getOneType() const { … }

::llvm::ArrayRef<int> CompoundAAttr::getArrayOfInts() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::CompoundAAttr)
namespace test {
namespace detail {
struct CompoundAttrNestedAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
CompoundAttrNestedAttr CompoundAttrNestedAttr::get(::mlir::MLIRContext *context, ::test::CompoundAAttr nested) { … }

CompoundAttrNestedAttr CompoundAttrNestedAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::test::CompoundAAttr nested) { … }

::llvm::LogicalResult CompoundAttrNestedAttr::verifyInvariantsImpl(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::test::CompoundAAttr nested) { … }

::llvm::LogicalResult CompoundAttrNestedAttr::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::test::CompoundAAttr nested) { … }

::mlir::Attribute CompoundAttrNestedAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void CompoundAttrNestedAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::test::CompoundAAttr CompoundAttrNestedAttr::getNested() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::CompoundAttrNestedAttr)
namespace test {
namespace detail {
struct AttrWithSelfTypeParamAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
AttrWithSelfTypeParamAttr AttrWithSelfTypeParamAttr::get(::mlir::MLIRContext *context, ::mlir::Type type) { … }

::mlir::Attribute AttrWithSelfTypeParamAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void AttrWithSelfTypeParamAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::mlir::Type AttrWithSelfTypeParamAttr::getType() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::AttrWithSelfTypeParamAttr)
namespace test {
namespace detail {
struct AttrWithTypeBuilderAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
AttrWithTypeBuilderAttr AttrWithTypeBuilderAttr::get(::mlir::MLIRContext *context, ::mlir::IntegerAttr attr, mlir::Type type) { … }

::mlir::Attribute AttrWithTypeBuilderAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void AttrWithTypeBuilderAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::mlir::IntegerAttr AttrWithTypeBuilderAttr::getAttr() const { … }

mlir::Type AttrWithTypeBuilderAttr::getType() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::AttrWithTypeBuilderAttr)
namespace test {
} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::AttrWithTraitAttr)
namespace test {
namespace detail {
struct TestDecimalShapeAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestDecimalShapeAttr TestDecimalShapeAttr::get(::mlir::MLIRContext *context, ::llvm::ArrayRef<int64_t> shape) { … }

::llvm::ArrayRef<int64_t> TestDecimalShapeAttr::getShape() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestDecimalShapeAttr)
namespace test {
namespace detail {
struct TestI64ElementsAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestI64ElementsAttr TestI64ElementsAttr::get(::mlir::MLIRContext *context, ::mlir::ShapedType type, ::llvm::ArrayRef<uint64_t> elements) { … }

TestI64ElementsAttr TestI64ElementsAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::mlir::ShapedType type, ::llvm::ArrayRef<uint64_t> elements) { … }

::llvm::LogicalResult TestI64ElementsAttr::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::ShapedType type, ::llvm::ArrayRef<uint64_t> elements) { … }

::mlir::ShapedType TestI64ElementsAttr::getType() const { … }

::llvm::ArrayRef<uint64_t> TestI64ElementsAttr::getElements() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestI64ElementsAttr)
namespace test {
namespace detail {
struct TestSubElementsAccessAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestSubElementsAccessAttr TestSubElementsAccessAttr::get(::mlir::MLIRContext *context, ::mlir::Attribute first, ::mlir::Attribute second, ::mlir::Attribute third) { … }

::mlir::Attribute TestSubElementsAccessAttr::getFirst() const { … }

::mlir::Attribute TestSubElementsAccessAttr::getSecond() const { … }

::mlir::Attribute TestSubElementsAccessAttr::getThird() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestSubElementsAccessAttr)
namespace test {
namespace detail {
struct CompoundNestedInnerAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
CompoundNestedInnerAttr CompoundNestedInnerAttr::get(::mlir::MLIRContext *context, int some_int, ::test::CompoundAAttr cmpdA) { … }

CompoundNestedInnerAttr CompoundNestedInnerAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int some_int, ::test::CompoundAAttr cmpdA) { … }

::llvm::LogicalResult CompoundNestedInnerAttr::verifyInvariantsImpl(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int some_int, ::test::CompoundAAttr cmpdA) { … }

::llvm::LogicalResult CompoundNestedInnerAttr::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int some_int, ::test::CompoundAAttr cmpdA) { … }

::mlir::Attribute CompoundNestedInnerAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void CompoundNestedInnerAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

int CompoundNestedInnerAttr::getSomeInt() const { … }

::test::CompoundAAttr CompoundNestedInnerAttr::getCmpdA() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::CompoundNestedInnerAttr)
namespace test {
namespace detail {
struct CompoundNestedOuterAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
CompoundNestedOuterAttr CompoundNestedOuterAttr::get(::mlir::MLIRContext *context, ::test::CompoundNestedInnerAttr inner) { … }

CompoundNestedOuterAttr CompoundNestedOuterAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::test::CompoundNestedInnerAttr inner) { … }

::llvm::LogicalResult CompoundNestedOuterAttr::verifyInvariantsImpl(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::test::CompoundNestedInnerAttr inner) { … }

::llvm::LogicalResult CompoundNestedOuterAttr::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::test::CompoundNestedInnerAttr inner) { … }

::mlir::Attribute CompoundNestedOuterAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void CompoundNestedOuterAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::test::CompoundNestedInnerAttr CompoundNestedOuterAttr::getInner() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::CompoundNestedOuterAttr)
namespace test {
namespace detail {
struct CompoundNestedOuterQualAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
CompoundNestedOuterQualAttr CompoundNestedOuterQualAttr::get(::mlir::MLIRContext *context, ::test::CompoundNestedInnerAttr inner) { … }

CompoundNestedOuterQualAttr CompoundNestedOuterQualAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::test::CompoundNestedInnerAttr inner) { … }

::llvm::LogicalResult CompoundNestedOuterQualAttr::verifyInvariantsImpl(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::test::CompoundNestedInnerAttr inner) { … }

::llvm::LogicalResult CompoundNestedOuterQualAttr::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::test::CompoundNestedInnerAttr inner) { … }

::mlir::Attribute CompoundNestedOuterQualAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void CompoundNestedOuterQualAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::test::CompoundNestedInnerAttr CompoundNestedOuterQualAttr::getInner() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::CompoundNestedOuterQualAttr)
namespace test {
namespace detail {
struct TestAttrWithFormatAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestAttrWithFormatAttr TestAttrWithFormatAttr::get(::mlir::MLIRContext *context, int64_t one, std::string two, ::mlir::IntegerAttr three, ::llvm::ArrayRef<int> four, uint64_t five, ::llvm::ArrayRef<int> six, ::llvm::ArrayRef<AttrWithTypeBuilderAttr> arrayOfAttrWithTypeBuilderAttr) { … }

TestAttrWithFormatAttr TestAttrWithFormatAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int64_t one, std::string two, ::mlir::IntegerAttr three, ::llvm::ArrayRef<int> four, uint64_t five, ::llvm::ArrayRef<int> six, ::llvm::ArrayRef<AttrWithTypeBuilderAttr> arrayOfAttrWithTypeBuilderAttr) { … }

::llvm::LogicalResult TestAttrWithFormatAttr::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int64_t one, std::string two, ::mlir::IntegerAttr three, ::llvm::ArrayRef<int> four, uint64_t five, ::llvm::ArrayRef<int> six, ::llvm::ArrayRef<AttrWithTypeBuilderAttr> arrayOfAttrWithTypeBuilderAttr) { … }

::mlir::Attribute TestAttrWithFormatAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestAttrWithFormatAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

int64_t TestAttrWithFormatAttr::getOne() const { … }

llvm::StringRef TestAttrWithFormatAttr::getTwo() const { … }

::mlir::IntegerAttr TestAttrWithFormatAttr::getThree() const { … }

::llvm::ArrayRef<int> TestAttrWithFormatAttr::getFour() const { … }

uint64_t TestAttrWithFormatAttr::getFive() const { … }

::llvm::ArrayRef<int> TestAttrWithFormatAttr::getSix() const { … }

::llvm::ArrayRef<AttrWithTypeBuilderAttr> TestAttrWithFormatAttr::getArrayOfAttrWithTypeBuilderAttr() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestAttrWithFormatAttr)
namespace test {
namespace detail {
struct TestAttrWithOptionalSignedAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestAttrWithOptionalSignedAttr TestAttrWithOptionalSignedAttr::get(::mlir::MLIRContext *context, std::optional<int64_t> value) { … }

::mlir::Attribute TestAttrWithOptionalSignedAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestAttrWithOptionalSignedAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

std::optional<int64_t> TestAttrWithOptionalSignedAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestAttrWithOptionalSignedAttr)
namespace test {
namespace detail {
struct TestAttrWithOptionalUnsignedAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestAttrWithOptionalUnsignedAttr TestAttrWithOptionalUnsignedAttr::get(::mlir::MLIRContext *context, std::optional<uint64_t> value) { … }

::mlir::Attribute TestAttrWithOptionalUnsignedAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestAttrWithOptionalUnsignedAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

std::optional<uint64_t> TestAttrWithOptionalUnsignedAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestAttrWithOptionalUnsignedAttr)
namespace test {
namespace detail {
struct TestAttrUglyAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestAttrUglyAttr TestAttrUglyAttr::get(::mlir::MLIRContext *context, ::mlir::Attribute attr) { … }

::mlir::Attribute TestAttrUglyAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestAttrUglyAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::mlir::Attribute TestAttrUglyAttr::getAttr() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestAttrUglyAttr)
namespace test {
namespace detail {
struct TestAttrParamsAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestAttrParamsAttr TestAttrParamsAttr::get(::mlir::MLIRContext *context, int v0, int v1) { … }

::mlir::Attribute TestAttrParamsAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestAttrParamsAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

int TestAttrParamsAttr::getV0() const { … }

int TestAttrParamsAttr::getV1() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestAttrParamsAttr)
namespace test {
namespace detail {
struct TestAttrWithTypeParamAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestAttrWithTypeParamAttr TestAttrWithTypeParamAttr::get(::mlir::MLIRContext *context, ::mlir::IntegerType int_type, ::mlir::Type any_type) { … }

::mlir::Attribute TestAttrWithTypeParamAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestAttrWithTypeParamAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::mlir::IntegerType TestAttrWithTypeParamAttr::getIntType() const { … }

::mlir::Type TestAttrWithTypeParamAttr::getAnyType() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestAttrWithTypeParamAttr)
namespace test {
namespace detail {
struct TestAttrSelfTypeParameterFormatAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestAttrSelfTypeParameterFormatAttr TestAttrSelfTypeParameterFormatAttr::get(::mlir::MLIRContext *context, int a, ::mlir::Type type) { … }

::mlir::Attribute TestAttrSelfTypeParameterFormatAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestAttrSelfTypeParameterFormatAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

int TestAttrSelfTypeParameterFormatAttr::getA() const { … }

::mlir::Type TestAttrSelfTypeParameterFormatAttr::getType() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestAttrSelfTypeParameterFormatAttr)
namespace test {
namespace detail {
struct TestAttrSelfTypeParameterStructFormatAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestAttrSelfTypeParameterStructFormatAttr TestAttrSelfTypeParameterStructFormatAttr::get(::mlir::MLIRContext *context, int a, ::mlir::Type type) { … }

::mlir::Attribute TestAttrSelfTypeParameterStructFormatAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestAttrSelfTypeParameterStructFormatAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

int TestAttrSelfTypeParameterStructFormatAttr::getA() const { … }

::mlir::Type TestAttrSelfTypeParameterStructFormatAttr::getType() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestAttrSelfTypeParameterStructFormatAttr)
namespace test {
namespace detail {
struct TestOverrideBuilderAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
::mlir::Attribute TestOverrideBuilderAttr::get(::mlir::MLIRContext *context, int a) { … }

::mlir::Attribute TestOverrideBuilderAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestOverrideBuilderAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

int TestOverrideBuilderAttr::getA() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestOverrideBuilderAttr)
namespace test {
namespace detail {
struct TestExtern1DI64ElementsAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestExtern1DI64ElementsAttr TestExtern1DI64ElementsAttr::get(::mlir::MLIRContext *context, ::mlir::ShapedType type, TestDialectResourceBlobHandle handle) { … }

::mlir::Attribute TestExtern1DI64ElementsAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestExtern1DI64ElementsAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::mlir::ShapedType TestExtern1DI64ElementsAttr::getType() const { … }

TestDialectResourceBlobHandle TestExtern1DI64ElementsAttr::getHandle() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestExtern1DI64ElementsAttr)
namespace test {
namespace detail {
struct ArrayOfUglyAttrsAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
ArrayOfUglyAttrsAttr ArrayOfUglyAttrsAttr::get(::mlir::MLIRContext *context, ::llvm::ArrayRef<TestAttrUglyAttr> value) { … }

::mlir::Attribute ArrayOfUglyAttrsAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void ArrayOfUglyAttrsAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::llvm::ArrayRef<TestAttrUglyAttr> ArrayOfUglyAttrsAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::ArrayOfUglyAttrsAttr)
namespace test {
namespace detail {
struct ArrayOfIntsAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
ArrayOfIntsAttr ArrayOfIntsAttr::get(::mlir::MLIRContext *context, ::llvm::ArrayRef<int32_t> value) { … }

::mlir::Attribute ArrayOfIntsAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void ArrayOfIntsAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::llvm::ArrayRef<int32_t> ArrayOfIntsAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::ArrayOfIntsAttr)
namespace test {
namespace detail {
struct SimpleEnumAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
SimpleEnumAttr SimpleEnumAttr::get(::mlir::MLIRContext *context, ::test::SimpleEnum value) { … }

::mlir::Attribute SimpleEnumAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void SimpleEnumAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::test::SimpleEnum SimpleEnumAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::SimpleEnumAttr)
namespace test {
namespace detail {
struct ArrayOfEnumsAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
ArrayOfEnumsAttr ArrayOfEnumsAttr::get(::mlir::MLIRContext *context, ::llvm::ArrayRef<SimpleEnumAttr> value) { … }

::mlir::Attribute ArrayOfEnumsAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void ArrayOfEnumsAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::llvm::ArrayRef<SimpleEnumAttr> ArrayOfEnumsAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::ArrayOfEnumsAttr)
namespace test {
namespace detail {
struct TestCustomAnchorAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestCustomAnchorAttr TestCustomAnchorAttr::get(::mlir::MLIRContext *context, int a, std::optional<int> b) { … }

::mlir::Attribute TestCustomAnchorAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestCustomAnchorAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

int TestCustomAnchorAttr::getA() const { … }

std::optional<int> TestCustomAnchorAttr::getB() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestCustomAnchorAttr)
namespace test {
namespace detail {
struct IteratorTypeAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
IteratorTypeAttr IteratorTypeAttr::get(::mlir::MLIRContext *context, ::mlir::utils::IteratorType value) { … }

::mlir::Attribute IteratorTypeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void IteratorTypeAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::mlir::utils::IteratorType IteratorTypeAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::IteratorTypeAttr)
namespace test {
namespace detail {
struct TestCopyCountAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestCopyCountAttr TestCopyCountAttr::get(::mlir::MLIRContext *context, CopyCount copy_count) { … }

::mlir::Attribute TestCopyCountAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestCopyCountAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

const CopyCount &TestCopyCountAttr::getCopyCount() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestCopyCountAttr)
namespace test {
namespace detail {
struct TestConditionalAliasAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestConditionalAliasAttr TestConditionalAliasAttr::get(::mlir::MLIRContext *context, mlir::StringAttr value) { … }

::mlir::Attribute TestConditionalAliasAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestConditionalAliasAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

mlir::StringAttr TestConditionalAliasAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestConditionalAliasAttr)
namespace test {
namespace detail {
struct TestCustomFloatAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestCustomFloatAttr TestCustomFloatAttr::get(::mlir::MLIRContext *context, mlir::StringAttr type_str, ::llvm::APFloat value) { … }

::mlir::Attribute TestCustomFloatAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestCustomFloatAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

mlir::StringAttr TestCustomFloatAttr::getTypeStr() const { … }

::llvm::APFloat TestCustomFloatAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestCustomFloatAttr)
namespace test {
namespace detail {
struct NestedPolynomialAttrAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
NestedPolynomialAttrAttr NestedPolynomialAttrAttr::get(::mlir::MLIRContext *context, ::mlir::polynomial::IntPolynomialAttr poly) { … }

NestedPolynomialAttrAttr NestedPolynomialAttrAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::mlir::polynomial::IntPolynomialAttr poly) { … }

::llvm::LogicalResult NestedPolynomialAttrAttr::verifyInvariantsImpl(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::polynomial::IntPolynomialAttr poly) { … }

::llvm::LogicalResult NestedPolynomialAttrAttr::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::polynomial::IntPolynomialAttr poly) { … }

::mlir::Attribute NestedPolynomialAttrAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void NestedPolynomialAttrAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::mlir::polynomial::IntPolynomialAttr NestedPolynomialAttrAttr::getPoly() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::NestedPolynomialAttrAttr)
namespace test {
namespace detail {
struct NestedPolynomialAttr2AttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
NestedPolynomialAttr2Attr NestedPolynomialAttr2Attr::get(::mlir::MLIRContext *context, ::mlir::polynomial::IntPolynomialAttr poly) { … }

::mlir::Attribute NestedPolynomialAttr2Attr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void NestedPolynomialAttr2Attr::print(::mlir::AsmPrinter &odsPrinter) const { … }

::mlir::polynomial::IntPolynomialAttr NestedPolynomialAttr2Attr::getPoly() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::NestedPolynomialAttr2Attr)
namespace test {
namespace detail {
struct TestEnumAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestEnumAttr TestEnumAttr::get(::mlir::MLIRContext *context, test::TestEnum value) { … }

::mlir::Attribute TestEnumAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestEnumAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

test::TestEnum TestEnumAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestEnumAttr)
namespace test {
namespace detail {
struct TestBitEnumAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestBitEnumAttr TestBitEnumAttr::get(::mlir::MLIRContext *context, test::TestBitEnum value) { … }

::mlir::Attribute TestBitEnumAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestBitEnumAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

test::TestBitEnum TestBitEnumAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestBitEnumAttr)
namespace test {
namespace detail {
struct TestBitEnumVerticalBarAttrStorage : public ::mlir::AttributeStorage { … };
} // namespace detail
TestBitEnumVerticalBarAttr TestBitEnumVerticalBarAttr::get(::mlir::MLIRContext *context, test::TestBitEnumVerticalBar value) { … }

::mlir::Attribute TestBitEnumVerticalBarAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) { … }

void TestBitEnumVerticalBarAttr::print(::mlir::AsmPrinter &odsPrinter) const { … }

test::TestBitEnumVerticalBar TestBitEnumVerticalBarAttr::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestBitEnumVerticalBarAttr)
namespace test {

/// Parse an attribute registered to this dialect.
::mlir::Attribute TestDialect::parseAttribute(::mlir::DialectAsmParser &parser,
                                      ::mlir::Type type) const { … }
/// Print an attribute registered to this dialect.
void TestDialect::printAttribute(::mlir::Attribute attr,
                         ::mlir::DialectAsmPrinter &printer) const { … }
} // namespace test

#endif  // GET_ATTRDEF_CLASSES
llvm/tools/mlir/test/lib/Dialect/Test/TestAttrDefs.cpp.inc
