TestTypeDefs.cpp.inc | Explore in Territory

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

#ifdef GET_TYPEDEF_LIST
#undef GET_TYPEDEF_LIST

::test::SimpleAType,
::test::CompoundAType,
::test::CompoundNestedInnerType,
::test::CompoundNestedOuterType,
::test::CompoundNestedOuterQualType,
::test::TestIntegerType,
::test::StructType,
::test::TestType,
::test::TestTypeWithLayoutType,
::test::TestMemRefElementTypeType,
::test::TestTypeWithTraitType,
::test::TestTypeWithFormatType,
::test::TestTypeNoParserType,
::test::TestStructTypeCaptureAllType,
::test::TestTypeOptionalParamType,
::test::TestTypeOptionalParamsType,
::test::TestTypeOptionalParamsAfterRequiredType,
::test::TestTypeOptionalStructType,
::test::TestTypeAllOptionalParamsType,
::test::TestTypeAllOptionalStructType,
::test::TestTypeOptionalGroupType,
::test::TestTypeOptionalGroupParamsType,
::test::TestTypeOptionalGroupStructType,
::test::TestTypeSpaceSType,
::test::TestTypeAPFloatType,
::test::TestTypeOptionalValueTypeType,
::test::TestTypeDefaultValuedTypeType,
::test::TestTypeCustomType,
::test::TestTypeCustomSpacingType,
::test::TestTypeCustomStringType,
::test::TestTypeOptionalStringType,
::test::TestTypeElseAnchorType,
::test::TestTypeElseAnchorStructType,
::test::TestI32Type,
::test::TestRecursiveAliasType,
::test::TestTypeVerificationType

#endif  // GET_TYPEDEF_LIST

#ifdef GET_TYPEDEF_CLASSES
#undef GET_TYPEDEF_CLASSES

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

static ::llvm::LogicalResult generatedTypePrinter(::mlir::Type def, ::mlir::AsmPrinter &printer) { … }

