llvm/tools/mlir/test/lib/Dialect/Test/TestOpsSyntax.h.inc

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Op Declarations                                                            *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: TestOpsSyntax.td                                                     *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

namespace test {
class CustomFormatFallbackOp;
} // namespace test
namespace test {
class ElseAnchorOp;
} // namespace test
namespace test {
class FormatAllTypesMatchAttrOp;
} // namespace test
namespace test {
class FormatAllTypesMatchVarOp;
} // namespace test
namespace test {
class FormatAttrDictWithKeywordOp;
} // namespace test
namespace test {
class FormatAttrOp;
} // namespace test
namespace test {
class FormatBuildableTypeOp;
} // namespace test
namespace test {
class FormatCompoundAttr;
} // namespace test
namespace test {
class FormatCustomDirectiveAttrDict;
} // namespace test
namespace test {
class FormatCustomDirectiveAttributes;
} // namespace test
namespace test {
class FormatCustomDirectiveOperands;
} // namespace test
namespace test {
class FormatCustomDirectiveOperandsAndTypes;
} // namespace test
namespace test {
class FormatCustomDirectiveRegions;
} // namespace test
namespace test {
class FormatCustomDirectiveResults;
} // namespace test
namespace test {
class FormatCustomDirectiveResultsWithTypeRefs;
} // namespace test
namespace test {
class FormatCustomDirectiveSpacing;
} // namespace test
namespace test {
class FormatCustomDirectiveSuccessors;
} // namespace test
namespace test {
class FormatCustomDirectiveWithOptionalOperandRef;
} // namespace test
namespace test {
class FormatFormatRegionImplicitTerminatorAOp;
} // namespace test
namespace test {
class FormatInferType2Op;
} // namespace test
namespace test {
class FormatInferTypeAllOperandsAndTypesOneOperandOp;
} // namespace test
namespace test {
class FormatInferTypeAllOperandsAndTypesOp;
} // namespace test
namespace test {
class FormatInferTypeAllOperandsAndTypesTwoOperandsOp;
} // namespace test
namespace test {
class FormatInferTypeAllTypesOp;
} // namespace test
namespace test {
class FormatInferTypeOp;
} // namespace test
namespace test {
class FormatInferTypeRegionsOp;
} // namespace test
namespace test {
class FormatInferTypeVariadicOperandsOp;
} // namespace test
namespace test {
class FormatInferVariadicTypeFromNonVariadic;
} // namespace test
namespace test {
class FormatLiteralFollowingOptionalGroup;
} // namespace test
namespace test {
class FormatLiteralOp;
} // namespace test
namespace test {
class FormatMaybeEmptyType;
} // namespace test
namespace test {
class FormatMultipleVariadicOperands;
} // namespace test
namespace test {
class FormatMultipleVariadicResults;
} // namespace test
namespace test {
class FormatNestedAttr;
} // namespace test
namespace test {
class FormatNestedCompoundAttr;
} // namespace test
namespace test {
class FormatNestedType;
} // namespace test
namespace test {
class FormatOperandAOp;
} // namespace test
namespace test {
class FormatOperandBOp;
} // namespace test
namespace test {
class FormatOperandCOp;
} // namespace test
namespace test {
class FormatOperandDOp;
} // namespace test
namespace test {
class FormatOperandEOp;
} // namespace test
namespace test {
class FormatOptAttrAOp;
} // namespace test
namespace test {
class FormatOptAttrBOp;
} // namespace test
namespace test {
class FormatOptSymbolNameAttrOp;
} // namespace test
namespace test {
class FormatOptSymbolRefAttrOp;
} // namespace test
namespace test {
class FormatOptionalDefaultAttrs;
} // namespace test
namespace test {
class FormatOptionalEnumAttr;
} // namespace test
namespace test {
class FormatOptionalOperandResultAOp;
} // namespace test
namespace test {
class FormatOptionalOperandResultBOp;
} // namespace test
namespace test {
class FormatOptionalResultAOp;
} // namespace test
namespace test {
class FormatOptionalResultBOp;
} // namespace test
namespace test {
class FormatOptionalResultCOp;
} // namespace test
namespace test {
class FormatOptionalResultDOp;
} // namespace test
namespace test {
class FormatOptionalUnitAttr;
} // namespace test
namespace test {
class FormatOptionalUnitAttrNoElide;
} // namespace test
namespace test {
class FormatOptionalUnitProperty;
} // namespace test
namespace test {
class FormatOptionalUnitPropertyNoElide;
} // namespace test
namespace test {
class FormatOptionalWithElse;
} // namespace test
namespace test {
class FormatQualifiedCompoundAttr;
} // namespace test
namespace test {
class FormatQualifiedNestedType;
} // namespace test
namespace test {
class FormatRegionAOp;
} // namespace test
namespace test {
class FormatRegionBOp;
} // namespace test
namespace test {
class FormatRegionCOp;
} // namespace test
namespace test {
class FormatResultAOp;
} // namespace test
namespace test {
class FormatResultBOp;
} // namespace test
namespace test {
class FormatResultCOp;
} // namespace test
namespace test {
class FormatSuccessorAOp;
} // namespace test
namespace test {
class FormatSymbolNameAttrOp;
} // namespace test
namespace test {
class FormatTwoVariadicOperandsNoBuildableTypeOp;
} // namespace test
namespace test {
class FormatTypesMatchAttrOp;
} // namespace test
namespace test {
class FormatTypesMatchContextOp;
} // namespace test
namespace test {
class FormatTypesMatchVarOp;
} // namespace test
namespace test {
class FormatTypesMatchVariadicOp;
} // namespace test
namespace test {
class FormatVariadicOfVariadicOperand;
} // namespace test
namespace test {
class FormatVariadicOperand;
} // namespace test
namespace test {
class FormatVariadicRegionAOp;
} // namespace test
namespace test {
class FormatVariadicRegionBOp;
} // namespace test
namespace test {
class FormatVariadicResult;
} // namespace test
namespace test {
class OIListAllowedLiteral;
} // namespace test
namespace test {
class OIListCustom;
} // namespace test
namespace test {
class OIListSimple;
} // namespace test
namespace test {
class OIListTrivial;
} // namespace test
namespace test {
class OIListTrivialProperties;
} // namespace test
namespace test {
class OIListVariadic;
} // namespace test
namespace test {
class OpWithDotInNameOp;
} // namespace test
namespace test {
class PolyForOp;
} // namespace test
namespace test {
class PrettyPrintedRegionOp;
} // namespace test
namespace test {
class TestAttrWithLoc;
} // namespace test
namespace test {
class TestEllipsisOp;
} // namespace test
namespace test {
class WrappingRegionOp;
} // namespace test
#ifdef GET_OP_CLASSES
#undef GET_OP_CLASSES

