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

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

namespace test {
class AffineScopeOp;
} // namespace test
namespace test {
class AllocaScopeRegionOp;
} // namespace test
namespace test {
class AnotherThreeResultOp;
} // namespace test
namespace test {
class AnotherTwoResultOp;
} // namespace test
namespace test {
class AnyAttrOfOp;
} // namespace test
namespace test {
class AnyCondOp;
} // namespace test
namespace test {
class ArgAndResHaveFixedElementTypesOp;
} // namespace test
namespace test {
class ArrayOfAttrOp;
} // namespace test
namespace test {
class AsmBlockNameOp;
} // namespace test
namespace test {
class AsmDialectInterfaceOp;
} // namespace test
namespace test {
class AsmInterfaceOp;
} // namespace test
namespace test {
class AttrSizedOperandOp;
} // namespace test
namespace test {
class AttrSizedResultCompileTestOp;
} // namespace test
namespace test {
class AttrSizedResultOp;
} // namespace test
namespace test {
class AttrWithTraitOp;
} // namespace test
namespace test {
class BlackHoleOp;
} // namespace test
namespace test {
class BroadcastableOp;
} // namespace test
namespace test {
class BufferBasedOp;
} // namespace test
namespace test {
class ChildOp;
} // namespace test
namespace test {
class ChildWithParentOneOf;
} // namespace test
namespace test {
class CompareOp;
} // namespace test
namespace test {
class ComplexOp;
} // namespace test
namespace test {
class ComplexTensorOp;
} // namespace test
namespace test {
class ConditionallySpeculatableOp;
} // namespace test
namespace test {
class ConfinedDenseArrayAttrOp;
} // namespace test
namespace test {
class ContainingIntPolynomialAttr2Op;
} // namespace test
namespace test {
class ContainingIntPolynomialAttrOp;
} // namespace test
namespace test {
class ConversionCallOp;
} // namespace test
namespace test {
class ConversionFuncOp;
} // namespace test
namespace test {
class CopyOp;
} // namespace test
namespace test {
class CustomDimensionListAttrOp;
} // namespace test
namespace test {
class CustomResultsNameOp;
} // namespace test
namespace test {
class DataLayoutQueryOp;
} // namespace test
namespace test {
class DefaultDialectOp;
} // namespace test
namespace test {
class DenseArrayAttrOp;
} // namespace test
namespace test {
class DenseArrayNonNegativeOp;
} // namespace test
namespace test {
class DenseArrayStrictlyPositiveAttrOp;
} // namespace test
namespace test {
class DerivedTypeAttrOp;
} // namespace test
namespace test {
class ElementwiseMappableOp;
} // namespace test
namespace test {
class FloatAttrOp;
} // namespace test
namespace test {
class FloatElementsAttrOp;
} // namespace test
namespace test {
class FoldToCallOp;
} // namespace test
namespace test {
class ForwardBufferOp;
} // namespace test
namespace test {
class FourEqualsFive;
} // namespace test
namespace test {
class FunctionalRegionOp;
} // namespace test
namespace test {
class GetTupleElementOp;
} // namespace test
namespace test {
class GraphRegionOp;
} // namespace test
namespace test {
class I32ElementsAttrOp;
} // namespace test
namespace test {
class I32EnumAttrOp;
} // namespace test
namespace test {
class I64EnumAttrOp;
} // namespace test
namespace test {
class ILLegalOpA;
} // namespace test
namespace test {
class ILLegalOpB;
} // namespace test
namespace test {
class ILLegalOpC;
} // namespace test
namespace test {
class ILLegalOpD;
} // namespace test
namespace test {
class ILLegalOpE;
} // namespace test
namespace test {
class ILLegalOpF;
} // namespace test
namespace test {
class ILLegalOpG;
} // namespace test
namespace test {
class IfFirstOperandIsNoneThenSoIsSecond;
} // namespace test
namespace test {
class IllegalOpTerminator;
} // namespace test
namespace test {
class IllegalOpWithRegion;
} // namespace test
namespace test {
class IllegalOpWithRegionAnchor;
} // namespace test
namespace test {
class IndexElementsAttrOp;
} // namespace test
namespace test {
class IntAttrOp;
} // namespace test
namespace test {
class IntElementsAttrOp;
} // namespace test
namespace test {
class IntTypesOp;
} // namespace test
namespace test {
class IsolatedGraphRegionOp;
} // namespace test
namespace test {
class IsolatedOneRegionOp;
} // namespace test
namespace test {
class IsolatedRegionOp;
} // namespace test
namespace test {
class IsolatedRegionsOp;
} // namespace test
namespace test {
class LegalOpA;
} // namespace test
namespace test {
class LegalOpB;
} // namespace test
namespace test {
class LegalOpC;
} // namespace test
namespace test {
class LegalOpD;
} // namespace test
namespace test {
class LoopBlockOp;
} // namespace test
namespace test {
class LoopBlockTerminatorOp;
} // namespace test
namespace test {
class MakeTupleOp;
} // namespace test
namespace test {
class ManyArgsOp;
} // namespace test
namespace test {
class MixedNormalVariadicOperandOp;
} // namespace test
namespace test {
class MixedNormalVariadicResults;
} // namespace test
namespace test {
class MixedVOperandInOutI32Op;
} // namespace test
namespace test {
class MixedVOperandOp1;
} // namespace test
namespace test {
class MixedVOperandOp2;
} // namespace test
namespace test {
class MixedVOperandOp3;
} // namespace test
namespace test {
class MixedVOperandOp4;
} // namespace test
namespace test {
class MixedVOperandOp5;
} // namespace test
namespace test {
class MixedVOperandOp6;
} // namespace test
namespace test {
class MixedVResultOp1;
} // namespace test
namespace test {
class MixedVResultOp2;
} // namespace test
namespace test {
class MixedVResultOp3;
} // namespace test
namespace test {
class MultiTensorRankOf;
} // namespace test
namespace test {
class NDTensorOfOp;
} // namespace test
namespace test {
class NestedTupleOp;
} // namespace test
namespace test {
class NeverSpeculatableOp;
} // namespace test
namespace test {
class NonNegIntAttrOp;
} // namespace test
namespace test {
class OneI32ResultOp;
} // namespace test
namespace test {
class OneRegionOp;
} // namespace test
namespace test {
class OneRegionWithOperandsOp;
} // namespace test
namespace test {
class OneRegionWithRecursiveMemoryEffectsOp;
} // namespace test
namespace test {
class OneResultOp1;
} // namespace test
namespace test {
class OneResultOp2;
} // namespace test
namespace test {
class OneResultOp3;
} // namespace test
namespace test {
class OneToTwo;
} // namespace test
namespace test {
class OneVResOneVOperandOp1;
} // namespace test
namespace test {
class OneVResOneVOperandOp2;
} // namespace test
namespace test {
class OpA;
} // namespace test
namespace test {
class OpAllAttrConstraint1;
} // namespace test
namespace test {
class OpAllAttrConstraint2;
} // namespace test
namespace test {
class OpAttrMatch1;
} // namespace test
namespace test {
class OpAttrMatch2;
} // namespace test
namespace test {
class OpAttrMatch3;
} // namespace test
namespace test {
class OpAttrMatch4;
} // namespace test
namespace test {
class OpB;
} // namespace test
namespace test {
class OpC;
} // namespace test
namespace test {
class OpCrashLong;
} // namespace test
namespace test {
class OpCrashShort;
} // namespace test
namespace test {
class OpD;
} // namespace test
namespace test {
class OpE;
} // namespace test
namespace test {
class OpF;
} // namespace test
namespace test {
class OpFuncRef;
} // namespace test
namespace test {
class OpG;
} // namespace test
namespace test {
class OpH;
} // namespace test
namespace test {
class OpI;
} // namespace test
namespace test {
class OpInterleavedOperandAttribute1;
} // namespace test
namespace test {
class OpInterleavedOperandAttribute2;
} // namespace test
namespace test {
class OpJ;
} // namespace test
namespace test {
class OpK;
} // namespace test
namespace test {
class OpM;
} // namespace test
namespace test {
class OpN;
} // namespace test
namespace test {
class OpNativeCodeCall1;
} // namespace test
namespace test {
class OpNativeCodeCall2;
} // namespace test
namespace test {
class OpNativeCodeCall3;
} // namespace test
namespace test {
class OpNativeCodeCall4;
} // namespace test
namespace test {
class OpNativeCodeCall5;
} // namespace test
namespace test {
class OpNativeCodeCall6;
} // namespace test
namespace test {
class OpNativeCodeCall7;
} // namespace test
namespace test {
class OpNonNorm;
} // namespace test
namespace test {
class OpNorm;
} // namespace test
namespace test {
class OpNormRet;
} // namespace test
namespace test {
class OpO;
} // namespace test
namespace test {
class OpP;
} // namespace test
namespace test {
class OpR;
} // namespace test
namespace test {
class OpS;
} // namespace test
namespace test {
class OpSymbolBindingA;
} // namespace test
namespace test {
class OpSymbolBindingB;
} // namespace test
namespace test {
class OpSymbolBindingC;
} // namespace test
namespace test {
class OpSymbolBindingD;
} // namespace test
namespace test {
class OpSymbolBindingNoResult;
} // namespace test
namespace test {
class OpWithBitEnum;
} // namespace test
namespace test {
class OpWithBitEnumVerticalBar;
} // namespace test
namespace test {
class OpWithDataLayoutOp;
} // namespace test
namespace test {
class OpWithEnum;
} // namespace test
namespace test {
class OpWithInferTypeAdaptorInterfaceOp;
} // namespace test
namespace test {
class OpWithInferTypeInterfaceOp;
} // namespace test
namespace test {
class OpWithRefineTypeInterfaceOp;
} // namespace test
namespace test {
class OpWithResultShapeInterfaceOp;
} // namespace test
namespace test {
class OpWithResultShapePerDimInterfaceOp;
} // namespace test
namespace test {
class OpWithShapedTypeInferTypeAdaptorInterfaceOp;
} // namespace test
namespace test {
class OpWithShapedTypeInferTypeInterfaceOp;
} // namespace test
namespace test {
class OpX;
} // namespace test
namespace test {
class OperandRankEqualsResultSize;
} // namespace test
namespace test {
class OperandZeroAndResultHaveSameElementCount;
} // namespace test
namespace test {
class OperandZeroAndResultHaveSameElementType;
} // namespace test
namespace test {
class OperandZeroAndResultHaveSameRank;
} // namespace test
namespace test {
class OperandZeroAndResultHaveSameShape;
} // namespace test
namespace test {
class OperandZeroAndResultHaveSameType;
} // namespace test
namespace test {
class OperandsAndResultHaveSameRank;
} // namespace test
namespace test {
class OperandsHaveSameElementType;
} // namespace test
namespace test {
class OperandsHaveSameRank;
} // namespace test
namespace test {
class OperandsHaveSameType;
} // namespace test
namespace test {
class OptionalCustomAttrOp;
} // namespace test
namespace test {
class ParentOp;
} // namespace test
namespace test {
class ParentOp1;
} // namespace test
namespace test {
class ParseB64BytesOp;
} // namespace test
namespace test {
class ParseIntegerLiteralOp;
} // namespace test
namespace test {
class ParseWrappedKeywordOp;
} // namespace test
namespace test {
class PositiveIntAttrOp;
} // namespace test
namespace test {
class PromisedInterfacesOp;
} // namespace test
namespace test {
class PureOp;
} // namespace test
namespace test {
class RankLessThan2I8F32MemRefOp;
} // namespace test
namespace test {
class RankedIntElementsAttrOp;
} // namespace test
namespace test {
class RankedTensorOp;
} // namespace test
namespace test {
class ReadBufferOp;
} // namespace test
namespace test {
class RecursivelySpeculatableOp;
} // namespace test
namespace test {
class RegionBufferBasedOp;
} // namespace test
namespace test {
class RegionIfOp;
} // namespace test
namespace test {
class RegionIfYieldOp;
} // namespace test
namespace test {
class RegionYieldOp;
} // namespace test
namespace test {
class ReifyBoundOp;
} // namespace test
namespace test {
class ResultHasSameTypeAsAttr;
} // namespace test
namespace test {
class ResultTypeWithTraitOp;
} // namespace test
namespace test {
class SSACFGRegionOp;
} // namespace test
namespace test {
class SameOperandAndResultElementTypeOp;
} // namespace test
namespace test {
class SameOperandAndResultShapeOp;
} // namespace test
namespace test {
class SameOperandAndResultTypeOp;
} // namespace test
namespace test {
class SameOperandElementTypeOp;
} // namespace test
namespace test {
class SameOperandShapeOp;
} // namespace test
namespace test {
class SameOperandsResultType;
} // namespace test
namespace test {
class SideEffectOp;
} // namespace test
namespace test {
class SideEffectWithRegionOp;
} // namespace test
namespace test {
class SingleBlockImplicitTerminatorOp;
} // namespace test
namespace test {
class SingleNoTerminatorCustomAsmOp;
} // namespace test
namespace test {
class SingleNoTerminatorOp;
} // namespace test
namespace test {
class SizedRegionOp;
} // namespace test
namespace test {
class SourceOp;
} // namespace test
namespace test {
class StringAttrPrettyNameOp;
} // namespace test
namespace test {
class StringElementsAttrOp;
} // namespace test
namespace test {
class SymbolOp;
} // namespace test
namespace test {
class SymbolScopeOp;
} // namespace test
namespace test {
class SymbolTableRegionOp;
} // namespace test
namespace test {
class TableGenBuildOp0;
} // namespace test
namespace test {
class TableGenBuildOp1;
} // namespace test
namespace test {
class TableGenBuildOp2;
} // namespace test
namespace test {
class TableGenBuildOp3;
} // namespace test
namespace test {
class TableGenBuildOp4;
} // namespace test
namespace test {
class TableGenBuildOp5;
} // namespace test
namespace test {
class TableGenBuildOp6;
} // namespace test
namespace test {
class TableGenConstant;
} // namespace test
namespace test {
class TakesStaticMemRefOp;
} // namespace test
namespace test {
class TensorBasedOp;
} // namespace test
namespace test {
class TerminatorOp;
} // namespace test
namespace test {
class TestAddIOp;
} // namespace test
namespace test {
class TestAnotherTypeProducerOp;
} // namespace test
namespace test {
class TestBranchOp;
} // namespace test
namespace test {
class TestCSEOfSingleBlockOp;
} // namespace test
namespace test {
class TestCallAndStoreOp;
} // namespace test
namespace test {
class TestCallOnDeviceOp;
} // namespace test
namespace test {
class TestCallOp;
} // namespace test
namespace test {
class TestCastOp;
} // namespace test
namespace test {
class TestCommutative2Op;
} // namespace test
namespace test {
class TestCommutativeOp;
} // namespace test
namespace test {
class TestDefaultAttrPrintOp;
} // namespace test
namespace test {
class TestDefaultStrAttrHasValueOp;
} // namespace test
namespace test {
class TestDefaultStrAttrNoValueOp;
} // namespace test
namespace test {
class TestDestinationStyleOp;
} // namespace test
namespace test {
class TestDialectCanonicalizerOp;
} // namespace test
namespace test {
class TestEffectsOpA;
} // namespace test
namespace test {
class TestEffectsOpB;
} // namespace test
namespace test {
class TestEffectsRead;
} // namespace test
namespace test {
class TestEffectsResult;
} // namespace test
namespace test {
class TestEffectsWrite;
} // namespace test
namespace test {
class TestEitherHelperOpA;
} // namespace test
namespace test {
class TestEitherHelperOpB;
} // namespace test
namespace test {
class TestEitherOpA;
} // namespace test
namespace test {
class TestEitherOpB;
} // namespace test
namespace test {
class TestGraphLoopOp;
} // namespace test
namespace test {
class TestIdempotentTraitBinaryOp;
} // namespace test
namespace test {
class TestIdempotentTraitOp;
} // namespace test
namespace test {
class TestIgnoreArgMatchDstOp;
} // namespace test
namespace test {
class TestIgnoreArgMatchSrcOp;
} // namespace test
namespace test {
class TestIncrementOp;
} // namespace test
namespace test {
class TestInternalBranchOp;
} // namespace test
namespace test {
class TestInvalidOp;
} // namespace test
namespace test {
class TestInvolutionTraitFailingOperationFolderOp;
} // namespace test
namespace test {
class TestInvolutionTraitNoOperationFolderOp;
} // namespace test
namespace test {
class TestInvolutionTraitSuccesfulOperationFolderOp;
} // namespace test
namespace test {
class TestLargeCommutativeOp;
} // namespace test
namespace test {
class TestLinalgConvOp;
} // namespace test
namespace test {
class TestLinalgConvOpNotLinalgOp;
} // namespace test
namespace test {
class TestLinalgFillOp;
} // namespace test
namespace test {
class TestLinalgFillOpNotLinalgOp;
} // namespace test
namespace test {
class TestLocationDstNoResOp;
} // namespace test
namespace test {
class TestLocationDstOp;
} // namespace test
namespace test {
class TestLocationSrcNoResOp;
} // namespace test
namespace test {
class TestLocationSrcOp;
} // namespace test
namespace test {
class TestMergeBlocksOp;
} // namespace test
namespace test {
class TestMultiSlotAlloca;
} // namespace test
namespace test {
class TestNoTerminatorOp;
} // namespace test
namespace test {
class TestOpConstant;
} // namespace test
namespace test {
class TestOpFoldWithFoldAdaptor;
} // namespace test
namespace test {
class TestOpInPlaceFold;
} // namespace test
namespace test {
class TestOpInPlaceFoldAnchor;
} // namespace test
namespace test {
class TestOpInPlaceFoldSuccess;
} // namespace test
namespace test {
class TestOpInPlaceSelfFold;
} // namespace test
namespace test {
class TestOpOptionallyImplementingInterface;
} // namespace test
namespace test {
class TestOpUsingIntPropertyWithWorseBytecode;
} // namespace test
namespace test {
class TestOpUsingPropertyInCustom;
} // namespace test
namespace test {
class TestOpUsingPropertyInCustomAndOther;
} // namespace test
namespace test {
class TestOpUsingPropertyRefInCustom;
} // namespace test
namespace test {
class TestOpWithArrayProperties;
} // namespace test
namespace test {
class TestOpWithDefaultValuedProperties;
} // namespace test
namespace test {
class TestOpWithNiceProperties;
} // namespace test
namespace test {
class TestOpWithOptionalProperties;
} // namespace test
namespace test {
class TestOpWithProperties;
} // namespace test
namespace test {
class TestOpWithPropertiesAndAttr;
} // namespace test
namespace test {
class TestOpWithPropertiesAndInferredType;
} // namespace test
namespace test {
class TestOpWithRegionFold;
} // namespace test
namespace test {
class TestOpWithRegionFoldNoMemoryEffect;
} // namespace test
namespace test {
class TestOpWithRegionPattern;
} // namespace test
namespace test {
class TestOpWithVariadicResultsAndFolder;
} // namespace test
namespace test {
class TestOpWithVersionedProperties;
} // namespace test
namespace test {
class TestOpWithWrappedProperties;
} // namespace test
namespace test {
class TestProducingBranchOp;
} // namespace test
namespace test {
class TestPropOp;
} // namespace test
namespace test {
class TestRecursiveRewriteOp;
} // namespace test
namespace test {
class TestReflectBoundsOp;
} // namespace test
namespace test {
class TestRegionBuilderOp;
} // namespace test
namespace test {
class TestRemappedValueRegionOp;
} // namespace test
namespace test {
class TestReturnOp;
} // namespace test
namespace test {
class TestRewriteOp;
} // namespace test
namespace test {
class TestSignatureConversionNoConverterOp;
} // namespace test
namespace test {
class TestSignatureConversionUndoOp;
} // namespace test
namespace test {
class TestStoreWithALoopRegion;
} // namespace test
namespace test {
class TestStoreWithARegion;
} // namespace test
namespace test {
class TestStoreWithARegionTerminator;
} // namespace test
namespace test {
class TestTypeChangerOp;
} // namespace test
namespace test {
class TestTypeConsumerOp;
} // namespace test
namespace test {
class TestTypeProducerOp;
} // namespace test
namespace test {
class TestValidOp;
} // namespace test
namespace test {
class TestVariadicRewriteDstOp;
} // namespace test
namespace test {
class TestVariadicRewriteSrcOp;
} // namespace test
namespace test {
class TestVerifiersOp;
} // namespace test
namespace test {
class TestVersionedOpA;
} // namespace test
namespace test {
class TestVersionedOpB;
} // namespace test
namespace test {
class TestVersionedOpC;
} // namespace test
namespace test {
class TestWithBoundsOp;
} // namespace test
namespace test {
class TestWithBoundsRegionOp;
} // namespace test
namespace test {
class ThreeResultOp;
} // namespace test
namespace test {
class TupleOp;
} // namespace test
namespace test {
class TwoRegionOp;
} // namespace test
namespace test {
class TwoResultOp;
} // namespace test
namespace test {
class TwoToOne;
} // namespace test
namespace test {
class TypeArrayAttrOp;
} // namespace test
namespace test {
class TypeArrayAttrWithDefaultOp;
} // namespace test
namespace test {
class TypeAttrOfOp;
} // namespace test
namespace test {
class TypeStringAttrWithTypeOp;
} // namespace test
namespace test {
class TypedAttrOp;
} // namespace test
namespace test {
class VariadicNoTerminatorOp;
} // namespace test
namespace test {
class VariadicRegionInferredTypesOp;
} // namespace test
namespace test {
class VariadicWithSameOperandsResult;
} // namespace test
#ifdef GET_OP_CLASSES
#undef GET_OP_CLASSES

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AffineScopeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AffineScopeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AffineScopeOpGenericAdaptor : public detail::AffineScopeOpGenericAdaptorBase { … };
class AffineScopeOpAdaptor : public AffineScopeOpGenericAdaptor<::mlir::ValueRange> { … };
class AffineScopeOp : public ::mlir::Op<AffineScopeOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::AffineScope> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::AffineScopeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AllocaScopeRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AllocaScopeRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AllocaScopeRegionOpGenericAdaptor : public detail::AllocaScopeRegionOpGenericAdaptorBase { … };
class AllocaScopeRegionOpAdaptor : public AllocaScopeRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class AllocaScopeRegionOp : public ::mlir::Op<AllocaScopeRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::AutomaticAllocationScope> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::AllocaScopeRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AnotherThreeResultOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AnotherThreeResultOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AnotherThreeResultOpGenericAdaptor : public detail::AnotherThreeResultOpGenericAdaptorBase { … };
class AnotherThreeResultOpAdaptor : public AnotherThreeResultOpGenericAdaptor<::mlir::ValueRange> { … };
class AnotherThreeResultOp : public ::mlir::Op<AnotherThreeResultOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<3>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::AnotherThreeResultOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AnotherTwoResultOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AnotherTwoResultOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AnotherTwoResultOpGenericAdaptor : public detail::AnotherTwoResultOpGenericAdaptorBase { … };
class AnotherTwoResultOpAdaptor : public AnotherTwoResultOpGenericAdaptor<::mlir::ValueRange> { … };
class AnotherTwoResultOp : public ::mlir::Op<AnotherTwoResultOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::AnotherTwoResultOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AnyAttrOfOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AnyAttrOfOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AnyAttrOfOpGenericAdaptor : public detail::AnyAttrOfOpGenericAdaptorBase { … };
class AnyAttrOfOpAdaptor : public AnyAttrOfOpGenericAdaptor<::mlir::ValueRange> { … };
class AnyAttrOfOp : public ::mlir::Op<AnyAttrOfOp, ::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::AnyAttrOfOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AnyCondOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AnyCondOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AnyCondOpGenericAdaptor : public detail::AnyCondOpGenericAdaptorBase { … };
class AnyCondOpAdaptor : public AnyCondOpGenericAdaptor<::mlir::ValueRange> { … };
class AnyCondOp : public ::mlir::Op<AnyCondOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::RegionBranchOpInterface::Trait, ::mlir::OpTrait::HasRecursiveMemoryEffects> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::AnyCondOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ArgAndResHaveFixedElementTypesOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ArgAndResHaveFixedElementTypesOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ArgAndResHaveFixedElementTypesOpGenericAdaptor : public detail::ArgAndResHaveFixedElementTypesOpGenericAdaptorBase { … };
class ArgAndResHaveFixedElementTypesOpAdaptor : public ArgAndResHaveFixedElementTypesOpGenericAdaptor<::mlir::ValueRange> { … };
class ArgAndResHaveFixedElementTypesOp : public ::mlir::Op<ArgAndResHaveFixedElementTypesOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::ShapedType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ArgAndResHaveFixedElementTypesOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ArrayOfAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ArrayOfAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ArrayOfAttrOpGenericAdaptor : public detail::ArrayOfAttrOpGenericAdaptorBase { … };
class ArrayOfAttrOpAdaptor : public ArrayOfAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class ArrayOfAttrOp : public ::mlir::Op<ArrayOfAttrOp, ::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::ArrayOfAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AsmBlockNameOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AsmBlockNameOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AsmBlockNameOpGenericAdaptor : public detail::AsmBlockNameOpGenericAdaptorBase { … };
class AsmBlockNameOpAdaptor : public AsmBlockNameOpGenericAdaptor<::mlir::ValueRange> { … };
class AsmBlockNameOp : public ::mlir::Op<AsmBlockNameOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::AsmBlockNameOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AsmDialectInterfaceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AsmDialectInterfaceOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AsmDialectInterfaceOpGenericAdaptor : public detail::AsmDialectInterfaceOpGenericAdaptorBase { … };
class AsmDialectInterfaceOpAdaptor : public AsmDialectInterfaceOpGenericAdaptor<::mlir::ValueRange> { … };
class AsmDialectInterfaceOp : public ::mlir::Op<AsmDialectInterfaceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::AsmDialectInterfaceOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AsmInterfaceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AsmInterfaceOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AsmInterfaceOpGenericAdaptor : public detail::AsmInterfaceOpGenericAdaptorBase { … };
class AsmInterfaceOpAdaptor : public AsmInterfaceOpGenericAdaptor<::mlir::ValueRange> { … };
class AsmInterfaceOp : public ::mlir::Op<AsmInterfaceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::AtLeastNResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::AsmInterfaceOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AttrSizedOperandOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AttrSizedOperandOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AttrSizedOperandOpGenericAdaptor : public detail::AttrSizedOperandOpGenericAdaptorBase { … };
class AttrSizedOperandOpAdaptor : public AttrSizedOperandOpGenericAdaptor<::mlir::ValueRange> { … };
class AttrSizedOperandOp : public ::mlir::Op<AttrSizedOperandOp, ::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::AttrSizedOperandOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AttrSizedResultCompileTestOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AttrSizedResultCompileTestOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AttrSizedResultCompileTestOpGenericAdaptor : public detail::AttrSizedResultCompileTestOpGenericAdaptorBase { … };
class AttrSizedResultCompileTestOpAdaptor : public AttrSizedResultCompileTestOpGenericAdaptor<::mlir::ValueRange> { … };
class AttrSizedResultCompileTestOp : public ::mlir::Op<AttrSizedResultCompileTestOp, ::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::AttrSizedResultCompileTestOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AttrSizedResultOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AttrSizedResultOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AttrSizedResultOpGenericAdaptor : public detail::AttrSizedResultOpGenericAdaptorBase { … };
class AttrSizedResultOpAdaptor : public AttrSizedResultOpGenericAdaptor<::mlir::ValueRange> { … };
class AttrSizedResultOp : public ::mlir::Op<AttrSizedResultOp, ::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::AttrSizedResultOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::AttrWithTraitOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class AttrWithTraitOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class AttrWithTraitOpGenericAdaptor : public detail::AttrWithTraitOpGenericAdaptorBase { … };
class AttrWithTraitOpAdaptor : public AttrWithTraitOpGenericAdaptor<::mlir::ValueRange> { … };
class AttrWithTraitOp : public ::mlir::Op<AttrWithTraitOp, ::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::AttrWithTraitOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::BlackHoleOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class BlackHoleOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class BlackHoleOpGenericAdaptor : public detail::BlackHoleOpGenericAdaptorBase { … };
class BlackHoleOpAdaptor : public BlackHoleOpGenericAdaptor<::mlir::ValueRange> { … };
class BlackHoleOp : public ::mlir::Op<BlackHoleOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::BlackHoleOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::BroadcastableOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class BroadcastableOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class BroadcastableOpGenericAdaptor : public detail::BroadcastableOpGenericAdaptorBase { … };
class BroadcastableOpAdaptor : public BroadcastableOpGenericAdaptor<::mlir::ValueRange> { … };
class BroadcastableOp : public ::mlir::Op<BroadcastableOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::TensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::ResultsBroadcastableShape> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::BroadcastableOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::BufferBasedOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class BufferBasedOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class BufferBasedOpGenericAdaptor : public detail::BufferBasedOpGenericAdaptorBase { … };
class BufferBasedOpAdaptor : public BufferBasedOpGenericAdaptor<::mlir::ValueRange> { … };
class BufferBasedOp : public ::mlir::Op<BufferBasedOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::BufferBasedOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ChildOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ChildOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ChildOpGenericAdaptor : public detail::ChildOpGenericAdaptorBase { … };
class ChildOpAdaptor : public ChildOpGenericAdaptor<::mlir::ValueRange> { … };
class ChildOp : public ::mlir::Op<ChildOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::HasParent<ParentOp>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ChildOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ChildWithParentOneOf declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ChildWithParentOneOfGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ChildWithParentOneOfGenericAdaptor : public detail::ChildWithParentOneOfGenericAdaptorBase { … };
class ChildWithParentOneOfAdaptor : public ChildWithParentOneOfGenericAdaptor<::mlir::ValueRange> { … };
class ChildWithParentOneOf : public ::mlir::Op<ChildWithParentOneOf, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::HasParent<ParentOp, ParentOp1>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ChildWithParentOneOf)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::CompareOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class CompareOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class CompareOpGenericAdaptor : public detail::CompareOpGenericAdaptorBase { … };
class CompareOpAdaptor : public CompareOpGenericAdaptor<::mlir::ValueRange> { … };
class CompareOp : public ::mlir::Op<CompareOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::CompareOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ComplexOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ComplexOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ComplexOpGenericAdaptor : public detail::ComplexOpGenericAdaptorBase { … };
class ComplexOpAdaptor : public ComplexOpGenericAdaptor<::mlir::ValueRange> { … };
class ComplexOp : public ::mlir::Op<ComplexOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::ComplexType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ComplexOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ComplexTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ComplexTensorOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ComplexTensorOpGenericAdaptor : public detail::ComplexTensorOpGenericAdaptorBase { … };
class ComplexTensorOpAdaptor : public ComplexTensorOpGenericAdaptor<::mlir::ValueRange> { … };
class ComplexTensorOp : public ::mlir::Op<ComplexTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::TensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ComplexTensorOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ConditionallySpeculatableOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ConditionallySpeculatableOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ConditionallySpeculatableOpGenericAdaptor : public detail::ConditionallySpeculatableOpGenericAdaptorBase { … };
class ConditionallySpeculatableOpAdaptor : public ConditionallySpeculatableOpGenericAdaptor<::mlir::ValueRange> { … };
class ConditionallySpeculatableOp : public ::mlir::Op<ConditionallySpeculatableOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ConditionallySpeculatableOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ConfinedDenseArrayAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ConfinedDenseArrayAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ConfinedDenseArrayAttrOpGenericAdaptor : public detail::ConfinedDenseArrayAttrOpGenericAdaptorBase { … };
class ConfinedDenseArrayAttrOpAdaptor : public ConfinedDenseArrayAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class ConfinedDenseArrayAttrOp : public ::mlir::Op<ConfinedDenseArrayAttrOp, ::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::ConfinedDenseArrayAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ContainingIntPolynomialAttr2Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ContainingIntPolynomialAttr2OpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ContainingIntPolynomialAttr2OpGenericAdaptor : public detail::ContainingIntPolynomialAttr2OpGenericAdaptorBase { … };
class ContainingIntPolynomialAttr2OpAdaptor : public ContainingIntPolynomialAttr2OpGenericAdaptor<::mlir::ValueRange> { … };
class ContainingIntPolynomialAttr2Op : public ::mlir::Op<ContainingIntPolynomialAttr2Op, ::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::ContainingIntPolynomialAttr2Op)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ContainingIntPolynomialAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ContainingIntPolynomialAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ContainingIntPolynomialAttrOpGenericAdaptor : public detail::ContainingIntPolynomialAttrOpGenericAdaptorBase { … };
class ContainingIntPolynomialAttrOpAdaptor : public ContainingIntPolynomialAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class ContainingIntPolynomialAttrOp : public ::mlir::Op<ContainingIntPolynomialAttrOp, ::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::ContainingIntPolynomialAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ConversionCallOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ConversionCallOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ConversionCallOpGenericAdaptor : public detail::ConversionCallOpGenericAdaptorBase { … };
class ConversionCallOpAdaptor : public ConversionCallOpGenericAdaptor<::mlir::ValueRange> { … };
class ConversionCallOp : public ::mlir::Op<ConversionCallOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::CallOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ConversionCallOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ConversionFuncOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ConversionFuncOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ConversionFuncOpGenericAdaptor : public detail::ConversionFuncOpGenericAdaptorBase { … };
class ConversionFuncOpAdaptor : public ConversionFuncOpGenericAdaptor<::mlir::ValueRange> { … };
class ConversionFuncOp : public ::mlir::Op<ConversionFuncOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::SymbolOpInterface::Trait, ::mlir::CallableOpInterface::Trait, ::mlir::FunctionOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ConversionFuncOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::CopyOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class CopyOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class CopyOpGenericAdaptor : public detail::CopyOpGenericAdaptorBase { … };
class CopyOpAdaptor : public CopyOpGenericAdaptor<::mlir::ValueRange> { … };
class CopyOp : public ::mlir::Op<CopyOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::CopyOpInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::CopyOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::CustomDimensionListAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class CustomDimensionListAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class CustomDimensionListAttrOpGenericAdaptor : public detail::CustomDimensionListAttrOpGenericAdaptorBase { … };
class CustomDimensionListAttrOpAdaptor : public CustomDimensionListAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class CustomDimensionListAttrOp : public ::mlir::Op<CustomDimensionListAttrOp, ::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::CustomDimensionListAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::CustomResultsNameOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class CustomResultsNameOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class CustomResultsNameOpGenericAdaptor : public detail::CustomResultsNameOpGenericAdaptorBase { … };
class CustomResultsNameOpAdaptor : public CustomResultsNameOpGenericAdaptor<::mlir::ValueRange> { … };
class CustomResultsNameOp : public ::mlir::Op<CustomResultsNameOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::CustomResultsNameOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::DataLayoutQueryOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class DataLayoutQueryOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class DataLayoutQueryOpGenericAdaptor : public detail::DataLayoutQueryOpGenericAdaptorBase { … };
class DataLayoutQueryOpAdaptor : public DataLayoutQueryOpGenericAdaptor<::mlir::ValueRange> { … };
class DataLayoutQueryOp : public ::mlir::Op<DataLayoutQueryOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::DataLayoutQueryOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::DefaultDialectOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class DefaultDialectOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class DefaultDialectOpGenericAdaptor : public detail::DefaultDialectOpGenericAdaptorBase { … };
class DefaultDialectOpAdaptor : public DefaultDialectOpGenericAdaptor<::mlir::ValueRange> { … };
class DefaultDialectOp : public ::mlir::Op<DefaultDialectOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::DefaultDialectOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::DenseArrayAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class DenseArrayAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class DenseArrayAttrOpGenericAdaptor : public detail::DenseArrayAttrOpGenericAdaptorBase { … };
class DenseArrayAttrOpAdaptor : public DenseArrayAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class DenseArrayAttrOp : public ::mlir::Op<DenseArrayAttrOp, ::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::DenseArrayAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::DenseArrayNonNegativeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class DenseArrayNonNegativeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class DenseArrayNonNegativeOpGenericAdaptor : public detail::DenseArrayNonNegativeOpGenericAdaptorBase { … };
class DenseArrayNonNegativeOpAdaptor : public DenseArrayNonNegativeOpGenericAdaptor<::mlir::ValueRange> { … };
class DenseArrayNonNegativeOp : public ::mlir::Op<DenseArrayNonNegativeOp, ::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::DenseArrayNonNegativeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::DenseArrayStrictlyPositiveAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class DenseArrayStrictlyPositiveAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class DenseArrayStrictlyPositiveAttrOpGenericAdaptor : public detail::DenseArrayStrictlyPositiveAttrOpGenericAdaptorBase { … };
class DenseArrayStrictlyPositiveAttrOpAdaptor : public DenseArrayStrictlyPositiveAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class DenseArrayStrictlyPositiveAttrOp : public ::mlir::Op<DenseArrayStrictlyPositiveAttrOp, ::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::DenseArrayStrictlyPositiveAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::DerivedTypeAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class DerivedTypeAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class DerivedTypeAttrOpGenericAdaptor : public detail::DerivedTypeAttrOpGenericAdaptorBase { … };
class DerivedTypeAttrOpAdaptor : public DerivedTypeAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class DerivedTypeAttrOp : public ::mlir::Op<DerivedTypeAttrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::TensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::DerivedAttributeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::DerivedTypeAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ElementwiseMappableOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ElementwiseMappableOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ElementwiseMappableOpGenericAdaptor : public detail::ElementwiseMappableOpGenericAdaptorBase { … };
class ElementwiseMappableOpAdaptor : public ElementwiseMappableOpGenericAdaptor<::mlir::ValueRange> { … };
class ElementwiseMappableOp : public ::mlir::Op<ElementwiseMappableOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::Elementwise, ::mlir::OpTrait::Scalarizable, ::mlir::OpTrait::Vectorizable, ::mlir::OpTrait::Tensorizable> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ElementwiseMappableOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FloatAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FloatAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FloatAttrOpGenericAdaptor : public detail::FloatAttrOpGenericAdaptorBase { … };
class FloatAttrOpAdaptor : public FloatAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class FloatAttrOp : public ::mlir::Op<FloatAttrOp, ::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::FloatAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FloatElementsAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FloatElementsAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FloatElementsAttrOpGenericAdaptor : public detail::FloatElementsAttrOpGenericAdaptorBase { … };
class FloatElementsAttrOpAdaptor : public FloatElementsAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class FloatElementsAttrOp : public ::mlir::Op<FloatElementsAttrOp, ::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::FloatElementsAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FoldToCallOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FoldToCallOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FoldToCallOpGenericAdaptor : public detail::FoldToCallOpGenericAdaptorBase { … };
class FoldToCallOpAdaptor : public FoldToCallOpGenericAdaptor<::mlir::ValueRange> { … };
class FoldToCallOp : public ::mlir::Op<FoldToCallOp, ::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::FoldToCallOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ForwardBufferOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ForwardBufferOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ForwardBufferOpGenericAdaptor : public detail::ForwardBufferOpGenericAdaptorBase { … };
class ForwardBufferOpAdaptor : public ForwardBufferOpGenericAdaptor<::mlir::ValueRange> { … };
class ForwardBufferOp : public ::mlir::Op<ForwardBufferOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::BaseMemRefType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ForwardBufferOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FourEqualsFive declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FourEqualsFiveGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FourEqualsFiveGenericAdaptor : public detail::FourEqualsFiveGenericAdaptorBase { … };
class FourEqualsFiveAdaptor : public FourEqualsFiveGenericAdaptor<::mlir::ValueRange> { … };
class FourEqualsFive : public ::mlir::Op<FourEqualsFive, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FourEqualsFive)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::FunctionalRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class FunctionalRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class FunctionalRegionOpGenericAdaptor : public detail::FunctionalRegionOpGenericAdaptorBase { … };
class FunctionalRegionOpAdaptor : public FunctionalRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class FunctionalRegionOp : public ::mlir::Op<FunctionalRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::FunctionType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::CallableOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::FunctionalRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::GetTupleElementOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class GetTupleElementOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class GetTupleElementOpGenericAdaptor : public detail::GetTupleElementOpGenericAdaptorBase { … };
class GetTupleElementOpAdaptor : public GetTupleElementOpGenericAdaptor<::mlir::ValueRange> { … };
class GetTupleElementOp : public ::mlir::Op<GetTupleElementOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::GetTupleElementOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::GraphRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class GraphRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class GraphRegionOpGenericAdaptor : public detail::GraphRegionOpGenericAdaptorBase { … };
class GraphRegionOpAdaptor : public GraphRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class GraphRegionOp : public ::mlir::Op<GraphRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::RegionKindInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::GraphRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::I32ElementsAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class I32ElementsAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class I32ElementsAttrOpGenericAdaptor : public detail::I32ElementsAttrOpGenericAdaptorBase { … };
class I32ElementsAttrOpAdaptor : public I32ElementsAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class I32ElementsAttrOp : public ::mlir::Op<I32ElementsAttrOp, ::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::I32ElementsAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::I32EnumAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class I32EnumAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class I32EnumAttrOpGenericAdaptor : public detail::I32EnumAttrOpGenericAdaptorBase { … };
class I32EnumAttrOpAdaptor : public I32EnumAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class I32EnumAttrOp : public ::mlir::Op<I32EnumAttrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::I32EnumAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::I64EnumAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class I64EnumAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class I64EnumAttrOpGenericAdaptor : public detail::I64EnumAttrOpGenericAdaptorBase { … };
class I64EnumAttrOpAdaptor : public I64EnumAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class I64EnumAttrOp : public ::mlir::Op<I64EnumAttrOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::I64EnumAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ILLegalOpA declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ILLegalOpAGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ILLegalOpAGenericAdaptor : public detail::ILLegalOpAGenericAdaptorBase { … };
class ILLegalOpAAdaptor : public ILLegalOpAGenericAdaptor<::mlir::ValueRange> { … };
class ILLegalOpA : public ::mlir::Op<ILLegalOpA, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ILLegalOpA)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ILLegalOpB declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ILLegalOpBGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ILLegalOpBGenericAdaptor : public detail::ILLegalOpBGenericAdaptorBase { … };
class ILLegalOpBAdaptor : public ILLegalOpBGenericAdaptor<::mlir::ValueRange> { … };
class ILLegalOpB : public ::mlir::Op<ILLegalOpB, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ILLegalOpB)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ILLegalOpC declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ILLegalOpCGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ILLegalOpCGenericAdaptor : public detail::ILLegalOpCGenericAdaptorBase { … };
class ILLegalOpCAdaptor : public ILLegalOpCGenericAdaptor<::mlir::ValueRange> { … };
class ILLegalOpC : public ::mlir::Op<ILLegalOpC, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ILLegalOpC)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ILLegalOpD declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ILLegalOpDGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ILLegalOpDGenericAdaptor : public detail::ILLegalOpDGenericAdaptorBase { … };
class ILLegalOpDAdaptor : public ILLegalOpDGenericAdaptor<::mlir::ValueRange> { … };
class ILLegalOpD : public ::mlir::Op<ILLegalOpD, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ILLegalOpD)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ILLegalOpE declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ILLegalOpEGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ILLegalOpEGenericAdaptor : public detail::ILLegalOpEGenericAdaptorBase { … };
class ILLegalOpEAdaptor : public ILLegalOpEGenericAdaptor<::mlir::ValueRange> { … };
class ILLegalOpE : public ::mlir::Op<ILLegalOpE, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ILLegalOpE)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ILLegalOpF declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ILLegalOpFGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ILLegalOpFGenericAdaptor : public detail::ILLegalOpFGenericAdaptorBase { … };
class ILLegalOpFAdaptor : public ILLegalOpFGenericAdaptor<::mlir::ValueRange> { … };
class ILLegalOpF : public ::mlir::Op<ILLegalOpF, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ILLegalOpF)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ILLegalOpG declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ILLegalOpGGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ILLegalOpGGenericAdaptor : public detail::ILLegalOpGGenericAdaptorBase { … };
class ILLegalOpGAdaptor : public ILLegalOpGGenericAdaptor<::mlir::ValueRange> { … };
class ILLegalOpG : public ::mlir::Op<ILLegalOpG, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ILLegalOpG)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IfFirstOperandIsNoneThenSoIsSecond declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IfFirstOperandIsNoneThenSoIsSecondGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IfFirstOperandIsNoneThenSoIsSecondGenericAdaptor : public detail::IfFirstOperandIsNoneThenSoIsSecondGenericAdaptorBase { … };
class IfFirstOperandIsNoneThenSoIsSecondAdaptor : public IfFirstOperandIsNoneThenSoIsSecondGenericAdaptor<::mlir::ValueRange> { … };
class IfFirstOperandIsNoneThenSoIsSecond : public ::mlir::Op<IfFirstOperandIsNoneThenSoIsSecond, ::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::IfFirstOperandIsNoneThenSoIsSecond)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IllegalOpTerminator declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IllegalOpTerminatorGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IllegalOpTerminatorGenericAdaptor : public detail::IllegalOpTerminatorGenericAdaptorBase { … };
class IllegalOpTerminatorAdaptor : public IllegalOpTerminatorGenericAdaptor<::mlir::ValueRange> { … };
class IllegalOpTerminator : public ::mlir::Op<IllegalOpTerminator, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::IllegalOpTerminator)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IllegalOpWithRegion declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IllegalOpWithRegionGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IllegalOpWithRegionGenericAdaptor : public detail::IllegalOpWithRegionGenericAdaptorBase { … };
class IllegalOpWithRegionAdaptor : public IllegalOpWithRegionGenericAdaptor<::mlir::ValueRange> { … };
class IllegalOpWithRegion : public ::mlir::Op<IllegalOpWithRegion, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::IllegalOpWithRegion)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IllegalOpWithRegionAnchor declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IllegalOpWithRegionAnchorGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IllegalOpWithRegionAnchorGenericAdaptor : public detail::IllegalOpWithRegionAnchorGenericAdaptorBase { … };
class IllegalOpWithRegionAnchorAdaptor : public IllegalOpWithRegionAnchorGenericAdaptor<::mlir::ValueRange> { … };
class IllegalOpWithRegionAnchor : public ::mlir::Op<IllegalOpWithRegionAnchor, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::IllegalOpWithRegionAnchor)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IndexElementsAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IndexElementsAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IndexElementsAttrOpGenericAdaptor : public detail::IndexElementsAttrOpGenericAdaptorBase { … };
class IndexElementsAttrOpAdaptor : public IndexElementsAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class IndexElementsAttrOp : public ::mlir::Op<IndexElementsAttrOp, ::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::IndexElementsAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IntAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IntAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IntAttrOpGenericAdaptor : public detail::IntAttrOpGenericAdaptorBase { … };
class IntAttrOpAdaptor : public IntAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class IntAttrOp : public ::mlir::Op<IntAttrOp, ::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::IntAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IntElementsAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IntElementsAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IntElementsAttrOpGenericAdaptor : public detail::IntElementsAttrOpGenericAdaptorBase { … };
class IntElementsAttrOpAdaptor : public IntElementsAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class IntElementsAttrOp : public ::mlir::Op<IntElementsAttrOp, ::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::IntElementsAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IntTypesOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IntTypesOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IntTypesOpGenericAdaptor : public detail::IntTypesOpGenericAdaptorBase { … };
class IntTypesOpAdaptor : public IntTypesOpGenericAdaptor<::mlir::ValueRange> { … };
class IntTypesOp : public ::mlir::Op<IntTypesOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<4>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::IntTypesOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IsolatedGraphRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IsolatedGraphRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IsolatedGraphRegionOpGenericAdaptor : public detail::IsolatedGraphRegionOpGenericAdaptorBase { … };
class IsolatedGraphRegionOpAdaptor : public IsolatedGraphRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class IsolatedGraphRegionOp : public ::mlir::Op<IsolatedGraphRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::RegionKindInterface::Trait, ::mlir::OpTrait::IsIsolatedFromAbove> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::IsolatedGraphRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IsolatedOneRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IsolatedOneRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IsolatedOneRegionOpGenericAdaptor : public detail::IsolatedOneRegionOpGenericAdaptorBase { … };
class IsolatedOneRegionOpAdaptor : public IsolatedOneRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class IsolatedOneRegionOp : public ::mlir::Op<IsolatedOneRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsIsolatedFromAbove> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::IsolatedOneRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IsolatedRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IsolatedRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IsolatedRegionOpGenericAdaptor : public detail::IsolatedRegionOpGenericAdaptorBase { … };
class IsolatedRegionOpAdaptor : public IsolatedRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class IsolatedRegionOp : public ::mlir::Op<IsolatedRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsIsolatedFromAbove> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::IsolatedRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::IsolatedRegionsOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class IsolatedRegionsOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class IsolatedRegionsOpGenericAdaptor : public detail::IsolatedRegionsOpGenericAdaptorBase { … };
class IsolatedRegionsOpAdaptor : public IsolatedRegionsOpGenericAdaptor<::mlir::ValueRange> { … };
class IsolatedRegionsOp : public ::mlir::Op<IsolatedRegionsOp, ::mlir::OpTrait::VariadicRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsIsolatedFromAbove> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::IsolatedRegionsOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::LegalOpA declarations
//===----------------------------------------------------------------------===//

