[ODS] Use Adaptor Traits for Type Inference

[amandatang]

Summary

Author inferReturnTypes methods with the Op Adaptor by using the InferTypeOpAdaptor.

[amandatang]

Fix naming

[amandatang]

Use function overloading

[jpienaar]

mlir/test/lib/Dialect/Test/TestDialect.cpp

1392

Is getX and getY general here?

[amandatang]

mlir/test/lib/Dialect/Test/TestDialect.cpp

1392

No, the arguments of OpWithInferTypeAdaptorInterfaceOp are named x and y.

[mehdi_amini]

This broke the bot, can you fix or revert?

https://lab.llvm.org/buildbot/#/builders/61/builds/46176

+ /vol/worker/mlir-nvidia/mlir-nvidia/llvm.obj/bin/FileCheck /vol/worker/mlir-nvidia/mlir-nvidia/llvm.src/mlir/test/python/dialects/shape.py
error: missing shape attribute
Traceback (most recent call last):
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.src/mlir/test/python/dialects/shape.py", line 17, in <module>
    def testConstShape():
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.src/mlir/test/python/dialects/shape.py", line 11, in run
    f()
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.src/mlir/test/python/dialects/shape.py", line 26, in testConstShape
    def const_shape_tensor(arg):
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.obj/tools/mlir/python_packages/mlir_core/mlir/dialects/_func_ops_ext.py", line 190, in decorator
    return_values = f(*func_args, **func_kwargs)
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.src/mlir/test/python/dialects/shape.py", line 30, in const_shape_tensor
    x = shape.ConstShapeOp([1, 2])
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.obj/tools/mlir/python_packages/mlir_core/mlir/dialects/_shape_ops_gen.py", line 278, in __init__
    results = _ods_ir.InferTypeOpInterface(ConstShapeOp).inferReturnTypes(
ValueError: Failed to infer result types

[amandatang]

In D155115#4511875, @mehdi_amini wrote:

This broke the bot, can you fix or revert?

https://lab.llvm.org/buildbot/#/builders/61/builds/46176

+ /vol/worker/mlir-nvidia/mlir-nvidia/llvm.obj/bin/FileCheck /vol/worker/mlir-nvidia/mlir-nvidia/llvm.src/mlir/test/python/dialects/shape.py
error: missing shape attribute
Traceback (most recent call last):
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.src/mlir/test/python/dialects/shape.py", line 17, in <module>
    def testConstShape():
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.src/mlir/test/python/dialects/shape.py", line 11, in run
    f()
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.src/mlir/test/python/dialects/shape.py", line 26, in testConstShape
    def const_shape_tensor(arg):
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.obj/tools/mlir/python_packages/mlir_core/mlir/dialects/_func_ops_ext.py", line 190, in decorator
    return_values = f(*func_args, **func_kwargs)
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.src/mlir/test/python/dialects/shape.py", line 30, in const_shape_tensor
    x = shape.ConstShapeOp([1, 2])
  File "/vol/worker/mlir-nvidia/mlir-nvidia/llvm.obj/tools/mlir/python_packages/mlir_core/mlir/dialects/_shape_ops_gen.py", line 278, in __init__
    results = _ods_ir.InferTypeOpInterface(ConstShapeOp).inferReturnTypes(
ValueError: Failed to infer result types

Yes, I'm investigating the error now.

[amandatang]

Here's a patch that fixes the issue: https://reviews.llvm.org/D155637

mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td

 // ExtractStridedMetadataOp
 //===----------------------------------------------------------------------===//
 
 def MemRef_ExtractStridedMetadataOp : MemRef_Op<"extract_strided_metadata", [
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
     Pure,
     SameVariadicResultSize,
     ViewLikeOpInterface,
-    InferTypeOpInterfaceAdaptor]> {
+    InferTypeOpAdaptor]> {
   let summary = "Extracts a buffer base with offset and strides";
   let description = [{
     Extracts a base buffer, offset and strides. This op allows additional layers
     of transformations and foldings to be added as lowering progresses from
     higher-level dialect to lower-level dialects such as the LLVM dialect.
 
     The op requires a strided memref source operand. If the source operand is not
     a strided memref, then verification fails.

mlir/include/mlir/Dialect/SCF/IR/SCFOps.td

 }
 
 //===----------------------------------------------------------------------===//
 // IfOp
 //===----------------------------------------------------------------------===//
 
 def IfOp : SCF_Op<"if", [DeclareOpInterfaceMethods<RegionBranchOpInterface, [
     "getNumRegionInvocations", "getRegionInvocationBounds"]>,
-    DeclareOpInterfaceMethods<InferTypeOpInterface>,
-    SingleBlockImplicitTerminator<"scf::YieldOp">, RecursiveMemoryEffects,
-    NoRegionArguments]> {
+    InferTypeOpAdaptor, SingleBlockImplicitTerminator<"scf::YieldOp">,
+    RecursiveMemoryEffects, NoRegionArguments]> {
   let summary = "if-then-else operation";
   let description = [{
     The `scf.if` operation represents an if-then-else construct for
     conditionally executing two regions of code. The operand to an if operation
     is a boolean value. For example:
 
     ```mlir
     scf.if %b  {

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

 // Shape op definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for the operation in this dialect
 class Shape_Op<string mnemonic, list<Trait> traits = []> :
     Op<ShapeDialect, mnemonic, traits>;
 
 def Shape_AddOp : Shape_Op<"add",
-    [Commutative, Pure,
-     DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Commutative, Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Addition of sizes and indices";
   let description = [{
     Adds two sizes or indices. If either operand is an error it will be
     propagated to the result. The operands can be of type `size` or `index`. If
     at least one of the operands can hold an error, i.e. if it is of type
     `size`, the result must be of type `size`. If error propagation is not
     possible because both operands are of type `index` then the result may be
     of type `size` or `index`.
   }];
 
   let arguments = (ins Shape_SizeOrIndexType:$lhs, Shape_SizeOrIndexType:$rhs);
   let results = (outs Shape_SizeOrIndexType:$result);
 
   let assemblyFormat = [{
     $lhs `,` $rhs attr-dict `:` type($lhs) `,` type($rhs) `->` type($result)
   }];
 
-  let extraClassDeclaration = [{
-    // Returns when two result types are compatible for this op; method used by
-    // InferTypeOpInterface
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
-  }];
-
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
 def Shape_BroadcastOp : Shape_Op<"broadcast", [Commutative, Pure]> {
   let summary = "Returns the broadcasted output shape of two or more inputs";
   let description = [{
     Returns the broadcasted shape for input shapes or extent tensors. The rest
def Shape_BroadcastOp : Shape_Op<"broadcast", [Commutative, Pure]> {
   ];
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 
 def Shape_ConstShapeOp : Shape_Op<"const_shape",
-    [ConstantLike, Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [ConstantLike, Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Creates a constant shape or extent tensor";
   let description = [{
     Creates a constant shape or extent tensor. The individual extents are given
     as the `shape` attribute. The number of these values equals the shape's
     rank.
 
     ```mlir
     %0 = shape.const_shape [] : !shape.shape
     %1 = shape.const_shape [1, 2, 3] : !shape.shape
     %2 = shape.const_shape [4, 5, 6] : tensor<3xindex>
     ```
   }];
   let arguments = (ins IndexElementsAttr:$shape);
   let results = (outs Shape_ShapeOrExtentTensorType:$result);
 
   let hasCustomAssemblyFormat = 1;
   let hasFolder = 1;
   let hasCanonicalizer = 1;
-
-  let extraClassDeclaration = [{
-    // InferTypeOpInterface:
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
-  }];
 }
 
 def Shape_ConstSizeOp : Shape_Op<"const_size", [
     ConstantLike,
     Pure,
     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>
   ]> {
   let summary = "Creates a constant of type `shape.size`";
def Shape_ConstSizeOp : Shape_Op<"const_size", [
   let results = (outs Shape_SizeType:$result);
 
   let builders = [OpBuilder<(ins "int64_t":$value)>];
 
   let assemblyFormat = "$value attr-dict";
   let hasFolder = 1;
 }
 
-def Shape_DivOp : Shape_Op<"div", [Pure,
-                           DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+def Shape_DivOp : Shape_Op<"div", [Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Division of sizes and indices";
   let description = [{
     Divides two sizes or indices. If either operand is an error it will be
     propagated to the result. The operands can be of type `size` or `index`.
     If at least one of the operands can hold an error, i.e. if it is of type
     `size`, the result must be of type `size`. If error propagation is not
     possible because both operands are of type `index` then the result may be
     of type  `size` or `index`. If both operands and result are of type
def Shape_DivOp : Shape_Op<"div", [Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let results = (outs Shape_SizeOrIndexType:$result);
 
   let assemblyFormat = [{
     $lhs `,` $rhs attr-dict `:` type($lhs) `,` type($rhs) `->` type($result)
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
-
-  let extraClassDeclaration = [{
-    // Returns when two result types are compatible for this op; method used by
-    // InferTypeOpInterface
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
-  }];
 }
 
 def Shape_ShapeEqOp : Shape_Op<"shape_eq", [Pure, Commutative]> {
   let summary = "Returns whether the input shapes or extent tensors are equal";
   let description = [{
     Takes one or more shape or extent tensor operands and determines whether
     they are equal. When extent tensors are compared to shapes they are
     regarded as their equivalent non-error shapes. Error shapes can be tested
def Shape_IsBroadcastableOp : Shape_Op<"is_broadcastable", [Commutative]> {
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 
   let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
 }
 
 def Shape_RankOp : Shape_Op<"rank",
-    [Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Gets the rank of a shape";
   let description = [{
     Returns the rank of the shape or extent tensor, i.e. the number of extents.
   }];
 
   let arguments = (ins Shape_ShapeOrExtentTensorType:$shape);
   let results = (outs Shape_SizeOrIndexType:$rank);
 
   let assemblyFormat = "$shape attr-dict `:` type($shape) `->` type($rank)";
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
-
-  let extraClassDeclaration = [{
-    // Returns when two result types are compatible for this op; method used by
-    // InferTypeOpInterface
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
-  }];
 }
 
 def Shape_ToExtentTensorOp : Shape_Op<"to_extent_tensor", [
     DeclareOpInterfaceMethods<CastOpInterface>, Pure
   ]> {
   let summary = "Creates a dimension tensor from a shape";
   let description = [{
     Converts a shape to a 1D integral tensor of extents. The number of elements
     in the tensor equals the rank of the shape, and the elements equal the
     extents of the shape.
 
     If the shape represents an error, this op's behavior is undefined.
   }];
 
   let arguments = (ins Shape_ShapeOrExtentTensorType:$input);
   let results = (outs IndexTensor:$result);
 
   let assemblyFormat = "$input attr-dict `:` type($input) `->` type($result)";
 
   let hasFolder = 1;
 }
 
 def Shape_DimOp : Shape_Op<"dim",
-    [Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Gets the specified extent from the shape of a shaped input";
   let description = [{
     Gets the extent indexed by `dim` from the shape of the `value` operand. If
     the index is error or out-of-bound then it returns an invalid size if the
     return type carries error information else the behavior is undefined.
 
     This is a convenience op that performs the equivalent of getting the extent
     of a shape (e.g., `dim(x, i) == get_extent(shape_of(x), i)`).
   }];
   let arguments = (ins AnyShaped:$value,
                        Shape_SizeOrIndexType:$index);
   let results = (outs Shape_SizeOrIndexType:$extent);
   let assemblyFormat = "$value `,` $index attr-dict `:` type($value) `,`"
                        "type($index) `->` type($extent)";
 
   let builders = [
     // Builder that allows passing a constant dimension as a simple integer.
     OpBuilder<(ins "Value":$value, "int64_t":$index)>
   ];
 
   let extraClassDeclaration = [{
     /// Get the `index` value as integer if it is constant.
     std::optional<int64_t> getConstantIndex();
-
-    /// Returns when two result types are compatible for this op; method used
-    /// by InferTypeOpInterface
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 
   let hasFolder = 1;
 }
 
 def Shape_GetExtentOp : Shape_Op<"get_extent",
-    [Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Gets the specified extent from a shape or extent tensor";
   let description = [{
     Gets the extent indexed by `dim` from the `shape` operand. If the shape is
     an error then it returns an invalid size.
   }];
   let arguments = (ins Shape_ShapeOrExtentTensorType:$shape,
                        Shape_SizeOrIndexType:$dim);
   let results = (outs Shape_SizeOrIndexType:$extent);
   let assemblyFormat = "$shape `,` $dim attr-dict `:` type($shape) `,` "
                        "type($dim) `->` type($extent)";
 
   let builders = [
     // Builder that allows passing a constant dimension as a simple integer.
     OpBuilder<(ins "Value":$shape, "int64_t":$dim)>
   ];
 
   let extraClassDeclaration = [{
     /// Get the `dim` value as integer if it is constant.
     std::optional<int64_t> getConstantDim();
-    /// Returns when two result types are compatible for this op; method used
-    /// by InferTypeOpInterface
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
 def Shape_IndexToSizeOp : Shape_Op<"index_to_size", [Pure]> {
   let summary = "Converts a standard index to a shape size";
def Shape_IndexToSizeOp : Shape_Op<"index_to_size", [Pure]> {
 
   let assemblyFormat = "$arg attr-dict";
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 
 def Shape_MaxOp : Shape_Op<"max",
-    [Commutative, Pure,
-     DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Commutative, Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Elementwise maximum";
   let description = [{
     Computes the elementwise maximum of two sizes or shapes with equal ranks.
     If either operand is an error, then an error will be propagated to the
     result. If the input types mismatch or the ranks do not match, then the
     result is an error.
   }];
 
   let arguments = (ins Shape_ShapeOrSizeType:$lhs, Shape_ShapeOrSizeType:$rhs);
   let results = (outs Shape_ShapeOrSizeType:$result);
 
   let assemblyFormat = [{
     $lhs `,` $rhs attr-dict `:` type($lhs) `,` type($rhs) `->` type($result)
   }];
 
   let hasFolder = 1;
-
-  let extraClassDeclaration = [{
-    // Returns when two result types are compatible for this op; method used by
-    // InferTypeOpInterface
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
-  }];
 }
 
 def Shape_MeetOp : Shape_Op<"meet",
-    [Commutative, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Commutative, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Returns the least general shape or size of its operands";
   let description = [{
     An operation that computes the least general shape or dim of input operands.
     This effectively asserts that corresponding static dimensions are equal.
     The behavior is to match each element of the shape/size and propagate the
     most restrictive information, returning an invalid shape if there are
     contradictory requirements. E.g., using pseudo code
 
let arguments = (ins
     Shape_AnyShapeOrSizeType:$arg1,
     OptionalAttr<StrAttr>:$error);
   let results = (outs Shape_AnyShapeOrSizeType:$result);
 
   let assemblyFormat = [{
     $arg0 `,` $arg1 (`,` `error` `=` $error^)? attr-dict `:`
       type($arg0) `,` type($arg1) `->` type($result)
   }];
-
-  let extraClassDeclaration = [{
-    // Returns when two result types are compatible for this op; method used by
-    // InferTypeOpInterface
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
-  }];
 }
 
 def Shape_MinOp : Shape_Op<"min",
-    [Commutative, Pure,
-     DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Commutative, Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Elementwise minimum";
   let description = [{
     Computes the elementwise minimum of two sizes or shapes with equal ranks.
     If either operand is an error, then an error will be propagated to the
     result. If the input types mismatch or the ranks do not match, then the
     result is an error.
   }];
 
   let arguments = (ins Shape_ShapeOrSizeType:$lhs, Shape_ShapeOrSizeType:$rhs);
   let results = (outs Shape_ShapeOrSizeType:$result);
 
   let assemblyFormat = [{
     $lhs `,` $rhs attr-dict `:` type($lhs) `,` type($rhs) `->` type($result)
   }];
 
   let hasFolder = 1;
-
-  let extraClassDeclaration = [{
-    // Returns when two result types are compatible for this op; method used by
-    // InferTypeOpInterface
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
-  }];
 }
 
 def Shape_MulOp : Shape_Op<"mul",
-    [Commutative, Pure,
-     DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Commutative, Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Multiplication of sizes and indices";
   let description = [{
     Multiplies two sizes or indices. If either operand is an error it will be
     propagated to the result. The operands can be of type `size` or `index`. If
     at least one of the operands can hold an error, i.e. if it is of type
     `size`, the result must be of type `size`. If error propagation is not
     possible because both operands are of type `index` then the result may be
     of type `size` or `index`.
   }];
 
   let arguments = (ins Shape_SizeOrIndexType:$lhs, Shape_SizeOrIndexType:$rhs);
   let results = (outs Shape_SizeOrIndexType:$result);
 
   let assemblyFormat = [{
     $lhs `,` $rhs attr-dict `:` type($lhs) `,` type($rhs) `->` type($result)
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
-
-  let extraClassDeclaration = [{
-    // Returns when two result types are compatible for this op; method used by
-    // InferTypeOpInterface
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
-  }];
 }
 
 def Shape_NumElementsOp : Shape_Op<"num_elements",
-    [Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Returns the number of elements for a given shape";
   let description = [{
     Returns the number of elements for a given shape which is the product of
     its extents. If the argument is of type `shape` then the result will be of
     type `size` and potential errors will be propagated. Otherwise, if the
     argument is and extent tensor `tensor<?xindex>` then the result will be of
     type `index`.
   }];
 
   let arguments = (ins Shape_ShapeOrExtentTensorType:$shape);
   let results = (outs Shape_SizeOrIndexType:$result);
 
   let assemblyFormat = "$shape attr-dict `:` type($shape) `->` type($result)";
 
   let hasFolder = 1;
   let hasVerifier = 1;
-  let extraClassDeclaration = [{
-    // Returns when two result types are compatible for this op; method used by
-    // InferTypeOpInterface
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
-  }];
 }
 
 def Shape_ReduceOp : Shape_Op<"reduce",
     [SingleBlockImplicitTerminator<"YieldOp">]> {
   let summary = "Returns an expression reduced over a shape or extent tensor";
   let description = [{
     An operation that takes as input a shape or extent tensor, and a number of
     initial values. This operation has a region that is applied repeatedly for
def Shape_ReduceOp : Shape_Op<"reduce",
 
   let builders = [OpBuilder<(ins "Value":$shape, "ValueRange":$initVals)>];
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 def Shape_ShapeOfOp : Shape_Op<"shape_of",
-    [Pure, DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
+    [Pure, InferTypeOpAdaptorWithIsCompatible]> {
   let summary = "Returns shape of a value or shaped type operand";
 
   let description = [{
     The operation takes a value or a shaped operand as an argument and it
     returns a shape or extent tensor.
   }];
 
   let arguments = (ins AnyTypeOf<[AnyShaped, Shape_ValueShapeType]>:$arg);
   let results = (outs Shape_ShapeOrExtentTensorType:$result);
 
   let assemblyFormat = "$arg attr-dict `:` type($arg) `->` type($result)";
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
-
-  let extraClassDeclaration = [{
-    // Returns when two result types are compatible for this op; method used by
-    // InferTypeOpInterface
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
-  }];
 }
 
 def Shape_ValueOfOp : Shape_Op<"value_of", [Pure]> {
   let summary = "Returns value of a !shape.value_shape operand";
 
    let description = [{
     The operation takes !shape.value_shape, a.k.a. (value, shape) tuple as an
     argument, and returns its value. The behavior is undefined for unknown and

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

 }
 
 def Vector_ShuffleOp :
   Vector_Op<"shuffle", [Pure,
      PredOpTrait<"first operand v1 and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
      PredOpTrait<"second operand v2 and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 1>>,
-     DeclareOpInterfaceMethods<InferTypeOpInterface>]>,
+     InferTypeOpAdaptor]>,
      Arguments<(ins AnyVectorOfAnyRank:$v1, AnyVectorOfAnyRank:$v2,
                     I64ArrayAttr:$mask)>,
      Results<(outs AnyVector:$vector)> {
   let summary = "shuffle operation";
   let description = [{
     The shuffle operation constructs a permutation (or duplication) of elements
     from two input vectors, returning a vector with the same element type as
     the input and a length that is the same as the shuffle mask. The two input
def Vector_ExtractElementOp :
   let hasVerifier = 1;
   let hasFolder = 1;
 }
 
 def Vector_ExtractOp :
   Vector_Op<"extract", [Pure,
      PredOpTrait<"operand and result have same element type",
                  TCresVTEtIsSameAsOpBase<0, 0>>,
-     DeclareOpInterfaceMethods<InferTypeOpInterface>]>,
+     InferTypeOpAdaptorWithIsCompatible]>,
     Arguments<(ins AnyVectorOfAnyRank:$vector, I64ArrayAttr:$position)>,
     Results<(outs AnyType)> {
   let summary = "extract operation";
   let description = [{
     Takes an n-D vector and a k-D position and extracts the (n-k)-D vector at
     the proper position. Degenerates to an element type if n-k is zero.
 
     Example:
let builders = [
     // Convenience builder which assumes the values in `position` are defined by
     // ConstantIndexOp.
     OpBuilder<(ins "Value":$source, "ValueRange":$position)>
   ];
   let extraClassDeclaration = [{
     VectorType getSourceVectorType() {
       return ::llvm::cast<VectorType>(getVector().getType());
     }
-    static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
   let assemblyFormat = "$vector `` $position attr-dict `:` type($vector)";
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
 def Vector_FMAOp :

mlir/include/mlir/Interfaces/InferTypeOpInterface.h

 
 /// Include the generated interface declarations.
 #include "mlir/Interfaces/InferTypeOpInterface.h.inc"
 
 namespace mlir {
 namespace OpTrait {
 
 template <typename ConcreteType>
-class InferTypeOpInterfaceAdaptor
-    : public TraitBase<ConcreteType, InferTypeOpInterfaceAdaptor> {};
+class InferTypeOpAdaptor : public TraitBase<ConcreteType, InferTypeOpAdaptor> {
+};
 
 /// Tensor type inference trait that constructs a tensor from the inferred
 /// shape and elemental types.
 /// Requires: Op implements InferShapedTypeOpInterface and InferTypeOpInterface.
 ///   Less strict is possible (e.g., implements inferReturnTypeComponents and
 ///   these always populates all element types and shapes or fails, but this\
 ///   trait is currently only used where the interfaces are, so keep it
 ///   restricted for now).
 template <typename ConcreteType>
 class InferTensorType : public TraitBase<ConcreteType, InferTensorType> {};
 
 } // namespace OpTrait
 } // namespace mlir
 
 #endif // MLIR_INTERFACES_INFERTYPEOPINTERFACE_H_

mlir/include/mlir/Interfaces/InferTypeOpInterface.td

InterfaceMethod<
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{ return ::mlir::failure(); }]
     >
   ];
 }
 
 // Convenient trait to define a wrapper to inferReturnTypes that passes in the
 // Op Adaptor directly
-def InferTypeOpInterfaceAdaptor : TraitList<
+class InferTypeOpAdaptorBase<code additionalDecls = [{}]> : TraitList<
   [
     // Op implements infer type op interface.
     DeclareOpInterfaceMethods<InferTypeOpInterface>,
     NativeOpTrait<
-      /*name=*/"InferTypeOpInterfaceAdaptor",
+      /*name=*/"InferTypeOpAdaptor",
       /*traits=*/[],
       /*extraOpDeclaration=*/[{
-        static LogicalResult
-        inferReturnTypesAdaptor(MLIRContext *context,
-                                std::optional<Location> location,
+        static ::mlir::LogicalResult
+        inferReturnTypes(::mlir::MLIRContext *context,
+                                std::optional<::mlir::Location> location,
                                 Adaptor adaptor,
-                                SmallVectorImpl<Type> &inferredReturnTypes);
-      }],
+                                ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes);
+      }] # additionalDecls,
       /*extraOpDefinition=*/[{
-        LogicalResult
-        $cppClass::inferReturnTypes(MLIRContext *context,
-                          std::optional<Location> location,
-                          ValueRange operands, DictionaryAttr attributes,
-                          OpaqueProperties properties, RegionRange regions,
-                          SmallVectorImpl<Type> &inferredReturnTypes) {
+        ::mlir::LogicalResult
+        $cppClass::inferReturnTypes(::mlir::MLIRContext *context,
+                          std::optional<::mlir::Location> location,
+                          ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes,
+                          ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions,
+                          ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
           $cppClass::Adaptor adaptor(operands, attributes, properties, regions);
-          return $cppClass::inferReturnTypesAdaptor(context,
+          return $cppClass::inferReturnTypes(context,
             location, adaptor, inferredReturnTypes);
         }
       }]
     >
   ]>;
 
+def InferTypeOpAdaptor : InferTypeOpAdaptorBase;
+def InferTypeOpAdaptorWithIsCompatible : InferTypeOpAdaptorBase<
+  [{
+    static bool isCompatibleReturnTypes(::mlir::TypeRange l, ::mlir::TypeRange r);
+  }]
+>;
+
 // Convenience class grouping together type and shaped type op interfaces for
 // ops that have tensor return types.
 class InferTensorTypeBase<list<string> overridenMethods = []> : TraitList<
   [
     // Op implements infer type op interface.
     DeclareOpInterfaceMethods<InferTypeOpInterface>,
     // The op will have methods implementing the ShapedType type inference
     // interface.
     DeclareOpInterfaceMethods<InferShapedTypeOpInterface, overridenMethods>,
     // The op produces tensors and will use the ShapedType type infer interface
     // along with knowledge that it is producing Tensors to infer the type.
     NativeOpTrait<
       /*name=*/"InferTensorType",
       /*traits=*/[],
       /*extraOpDeclaration=*/[{}],
       /*extraOpDefinition=*/[{
-        LogicalResult
-        $cppClass::inferReturnTypes(MLIRContext *context,
-                          std::optional<Location> location,
-                          ValueRange operands, DictionaryAttr attributes,
-                          OpaqueProperties properties, RegionRange regions,
-                          SmallVectorImpl<Type> &inferredReturnTypes) {
-          SmallVector<ShapedTypeComponents, 2> retComponents;
+        ::mlir::LogicalResult
+        $cppClass::inferReturnTypes(::mlir::MLIRContext *context,
+                          std::optional<::mlir::Location> location,
+                          ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes,
+                          ::mlir::OpaqueProperties properties, ::mlir::RegionRange regions,
+                          ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
+          ::llvm::SmallVector<::mlir::ShapedTypeComponents, 2> retComponents;
           if (failed($cppClass::inferReturnTypeComponents(context, location,
                                     operands, attributes, properties, regions,
                                     retComponents)))
             return failure();
           return ::mlir::detail::inferReturnTensorTypes(retComponents,
                                     inferredReturnTypes);
         }
       }]

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // ExtractStridedMetadataOp
 //===----------------------------------------------------------------------===//
 
 /// The number and type of the results are inferred from the
 /// shape of the source.
-LogicalResult ExtractStridedMetadataOp::inferReturnTypesAdaptor(
+LogicalResult ExtractStridedMetadataOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location,
     ExtractStridedMetadataOp::Adaptor adaptor,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   auto sourceType = llvm::dyn_cast<MemRefType>(adaptor.getSource().getType());
   if (!sourceType)
     return failure();
 
   unsigned sourceRank = sourceType.getRank();

mlir/lib/Dialect/SCF/IR/SCF.cpp

bool mlir::scf::insideMutuallyExclusiveBranches(Operation *a, Operation *b) {
   }
 
   // Could not find a common IfOp among a's and b's ancestors.
   return false;
 }
 
 LogicalResult
 IfOp::inferReturnTypes(MLIRContext *ctx, std::optional<Location> loc,
-                       ValueRange operands, DictionaryAttr attrs,
-                       OpaqueProperties properties, RegionRange regions,
+                       IfOp::Adaptor adaptor,
                        SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (regions.empty())
+  if (adaptor.getRegions().empty())
     return failure();
-  Region *r = regions.front();
+  Region *r = &adaptor.getThenRegion();
   if (r->empty())
     return failure();
   Block &b = r->front();
   if (b.empty())
     return failure();
   auto yieldOp = llvm::dyn_cast<YieldOp>(b.back());
   if (!yieldOp)
     return failure();

mlir/lib/Dialect/Shape/IR/Shape.cpp

void AssumingOp::build(
   result.addTypes(assumingTypes);
 }
 
 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult mlir::shape::AddOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (llvm::isa<SizeType>(operands[0].getType()) ||
-      llvm::isa<SizeType>(operands[1].getType()))
+    MLIRContext *context, std::optional<Location> location,
+    AddOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
+  if (llvm::isa<SizeType>(adaptor.getLhs().getType()) ||
+      llvm::isa<SizeType>(adaptor.getRhs().getType()))
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::AddOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.

 OpFoldResult ConstShapeOp::fold(FoldAdaptor) { return getShapeAttr(); }
 
 void ConstShapeOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                MLIRContext *context) {
   patterns.add<TensorCastConstShape>(context);
 }
 
 LogicalResult mlir::shape::ConstShapeOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *context, std::optional<Location> location,
+    ConstShapeOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
   Builder b(context);
-  Properties *prop = properties.as<Properties *>();
+  const Properties *prop = &adaptor.getProperties();
   DenseIntElementsAttr shape;
   // TODO: this is only exercised by the Python bindings codepath which does not
   // support properties
   if (prop)
     shape = prop->shape;
   else
-    shape = attributes.getAs<DenseIntElementsAttr>("shape");
+    shape = adaptor.getAttributes().getAs<DenseIntElementsAttr>("shape");
   if (!shape)
     return emitOptionalError(location, "missing shape attribute");
   inferredReturnTypes.assign({RankedTensorType::get(
       {static_cast<int64_t>(shape.size())}, b.getIndexType())});
   return success();
 }
 
 bool mlir::shape::ConstShapeOp::isCompatibleReturnTypes(TypeRange l,
if (index.value() < 0 || index.value() >= valShapedType.getRank())
     return nullptr;
   auto extent = valShapedType.getDimSize(*index);
   if (ShapedType::isDynamic(extent))
     return nullptr;
   return IntegerAttr::get(IndexType::get(getContext()), extent);
 }
 
 LogicalResult mlir::shape::DimOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
-  DimOpAdaptor dimOp(operands);
-  inferredReturnTypes.assign({dimOp.getIndex().getType()});
+    MLIRContext *context, std::optional<Location> location,
+    DimOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
+  inferredReturnTypes.assign({adaptor.getIndex().getType()});
   return success();
 }
 
 bool mlir::shape::DimOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
 }
 
 //===----------------------------------------------------------------------===//
if (quotient.isNegative() && !remainder.isZero()) {
     quotient -= 1;
   }
 
   Type indexTy = IndexType::get(getContext());
   return IntegerAttr::get(indexTy, quotient);
 }
 
 LogicalResult mlir::shape::DivOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (llvm::isa<SizeType>(operands[0].getType()) ||
-      llvm::isa<SizeType>(operands[1].getType()))
+    MLIRContext *context, std::optional<Location> location,
+    DivOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
+  if (llvm::isa<SizeType>(adaptor.getLhs().getType()) ||
+      llvm::isa<SizeType>(adaptor.getRhs().getType()))
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::DivOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.
void GetExtentOp::build(OpBuilder &builder, OperationState &result, Value shape,
   } else {
     Value dim =
         builder.create<arith::ConstantOp>(loc, builder.getIndexType(), dimAttr);
     build(builder, result, builder.getIndexType(), shape, dim);
   }
 }
 
 LogicalResult mlir::shape::GetExtentOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *context, std::optional<Location> location,
+    GetExtentOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
   inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::GetExtentOp::isCompatibleReturnTypes(TypeRange l,
                                                        TypeRange r) {
   // SizeType is compatible with IndexType.
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
OpFoldResult IsBroadcastableOp::fold(FoldAdaptor adaptor) {
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // MeetOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult mlir::shape::MeetOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (operands.empty())
+    MLIRContext *context, std::optional<Location> location,
+    MeetOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
+  if (adaptor.getOperands().empty())
     return failure();
 
   auto isShapeType = [](Type arg) {
     if (llvm::isa<ShapeType>(arg))
       return true;
     return isExtentTensorType(arg);
   };
 
-  ValueRange::type_range types = operands.getTypes();
+  ValueRange::type_range types = adaptor.getOperands().getTypes();
   Type acc = types.front();
   for (auto t : drop_begin(types)) {
     Type l = acc, r = t;
     if (!llvm::isa<ShapeType, SizeType>(l))
       std::swap(l, r);
 
     // Handle sizes, propagate error type if present.
     if (llvm::isa<SizeType>(l)) {

 } // namespace
 
 void shape::RankOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                 MLIRContext *context) {
   patterns.add<RankShapeOfCanonicalizationPattern>(context);
 }
 
 LogicalResult mlir::shape::RankOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (llvm::isa<ShapeType>(operands[0].getType()))
+    MLIRContext *context, std::optional<Location> location,
+    RankOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
+  if (llvm::isa<ShapeType>(adaptor.getShape().getType()))
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::RankOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.
OpFoldResult NumElementsOp::fold(FoldAdaptor adaptor) {
   APInt product(64, 1);
   for (auto value : llvm::cast<DenseIntElementsAttr>(shape))
     product *= value;
   Builder builder(getContext());
   return builder.getIndexAttr(product.getLimitedValue());
 }
 
 LogicalResult mlir::shape::NumElementsOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
+    MLIRContext *context, std::optional<Location> location,
+    NumElementsOp::Adaptor adaptor,
     SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (llvm::isa<ShapeType>(operands[0].getType()))
+  if (llvm::isa<ShapeType>(adaptor.getShape().getType()))
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::NumElementsOp::isCompatibleReturnTypes(TypeRange l,
                                                          TypeRange r) {

 OpFoldResult MaxOp::fold(FoldAdaptor adaptor) {
   // If operands are equal, just propagate one.
   if (getLhs() == getRhs())
     return getLhs();
   return nullptr;
 }
 
 LogicalResult mlir::shape::MaxOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (operands[0].getType() == operands[1].getType())
-    inferredReturnTypes.assign({operands[0].getType()});
+    MLIRContext *context, std::optional<Location> location,
+    MaxOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
+  if (adaptor.getLhs().getType() == adaptor.getRhs().getType())
+    inferredReturnTypes.assign({adaptor.getLhs().getType()});
   else
     inferredReturnTypes.assign({SizeType::get(context)});
   return success();
 }
 
 bool mlir::shape::MaxOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;

 OpFoldResult MinOp::fold(FoldAdaptor adaptor) {
   // If operands are equal, just propagate one.
   if (getLhs() == getRhs())
     return getLhs();
   return nullptr;
 }
 
 LogicalResult mlir::shape::MinOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (operands[0].getType() == operands[1].getType())
-    inferredReturnTypes.assign({operands[0].getType()});
+    MLIRContext *context, std::optional<Location> location,
+    MinOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
+  if (adaptor.getLhs().getType() == adaptor.getRhs().getType())
+    inferredReturnTypes.assign({adaptor.getLhs().getType()});
   else
     inferredReturnTypes.assign({SizeType::get(context)});
   return success();
 }
 
 bool mlir::shape::MinOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;
OpFoldResult MulOp::fold(FoldAdaptor adaptor) {
   if (!rhs)
     return nullptr;
   APInt folded = lhs.getValue() * rhs.getValue();
   Type indexTy = IndexType::get(getContext());
   return IntegerAttr::get(indexTy, folded);
 }
 
 LogicalResult mlir::shape::MulOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (llvm::isa<SizeType>(operands[0].getType()) ||
-      llvm::isa<SizeType>(operands[1].getType()))
+    MLIRContext *context, std::optional<Location> location,
+    MulOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
+  if (llvm::isa<SizeType>(adaptor.getLhs().getType()) ||
+      llvm::isa<SizeType>(adaptor.getRhs().getType()))
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::MulOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.

 
 void ShapeOfOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                             MLIRContext *context) {
   patterns.add<ShapeOfCastExtentTensor, ShapeOfWithTensor,
                ExtractFromShapeOfExtentTensor>(context);
 }
 
 LogicalResult mlir::shape::ShapeOfOp::inferReturnTypes(
-    MLIRContext *context, std::optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
-  if (llvm::isa<ValueShapeType>(operands[0].getType()))
+    MLIRContext *context, std::optional<Location> location,
+    ShapeOfOp::Adaptor adaptor, SmallVectorImpl<Type> &inferredReturnTypes) {
+  if (llvm::isa<ValueShapeType>(adaptor.getArg().getType()))
     inferredReturnTypes.assign({ShapeType::get(context)});
   else {
-    auto shapedTy = llvm::cast<ShapedType>(operands[0].getType());
+    auto shapedTy = llvm::cast<ShapedType>(adaptor.getArg().getType());
     int64_t rank =
         shapedTy.hasRank() ? shapedTy.getRank() : ShapedType::kDynamic;
     Type indexTy = IndexType::get(context);
     Type extentTensorTy = RankedTensorType::get({rank}, indexTy);
     inferredReturnTypes.assign({extentTensorTy});
   }
   return success();
 }

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

SmallVector<int64_t, 4> positionConstants =
       llvm::to_vector<4>(llvm::map_range(position, [](Value pos) {
         return getConstantIntValue(pos).value();
       }));
   build(builder, result, source, positionConstants);
 }
 
 LogicalResult
 ExtractOp::inferReturnTypes(MLIRContext *, std::optional<Location>,
-                            ValueRange operands, DictionaryAttr attributes,
-                            OpaqueProperties properties, RegionRange,
+                            ExtractOp::Adaptor adaptor,
                             SmallVectorImpl<Type> &inferredReturnTypes) {
-  ExtractOp::Adaptor op(operands, attributes, properties);
-  auto vectorType = llvm::cast<VectorType>(op.getVector().getType());
-  if (static_cast<int64_t>(op.getPosition().size()) == vectorType.getRank()) {
+  auto vectorType = llvm::cast<VectorType>(adaptor.getVector().getType());
+  if (static_cast<int64_t>(adaptor.getPosition().size()) ==
+      vectorType.getRank()) {
     inferredReturnTypes.push_back(vectorType.getElementType());
   } else {
-    auto n = std::min<size_t>(op.getPosition().size(), vectorType.getRank());
+    auto n =
+        std::min<size_t>(adaptor.getPosition().size(), vectorType.getRank());
     inferredReturnTypes.push_back(VectorType::get(
         vectorType.getShape().drop_front(n), vectorType.getElementType()));
   }
   return success();
 }
 
 bool ExtractOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // Allow extracting 1-element vectors instead of scalars.
for (const auto &en : llvm::enumerate(maskAttr)) {
     if (!attr || attr.getInt() < 0 || attr.getInt() >= indexSize)
       return emitOpError("mask index #") << (en.index() + 1) << " out of range";
   }
   return success();
 }
 
 LogicalResult
 ShuffleOp::inferReturnTypes(MLIRContext *, std::optional<Location>,
-                            ValueRange operands, DictionaryAttr attributes,
-                            OpaqueProperties properties, RegionRange,
+                            ShuffleOp::Adaptor adaptor,
                             SmallVectorImpl<Type> &inferredReturnTypes) {
-  ShuffleOp::Adaptor op(operands, attributes, properties);
-  auto v1Type = llvm::cast<VectorType>(op.getV1().getType());
+  auto v1Type = llvm::cast<VectorType>(adaptor.getV1().getType());
   auto v1Rank = v1Type.getRank();
   // Construct resulting type: leading dimension matches mask
   // length, all trailing dimensions match the operands.
   SmallVector<int64_t, 4> shape;
   shape.reserve(v1Rank);
-  shape.push_back(std::max<size_t>(1, op.getMask().size()));
+  shape.push_back(std::max<size_t>(1, adaptor.getMask().size()));
   // In the 0-D case there is no trailing shape to append.
   if (v1Rank > 0)
     llvm::append_range(shape, v1Type.getShape().drop_front());
   inferredReturnTypes.push_back(
       VectorType::get(shape, v1Type.getElementType()));
   return success();
 }
 

mlir/test/lib/Dialect/Test/TestDialect.cpp

if (operands[0].getType() != operands[1].getType()) {
     return emitOptionalError(location, "operand type mismatch ",
                              operands[0].getType(), " vs ",
                              operands[1].getType());
   }
   inferredReturnTypes.assign({operands[0].getType()});
   return success();
 }
 
+LogicalResult OpWithInferTypeAdaptorInterfaceOp::inferReturnTypes(
+    MLIRContext *, std::optional<Location> location,
+    OpWithInferTypeAdaptorInterfaceOp::Adaptor adaptor,
+    SmallVectorImpl<Type> &inferredReturnTypes) {
+  if (adaptor.getX().getType() != adaptor.getY().getType()) {
+    return emitOptionalError(location, "operand type mismatch ",
+                             adaptor.getX().getType(), " vs ",
+                             adaptor.getY().getType());
+  }
+  inferredReturnTypes.assign({adaptor.getX().getType()});
+  return success();
+}
+
 // TODO: We should be able to only define either inferReturnType or
 // refineReturnType, currently only refineReturnType can be omitted.
 LogicalResult OpWithRefineTypeInterfaceOp::inferReturnTypes(
     MLIRContext *context, std::optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, OpaqueProperties properties, RegionRange regions,
     SmallVectorImpl<Type> &returnTypes) {
   returnTypes.clear();
   return OpWithRefineTypeInterfaceOp::refineReturnTypes(

mlir/test/lib/Dialect/Test/TestOps.td

 }
 
 def OpWithInferTypeInterfaceOp : TEST_Op<"op_with_infer_type_if", [
     DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let arguments = (ins AnyTensor, AnyTensor);
   let results = (outs AnyTensor);
 }
 
+def OpWithInferTypeAdaptorInterfaceOp : TEST_Op<"op_with_infer_type_adaptor_if", [
+    InferTypeOpAdaptor]> {
+  let arguments = (ins AnyTensor:$x, AnyTensor:$y);
+  let results = (outs AnyTensor);
+}
+
 def OpWithRefineTypeInterfaceOp : TEST_Op<"op_with_refine_type_if", [
     DeclareOpInterfaceMethods<InferTypeOpInterface,
         ["refineReturnTypes"]>]> {
   let arguments = (ins AnyTensor, AnyTensor);
   let results = (outs AnyTensor);
 }
 
 def OpWithShapedTypeInferTypeInterfaceOp : TEST_Op<"op_with_shaped_type_infer_type_if",

mlir/test/lib/Dialect/Test/TestPatterns.cpp

if (getOperation().getName() == "testCreateFunctions") {
       for (auto &op : getOperation().getBody().front())
         ops.push_back(&op);
       // Generate test patterns for each, but skip terminator.
       for (auto *op : llvm::ArrayRef(ops).drop_back()) {
         // Test create method of each of the Op classes below. The resultant
         // output would be in reverse order underneath `op` from which
         // the attributes and regions are used.
         invokeCreateWithInferredReturnType<OpWithInferTypeInterfaceOp>(op);
+        invokeCreateWithInferredReturnType<OpWithInferTypeAdaptorInterfaceOp>(
+            op);
         invokeCreateWithInferredReturnType<
             OpWithShapedTypeInferTypeInterfaceOp>(op);
       };
       return;
     }
     if (getOperation().getName() == "testReifyFunctions") {
       std::vector<Operation *> ops;
       // Collect ops to avoid triggering on inserted ops.