namespace test {
} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::SimpleAType)
namespace test {
namespace detail {
struct CompoundATypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
CompoundAType CompoundAType::get(::mlir::MLIRContext *context, int widthOfSomething, ::mlir::Type oneType, ::llvm::ArrayRef<int> arrayOfInts) { … }

int CompoundAType::getWidthOfSomething() const { … }

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

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

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::CompoundAType)
namespace test {
namespace detail {
struct CompoundNestedInnerTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
CompoundNestedInnerType CompoundNestedInnerType::get(::mlir::MLIRContext *context, int some_int, ::test::CompoundAType cmpdA) { … }

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

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

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

::mlir::Type CompoundNestedInnerType::parse(::mlir::AsmParser &odsParser) { … }

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

int CompoundNestedInnerType::getSomeInt() const { … }

::test::CompoundAType CompoundNestedInnerType::getCmpdA() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::CompoundNestedInnerType)
namespace test {
namespace detail {
struct CompoundNestedOuterTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
CompoundNestedOuterType CompoundNestedOuterType::get(::mlir::MLIRContext *context, ::test::CompoundNestedInnerType inner) { … }

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

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

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

::mlir::Type CompoundNestedOuterType::parse(::mlir::AsmParser &odsParser) { … }

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

::test::CompoundNestedInnerType CompoundNestedOuterType::getInner() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::CompoundNestedOuterType)
namespace test {
namespace detail {
struct CompoundNestedOuterQualTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
CompoundNestedOuterQualType CompoundNestedOuterQualType::get(::mlir::MLIRContext *context, ::test::CompoundNestedInnerType inner) { … }

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

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

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

::mlir::Type CompoundNestedOuterQualType::parse(::mlir::AsmParser &odsParser) { … }

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

::test::CompoundNestedInnerType CompoundNestedOuterQualType::getInner() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::CompoundNestedOuterQualType)
namespace test {
namespace detail {
struct TestIntegerTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestIntegerType TestIntegerType::get(::mlir::MLIRContext *context, unsigned width, SignednessSemantics signedness) { … }

TestIntegerType TestIntegerType::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, unsigned width, SignednessSemantics signedness) { … }

::llvm::LogicalResult TestIntegerType::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, unsigned width, ::test::TestIntegerType::SignednessSemantics signedness) { … }

unsigned TestIntegerType::getWidth() const { … }

::test::TestIntegerType::SignednessSemantics TestIntegerType::getSignedness() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestIntegerType)
namespace test {
namespace detail {
struct StructTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
StructType StructType::get(::mlir::MLIRContext *context, ::llvm::ArrayRef<::test::FieldInfo> fields) { … }

::llvm::ArrayRef<::test::FieldInfo> StructType::getFields() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::StructType)
namespace test {
} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestType)
namespace test {
namespace detail {
struct TestTypeWithLayoutTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeWithLayoutType TestTypeWithLayoutType::get(::mlir::MLIRContext *context, unsigned key) { … }

unsigned TestTypeWithLayoutType::getKey() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeWithLayoutType)
namespace test {
} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestMemRefElementTypeType)
namespace test {
} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeWithTraitType)
namespace test {
namespace detail {
struct TestTypeWithFormatTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeWithFormatType TestTypeWithFormatType::get(::mlir::MLIRContext *context, int64_t one, std::string two, ::mlir::Attribute three) { … }

::mlir::Type TestTypeWithFormatType::parse(::mlir::AsmParser &odsParser) { … }

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

int64_t TestTypeWithFormatType::getOne() const { … }

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

::mlir::Attribute TestTypeWithFormatType::getThree() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeWithFormatType)
namespace test {
namespace detail {
struct TestTypeNoParserTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeNoParserType TestTypeNoParserType::get(::mlir::MLIRContext *context, uint32_t one, ::llvm::ArrayRef<int64_t> two, ::llvm::StringRef three, ::test::CustomParam four) { … }

::mlir::Type TestTypeNoParserType::parse(::mlir::AsmParser &odsParser) { … }

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

uint32_t TestTypeNoParserType::getOne() const { … }

::llvm::ArrayRef<int64_t> TestTypeNoParserType::getTwo() const { … }

::llvm::StringRef TestTypeNoParserType::getThree() const { … }

::test::CustomParam TestTypeNoParserType::getFour() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeNoParserType)
namespace test {
namespace detail {
struct TestStructTypeCaptureAllTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestStructTypeCaptureAllType TestStructTypeCaptureAllType::get(::mlir::MLIRContext *context, int v0, int v1, int v2, int v3) { … }

::mlir::Type TestStructTypeCaptureAllType::parse(::mlir::AsmParser &odsParser) { … }

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

int TestStructTypeCaptureAllType::getV0() const { … }

int TestStructTypeCaptureAllType::getV1() const { … }

int TestStructTypeCaptureAllType::getV2() const { … }

int TestStructTypeCaptureAllType::getV3() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestStructTypeCaptureAllType)
namespace test {
namespace detail {
struct TestTypeOptionalParamTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeOptionalParamType TestTypeOptionalParamType::get(::mlir::MLIRContext *context, std::optional<int> a, int b, std::optional<::mlir::Attribute> c) { … }

::mlir::Type TestTypeOptionalParamType::parse(::mlir::AsmParser &odsParser) { … }

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

std::optional<int> TestTypeOptionalParamType::getA() const { … }

int TestTypeOptionalParamType::getB() const { … }

std::optional<::mlir::Attribute> TestTypeOptionalParamType::getC() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeOptionalParamType)
namespace test {
namespace detail {
struct TestTypeOptionalParamsTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeOptionalParamsType TestTypeOptionalParamsType::get(::mlir::MLIRContext *context, std::optional<int> a, ::llvm::StringRef b) { … }

::mlir::Type TestTypeOptionalParamsType::parse(::mlir::AsmParser &odsParser) { … }

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

std::optional<int> TestTypeOptionalParamsType::getA() const { … }

::llvm::StringRef TestTypeOptionalParamsType::getB() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeOptionalParamsType)
namespace test {
namespace detail {
struct TestTypeOptionalParamsAfterRequiredTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeOptionalParamsAfterRequiredType TestTypeOptionalParamsAfterRequiredType::get(::mlir::MLIRContext *context, ::llvm::StringRef a, std::optional<int> b) { … }

::mlir::Type TestTypeOptionalParamsAfterRequiredType::parse(::mlir::AsmParser &odsParser) { … }

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

::llvm::StringRef TestTypeOptionalParamsAfterRequiredType::getA() const { … }

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

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeOptionalParamsAfterRequiredType)
namespace test {
namespace detail {
struct TestTypeOptionalStructTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeOptionalStructType TestTypeOptionalStructType::get(::mlir::MLIRContext *context, std::optional<int> a, ::llvm::StringRef b) { … }

::mlir::Type TestTypeOptionalStructType::parse(::mlir::AsmParser &odsParser) { … }

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

std::optional<int> TestTypeOptionalStructType::getA() const { … }

::llvm::StringRef TestTypeOptionalStructType::getB() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeOptionalStructType)
namespace test {
namespace detail {
struct TestTypeAllOptionalParamsTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeAllOptionalParamsType TestTypeAllOptionalParamsType::get(::mlir::MLIRContext *context, std::optional<int> a, std::optional<int> b) { … }

::mlir::Type TestTypeAllOptionalParamsType::parse(::mlir::AsmParser &odsParser) { … }

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

std::optional<int> TestTypeAllOptionalParamsType::getA() const { … }

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

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeAllOptionalParamsType)
namespace test {
namespace detail {
struct TestTypeAllOptionalStructTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeAllOptionalStructType TestTypeAllOptionalStructType::get(::mlir::MLIRContext *context, std::optional<int> a, std::optional<int> b) { … }

::mlir::Type TestTypeAllOptionalStructType::parse(::mlir::AsmParser &odsParser) { … }

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

std::optional<int> TestTypeAllOptionalStructType::getA() const { … }

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

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeAllOptionalStructType)
namespace test {
namespace detail {
struct TestTypeOptionalGroupTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeOptionalGroupType TestTypeOptionalGroupType::get(::mlir::MLIRContext *context, int a, std::optional<int> b) { … }

::mlir::Type TestTypeOptionalGroupType::parse(::mlir::AsmParser &odsParser) { … }

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

int TestTypeOptionalGroupType::getA() const { … }

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

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeOptionalGroupType)
namespace test {
namespace detail {
struct TestTypeOptionalGroupParamsTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeOptionalGroupParamsType TestTypeOptionalGroupParamsType::get(::mlir::MLIRContext *context, std::optional<int> a, std::optional<int> b) { … }

::mlir::Type TestTypeOptionalGroupParamsType::parse(::mlir::AsmParser &odsParser) { … }

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

std::optional<int> TestTypeOptionalGroupParamsType::getA() const { … }

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

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeOptionalGroupParamsType)
namespace test {
namespace detail {
struct TestTypeOptionalGroupStructTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeOptionalGroupStructType TestTypeOptionalGroupStructType::get(::mlir::MLIRContext *context, std::optional<int> a, std::optional<int> b) { … }

::mlir::Type TestTypeOptionalGroupStructType::parse(::mlir::AsmParser &odsParser) { … }

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

std::optional<int> TestTypeOptionalGroupStructType::getA() const { … }

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

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeOptionalGroupStructType)
namespace test {
namespace detail {
struct TestTypeSpaceSTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeSpaceSType TestTypeSpaceSType::get(::mlir::MLIRContext *context, int a, int b) { … }

::mlir::Type TestTypeSpaceSType::parse(::mlir::AsmParser &odsParser) { … }

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

int TestTypeSpaceSType::getA() const { … }

int TestTypeSpaceSType::getB() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeSpaceSType)
namespace test {
namespace detail {
struct TestTypeAPFloatTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeAPFloatType TestTypeAPFloatType::get(::mlir::MLIRContext *context, llvm::APFloat a) { … }

::mlir::Type TestTypeAPFloatType::parse(::mlir::AsmParser &odsParser) { … }

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

llvm::APFloat TestTypeAPFloatType::getA() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeAPFloatType)
namespace test {
namespace detail {
struct TestTypeOptionalValueTypeTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeOptionalValueTypeType TestTypeOptionalValueTypeType::get(::mlir::MLIRContext *context, std::optional<int> value) { … }

::mlir::Type TestTypeOptionalValueTypeType::parse(::mlir::AsmParser &odsParser) { … }

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

std::optional<int> TestTypeOptionalValueTypeType::getValue() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeOptionalValueTypeType)
namespace test {
namespace detail {
struct TestTypeDefaultValuedTypeTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeDefaultValuedTypeType TestTypeDefaultValuedTypeType::get(::mlir::MLIRContext *context, mlir::IntegerType type) { … }

::mlir::Type TestTypeDefaultValuedTypeType::parse(::mlir::AsmParser &odsParser) { … }

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

mlir::IntegerType TestTypeDefaultValuedTypeType::getType() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeDefaultValuedTypeType)
namespace test {
namespace detail {
struct TestTypeCustomTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeCustomType TestTypeCustomType::get(::mlir::MLIRContext *context, int a, std::optional<int> b) { … }

::mlir::Type TestTypeCustomType::parse(::mlir::AsmParser &odsParser) { … }

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

int TestTypeCustomType::getA() const { … }

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

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeCustomType)
namespace test {
namespace detail {
struct TestTypeCustomSpacingTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeCustomSpacingType TestTypeCustomSpacingType::get(::mlir::MLIRContext *context, int a, int b) { … }

::mlir::Type TestTypeCustomSpacingType::parse(::mlir::AsmParser &odsParser) { … }

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

int TestTypeCustomSpacingType::getA() const { … }

int TestTypeCustomSpacingType::getB() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeCustomSpacingType)
namespace test {
namespace detail {
struct TestTypeCustomStringTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeCustomStringType TestTypeCustomStringType::get(::mlir::MLIRContext *context, ::llvm::StringRef foo) { … }

::mlir::Type TestTypeCustomStringType::parse(::mlir::AsmParser &odsParser) { … }

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

::llvm::StringRef TestTypeCustomStringType::getFoo() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeCustomStringType)
namespace test {
namespace detail {
struct TestTypeOptionalStringTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeOptionalStringType TestTypeOptionalStringType::get(::mlir::MLIRContext *context, ::llvm::StringRef str) { … }

::mlir::Type TestTypeOptionalStringType::parse(::mlir::AsmParser &odsParser) { … }

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

::llvm::StringRef TestTypeOptionalStringType::getStr() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeOptionalStringType)
namespace test {
namespace detail {
struct TestTypeElseAnchorTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeElseAnchorType TestTypeElseAnchorType::get(::mlir::MLIRContext *context, std::optional<int> a) { … }

::mlir::Type TestTypeElseAnchorType::parse(::mlir::AsmParser &odsParser) { … }

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

std::optional<int> TestTypeElseAnchorType::getA() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeElseAnchorType)
namespace test {
namespace detail {
struct TestTypeElseAnchorStructTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeElseAnchorStructType TestTypeElseAnchorStructType::get(::mlir::MLIRContext *context, std::optional<int> a, std::optional<int> b) { … }

::mlir::Type TestTypeElseAnchorStructType::parse(::mlir::AsmParser &odsParser) { … }

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

std::optional<int> TestTypeElseAnchorStructType::getA() const { … }

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

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeElseAnchorStructType)
namespace test {
} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestI32Type)
namespace test {
TestRecursiveAliasType TestRecursiveAliasType::get(::mlir::MLIRContext *context, llvm::StringRef name) { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestRecursiveAliasType)
namespace test {
namespace detail {
struct TestTypeVerificationTypeStorage : public ::mlir::TypeStorage { … };
} // namespace detail
TestTypeVerificationType TestTypeVerificationType::get(::mlir::MLIRContext *context, ::mlir::Type param) { … }

TestTypeVerificationType TestTypeVerificationType::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::mlir::Type param) { … }

::llvm::LogicalResult TestTypeVerificationType::verifyInvariantsImpl(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::Type param) { … }

::llvm::LogicalResult TestTypeVerificationType::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::Type param) { … }

::mlir::Type TestTypeVerificationType::parse(::mlir::AsmParser &odsParser) { … }

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

::mlir::Type TestTypeVerificationType::getParam() const { … }

} // namespace test
MLIR_DEFINE_EXPLICIT_TYPE_ID(::test::TestTypeVerificationType)

#endif  // GET_TYPEDEF_CLASSES
llvm/tools/mlir/test/lib/Dialect/Test/TestTypeDefs.cpp.inc