namespace detail {
class LegalOpAGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class LegalOpAGenericAdaptor : public detail::LegalOpAGenericAdaptorBase { … };
class LegalOpAAdaptor : public LegalOpAGenericAdaptor<::mlir::ValueRange> { … };
class LegalOpA : public ::mlir::Op<LegalOpA, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::LegalOpA)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::LegalOpB declarations
//===----------------------------------------------------------------------===//

namespace detail {
class LegalOpBGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class LegalOpBGenericAdaptor : public detail::LegalOpBGenericAdaptorBase { … };
class LegalOpBAdaptor : public LegalOpBGenericAdaptor<::mlir::ValueRange> { … };
class LegalOpB : public ::mlir::Op<LegalOpB, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::LegalOpB)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::LegalOpC declarations
//===----------------------------------------------------------------------===//

namespace detail {
class LegalOpCGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class LegalOpCGenericAdaptor : public detail::LegalOpCGenericAdaptorBase { … };
class LegalOpCAdaptor : public LegalOpCGenericAdaptor<::mlir::ValueRange> { … };
class LegalOpC : public ::mlir::Op<LegalOpC, ::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::LegalOpC)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::LegalOpD declarations
//===----------------------------------------------------------------------===//

namespace detail {
class LegalOpDGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class LegalOpDGenericAdaptor : public detail::LegalOpDGenericAdaptorBase { … };
class LegalOpDAdaptor : public LegalOpDGenericAdaptor<::mlir::ValueRange> { … };
class LegalOpD : public ::mlir::Op<LegalOpD, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::LegalOpD)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::LoopBlockOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class LoopBlockOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class LoopBlockOpGenericAdaptor : public detail::LoopBlockOpGenericAdaptorBase { … };
class LoopBlockOpAdaptor : public LoopBlockOpGenericAdaptor<::mlir::ValueRange> { … };
class LoopBlockOp : public ::mlir::Op<LoopBlockOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::FloatType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::RegionBranchOpInterface::Trait, ::mlir::OpTrait::HasRecursiveMemoryEffects, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::LoopBlockOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::LoopBlockTerminatorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class LoopBlockTerminatorOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class LoopBlockTerminatorOpGenericAdaptor : public detail::LoopBlockTerminatorOpGenericAdaptorBase { … };
class LoopBlockTerminatorOpAdaptor : public LoopBlockTerminatorOpGenericAdaptor<::mlir::ValueRange> { … };
class LoopBlockTerminatorOp : public ::mlir::Op<LoopBlockTerminatorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::RegionBranchTerminatorOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::LoopBlockTerminatorOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MakeTupleOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MakeTupleOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MakeTupleOpGenericAdaptor : public detail::MakeTupleOpGenericAdaptorBase { … };
class MakeTupleOpAdaptor : public MakeTupleOpGenericAdaptor<::mlir::ValueRange> { … };
class MakeTupleOp : public ::mlir::Op<MakeTupleOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MakeTupleOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ManyArgsOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ManyArgsOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ManyArgsOpGenericAdaptor : public detail::ManyArgsOpGenericAdaptorBase { … };
class ManyArgsOpAdaptor : public ManyArgsOpGenericAdaptor<::mlir::ValueRange> { … };
class ManyArgsOp : public ::mlir::Op<ManyArgsOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<9>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ManyArgsOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedNormalVariadicOperandOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedNormalVariadicOperandOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedNormalVariadicOperandOpGenericAdaptor : public detail::MixedNormalVariadicOperandOpGenericAdaptorBase { … };
class MixedNormalVariadicOperandOpAdaptor : public MixedNormalVariadicOperandOpGenericAdaptor<::mlir::ValueRange> { … };
class MixedNormalVariadicOperandOp : public ::mlir::Op<MixedNormalVariadicOperandOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MixedNormalVariadicOperandOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedNormalVariadicResults declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedNormalVariadicResultsGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedNormalVariadicResultsGenericAdaptor : public detail::MixedNormalVariadicResultsGenericAdaptorBase { … };
class MixedNormalVariadicResultsAdaptor : public MixedNormalVariadicResultsGenericAdaptor<::mlir::ValueRange> { … };
class MixedNormalVariadicResults : public ::mlir::Op<MixedNormalVariadicResults, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::AtLeastNResults<1>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MixedNormalVariadicResults)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedVOperandInOutI32Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedVOperandInOutI32OpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedVOperandInOutI32OpGenericAdaptor : public detail::MixedVOperandInOutI32OpGenericAdaptorBase { … };
class MixedVOperandInOutI32OpAdaptor : public MixedVOperandInOutI32OpGenericAdaptor<::mlir::ValueRange> { … };
class MixedVOperandInOutI32Op : public ::mlir::Op<MixedVOperandInOutI32Op, ::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::MixedVOperandInOutI32Op)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedVOperandOp1 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedVOperandOp1GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedVOperandOp1GenericAdaptor : public detail::MixedVOperandOp1GenericAdaptorBase { … };
class MixedVOperandOp1Adaptor : public MixedVOperandOp1GenericAdaptor<::mlir::ValueRange> { … };
class MixedVOperandOp1 : public ::mlir::Op<MixedVOperandOp1, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MixedVOperandOp1)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedVOperandOp2 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedVOperandOp2GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedVOperandOp2GenericAdaptor : public detail::MixedVOperandOp2GenericAdaptorBase { … };
class MixedVOperandOp2Adaptor : public MixedVOperandOp2GenericAdaptor<::mlir::ValueRange> { … };
class MixedVOperandOp2 : public ::mlir::Op<MixedVOperandOp2, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MixedVOperandOp2)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedVOperandOp3 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedVOperandOp3GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedVOperandOp3GenericAdaptor : public detail::MixedVOperandOp3GenericAdaptorBase { … };
class MixedVOperandOp3Adaptor : public MixedVOperandOp3GenericAdaptor<::mlir::ValueRange> { … };
class MixedVOperandOp3 : public ::mlir::Op<MixedVOperandOp3, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MixedVOperandOp3)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedVOperandOp4 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedVOperandOp4GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedVOperandOp4GenericAdaptor : public detail::MixedVOperandOp4GenericAdaptorBase { … };
class MixedVOperandOp4Adaptor : public MixedVOperandOp4GenericAdaptor<::mlir::ValueRange> { … };
class MixedVOperandOp4 : public ::mlir::Op<MixedVOperandOp4, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MixedVOperandOp4)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedVOperandOp5 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedVOperandOp5GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedVOperandOp5GenericAdaptor : public detail::MixedVOperandOp5GenericAdaptorBase { … };
class MixedVOperandOp5Adaptor : public MixedVOperandOp5GenericAdaptor<::mlir::ValueRange> { … };
class MixedVOperandOp5 : public ::mlir::Op<MixedVOperandOp5, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MixedVOperandOp5)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedVOperandOp6 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedVOperandOp6GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedVOperandOp6GenericAdaptor : public detail::MixedVOperandOp6GenericAdaptorBase { … };
class MixedVOperandOp6Adaptor : public MixedVOperandOp6GenericAdaptor<::mlir::ValueRange> { … };
class MixedVOperandOp6 : public ::mlir::Op<MixedVOperandOp6, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MixedVOperandOp6)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedVResultOp1 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedVResultOp1GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedVResultOp1GenericAdaptor : public detail::MixedVResultOp1GenericAdaptorBase { … };
class MixedVResultOp1Adaptor : public MixedVResultOp1GenericAdaptor<::mlir::ValueRange> { … };
class MixedVResultOp1 : public ::mlir::Op<MixedVResultOp1, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::AtLeastNResults<1>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MixedVResultOp1)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedVResultOp2 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedVResultOp2GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedVResultOp2GenericAdaptor : public detail::MixedVResultOp2GenericAdaptorBase { … };
class MixedVResultOp2Adaptor : public MixedVResultOp2GenericAdaptor<::mlir::ValueRange> { … };
class MixedVResultOp2 : public ::mlir::Op<MixedVResultOp2, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::AtLeastNResults<1>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MixedVResultOp2)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MixedVResultOp3 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MixedVResultOp3GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MixedVResultOp3GenericAdaptor : public detail::MixedVResultOp3GenericAdaptorBase { … };
class MixedVResultOp3Adaptor : public MixedVResultOp3GenericAdaptor<::mlir::ValueRange> { … };
class MixedVResultOp3 : public ::mlir::Op<MixedVResultOp3, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::AtLeastNResults<1>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MixedVResultOp3)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::MultiTensorRankOf declarations
//===----------------------------------------------------------------------===//