namespace test {

//===----------------------------------------------------------------------===//
// ::test::CustomFormatFallbackOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class CustomFormatFallbackOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class CustomFormatFallbackOpGenericAdaptor : public detail::CustomFormatFallbackOpGenericAdaptorBase { … };
class CustomFormatFallbackOpAdaptor : public CustomFormatFallbackOpGenericAdaptor<::mlir::ValueRange> { … };
class CustomFormatFallbackOp : public ::mlir::Op<CustomFormatFallbackOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::CustomFormatFallbackOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ElseAnchorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ElseAnchorOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ElseAnchorOpGenericAdaptor : public detail::ElseAnchorOpGenericAdaptorBase { … };
class ElseAnchorOpAdaptor : public ElseAnchorOpGenericAdaptor<::mlir::ValueRange> { … };
class ElseAnchorOp : public ::mlir::Op<ElseAnchorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ElseAnchorOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatAllTypesMatchAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatAllTypesMatchAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatAllTypesMatchAttrOpGenericAdaptor : public detail::FormatAllTypesMatchAttrOpGenericAdaptorBase { … };
class FormatAllTypesMatchAttrOpAdaptor : public FormatAllTypesMatchAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatAllTypesMatchAttrOp : public ::mlir::Op<FormatAllTypesMatchAttrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatAllTypesMatchAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatAllTypesMatchVarOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatAllTypesMatchVarOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatAllTypesMatchVarOpGenericAdaptor : public detail::FormatAllTypesMatchVarOpGenericAdaptorBase { … };
class FormatAllTypesMatchVarOpAdaptor : public FormatAllTypesMatchVarOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatAllTypesMatchVarOp : public ::mlir::Op<FormatAllTypesMatchVarOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatAllTypesMatchVarOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatAttrDictWithKeywordOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatAttrDictWithKeywordOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatAttrDictWithKeywordOpGenericAdaptor : public detail::FormatAttrDictWithKeywordOpGenericAdaptorBase { … };
class FormatAttrDictWithKeywordOpAdaptor : public FormatAttrDictWithKeywordOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatAttrDictWithKeywordOp : public ::mlir::Op<FormatAttrDictWithKeywordOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatAttrDictWithKeywordOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatAttrOpGenericAdaptor : public detail::FormatAttrOpGenericAdaptorBase { … };
class FormatAttrOpAdaptor : public FormatAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatAttrOp : public ::mlir::Op<FormatAttrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatBuildableTypeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatBuildableTypeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatBuildableTypeOpGenericAdaptor : public detail::FormatBuildableTypeOpGenericAdaptorBase { … };
class FormatBuildableTypeOpAdaptor : public FormatBuildableTypeOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatBuildableTypeOp : public ::mlir::Op<FormatBuildableTypeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatBuildableTypeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatCompoundAttr declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatCompoundAttrGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatCompoundAttrGenericAdaptor : public detail::FormatCompoundAttrGenericAdaptorBase { … };
class FormatCompoundAttrAdaptor : public FormatCompoundAttrGenericAdaptor<::mlir::ValueRange> { … };
class FormatCompoundAttr : public ::mlir::Op<FormatCompoundAttr, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatCompoundAttr)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatCustomDirectiveAttrDict declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatCustomDirectiveAttrDictGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatCustomDirectiveAttrDictGenericAdaptor : public detail::FormatCustomDirectiveAttrDictGenericAdaptorBase { … };
class FormatCustomDirectiveAttrDictAdaptor : public FormatCustomDirectiveAttrDictGenericAdaptor<::mlir::ValueRange> { … };
class FormatCustomDirectiveAttrDict : public ::mlir::Op<FormatCustomDirectiveAttrDict, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatCustomDirectiveAttrDict)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatCustomDirectiveAttributes declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatCustomDirectiveAttributesGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatCustomDirectiveAttributesGenericAdaptor : public detail::FormatCustomDirectiveAttributesGenericAdaptorBase { … };
class FormatCustomDirectiveAttributesAdaptor : public FormatCustomDirectiveAttributesGenericAdaptor<::mlir::ValueRange> { … };
class FormatCustomDirectiveAttributes : public ::mlir::Op<FormatCustomDirectiveAttributes, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatCustomDirectiveAttributes)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatCustomDirectiveOperands declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatCustomDirectiveOperandsGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatCustomDirectiveOperandsGenericAdaptor : public detail::FormatCustomDirectiveOperandsGenericAdaptorBase { … };
class FormatCustomDirectiveOperandsAdaptor : public FormatCustomDirectiveOperandsGenericAdaptor<::mlir::ValueRange> { … };
class FormatCustomDirectiveOperands : public ::mlir::Op<FormatCustomDirectiveOperands, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatCustomDirectiveOperands)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatCustomDirectiveOperandsAndTypes declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatCustomDirectiveOperandsAndTypesGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatCustomDirectiveOperandsAndTypesGenericAdaptor : public detail::FormatCustomDirectiveOperandsAndTypesGenericAdaptorBase { … };
class FormatCustomDirectiveOperandsAndTypesAdaptor : public FormatCustomDirectiveOperandsAndTypesGenericAdaptor<::mlir::ValueRange> { … };
class FormatCustomDirectiveOperandsAndTypes : public ::mlir::Op<FormatCustomDirectiveOperandsAndTypes, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatCustomDirectiveOperandsAndTypes)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatCustomDirectiveRegions declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatCustomDirectiveRegionsGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatCustomDirectiveRegionsGenericAdaptor : public detail::FormatCustomDirectiveRegionsGenericAdaptorBase { … };
class FormatCustomDirectiveRegionsAdaptor : public FormatCustomDirectiveRegionsGenericAdaptor<::mlir::ValueRange> { … };
class FormatCustomDirectiveRegions : public ::mlir::Op<FormatCustomDirectiveRegions, ::mlir::OpTrait::AtLeastNRegions<1>::Impl, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatCustomDirectiveRegions)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatCustomDirectiveResults declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatCustomDirectiveResultsGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatCustomDirectiveResultsGenericAdaptor : public detail::FormatCustomDirectiveResultsGenericAdaptorBase { … };
class FormatCustomDirectiveResultsAdaptor : public FormatCustomDirectiveResultsGenericAdaptor<::mlir::ValueRange> { … };
class FormatCustomDirectiveResults : public ::mlir::Op<FormatCustomDirectiveResults, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::AtLeastNResults<1>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::AttrSizedResultSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatCustomDirectiveResults)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatCustomDirectiveResultsWithTypeRefs declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatCustomDirectiveResultsWithTypeRefsGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatCustomDirectiveResultsWithTypeRefsGenericAdaptor : public detail::FormatCustomDirectiveResultsWithTypeRefsGenericAdaptorBase { … };
class FormatCustomDirectiveResultsWithTypeRefsAdaptor : public FormatCustomDirectiveResultsWithTypeRefsGenericAdaptor<::mlir::ValueRange> { … };
class FormatCustomDirectiveResultsWithTypeRefs : public ::mlir::Op<FormatCustomDirectiveResultsWithTypeRefs, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::AtLeastNResults<1>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::AttrSizedResultSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatCustomDirectiveResultsWithTypeRefs)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatCustomDirectiveSpacing declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatCustomDirectiveSpacingGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatCustomDirectiveSpacingGenericAdaptor : public detail::FormatCustomDirectiveSpacingGenericAdaptorBase { … };
class FormatCustomDirectiveSpacingAdaptor : public FormatCustomDirectiveSpacingGenericAdaptor<::mlir::ValueRange> { … };
class FormatCustomDirectiveSpacing : public ::mlir::Op<FormatCustomDirectiveSpacing, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatCustomDirectiveSpacing)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatCustomDirectiveSuccessors declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatCustomDirectiveSuccessorsGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatCustomDirectiveSuccessorsGenericAdaptor : public detail::FormatCustomDirectiveSuccessorsGenericAdaptorBase { … };
class FormatCustomDirectiveSuccessorsAdaptor : public FormatCustomDirectiveSuccessorsGenericAdaptor<::mlir::ValueRange> { … };
class FormatCustomDirectiveSuccessors : public ::mlir::Op<FormatCustomDirectiveSuccessors, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::AtLeastNSuccessors<1>::Impl, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatCustomDirectiveSuccessors)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatCustomDirectiveWithOptionalOperandRef declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatCustomDirectiveWithOptionalOperandRefGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatCustomDirectiveWithOptionalOperandRefGenericAdaptor : public detail::FormatCustomDirectiveWithOptionalOperandRefGenericAdaptorBase { … };
class FormatCustomDirectiveWithOptionalOperandRefAdaptor : public FormatCustomDirectiveWithOptionalOperandRefGenericAdaptor<::mlir::ValueRange> { … };
class FormatCustomDirectiveWithOptionalOperandRef : public ::mlir::Op<FormatCustomDirectiveWithOptionalOperandRef, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatCustomDirectiveWithOptionalOperandRef)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatFormatRegionImplicitTerminatorAOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatFormatRegionImplicitTerminatorAOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatFormatRegionImplicitTerminatorAOpGenericAdaptor : public detail::FormatFormatRegionImplicitTerminatorAOpGenericAdaptorBase { … };
class FormatFormatRegionImplicitTerminatorAOpAdaptor : public FormatFormatRegionImplicitTerminatorAOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatFormatRegionImplicitTerminatorAOp : public ::mlir::Op<FormatFormatRegionImplicitTerminatorAOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<TestReturnOp>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatFormatRegionImplicitTerminatorAOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatInferType2Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatInferType2OpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatInferType2OpGenericAdaptor : public detail::FormatInferType2OpGenericAdaptorBase { … };
class FormatInferType2OpAdaptor : public FormatInferType2OpGenericAdaptor<::mlir::ValueRange> { … };
class FormatInferType2Op : public ::mlir::Op<FormatInferType2Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatInferType2Op)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatInferTypeAllOperandsAndTypesOneOperandOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatInferTypeAllOperandsAndTypesOneOperandOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatInferTypeAllOperandsAndTypesOneOperandOpGenericAdaptor : public detail::FormatInferTypeAllOperandsAndTypesOneOperandOpGenericAdaptorBase { … };
class FormatInferTypeAllOperandsAndTypesOneOperandOpAdaptor : public FormatInferTypeAllOperandsAndTypesOneOperandOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatInferTypeAllOperandsAndTypesOneOperandOp : public ::mlir::Op<FormatInferTypeAllOperandsAndTypesOneOperandOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatInferTypeAllOperandsAndTypesOneOperandOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatInferTypeAllOperandsAndTypesOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatInferTypeAllOperandsAndTypesOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatInferTypeAllOperandsAndTypesOpGenericAdaptor : public detail::FormatInferTypeAllOperandsAndTypesOpGenericAdaptorBase { … };
class FormatInferTypeAllOperandsAndTypesOpAdaptor : public FormatInferTypeAllOperandsAndTypesOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatInferTypeAllOperandsAndTypesOp : public ::mlir::Op<FormatInferTypeAllOperandsAndTypesOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatInferTypeAllOperandsAndTypesOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatInferTypeAllOperandsAndTypesTwoOperandsOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatInferTypeAllOperandsAndTypesTwoOperandsOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatInferTypeAllOperandsAndTypesTwoOperandsOpGenericAdaptor : public detail::FormatInferTypeAllOperandsAndTypesTwoOperandsOpGenericAdaptorBase { … };
class FormatInferTypeAllOperandsAndTypesTwoOperandsOpAdaptor : public FormatInferTypeAllOperandsAndTypesTwoOperandsOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatInferTypeAllOperandsAndTypesTwoOperandsOp : public ::mlir::Op<FormatInferTypeAllOperandsAndTypesTwoOperandsOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatInferTypeAllOperandsAndTypesTwoOperandsOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatInferTypeAllTypesOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatInferTypeAllTypesOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatInferTypeAllTypesOpGenericAdaptor : public detail::FormatInferTypeAllTypesOpGenericAdaptorBase { … };
class FormatInferTypeAllTypesOpAdaptor : public FormatInferTypeAllTypesOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatInferTypeAllTypesOp : public ::mlir::Op<FormatInferTypeAllTypesOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatInferTypeAllTypesOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatInferTypeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatInferTypeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatInferTypeOpGenericAdaptor : public detail::FormatInferTypeOpGenericAdaptorBase { … };
class FormatInferTypeOpAdaptor : public FormatInferTypeOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatInferTypeOp : public ::mlir::Op<FormatInferTypeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatInferTypeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatInferTypeRegionsOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatInferTypeRegionsOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatInferTypeRegionsOpGenericAdaptor : public detail::FormatInferTypeRegionsOpGenericAdaptorBase { … };
class FormatInferTypeRegionsOpAdaptor : public FormatInferTypeRegionsOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatInferTypeRegionsOp : public ::mlir::Op<FormatInferTypeRegionsOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatInferTypeRegionsOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatInferTypeVariadicOperandsOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatInferTypeVariadicOperandsOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatInferTypeVariadicOperandsOpGenericAdaptor : public detail::FormatInferTypeVariadicOperandsOpGenericAdaptorBase { … };
class FormatInferTypeVariadicOperandsOpAdaptor : public FormatInferTypeVariadicOperandsOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatInferTypeVariadicOperandsOp : public ::mlir::Op<FormatInferTypeVariadicOperandsOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatInferTypeVariadicOperandsOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatInferVariadicTypeFromNonVariadic declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatInferVariadicTypeFromNonVariadicGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatInferVariadicTypeFromNonVariadicGenericAdaptor : public detail::FormatInferVariadicTypeFromNonVariadicGenericAdaptorBase { … };
class FormatInferVariadicTypeFromNonVariadicAdaptor : public FormatInferVariadicTypeFromNonVariadicGenericAdaptor<::mlir::ValueRange> { … };
class FormatInferVariadicTypeFromNonVariadic : public ::mlir::Op<FormatInferVariadicTypeFromNonVariadic, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatInferVariadicTypeFromNonVariadic)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatLiteralFollowingOptionalGroup declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatLiteralFollowingOptionalGroupGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatLiteralFollowingOptionalGroupGenericAdaptor : public detail::FormatLiteralFollowingOptionalGroupGenericAdaptorBase { … };
class FormatLiteralFollowingOptionalGroupAdaptor : public FormatLiteralFollowingOptionalGroupGenericAdaptor<::mlir::ValueRange> { … };
class FormatLiteralFollowingOptionalGroup : public ::mlir::Op<FormatLiteralFollowingOptionalGroup, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatLiteralFollowingOptionalGroup)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatLiteralOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatLiteralOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatLiteralOpGenericAdaptor : public detail::FormatLiteralOpGenericAdaptorBase { … };
class FormatLiteralOpAdaptor : public FormatLiteralOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatLiteralOp : public ::mlir::Op<FormatLiteralOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatLiteralOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatMaybeEmptyType declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatMaybeEmptyTypeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatMaybeEmptyTypeGenericAdaptor : public detail::FormatMaybeEmptyTypeGenericAdaptorBase { … };
class FormatMaybeEmptyTypeAdaptor : public FormatMaybeEmptyTypeGenericAdaptor<::mlir::ValueRange> { … };
class FormatMaybeEmptyType : public ::mlir::Op<FormatMaybeEmptyType, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatMaybeEmptyType)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatMultipleVariadicOperands declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatMultipleVariadicOperandsGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatMultipleVariadicOperandsGenericAdaptor : public detail::FormatMultipleVariadicOperandsGenericAdaptorBase { … };
class FormatMultipleVariadicOperandsAdaptor : public FormatMultipleVariadicOperandsGenericAdaptor<::mlir::ValueRange> { … };
class FormatMultipleVariadicOperands : public ::mlir::Op<FormatMultipleVariadicOperands, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatMultipleVariadicOperands)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatMultipleVariadicResults declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatMultipleVariadicResultsGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatMultipleVariadicResultsGenericAdaptor : public detail::FormatMultipleVariadicResultsGenericAdaptorBase { … };
class FormatMultipleVariadicResultsAdaptor : public FormatMultipleVariadicResultsGenericAdaptor<::mlir::ValueRange> { … };
class FormatMultipleVariadicResults : public ::mlir::Op<FormatMultipleVariadicResults, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::AttrSizedResultSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatMultipleVariadicResults)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatNestedAttr declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatNestedAttrGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatNestedAttrGenericAdaptor : public detail::FormatNestedAttrGenericAdaptorBase { … };
class FormatNestedAttrAdaptor : public FormatNestedAttrGenericAdaptor<::mlir::ValueRange> { … };
class FormatNestedAttr : public ::mlir::Op<FormatNestedAttr, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatNestedAttr)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatNestedCompoundAttr declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatNestedCompoundAttrGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatNestedCompoundAttrGenericAdaptor : public detail::FormatNestedCompoundAttrGenericAdaptorBase { … };
class FormatNestedCompoundAttrAdaptor : public FormatNestedCompoundAttrGenericAdaptor<::mlir::ValueRange> { … };
class FormatNestedCompoundAttr : public ::mlir::Op<FormatNestedCompoundAttr, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatNestedCompoundAttr)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatNestedType declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatNestedTypeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatNestedTypeGenericAdaptor : public detail::FormatNestedTypeGenericAdaptorBase { … };
class FormatNestedTypeAdaptor : public FormatNestedTypeGenericAdaptor<::mlir::ValueRange> { … };
class FormatNestedType : public ::mlir::Op<FormatNestedType, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatNestedType)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOperandAOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOperandAOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOperandAOpGenericAdaptor : public detail::FormatOperandAOpGenericAdaptorBase { … };
class FormatOperandAOpAdaptor : public FormatOperandAOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOperandAOp : public ::mlir::Op<FormatOperandAOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOperandAOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOperandBOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOperandBOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOperandBOpGenericAdaptor : public detail::FormatOperandBOpGenericAdaptorBase { … };
class FormatOperandBOpAdaptor : public FormatOperandBOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOperandBOp : public ::mlir::Op<FormatOperandBOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOperandBOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOperandCOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOperandCOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOperandCOpGenericAdaptor : public detail::FormatOperandCOpGenericAdaptorBase { … };
class FormatOperandCOpAdaptor : public FormatOperandCOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOperandCOp : public ::mlir::Op<FormatOperandCOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOperandCOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOperandDOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOperandDOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOperandDOpGenericAdaptor : public detail::FormatOperandDOpGenericAdaptorBase { … };
class FormatOperandDOpAdaptor : public FormatOperandDOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOperandDOp : public ::mlir::Op<FormatOperandDOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOperandDOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOperandEOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOperandEOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOperandEOpGenericAdaptor : public detail::FormatOperandEOpGenericAdaptorBase { … };
class FormatOperandEOpAdaptor : public FormatOperandEOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOperandEOp : public ::mlir::Op<FormatOperandEOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOperandEOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptAttrAOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptAttrAOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptAttrAOpGenericAdaptor : public detail::FormatOptAttrAOpGenericAdaptorBase { … };
class FormatOptAttrAOpAdaptor : public FormatOptAttrAOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptAttrAOp : public ::mlir::Op<FormatOptAttrAOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptAttrAOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptAttrBOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptAttrBOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptAttrBOpGenericAdaptor : public detail::FormatOptAttrBOpGenericAdaptorBase { … };
class FormatOptAttrBOpAdaptor : public FormatOptAttrBOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptAttrBOp : public ::mlir::Op<FormatOptAttrBOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptAttrBOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptSymbolNameAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptSymbolNameAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptSymbolNameAttrOpGenericAdaptor : public detail::FormatOptSymbolNameAttrOpGenericAdaptorBase { … };
class FormatOptSymbolNameAttrOpAdaptor : public FormatOptSymbolNameAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptSymbolNameAttrOp : public ::mlir::Op<FormatOptSymbolNameAttrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptSymbolNameAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptSymbolRefAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptSymbolRefAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptSymbolRefAttrOpGenericAdaptor : public detail::FormatOptSymbolRefAttrOpGenericAdaptorBase { … };
class FormatOptSymbolRefAttrOpAdaptor : public FormatOptSymbolRefAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptSymbolRefAttrOp : public ::mlir::Op<FormatOptSymbolRefAttrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptSymbolRefAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalDefaultAttrs declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalDefaultAttrsGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalDefaultAttrsGenericAdaptor : public detail::FormatOptionalDefaultAttrsGenericAdaptorBase { … };
class FormatOptionalDefaultAttrsAdaptor : public FormatOptionalDefaultAttrsGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalDefaultAttrs : public ::mlir::Op<FormatOptionalDefaultAttrs, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalDefaultAttrs)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalEnumAttr declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalEnumAttrGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalEnumAttrGenericAdaptor : public detail::FormatOptionalEnumAttrGenericAdaptorBase { … };
class FormatOptionalEnumAttrAdaptor : public FormatOptionalEnumAttrGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalEnumAttr : public ::mlir::Op<FormatOptionalEnumAttr, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalEnumAttr)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalOperandResultAOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalOperandResultAOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalOperandResultAOpGenericAdaptor : public detail::FormatOptionalOperandResultAOpGenericAdaptorBase { … };
class FormatOptionalOperandResultAOpAdaptor : public FormatOptionalOperandResultAOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalOperandResultAOp : public ::mlir::Op<FormatOptionalOperandResultAOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalOperandResultAOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalOperandResultBOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalOperandResultBOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalOperandResultBOpGenericAdaptor : public detail::FormatOptionalOperandResultBOpGenericAdaptorBase { … };
class FormatOptionalOperandResultBOpAdaptor : public FormatOptionalOperandResultBOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalOperandResultBOp : public ::mlir::Op<FormatOptionalOperandResultBOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalOperandResultBOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalResultAOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalResultAOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalResultAOpGenericAdaptor : public detail::FormatOptionalResultAOpGenericAdaptorBase { … };
class FormatOptionalResultAOpAdaptor : public FormatOptionalResultAOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalResultAOp : public ::mlir::Op<FormatOptionalResultAOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::AttrSizedResultSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalResultAOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalResultBOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalResultBOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalResultBOpGenericAdaptor : public detail::FormatOptionalResultBOpGenericAdaptorBase { … };
class FormatOptionalResultBOpAdaptor : public FormatOptionalResultBOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalResultBOp : public ::mlir::Op<FormatOptionalResultBOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::AttrSizedResultSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalResultBOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalResultCOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalResultCOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalResultCOpGenericAdaptor : public detail::FormatOptionalResultCOpGenericAdaptorBase { … };
class FormatOptionalResultCOpAdaptor : public FormatOptionalResultCOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalResultCOp : public ::mlir::Op<FormatOptionalResultCOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::AttrSizedResultSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalResultCOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalResultDOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalResultDOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalResultDOpGenericAdaptor : public detail::FormatOptionalResultDOpGenericAdaptorBase { … };
class FormatOptionalResultDOpAdaptor : public FormatOptionalResultDOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalResultDOp : public ::mlir::Op<FormatOptionalResultDOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalResultDOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalUnitAttr declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalUnitAttrGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalUnitAttrGenericAdaptor : public detail::FormatOptionalUnitAttrGenericAdaptorBase { … };
class FormatOptionalUnitAttrAdaptor : public FormatOptionalUnitAttrGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalUnitAttr : public ::mlir::Op<FormatOptionalUnitAttr, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalUnitAttr)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalUnitAttrNoElide declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalUnitAttrNoElideGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalUnitAttrNoElideGenericAdaptor : public detail::FormatOptionalUnitAttrNoElideGenericAdaptorBase { … };
class FormatOptionalUnitAttrNoElideAdaptor : public FormatOptionalUnitAttrNoElideGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalUnitAttrNoElide : public ::mlir::Op<FormatOptionalUnitAttrNoElide, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalUnitAttrNoElide)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalUnitProperty declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalUnitPropertyGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalUnitPropertyGenericAdaptor : public detail::FormatOptionalUnitPropertyGenericAdaptorBase { … };
class FormatOptionalUnitPropertyAdaptor : public FormatOptionalUnitPropertyGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalUnitProperty : public ::mlir::Op<FormatOptionalUnitProperty, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalUnitProperty)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalUnitPropertyNoElide declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalUnitPropertyNoElideGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalUnitPropertyNoElideGenericAdaptor : public detail::FormatOptionalUnitPropertyNoElideGenericAdaptorBase { … };
class FormatOptionalUnitPropertyNoElideAdaptor : public FormatOptionalUnitPropertyNoElideGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalUnitPropertyNoElide : public ::mlir::Op<FormatOptionalUnitPropertyNoElide, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalUnitPropertyNoElide)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatOptionalWithElse declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatOptionalWithElseGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatOptionalWithElseGenericAdaptor : public detail::FormatOptionalWithElseGenericAdaptorBase { … };
class FormatOptionalWithElseAdaptor : public FormatOptionalWithElseGenericAdaptor<::mlir::ValueRange> { … };
class FormatOptionalWithElse : public ::mlir::Op<FormatOptionalWithElse, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatOptionalWithElse)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatQualifiedCompoundAttr declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatQualifiedCompoundAttrGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatQualifiedCompoundAttrGenericAdaptor : public detail::FormatQualifiedCompoundAttrGenericAdaptorBase { … };
class FormatQualifiedCompoundAttrAdaptor : public FormatQualifiedCompoundAttrGenericAdaptor<::mlir::ValueRange> { … };
class FormatQualifiedCompoundAttr : public ::mlir::Op<FormatQualifiedCompoundAttr, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatQualifiedCompoundAttr)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatQualifiedNestedType declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatQualifiedNestedTypeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatQualifiedNestedTypeGenericAdaptor : public detail::FormatQualifiedNestedTypeGenericAdaptorBase { … };
class FormatQualifiedNestedTypeAdaptor : public FormatQualifiedNestedTypeGenericAdaptor<::mlir::ValueRange> { … };
class FormatQualifiedNestedType : public ::mlir::Op<FormatQualifiedNestedType, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatQualifiedNestedType)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatRegionAOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatRegionAOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatRegionAOpGenericAdaptor : public detail::FormatRegionAOpGenericAdaptorBase { … };
class FormatRegionAOpAdaptor : public FormatRegionAOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatRegionAOp : public ::mlir::Op<FormatRegionAOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatRegionAOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatRegionBOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatRegionBOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatRegionBOpGenericAdaptor : public detail::FormatRegionBOpGenericAdaptorBase { … };
class FormatRegionBOpAdaptor : public FormatRegionBOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatRegionBOp : public ::mlir::Op<FormatRegionBOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatRegionBOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatRegionCOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatRegionCOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatRegionCOpGenericAdaptor : public detail::FormatRegionCOpGenericAdaptorBase { … };
class FormatRegionCOpAdaptor : public FormatRegionCOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatRegionCOp : public ::mlir::Op<FormatRegionCOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatRegionCOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatResultAOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatResultAOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatResultAOpGenericAdaptor : public detail::FormatResultAOpGenericAdaptorBase { … };
class FormatResultAOpAdaptor : public FormatResultAOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatResultAOp : public ::mlir::Op<FormatResultAOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatResultAOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatResultBOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatResultBOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatResultBOpGenericAdaptor : public detail::FormatResultBOpGenericAdaptorBase { … };
class FormatResultBOpAdaptor : public FormatResultBOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatResultBOp : public ::mlir::Op<FormatResultBOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatResultBOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatResultCOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatResultCOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatResultCOpGenericAdaptor : public detail::FormatResultCOpGenericAdaptorBase { … };
class FormatResultCOpAdaptor : public FormatResultCOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatResultCOp : public ::mlir::Op<FormatResultCOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatResultCOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatSuccessorAOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatSuccessorAOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatSuccessorAOpGenericAdaptor : public detail::FormatSuccessorAOpGenericAdaptorBase { … };
class FormatSuccessorAOpAdaptor : public FormatSuccessorAOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatSuccessorAOp : public ::mlir::Op<FormatSuccessorAOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::VariadicSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatSuccessorAOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatSymbolNameAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatSymbolNameAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatSymbolNameAttrOpGenericAdaptor : public detail::FormatSymbolNameAttrOpGenericAdaptorBase { … };
class FormatSymbolNameAttrOpAdaptor : public FormatSymbolNameAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatSymbolNameAttrOp : public ::mlir::Op<FormatSymbolNameAttrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatSymbolNameAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatTwoVariadicOperandsNoBuildableTypeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatTwoVariadicOperandsNoBuildableTypeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatTwoVariadicOperandsNoBuildableTypeOpGenericAdaptor : public detail::FormatTwoVariadicOperandsNoBuildableTypeOpGenericAdaptorBase { … };
class FormatTwoVariadicOperandsNoBuildableTypeOpAdaptor : public FormatTwoVariadicOperandsNoBuildableTypeOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatTwoVariadicOperandsNoBuildableTypeOp : public ::mlir::Op<FormatTwoVariadicOperandsNoBuildableTypeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatTwoVariadicOperandsNoBuildableTypeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatTypesMatchAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatTypesMatchAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatTypesMatchAttrOpGenericAdaptor : public detail::FormatTypesMatchAttrOpGenericAdaptorBase { … };
class FormatTypesMatchAttrOpAdaptor : public FormatTypesMatchAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatTypesMatchAttrOp : public ::mlir::Op<FormatTypesMatchAttrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatTypesMatchAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatTypesMatchContextOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatTypesMatchContextOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatTypesMatchContextOpGenericAdaptor : public detail::FormatTypesMatchContextOpGenericAdaptorBase { … };
class FormatTypesMatchContextOpAdaptor : public FormatTypesMatchContextOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatTypesMatchContextOp : public ::mlir::Op<FormatTypesMatchContextOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatTypesMatchContextOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatTypesMatchVarOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatTypesMatchVarOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatTypesMatchVarOpGenericAdaptor : public detail::FormatTypesMatchVarOpGenericAdaptorBase { … };
class FormatTypesMatchVarOpAdaptor : public FormatTypesMatchVarOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatTypesMatchVarOp : public ::mlir::Op<FormatTypesMatchVarOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatTypesMatchVarOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatTypesMatchVariadicOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatTypesMatchVariadicOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FormatTypesMatchVariadicOpGenericAdaptor : public detail::FormatTypesMatchVariadicOpGenericAdaptorBase { … };
class FormatTypesMatchVariadicOpAdaptor : public FormatTypesMatchVariadicOpGenericAdaptor<::mlir::ValueRange> { … };
class FormatTypesMatchVariadicOp : public ::mlir::Op<FormatTypesMatchVariadicOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatTypesMatchVariadicOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FormatVariadicOfVariadicOperand declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FormatVariadicOfVariadicOperandGenericAdaptorBase { … }template <typename RangeT>
class FormatVariadicOfVariadicOperandGenericAdaptor : public detail::FormatVariadicOfVariadicOperandGenericAdaptorBase { … }class FormatVariadicOfVariadicOperandAdaptor : public FormatVariadicOfVariadicOperandGenericAdaptor<::mlir::ValueRange> { … }class FormatVariadicOfVariadicOperand : public ::mlir::Op<FormatVariadicOfVariadicOperand, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatVariadicOfVariadicOperand)class FormatVariadicOperandGenericAdaptorBase { … }template <typename RangeT>
class FormatVariadicOperandGenericAdaptor : public detail::FormatVariadicOperandGenericAdaptorBase { … }class FormatVariadicOperandAdaptor : public FormatVariadicOperandGenericAdaptor<::mlir::ValueRange> { … }class FormatVariadicOperand : public ::mlir::Op<FormatVariadicOperand, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatVariadicOperand)class FormatVariadicRegionAOpGenericAdaptorBase { … }template <typename RangeT>
class FormatVariadicRegionAOpGenericAdaptor : public detail::FormatVariadicRegionAOpGenericAdaptorBase { … }class FormatVariadicRegionAOpAdaptor : public FormatVariadicRegionAOpGenericAdaptor<::mlir::ValueRange> { … }class FormatVariadicRegionAOp : public ::mlir::Op<FormatVariadicRegionAOp, ::mlir::OpTrait::VariadicRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatVariadicRegionAOp)class FormatVariadicRegionBOpGenericAdaptorBase { … }template <typename RangeT>
class FormatVariadicRegionBOpGenericAdaptor : public detail::FormatVariadicRegionBOpGenericAdaptorBase { … }class FormatVariadicRegionBOpAdaptor : public FormatVariadicRegionBOpGenericAdaptor<::mlir::ValueRange> { … }class FormatVariadicRegionBOp : public ::mlir::Op<FormatVariadicRegionBOp, ::mlir::OpTrait::VariadicRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatVariadicRegionBOp)class FormatVariadicResultGenericAdaptorBase { … }template <typename RangeT>
class FormatVariadicResultGenericAdaptor : public detail::FormatVariadicResultGenericAdaptorBase { … }class FormatVariadicResultAdaptor : public FormatVariadicResultGenericAdaptor<::mlir::ValueRange> { … }class FormatVariadicResult : public ::mlir::Op<FormatVariadicResult, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FormatVariadicResult)class OIListAllowedLiteralGenericAdaptorBase { … }template <typename RangeT>
class OIListAllowedLiteralGenericAdaptor : public detail::OIListAllowedLiteralGenericAdaptorBase { … }class OIListAllowedLiteralAdaptor : public OIListAllowedLiteralGenericAdaptor<::mlir::ValueRange> { … }class OIListAllowedLiteral : public ::mlir::Op<OIListAllowedLiteral, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OIListAllowedLiteral)class OIListCustomGenericAdaptorBase { … }template <typename RangeT>
class OIListCustomGenericAdaptor : public detail::OIListCustomGenericAdaptorBase { … }class OIListCustomAdaptor : public OIListCustomGenericAdaptor<::mlir::ValueRange> { … }class OIListCustom : public ::mlir::Op<OIListCustom, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OIListCustom)class OIListSimpleGenericAdaptorBase { … }template <typename RangeT>
class OIListSimpleGenericAdaptor : public detail::OIListSimpleGenericAdaptorBase { … }class OIListSimpleAdaptor : public OIListSimpleGenericAdaptor<::mlir::ValueRange> { … }class OIListSimple : public ::mlir::Op<OIListSimple, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OIListSimple)class OIListTrivialGenericAdaptorBase { … }template <typename RangeT>
class OIListTrivialGenericAdaptor : public detail::OIListTrivialGenericAdaptorBase { … }class OIListTrivialAdaptor : public OIListTrivialGenericAdaptor<::mlir::ValueRange> { … }class OIListTrivial : public ::mlir::Op<OIListTrivial, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OIListTrivial)class OIListTrivialPropertiesGenericAdaptorBase { … }template <typename RangeT>
class OIListTrivialPropertiesGenericAdaptor : public detail::OIListTrivialPropertiesGenericAdaptorBase { … }class OIListTrivialPropertiesAdaptor : public OIListTrivialPropertiesGenericAdaptor<::mlir::ValueRange> { … }class OIListTrivialProperties : public ::mlir::Op<OIListTrivialProperties, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OIListTrivialProperties)class OIListVariadicGenericAdaptorBase { … }template <typename RangeT>
class OIListVariadicGenericAdaptor : public detail::OIListVariadicGenericAdaptorBase { … }class OIListVariadicAdaptor : public OIListVariadicGenericAdaptor<::mlir::ValueRange> { … }class OIListVariadic : public ::mlir::Op<OIListVariadic, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OIListVariadic)class OpWithDotInNameOpGenericAdaptorBase { … }template <typename RangeT>
class OpWithDotInNameOpGenericAdaptor : public detail::OpWithDotInNameOpGenericAdaptorBase { … }class OpWithDotInNameOpAdaptor : public OpWithDotInNameOpGenericAdaptor<::mlir::ValueRange> { … }class OpWithDotInNameOp : public ::mlir::Op<OpWithDotInNameOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpWithDotInNameOp)class PolyForOpGenericAdaptorBase { … }template <typename RangeT>
class PolyForOpGenericAdaptor : public detail::PolyForOpGenericAdaptorBase { … }class PolyForOpAdaptor : public PolyForOpGenericAdaptor<::mlir::ValueRange> { … }class PolyForOp : public ::mlir::Op<PolyForOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::PolyForOp)class PrettyPrintedRegionOpGenericAdaptorBase { … }template <typename RangeT>
class PrettyPrintedRegionOpGenericAdaptor : public detail::PrettyPrintedRegionOpGenericAdaptorBase { … }class PrettyPrintedRegionOpAdaptor : public PrettyPrintedRegionOpGenericAdaptor<::mlir::ValueRange> { … }class PrettyPrintedRegionOp : public ::mlir::Op<PrettyPrintedRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<TestReturnOp>::Impl, ::mlir::OpTrait::OpInvariants> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::PrettyPrintedRegionOp)class TestAttrWithLocGenericAdaptorBase { … }template <typename RangeT>
class TestAttrWithLocGenericAdaptor : public detail::TestAttrWithLocGenericAdaptorBase { … }class TestAttrWithLocAdaptor : public TestAttrWithLocGenericAdaptor<::mlir::ValueRange> { … }class TestAttrWithLoc : public ::mlir::Op<TestAttrWithLoc, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestAttrWithLoc)class TestEllipsisOpGenericAdaptorBase { … }template <typename RangeT>
class TestEllipsisOpGenericAdaptor : public detail::TestEllipsisOpGenericAdaptorBase { … }class TestEllipsisOpAdaptor : public TestEllipsisOpGenericAdaptor<::mlir::ValueRange> { … }class TestEllipsisOp : public ::mlir::Op<TestEllipsisOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestEllipsisOp)class WrappingRegionOpGenericAdaptorBase { … }template <typename RangeT>
class WrappingRegionOpGenericAdaptor : public detail::WrappingRegionOpGenericAdaptorBase { … }class WrappingRegionOpAdaptor : public WrappingRegionOpGenericAdaptor<::mlir::ValueRange> { … }class WrappingRegionOp : public ::mlir::Op<WrappingRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<TestReturnOp>::Impl, ::mlir::OpTrait::OpInvariants> { … }MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::WrappingRegionOp)#endif  // GET_OP_CLASSES