namespace detail {
class MultiTensorRankOfGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class MultiTensorRankOfGenericAdaptor : public detail::MultiTensorRankOfGenericAdaptorBase { … };
class MultiTensorRankOfAdaptor : public MultiTensorRankOfGenericAdaptor<::mlir::ValueRange> { … };
class MultiTensorRankOf : public ::mlir::Op<MultiTensorRankOf, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::MultiTensorRankOf)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::NDTensorOfOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class NDTensorOfOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class NDTensorOfOpGenericAdaptor : public detail::NDTensorOfOpGenericAdaptorBase { … };
class NDTensorOfOpAdaptor : public NDTensorOfOpGenericAdaptor<::mlir::ValueRange> { … };
class NDTensorOfOp : public ::mlir::Op<NDTensorOfOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<5>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::NDTensorOfOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::NestedTupleOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class NestedTupleOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class NestedTupleOpGenericAdaptor : public detail::NestedTupleOpGenericAdaptorBase { … };
class NestedTupleOpAdaptor : public NestedTupleOpGenericAdaptor<::mlir::ValueRange> { … };
class NestedTupleOp : public ::mlir::Op<NestedTupleOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::NestedTupleOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::NeverSpeculatableOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class NeverSpeculatableOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class NeverSpeculatableOpGenericAdaptor : public detail::NeverSpeculatableOpGenericAdaptorBase { … };
class NeverSpeculatableOpAdaptor : public NeverSpeculatableOpGenericAdaptor<::mlir::ValueRange> { … };
class NeverSpeculatableOp : public ::mlir::Op<NeverSpeculatableOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::NeverSpeculatableOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::NonNegIntAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class NonNegIntAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class NonNegIntAttrOpGenericAdaptor : public detail::NonNegIntAttrOpGenericAdaptorBase { … };
class NonNegIntAttrOpAdaptor : public NonNegIntAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class NonNegIntAttrOp : public ::mlir::Op<NonNegIntAttrOp, ::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::NonNegIntAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OneI32ResultOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OneI32ResultOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OneI32ResultOpGenericAdaptor : public detail::OneI32ResultOpGenericAdaptorBase { … };
class OneI32ResultOpAdaptor : public OneI32ResultOpGenericAdaptor<::mlir::ValueRange> { … };
class OneI32ResultOp : public ::mlir::Op<OneI32ResultOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OneI32ResultOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OneRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OneRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OneRegionOpGenericAdaptor : public detail::OneRegionOpGenericAdaptorBase { … };
class OneRegionOpAdaptor : public OneRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class OneRegionOp : public ::mlir::Op<OneRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OneRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OneRegionWithOperandsOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OneRegionWithOperandsOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OneRegionWithOperandsOpGenericAdaptor : public detail::OneRegionWithOperandsOpGenericAdaptorBase { … };
class OneRegionWithOperandsOpAdaptor : public OneRegionWithOperandsOpGenericAdaptor<::mlir::ValueRange> { … };
class OneRegionWithOperandsOp : public ::mlir::Op<OneRegionWithOperandsOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OneRegionWithOperandsOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OneRegionWithRecursiveMemoryEffectsOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OneRegionWithRecursiveMemoryEffectsOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OneRegionWithRecursiveMemoryEffectsOpGenericAdaptor : public detail::OneRegionWithRecursiveMemoryEffectsOpGenericAdaptorBase { … };
class OneRegionWithRecursiveMemoryEffectsOpAdaptor : public OneRegionWithRecursiveMemoryEffectsOpGenericAdaptor<::mlir::ValueRange> { … };
class OneRegionWithRecursiveMemoryEffectsOp : public ::mlir::Op<OneRegionWithRecursiveMemoryEffectsOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::HasRecursiveMemoryEffects> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OneRegionWithRecursiveMemoryEffectsOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OneResultOp1 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OneResultOp1GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OneResultOp1GenericAdaptor : public detail::OneResultOp1GenericAdaptorBase { … };
class OneResultOp1Adaptor : public OneResultOp1GenericAdaptor<::mlir::ValueRange> { … };
class OneResultOp1 : public ::mlir::Op<OneResultOp1, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::FloatType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OneResultOp1)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OneResultOp2 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OneResultOp2GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OneResultOp2GenericAdaptor : public detail::OneResultOp2GenericAdaptorBase { … };
class OneResultOp2Adaptor : public OneResultOp2GenericAdaptor<::mlir::ValueRange> { … };
class OneResultOp2 : public ::mlir::Op<OneResultOp2, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OneResultOp2)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OneResultOp3 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OneResultOp3GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OneResultOp3GenericAdaptor : public detail::OneResultOp3GenericAdaptorBase { … };
class OneResultOp3Adaptor : public OneResultOp3GenericAdaptor<::mlir::ValueRange> { … };
class OneResultOp3 : public ::mlir::Op<OneResultOp3, ::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::OneResultOp3)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OneToTwo declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OneToTwoGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OneToTwoGenericAdaptor : public detail::OneToTwoGenericAdaptorBase { … };
class OneToTwoAdaptor : public OneToTwoGenericAdaptor<::mlir::ValueRange> { … };
class OneToTwo : public ::mlir::Op<OneToTwo, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OneToTwo)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OneVResOneVOperandOp1 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OneVResOneVOperandOp1GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OneVResOneVOperandOp1GenericAdaptor : public detail::OneVResOneVOperandOp1GenericAdaptorBase { … };
class OneVResOneVOperandOp1Adaptor : public OneVResOneVOperandOp1GenericAdaptor<::mlir::ValueRange> { … };
class OneVResOneVOperandOp1 : public ::mlir::Op<OneVResOneVOperandOp1, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OneVResOneVOperandOp1)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OneVResOneVOperandOp2 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OneVResOneVOperandOp2GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OneVResOneVOperandOp2GenericAdaptor : public detail::OneVResOneVOperandOp2GenericAdaptorBase { … };
class OneVResOneVOperandOp2Adaptor : public OneVResOneVOperandOp2GenericAdaptor<::mlir::ValueRange> { … };
class OneVResOneVOperandOp2 : public ::mlir::Op<OneVResOneVOperandOp2, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OneVResOneVOperandOp2)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpA declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpAGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpAGenericAdaptor : public detail::OpAGenericAdaptorBase { … };
class OpAAdaptor : public OpAGenericAdaptor<::mlir::ValueRange> { … };
class OpA : public ::mlir::Op<OpA, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpA)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpAllAttrConstraint1 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpAllAttrConstraint1GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpAllAttrConstraint1GenericAdaptor : public detail::OpAllAttrConstraint1GenericAdaptorBase { … };
class OpAllAttrConstraint1Adaptor : public OpAllAttrConstraint1GenericAdaptor<::mlir::ValueRange> { … };
class OpAllAttrConstraint1 : public ::mlir::Op<OpAllAttrConstraint1, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpAllAttrConstraint1)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpAllAttrConstraint2 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpAllAttrConstraint2GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpAllAttrConstraint2GenericAdaptor : public detail::OpAllAttrConstraint2GenericAdaptorBase { … };
class OpAllAttrConstraint2Adaptor : public OpAllAttrConstraint2GenericAdaptor<::mlir::ValueRange> { … };
class OpAllAttrConstraint2 : public ::mlir::Op<OpAllAttrConstraint2, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpAllAttrConstraint2)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpAttrMatch1 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpAttrMatch1GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpAttrMatch1GenericAdaptor : public detail::OpAttrMatch1GenericAdaptorBase { … };
class OpAttrMatch1Adaptor : public OpAttrMatch1GenericAdaptor<::mlir::ValueRange> { … };
class OpAttrMatch1 : public ::mlir::Op<OpAttrMatch1, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpAttrMatch1)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpAttrMatch2 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpAttrMatch2GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpAttrMatch2GenericAdaptor : public detail::OpAttrMatch2GenericAdaptorBase { … };
class OpAttrMatch2Adaptor : public OpAttrMatch2GenericAdaptor<::mlir::ValueRange> { … };
class OpAttrMatch2 : public ::mlir::Op<OpAttrMatch2, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpAttrMatch2)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpAttrMatch3 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpAttrMatch3GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpAttrMatch3GenericAdaptor : public detail::OpAttrMatch3GenericAdaptorBase { … };
class OpAttrMatch3Adaptor : public OpAttrMatch3GenericAdaptor<::mlir::ValueRange> { … };
class OpAttrMatch3 : public ::mlir::Op<OpAttrMatch3, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpAttrMatch3)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpAttrMatch4 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpAttrMatch4GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpAttrMatch4GenericAdaptor : public detail::OpAttrMatch4GenericAdaptorBase { … };
class OpAttrMatch4Adaptor : public OpAttrMatch4GenericAdaptor<::mlir::ValueRange> { … };
class OpAttrMatch4 : public ::mlir::Op<OpAttrMatch4, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpAttrMatch4)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpB declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpBGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpBGenericAdaptor : public detail::OpBGenericAdaptorBase { … };
class OpBAdaptor : public OpBGenericAdaptor<::mlir::ValueRange> { … };
class OpB : public ::mlir::Op<OpB, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpB)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpC declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpCGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpCGenericAdaptor : public detail::OpCGenericAdaptorBase { … };
class OpCAdaptor : public OpCGenericAdaptor<::mlir::ValueRange> { … };
class OpC : public ::mlir::Op<OpC, ::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::OpC)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpCrashLong declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpCrashLongGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpCrashLongGenericAdaptor : public detail::OpCrashLongGenericAdaptorBase { … };
class OpCrashLongAdaptor : public OpCrashLongGenericAdaptor<::mlir::ValueRange> { … };
class OpCrashLong : public ::mlir::Op<OpCrashLong, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpCrashLong)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpCrashShort declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpCrashShortGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpCrashShortGenericAdaptor : public detail::OpCrashShortGenericAdaptorBase { … };
class OpCrashShortAdaptor : public OpCrashShortGenericAdaptor<::mlir::ValueRange> { … };
class OpCrashShort : public ::mlir::Op<OpCrashShort, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpCrashShort)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpD declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpDGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpDGenericAdaptor : public detail::OpDGenericAdaptorBase { … };
class OpDAdaptor : public OpDGenericAdaptor<::mlir::ValueRange> { … };
class OpD : public ::mlir::Op<OpD, ::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::OpD)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpE declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpEGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpEGenericAdaptor : public detail::OpEGenericAdaptorBase { … };
class OpEAdaptor : public OpEGenericAdaptor<::mlir::ValueRange> { … };
class OpE : public ::mlir::Op<OpE, ::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::OpE)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpF declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpFGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpFGenericAdaptor : public detail::OpFGenericAdaptorBase { … };
class OpFAdaptor : public OpFGenericAdaptor<::mlir::ValueRange> { … };
class OpF : public ::mlir::Op<OpF, ::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::OpF)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpFuncRef declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpFuncRefGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpFuncRefGenericAdaptor : public detail::OpFuncRefGenericAdaptorBase { … };
class OpFuncRefAdaptor : public OpFuncRefGenericAdaptor<::mlir::ValueRange> { … };
class OpFuncRef : public ::mlir::Op<OpFuncRef, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpFuncRef)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpG declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpGGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpGGenericAdaptor : public detail::OpGGenericAdaptorBase { … };
class OpGAdaptor : public OpGGenericAdaptor<::mlir::ValueRange> { … };
class OpG : public ::mlir::Op<OpG, ::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::OpG)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpH declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpHGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpHGenericAdaptor : public detail::OpHGenericAdaptorBase { … };
class OpHAdaptor : public OpHGenericAdaptor<::mlir::ValueRange> { … };
class OpH : public ::mlir::Op<OpH, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpH)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpI declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpIGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpIGenericAdaptor : public detail::OpIGenericAdaptorBase { … };
class OpIAdaptor : public OpIGenericAdaptor<::mlir::ValueRange> { … };
class OpI : public ::mlir::Op<OpI, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpI)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpInterleavedOperandAttribute1 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpInterleavedOperandAttribute1GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpInterleavedOperandAttribute1GenericAdaptor : public detail::OpInterleavedOperandAttribute1GenericAdaptorBase { … };
class OpInterleavedOperandAttribute1Adaptor : public OpInterleavedOperandAttribute1GenericAdaptor<::mlir::ValueRange> { … };
class OpInterleavedOperandAttribute1 : public ::mlir::Op<OpInterleavedOperandAttribute1, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpInterleavedOperandAttribute1)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpInterleavedOperandAttribute2 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpInterleavedOperandAttribute2GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpInterleavedOperandAttribute2GenericAdaptor : public detail::OpInterleavedOperandAttribute2GenericAdaptorBase { … };
class OpInterleavedOperandAttribute2Adaptor : public OpInterleavedOperandAttribute2GenericAdaptor<::mlir::ValueRange> { … };
class OpInterleavedOperandAttribute2 : public ::mlir::Op<OpInterleavedOperandAttribute2, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpInterleavedOperandAttribute2)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpJ declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpJGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpJGenericAdaptor : public detail::OpJGenericAdaptorBase { … };
class OpJAdaptor : public OpJGenericAdaptor<::mlir::ValueRange> { … };
class OpJ : public ::mlir::Op<OpJ, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpJ)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpK declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpKGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpKGenericAdaptor : public detail::OpKGenericAdaptorBase { … };
class OpKAdaptor : public OpKGenericAdaptor<::mlir::ValueRange> { … };
class OpK : public ::mlir::Op<OpK, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpK)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpM declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpMGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpMGenericAdaptor : public detail::OpMGenericAdaptorBase { … };
class OpMAdaptor : public OpMGenericAdaptor<::mlir::ValueRange> { … };
class OpM : public ::mlir::Op<OpM, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpM)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpN declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpNGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpNGenericAdaptor : public detail::OpNGenericAdaptorBase { … };
class OpNAdaptor : public OpNGenericAdaptor<::mlir::ValueRange> { … };
class OpN : public ::mlir::Op<OpN, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpN)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpNativeCodeCall1 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpNativeCodeCall1GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpNativeCodeCall1GenericAdaptor : public detail::OpNativeCodeCall1GenericAdaptorBase { … };
class OpNativeCodeCall1Adaptor : public OpNativeCodeCall1GenericAdaptor<::mlir::ValueRange> { … };
class OpNativeCodeCall1 : public ::mlir::Op<OpNativeCodeCall1, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpNativeCodeCall1)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpNativeCodeCall2 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpNativeCodeCall2GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpNativeCodeCall2GenericAdaptor : public detail::OpNativeCodeCall2GenericAdaptorBase { … };
class OpNativeCodeCall2Adaptor : public OpNativeCodeCall2GenericAdaptor<::mlir::ValueRange> { … };
class OpNativeCodeCall2 : public ::mlir::Op<OpNativeCodeCall2, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpNativeCodeCall2)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpNativeCodeCall3 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpNativeCodeCall3GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpNativeCodeCall3GenericAdaptor : public detail::OpNativeCodeCall3GenericAdaptorBase { … };
class OpNativeCodeCall3Adaptor : public OpNativeCodeCall3GenericAdaptor<::mlir::ValueRange> { … };
class OpNativeCodeCall3 : public ::mlir::Op<OpNativeCodeCall3, ::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::OpNativeCodeCall3)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpNativeCodeCall4 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpNativeCodeCall4GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpNativeCodeCall4GenericAdaptor : public detail::OpNativeCodeCall4GenericAdaptorBase { … };
class OpNativeCodeCall4Adaptor : public OpNativeCodeCall4GenericAdaptor<::mlir::ValueRange> { … };
class OpNativeCodeCall4 : public ::mlir::Op<OpNativeCodeCall4, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpNativeCodeCall4)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpNativeCodeCall5 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpNativeCodeCall5GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpNativeCodeCall5GenericAdaptor : public detail::OpNativeCodeCall5GenericAdaptorBase { … };
class OpNativeCodeCall5Adaptor : public OpNativeCodeCall5GenericAdaptor<::mlir::ValueRange> { … };
class OpNativeCodeCall5 : public ::mlir::Op<OpNativeCodeCall5, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpNativeCodeCall5)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpNativeCodeCall6 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpNativeCodeCall6GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpNativeCodeCall6GenericAdaptor : public detail::OpNativeCodeCall6GenericAdaptorBase { … };
class OpNativeCodeCall6Adaptor : public OpNativeCodeCall6GenericAdaptor<::mlir::ValueRange> { … };
class OpNativeCodeCall6 : public ::mlir::Op<OpNativeCodeCall6, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpNativeCodeCall6)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpNativeCodeCall7 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpNativeCodeCall7GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpNativeCodeCall7GenericAdaptor : public detail::OpNativeCodeCall7GenericAdaptorBase { … };
class OpNativeCodeCall7Adaptor : public OpNativeCodeCall7GenericAdaptor<::mlir::ValueRange> { … };
class OpNativeCodeCall7 : public ::mlir::Op<OpNativeCodeCall7, ::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::OpNativeCodeCall7)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpNonNorm declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpNonNormGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpNonNormGenericAdaptor : public detail::OpNonNormGenericAdaptorBase { … };
class OpNonNormAdaptor : public OpNonNormGenericAdaptor<::mlir::ValueRange> { … };
class OpNonNorm : public ::mlir::Op<OpNonNorm, ::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::OpNonNorm)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpNorm declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpNormGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpNormGenericAdaptor : public detail::OpNormGenericAdaptorBase { … };
class OpNormAdaptor : public OpNormGenericAdaptor<::mlir::ValueRange> { … };
class OpNorm : public ::mlir::Op<OpNorm, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::MemRefsNormalizable> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpNorm)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpNormRet declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpNormRetGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpNormRetGenericAdaptor : public detail::OpNormRetGenericAdaptorBase { … };
class OpNormRetAdaptor : public OpNormRetGenericAdaptor<::mlir::ValueRange> { … };
class OpNormRet : public ::mlir::Op<OpNormRet, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::MemRefsNormalizable, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpNormRet)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpO declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpOGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpOGenericAdaptor : public detail::OpOGenericAdaptorBase { … };
class OpOAdaptor : public OpOGenericAdaptor<::mlir::ValueRange> { … };
class OpO : public ::mlir::Op<OpO, ::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::OpO)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpP declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpPGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpPGenericAdaptor : public detail::OpPGenericAdaptorBase { … };
class OpPAdaptor : public OpPGenericAdaptor<::mlir::ValueRange> { … };
class OpP : public ::mlir::Op<OpP, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<6>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpP)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpR declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpRGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpRGenericAdaptor : public detail::OpRGenericAdaptorBase { … };
class OpRAdaptor : public OpRGenericAdaptor<::mlir::ValueRange> { … };
class OpR : public ::mlir::Op<OpR, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpR)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpS declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpSGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpSGenericAdaptor : public detail::OpSGenericAdaptorBase { … };
class OpSAdaptor : public OpSGenericAdaptor<::mlir::ValueRange> { … };
class OpS : public ::mlir::Op<OpS, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpS)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpSymbolBindingA declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpSymbolBindingAGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpSymbolBindingAGenericAdaptor : public detail::OpSymbolBindingAGenericAdaptorBase { … };
class OpSymbolBindingAAdaptor : public OpSymbolBindingAGenericAdaptor<::mlir::ValueRange> { … };
class OpSymbolBindingA : public ::mlir::Op<OpSymbolBindingA, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpSymbolBindingA)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpSymbolBindingB declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpSymbolBindingBGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpSymbolBindingBGenericAdaptor : public detail::OpSymbolBindingBGenericAdaptorBase { … };
class OpSymbolBindingBAdaptor : public OpSymbolBindingBGenericAdaptor<::mlir::ValueRange> { … };
class OpSymbolBindingB : public ::mlir::Op<OpSymbolBindingB, ::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::OpSymbolBindingB)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpSymbolBindingC declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpSymbolBindingCGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpSymbolBindingCGenericAdaptor : public detail::OpSymbolBindingCGenericAdaptorBase { … };
class OpSymbolBindingCAdaptor : public OpSymbolBindingCGenericAdaptor<::mlir::ValueRange> { … };
class OpSymbolBindingC : public ::mlir::Op<OpSymbolBindingC, ::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::OpSymbolBindingC)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpSymbolBindingD declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpSymbolBindingDGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpSymbolBindingDGenericAdaptor : public detail::OpSymbolBindingDGenericAdaptorBase { … };
class OpSymbolBindingDAdaptor : public OpSymbolBindingDGenericAdaptor<::mlir::ValueRange> { … };
class OpSymbolBindingD : public ::mlir::Op<OpSymbolBindingD, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpSymbolBindingD)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpSymbolBindingNoResult declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpSymbolBindingNoResultGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpSymbolBindingNoResultGenericAdaptor : public detail::OpSymbolBindingNoResultGenericAdaptorBase { … };
class OpSymbolBindingNoResultAdaptor : public OpSymbolBindingNoResultGenericAdaptor<::mlir::ValueRange> { … };
class OpSymbolBindingNoResult : public ::mlir::Op<OpSymbolBindingNoResult, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpSymbolBindingNoResult)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpWithBitEnum declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpWithBitEnumGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpWithBitEnumGenericAdaptor : public detail::OpWithBitEnumGenericAdaptorBase { … };
class OpWithBitEnumAdaptor : public OpWithBitEnumGenericAdaptor<::mlir::ValueRange> { … };
class OpWithBitEnum : public ::mlir::Op<OpWithBitEnum, ::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::OpWithBitEnum)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpWithBitEnumVerticalBar declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpWithBitEnumVerticalBarGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpWithBitEnumVerticalBarGenericAdaptor : public detail::OpWithBitEnumVerticalBarGenericAdaptorBase { … };
class OpWithBitEnumVerticalBarAdaptor : public OpWithBitEnumVerticalBarGenericAdaptor<::mlir::ValueRange> { … };
class OpWithBitEnumVerticalBar : public ::mlir::Op<OpWithBitEnumVerticalBar, ::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::OpWithBitEnumVerticalBar)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpWithDataLayoutOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpWithDataLayoutOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpWithDataLayoutOpGenericAdaptor : public detail::OpWithDataLayoutOpGenericAdaptorBase { … };
class OpWithDataLayoutOpAdaptor : public OpWithDataLayoutOpGenericAdaptor<::mlir::ValueRange> { … };
class OpWithDataLayoutOp : public ::mlir::Op<OpWithDataLayoutOp, ::mlir::OpTrait::VariadicRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::HasDefaultDLTIDataLayout, ::mlir::DataLayoutOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpWithDataLayoutOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpWithEnum declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpWithEnumGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpWithEnumGenericAdaptor : public detail::OpWithEnumGenericAdaptorBase { … };
class OpWithEnumAdaptor : public OpWithEnumGenericAdaptor<::mlir::ValueRange> { … };
class OpWithEnum : public ::mlir::Op<OpWithEnum, ::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::OpWithEnum)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpWithInferTypeAdaptorInterfaceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpWithInferTypeAdaptorInterfaceOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpWithInferTypeAdaptorInterfaceOpGenericAdaptor : public detail::OpWithInferTypeAdaptorInterfaceOpGenericAdaptorBase { … };
class OpWithInferTypeAdaptorInterfaceOpAdaptor : public OpWithInferTypeAdaptorInterfaceOpGenericAdaptor<::mlir::ValueRange> { … };
class OpWithInferTypeAdaptorInterfaceOp : public ::mlir::Op<OpWithInferTypeAdaptorInterfaceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::TensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait, ::mlir::OpTrait::InferTypeOpAdaptor> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpWithInferTypeAdaptorInterfaceOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpWithInferTypeInterfaceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpWithInferTypeInterfaceOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpWithInferTypeInterfaceOpGenericAdaptor : public detail::OpWithInferTypeInterfaceOpGenericAdaptorBase { … };
class OpWithInferTypeInterfaceOpAdaptor : public OpWithInferTypeInterfaceOpGenericAdaptor<::mlir::ValueRange> { … };
class OpWithInferTypeInterfaceOp : public ::mlir::Op<OpWithInferTypeInterfaceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::TensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpWithInferTypeInterfaceOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpWithRefineTypeInterfaceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpWithRefineTypeInterfaceOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpWithRefineTypeInterfaceOpGenericAdaptor : public detail::OpWithRefineTypeInterfaceOpGenericAdaptorBase { … };
class OpWithRefineTypeInterfaceOpAdaptor : public OpWithRefineTypeInterfaceOpGenericAdaptor<::mlir::ValueRange> { … };
class OpWithRefineTypeInterfaceOp : public ::mlir::Op<OpWithRefineTypeInterfaceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::TensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpWithRefineTypeInterfaceOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpWithResultShapeInterfaceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpWithResultShapeInterfaceOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpWithResultShapeInterfaceOpGenericAdaptor : public detail::OpWithResultShapeInterfaceOpGenericAdaptorBase { … };
class OpWithResultShapeInterfaceOpAdaptor : public OpWithResultShapeInterfaceOpGenericAdaptor<::mlir::ValueRange> { … };
class OpWithResultShapeInterfaceOp : public ::mlir::Op<OpWithResultShapeInterfaceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferShapedTypeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpWithResultShapeInterfaceOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpWithResultShapePerDimInterfaceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpWithResultShapePerDimInterfaceOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpWithResultShapePerDimInterfaceOpGenericAdaptor : public detail::OpWithResultShapePerDimInterfaceOpGenericAdaptorBase { … };
class OpWithResultShapePerDimInterfaceOpAdaptor : public OpWithResultShapePerDimInterfaceOpGenericAdaptor<::mlir::ValueRange> { … };
class OpWithResultShapePerDimInterfaceOp : public ::mlir::Op<OpWithResultShapePerDimInterfaceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ReifyRankedShapedTypeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpWithResultShapePerDimInterfaceOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpWithShapedTypeInferTypeAdaptorInterfaceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpWithShapedTypeInferTypeAdaptorInterfaceOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpWithShapedTypeInferTypeAdaptorInterfaceOpGenericAdaptor : public detail::OpWithShapedTypeInferTypeAdaptorInterfaceOpGenericAdaptorBase { … };
class OpWithShapedTypeInferTypeAdaptorInterfaceOpAdaptor : public OpWithShapedTypeInferTypeAdaptorInterfaceOpGenericAdaptor<::mlir::ValueRange> { … };
class OpWithShapedTypeInferTypeAdaptorInterfaceOp : public ::mlir::Op<OpWithShapedTypeInferTypeAdaptorInterfaceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::TensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait, ::mlir::InferShapedTypeOpInterface::Trait, ::mlir::OpTrait::InferShapedTypeOpAdaptor, ::mlir::OpTrait::InferTensorType> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpWithShapedTypeInferTypeAdaptorInterfaceOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpWithShapedTypeInferTypeInterfaceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpWithShapedTypeInferTypeInterfaceOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpWithShapedTypeInferTypeInterfaceOpGenericAdaptor : public detail::OpWithShapedTypeInferTypeInterfaceOpGenericAdaptorBase { … };
class OpWithShapedTypeInferTypeInterfaceOpAdaptor : public OpWithShapedTypeInferTypeInterfaceOpGenericAdaptor<::mlir::ValueRange> { … };
class OpWithShapedTypeInferTypeInterfaceOp : public ::mlir::Op<OpWithShapedTypeInferTypeInterfaceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::TensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait, ::mlir::InferShapedTypeOpInterface::Trait, ::mlir::OpTrait::InferTensorType> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpWithShapedTypeInferTypeInterfaceOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OpX declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OpXGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OpXGenericAdaptor : public detail::OpXGenericAdaptorBase { … };
class OpXAdaptor : public OpXGenericAdaptor<::mlir::ValueRange> { … };
class OpX : public ::mlir::Op<OpX, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OpX)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OperandRankEqualsResultSize declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OperandRankEqualsResultSizeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OperandRankEqualsResultSizeGenericAdaptor : public detail::OperandRankEqualsResultSizeGenericAdaptorBase { … };
class OperandRankEqualsResultSizeAdaptor : public OperandRankEqualsResultSizeGenericAdaptor<::mlir::ValueRange> { … };
class OperandRankEqualsResultSize : public ::mlir::Op<OperandRankEqualsResultSize, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::ShapedType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OperandRankEqualsResultSize)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OperandZeroAndResultHaveSameElementCount declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OperandZeroAndResultHaveSameElementCountGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OperandZeroAndResultHaveSameElementCountGenericAdaptor : public detail::OperandZeroAndResultHaveSameElementCountGenericAdaptorBase { … };
class OperandZeroAndResultHaveSameElementCountAdaptor : public OperandZeroAndResultHaveSameElementCountGenericAdaptor<::mlir::ValueRange> { … };
class OperandZeroAndResultHaveSameElementCount : public ::mlir::Op<OperandZeroAndResultHaveSameElementCount, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::ShapedType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OperandZeroAndResultHaveSameElementCount)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OperandZeroAndResultHaveSameElementType declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OperandZeroAndResultHaveSameElementTypeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OperandZeroAndResultHaveSameElementTypeGenericAdaptor : public detail::OperandZeroAndResultHaveSameElementTypeGenericAdaptorBase { … };
class OperandZeroAndResultHaveSameElementTypeAdaptor : public OperandZeroAndResultHaveSameElementTypeGenericAdaptor<::mlir::ValueRange> { … };
class OperandZeroAndResultHaveSameElementType : public ::mlir::Op<OperandZeroAndResultHaveSameElementType, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OperandZeroAndResultHaveSameElementType)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OperandZeroAndResultHaveSameRank declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OperandZeroAndResultHaveSameRankGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OperandZeroAndResultHaveSameRankGenericAdaptor : public detail::OperandZeroAndResultHaveSameRankGenericAdaptorBase { … };
class OperandZeroAndResultHaveSameRankAdaptor : public OperandZeroAndResultHaveSameRankGenericAdaptor<::mlir::ValueRange> { … };
class OperandZeroAndResultHaveSameRank : public ::mlir::Op<OperandZeroAndResultHaveSameRank, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::ShapedType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OperandZeroAndResultHaveSameRank)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OperandZeroAndResultHaveSameShape declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OperandZeroAndResultHaveSameShapeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OperandZeroAndResultHaveSameShapeGenericAdaptor : public detail::OperandZeroAndResultHaveSameShapeGenericAdaptorBase { … };
class OperandZeroAndResultHaveSameShapeAdaptor : public OperandZeroAndResultHaveSameShapeGenericAdaptor<::mlir::ValueRange> { … };
class OperandZeroAndResultHaveSameShape : public ::mlir::Op<OperandZeroAndResultHaveSameShape, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::ShapedType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OperandZeroAndResultHaveSameShape)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OperandZeroAndResultHaveSameType declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OperandZeroAndResultHaveSameTypeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OperandZeroAndResultHaveSameTypeGenericAdaptor : public detail::OperandZeroAndResultHaveSameTypeGenericAdaptorBase { … };
class OperandZeroAndResultHaveSameTypeAdaptor : public OperandZeroAndResultHaveSameTypeGenericAdaptor<::mlir::ValueRange> { … };
class OperandZeroAndResultHaveSameType : public ::mlir::Op<OperandZeroAndResultHaveSameType, ::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::OperandZeroAndResultHaveSameType)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OperandsAndResultHaveSameRank declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OperandsAndResultHaveSameRankGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OperandsAndResultHaveSameRankGenericAdaptor : public detail::OperandsAndResultHaveSameRankGenericAdaptorBase { … };
class OperandsAndResultHaveSameRankAdaptor : public OperandsAndResultHaveSameRankGenericAdaptor<::mlir::ValueRange> { … };
class OperandsAndResultHaveSameRank : public ::mlir::Op<OperandsAndResultHaveSameRank, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::ShapedType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultRank> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::OperandsAndResultHaveSameRank)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OperandsHaveSameElementType declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OperandsHaveSameElementTypeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OperandsHaveSameElementTypeGenericAdaptor : public detail::OperandsHaveSameElementTypeGenericAdaptorBase { … };
class OperandsHaveSameElementTypeAdaptor : public OperandsHaveSameElementTypeGenericAdaptor<::mlir::ValueRange> { … };
class OperandsHaveSameElementType : public ::mlir::Op<OperandsHaveSameElementType, ::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::OperandsHaveSameElementType)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OperandsHaveSameRank declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OperandsHaveSameRankGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OperandsHaveSameRankGenericAdaptor : public detail::OperandsHaveSameRankGenericAdaptorBase { … };
class OperandsHaveSameRankAdaptor : public OperandsHaveSameRankGenericAdaptor<::mlir::ValueRange> { … };
class OperandsHaveSameRank : public ::mlir::Op<OperandsHaveSameRank, ::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::OperandsHaveSameRank)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OperandsHaveSameType declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OperandsHaveSameTypeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OperandsHaveSameTypeGenericAdaptor : public detail::OperandsHaveSameTypeGenericAdaptorBase { … };
class OperandsHaveSameTypeAdaptor : public OperandsHaveSameTypeGenericAdaptor<::mlir::ValueRange> { … };
class OperandsHaveSameType : public ::mlir::Op<OperandsHaveSameType, ::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::OperandsHaveSameType)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::OptionalCustomAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class OptionalCustomAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class OptionalCustomAttrOpGenericAdaptor : public detail::OptionalCustomAttrOpGenericAdaptorBase { … };
class OptionalCustomAttrOpAdaptor : public OptionalCustomAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class OptionalCustomAttrOp : public ::mlir::Op<OptionalCustomAttrOp, ::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::OptionalCustomAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ParentOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ParentOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ParentOpGenericAdaptor : public detail::ParentOpGenericAdaptorBase { … };
class ParentOpAdaptor : public ParentOpGenericAdaptor<::mlir::ValueRange> { … };
class ParentOp : public ::mlir::Op<ParentOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ParentOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ParentOp1 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ParentOp1GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ParentOp1GenericAdaptor : public detail::ParentOp1GenericAdaptorBase { … };
class ParentOp1Adaptor : public ParentOp1GenericAdaptor<::mlir::ValueRange> { … };
class ParentOp1 : public ::mlir::Op<ParentOp1, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ParentOp1)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ParseB64BytesOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ParseB64BytesOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ParseB64BytesOpGenericAdaptor : public detail::ParseB64BytesOpGenericAdaptorBase { … };
class ParseB64BytesOpAdaptor : public ParseB64BytesOpGenericAdaptor<::mlir::ValueRange> { … };
class ParseB64BytesOp : public ::mlir::Op<ParseB64BytesOp, ::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::ParseB64BytesOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ParseIntegerLiteralOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ParseIntegerLiteralOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ParseIntegerLiteralOpGenericAdaptor : public detail::ParseIntegerLiteralOpGenericAdaptorBase { … };
class ParseIntegerLiteralOpAdaptor : public ParseIntegerLiteralOpGenericAdaptor<::mlir::ValueRange> { … };
class ParseIntegerLiteralOp : public ::mlir::Op<ParseIntegerLiteralOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ParseIntegerLiteralOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ParseWrappedKeywordOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ParseWrappedKeywordOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ParseWrappedKeywordOpGenericAdaptor : public detail::ParseWrappedKeywordOpGenericAdaptorBase { … };
class ParseWrappedKeywordOpAdaptor : public ParseWrappedKeywordOpGenericAdaptor<::mlir::ValueRange> { … };
class ParseWrappedKeywordOp : public ::mlir::Op<ParseWrappedKeywordOp, ::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::ParseWrappedKeywordOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::PositiveIntAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class PositiveIntAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class PositiveIntAttrOpGenericAdaptor : public detail::PositiveIntAttrOpGenericAdaptorBase { … };
class PositiveIntAttrOpAdaptor : public PositiveIntAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class PositiveIntAttrOp : public ::mlir::Op<PositiveIntAttrOp, ::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::PositiveIntAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::PromisedInterfacesOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class PromisedInterfacesOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class PromisedInterfacesOpGenericAdaptor : public detail::PromisedInterfacesOpGenericAdaptorBase { … };
class PromisedInterfacesOpAdaptor : public PromisedInterfacesOpGenericAdaptor<::mlir::ValueRange> { … };
class PromisedInterfacesOp : public ::mlir::Op<PromisedInterfacesOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::PromisedInterfacesOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::PureOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class PureOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class PureOpGenericAdaptor : public detail::PureOpGenericAdaptorBase { … };
class PureOpAdaptor : public PureOpGenericAdaptor<::mlir::ValueRange> { … };
class PureOp : public ::mlir::Op<PureOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::PureOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::RankLessThan2I8F32MemRefOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class RankLessThan2I8F32MemRefOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class RankLessThan2I8F32MemRefOpGenericAdaptor : public detail::RankLessThan2I8F32MemRefOpGenericAdaptorBase { … };
class RankLessThan2I8F32MemRefOpAdaptor : public RankLessThan2I8F32MemRefOpGenericAdaptor<::mlir::ValueRange> { … };
class RankLessThan2I8F32MemRefOp : public ::mlir::Op<RankLessThan2I8F32MemRefOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::MemRefType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::RankLessThan2I8F32MemRefOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::RankedIntElementsAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class RankedIntElementsAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class RankedIntElementsAttrOpGenericAdaptor : public detail::RankedIntElementsAttrOpGenericAdaptorBase { … };
class RankedIntElementsAttrOpAdaptor : public RankedIntElementsAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class RankedIntElementsAttrOp : public ::mlir::Op<RankedIntElementsAttrOp, ::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::RankedIntElementsAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::RankedTensorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class RankedTensorOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class RankedTensorOpGenericAdaptor : public detail::RankedTensorOpGenericAdaptorBase { … };
class RankedTensorOpAdaptor : public RankedTensorOpGenericAdaptor<::mlir::ValueRange> { … };
class RankedTensorOp : public ::mlir::Op<RankedTensorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::RankedTensorOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ReadBufferOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ReadBufferOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ReadBufferOpGenericAdaptor : public detail::ReadBufferOpGenericAdaptorBase { … };
class ReadBufferOpAdaptor : public ReadBufferOpGenericAdaptor<::mlir::ValueRange> { … };
class ReadBufferOp : public ::mlir::Op<ReadBufferOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ReadBufferOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::RecursivelySpeculatableOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class RecursivelySpeculatableOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class RecursivelySpeculatableOpGenericAdaptor : public detail::RecursivelySpeculatableOpGenericAdaptorBase { … };
class RecursivelySpeculatableOpAdaptor : public RecursivelySpeculatableOpGenericAdaptor<::mlir::ValueRange> { … };
class RecursivelySpeculatableOp : public ::mlir::Op<RecursivelySpeculatableOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::RecursivelySpeculatableImplTrait, ::mlir::OpTrait::HasRecursiveMemoryEffects, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::RecursivelySpeculatableOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::RegionBufferBasedOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class RegionBufferBasedOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class RegionBufferBasedOpGenericAdaptor : public detail::RegionBufferBasedOpGenericAdaptorBase { … };
class RegionBufferBasedOpAdaptor : public RegionBufferBasedOpGenericAdaptor<::mlir::ValueRange> { … };
class RegionBufferBasedOp : public ::mlir::Op<RegionBufferBasedOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<RegionYieldOp>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::RegionBufferBasedOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::RegionIfOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class RegionIfOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class RegionIfOpGenericAdaptor : public detail::RegionIfOpGenericAdaptorBase { … };
class RegionIfOpAdaptor : public RegionIfOpGenericAdaptor<::mlir::ValueRange> { … };
class RegionIfOp : public ::mlir::Op<RegionIfOp, ::mlir::OpTrait::NRegions<3>::Impl, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<RegionIfYieldOp>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::RegionBranchOpInterface::Trait, ::mlir::OpTrait::HasRecursiveMemoryEffects> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::RegionIfOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::RegionIfYieldOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class RegionIfYieldOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class RegionIfYieldOpGenericAdaptor : public detail::RegionIfYieldOpGenericAdaptorBase { … };
class RegionIfYieldOpAdaptor : public RegionIfYieldOpGenericAdaptor<::mlir::ValueRange> { … };
class RegionIfYieldOp : public ::mlir::Op<RegionIfYieldOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::RegionBranchTerminatorOpInterface::Trait, ::mlir::OpTrait::ReturnLike, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::RegionIfYieldOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::RegionYieldOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class RegionYieldOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class RegionYieldOpGenericAdaptor : public detail::RegionYieldOpGenericAdaptorBase { … };
class RegionYieldOpAdaptor : public RegionYieldOpGenericAdaptor<::mlir::ValueRange> { … };
class RegionYieldOp : public ::mlir::Op<RegionYieldOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::RegionBranchTerminatorOpInterface::Trait, ::mlir::OpTrait::ReturnLike, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::RegionYieldOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ReifyBoundOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ReifyBoundOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ReifyBoundOpGenericAdaptor : public detail::ReifyBoundOpGenericAdaptorBase { … };
class ReifyBoundOpAdaptor : public ReifyBoundOpGenericAdaptor<::mlir::ValueRange> { … };
class ReifyBoundOp : public ::mlir::Op<ReifyBoundOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IndexType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ReifyBoundOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ResultHasSameTypeAsAttr declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ResultHasSameTypeAsAttrGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ResultHasSameTypeAsAttrGenericAdaptor : public detail::ResultHasSameTypeAsAttrGenericAdaptorBase { … };
class ResultHasSameTypeAsAttrAdaptor : public ResultHasSameTypeAsAttrGenericAdaptor<::mlir::ValueRange> { … };
class ResultHasSameTypeAsAttr : public ::mlir::Op<ResultHasSameTypeAsAttr, ::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::ResultHasSameTypeAsAttr)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ResultTypeWithTraitOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ResultTypeWithTraitOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ResultTypeWithTraitOpGenericAdaptor : public detail::ResultTypeWithTraitOpGenericAdaptorBase { … };
class ResultTypeWithTraitOpAdaptor : public ResultTypeWithTraitOpGenericAdaptor<::mlir::ValueRange> { … };
class ResultTypeWithTraitOp : public ::mlir::Op<ResultTypeWithTraitOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ResultTypeWithTraitOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SSACFGRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SSACFGRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SSACFGRegionOpGenericAdaptor : public detail::SSACFGRegionOpGenericAdaptorBase { … };
class SSACFGRegionOpAdaptor : public SSACFGRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class SSACFGRegionOp : public ::mlir::Op<SSACFGRegionOp, ::mlir::OpTrait::VariadicRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::RegionKindInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SSACFGRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SameOperandAndResultElementTypeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SameOperandAndResultElementTypeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SameOperandAndResultElementTypeOpGenericAdaptor : public detail::SameOperandAndResultElementTypeOpGenericAdaptorBase { … };
class SameOperandAndResultElementTypeOpAdaptor : public SameOperandAndResultElementTypeOpGenericAdaptor<::mlir::ValueRange> { … };
class SameOperandAndResultElementTypeOp : public ::mlir::Op<SameOperandAndResultElementTypeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultElementType> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SameOperandAndResultElementTypeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SameOperandAndResultShapeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SameOperandAndResultShapeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SameOperandAndResultShapeOpGenericAdaptor : public detail::SameOperandAndResultShapeOpGenericAdaptorBase { … };
class SameOperandAndResultShapeOpAdaptor : public SameOperandAndResultShapeOpGenericAdaptor<::mlir::ValueRange> { … };
class SameOperandAndResultShapeOp : public ::mlir::Op<SameOperandAndResultShapeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultShape> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SameOperandAndResultShapeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SameOperandAndResultTypeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SameOperandAndResultTypeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SameOperandAndResultTypeOpGenericAdaptor : public detail::SameOperandAndResultTypeOpGenericAdaptorBase { … };
class SameOperandAndResultTypeOpAdaptor : public SameOperandAndResultTypeOpGenericAdaptor<::mlir::ValueRange> { … };
class SameOperandAndResultTypeOp : public ::mlir::Op<SameOperandAndResultTypeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SameOperandAndResultTypeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SameOperandElementTypeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SameOperandElementTypeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SameOperandElementTypeOpGenericAdaptor : public detail::SameOperandElementTypeOpGenericAdaptorBase { … };
class SameOperandElementTypeOpAdaptor : public SameOperandElementTypeOpGenericAdaptor<::mlir::ValueRange> { … };
class SameOperandElementTypeOp : public ::mlir::Op<SameOperandElementTypeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsElementType> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SameOperandElementTypeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SameOperandShapeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SameOperandShapeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SameOperandShapeOpGenericAdaptor : public detail::SameOperandShapeOpGenericAdaptorBase { … };
class SameOperandShapeOpAdaptor : public SameOperandShapeOpGenericAdaptor<::mlir::ValueRange> { … };
class SameOperandShapeOp : public ::mlir::Op<SameOperandShapeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsShape> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SameOperandShapeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SameOperandsResultType declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SameOperandsResultTypeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SameOperandsResultTypeGenericAdaptor : public detail::SameOperandsResultTypeGenericAdaptorBase { … };
class SameOperandsResultTypeAdaptor : public SameOperandsResultTypeGenericAdaptor<::mlir::ValueRange> { … };
class SameOperandsResultType : public ::mlir::Op<SameOperandsResultType, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::TensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SameOperandsResultType)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SideEffectOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SideEffectOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SideEffectOpGenericAdaptor : public detail::SideEffectOpGenericAdaptorBase { … };
class SideEffectOpAdaptor : public SideEffectOpGenericAdaptor<::mlir::ValueRange> { … };
class SideEffectOp : public ::mlir::Op<SideEffectOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::TestEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SideEffectOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SideEffectWithRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SideEffectWithRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SideEffectWithRegionOpGenericAdaptor : public detail::SideEffectWithRegionOpGenericAdaptorBase { … };
class SideEffectWithRegionOpAdaptor : public SideEffectWithRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class SideEffectWithRegionOp : public ::mlir::Op<SideEffectWithRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::TestEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SideEffectWithRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SingleBlockImplicitTerminatorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SingleBlockImplicitTerminatorOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SingleBlockImplicitTerminatorOpGenericAdaptor : public detail::SingleBlockImplicitTerminatorOpGenericAdaptorBase { … };
class SingleBlockImplicitTerminatorOpAdaptor : public SingleBlockImplicitTerminatorOpGenericAdaptor<::mlir::ValueRange> { … };
class SingleBlockImplicitTerminatorOp : public ::mlir::Op<SingleBlockImplicitTerminatorOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<TerminatorOp>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SingleBlockImplicitTerminatorOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SingleNoTerminatorCustomAsmOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SingleNoTerminatorCustomAsmOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SingleNoTerminatorCustomAsmOpGenericAdaptor : public detail::SingleNoTerminatorCustomAsmOpGenericAdaptorBase { … };
class SingleNoTerminatorCustomAsmOpAdaptor : public SingleNoTerminatorCustomAsmOpGenericAdaptor<::mlir::ValueRange> { … };
class SingleNoTerminatorCustomAsmOp : public ::mlir::Op<SingleNoTerminatorCustomAsmOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::NoTerminator, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SingleNoTerminatorCustomAsmOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SingleNoTerminatorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SingleNoTerminatorOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SingleNoTerminatorOpGenericAdaptor : public detail::SingleNoTerminatorOpGenericAdaptorBase { … };
class SingleNoTerminatorOpAdaptor : public SingleNoTerminatorOpGenericAdaptor<::mlir::ValueRange> { … };
class SingleNoTerminatorOp : public ::mlir::Op<SingleNoTerminatorOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::NoTerminator, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::OpInvariants, ::mlir::RegionKindInterface::Trait, ::mlir::OpTrait::HasOnlyGraphRegion> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SingleNoTerminatorOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SizedRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SizedRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SizedRegionOpGenericAdaptor : public detail::SizedRegionOpGenericAdaptorBase { … };
class SizedRegionOpAdaptor : public SizedRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class SizedRegionOp : public ::mlir::Op<SizedRegionOp, ::mlir::OpTrait::NRegions<2>::Impl, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SizedRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SourceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SourceOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SourceOpGenericAdaptor : public detail::SourceOpGenericAdaptorBase { … };
class SourceOpAdaptor : public SourceOpGenericAdaptor<::mlir::ValueRange> { … };
class SourceOp : public ::mlir::Op<SourceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SourceOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::StringAttrPrettyNameOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class StringAttrPrettyNameOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class StringAttrPrettyNameOpGenericAdaptor : public detail::StringAttrPrettyNameOpGenericAdaptorBase { … };
class StringAttrPrettyNameOpAdaptor : public StringAttrPrettyNameOpGenericAdaptor<::mlir::ValueRange> { … };
class StringAttrPrettyNameOp : public ::mlir::Op<StringAttrPrettyNameOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::StringAttrPrettyNameOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::StringElementsAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class StringElementsAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class StringElementsAttrOpGenericAdaptor : public detail::StringElementsAttrOpGenericAdaptorBase { … };
class StringElementsAttrOpAdaptor : public StringElementsAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class StringElementsAttrOp : public ::mlir::Op<StringElementsAttrOp, ::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::StringElementsAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SymbolOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SymbolOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SymbolOpGenericAdaptor : public detail::SymbolOpGenericAdaptorBase { … };
class SymbolOpAdaptor : public SymbolOpGenericAdaptor<::mlir::ValueRange> { … };
class SymbolOp : public ::mlir::Op<SymbolOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::SymbolOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SymbolOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SymbolScopeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SymbolScopeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SymbolScopeOpGenericAdaptor : public detail::SymbolScopeOpGenericAdaptorBase { … };
class SymbolScopeOpAdaptor : public SymbolScopeOpGenericAdaptor<::mlir::ValueRange> { … };
class SymbolScopeOp : public ::mlir::Op<SymbolScopeOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<TerminatorOp>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SymbolTable> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SymbolScopeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::SymbolTableRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class SymbolTableRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class SymbolTableRegionOpGenericAdaptor : public detail::SymbolTableRegionOpGenericAdaptorBase { … };
class SymbolTableRegionOpAdaptor : public SymbolTableRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class SymbolTableRegionOp : public ::mlir::Op<SymbolTableRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SymbolTable> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::SymbolTableRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TableGenBuildOp0 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TableGenBuildOp0GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TableGenBuildOp0GenericAdaptor : public detail::TableGenBuildOp0GenericAdaptorBase { … };
class TableGenBuildOp0Adaptor : public TableGenBuildOp0GenericAdaptor<::mlir::ValueRange> { … };
class TableGenBuildOp0 : public ::mlir::Op<TableGenBuildOp0, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TableGenBuildOp0)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TableGenBuildOp1 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TableGenBuildOp1GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TableGenBuildOp1GenericAdaptor : public detail::TableGenBuildOp1GenericAdaptorBase { … };
class TableGenBuildOp1Adaptor : public TableGenBuildOp1GenericAdaptor<::mlir::ValueRange> { … };
class TableGenBuildOp1 : public ::mlir::Op<TableGenBuildOp1, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TableGenBuildOp1)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TableGenBuildOp2 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TableGenBuildOp2GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TableGenBuildOp2GenericAdaptor : public detail::TableGenBuildOp2GenericAdaptorBase { … };
class TableGenBuildOp2Adaptor : public TableGenBuildOp2GenericAdaptor<::mlir::ValueRange> { … };
class TableGenBuildOp2 : public ::mlir::Op<TableGenBuildOp2, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TableGenBuildOp2)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TableGenBuildOp3 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TableGenBuildOp3GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TableGenBuildOp3GenericAdaptor : public detail::TableGenBuildOp3GenericAdaptorBase { … };
class TableGenBuildOp3Adaptor : public TableGenBuildOp3GenericAdaptor<::mlir::ValueRange> { … };
class TableGenBuildOp3 : public ::mlir::Op<TableGenBuildOp3, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TableGenBuildOp3)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TableGenBuildOp4 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TableGenBuildOp4GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TableGenBuildOp4GenericAdaptor : public detail::TableGenBuildOp4GenericAdaptorBase { … };
class TableGenBuildOp4Adaptor : public TableGenBuildOp4GenericAdaptor<::mlir::ValueRange> { … };
class TableGenBuildOp4 : public ::mlir::Op<TableGenBuildOp4, ::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::TableGenBuildOp4)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TableGenBuildOp5 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TableGenBuildOp5GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TableGenBuildOp5GenericAdaptor : public detail::TableGenBuildOp5GenericAdaptorBase { … };
class TableGenBuildOp5Adaptor : public TableGenBuildOp5GenericAdaptor<::mlir::ValueRange> { … };
class TableGenBuildOp5 : public ::mlir::Op<TableGenBuildOp5, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TableGenBuildOp5)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TableGenBuildOp6 declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TableGenBuildOp6GenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TableGenBuildOp6GenericAdaptor : public detail::TableGenBuildOp6GenericAdaptorBase { … };
class TableGenBuildOp6Adaptor : public TableGenBuildOp6GenericAdaptor<::mlir::ValueRange> { … };
class TableGenBuildOp6 : public ::mlir::Op<TableGenBuildOp6, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::FloatType>::Impl, ::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::TableGenBuildOp6)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TableGenConstant declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TableGenConstantGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TableGenConstantGenericAdaptor : public detail::TableGenConstantGenericAdaptorBase { … };
class TableGenConstantAdaptor : public TableGenConstantGenericAdaptor<::mlir::ValueRange> { … };
class TableGenConstant : public ::mlir::Op<TableGenConstant, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TableGenConstant)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TakesStaticMemRefOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TakesStaticMemRefOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TakesStaticMemRefOpGenericAdaptor : public detail::TakesStaticMemRefOpGenericAdaptorBase { … };
class TakesStaticMemRefOpAdaptor : public TakesStaticMemRefOpGenericAdaptor<::mlir::ValueRange> { … };
class TakesStaticMemRefOp : public ::mlir::Op<TakesStaticMemRefOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TakesStaticMemRefOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TensorBasedOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TensorBasedOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TensorBasedOpGenericAdaptor : public detail::TensorBasedOpGenericAdaptorBase { … };
class TensorBasedOpAdaptor : public TensorBasedOpGenericAdaptor<::mlir::ValueRange> { … };
class TensorBasedOp : public ::mlir::Op<TensorBasedOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::RankedTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TensorBasedOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TerminatorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TerminatorOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TerminatorOpGenericAdaptor : public detail::TerminatorOpGenericAdaptorBase { … };
class TerminatorOpAdaptor : public TerminatorOpGenericAdaptor<::mlir::ValueRange> { … };
class TerminatorOp : public ::mlir::Op<TerminatorOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TerminatorOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestAddIOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestAddIOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestAddIOpGenericAdaptor : public detail::TestAddIOpGenericAdaptorBase { … };
class TestAddIOpAdaptor : public TestAddIOpGenericAdaptor<::mlir::ValueRange> { … };
class TestAddIOp : public ::mlir::Op<TestAddIOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestAddIOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestAnotherTypeProducerOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestAnotherTypeProducerOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestAnotherTypeProducerOpGenericAdaptor : public detail::TestAnotherTypeProducerOpGenericAdaptorBase { … };
class TestAnotherTypeProducerOpAdaptor : public TestAnotherTypeProducerOpGenericAdaptor<::mlir::ValueRange> { … };
class TestAnotherTypeProducerOp : public ::mlir::Op<TestAnotherTypeProducerOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestAnotherTypeProducerOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestBranchOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestBranchOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestBranchOpGenericAdaptor : public detail::TestBranchOpGenericAdaptorBase { … };
class TestBranchOpAdaptor : public TestBranchOpGenericAdaptor<::mlir::ValueRange> { … };
class TestBranchOp : public ::mlir::Op<TestBranchOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::OneSuccessor, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BranchOpInterface::Trait, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestBranchOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestCSEOfSingleBlockOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestCSEOfSingleBlockOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestCSEOfSingleBlockOpGenericAdaptor : public detail::TestCSEOfSingleBlockOpGenericAdaptorBase { … };
class TestCSEOfSingleBlockOpAdaptor : public TestCSEOfSingleBlockOpGenericAdaptor<::mlir::ValueRange> { … };
class TestCSEOfSingleBlockOp : public ::mlir::Op<TestCSEOfSingleBlockOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::SingleBlockImplicitTerminator<RegionYieldOp>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestCSEOfSingleBlockOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestCallAndStoreOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestCallAndStoreOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestCallAndStoreOpGenericAdaptor : public detail::TestCallAndStoreOpGenericAdaptorBase { … };
class TestCallAndStoreOpAdaptor : public TestCallAndStoreOpGenericAdaptor<::mlir::ValueRange> { … };
class TestCallAndStoreOp : public ::mlir::Op<TestCallAndStoreOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::CallOpInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestCallAndStoreOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestCallOnDeviceOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestCallOnDeviceOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestCallOnDeviceOpGenericAdaptor : public detail::TestCallOnDeviceOpGenericAdaptorBase { … };
class TestCallOnDeviceOpAdaptor : public TestCallOnDeviceOpGenericAdaptor<::mlir::ValueRange> { … };
class TestCallOnDeviceOp : public ::mlir::Op<TestCallOnDeviceOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::CallOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestCallOnDeviceOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestCallOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestCallOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestCallOpGenericAdaptor : public detail::TestCallOpGenericAdaptorBase { … };
class TestCallOpAdaptor : public TestCallOpGenericAdaptor<::mlir::ValueRange> { … };
class TestCallOp : public ::mlir::Op<TestCallOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::SymbolUserOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestCallOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestCastOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestCastOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestCastOpGenericAdaptor : public detail::TestCastOpGenericAdaptorBase { … };
class TestCastOpAdaptor : public TestCastOpGenericAdaptor<::mlir::ValueRange> { … };
class TestCastOp : public ::mlir::Op<TestCastOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestCastOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestCommutative2Op declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestCommutative2OpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestCommutative2OpGenericAdaptor : public detail::TestCommutative2OpGenericAdaptorBase { … };
class TestCommutative2OpAdaptor : public TestCommutative2OpGenericAdaptor<::mlir::ValueRange> { … };
class TestCommutative2Op : public ::mlir::Op<TestCommutative2Op, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsCommutative, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestCommutative2Op)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestCommutativeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestCommutativeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestCommutativeOpGenericAdaptor : public detail::TestCommutativeOpGenericAdaptorBase { … };
class TestCommutativeOpAdaptor : public TestCommutativeOpGenericAdaptor<::mlir::ValueRange> { … };
class TestCommutativeOp : public ::mlir::Op<TestCommutativeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<4>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsCommutative, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestCommutativeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestDefaultAttrPrintOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestDefaultAttrPrintOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestDefaultAttrPrintOpGenericAdaptor : public detail::TestDefaultAttrPrintOpGenericAdaptorBase { … };
class TestDefaultAttrPrintOpAdaptor : public TestDefaultAttrPrintOpGenericAdaptor<::mlir::ValueRange> { … };
class TestDefaultAttrPrintOp : public ::mlir::Op<TestDefaultAttrPrintOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestDefaultAttrPrintOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestDefaultStrAttrHasValueOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestDefaultStrAttrHasValueOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestDefaultStrAttrHasValueOpGenericAdaptor : public detail::TestDefaultStrAttrHasValueOpGenericAdaptorBase { … };
class TestDefaultStrAttrHasValueOpAdaptor : public TestDefaultStrAttrHasValueOpGenericAdaptor<::mlir::ValueRange> { … };
class TestDefaultStrAttrHasValueOp : public ::mlir::Op<TestDefaultStrAttrHasValueOp, ::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::TestDefaultStrAttrHasValueOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestDefaultStrAttrNoValueOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestDefaultStrAttrNoValueOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestDefaultStrAttrNoValueOpGenericAdaptor : public detail::TestDefaultStrAttrNoValueOpGenericAdaptorBase { … };
class TestDefaultStrAttrNoValueOpAdaptor : public TestDefaultStrAttrNoValueOpGenericAdaptor<::mlir::ValueRange> { … };
class TestDefaultStrAttrNoValueOp : public ::mlir::Op<TestDefaultStrAttrNoValueOp, ::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::TestDefaultStrAttrNoValueOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestDestinationStyleOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestDestinationStyleOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestDestinationStyleOpGenericAdaptor : public detail::TestDestinationStyleOpGenericAdaptorBase { … };
class TestDestinationStyleOpAdaptor : public TestDestinationStyleOpGenericAdaptor<::mlir::ValueRange> { … };
class TestDestinationStyleOp : public ::mlir::Op<TestDestinationStyleOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::DestinationStyleOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestDestinationStyleOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestDialectCanonicalizerOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestDialectCanonicalizerOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestDialectCanonicalizerOpGenericAdaptor : public detail::TestDialectCanonicalizerOpGenericAdaptorBase { … };
class TestDialectCanonicalizerOpAdaptor : public TestDialectCanonicalizerOpGenericAdaptor<::mlir::ValueRange> { … };
class TestDialectCanonicalizerOp : public ::mlir::Op<TestDialectCanonicalizerOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestDialectCanonicalizerOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestEffectsOpA declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestEffectsOpAGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestEffectsOpAGenericAdaptor : public detail::TestEffectsOpAGenericAdaptorBase { … };
class TestEffectsOpAAdaptor : public TestEffectsOpAGenericAdaptor<::mlir::ValueRange> { … };
class TestEffectsOpA : public ::mlir::Op<TestEffectsOpA, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::MemRefType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestEffectsOpA)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestEffectsOpB declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestEffectsOpBGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestEffectsOpBGenericAdaptor : public detail::TestEffectsOpBGenericAdaptorBase { … };
class TestEffectsOpBAdaptor : public TestEffectsOpBGenericAdaptor<::mlir::ValueRange> { … };
class TestEffectsOpB : public ::mlir::Op<TestEffectsOpB, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestEffectsOpB)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestEffectsRead declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestEffectsReadGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestEffectsReadGenericAdaptor : public detail::TestEffectsReadGenericAdaptorBase { … };
class TestEffectsReadAdaptor : public TestEffectsReadGenericAdaptor<::mlir::ValueRange> { … };
class TestEffectsRead : public ::mlir::Op<TestEffectsRead, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestEffectsRead)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestEffectsResult declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestEffectsResultGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestEffectsResultGenericAdaptor : public detail::TestEffectsResultGenericAdaptorBase { … };
class TestEffectsResultAdaptor : public TestEffectsResultGenericAdaptor<::mlir::ValueRange> { … };
class TestEffectsResult : public ::mlir::Op<TestEffectsResult, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestEffectsResult)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestEffectsWrite declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestEffectsWriteGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestEffectsWriteGenericAdaptor : public detail::TestEffectsWriteGenericAdaptorBase { … };
class TestEffectsWriteAdaptor : public TestEffectsWriteGenericAdaptor<::mlir::ValueRange> { … };
class TestEffectsWrite : public ::mlir::Op<TestEffectsWrite, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestEffectsWrite)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestEitherHelperOpA declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestEitherHelperOpAGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestEitherHelperOpAGenericAdaptor : public detail::TestEitherHelperOpAGenericAdaptorBase { … };
class TestEitherHelperOpAAdaptor : public TestEitherHelperOpAGenericAdaptor<::mlir::ValueRange> { … };
class TestEitherHelperOpA : public ::mlir::Op<TestEitherHelperOpA, ::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::TestEitherHelperOpA)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestEitherHelperOpB declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestEitherHelperOpBGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestEitherHelperOpBGenericAdaptor : public detail::TestEitherHelperOpBGenericAdaptorBase { … };
class TestEitherHelperOpBAdaptor : public TestEitherHelperOpBGenericAdaptor<::mlir::ValueRange> { … };
class TestEitherHelperOpB : public ::mlir::Op<TestEitherHelperOpB, ::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::TestEitherHelperOpB)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestEitherOpA declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestEitherOpAGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestEitherOpAGenericAdaptor : public detail::TestEitherOpAGenericAdaptorBase { … };
class TestEitherOpAAdaptor : public TestEitherOpAGenericAdaptor<::mlir::ValueRange> { … };
class TestEitherOpA : public ::mlir::Op<TestEitherOpA, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestEitherOpA)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestEitherOpB declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestEitherOpBGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestEitherOpBGenericAdaptor : public detail::TestEitherOpBGenericAdaptorBase { … };
class TestEitherOpBAdaptor : public TestEitherOpBGenericAdaptor<::mlir::ValueRange> { … };
class TestEitherOpB : public ::mlir::Op<TestEitherOpB, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestEitherOpB)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestGraphLoopOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestGraphLoopOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestGraphLoopOpGenericAdaptor : public detail::TestGraphLoopOpGenericAdaptorBase { … };
class TestGraphLoopOpAdaptor : public TestGraphLoopOpGenericAdaptor<::mlir::ValueRange> { … };
class TestGraphLoopOp : public ::mlir::Op<TestGraphLoopOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::OpInvariants, ::mlir::LoopLikeOpInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::RecursivelySpeculatableImplTrait, ::mlir::RegionKindInterface::Trait, ::mlir::OpTrait::HasOnlyGraphRegion> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestGraphLoopOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestIdempotentTraitBinaryOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestIdempotentTraitBinaryOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestIdempotentTraitBinaryOpGenericAdaptor : public detail::TestIdempotentTraitBinaryOpGenericAdaptorBase { … };
class TestIdempotentTraitBinaryOpAdaptor : public TestIdempotentTraitBinaryOpGenericAdaptor<::mlir::ValueRange> { … };
class TestIdempotentTraitBinaryOp : public ::mlir::Op<TestIdempotentTraitBinaryOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsIdempotent, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestIdempotentTraitBinaryOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestIdempotentTraitOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestIdempotentTraitOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestIdempotentTraitOpGenericAdaptor : public detail::TestIdempotentTraitOpGenericAdaptorBase { … };
class TestIdempotentTraitOpAdaptor : public TestIdempotentTraitOpGenericAdaptor<::mlir::ValueRange> { … };
class TestIdempotentTraitOp : public ::mlir::Op<TestIdempotentTraitOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsIdempotent, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestIdempotentTraitOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestIgnoreArgMatchDstOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestIgnoreArgMatchDstOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestIgnoreArgMatchDstOpGenericAdaptor : public detail::TestIgnoreArgMatchDstOpGenericAdaptorBase { … };
class TestIgnoreArgMatchDstOpAdaptor : public TestIgnoreArgMatchDstOpGenericAdaptor<::mlir::ValueRange> { … };
class TestIgnoreArgMatchDstOp : public ::mlir::Op<TestIgnoreArgMatchDstOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestIgnoreArgMatchDstOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestIgnoreArgMatchSrcOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestIgnoreArgMatchSrcOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestIgnoreArgMatchSrcOpGenericAdaptor : public detail::TestIgnoreArgMatchSrcOpGenericAdaptorBase { … };
class TestIgnoreArgMatchSrcOpAdaptor : public TestIgnoreArgMatchSrcOpGenericAdaptor<::mlir::ValueRange> { … };
class TestIgnoreArgMatchSrcOp : public ::mlir::Op<TestIgnoreArgMatchSrcOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestIgnoreArgMatchSrcOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestIncrementOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestIncrementOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestIncrementOpGenericAdaptor : public detail::TestIncrementOpGenericAdaptorBase { … };
class TestIncrementOpAdaptor : public TestIncrementOpGenericAdaptor<::mlir::ValueRange> { … };
class TestIncrementOp : public ::mlir::Op<TestIncrementOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::InferIntRangeInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestIncrementOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestInternalBranchOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestInternalBranchOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestInternalBranchOpGenericAdaptor : public detail::TestInternalBranchOpGenericAdaptorBase { … };
class TestInternalBranchOpAdaptor : public TestInternalBranchOpGenericAdaptor<::mlir::ValueRange> { … };
class TestInternalBranchOp : public ::mlir::Op<TestInternalBranchOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::NSuccessors<2>::Impl, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::BranchOpInterface::Trait, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestInternalBranchOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestInvalidOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestInvalidOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestInvalidOpGenericAdaptor : public detail::TestInvalidOpGenericAdaptorBase { … };
class TestInvalidOpAdaptor : public TestInvalidOpGenericAdaptor<::mlir::ValueRange> { … };
class TestInvalidOp : public ::mlir::Op<TestInvalidOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestInvalidOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestInvolutionTraitFailingOperationFolderOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestInvolutionTraitFailingOperationFolderOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestInvolutionTraitFailingOperationFolderOpGenericAdaptor : public detail::TestInvolutionTraitFailingOperationFolderOpGenericAdaptorBase { … };
class TestInvolutionTraitFailingOperationFolderOpAdaptor : public TestInvolutionTraitFailingOperationFolderOpGenericAdaptor<::mlir::ValueRange> { … };
class TestInvolutionTraitFailingOperationFolderOp : public ::mlir::Op<TestInvolutionTraitFailingOperationFolderOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsInvolution, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestInvolutionTraitFailingOperationFolderOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestInvolutionTraitNoOperationFolderOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestInvolutionTraitNoOperationFolderOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestInvolutionTraitNoOperationFolderOpGenericAdaptor : public detail::TestInvolutionTraitNoOperationFolderOpGenericAdaptorBase { … };
class TestInvolutionTraitNoOperationFolderOpAdaptor : public TestInvolutionTraitNoOperationFolderOpGenericAdaptor<::mlir::ValueRange> { … };
class TestInvolutionTraitNoOperationFolderOp : public ::mlir::Op<TestInvolutionTraitNoOperationFolderOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsInvolution, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestInvolutionTraitNoOperationFolderOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestInvolutionTraitSuccesfulOperationFolderOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestInvolutionTraitSuccesfulOperationFolderOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestInvolutionTraitSuccesfulOperationFolderOpGenericAdaptor : public detail::TestInvolutionTraitSuccesfulOperationFolderOpGenericAdaptorBase { … };
class TestInvolutionTraitSuccesfulOperationFolderOpAdaptor : public TestInvolutionTraitSuccesfulOperationFolderOpGenericAdaptor<::mlir::ValueRange> { … };
class TestInvolutionTraitSuccesfulOperationFolderOp : public ::mlir::Op<TestInvolutionTraitSuccesfulOperationFolderOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::OpTrait::IsInvolution, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestInvolutionTraitSuccesfulOperationFolderOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestLargeCommutativeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestLargeCommutativeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestLargeCommutativeOpGenericAdaptor : public detail::TestLargeCommutativeOpGenericAdaptorBase { … };
class TestLargeCommutativeOpAdaptor : public TestLargeCommutativeOpGenericAdaptor<::mlir::ValueRange> { … };
class TestLargeCommutativeOp : public ::mlir::Op<TestLargeCommutativeOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<7>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsCommutative, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestLargeCommutativeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestLinalgConvOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestLinalgConvOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestLinalgConvOpGenericAdaptor : public detail::TestLinalgConvOpGenericAdaptorBase { … };
class TestLinalgConvOpAdaptor : public TestLinalgConvOpGenericAdaptor<::mlir::ValueRange> { … };
class TestLinalgConvOp : public ::mlir::Op<TestLinalgConvOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::DestinationStyleOpInterface::Trait, ::mlir::linalg::LinalgOp::Trait, ::mlir::linalg::ConvolutionOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestLinalgConvOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestLinalgConvOpNotLinalgOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestLinalgConvOpNotLinalgOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestLinalgConvOpNotLinalgOpGenericAdaptor : public detail::TestLinalgConvOpNotLinalgOpGenericAdaptorBase { … };
class TestLinalgConvOpNotLinalgOpAdaptor : public TestLinalgConvOpNotLinalgOpGenericAdaptor<::mlir::ValueRange> { … };
class TestLinalgConvOpNotLinalgOp : public ::mlir::Op<TestLinalgConvOpNotLinalgOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::RankedTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<3>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::linalg::ConvolutionOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestLinalgConvOpNotLinalgOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestLinalgFillOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestLinalgFillOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestLinalgFillOpGenericAdaptor : public detail::TestLinalgFillOpGenericAdaptorBase { … };
class TestLinalgFillOpAdaptor : public TestLinalgFillOpGenericAdaptor<::mlir::ValueRange> { … };
class TestLinalgFillOp : public ::mlir::Op<TestLinalgFillOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::DestinationStyleOpInterface::Trait, ::mlir::linalg::LinalgOp::Trait, ::mlir::linalg::FillOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestLinalgFillOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestLinalgFillOpNotLinalgOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestLinalgFillOpNotLinalgOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestLinalgFillOpNotLinalgOpGenericAdaptor : public detail::TestLinalgFillOpNotLinalgOpGenericAdaptorBase { … };
class TestLinalgFillOpNotLinalgOpAdaptor : public TestLinalgFillOpNotLinalgOpGenericAdaptor<::mlir::ValueRange> { … };
class TestLinalgFillOpNotLinalgOp : public ::mlir::Op<TestLinalgFillOpNotLinalgOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::RankedTensorType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants, ::mlir::linalg::FillOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestLinalgFillOpNotLinalgOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestLocationDstNoResOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestLocationDstNoResOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestLocationDstNoResOpGenericAdaptor : public detail::TestLocationDstNoResOpGenericAdaptorBase { … };
class TestLocationDstNoResOpAdaptor : public TestLocationDstNoResOpGenericAdaptor<::mlir::ValueRange> { … };
class TestLocationDstNoResOp : public ::mlir::Op<TestLocationDstNoResOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestLocationDstNoResOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestLocationDstOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestLocationDstOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestLocationDstOpGenericAdaptor : public detail::TestLocationDstOpGenericAdaptorBase { … };
class TestLocationDstOpAdaptor : public TestLocationDstOpGenericAdaptor<::mlir::ValueRange> { … };
class TestLocationDstOp : public ::mlir::Op<TestLocationDstOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestLocationDstOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestLocationSrcNoResOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestLocationSrcNoResOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestLocationSrcNoResOpGenericAdaptor : public detail::TestLocationSrcNoResOpGenericAdaptorBase { … };
class TestLocationSrcNoResOpAdaptor : public TestLocationSrcNoResOpGenericAdaptor<::mlir::ValueRange> { … };
class TestLocationSrcNoResOp : public ::mlir::Op<TestLocationSrcNoResOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestLocationSrcNoResOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestLocationSrcOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestLocationSrcOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestLocationSrcOpGenericAdaptor : public detail::TestLocationSrcOpGenericAdaptorBase { … };
class TestLocationSrcOpAdaptor : public TestLocationSrcOpGenericAdaptor<::mlir::ValueRange> { … };
class TestLocationSrcOp : public ::mlir::Op<TestLocationSrcOp, ::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::TestLocationSrcOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestMergeBlocksOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestMergeBlocksOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestMergeBlocksOpGenericAdaptor : public detail::TestMergeBlocksOpGenericAdaptorBase { … };
class TestMergeBlocksOpAdaptor : public TestMergeBlocksOpGenericAdaptor<::mlir::ValueRange> { … };
class TestMergeBlocksOp : public ::mlir::Op<TestMergeBlocksOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestMergeBlocksOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestMultiSlotAlloca declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestMultiSlotAllocaGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestMultiSlotAllocaGenericAdaptor : public detail::TestMultiSlotAllocaGenericAdaptorBase { … };
class TestMultiSlotAllocaAdaptor : public TestMultiSlotAllocaGenericAdaptor<::mlir::ValueRange> { … };
class TestMultiSlotAlloca : public ::mlir::Op<TestMultiSlotAlloca, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::PromotableAllocationOpInterface::Trait, ::mlir::DestructurableAllocationOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestMultiSlotAlloca)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestNoTerminatorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestNoTerminatorOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestNoTerminatorOpGenericAdaptor : public detail::TestNoTerminatorOpGenericAdaptorBase { … };
class TestNoTerminatorOpAdaptor : public TestNoTerminatorOpGenericAdaptor<::mlir::ValueRange> { … };
class TestNoTerminatorOp : public ::mlir::Op<TestNoTerminatorOp, ::mlir::OpTrait::VariadicRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::NoTerminator, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::RegionBranchOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestNoTerminatorOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpConstant declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpConstantGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpConstantGenericAdaptor : public detail::TestOpConstantGenericAdaptorBase { … };
class TestOpConstantAdaptor : public TestOpConstantGenericAdaptor<::mlir::ValueRange> { … };
class TestOpConstant : public ::mlir::Op<TestOpConstant, ::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::OpTrait::ConstantLike, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestOpConstant)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpFoldWithFoldAdaptor declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpFoldWithFoldAdaptorGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpFoldWithFoldAdaptorGenericAdaptor : public detail::TestOpFoldWithFoldAdaptorGenericAdaptorBase { … };
class TestOpFoldWithFoldAdaptorAdaptor : public TestOpFoldWithFoldAdaptorGenericAdaptor<::mlir::ValueRange> { … };
class TestOpFoldWithFoldAdaptor : public ::mlir::Op<TestOpFoldWithFoldAdaptor, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::NoTerminator, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestOpFoldWithFoldAdaptor)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpInPlaceFold declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpInPlaceFoldGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpInPlaceFoldGenericAdaptor : public detail::TestOpInPlaceFoldGenericAdaptorBase { … };
class TestOpInPlaceFoldAdaptor : public TestOpInPlaceFoldGenericAdaptor<::mlir::ValueRange> { … };
class TestOpInPlaceFold : public ::mlir::Op<TestOpInPlaceFold, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestOpInPlaceFold)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpInPlaceFoldAnchor declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpInPlaceFoldAnchorGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpInPlaceFoldAnchorGenericAdaptor : public detail::TestOpInPlaceFoldAnchorGenericAdaptorBase { … };
class TestOpInPlaceFoldAnchorAdaptor : public TestOpInPlaceFoldAnchorGenericAdaptor<::mlir::ValueRange> { … };
class TestOpInPlaceFoldAnchor : public ::mlir::Op<TestOpInPlaceFoldAnchor, ::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::TestOpInPlaceFoldAnchor)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpInPlaceFoldSuccess declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpInPlaceFoldSuccessGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpInPlaceFoldSuccessGenericAdaptor : public detail::TestOpInPlaceFoldSuccessGenericAdaptorBase { … };
class TestOpInPlaceFoldSuccessAdaptor : public TestOpInPlaceFoldSuccessGenericAdaptor<::mlir::ValueRange> { … };
class TestOpInPlaceFoldSuccess : public ::mlir::Op<TestOpInPlaceFoldSuccess, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestOpInPlaceFoldSuccess)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpInPlaceSelfFold declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpInPlaceSelfFoldGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpInPlaceSelfFoldGenericAdaptor : public detail::TestOpInPlaceSelfFoldGenericAdaptorBase { … };
class TestOpInPlaceSelfFoldAdaptor : public TestOpInPlaceSelfFoldGenericAdaptor<::mlir::ValueRange> { … };
class TestOpInPlaceSelfFold : public ::mlir::Op<TestOpInPlaceSelfFold, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestOpInPlaceSelfFold)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpOptionallyImplementingInterface declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpOptionallyImplementingInterfaceGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpOptionallyImplementingInterfaceGenericAdaptor : public detail::TestOpOptionallyImplementingInterfaceGenericAdaptorBase { … };
class TestOpOptionallyImplementingInterfaceAdaptor : public TestOpOptionallyImplementingInterfaceGenericAdaptor<::mlir::ValueRange> { … };
class TestOpOptionallyImplementingInterface : public ::mlir::Op<TestOpOptionallyImplementingInterface, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::TestOptionallyImplementedOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestOpOptionallyImplementingInterface)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpUsingIntPropertyWithWorseBytecode declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpUsingIntPropertyWithWorseBytecodeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpUsingIntPropertyWithWorseBytecodeGenericAdaptor : public detail::TestOpUsingIntPropertyWithWorseBytecodeGenericAdaptorBase { … };
class TestOpUsingIntPropertyWithWorseBytecodeAdaptor : public TestOpUsingIntPropertyWithWorseBytecodeGenericAdaptor<::mlir::ValueRange> { … };
class TestOpUsingIntPropertyWithWorseBytecode : public ::mlir::Op<TestOpUsingIntPropertyWithWorseBytecode, ::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::TestOpUsingIntPropertyWithWorseBytecode)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpUsingPropertyInCustom declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpUsingPropertyInCustomGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpUsingPropertyInCustomGenericAdaptor : public detail::TestOpUsingPropertyInCustomGenericAdaptorBase { … };
class TestOpUsingPropertyInCustomAdaptor : public TestOpUsingPropertyInCustomGenericAdaptor<::mlir::ValueRange> { … };
class TestOpUsingPropertyInCustom : public ::mlir::Op<TestOpUsingPropertyInCustom, ::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::TestOpUsingPropertyInCustom)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpUsingPropertyInCustomAndOther declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpUsingPropertyInCustomAndOtherGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpUsingPropertyInCustomAndOtherGenericAdaptor : public detail::TestOpUsingPropertyInCustomAndOtherGenericAdaptorBase { … };
class TestOpUsingPropertyInCustomAndOtherAdaptor : public TestOpUsingPropertyInCustomAndOtherGenericAdaptor<::mlir::ValueRange> { … };
class TestOpUsingPropertyInCustomAndOther : public ::mlir::Op<TestOpUsingPropertyInCustomAndOther, ::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::TestOpUsingPropertyInCustomAndOther)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpUsingPropertyRefInCustom declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpUsingPropertyRefInCustomGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpUsingPropertyRefInCustomGenericAdaptor : public detail::TestOpUsingPropertyRefInCustomGenericAdaptorBase { … };
class TestOpUsingPropertyRefInCustomAdaptor : public TestOpUsingPropertyRefInCustomGenericAdaptor<::mlir::ValueRange> { … };
class TestOpUsingPropertyRefInCustom : public ::mlir::Op<TestOpUsingPropertyRefInCustom, ::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::TestOpUsingPropertyRefInCustom)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithArrayProperties declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithArrayPropertiesGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithArrayPropertiesGenericAdaptor : public detail::TestOpWithArrayPropertiesGenericAdaptorBase { … };
class TestOpWithArrayPropertiesAdaptor : public TestOpWithArrayPropertiesGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithArrayProperties : public ::mlir::Op<TestOpWithArrayProperties, ::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::TestOpWithArrayProperties)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithDefaultValuedProperties declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithDefaultValuedPropertiesGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithDefaultValuedPropertiesGenericAdaptor : public detail::TestOpWithDefaultValuedPropertiesGenericAdaptorBase { … };
class TestOpWithDefaultValuedPropertiesAdaptor : public TestOpWithDefaultValuedPropertiesGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithDefaultValuedProperties : public ::mlir::Op<TestOpWithDefaultValuedProperties, ::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::TestOpWithDefaultValuedProperties)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithNiceProperties declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithNicePropertiesGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithNicePropertiesGenericAdaptor : public detail::TestOpWithNicePropertiesGenericAdaptorBase { … };
class TestOpWithNicePropertiesAdaptor : public TestOpWithNicePropertiesGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithNiceProperties : public ::mlir::Op<TestOpWithNiceProperties, ::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::TestOpWithNiceProperties)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithOptionalProperties declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithOptionalPropertiesGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithOptionalPropertiesGenericAdaptor : public detail::TestOpWithOptionalPropertiesGenericAdaptorBase { … };
class TestOpWithOptionalPropertiesAdaptor : public TestOpWithOptionalPropertiesGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithOptionalProperties : public ::mlir::Op<TestOpWithOptionalProperties, ::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::TestOpWithOptionalProperties)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithProperties declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithPropertiesGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithPropertiesGenericAdaptor : public detail::TestOpWithPropertiesGenericAdaptorBase { … };
class TestOpWithPropertiesAdaptor : public TestOpWithPropertiesGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithProperties : public ::mlir::Op<TestOpWithProperties, ::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::TestOpWithProperties)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithPropertiesAndAttr declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithPropertiesAndAttrGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithPropertiesAndAttrGenericAdaptor : public detail::TestOpWithPropertiesAndAttrGenericAdaptorBase { … };
class TestOpWithPropertiesAndAttrAdaptor : public TestOpWithPropertiesAndAttrGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithPropertiesAndAttr : public ::mlir::Op<TestOpWithPropertiesAndAttr, ::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::TestOpWithPropertiesAndAttr)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithPropertiesAndInferredType declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithPropertiesAndInferredTypeGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithPropertiesAndInferredTypeGenericAdaptor : public detail::TestOpWithPropertiesAndInferredTypeGenericAdaptorBase { … };
class TestOpWithPropertiesAndInferredTypeAdaptor : public TestOpWithPropertiesAndInferredTypeGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithPropertiesAndInferredType : public ::mlir::Op<TestOpWithPropertiesAndInferredType, ::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::TestOpWithPropertiesAndInferredType)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithRegionFold declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithRegionFoldGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithRegionFoldGenericAdaptor : public detail::TestOpWithRegionFoldGenericAdaptorBase { … };
class TestOpWithRegionFoldAdaptor : public TestOpWithRegionFoldGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithRegionFold : public ::mlir::Op<TestOpWithRegionFold, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestOpWithRegionFold)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithRegionFoldNoMemoryEffect declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithRegionFoldNoMemoryEffectGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithRegionFoldNoMemoryEffectGenericAdaptor : public detail::TestOpWithRegionFoldNoMemoryEffectGenericAdaptorBase { … };
class TestOpWithRegionFoldNoMemoryEffectAdaptor : public TestOpWithRegionFoldNoMemoryEffectGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithRegionFoldNoMemoryEffect : public ::mlir::Op<TestOpWithRegionFoldNoMemoryEffect, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestOpWithRegionFoldNoMemoryEffect)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithRegionPattern declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithRegionPatternGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithRegionPatternGenericAdaptor : public detail::TestOpWithRegionPatternGenericAdaptorBase { … };
class TestOpWithRegionPatternAdaptor : public TestOpWithRegionPatternGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithRegionPattern : public ::mlir::Op<TestOpWithRegionPattern, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestOpWithRegionPattern)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithVariadicResultsAndFolder declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithVariadicResultsAndFolderGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithVariadicResultsAndFolderGenericAdaptor : public detail::TestOpWithVariadicResultsAndFolderGenericAdaptorBase { … };
class TestOpWithVariadicResultsAndFolderAdaptor : public TestOpWithVariadicResultsAndFolderGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithVariadicResultsAndFolder : public ::mlir::Op<TestOpWithVariadicResultsAndFolder, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestOpWithVariadicResultsAndFolder)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithVersionedProperties declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithVersionedPropertiesGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithVersionedPropertiesGenericAdaptor : public detail::TestOpWithVersionedPropertiesGenericAdaptorBase { … };
class TestOpWithVersionedPropertiesAdaptor : public TestOpWithVersionedPropertiesGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithVersionedProperties : public ::mlir::Op<TestOpWithVersionedProperties, ::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::TestOpWithVersionedProperties)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestOpWithWrappedProperties declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestOpWithWrappedPropertiesGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestOpWithWrappedPropertiesGenericAdaptor : public detail::TestOpWithWrappedPropertiesGenericAdaptorBase { … };
class TestOpWithWrappedPropertiesAdaptor : public TestOpWithWrappedPropertiesGenericAdaptor<::mlir::ValueRange> { … };
class TestOpWithWrappedProperties : public ::mlir::Op<TestOpWithWrappedProperties, ::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::TestOpWithWrappedProperties)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestProducingBranchOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestProducingBranchOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestProducingBranchOpGenericAdaptor : public detail::TestProducingBranchOpGenericAdaptorBase { … };
class TestProducingBranchOpAdaptor : public TestProducingBranchOpGenericAdaptor<::mlir::ValueRange> { … };
class TestProducingBranchOp : public ::mlir::Op<TestProducingBranchOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::NSuccessors<2>::Impl, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::AttrSizedOperandSegments, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::BranchOpInterface::Trait, ::mlir::OpTrait::IsTerminator, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestProducingBranchOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestPropOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestPropOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestPropOpGenericAdaptor : public detail::TestPropOpGenericAdaptorBase { … };
class TestPropOpAdaptor : public TestPropOpGenericAdaptor<::mlir::ValueRange> { … };
class TestPropOp : public ::mlir::Op<TestPropOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::DerivedAttributeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestPropOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestRecursiveRewriteOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestRecursiveRewriteOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestRecursiveRewriteOpGenericAdaptor : public detail::TestRecursiveRewriteOpGenericAdaptorBase { … };
class TestRecursiveRewriteOpAdaptor : public TestRecursiveRewriteOpGenericAdaptor<::mlir::ValueRange> { … };
class TestRecursiveRewriteOp : public ::mlir::Op<TestRecursiveRewriteOp, ::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::TestRecursiveRewriteOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestReflectBoundsOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestReflectBoundsOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestReflectBoundsOpGenericAdaptor : public detail::TestReflectBoundsOpGenericAdaptorBase { … };
class TestReflectBoundsOpAdaptor : public TestReflectBoundsOpGenericAdaptor<::mlir::ValueRange> { … };
class TestReflectBoundsOp : public ::mlir::Op<TestReflectBoundsOp, ::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::InferIntRangeInterface::Trait, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestReflectBoundsOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestRegionBuilderOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestRegionBuilderOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestRegionBuilderOpGenericAdaptor : public detail::TestRegionBuilderOpGenericAdaptorBase { … };
class TestRegionBuilderOpAdaptor : public TestRegionBuilderOpGenericAdaptor<::mlir::ValueRange> { … };
class TestRegionBuilderOp : public ::mlir::Op<TestRegionBuilderOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestRegionBuilderOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestRemappedValueRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestRemappedValueRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestRemappedValueRegionOpGenericAdaptor : public detail::TestRemappedValueRegionOpGenericAdaptorBase { … };
class TestRemappedValueRegionOpAdaptor : public TestRemappedValueRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class TestRemappedValueRegionOp : public ::mlir::Op<TestRemappedValueRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestRemappedValueRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestReturnOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestReturnOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestReturnOpGenericAdaptor : public detail::TestReturnOpGenericAdaptorBase { … };
class TestReturnOpAdaptor : public TestReturnOpGenericAdaptor<::mlir::ValueRange> { … };
class TestReturnOp : public ::mlir::Op<TestReturnOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::ConditionallySpeculatable::Trait, ::mlir::OpTrait::AlwaysSpeculatableImplTrait, ::mlir::MemoryEffectOpInterface::Trait, ::mlir::RegionBranchTerminatorOpInterface::Trait, ::mlir::OpTrait::ReturnLike, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestReturnOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestRewriteOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestRewriteOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestRewriteOpGenericAdaptor : public detail::TestRewriteOpGenericAdaptorBase { … };
class TestRewriteOpAdaptor : public TestRewriteOpGenericAdaptor<::mlir::ValueRange> { … };
class TestRewriteOp : public ::mlir::Op<TestRewriteOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestRewriteOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestSignatureConversionNoConverterOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestSignatureConversionNoConverterOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestSignatureConversionNoConverterOpGenericAdaptor : public detail::TestSignatureConversionNoConverterOpGenericAdaptorBase { … };
class TestSignatureConversionNoConverterOpAdaptor : public TestSignatureConversionNoConverterOpGenericAdaptor<::mlir::ValueRange> { … };
class TestSignatureConversionNoConverterOp : public ::mlir::Op<TestSignatureConversionNoConverterOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestSignatureConversionNoConverterOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestSignatureConversionUndoOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestSignatureConversionUndoOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestSignatureConversionUndoOpGenericAdaptor : public detail::TestSignatureConversionUndoOpGenericAdaptorBase { … };
class TestSignatureConversionUndoOpAdaptor : public TestSignatureConversionUndoOpGenericAdaptor<::mlir::ValueRange> { … };
class TestSignatureConversionUndoOp : public ::mlir::Op<TestSignatureConversionUndoOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestSignatureConversionUndoOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestStoreWithALoopRegion declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestStoreWithALoopRegionGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestStoreWithALoopRegionGenericAdaptor : public detail::TestStoreWithALoopRegionGenericAdaptorBase { … };
class TestStoreWithALoopRegionAdaptor : public TestStoreWithALoopRegionGenericAdaptor<::mlir::ValueRange> { … };
class TestStoreWithALoopRegion : public ::mlir::Op<TestStoreWithALoopRegion, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::RegionBranchOpInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestStoreWithALoopRegion)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestStoreWithARegion declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestStoreWithARegionGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestStoreWithARegionGenericAdaptor : public detail::TestStoreWithARegionGenericAdaptorBase { … };
class TestStoreWithARegionAdaptor : public TestStoreWithARegionGenericAdaptor<::mlir::ValueRange> { … };
class TestStoreWithARegion : public ::mlir::Op<TestStoreWithARegion, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::RegionBranchOpInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestStoreWithARegion)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestStoreWithARegionTerminator declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestStoreWithARegionTerminatorGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestStoreWithARegionTerminatorGenericAdaptor : public detail::TestStoreWithARegionTerminatorGenericAdaptorBase { … };
class TestStoreWithARegionTerminatorAdaptor : public TestStoreWithARegionTerminatorGenericAdaptor<::mlir::ValueRange> { … };
class TestStoreWithARegionTerminator : public ::mlir::Op<TestStoreWithARegionTerminator, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::RegionBranchTerminatorOpInterface::Trait, ::mlir::OpTrait::ReturnLike, ::mlir::OpTrait::IsTerminator, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestStoreWithARegionTerminator)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestTypeChangerOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestTypeChangerOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestTypeChangerOpGenericAdaptor : public detail::TestTypeChangerOpGenericAdaptorBase { … };
class TestTypeChangerOpAdaptor : public TestTypeChangerOpGenericAdaptor<::mlir::ValueRange> { … };
class TestTypeChangerOp : public ::mlir::Op<TestTypeChangerOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestTypeChangerOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestTypeConsumerOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestTypeConsumerOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestTypeConsumerOpGenericAdaptor : public detail::TestTypeConsumerOpGenericAdaptorBase { … };
class TestTypeConsumerOpAdaptor : public TestTypeConsumerOpGenericAdaptor<::mlir::ValueRange> { … };
class TestTypeConsumerOp : public ::mlir::Op<TestTypeConsumerOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestTypeConsumerOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestTypeProducerOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestTypeProducerOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestTypeProducerOpGenericAdaptor : public detail::TestTypeProducerOpGenericAdaptorBase { … };
class TestTypeProducerOpAdaptor : public TestTypeProducerOpGenericAdaptor<::mlir::ValueRange> { … };
class TestTypeProducerOp : public ::mlir::Op<TestTypeProducerOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestTypeProducerOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestValidOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestValidOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestValidOpGenericAdaptor : public detail::TestValidOpGenericAdaptorBase { … };
class TestValidOpAdaptor : public TestValidOpGenericAdaptor<::mlir::ValueRange> { … };
class TestValidOp : public ::mlir::Op<TestValidOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsTerminator> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestValidOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestVariadicRewriteDstOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestVariadicRewriteDstOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestVariadicRewriteDstOpGenericAdaptor : public detail::TestVariadicRewriteDstOpGenericAdaptorBase { … };
class TestVariadicRewriteDstOpAdaptor : public TestVariadicRewriteDstOpGenericAdaptor<::mlir::ValueRange> { … };
class TestVariadicRewriteDstOp : public ::mlir::Op<TestVariadicRewriteDstOp, ::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::TestVariadicRewriteDstOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestVariadicRewriteSrcOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestVariadicRewriteSrcOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestVariadicRewriteSrcOpGenericAdaptor : public detail::TestVariadicRewriteSrcOpGenericAdaptorBase { … };
class TestVariadicRewriteSrcOpAdaptor : public TestVariadicRewriteSrcOpGenericAdaptor<::mlir::ValueRange> { … };
class TestVariadicRewriteSrcOp : public ::mlir::Op<TestVariadicRewriteSrcOp, ::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::TestVariadicRewriteSrcOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestVerifiersOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestVerifiersOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestVerifiersOpGenericAdaptor : public detail::TestVerifiersOpGenericAdaptorBase { … };
class TestVerifiersOpAdaptor : public TestVerifiersOpGenericAdaptor<::mlir::ValueRange> { … };
class TestVerifiersOp : public ::mlir::Op<TestVerifiersOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::OneOperand, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::NoTerminator, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::IsIsolatedFromAbove> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestVerifiersOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestVersionedOpA declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestVersionedOpAGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestVersionedOpAGenericAdaptor : public detail::TestVersionedOpAGenericAdaptorBase { … };
class TestVersionedOpAAdaptor : public TestVersionedOpAGenericAdaptor<::mlir::ValueRange> { … };
class TestVersionedOpA : public ::mlir::Op<TestVersionedOpA, ::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::TestVersionedOpA)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestVersionedOpB declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestVersionedOpBGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestVersionedOpBGenericAdaptor : public detail::TestVersionedOpBGenericAdaptorBase { … };
class TestVersionedOpBAdaptor : public TestVersionedOpBGenericAdaptor<::mlir::ValueRange> { … };
class TestVersionedOpB : public ::mlir::Op<TestVersionedOpB, ::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::TestVersionedOpB)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestVersionedOpC declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestVersionedOpCGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestVersionedOpCGenericAdaptor : public detail::TestVersionedOpCGenericAdaptorBase { … };
class TestVersionedOpCAdaptor : public TestVersionedOpCGenericAdaptor<::mlir::ValueRange> { … };
class TestVersionedOpC : public ::mlir::Op<TestVersionedOpC, ::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::TestVersionedOpC)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestWithBoundsOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestWithBoundsOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestWithBoundsOpGenericAdaptor : public detail::TestWithBoundsOpGenericAdaptorBase { … };
class TestWithBoundsOpAdaptor : public TestWithBoundsOpGenericAdaptor<::mlir::ValueRange> { … };
class TestWithBoundsOp : public ::mlir::Op<TestWithBoundsOp, ::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::InferIntRangeInterface::Trait, ::mlir::MemoryEffectOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestWithBoundsOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TestWithBoundsRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TestWithBoundsRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TestWithBoundsRegionOpGenericAdaptor : public detail::TestWithBoundsRegionOpGenericAdaptorBase { … };
class TestWithBoundsRegionOpAdaptor : public TestWithBoundsRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class TestWithBoundsRegionOp : public ::mlir::Op<TestWithBoundsRegionOp, ::mlir::OpTrait::OneRegion, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::NoTerminator, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferIntRangeInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TestWithBoundsRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::ThreeResultOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class ThreeResultOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class ThreeResultOpGenericAdaptor : public detail::ThreeResultOpGenericAdaptorBase { … };
class ThreeResultOpAdaptor : public ThreeResultOpGenericAdaptor<::mlir::ValueRange> { … };
class ThreeResultOp : public ::mlir::Op<ThreeResultOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<3>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::ThreeResultOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TupleOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TupleOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TupleOpGenericAdaptor : public detail::TupleOpGenericAdaptorBase { … };
class TupleOpAdaptor : public TupleOpGenericAdaptor<::mlir::ValueRange> { … };
class TupleOp : public ::mlir::Op<TupleOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::Type>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TupleOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TwoRegionOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TwoRegionOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TwoRegionOpGenericAdaptor : public detail::TwoRegionOpGenericAdaptorBase { … };
class TwoRegionOpAdaptor : public TwoRegionOpGenericAdaptor<::mlir::ValueRange> { … };
class TwoRegionOp : public ::mlir::Op<TwoRegionOp, ::mlir::OpTrait::NRegions<2>::Impl, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TwoRegionOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TwoResultOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TwoResultOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TwoResultOpGenericAdaptor : public detail::TwoResultOpGenericAdaptorBase { … };
class TwoResultOpAdaptor : public TwoResultOpGenericAdaptor<::mlir::ValueRange> { … };
class TwoResultOp : public ::mlir::Op<TwoResultOp, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::NResults<2>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::BytecodeOpInterface::Trait, ::mlir::InferTypeOpInterface::Trait, ::mlir::OpAsmOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TwoResultOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TwoToOne declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TwoToOneGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TwoToOneGenericAdaptor : public detail::TwoToOneGenericAdaptorBase { … };
class TwoToOneAdaptor : public TwoToOneGenericAdaptor<::mlir::ValueRange> { … };
class TwoToOne : public ::mlir::Op<TwoToOne, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::NOperands<2>::Impl, ::mlir::OpTrait::OpInvariants> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::TwoToOne)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TypeArrayAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TypeArrayAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TypeArrayAttrOpGenericAdaptor : public detail::TypeArrayAttrOpGenericAdaptorBase { … };
class TypeArrayAttrOpAdaptor : public TypeArrayAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class TypeArrayAttrOp : public ::mlir::Op<TypeArrayAttrOp, ::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::TypeArrayAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TypeArrayAttrWithDefaultOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TypeArrayAttrWithDefaultOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TypeArrayAttrWithDefaultOpGenericAdaptor : public detail::TypeArrayAttrWithDefaultOpGenericAdaptorBase { … };
class TypeArrayAttrWithDefaultOpAdaptor : public TypeArrayAttrWithDefaultOpGenericAdaptor<::mlir::ValueRange> { … };
class TypeArrayAttrWithDefaultOp : public ::mlir::Op<TypeArrayAttrWithDefaultOp, ::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::TypeArrayAttrWithDefaultOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TypeAttrOfOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TypeAttrOfOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TypeAttrOfOpGenericAdaptor : public detail::TypeAttrOfOpGenericAdaptorBase { … };
class TypeAttrOfOpAdaptor : public TypeAttrOfOpGenericAdaptor<::mlir::ValueRange> { … };
class TypeAttrOfOp : public ::mlir::Op<TypeAttrOfOp, ::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::TypeAttrOfOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TypeStringAttrWithTypeOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TypeStringAttrWithTypeOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TypeStringAttrWithTypeOpGenericAdaptor : public detail::TypeStringAttrWithTypeOpGenericAdaptorBase { … };
class TypeStringAttrWithTypeOpAdaptor : public TypeStringAttrWithTypeOpGenericAdaptor<::mlir::ValueRange> { … };
class TypeStringAttrWithTypeOp : public ::mlir::Op<TypeStringAttrWithTypeOp, ::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::TypeStringAttrWithTypeOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::TypedAttrOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class TypedAttrOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class TypedAttrOpGenericAdaptor : public detail::TypedAttrOpGenericAdaptorBase { … };
class TypedAttrOpAdaptor : public TypedAttrOpGenericAdaptor<::mlir::ValueRange> { … };
class TypedAttrOp : public ::mlir::Op<TypedAttrOp, ::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::TypedAttrOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::VariadicNoTerminatorOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class VariadicNoTerminatorOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class VariadicNoTerminatorOpGenericAdaptor : public detail::VariadicNoTerminatorOpGenericAdaptorBase { … };
class VariadicNoTerminatorOpAdaptor : public VariadicNoTerminatorOpGenericAdaptor<::mlir::ValueRange> { … };
class VariadicNoTerminatorOp : public ::mlir::Op<VariadicNoTerminatorOp, ::mlir::OpTrait::VariadicRegions, ::mlir::OpTrait::ZeroResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::NoTerminator, ::mlir::OpTrait::SingleBlock, ::mlir::OpTrait::OpInvariants, ::mlir::RegionKindInterface::Trait, ::mlir::OpTrait::HasOnlyGraphRegion> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::VariadicNoTerminatorOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::VariadicRegionInferredTypesOp declarations
//===----------------------------------------------------------------------===//

namespace detail {
class VariadicRegionInferredTypesOpGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class VariadicRegionInferredTypesOpGenericAdaptor : public detail::VariadicRegionInferredTypesOpGenericAdaptorBase { … };
class VariadicRegionInferredTypesOpAdaptor : public VariadicRegionInferredTypesOpGenericAdaptor<::mlir::ValueRange> { … };
class VariadicRegionInferredTypesOp : public ::mlir::Op<VariadicRegionInferredTypesOp, ::mlir::OpTrait::VariadicRegions, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::ZeroOperands, ::mlir::OpTrait::OpInvariants, ::mlir::InferTypeOpInterface::Trait> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::VariadicRegionInferredTypesOp)

namespace test {

//===----------------------------------------------------------------------===//
// ::test::VariadicWithSameOperandsResult declarations
//===----------------------------------------------------------------------===//

namespace detail {
class VariadicWithSameOperandsResultGenericAdaptorBase { … };
} // namespace detail
template <typename RangeT>
class VariadicWithSameOperandsResultGenericAdaptor : public detail::VariadicWithSameOperandsResultGenericAdaptorBase { … };
class VariadicWithSameOperandsResultAdaptor : public VariadicWithSameOperandsResultGenericAdaptor<::mlir::ValueRange> { … };
class VariadicWithSameOperandsResult : public ::mlir::Op<VariadicWithSameOperandsResult, ::mlir::OpTrait::ZeroRegions, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::OneTypedResult<::mlir::IntegerType>::Impl, ::mlir::OpTrait::ZeroSuccessors, ::mlir::OpTrait::VariadicOperands, ::mlir::OpTrait::OpInvariants, ::mlir::OpTrait::SameOperandsAndResultType> { … };
} // namespace test
MLIR_DECLARE_EXPLICIT_TYPE_ID(::test::VariadicWithSameOperandsResult)


#endif  // GET_OP_CLASSES

namespace test {
void registerTestDialectOperations(::test::TestDialect *dialect);
void registerTestDialectOperations0(::test::TestDialect *dialect);
void registerTestDialectOperations1(::test::TestDialect *dialect);
void registerTestDialectOperations2(::test::TestDialect *dialect);
void registerTestDialectOperations3(::test::TestDialect *dialect);
void registerTestDialectOperations4(::test::TestDialect *dialect);
void registerTestDialectOperations5(::test::TestDialect *dialect);
void registerTestDialectOperations6(::test::TestDialect *dialect);
void registerTestDialectOperations7(::test::TestDialect *dialect);
void registerTestDialectOperations8(::test::TestDialect *dialect);
void registerTestDialectOperations9(::test::TestDialect *dialect);
void registerTestDialectOperations10(::test::TestDialect *dialect);
void registerTestDialectOperations11(::test::TestDialect *dialect);
void registerTestDialectOperations12(::test::TestDialect *dialect);
void registerTestDialectOperations13(::test::TestDialect *dialect);
void registerTestDialectOperations14(::test::TestDialect *dialect);
void registerTestDialectOperations15(::test::TestDialect *dialect);
void registerTestDialectOperations16(::test::TestDialect *dialect);
void registerTestDialectOperations17(::test::TestDialect *dialect);
void registerTestDialectOperations18(::test::TestDialect *dialect);
void registerTestDialectOperations19(::test::TestDialect *dialect);
} // namespace test