[mlir:OpConversionPattern] Add overloads for taking an Adaptor instead of ArrayRef

[rriddle]

Summary

This has been a TODO for a long time, and it brings about many advantages (namely nice accessors, and less fragile code). The existing overloads that accept ArrayRef are now treated as deprecated and will be removed in a followup (after a small grace period). Most of the upstream MLIR usages have been fixed by this commit, the rest will be handled in a followup.

[ftynse]

Very nice usability improvement!

mlir/docs/Bufferization.md

146

Nit: I know this is a large-scale refactoring, but could we fix this particular place in the documentation to be adaptor.source() instead of using getOperands + magic number? For the sake of documenting best practices.

mlir/include/mlir/Conversion/LLVMCommon/Pattern.h

161

Is it too early to put LLVM_ATTRIBUTE_DEPRECATED here?

[rriddle]

Update

[aartbik]

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp

374–375

heads up: I added an emitCInterface parameter to some of these calls at exactly the same line, so you probably need to resolve some conflicts on the rebase with main

[rriddle]

Thanks for the review Alex!

(Also thanks for the heads up Aart!)

mlir/include/mlir/Conversion/LLVMCommon/Pattern.h

161

Yeah, I think so. I'm going to send out the PSA first and then mark deprecated sometime early next week.

[antiagainst]

This is nice!

mlir/docs/Bufferization.md

 simple example being
 [BufferizeCastOp](https://github.com/llvm/llvm-project/blob/2bf6e443e54604c7818c4d1a1837f3d091023270/mlir/lib/Dialect/Tensor/Transforms/Bufferize.cpp#L23)).
 
 ```
 class BufferizeCastOp : public OpConversionPattern<tensor::CastOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tensor::CastOp op, ArrayRef<Value> operands,
+  matchAndRewrite(tensor::CastOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto resultType = getTypeConverter()->convertType(op.getType());
-    rewriter.replaceOpWithNewOp<MemRefCastOp>(op, resultType, operands[0]);
+    rewriter.replaceOpWithNewOp<MemRefCastOp>(op, resultType,
+                                              adaptor.getOperands()[0]);
     return success();
   }
 };
 ```
 
 See [the talk](#the-talk) for more details on how to write these patterns.
 
 The

mlir/include/mlir/Conversion/LLVMCommon/Pattern.h

LogicalResult copyUnrankedDescriptors(OpBuilder &builder, Location loc,
                                         bool toDynamic) const;
 };
 
 /// Utility class for operation conversions targeting the LLVM dialect that
 /// match exactly one source operation.
 template <typename SourceOp>
 class ConvertOpToLLVMPattern : public ConvertToLLVMPattern {
 public:
+  using OpAdaptor = typename SourceOp::Adaptor;
+
   explicit ConvertOpToLLVMPattern(LLVMTypeConverter &typeConverter,
                                   PatternBenefit benefit = 1)
       : ConvertToLLVMPattern(SourceOp::getOperationName(),
                              &typeConverter.getContext(), typeConverter,
                              benefit) {}
 
   /// Wrappers around the RewritePattern methods that pass the derived op type.
   void rewrite(Operation *op, ArrayRef<Value> operands,
                ConversionPatternRewriter &rewriter) const final {
-    rewrite(cast<SourceOp>(op), operands, rewriter);
+    rewrite(cast<SourceOp>(op), OpAdaptor(operands, op->getAttrDictionary()),
+            rewriter);
   }
   LogicalResult match(Operation *op) const final {
     return match(cast<SourceOp>(op));
   }
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
-    return matchAndRewrite(cast<SourceOp>(op), operands, rewriter);
+    return matchAndRewrite(cast<SourceOp>(op),
+                           OpAdaptor(operands, op->getAttrDictionary()),
+                           rewriter);
   }
 
   /// Rewrite and Match methods that operate on the SourceOp type. These must be
   /// overridden by the derived pattern class.
+  /// NOTICE: These methods are deprecated and will be removed. All new code
+  /// should use the adaptor methods below instead.
   virtual void rewrite(SourceOp op, ArrayRef<Value> operands,
                        ConversionPatternRewriter &rewriter) const {
     llvm_unreachable("must override rewrite or matchAndRewrite");
   }
-  virtual LogicalResult match(SourceOp op) const {
-    llvm_unreachable("must override match or matchAndRewrite");
-  }
   virtual LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const {
     if (succeeded(match(op))) {
       rewrite(op, operands, rewriter);
       return success();
     }
     return failure();
   }
 
+  /// Rewrite and Match methods that operate on the SourceOp type. These must be
+  /// overridden by the derived pattern class.
+  virtual LogicalResult match(SourceOp op) const {
+    llvm_unreachable("must override match or matchAndRewrite");
+  }
+  virtual void rewrite(SourceOp op, OpAdaptor adaptor,
+                       ConversionPatternRewriter &rewriter) const {
+    ValueRange operands = adaptor.getOperands();
+    rewrite(op,
+            ArrayRef<Value>(operands.getBase().get<const Value *>(),
+                            operands.size()),
+            rewriter);
+  }
+  virtual LogicalResult
+  matchAndRewrite(SourceOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const {
+    ValueRange operands = adaptor.getOperands();
+    return matchAndRewrite(
+        op,
+        ArrayRef<Value>(operands.getBase().get<const Value *>(),
+                        operands.size()),
+        rewriter);
+  }
+
 private:
   using ConvertToLLVMPattern::match;
   using ConvertToLLVMPattern::matchAndRewrite;
 };
 
 /// Generic implementation of one-to-one conversion from "SourceOp" to
 /// "TargetOp" where the latter belongs to the LLVM dialect or an equivalent.
 /// Upholds a convention that multi-result operations get converted into an

mlir/include/mlir/Transforms/DialectConversion.h

 protected:
   /// An optional type converter for use by this pattern.
   TypeConverter *typeConverter = nullptr;
 
 private:
   using RewritePattern::rewrite;
 };
 
-namespace detail {
-/// OpOrInterfaceConversionPatternBase is a wrapper around ConversionPattern
-/// that allows for matching and rewriting against an instance of a derived
-/// operation class or an Interface as opposed to a raw Operation.
+/// OpConversionPattern is a wrapper around ConversionPattern that allows for
+/// matching and rewriting against an instance of a derived operation class as
+/// opposed to a raw Operation.
 template <typename SourceOp>
-struct OpOrInterfaceConversionPatternBase : public ConversionPattern {
-  using ConversionPattern::ConversionPattern;
+class OpConversionPattern : public ConversionPattern {
+public:
+  using OpAdaptor = typename SourceOp::Adaptor;
+
+  OpConversionPattern(MLIRContext *context, PatternBenefit benefit = 1)
+      : ConversionPattern(SourceOp::getOperationName(), benefit, context) {}
+  OpConversionPattern(TypeConverter &typeConverter, MLIRContext *context,
+                      PatternBenefit benefit = 1)
+      : ConversionPattern(typeConverter, SourceOp::getOperationName(), benefit,
+                          context) {}
 
   /// Wrappers around the ConversionPattern methods that pass the derived op
   /// type.
   void rewrite(Operation *op, ArrayRef<Value> operands,
                ConversionPatternRewriter &rewriter) const final {
-    rewrite(cast<SourceOp>(op), operands, rewriter);
+    rewrite(cast<SourceOp>(op), OpAdaptor(operands, op->getAttrDictionary()),
+            rewriter);
   }
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
-    return matchAndRewrite(cast<SourceOp>(op), operands, rewriter);
+    return matchAndRewrite(cast<SourceOp>(op),
+                           OpAdaptor(operands, op->getAttrDictionary()),
+                           rewriter);
   }
 
-  // TODO: Use OperandAdaptor when it supports access to unnamed operands.
-
-  /// Rewrite and Match methods that operate on the SourceOp type. These must be
-  /// overridden by the derived pattern class.
+  /// Rewrite and Match methods that operate on the SourceOp type and accept the
+  /// raw operand values.
+  /// NOTICE: These methods are deprecated and will be removed. All new code
+  /// should use the adaptor methods below instead.
   virtual void rewrite(SourceOp op, ArrayRef<Value> operands,
                        ConversionPatternRewriter &rewriter) const {
     llvm_unreachable("must override matchAndRewrite or a rewrite method");
   }
-
   virtual LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const {
     if (failed(match(op)))
       return failure();
-    rewrite(op, operands, rewriter);
+    rewrite(op, OpAdaptor(operands, op->getAttrDictionary()), rewriter);
     return success();
   }
 
+  /// Rewrite and Match methods that operate on the SourceOp type. These must be
+  /// overridden by the derived pattern class.
+  virtual void rewrite(SourceOp op, OpAdaptor adaptor,
+                       ConversionPatternRewriter &rewriter) const {
+    ValueRange operands = adaptor.getOperands();
+    rewrite(op,
+            ArrayRef<Value>(operands.getBase().get<const Value *>(),
+                            operands.size()),
+            rewriter);
+  }
+  virtual LogicalResult
+  matchAndRewrite(SourceOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const {
+    ValueRange operands = adaptor.getOperands();
+    return matchAndRewrite(
+        op,
+        ArrayRef<Value>(operands.getBase().get<const Value *>(),
+                        operands.size()),
+        rewriter);
+  }
+
 private:
   using ConversionPattern::matchAndRewrite;
 };
-} // namespace detail
-
-/// OpConversionPattern is a wrapper around ConversionPattern that allows for
-/// matching and rewriting against an instance of a derived operation class as
-/// opposed to a raw Operation.
-template <typename SourceOp>
-struct OpConversionPattern
-    : public detail::OpOrInterfaceConversionPatternBase<SourceOp> {
-  OpConversionPattern(MLIRContext *context, PatternBenefit benefit = 1)
-      : detail::OpOrInterfaceConversionPatternBase<SourceOp>(
-            SourceOp::getOperationName(), benefit, context) {}
-  OpConversionPattern(TypeConverter &typeConverter, MLIRContext *context,
-                      PatternBenefit benefit = 1)
-      : detail::OpOrInterfaceConversionPatternBase<SourceOp>(
-            typeConverter, SourceOp::getOperationName(), benefit, context) {}
-};
 
 /// OpInterfaceConversionPattern is a wrapper around ConversionPattern that
 /// allows for matching and rewriting against an instance of an OpInterface
 /// class as opposed to a raw Operation.
 template <typename SourceOp>
-struct OpInterfaceConversionPattern
-    : public detail::OpOrInterfaceConversionPatternBase<SourceOp> {
+class OpInterfaceConversionPattern : public ConversionPattern {
+public:
   OpInterfaceConversionPattern(MLIRContext *context, PatternBenefit benefit = 1)
-      : detail::OpOrInterfaceConversionPatternBase<SourceOp>(
-            Pattern::MatchInterfaceOpTypeTag(), SourceOp::getInterfaceID(),
-            benefit, context) {}
+      : ConversionPattern(Pattern::MatchInterfaceOpTypeTag(),
+                          SourceOp::getInterfaceID(), benefit, context) {}
   OpInterfaceConversionPattern(TypeConverter &typeConverter,
                                MLIRContext *context, PatternBenefit benefit = 1)
-      : detail::OpOrInterfaceConversionPatternBase<SourceOp>(
-            typeConverter, Pattern::MatchInterfaceOpTypeTag(),
+      : ConversionPattern(typeConverter, Pattern::MatchInterfaceOpTypeTag(),
                           SourceOp::getInterfaceID(), benefit, context) {}
+
+  /// Wrappers around the ConversionPattern methods that pass the derived op
+  /// type.
+  void rewrite(Operation *op, ArrayRef<Value> operands,
+               ConversionPatternRewriter &rewriter) const final {
+    rewrite(cast<SourceOp>(op), operands, rewriter);
+  }
+  LogicalResult
+  matchAndRewrite(Operation *op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const final {
+    return matchAndRewrite(cast<SourceOp>(op), operands, rewriter);
+  }
+
+  /// Rewrite and Match methods that operate on the SourceOp type. These must be
+  /// overridden by the derived pattern class.
+  virtual void rewrite(SourceOp op, ArrayRef<Value> operands,
+                       ConversionPatternRewriter &rewriter) const {
+    llvm_unreachable("must override matchAndRewrite or a rewrite method");
+  }
+  virtual LogicalResult
+  matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const {
+    if (failed(match(op)))
+      return failure();
+    rewrite(op, operands, rewriter);
+    return success();
+  }
+
+private:
+  using ConversionPattern::matchAndRewrite;
 };
 
 /// Add a pattern to the given pattern list to convert the signature of a
 /// FunctionLike op with the given type converter. This only supports
 /// FunctionLike ops which use FunctionType to represent their type.
 void populateFunctionLikeTypeConversionPattern(StringRef functionLikeOpName,
                                                RewritePatternSet &patterns,
                                                TypeConverter &converter);

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

 //===----------------------------------------------------------------------===//
 
 namespace {
 class CoroIdOpConversion : public OpConversionPattern<CoroIdOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CoroIdOp op, ArrayRef<Value> operands,
+  matchAndRewrite(CoroIdOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto token = AsyncAPI::tokenType(op->getContext());
     auto i8Ptr = AsyncAPI::opaquePointerType(op->getContext());
     auto loc = op->getLoc();
 
     // Constants for initializing coroutine frame.
     auto constZero = rewriter.create<LLVM::ConstantOp>(
         loc, rewriter.getI32Type(), rewriter.getI32IntegerAttr(0));

 //===----------------------------------------------------------------------===//
 
 namespace {
 class CoroBeginOpConversion : public OpConversionPattern<CoroBeginOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CoroBeginOp op, ArrayRef<Value> operands,
+  matchAndRewrite(CoroBeginOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto i8Ptr = AsyncAPI::opaquePointerType(op->getContext());
     auto loc = op->getLoc();
 
     // Get coroutine frame size: @llvm.coro.size.i64.
     auto coroSize =
         rewriter.create<LLVM::CoroSizeOp>(loc, rewriter.getI64Type());
 
     // Allocate memory for the coroutine frame.
     auto coroAlloc = rewriter.create<LLVM::CallOp>(
         loc, i8Ptr, SymbolRefAttr::get(rewriter.getContext(), kMalloc),
         ValueRange(coroSize.getResult()));
 
     // Begin a coroutine: @llvm.coro.begin.
-    auto coroId = CoroBeginOpAdaptor(operands).id();
+    auto coroId = CoroBeginOpAdaptor(adaptor.getOperands()).id();
     rewriter.replaceOpWithNewOp<LLVM::CoroBeginOp>(
         op, i8Ptr, ValueRange({coroId, coroAlloc.getResult(0)}));
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.coro.free to @llvm.coro.free intrinsic.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class CoroFreeOpConversion : public OpConversionPattern<CoroFreeOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CoroFreeOp op, ArrayRef<Value> operands,
+  matchAndRewrite(CoroFreeOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto i8Ptr = AsyncAPI::opaquePointerType(op->getContext());
     auto loc = op->getLoc();
 
     // Get a pointer to the coroutine frame memory: @llvm.coro.free.
-    auto coroMem = rewriter.create<LLVM::CoroFreeOp>(loc, i8Ptr, operands);
+    auto coroMem =
+        rewriter.create<LLVM::CoroFreeOp>(loc, i8Ptr, adaptor.getOperands());
 
     // Free the memory.
     rewriter.replaceOpWithNewOp<LLVM::CallOp>(
         op, TypeRange(), SymbolRefAttr::get(rewriter.getContext(), kFree),
         ValueRange(coroMem.getResult()));
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.coro.end to @llvm.coro.end intrinsic.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class CoroEndOpConversion : public OpConversionPattern<CoroEndOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CoroEndOp op, ArrayRef<Value> operands,
+  matchAndRewrite(CoroEndOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // We are not in the block that is part of the unwind sequence.
     auto constFalse = rewriter.create<LLVM::ConstantOp>(
         op->getLoc(), rewriter.getI1Type(), rewriter.getBoolAttr(false));
 
     // Mark the end of a coroutine: @llvm.coro.end.
-    auto coroHdl = CoroEndOpAdaptor(operands).handle();
+    auto coroHdl = adaptor.handle();
     rewriter.create<LLVM::CoroEndOp>(op->getLoc(), rewriter.getI1Type(),
                                      ValueRange({coroHdl, constFalse}));
     rewriter.eraseOp(op);
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.coro.save to @llvm.coro.save intrinsic.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class CoroSaveOpConversion : public OpConversionPattern<CoroSaveOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CoroSaveOp op, ArrayRef<Value> operands,
+  matchAndRewrite(CoroSaveOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Save the coroutine state: @llvm.coro.save
     rewriter.replaceOpWithNewOp<LLVM::CoroSaveOp>(
-        op, AsyncAPI::tokenType(op->getContext()), operands);
+        op, AsyncAPI::tokenType(op->getContext()), adaptor.getOperands());
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.coro.suspend to @llvm.coro.suspend intrinsic.

 ///   ^cleanup: ...
 ///   ^suspend: ...
 ///
 class CoroSuspendOpConversion : public OpConversionPattern<CoroSuspendOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CoroSuspendOp op, ArrayRef<Value> operands,
+  matchAndRewrite(CoroSuspendOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto i8 = rewriter.getIntegerType(8);
     auto i32 = rewriter.getI32Type();
     auto loc = op->getLoc();
 
     // This is not a final suspension point.
     auto constFalse = rewriter.create<LLVM::ConstantOp>(
         loc, rewriter.getI1Type(), rewriter.getBoolAttr(false));
 
     // Suspend a coroutine: @llvm.coro.suspend
-    auto coroState = CoroSuspendOpAdaptor(operands).state();
+    auto coroState = adaptor.state();
     auto coroSuspend = rewriter.create<LLVM::CoroSuspendOp>(
         loc, i8, ValueRange({coroState, constFalse}));
 
     // Cast return code to i32.
 
     // After a suspension point decide if we should branch into resume, cleanup
     // or suspend block of the coroutine (see @llvm.coro.suspend return code
     // documentation).

 //===----------------------------------------------------------------------===//
 
 namespace {
 class RuntimeCreateOpLowering : public OpConversionPattern<RuntimeCreateOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeCreateOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RuntimeCreateOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     TypeConverter *converter = getTypeConverter();
     Type resultType = op->getResultTypes()[0];
 
     // Tokens creation maps to a simple function call.
     if (resultType.isa<TokenType>()) {
       rewriter.replaceOpWithNewOp<CallOp>(op, kCreateToken,
                                           converter->convertType(resultType));

 
 namespace {
 class RuntimeCreateGroupOpLowering
     : public OpConversionPattern<RuntimeCreateGroupOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeCreateGroupOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RuntimeCreateGroupOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     TypeConverter *converter = getTypeConverter();
     Type resultType = op.getResult().getType();
 
-    rewriter.replaceOpWithNewOp<CallOp>(
-        op, kCreateGroup, converter->convertType(resultType), operands);
+    rewriter.replaceOpWithNewOp<CallOp>(op, kCreateGroup,
+                                        converter->convertType(resultType),
+                                        adaptor.getOperands());
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.runtime.set_available to the corresponding runtime API call.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class RuntimeSetAvailableOpLowering
     : public OpConversionPattern<RuntimeSetAvailableOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeSetAvailableOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RuntimeSetAvailableOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     StringRef apiFuncName =
         TypeSwitch<Type, StringRef>(op.operand().getType())
             .Case<TokenType>([](Type) { return kEmplaceToken; })
             .Case<ValueType>([](Type) { return kEmplaceValue; });
 
-    rewriter.replaceOpWithNewOp<CallOp>(op, apiFuncName, TypeRange(), operands);
+    rewriter.replaceOpWithNewOp<CallOp>(op, apiFuncName, TypeRange(),
+                                        adaptor.getOperands());
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.runtime.set_error to the corresponding runtime API call.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class RuntimeSetErrorOpLowering
     : public OpConversionPattern<RuntimeSetErrorOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeSetErrorOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RuntimeSetErrorOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     StringRef apiFuncName =
         TypeSwitch<Type, StringRef>(op.operand().getType())
             .Case<TokenType>([](Type) { return kSetTokenError; })
             .Case<ValueType>([](Type) { return kSetValueError; });
 
-    rewriter.replaceOpWithNewOp<CallOp>(op, apiFuncName, TypeRange(), operands);
+    rewriter.replaceOpWithNewOp<CallOp>(op, apiFuncName, TypeRange(),
+                                        adaptor.getOperands());
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.runtime.is_error to the corresponding runtime API call.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class RuntimeIsErrorOpLowering : public OpConversionPattern<RuntimeIsErrorOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeIsErrorOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RuntimeIsErrorOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     StringRef apiFuncName =
         TypeSwitch<Type, StringRef>(op.operand().getType())
             .Case<TokenType>([](Type) { return kIsTokenError; })
             .Case<GroupType>([](Type) { return kIsGroupError; })
             .Case<ValueType>([](Type) { return kIsValueError; });
 
     rewriter.replaceOpWithNewOp<CallOp>(op, apiFuncName, rewriter.getI1Type(),
-                                        operands);
+                                        adaptor.getOperands());
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.runtime.await to the corresponding runtime API call.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class RuntimeAwaitOpLowering : public OpConversionPattern<RuntimeAwaitOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeAwaitOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RuntimeAwaitOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     StringRef apiFuncName =
         TypeSwitch<Type, StringRef>(op.operand().getType())
             .Case<TokenType>([](Type) { return kAwaitToken; })
             .Case<ValueType>([](Type) { return kAwaitValue; })
             .Case<GroupType>([](Type) { return kAwaitGroup; });
 
-    rewriter.create<CallOp>(op->getLoc(), apiFuncName, TypeRange(), operands);
+    rewriter.create<CallOp>(op->getLoc(), apiFuncName, TypeRange(),
+                            adaptor.getOperands());
     rewriter.eraseOp(op);
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.runtime.await_and_resume to the corresponding runtime API call.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class RuntimeAwaitAndResumeOpLowering
     : public OpConversionPattern<RuntimeAwaitAndResumeOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeAwaitAndResumeOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RuntimeAwaitAndResumeOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     StringRef apiFuncName =
         TypeSwitch<Type, StringRef>(op.operand().getType())
             .Case<TokenType>([](Type) { return kAwaitTokenAndExecute; })
             .Case<ValueType>([](Type) { return kAwaitValueAndExecute; })
             .Case<GroupType>([](Type) { return kAwaitAllAndExecute; });
 
-    Value operand = RuntimeAwaitAndResumeOpAdaptor(operands).operand();
-    Value handle = RuntimeAwaitAndResumeOpAdaptor(operands).handle();
+    Value operand = adaptor.operand();
+    Value handle = adaptor.handle();
 
     // A pointer to coroutine resume intrinsic wrapper.
     addResumeFunction(op->getParentOfType<ModuleOp>());
     auto resumeFnTy = AsyncAPI::resumeFunctionType(op->getContext());
     auto resumePtr = rewriter.create<LLVM::AddressOfOp>(
         op->getLoc(), LLVM::LLVMPointerType::get(resumeFnTy), kResume);
 
     rewriter.create<CallOp>(op->getLoc(), apiFuncName, TypeRange(),

 //===----------------------------------------------------------------------===//
 
 namespace {
 class RuntimeResumeOpLowering : public OpConversionPattern<RuntimeResumeOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeResumeOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RuntimeResumeOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // A pointer to coroutine resume intrinsic wrapper.
     addResumeFunction(op->getParentOfType<ModuleOp>());
     auto resumeFnTy = AsyncAPI::resumeFunctionType(op->getContext());
     auto resumePtr = rewriter.create<LLVM::AddressOfOp>(
         op->getLoc(), LLVM::LLVMPointerType::get(resumeFnTy), kResume);
 
     // Call async runtime API to execute a coroutine in the managed thread.
-    auto coroHdl = RuntimeResumeOpAdaptor(operands).handle();
+    auto coroHdl = adaptor.handle();
     rewriter.replaceOpWithNewOp<CallOp>(op, TypeRange(), kExecute,
                                         ValueRange({coroHdl, resumePtr.res()}));
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.runtime.store to the corresponding runtime API call.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class RuntimeStoreOpLowering : public OpConversionPattern<RuntimeStoreOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeStoreOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RuntimeStoreOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
 
     // Get a pointer to the async value storage from the runtime.
     auto i8Ptr = AsyncAPI::opaquePointerType(rewriter.getContext());
-    auto storage = RuntimeStoreOpAdaptor(operands).storage();
+    auto storage = adaptor.storage();
     auto storagePtr = rewriter.create<CallOp>(loc, kGetValueStorage,
                                               TypeRange(i8Ptr), storage);
 
     // Cast from i8* to the LLVM pointer type.
     auto valueType = op.value().getType();
     auto llvmValueType = getTypeConverter()->convertType(valueType);
     if (!llvmValueType)
       return rewriter.notifyMatchFailure(
           op, "failed to convert stored value type to LLVM type");
 
     auto castedStoragePtr = rewriter.create<LLVM::BitcastOp>(
         loc, LLVM::LLVMPointerType::get(llvmValueType),
         storagePtr.getResult(0));
 
     // Store the yielded value into the async value storage.
-    auto value = RuntimeStoreOpAdaptor(operands).value();
+    auto value = adaptor.value();
     rewriter.create<LLVM::StoreOp>(loc, value, castedStoragePtr.getResult());
 
     // Erase the original runtime store operation.
     rewriter.eraseOp(op);
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.runtime.load to the corresponding runtime API call.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class RuntimeLoadOpLowering : public OpConversionPattern<RuntimeLoadOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeLoadOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RuntimeLoadOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
 
     // Get a pointer to the async value storage from the runtime.
     auto i8Ptr = AsyncAPI::opaquePointerType(rewriter.getContext());
-    auto storage = RuntimeLoadOpAdaptor(operands).storage();
+    auto storage = adaptor.storage();
     auto storagePtr = rewriter.create<CallOp>(loc, kGetValueStorage,
                                               TypeRange(i8Ptr), storage);
 
     // Cast from i8* to the LLVM pointer type.
     auto valueType = op.result().getType();
     auto llvmValueType = getTypeConverter()->convertType(valueType);
     if (!llvmValueType)
       return rewriter.notifyMatchFailure(

 
 namespace {
 class RuntimeAddToGroupOpLowering
     : public OpConversionPattern<RuntimeAddToGroupOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeAddToGroupOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RuntimeAddToGroupOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Currently we can only add tokens to the group.
     if (!op.operand().getType().isa<TokenType>())
       return rewriter.notifyMatchFailure(op, "only token type is supported");
 
     // Replace with a runtime API function call.
-    rewriter.replaceOpWithNewOp<CallOp>(op, kAddTokenToGroup,
-                                        rewriter.getI64Type(), operands);
+    rewriter.replaceOpWithNewOp<CallOp>(
+        op, kAddTokenToGroup, rewriter.getI64Type(), adaptor.getOperands());
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Async reference counting ops lowering (`async.runtime.add_ref` and
 // `async.runtime.drop_ref` to the corresponding API calls).
 //===----------------------------------------------------------------------===//
 
 namespace {
 template <typename RefCountingOp>
 class RefCountingOpLowering : public OpConversionPattern<RefCountingOp> {
 public:
   explicit RefCountingOpLowering(TypeConverter &converter, MLIRContext *ctx,
                                  StringRef apiFunctionName)
       : OpConversionPattern<RefCountingOp>(converter, ctx),
         apiFunctionName(apiFunctionName) {}
 
   LogicalResult
-  matchAndRewrite(RefCountingOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RefCountingOp op, typename RefCountingOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto count =
         rewriter.create<ConstantOp>(op->getLoc(), rewriter.getI32Type(),
                                     rewriter.getI32IntegerAttr(op.count()));
 
-    auto operand = typename RefCountingOp::Adaptor(operands).operand();
+    auto operand = adaptor.operand();
     rewriter.replaceOpWithNewOp<CallOp>(op, TypeRange(), apiFunctionName,
                                         ValueRange({operand, count}));
 
     return success();
   }
 
 private:
   StringRef apiFunctionName;

 //===----------------------------------------------------------------------===//
 
 namespace {
 class ReturnOpOpConversion : public OpConversionPattern<ReturnOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ReturnOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ReturnOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<ReturnOp>(op, operands);
+    rewriter.replaceOpWithNewOp<ReturnOp>(op, adaptor.getOperands());
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 
 namespace {

 // Patterns for structural type conversions for the Async dialect operations.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class ConvertExecuteOpTypes : public OpConversionPattern<ExecuteOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(ExecuteOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ExecuteOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     ExecuteOp newOp =
         cast<ExecuteOp>(rewriter.cloneWithoutRegions(*op.getOperation()));
     rewriter.inlineRegionBefore(op.getRegion(), newOp.getRegion(),
                                 newOp.getRegion().end());
 
     // Set operands and update block argument and result types.
-    newOp->setOperands(operands);
+    newOp->setOperands(adaptor.getOperands());
     if (failed(rewriter.convertRegionTypes(&newOp.getRegion(), *typeConverter)))
       return failure();
     for (auto result : newOp.getResults())
       result.setType(typeConverter->convertType(result.getType()));
 
     rewriter.replaceOp(op, newOp.getResults());
     return success();
   }
 };
 
 // Dummy pattern to trigger the appropriate type conversion / materialization.
 class ConvertAwaitOpTypes : public OpConversionPattern<AwaitOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(AwaitOp op, ArrayRef<Value> operands,
+  matchAndRewrite(AwaitOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<AwaitOp>(op, operands.front());
+    rewriter.replaceOpWithNewOp<AwaitOp>(op, adaptor.getOperands().front());
     return success();
   }
 };
 
 // Dummy pattern to trigger the appropriate type conversion / materialization.
 class ConvertYieldOpTypes : public OpConversionPattern<async::YieldOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(async::YieldOp op, ArrayRef<Value> operands,
+  matchAndRewrite(async::YieldOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<async::YieldOp>(op, operands);
+    rewriter.replaceOpWithNewOp<async::YieldOp>(op, adaptor.getOperands());
     return success();
   }
 };
 } // namespace
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertAsyncToLLVMPass() {
   return std::make_unique<ConvertAsyncToLLVMPass>();
 }

mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp

 
 using namespace mlir;
 
 namespace {
 struct AbsOpConversion : public OpConversionPattern<complex::AbsOp> {
   using OpConversionPattern<complex::AbsOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(complex::AbsOp op, ArrayRef<Value> operands,
+  matchAndRewrite(complex::AbsOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    complex::AbsOp::Adaptor transformed(operands);
     auto loc = op.getLoc();
     auto type = op.getType();
 
-    Value real =
-        rewriter.create<complex::ReOp>(loc, type, transformed.complex());
-    Value imag =
-        rewriter.create<complex::ImOp>(loc, type, transformed.complex());
+    Value real = rewriter.create<complex::ReOp>(loc, type, adaptor.complex());
+    Value imag = rewriter.create<complex::ImOp>(loc, type, adaptor.complex());
     Value realSqr = rewriter.create<MulFOp>(loc, real, real);
     Value imagSqr = rewriter.create<MulFOp>(loc, imag, imag);
     Value sqNorm = rewriter.create<AddFOp>(loc, realSqr, imagSqr);
 
     rewriter.replaceOpWithNewOp<math::SqrtOp>(op, sqNorm);
     return success();
   }
 };
 
 template <typename ComparisonOp, CmpFPredicate p>
 struct ComparisonOpConversion : public OpConversionPattern<ComparisonOp> {
   using OpConversionPattern<ComparisonOp>::OpConversionPattern;
   using ResultCombiner =
       std::conditional_t<std::is_same<ComparisonOp, complex::EqualOp>::value,
                          AndOp, OrOp>;
 
   LogicalResult
-  matchAndRewrite(ComparisonOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ComparisonOp op, typename ComparisonOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    typename ComparisonOp::Adaptor transformed(operands);
     auto loc = op.getLoc();
-    auto type = transformed.lhs()
-                    .getType()
-                    .template cast<ComplexType>()
-                    .getElementType();
-
-    Value realLhs =
-        rewriter.create<complex::ReOp>(loc, type, transformed.lhs());
-    Value imagLhs =
-        rewriter.create<complex::ImOp>(loc, type, transformed.lhs());
-    Value realRhs =
-        rewriter.create<complex::ReOp>(loc, type, transformed.rhs());
-    Value imagRhs =
-        rewriter.create<complex::ImOp>(loc, type, transformed.rhs());
+    auto type =
+        adaptor.lhs().getType().template cast<ComplexType>().getElementType();
+
+    Value realLhs = rewriter.create<complex::ReOp>(loc, type, adaptor.lhs());
+    Value imagLhs = rewriter.create<complex::ImOp>(loc, type, adaptor.lhs());
+    Value realRhs = rewriter.create<complex::ReOp>(loc, type, adaptor.rhs());
+    Value imagRhs = rewriter.create<complex::ImOp>(loc, type, adaptor.rhs());
     Value realComparison = rewriter.create<CmpFOp>(loc, p, realLhs, realRhs);
     Value imagComparison = rewriter.create<CmpFOp>(loc, p, imagLhs, imagRhs);
 
     rewriter.replaceOpWithNewOp<ResultCombiner>(op, realComparison,
                                                 imagComparison);
     return success();
   }
 };
 
 // Default conversion which applies the BinaryStandardOp separately on the real
 // and imaginary parts. Can for example be used for complex::AddOp and
 // complex::SubOp.
 template <typename BinaryComplexOp, typename BinaryStandardOp>
 struct BinaryComplexOpConversion : public OpConversionPattern<BinaryComplexOp> {
   using OpConversionPattern<BinaryComplexOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(BinaryComplexOp op, ArrayRef<Value> operands,
+  matchAndRewrite(BinaryComplexOp op, typename BinaryComplexOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    typename BinaryComplexOp::Adaptor transformed(operands);
-    auto type = transformed.lhs().getType().template cast<ComplexType>();
+    auto type = adaptor.lhs().getType().template cast<ComplexType>();
     auto elementType = type.getElementType().template cast<FloatType>();
     mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
 
-    Value realLhs = b.create<complex::ReOp>(elementType, transformed.lhs());
-    Value realRhs = b.create<complex::ReOp>(elementType, transformed.rhs());
+    Value realLhs = b.create<complex::ReOp>(elementType, adaptor.lhs());
+    Value realRhs = b.create<complex::ReOp>(elementType, adaptor.rhs());
     Value resultReal =
         b.create<BinaryStandardOp>(elementType, realLhs, realRhs);
-    Value imagLhs = b.create<complex::ImOp>(elementType, transformed.lhs());
-    Value imagRhs = b.create<complex::ImOp>(elementType, transformed.rhs());
+    Value imagLhs = b.create<complex::ImOp>(elementType, adaptor.lhs());
+    Value imagRhs = b.create<complex::ImOp>(elementType, adaptor.rhs());
     Value resultImag =
         b.create<BinaryStandardOp>(elementType, imagLhs, imagRhs);
     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, resultReal,
                                                    resultImag);
     return success();
   }
 };
 
 struct DivOpConversion : public OpConversionPattern<complex::DivOp> {
   using OpConversionPattern<complex::DivOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(complex::DivOp op, ArrayRef<Value> operands,
+  matchAndRewrite(complex::DivOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    complex::DivOp::Adaptor transformed(operands);
     auto loc = op.getLoc();
-    auto type = transformed.lhs().getType().cast<ComplexType>();
+    auto type = adaptor.lhs().getType().cast<ComplexType>();
     auto elementType = type.getElementType().cast<FloatType>();
 
     Value lhsReal =
-        rewriter.create<complex::ReOp>(loc, elementType, transformed.lhs());
+        rewriter.create<complex::ReOp>(loc, elementType, adaptor.lhs());
     Value lhsImag =
-        rewriter.create<complex::ImOp>(loc, elementType, transformed.lhs());
+        rewriter.create<complex::ImOp>(loc, elementType, adaptor.lhs());
     Value rhsReal =
-        rewriter.create<complex::ReOp>(loc, elementType, transformed.rhs());
+        rewriter.create<complex::ReOp>(loc, elementType, adaptor.rhs());
     Value rhsImag =
-        rewriter.create<complex::ImOp>(loc, elementType, transformed.rhs());
+        rewriter.create<complex::ImOp>(loc, elementType, adaptor.rhs());
 
     // Smith's algorithm to divide complex numbers. It is just a bit smarter
     // way to compute the following formula:
     //  (lhsReal + lhsImag * i) / (rhsReal + rhsImag * i)
     //    = (lhsReal + lhsImag * i) (rhsReal - rhsImag * i) /
     //          ((rhsReal + rhsImag * i)(rhsReal - rhsImag * i))
     //    = ((lhsReal * rhsReal + lhsImag * rhsImag) +
     //          (lhsImag * rhsReal - lhsReal * rhsImag) * i) / ||rhs||^2
matchAndRewrite(complex::DivOp op, OpAdaptor adaptor,
     return success();
   }
 };
 
 struct ExpOpConversion : public OpConversionPattern<complex::ExpOp> {
   using OpConversionPattern<complex::ExpOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(complex::ExpOp op, ArrayRef<Value> operands,
+  matchAndRewrite(complex::ExpOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    complex::ExpOp::Adaptor transformed(operands);
     auto loc = op.getLoc();
-    auto type = transformed.complex().getType().cast<ComplexType>();
+    auto type = adaptor.complex().getType().cast<ComplexType>();
     auto elementType = type.getElementType().cast<FloatType>();
 
     Value real =
-        rewriter.create<complex::ReOp>(loc, elementType, transformed.complex());
+        rewriter.create<complex::ReOp>(loc, elementType, adaptor.complex());
     Value imag =
-        rewriter.create<complex::ImOp>(loc, elementType, transformed.complex());
+        rewriter.create<complex::ImOp>(loc, elementType, adaptor.complex());
     Value expReal = rewriter.create<math::ExpOp>(loc, real);
     Value cosImag = rewriter.create<math::CosOp>(loc, imag);
     Value resultReal = rewriter.create<MulFOp>(loc, expReal, cosImag);
     Value sinImag = rewriter.create<math::SinOp>(loc, imag);
     Value resultImag = rewriter.create<MulFOp>(loc, expReal, sinImag);
 
     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, resultReal,
                                                    resultImag);
     return success();
   }
 };
 
 struct LogOpConversion : public OpConversionPattern<complex::LogOp> {
   using OpConversionPattern<complex::LogOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(complex::LogOp op, ArrayRef<Value> operands,
+  matchAndRewrite(complex::LogOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    complex::LogOp::Adaptor transformed(operands);
-    auto type = transformed.complex().getType().cast<ComplexType>();
+    auto type = adaptor.complex().getType().cast<ComplexType>();
     auto elementType = type.getElementType().cast<FloatType>();
     mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
 
-    Value abs = b.create<complex::AbsOp>(elementType, transformed.complex());
+    Value abs = b.create<complex::AbsOp>(elementType, adaptor.complex());
     Value resultReal = b.create<math::LogOp>(elementType, abs);
-    Value real = b.create<complex::ReOp>(elementType, transformed.complex());
-    Value imag = b.create<complex::ImOp>(elementType, transformed.complex());
+    Value real = b.create<complex::ReOp>(elementType, adaptor.complex());
+    Value imag = b.create<complex::ImOp>(elementType, adaptor.complex());
     Value resultImag = b.create<math::Atan2Op>(elementType, imag, real);
     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, resultReal,
                                                    resultImag);
     return success();
   }
 };
 
 struct Log1pOpConversion : public OpConversionPattern<complex::Log1pOp> {
   using OpConversionPattern<complex::Log1pOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(complex::Log1pOp op, ArrayRef<Value> operands,
+  matchAndRewrite(complex::Log1pOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    complex::Log1pOp::Adaptor transformed(operands);
-    auto type = transformed.complex().getType().cast<ComplexType>();
+    auto type = adaptor.complex().getType().cast<ComplexType>();
     auto elementType = type.getElementType().cast<FloatType>();
     mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
 
-    Value real = b.create<complex::ReOp>(elementType, transformed.complex());
-    Value imag = b.create<complex::ImOp>(elementType, transformed.complex());
+    Value real = b.create<complex::ReOp>(elementType, adaptor.complex());
+    Value imag = b.create<complex::ImOp>(elementType, adaptor.complex());
     Value one =
         b.create<ConstantOp>(elementType, b.getFloatAttr(elementType, 1));
     Value realPlusOne = b.create<AddFOp>(real, one);
     Value newComplex = b.create<complex::CreateOp>(type, realPlusOne, imag);
     rewriter.replaceOpWithNewOp<complex::LogOp>(op, type, newComplex);
     return success();
   }
 };
 
 struct MulOpConversion : public OpConversionPattern<complex::MulOp> {
   using OpConversionPattern<complex::MulOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(complex::MulOp op, ArrayRef<Value> operands,
+  matchAndRewrite(complex::MulOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    complex::MulOp::Adaptor transformed(operands);
     mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
-    auto type = transformed.lhs().getType().cast<ComplexType>();
+    auto type = adaptor.lhs().getType().cast<ComplexType>();
     auto elementType = type.getElementType().cast<FloatType>();
 
-    Value lhsReal = b.create<complex::ReOp>(elementType, transformed.lhs());
+    Value lhsReal = b.create<complex::ReOp>(elementType, adaptor.lhs());
     Value lhsRealAbs = b.create<AbsFOp>(lhsReal);
-    Value lhsImag = b.create<complex::ImOp>(elementType, transformed.lhs());
+    Value lhsImag = b.create<complex::ImOp>(elementType, adaptor.lhs());
     Value lhsImagAbs = b.create<AbsFOp>(lhsImag);
-    Value rhsReal = b.create<complex::ReOp>(elementType, transformed.rhs());
+    Value rhsReal = b.create<complex::ReOp>(elementType, adaptor.rhs());
     Value rhsRealAbs = b.create<AbsFOp>(rhsReal);
-    Value rhsImag = b.create<complex::ImOp>(elementType, transformed.rhs());
+    Value rhsImag = b.create<complex::ImOp>(elementType, adaptor.rhs());
     Value rhsImagAbs = b.create<AbsFOp>(rhsImag);
 
     Value lhsRealTimesRhsReal = b.create<MulFOp>(lhsReal, rhsReal);
     Value lhsRealTimesRhsRealAbs = b.create<AbsFOp>(lhsRealTimesRhsReal);
     Value lhsImagTimesRhsImag = b.create<MulFOp>(lhsImag, rhsImag);
     Value lhsImagTimesRhsImagAbs = b.create<AbsFOp>(lhsImagTimesRhsImag);
     Value real = b.create<SubFOp>(lhsRealTimesRhsReal, lhsImagTimesRhsImag);
 
matchAndRewrite(complex::MulOp op, OpAdaptor adaptor,
     return success();
   }
 };
 
 struct NegOpConversion : public OpConversionPattern<complex::NegOp> {
   using OpConversionPattern<complex::NegOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(complex::NegOp op, ArrayRef<Value> operands,
+  matchAndRewrite(complex::NegOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    complex::NegOp::Adaptor transformed(operands);
     auto loc = op.getLoc();
-    auto type = transformed.complex().getType().cast<ComplexType>();
+    auto type = adaptor.complex().getType().cast<ComplexType>();
     auto elementType = type.getElementType().cast<FloatType>();
 
     Value real =
-        rewriter.create<complex::ReOp>(loc, elementType, transformed.complex());
+        rewriter.create<complex::ReOp>(loc, elementType, adaptor.complex());
     Value imag =
-        rewriter.create<complex::ImOp>(loc, elementType, transformed.complex());
+        rewriter.create<complex::ImOp>(loc, elementType, adaptor.complex());
     Value negReal = rewriter.create<NegFOp>(loc, real);
     Value negImag = rewriter.create<NegFOp>(loc, imag);
     rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, negReal, negImag);
     return success();
   }
 };
 
 struct SignOpConversion : public OpConversionPattern<complex::SignOp> {
   using OpConversionPattern<complex::SignOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(complex::SignOp op, ArrayRef<Value> operands,
+  matchAndRewrite(complex::SignOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    complex::SignOp::Adaptor transformed(operands);
-    auto type = transformed.complex().getType().cast<ComplexType>();
+    auto type = adaptor.complex().getType().cast<ComplexType>();
     auto elementType = type.getElementType().cast<FloatType>();
     mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
 
-    Value real = b.create<complex::ReOp>(elementType, transformed.complex());
-    Value imag = b.create<complex::ImOp>(elementType, transformed.complex());
+    Value real = b.create<complex::ReOp>(elementType, adaptor.complex());
+    Value imag = b.create<complex::ImOp>(elementType, adaptor.complex());
     Value zero = b.create<ConstantOp>(elementType, b.getZeroAttr(elementType));
     Value realIsZero = b.create<CmpFOp>(CmpFPredicate::OEQ, real, zero);
     Value imagIsZero = b.create<CmpFOp>(CmpFPredicate::OEQ, imag, zero);
     Value isZero = b.create<AndOp>(realIsZero, imagIsZero);
-    auto abs = b.create<complex::AbsOp>(elementType, transformed.complex());
+    auto abs = b.create<complex::AbsOp>(elementType, adaptor.complex());
     Value realSign = b.create<DivFOp>(real, abs);
     Value imagSign = b.create<DivFOp>(imag, abs);
     Value sign = b.create<complex::CreateOp>(type, realSign, imagSign);
-    rewriter.replaceOpWithNewOp<SelectOp>(op, isZero, transformed.complex(),
-                                          sign);
+    rewriter.replaceOpWithNewOp<SelectOp>(op, isZero, adaptor.complex(), sign);
     return success();
   }
 };
 } // namespace
 
 void mlir::populateComplexToStandardConversionPatterns(
     RewritePatternSet &patterns) {
   // clang-format off

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp

 /// Pattern lowering GPU block/thread size/id to loading SPIR-V invocation
 /// builtin variables.
 template <typename SourceOp, spirv::BuiltIn builtin>
 class LaunchConfigConversion : public OpConversionPattern<SourceOp> {
 public:
   using OpConversionPattern<SourceOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
+  matchAndRewrite(SourceOp op, typename SourceOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Pattern lowering subgroup size/id to loading SPIR-V invocation
 /// builtin variables.
 template <typename SourceOp, spirv::BuiltIn builtin>
 class SingleDimLaunchConfigConversion : public OpConversionPattern<SourceOp> {
 public:
   using OpConversionPattern<SourceOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
+  matchAndRewrite(SourceOp op, typename SourceOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// This is separate because in Vulkan workgroup size is exposed to shaders via
 /// a constant with WorkgroupSize decoration. So here we cannot generate a
 /// builtin variable; instead the information in the `spv.entry_point_abi`
 /// attribute on the surrounding FuncOp is used to replace the gpu::BlockDimOp.
 class WorkGroupSizeConversion : public OpConversionPattern<gpu::BlockDimOp> {
 public:
   using OpConversionPattern<gpu::BlockDimOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(gpu::BlockDimOp op, ArrayRef<Value> operands,
+  matchAndRewrite(gpu::BlockDimOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Pattern to convert a kernel function in GPU dialect within a spv.module.
 class GPUFuncOpConversion final : public OpConversionPattern<gpu::GPUFuncOp> {
 public:
   using OpConversionPattern<gpu::GPUFuncOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(gpu::GPUFuncOp funcOp, ArrayRef<Value> operands,
+  matchAndRewrite(gpu::GPUFuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 
 private:
   SmallVector<int32_t, 3> workGroupSizeAsInt32;
 };
 
 /// Pattern to convert a gpu.module to a spv.module.
 class GPUModuleConversion final : public OpConversionPattern<gpu::GPUModuleOp> {
 public:
   using OpConversionPattern<gpu::GPUModuleOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(gpu::GPUModuleOp moduleOp, ArrayRef<Value> operands,
+  matchAndRewrite(gpu::GPUModuleOp moduleOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 class GPUModuleEndConversion final
     : public OpConversionPattern<gpu::ModuleEndOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(gpu::ModuleEndOp endOp, ArrayRef<Value> operands,
+  matchAndRewrite(gpu::ModuleEndOp endOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.eraseOp(endOp);
     return success();
   }
 };
 
 /// Pattern to convert a gpu.return into a SPIR-V return.
 // TODO: This can go to DRR when GPU return has operands.
 class GPUReturnOpConversion final : public OpConversionPattern<gpu::ReturnOp> {
 public:
   using OpConversionPattern<gpu::ReturnOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(gpu::ReturnOp returnOp, ArrayRef<Value> operands,
+  matchAndRewrite(gpu::ReturnOp returnOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Builtins.
 //===----------------------------------------------------------------------===//
 
 static Optional<int32_t> getLaunchConfigIndex(Operation *op) {
   auto dimAttr = op->getAttrOfType<StringAttr>("dimension");
   if (!dimAttr)
     return llvm::None;
 
   return llvm::StringSwitch<Optional<int32_t>>(dimAttr.getValue())
       .Case("x", 0)
       .Case("y", 1)
       .Case("z", 2)
       .Default(llvm::None);
 }
 
 template <typename SourceOp, spirv::BuiltIn builtin>
 LogicalResult LaunchConfigConversion<SourceOp, builtin>::matchAndRewrite(
-    SourceOp op, ArrayRef<Value> operands,
+    SourceOp op, typename SourceOp::Adaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   auto index = getLaunchConfigIndex(op);
   if (!index)
     return failure();
 
   auto *typeConverter = this->template getTypeConverter<SPIRVTypeConverter>();
   auto indexType = typeConverter->getIndexType();
 
   // SPIR-V invocation builtin variables are a vector of type <3xi32>
   auto spirvBuiltin =
       spirv::getBuiltinVariableValue(op, builtin, indexType, rewriter);
   rewriter.replaceOpWithNewOp<spirv::CompositeExtractOp>(
       op, indexType, spirvBuiltin,
       rewriter.getI32ArrayAttr({index.getValue()}));
   return success();
 }
 
 template <typename SourceOp, spirv::BuiltIn builtin>
 LogicalResult
 SingleDimLaunchConfigConversion<SourceOp, builtin>::matchAndRewrite(
-    SourceOp op, ArrayRef<Value> operands,
+    SourceOp op, typename SourceOp::Adaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   auto *typeConverter = this->template getTypeConverter<SPIRVTypeConverter>();
   auto indexType = typeConverter->getIndexType();
 
   auto spirvBuiltin =
       spirv::getBuiltinVariableValue(op, builtin, indexType, rewriter);
   rewriter.replaceOp(op, spirvBuiltin);
   return success();
 }
 
 LogicalResult WorkGroupSizeConversion::matchAndRewrite(
-    gpu::BlockDimOp op, ArrayRef<Value> operands,
+    gpu::BlockDimOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   auto index = getLaunchConfigIndex(op);
   if (!index)
     return failure();
 
   auto workGroupSizeAttr = spirv::lookupLocalWorkGroupSize(op);
   auto val = workGroupSizeAttr.getValue<int32_t>(index.getValue());
   auto convertedType =
for (auto argIndex : llvm::seq<unsigned>(0, funcOp.getNumArguments())) {
     if (funcOp.getArgument(argIndex).getType().isIntOrIndexOrFloat())
       sc = spirv::StorageClass::StorageBuffer;
     argABI.push_back(spirv::getInterfaceVarABIAttr(0, argIndex, sc, context));
   }
   return success();
 }
 
 LogicalResult GPUFuncOpConversion::matchAndRewrite(
-    gpu::GPUFuncOp funcOp, ArrayRef<Value> operands,
+    gpu::GPUFuncOp funcOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   if (!gpu::GPUDialect::isKernel(funcOp))
     return failure();
 
   SmallVector<spirv::InterfaceVarABIAttr, 4> argABI;
   if (failed(getDefaultABIAttrs(rewriter.getContext(), funcOp, argABI))) {
     argABI.clear();
     for (auto argIndex : llvm::seq<unsigned>(0, funcOp.getNumArguments())) {
LogicalResult GPUFuncOpConversion::matchAndRewrite(
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ModuleOp with gpu.module.
 //===----------------------------------------------------------------------===//
 
 LogicalResult GPUModuleConversion::matchAndRewrite(
-    gpu::GPUModuleOp moduleOp, ArrayRef<Value> operands,
+    gpu::GPUModuleOp moduleOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   spirv::TargetEnvAttr targetEnv = spirv::lookupTargetEnvOrDefault(moduleOp);
   spirv::AddressingModel addressingModel = spirv::getAddressingModel(targetEnv);
   FailureOr<spirv::MemoryModel> memoryModel = spirv::getMemoryModel(targetEnv);
   if (failed(memoryModel))
     return moduleOp.emitRemark("match failure: could not selected memory model "
                                "based on 'spv.target_env'");
 
LogicalResult GPUModuleConversion::matchAndRewrite(
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GPU return inside kernel functions to SPIR-V return.
 //===----------------------------------------------------------------------===//
 
 LogicalResult GPUReturnOpConversion::matchAndRewrite(
-    gpu::ReturnOp returnOp, ArrayRef<Value> operands,
+    gpu::ReturnOp returnOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
-  if (!operands.empty())
+  if (!adaptor.getOperands().empty())
     return failure();
 
   rewriter.replaceOpWithNewOp<spirv::ReturnOp>(returnOp);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // GPU To SPIRV Patterns.

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp

struct SingleWorkgroupReduction final
   using OpConversionPattern::OpConversionPattern;
 
   /// Matches the given linalg.generic op as performing reduction and returns
   /// the binary op kind if successful.
   static Optional<linalg::RegionMatcher::BinaryOpKind>
   matchAsPerformingReduction(linalg::GenericOp genericOp);
 
   LogicalResult
-  matchAndRewrite(linalg::GenericOp genericOp, ArrayRef<Value> operands,
+  matchAndRewrite(linalg::GenericOp genericOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 } // namespace
 
 Optional<linalg::RegionMatcher::BinaryOpKind>
 SingleWorkgroupReduction::matchAsPerformingReduction(
     linalg::GenericOp genericOp) {
SingleWorkgroupReduction::matchAsPerformingReduction(
   if (outputMap.getValue() !=
       AffineMap::get(1, 0, getAffineConstantExpr(0, op->getContext())))
     return llvm::None;
 
   return linalg::RegionMatcher::matchAsScalarBinaryOp(genericOp);
 }
 
 LogicalResult SingleWorkgroupReduction::matchAndRewrite(
-    linalg::GenericOp genericOp, ArrayRef<Value> operands,
+    linalg::GenericOp genericOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   Operation *op = genericOp.getOperation();
   auto originalInputType = op->getOperand(0).getType().cast<MemRefType>();
   auto originalOutputType = op->getOperand(1).getType().cast<MemRefType>();
 
   auto binaryOpKind = matchAsPerformingReduction(genericOp);
   if (!binaryOpKind)
     return failure();
 
   // Query the shader interface for local workgroup size to make sure the
   // invocation configuration fits with the input memref's shape.
   DenseIntElementsAttr localSize = spirv::lookupLocalWorkGroupSize(genericOp);
   if (!localSize)
     return failure();
 
   if ((*localSize.begin()).getSExtValue() != originalInputType.getDimSize(0))
     return failure();
   if (llvm::any_of(llvm::drop_begin(localSize.getIntValues(), 1),
                    [](const APInt &size) { return !size.isOneValue(); }))
     return failure();
 
   // TODO: Query the target environment to make sure the current
   // workload fits in a local workgroup.
 
-  Value convertedInput = operands[0], convertedOutput = operands[1];
+  Value convertedInput = adaptor.getOperands()[0];
+  Value convertedOutput = adaptor.getOperands()[1];
   Location loc = genericOp.getLoc();
 
   auto *typeConverter = getTypeConverter<SPIRVTypeConverter>();
   auto indexType = typeConverter->getIndexType();
 
   // Get the invocation ID.
   Value x = getLocalInvocationDimSize(genericOp, /*dim=*/0, indexType, loc,
                                       &rewriter);

mlir/lib/Conversion/MathToSPIRV/MathToSPIRV.cpp

 
 /// Converts unary and binary standard operations to SPIR-V operations.
 template <typename StdOp, typename SPIRVOp>
 class UnaryAndBinaryOpPattern final : public OpConversionPattern<StdOp> {
 public:
   using OpConversionPattern<StdOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(StdOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(StdOp operation, typename StdOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    assert(operands.size() <= 2);
+    assert(adaptor.getOperands().size() <= 2);
     auto dstType = this->getTypeConverter()->convertType(operation.getType());
     if (!dstType)
       return failure();
     if (SPIRVOp::template hasTrait<OpTrait::spirv::UnsignedOp>() &&
         dstType != operation.getType()) {
       return operation.emitError(
           "bitwidth emulation is not implemented yet on unsigned op");
     }
-    rewriter.template replaceOpWithNewOp<SPIRVOp>(operation, dstType, operands);
+    rewriter.template replaceOpWithNewOp<SPIRVOp>(operation, dstType,
+                                                  adaptor.getOperands());
     return success();
   }
 };
 
 /// Converts math.log1p to SPIR-V ops.
 ///
 /// SPIR-V does not have a direct operations for log(1+x). Explicitly lower to
 /// these operations.
 class Log1pOpPattern final : public OpConversionPattern<math::Log1pOp> {
 public:
   using OpConversionPattern<math::Log1pOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(math::Log1pOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(math::Log1pOp operation, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    assert(operands.size() == 1);
+    assert(adaptor.getOperands().size() == 1);
     Location loc = operation.getLoc();
     auto type =
         this->getTypeConverter()->convertType(operation.operand().getType());
     auto one = spirv::ConstantOp::getOne(type, operation.getLoc(), rewriter);
-    auto onePlus = rewriter.create<spirv::FAddOp>(loc, one, operands[0]);
+    auto onePlus =
+        rewriter.create<spirv::FAddOp>(loc, one, adaptor.getOperands()[0]);
     rewriter.replaceOpWithNewOp<spirv::GLSLLogOp>(operation, type, onePlus);
     return success();
   }
 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//

mlir/lib/Conversion/MemRefToSPIRV/MemRefToSPIRV.cpp

 /// to Workgroup memory when the size is constant.  Note that this pattern needs
 /// to be applied in a pass that runs at least at spv.module scope since it wil
 /// ladd global variables into the spv.module.
 class AllocOpPattern final : public OpConversionPattern<memref::AllocOp> {
 public:
   using OpConversionPattern<memref::AllocOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(memref::AllocOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(memref::AllocOp operation, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Removed a deallocation if it is a supported allocation. Currently only
 /// removes deallocation if the memory space is workgroup memory.
 class DeallocOpPattern final : public OpConversionPattern<memref::DeallocOp> {
 public:
   using OpConversionPattern<memref::DeallocOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(memref::DeallocOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(memref::DeallocOp operation, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts memref.load to spv.Load.
 class IntLoadOpPattern final : public OpConversionPattern<memref::LoadOp> {
 public:
   using OpConversionPattern<memref::LoadOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(memref::LoadOp loadOp, ArrayRef<Value> operands,
+  matchAndRewrite(memref::LoadOp loadOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts memref.load to spv.Load.
 class LoadOpPattern final : public OpConversionPattern<memref::LoadOp> {
 public:
   using OpConversionPattern<memref::LoadOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(memref::LoadOp loadOp, ArrayRef<Value> operands,
+  matchAndRewrite(memref::LoadOp loadOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts memref.store to spv.Store on integers.
 class IntStoreOpPattern final : public OpConversionPattern<memref::StoreOp> {
 public:
   using OpConversionPattern<memref::StoreOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(memref::StoreOp storeOp, ArrayRef<Value> operands,
+  matchAndRewrite(memref::StoreOp storeOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts memref.store to spv.Store.
 class StoreOpPattern final : public OpConversionPattern<memref::StoreOp> {
 public:
   using OpConversionPattern<memref::StoreOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(memref::StoreOp storeOp, ArrayRef<Value> operands,
+  matchAndRewrite(memref::StoreOp storeOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // AllocOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-AllocOpPattern::matchAndRewrite(memref::AllocOp operation,
-                                ArrayRef<Value> operands,
+AllocOpPattern::matchAndRewrite(memref::AllocOp operation, OpAdaptor adaptor,
                                 ConversionPatternRewriter &rewriter) const {
   MemRefType allocType = operation.getType();
   if (!isAllocationSupported(allocType))
     return operation.emitError("unhandled allocation type");
 
   // Get the SPIR-V type for the allocation.
   Type spirvType = getTypeConverter()->convertType(allocType);
 

 }
 
 //===----------------------------------------------------------------------===//
 // DeallocOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 DeallocOpPattern::matchAndRewrite(memref::DeallocOp operation,
-                                  ArrayRef<Value> operands,
+                                  OpAdaptor adaptor,
                                   ConversionPatternRewriter &rewriter) const {
   MemRefType deallocType = operation.memref().getType().cast<MemRefType>();
   if (!isAllocationSupported(deallocType))
     return operation.emitError("unhandled deallocation type");
   rewriter.eraseOp(operation);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // LoadOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-IntLoadOpPattern::matchAndRewrite(memref::LoadOp loadOp,
-                                  ArrayRef<Value> operands,
+IntLoadOpPattern::matchAndRewrite(memref::LoadOp loadOp, OpAdaptor adaptor,
                                   ConversionPatternRewriter &rewriter) const {
-  memref::LoadOpAdaptor loadOperands(operands);
   auto loc = loadOp.getLoc();
   auto memrefType = loadOp.memref().getType().cast<MemRefType>();
   if (!memrefType.getElementType().isSignlessInteger())
     return failure();
 
   auto &typeConverter = *getTypeConverter<SPIRVTypeConverter>();
   spirv::AccessChainOp accessChainOp =
-      spirv::getElementPtr(typeConverter, memrefType, loadOperands.memref(),
-                           loadOperands.indices(), loc, rewriter);
+      spirv::getElementPtr(typeConverter, memrefType, adaptor.memref(),
+                           adaptor.indices(), loc, rewriter);
 
   if (!accessChainOp)
     return failure();
 
   int srcBits = memrefType.getElementType().getIntOrFloatBitWidth();
   bool isBool = srcBits == 1;
   if (isBool)
     srcBits = typeConverter.getOptions().boolNumBits;
IntLoadOpPattern::matchAndRewrite(memref::LoadOp loadOp, OpAdaptor adaptor,
 
   assert(accessChainOp.use_empty());
   rewriter.eraseOp(accessChainOp);
 
   return success();
 }
 
 LogicalResult
-LoadOpPattern::matchAndRewrite(memref::LoadOp loadOp, ArrayRef<Value> operands,
+LoadOpPattern::matchAndRewrite(memref::LoadOp loadOp, OpAdaptor adaptor,
                                ConversionPatternRewriter &rewriter) const {
-  memref::LoadOpAdaptor loadOperands(operands);
   auto memrefType = loadOp.memref().getType().cast<MemRefType>();
   if (memrefType.getElementType().isSignlessInteger())
     return failure();
   auto loadPtr = spirv::getElementPtr(
-      *getTypeConverter<SPIRVTypeConverter>(), memrefType,
-      loadOperands.memref(), loadOperands.indices(), loadOp.getLoc(), rewriter);
+      *getTypeConverter<SPIRVTypeConverter>(), memrefType, adaptor.memref(),
+      adaptor.indices(), loadOp.getLoc(), rewriter);
 
   if (!loadPtr)
     return failure();
 
   rewriter.replaceOpWithNewOp<spirv::LoadOp>(loadOp, loadPtr);
   return success();
 }
 
 LogicalResult
-IntStoreOpPattern::matchAndRewrite(memref::StoreOp storeOp,
-                                   ArrayRef<Value> operands,
+IntStoreOpPattern::matchAndRewrite(memref::StoreOp storeOp, OpAdaptor adaptor,
                                    ConversionPatternRewriter &rewriter) const {
-  memref::StoreOpAdaptor storeOperands(operands);
   auto memrefType = storeOp.memref().getType().cast<MemRefType>();
   if (!memrefType.getElementType().isSignlessInteger())
     return failure();
 
   auto loc = storeOp.getLoc();
   auto &typeConverter = *getTypeConverter<SPIRVTypeConverter>();
   spirv::AccessChainOp accessChainOp =
-      spirv::getElementPtr(typeConverter, memrefType, storeOperands.memref(),
-                           storeOperands.indices(), loc, rewriter);
+      spirv::getElementPtr(typeConverter, memrefType, adaptor.memref(),
+                           adaptor.indices(), loc, rewriter);
 
   if (!accessChainOp)
     return failure();
 
   int srcBits = memrefType.getElementType().getIntOrFloatBitWidth();
 
   bool isBool = srcBits == 1;
   if (isBool)
     srcBits = typeConverter.getOptions().boolNumBits;
 
   Type pointeeType = typeConverter.convertType(memrefType)
                          .cast<spirv::PointerType>()
                          .getPointeeType();
   Type structElemType = pointeeType.cast<spirv::StructType>().getElementType(0);
   Type dstType;
   if (auto arrayType = structElemType.dyn_cast<spirv::ArrayType>())
     dstType = arrayType.getElementType();
   else
     dstType = structElemType.cast<spirv::RuntimeArrayType>().getElementType();
 
   int dstBits = dstType.getIntOrFloatBitWidth();
   assert(dstBits % srcBits == 0);
 
   if (srcBits == dstBits) {
-    Value storeVal = storeOperands.value();
+    Value storeVal = adaptor.value();
     if (isBool)
       storeVal = castBoolToIntN(loc, storeVal, dstType, rewriter);
     rewriter.replaceOpWithNewOp<spirv::StoreOp>(
         storeOp, accessChainOp.getResult(), storeVal);
     return success();
   }
 
   // Since there are multi threads in the processing, the emulation will be done
IntStoreOpPattern::matchAndRewrite(memref::StoreOp storeOp, OpAdaptor adaptor,
   // Create a mask to clear the destination. E.g., if it is the second i8 in
   // i32, 0xFFFF00FF is created.
   Value mask = rewriter.create<spirv::ConstantOp>(
       loc, dstType, rewriter.getIntegerAttr(dstType, (1 << srcBits) - 1));
   Value clearBitsMask =
       rewriter.create<spirv::ShiftLeftLogicalOp>(loc, dstType, mask, offset);
   clearBitsMask = rewriter.create<spirv::NotOp>(loc, dstType, clearBitsMask);
 
-  Value storeVal = storeOperands.value();
+  Value storeVal = adaptor.value();
   if (isBool)
     storeVal = castBoolToIntN(loc, storeVal, dstType, rewriter);
   storeVal = shiftValue(loc, storeVal, offset, mask, dstBits, rewriter);
   Value adjustedPtr = adjustAccessChainForBitwidth(typeConverter, accessChainOp,
                                                    srcBits, dstBits, rewriter);
   Optional<spirv::Scope> scope = getAtomicOpScope(memrefType);
   if (!scope)
     return failure();
IntStoreOpPattern::matchAndRewrite(memref::StoreOp storeOp, OpAdaptor adaptor,
 
   assert(accessChainOp.use_empty());
   rewriter.eraseOp(accessChainOp);
 
   return success();
 }
 
 LogicalResult
-StoreOpPattern::matchAndRewrite(memref::StoreOp storeOp,
-                                ArrayRef<Value> operands,
+StoreOpPattern::matchAndRewrite(memref::StoreOp storeOp, OpAdaptor adaptor,
                                 ConversionPatternRewriter &rewriter) const {
-  memref::StoreOpAdaptor storeOperands(operands);
   auto memrefType = storeOp.memref().getType().cast<MemRefType>();
   if (memrefType.getElementType().isSignlessInteger())
     return failure();
-  auto storePtr =
-      spirv::getElementPtr(*getTypeConverter<SPIRVTypeConverter>(), memrefType,
-                           storeOperands.memref(), storeOperands.indices(),
-                           storeOp.getLoc(), rewriter);
+  auto storePtr = spirv::getElementPtr(
+      *getTypeConverter<SPIRVTypeConverter>(), memrefType, adaptor.memref(),
+      adaptor.indices(), storeOp.getLoc(), rewriter);
 
   if (!storePtr)
     return failure();
 
   rewriter.replaceOpWithNewOp<spirv::StoreOp>(storeOp, storePtr,
-                                              storeOperands.value());
+                                              adaptor.value());
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Pattern population
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 void populateMemRefToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
                                    RewritePatternSet &patterns) {
   patterns.add<AllocOpPattern, DeallocOpPattern, IntLoadOpPattern,
                IntStoreOpPattern, LoadOpPattern, StoreOpPattern>(
       typeConverter, patterns.getContext());
 }
 } // namespace mlir

mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp

 };
 
 /// Pattern to convert a scf::ForOp within kernel functions into spirv::LoopOp.
 class ForOpConversion final : public SCFToSPIRVPattern<scf::ForOp> {
 public:
   using SCFToSPIRVPattern<scf::ForOp>::SCFToSPIRVPattern;
 
   LogicalResult
-  matchAndRewrite(scf::ForOp forOp, ArrayRef<Value> operands,
+  matchAndRewrite(scf::ForOp forOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Pattern to convert a scf::IfOp within kernel functions into
 /// spirv::SelectionOp.
 class IfOpConversion final : public SCFToSPIRVPattern<scf::IfOp> {
 public:
   using SCFToSPIRVPattern<scf::IfOp>::SCFToSPIRVPattern;
 
   LogicalResult
-  matchAndRewrite(scf::IfOp ifOp, ArrayRef<Value> operands,
+  matchAndRewrite(scf::IfOp ifOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 class TerminatorOpConversion final : public SCFToSPIRVPattern<scf::YieldOp> {
 public:
   using SCFToSPIRVPattern<scf::YieldOp>::SCFToSPIRVPattern;
 
   LogicalResult
-  matchAndRewrite(scf::YieldOp terminatorOp, ArrayRef<Value> operands,
+  matchAndRewrite(scf::YieldOp terminatorOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 /// Helper function to replaces SCF op outputs with SPIR-V variable loads.
 /// We create VariableOp to handle the results value of the control flow region.
 /// spv.mlir.loop/spv.mlir.selection currently don't yield value. Right after
 /// the loop we load the value from the allocation and use it as the SCF op
static void replaceSCFOutputValue(ScfOp scfOp, OpTy newOp,
   rewriter.replaceOp(scfOp, resultValue);
 }
 
 //===----------------------------------------------------------------------===//
 // scf::ForOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-ForOpConversion::matchAndRewrite(scf::ForOp forOp, ArrayRef<Value> operands,
+ForOpConversion::matchAndRewrite(scf::ForOp forOp, OpAdaptor adaptor,
                                  ConversionPatternRewriter &rewriter) const {
   // scf::ForOp can be lowered to the structured control flow represented by
   // spirv::LoopOp by making the continue block of the spirv::LoopOp the loop
   // latch and the merge block the exit block. The resulting spirv::LoopOp has a
   // single back edge from the continue to header block, and a single exit from
   // header to merge.
-  scf::ForOpAdaptor forOperands(operands);
   auto loc = forOp.getLoc();
   auto loopOp = rewriter.create<spirv::LoopOp>(loc, spirv::LoopControl::None);
   loopOp.addEntryAndMergeBlock();
 
   OpBuilder::InsertionGuard guard(rewriter);
   // Create the block for the header.
   auto *header = new Block();
   // Insert the header.
   loopOp.body().getBlocks().insert(std::next(loopOp.body().begin(), 1), header);
 
   // Create the new induction variable to use.
-  BlockArgument newIndVar =
-      header->addArgument(forOperands.lowerBound().getType());
-  for (Value arg : forOperands.initArgs())
+  BlockArgument newIndVar = header->addArgument(adaptor.lowerBound().getType());
+  for (Value arg : adaptor.initArgs())
     header->addArgument(arg.getType());
   Block *body = forOp.getBody();
 
   // Apply signature conversion to the body of the forOp. It has a single block,
   // with argument which is the induction variable. That has to be replaced with
   // the new induction variable.
   TypeConverter::SignatureConversion signatureConverter(
       body->getNumArguments());
   signatureConverter.remapInput(0, newIndVar);
   for (unsigned i = 1, e = body->getNumArguments(); i < e; i++)
     signatureConverter.remapInput(i, header->getArgument(i));
   body = rewriter.applySignatureConversion(&forOp.getLoopBody(),
                                            signatureConverter);
 
   // Move the blocks from the forOp into the loopOp. This is the body of the
   // loopOp.
   rewriter.inlineRegionBefore(forOp->getRegion(0), loopOp.body(),
                               std::next(loopOp.body().begin(), 2));
 
-  SmallVector<Value, 8> args(1, forOperands.lowerBound());
-  args.append(forOperands.initArgs().begin(), forOperands.initArgs().end());
+  SmallVector<Value, 8> args(1, adaptor.lowerBound());
+  args.append(adaptor.initArgs().begin(), adaptor.initArgs().end());
   // Branch into it from the entry.
   rewriter.setInsertionPointToEnd(&(loopOp.body().front()));
   rewriter.create<spirv::BranchOp>(loc, header, args);
 
   // Generate the rest of the loop header.
   rewriter.setInsertionPointToEnd(header);
   auto *mergeBlock = loopOp.getMergeBlock();
   auto cmpOp = rewriter.create<spirv::SLessThanOp>(
-      loc, rewriter.getI1Type(), newIndVar, forOperands.upperBound());
+      loc, rewriter.getI1Type(), newIndVar, adaptor.upperBound());
 
   rewriter.create<spirv::BranchConditionalOp>(
       loc, cmpOp, body, ArrayRef<Value>(), mergeBlock, ArrayRef<Value>());
 
   // Generate instructions to increment the step of the induction variable and
   // branch to the header.
   Block *continueBlock = loopOp.getContinueBlock();
   rewriter.setInsertionPointToEnd(continueBlock);
 
   // Add the step to the induction variable and branch to the header.
   Value updatedIndVar = rewriter.create<spirv::IAddOp>(
-      loc, newIndVar.getType(), newIndVar, forOperands.step());
+      loc, newIndVar.getType(), newIndVar, adaptor.step());
   rewriter.create<spirv::BranchOp>(loc, header, updatedIndVar);
 
   // Infer the return types from the init operands. Vector type may get
   // converted to CooperativeMatrix or to Vector type, to avoid having complex
   // extra logic to figure out the right type we just infer it from the Init
   // operands.
   SmallVector<Type, 8> initTypes;
-  for (auto arg : forOperands.initArgs())
+  for (auto arg : adaptor.initArgs())
     initTypes.push_back(arg.getType());
   replaceSCFOutputValue(forOp, loopOp, rewriter, scfToSPIRVContext, initTypes);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // scf::IfOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-IfOpConversion::matchAndRewrite(scf::IfOp ifOp, ArrayRef<Value> operands,
+IfOpConversion::matchAndRewrite(scf::IfOp ifOp, OpAdaptor adaptor,
                                 ConversionPatternRewriter &rewriter) const {
   // When lowering `scf::IfOp` we explicitly create a selection header block
   // before the control flow diverges and a merge block where control flow
   // subsequently converges.
-  scf::IfOpAdaptor ifOperands(operands);
   auto loc = ifOp.getLoc();
 
   // Create `spv.selection` operation, selection header block and merge block.
   auto selectionOp =
       rewriter.create<spirv::SelectionOp>(loc, spirv::SelectionControl::None);
   auto *mergeBlock =
       rewriter.createBlock(&selectionOp.body(), selectionOp.body().end());
   rewriter.create<spirv::MergeOp>(loc);
if (!ifOp.elseRegion().empty()) {
     elseBlock = &elseRegion.front();
     rewriter.setInsertionPointToEnd(&elseRegion.back());
     rewriter.create<spirv::BranchOp>(loc, mergeBlock);
     rewriter.inlineRegionBefore(elseRegion, mergeBlock);
   }
 
   // Create a `spv.BranchConditional` operation for selection header block.
   rewriter.setInsertionPointToEnd(selectionHeaderBlock);
-  rewriter.create<spirv::BranchConditionalOp>(loc, ifOperands.condition(),
+  rewriter.create<spirv::BranchConditionalOp>(loc, adaptor.condition(),
                                               thenBlock, ArrayRef<Value>(),
                                               elseBlock, ArrayRef<Value>());
 
   SmallVector<Type, 8> returnTypes;
   for (auto result : ifOp.results()) {
     auto convertedType = typeConverter.convertType(result.getType());
     returnTypes.push_back(convertedType);
   }
   replaceSCFOutputValue(ifOp, selectionOp, rewriter, scfToSPIRVContext,
                         returnTypes);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // scf::YieldOp
 //===----------------------------------------------------------------------===//
 
 /// Yield is lowered to stores to the VariableOp created during lowering of the
 /// parent region. For loops we also need to update the branch looping back to
 /// the header with the loop carried values.
 LogicalResult TerminatorOpConversion::matchAndRewrite(
-    scf::YieldOp terminatorOp, ArrayRef<Value> operands,
+    scf::YieldOp terminatorOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
+  ValueRange operands = adaptor.getOperands();
+
   // If the region is return values, store each value into the associated
   // VariableOp created during lowering of the parent region.
   if (!operands.empty()) {
     auto loc = terminatorOp.getLoc();
     auto &allocas = scfToSPIRVContext->outputVars[terminatorOp->getParentOp()];
     assert(allocas.size() == operands.size());
     for (unsigned i = 0, e = operands.size(); i < e; i++)
       rewriter.create<spirv::StoreOp>(loc, allocas[i], operands[i]);

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

 
 namespace {
 
 class AccessChainPattern : public SPIRVToLLVMConversion<spirv::AccessChainOp> {
 public:
   using SPIRVToLLVMConversion<spirv::AccessChainOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::AccessChainOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::AccessChainOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = typeConverter.convertType(op.component_ptr().getType());
     if (!dstType)
       return failure();
     // To use GEP we need to add a first 0 index to go through the pointer.
     auto indices = llvm::to_vector<4>(op.indices());
     Type indexType = op.indices().front().getType();
     auto llvmIndexType = typeConverter.convertType(indexType);
     if (!llvmIndexType)
       return failure();
     Value zero = rewriter.create<LLVM::ConstantOp>(
         op.getLoc(), llvmIndexType, rewriter.getIntegerAttr(indexType, 0));
     indices.insert(indices.begin(), zero);
     rewriter.replaceOpWithNewOp<LLVM::GEPOp>(op, dstType, op.base_ptr(),
                                              indices);
     return success();
   }
 };
 
 class AddressOfPattern : public SPIRVToLLVMConversion<spirv::AddressOfOp> {
 public:
   using SPIRVToLLVMConversion<spirv::AddressOfOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::AddressOfOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::AddressOfOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = typeConverter.convertType(op.pointer().getType());
     if (!dstType)
       return failure();
     rewriter.replaceOpWithNewOp<LLVM::AddressOfOp>(op, dstType, op.variable());
     return success();
   }
 };
 
 class BitFieldInsertPattern
     : public SPIRVToLLVMConversion<spirv::BitFieldInsertOp> {
 public:
   using SPIRVToLLVMConversion<spirv::BitFieldInsertOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::BitFieldInsertOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::BitFieldInsertOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
     Location loc = op.getLoc();
 
     // Process `Offset` and `Count`: broadcast and extend/truncate if needed.

 
 /// Converts SPIR-V ConstantOp with scalar or vector type.
 class ConstantScalarAndVectorPattern
     : public SPIRVToLLVMConversion<spirv::ConstantOp> {
 public:
   using SPIRVToLLVMConversion<spirv::ConstantOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::ConstantOp constOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::ConstantOp constOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = constOp.getType();
     if (!srcType.isa<VectorType>() && !srcType.isIntOrFloat())
       return failure();
 
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
if (isSignedIntegerOrVector(srcType) ||
                 signlessType, [&](const APInt &value) { return value; }));
         return success();
       }
       auto srcAttr = constOp.value().cast<IntegerAttr>();
       auto dstAttr = rewriter.getIntegerAttr(signlessType, srcAttr.getValue());
       rewriter.replaceOpWithNewOp<LLVM::ConstantOp>(constOp, dstType, dstAttr);
       return success();
     }
-    rewriter.replaceOpWithNewOp<LLVM::ConstantOp>(constOp, dstType, operands,
-                                                  constOp->getAttrs());
+    rewriter.replaceOpWithNewOp<LLVM::ConstantOp>(
+        constOp, dstType, adaptor.getOperands(), constOp->getAttrs());
     return success();
   }
 };
 
 class BitFieldSExtractPattern
     : public SPIRVToLLVMConversion<spirv::BitFieldSExtractOp> {
 public:
   using SPIRVToLLVMConversion<spirv::BitFieldSExtractOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::BitFieldSExtractOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::BitFieldSExtractOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
     Location loc = op.getLoc();
 
     // Process `Offset` and `Count`: broadcast and extend/truncate if needed.

 };
 
 class BitFieldUExtractPattern
     : public SPIRVToLLVMConversion<spirv::BitFieldUExtractOp> {
 public:
   using SPIRVToLLVMConversion<spirv::BitFieldUExtractOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::BitFieldUExtractOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::BitFieldUExtractOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
     Location loc = op.getLoc();
 
     // Process `Offset` and `Count`: broadcast and extend/truncate if needed.
public:
   }
 };
 
 class BranchConversionPattern : public SPIRVToLLVMConversion<spirv::BranchOp> {
 public:
   using SPIRVToLLVMConversion<spirv::BranchOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::BranchOp branchOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::BranchOp branchOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<LLVM::BrOp>(branchOp, operands,
+    rewriter.replaceOpWithNewOp<LLVM::BrOp>(branchOp, adaptor.getOperands(),
                                             branchOp.getTarget());
     return success();
   }
 };
 
 class BranchConditionalConversionPattern
     : public SPIRVToLLVMConversion<spirv::BranchConditionalOp> {
 public:
   using SPIRVToLLVMConversion<
       spirv::BranchConditionalOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::BranchConditionalOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::BranchConditionalOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // If branch weights exist, map them to 32-bit integer vector.
     ElementsAttr branchWeights = nullptr;
     if (auto weights = op.branch_weights()) {
       VectorType weightType = VectorType::get(2, rewriter.getI32Type());
       branchWeights =
           DenseElementsAttr::get(weightType, weights.getValue().getValue());
     }

 /// is an aggregate type (struct or array). Otherwise, converts to
 /// `llvm.extractelement` that operates on vectors.
 class CompositeExtractPattern
     : public SPIRVToLLVMConversion<spirv::CompositeExtractOp> {
 public:
   using SPIRVToLLVMConversion<spirv::CompositeExtractOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::CompositeExtractOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::CompositeExtractOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = this->typeConverter.convertType(op.getType());
     if (!dstType)
       return failure();
 
     Type containerType = op.composite().getType();
     if (containerType.isa<VectorType>()) {
       Location loc = op.getLoc();

 /// is an aggregate type (struct or array). Otherwise, converts to
 /// `llvm.insertelement` that operates on vectors.
 class CompositeInsertPattern
     : public SPIRVToLLVMConversion<spirv::CompositeInsertOp> {
 public:
   using SPIRVToLLVMConversion<spirv::CompositeInsertOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::CompositeInsertOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::CompositeInsertOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = this->typeConverter.convertType(op.getType());
     if (!dstType)
       return failure();
 
     Type containerType = op.composite().getType();
     if (containerType.isa<VectorType>()) {
       Location loc = op.getLoc();

 /// Converts SPIR-V operations that have straightforward LLVM equivalent
 /// into LLVM dialect operations.
 template <typename SPIRVOp, typename LLVMOp>
 class DirectConversionPattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
-    rewriter.template replaceOpWithNewOp<LLVMOp>(operation, dstType, operands,
-                                                 operation->getAttrs());
+    rewriter.template replaceOpWithNewOp<LLVMOp>(
+        operation, dstType, adaptor.getOperands(), operation->getAttrs());
     return success();
   }
 };
 
 /// Converts `spv.ExecutionMode` into a global struct constant that holds
 /// execution mode information.
 class ExecutionModePattern
     : public SPIRVToLLVMConversion<spirv::ExecutionModeOp> {
 public:
   using SPIRVToLLVMConversion<spirv::ExecutionModeOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::ExecutionModeOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::ExecutionModeOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // First, create the global struct's name that would be associated with
     // this entry point's execution mode. We set it to be:
     //   __spv__{SPIR-V module name}_{function name}_execution_mode_info
     ModuleOp module = op->getParentOfType<ModuleOp>();
     std::string moduleName;
     if (module.getName().hasValue())
       moduleName = "_" + module.getName().getValue().str();

 /// This difference is handled by `spv.mlir.addressof` and
 /// `llvm.mlir.addressof`ops that both return a pointer.
 class GlobalVariablePattern
     : public SPIRVToLLVMConversion<spirv::GlobalVariableOp> {
 public:
   using SPIRVToLLVMConversion<spirv::GlobalVariableOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::GlobalVariableOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::GlobalVariableOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Currently, there is no support of initialization with a constant value in
     // SPIR-V dialect. Specialization constants are not considered as well.
     if (op.initializer())
       return failure();
 
     auto srcType = op.type().cast<spirv::PointerType>();
     auto dstType = typeConverter.convertType(srcType.getPointeeType());

 /// Converts SPIR-V cast ops that do not have straightforward LLVM
 /// equivalent in LLVM dialect.
 template <typename SPIRVOp, typename LLVMExtOp, typename LLVMTruncOp>
 class IndirectCastPattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     Type fromType = operation.operand().getType();
     Type toType = operation.getType();
 
     auto dstType = this->typeConverter.convertType(toType);
     if (!dstType)
       return failure();
 
     if (getBitWidth(fromType) < getBitWidth(toType)) {
       rewriter.template replaceOpWithNewOp<LLVMExtOp>(operation, dstType,
-                                                      operands);
+                                                      adaptor.getOperands());
       return success();
     }
     if (getBitWidth(fromType) > getBitWidth(toType)) {
       rewriter.template replaceOpWithNewOp<LLVMTruncOp>(operation, dstType,
-                                                        operands);
+                                                        adaptor.getOperands());
       return success();
     }
     return failure();
   }
 };
 
 class FunctionCallPattern
     : public SPIRVToLLVMConversion<spirv::FunctionCallOp> {
 public:
   using SPIRVToLLVMConversion<spirv::FunctionCallOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::FunctionCallOp callOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::FunctionCallOp callOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (callOp.getNumResults() == 0) {
-      rewriter.replaceOpWithNewOp<LLVM::CallOp>(callOp, llvm::None, operands,
-                                                callOp->getAttrs());
+      rewriter.replaceOpWithNewOp<LLVM::CallOp>(
+          callOp, llvm::None, adaptor.getOperands(), callOp->getAttrs());
       return success();
     }
 
     // Function returns a single result.
     auto dstType = typeConverter.convertType(callOp.getType(0));
-    rewriter.replaceOpWithNewOp<LLVM::CallOp>(callOp, dstType, operands,
-                                              callOp->getAttrs());
+    rewriter.replaceOpWithNewOp<LLVM::CallOp>(
+        callOp, dstType, adaptor.getOperands(), callOp->getAttrs());
     return success();
   }
 };
 
 /// Converts SPIR-V floating-point comparisons to llvm.fcmp "predicate"
 template <typename SPIRVOp, LLVM::FCmpPredicate predicate>
 class FComparePattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
 
     rewriter.template replaceOpWithNewOp<LLVM::FCmpOp>(
         operation, dstType, predicate, operation.operand1(),
         operation.operand2());
     return success();
   }
 };
 
 /// Converts SPIR-V integer comparisons to llvm.icmp "predicate"
 template <typename SPIRVOp, LLVM::ICmpPredicate predicate>
 class IComparePattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
 
     rewriter.template replaceOpWithNewOp<LLVM::ICmpOp>(
         operation, dstType, predicate, operation.operand1(),
         operation.operand2());
     return success();
   }
 };
 
 class InverseSqrtPattern
     : public SPIRVToLLVMConversion<spirv::GLSLInverseSqrtOp> {
 public:
   using SPIRVToLLVMConversion<spirv::GLSLInverseSqrtOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::GLSLInverseSqrtOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::GLSLInverseSqrtOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
 
     Location loc = op.getLoc();
     Value one = createFPConstant(loc, srcType, dstType, rewriter, 1.0);
     Value sqrt = rewriter.create<LLVM::SqrtOp>(loc, dstType, op.operand());
     rewriter.replaceOpWithNewOp<LLVM::FDivOp>(op, dstType, one, sqrt);
     return success();
   }
 };
 
 /// Converts `spv.Load` and `spv.Store` to LLVM dialect.
-template <typename SPIRVop>
-class LoadStorePattern : public SPIRVToLLVMConversion<SPIRVop> {
+template <typename SPIRVOp>
+class LoadStorePattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
-  using SPIRVToLLVMConversion<SPIRVop>::SPIRVToLLVMConversion;
+  using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVop op, ArrayRef<Value> operands,
+  matchAndRewrite(SPIRVOp op, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-
     if (!op.memory_access().hasValue()) {
       return replaceWithLoadOrStore(
           op, rewriter, this->typeConverter, /*alignment=*/0,
           /*isVolatile=*/false, /*isNonTemporal=*/false);
     }
     auto memoryAccess = op.memory_access().getValue();
     switch (memoryAccess) {
     case spirv::MemoryAccess::Aligned:

 
 /// Converts `spv.Not` and `spv.LogicalNot` into LLVM dialect.
 template <typename SPIRVOp>
 class NotPattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVOp notOp, ArrayRef<Value> operands,
+  matchAndRewrite(SPIRVOp notOp, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-
     auto srcType = notOp.getType();
     auto dstType = this->typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
 
     Location loc = notOp.getLoc();
     IntegerAttr minusOne = minusOneIntegerAttribute(srcType, rewriter);
     auto mask = srcType.template isa<VectorType>()

 
 /// A template pattern that erases the given `SPIRVOp`.
 template <typename SPIRVOp>
 class ErasePattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVOp op, ArrayRef<Value> operands,
+  matchAndRewrite(SPIRVOp op, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.eraseOp(op);
     return success();
   }
 };
 
 class ReturnPattern : public SPIRVToLLVMConversion<spirv::ReturnOp> {
 public:
   using SPIRVToLLVMConversion<spirv::ReturnOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::ReturnOp returnOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::ReturnOp returnOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(returnOp, ArrayRef<Type>(),
                                                 ArrayRef<Value>());
     return success();
   }
 };
 
 class ReturnValuePattern : public SPIRVToLLVMConversion<spirv::ReturnValueOp> {
 public:
   using SPIRVToLLVMConversion<spirv::ReturnValueOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::ReturnValueOp returnValueOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::ReturnValueOp returnValueOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(returnValueOp, ArrayRef<Type>(),
-                                                operands);
+                                                adaptor.getOperands());
     return success();
   }
 };
 
 /// Converts `spv.mlir.loop` to LLVM dialect. All blocks within selection should
 /// be reachable for conversion to succeed. The structure of the loop in LLVM
 /// dialect will be the following:
 ///

 ///      |   <code after spv.mlir.loop>       |
 ///      +------------------------------------+
 ///
 class LoopPattern : public SPIRVToLLVMConversion<spirv::LoopOp> {
 public:
   using SPIRVToLLVMConversion<spirv::LoopOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::LoopOp loopOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::LoopOp loopOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // There is no support of loop control at the moment.
     if (loopOp.loop_control() != spirv::LoopControl::None)
       return failure();
 
     Location loc = loopOp.getLoc();
 
     // Split the current block after `spv.mlir.loop`. The remaining ops will be

 /// Converts `spv.mlir.selection` with `spv.BranchConditional` in its header
 /// block. All blocks within selection should be reachable for conversion to
 /// succeed.
 class SelectionPattern : public SPIRVToLLVMConversion<spirv::SelectionOp> {
 public:
   using SPIRVToLLVMConversion<spirv::SelectionOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::SelectionOp op, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::SelectionOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // There is no support for `Flatten` or `DontFlatten` selection control at
     // the moment. This are just compiler hints and can be performed during the
     // optimization passes.
     if (op.selection_control() != spirv::SelectionControl::None)
       return failure();
 
     // `spv.mlir.selection` should have at least two blocks: one selection

 /// `Shift` is zero or sign extended to match this specification. Cases when
 /// `Shift` bit width > `Base` bit width are considered to be illegal.
 template <typename SPIRVOp, typename LLVMOp>
 class ShiftPattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
 
     Type op1Type = operation.operand1().getType();
     Type op2Type = operation.operand2().getType();
 
     if (op1Type == op2Type) {
       rewriter.template replaceOpWithNewOp<LLVMOp>(operation, dstType,
-                                                   operands);
+                                                   adaptor.getOperands());
       return success();
     }
 
     Location loc = operation.getLoc();
     Value extended;
     if (isUnsignedIntegerOrVector(op2Type)) {
       extended = rewriter.template create<LLVM::ZExtOp>(loc, dstType,
                                                         operation.operand2());
     } else {
       extended = rewriter.template create<LLVM::SExtOp>(loc, dstType,
                                                         operation.operand2());
     }
     Value result = rewriter.template create<LLVMOp>(
         loc, dstType, operation.operand1(), extended);
     rewriter.replaceOp(operation, result);
     return success();
   }
 };
 
 class TanPattern : public SPIRVToLLVMConversion<spirv::GLSLTanOp> {
 public:
   using SPIRVToLLVMConversion<spirv::GLSLTanOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::GLSLTanOp tanOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::GLSLTanOp tanOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = typeConverter.convertType(tanOp.getType());
     if (!dstType)
       return failure();
 
     Location loc = tanOp.getLoc();
     Value sin = rewriter.create<LLVM::SinOp>(loc, dstType, tanOp.operand());
     Value cos = rewriter.create<LLVM::CosOp>(loc, dstType, tanOp.operand());
     rewriter.replaceOpWithNewOp<LLVM::FDivOp>(tanOp, dstType, sin, cos);
     return success();
   }
 };
 
 /// Convert `spv.Tanh` to
 ///
 ///   exp(2x) - 1
 ///   -----------
 ///   exp(2x) + 1
 ///
 class TanhPattern : public SPIRVToLLVMConversion<spirv::GLSLTanhOp> {
 public:
   using SPIRVToLLVMConversion<spirv::GLSLTanhOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::GLSLTanhOp tanhOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::GLSLTanhOp tanhOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = tanhOp.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
 
     Location loc = tanhOp.getLoc();
     Value two = createFPConstant(loc, srcType, dstType, rewriter, 2.0);
public:
   }
 };
 
 class VariablePattern : public SPIRVToLLVMConversion<spirv::VariableOp> {
 public:
   using SPIRVToLLVMConversion<spirv::VariableOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::VariableOp varOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::VariableOp varOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = varOp.getType();
     // Initialization is supported for scalars and vectors only.
     auto pointerTo = srcType.cast<spirv::PointerType>().getPointeeType();
     auto init = varOp.initializer();
     if (init && !pointerTo.isIntOrFloat() && !pointerTo.isa<VectorType>())
       return failure();
 

 // FuncOp conversion
 //===----------------------------------------------------------------------===//
 
 class FuncConversionPattern : public SPIRVToLLVMConversion<spirv::FuncOp> {
 public:
   using SPIRVToLLVMConversion<spirv::FuncOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::FuncOp funcOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::FuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     // Convert function signature. At the moment LLVMType converter is enough
     // for currently supported types.
     auto funcType = funcOp.getType();
     TypeConverter::SignatureConversion signatureConverter(
         funcType.getNumInputs());
     auto llvmType = typeConverter.convertFunctionSignature(

 // ModuleOp conversion
 //===----------------------------------------------------------------------===//
 
 class ModuleConversionPattern : public SPIRVToLLVMConversion<spirv::ModuleOp> {
 public:
   using SPIRVToLLVMConversion<spirv::ModuleOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::ModuleOp spvModuleOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::ModuleOp spvModuleOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto newModuleOp =
         rewriter.create<ModuleOp>(spvModuleOp.getLoc(), spvModuleOp.getName());
     rewriter.inlineRegionBefore(spvModuleOp.getRegion(), newModuleOp.getBody());
 
     // Remove the terminator block that was automatically added by builder
     rewriter.eraseBlock(&newModuleOp.getBodyRegion().back());

mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp

 
 /// Conversion patterns.
 namespace {
 class AnyOpConversion : public OpConversionPattern<AnyOp> {
 public:
   using OpConversionPattern<AnyOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(AnyOp op, ArrayRef<Value> operands,
+  matchAndRewrite(AnyOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult
-AnyOpConversion::matchAndRewrite(AnyOp op, ArrayRef<Value> operands,
+AnyOpConversion::matchAndRewrite(AnyOp op, OpAdaptor adaptor,
                                  ConversionPatternRewriter &rewriter) const {
-  AnyOp::Adaptor transformed(operands);
-
   // Replace `any` with its first operand.
   // Any operand would be a valid substitution.
-  rewriter.replaceOp(op, {transformed.inputs().front()});
+  rewriter.replaceOp(op, {adaptor.inputs().front()});
   return success();
 }
 
 namespace {
 template <typename SrcOpTy, typename DstOpTy>
 class BinaryOpConversion : public OpConversionPattern<SrcOpTy> {
 public:
   using OpConversionPattern<SrcOpTy>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(SrcOpTy op, ArrayRef<Value> operands,
+  matchAndRewrite(SrcOpTy op, typename SrcOpTy::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    typename SrcOpTy::Adaptor transformed(operands);
-
     // For now, only error-free types are supported by this lowering.
     if (op.getType().template isa<SizeType>())
       return failure();
 
-    rewriter.replaceOpWithNewOp<DstOpTy>(op, transformed.lhs(),
-                                         transformed.rhs());
+    rewriter.replaceOpWithNewOp<DstOpTy>(op, adaptor.lhs(), adaptor.rhs());
     return success();
   }
 };
 } // namespace
 
 namespace {
 struct BroadcastOpConverter : public OpConversionPattern<BroadcastOp> {
   using OpConversionPattern<BroadcastOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(BroadcastOp op, ArrayRef<Value> operands,
+  matchAndRewrite(BroadcastOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 // Get the resulting extent in a given dimension. This is computed with any
 // number of extent tensors and shifted offsets into them.
 Value getBroadcastedDim(ImplicitLocOpBuilder lb, ValueRange extentTensors,
                         ValueRange rankDiffs, Value outputDimension) {
   Value one = lb.create<ConstantIndexOp>(1);
broadcastedDim =
               })
             .getResult(0);
   }
   return broadcastedDim;
 }
 } // namespace
 
 LogicalResult BroadcastOpConverter::matchAndRewrite(
-    BroadcastOp op, ArrayRef<Value> operands,
+    BroadcastOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   // For now, this lowering is only defined on `tensor<?xindex>` operands, not
   // on shapes.
   if (op.getType().isa<ShapeType>())
     return failure();
 
   auto loc = op.getLoc();
   ImplicitLocOpBuilder lb(loc, rewriter);
-  BroadcastOp::Adaptor transformed(operands);
 
   Value zero = lb.create<ConstantIndexOp>(0);
   Type indexTy = lb.getIndexType();
 
   // Save all the ranks for bounds checking. Because this is a tensor
   // representing the shape extents, the rank is the extent of the only
   // dimension in the tensor.
   SmallVector<Value> ranks, rankDiffs;
-  llvm::append_range(ranks, llvm::map_range(transformed.shapes(), [&](Value v) {
+  llvm::append_range(ranks, llvm::map_range(adaptor.shapes(), [&](Value v) {
                        return lb.create<tensor::DimOp>(v, zero);
                      }));
 
   // Find the maximum rank
   Value maxRank = ranks.front();
   for (Value v : llvm::drop_begin(ranks, 1)) {
     Value rankIsGreater = lb.create<CmpIOp>(CmpIPredicate::ugt, v, maxRank);
     maxRank = lb.create<SelectOp>(rankIsGreater, v, maxRank);
   }
 
   // Calculate the difference of ranks and the maximum rank for later offsets.
   llvm::append_range(rankDiffs, llvm::map_range(ranks, [&](Value v) {
                        return lb.create<SubIOp>(indexTy, maxRank, v);
                      }));
 
   Value replacement = lb.create<tensor::GenerateOp>(
       getExtentTensorType(lb.getContext()), ValueRange{maxRank},
       [&](OpBuilder &b, Location loc, ValueRange args) {
-        Value broadcastedDim =
-            getBroadcastedDim(ImplicitLocOpBuilder(loc, b),
-                              transformed.shapes(), rankDiffs, args[0]);
+        Value broadcastedDim = getBroadcastedDim(
+            ImplicitLocOpBuilder(loc, b), adaptor.shapes(), rankDiffs, args[0]);
 
         b.create<tensor::YieldOp>(loc, broadcastedDim);
       });
   if (replacement.getType() != op.getType())
     replacement = lb.create<tensor::CastOp>(op.getType(), replacement);
   rewriter.replaceOp(op, replacement);
   return success();
 }
 
 namespace {
 class ConstShapeOpConverter : public OpConversionPattern<ConstShapeOp> {
 public:
   using OpConversionPattern<ConstShapeOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ConstShapeOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ConstShapeOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult ConstShapeOpConverter::matchAndRewrite(
-    ConstShapeOp op, ArrayRef<Value> operands,
+    ConstShapeOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
 
   // For now, this lowering supports only extent tensors, not `shape.shape`
   // types.
   if (op.getType().isa<ShapeType>())
     return failure();
 
   auto loc = op.getLoc();

 }
 
 namespace {
 class ConstSizeOpConversion : public OpConversionPattern<ConstSizeOp> {
 public:
   using OpConversionPattern<ConstSizeOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ConstSizeOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ConstSizeOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult ConstSizeOpConversion::matchAndRewrite(
-    ConstSizeOp op, ArrayRef<Value> operands,
+    ConstSizeOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   rewriter.replaceOpWithNewOp<ConstantIndexOp>(op, op.value().getSExtValue());
   return success();
 }
 
 namespace {
 struct IsBroadcastableOpConverter
     : public OpConversionPattern<IsBroadcastableOp> {
   using OpConversionPattern<IsBroadcastableOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(IsBroadcastableOp op, ArrayRef<Value> operands,
+  matchAndRewrite(IsBroadcastableOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult IsBroadcastableOpConverter::matchAndRewrite(
-    IsBroadcastableOp op, ArrayRef<Value> operands,
+    IsBroadcastableOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   // For now, this lowering is only defined on `tensor<?xindex>` operands, not
   // on shapes.
-  IsBroadcastableOp::Adaptor transformed(operands);
   if (!llvm::all_of(op.shapes(),
                     [](Value v) { return !v.getType().isa<ShapeType>(); }))
     return failure();
 
   auto loc = op.getLoc();
   ImplicitLocOpBuilder lb(loc, rewriter);
   Value zero = lb.create<ConstantIndexOp>(0);
   Value one = lb.create<ConstantIndexOp>(1);
   Type indexTy = lb.getIndexType();
 
   // Save all the ranks for bounds checking. Because this is a tensor
   // representing the shape extents, the rank is the extent of the only
   // dimension in the tensor.
   SmallVector<Value> ranks, rankDiffs;
-  llvm::append_range(ranks, llvm::map_range(transformed.shapes(), [&](Value v) {
+  llvm::append_range(ranks, llvm::map_range(adaptor.shapes(), [&](Value v) {
                        return lb.create<tensor::DimOp>(v, zero);
                      }));
 
   // Find the maximum rank
   Value maxRank = ranks.front();
   for (Value v : llvm::drop_begin(ranks, 1)) {
     Value rankIsGreater = lb.create<CmpIOp>(CmpIPredicate::ugt, v, maxRank);
     maxRank = lb.create<SelectOp>(rankIsGreater, v, maxRank);
LogicalResult IsBroadcastableOpConverter::matchAndRewrite(
 
   auto reduceResult = lb.create<ForOp>(
       loc, zero, maxRank, one, ValueRange{trueVal},
       [&](OpBuilder &b, Location loc, Value iv, ValueRange iterArgs) {
         // Find a non-1 dim, if it exists. Note that the first part of this
         // could reuse the Broadcast lowering entirely, but we redo the work
         // here to make optimizations easier between the two loops.
         Value broadcastedDim = getBroadcastedDim(
-            ImplicitLocOpBuilder(loc, b), transformed.shapes(), rankDiffs, iv);
+            ImplicitLocOpBuilder(loc, b), adaptor.shapes(), rankDiffs, iv);
 
         Value broadcastable = iterArgs[0];
-        for (auto tup : llvm::zip(transformed.shapes(), rankDiffs)) {
+        for (auto tup : llvm::zip(adaptor.shapes(), rankDiffs)) {
           Value shape, rankDiff;
           std::tie(shape, rankDiff) = tup;
           Value outOfBounds =
               b.create<CmpIOp>(loc, CmpIPredicate::ult, iv, rankDiff);
           broadcastable =
               b.create<IfOp>(
                    loc, TypeRange{i1Ty}, outOfBounds,
                    [&](OpBuilder &b, Location loc) {
LogicalResult IsBroadcastableOpConverter::matchAndRewrite(
   return success();
 }
 
 namespace {
 class GetExtentOpConverter : public OpConversionPattern<GetExtentOp> {
   using OpConversionPattern<GetExtentOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(GetExtentOp op, ArrayRef<Value> operands,
+  matchAndRewrite(GetExtentOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult GetExtentOpConverter::matchAndRewrite(
-    GetExtentOp op, ArrayRef<Value> operands,
+    GetExtentOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
-  GetExtentOp::Adaptor transformed(operands);
-
   // For now, only error-free types are supported by this lowering.
   if (op.getType().isa<SizeType>())
     return failure();
 
   // Derive shape extent directly from shape origin if possible. This
   // circumvents the necessity to materialize the shape in memory.
   if (auto shapeOfOp = op.shape().getDefiningOp<ShapeOfOp>()) {
     if (shapeOfOp.arg().getType().isa<ShapedType>()) {
       rewriter.replaceOpWithNewOp<tensor::DimOp>(op, shapeOfOp.arg(),
-                                                 transformed.dim());
+                                                 adaptor.dim());
       return success();
     }
   }
 
-  rewriter.replaceOpWithNewOp<tensor::ExtractOp>(op, rewriter.getIndexType(),
-                                                 transformed.shape(),
-                                                 ValueRange{transformed.dim()});
+  rewriter.replaceOpWithNewOp<tensor::ExtractOp>(
+      op, rewriter.getIndexType(), adaptor.shape(), ValueRange{adaptor.dim()});
   return success();
 }
 
 namespace {
 class RankOpConverter : public OpConversionPattern<shape::RankOp> {
 public:
   using OpConversionPattern<shape::RankOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(shape::RankOp op, ArrayRef<Value> operands,
+  matchAndRewrite(shape::RankOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult
-RankOpConverter::matchAndRewrite(shape::RankOp op, ArrayRef<Value> operands,
+RankOpConverter::matchAndRewrite(shape::RankOp op, OpAdaptor adaptor,
                                  ConversionPatternRewriter &rewriter) const {
   // For now, this lowering supports only error-free types.
   if (op.getType().isa<SizeType>())
     return failure();
 
-  shape::RankOp::Adaptor transformed(operands);
-  rewriter.replaceOpWithNewOp<tensor::DimOp>(op, transformed.shape(), 0);
+  rewriter.replaceOpWithNewOp<tensor::DimOp>(op, adaptor.shape(), 0);
   return success();
 }
 
 namespace {
 /// Converts `shape.reduce` to `scf.for`.
 struct ReduceOpConverter : public OpConversionPattern<shape::ReduceOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(shape::ReduceOp op, ArrayRef<Value> operands,
+  matchAndRewrite(shape::ReduceOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final;
 };
 } // namespace
 
 LogicalResult
-ReduceOpConverter::matchAndRewrite(shape::ReduceOp op, ArrayRef<Value> operands,
+ReduceOpConverter::matchAndRewrite(shape::ReduceOp op, OpAdaptor adaptor,
                                    ConversionPatternRewriter &rewriter) const {
   // For now, this lowering is only defined on `tensor<?xindex>` operands.
   if (op.shape().getType().isa<ShapeType>())
     return failure();
 
   auto loc = op.getLoc();
-  shape::ReduceOp::Adaptor transformed(operands);
 
   Value zero = rewriter.create<ConstantIndexOp>(loc, 0);
   Value one = rewriter.create<ConstantIndexOp>(loc, 1);
   Type indexTy = rewriter.getIndexType();
   Value rank =
-      rewriter.create<tensor::DimOp>(loc, indexTy, transformed.shape(), zero);
+      rewriter.create<tensor::DimOp>(loc, indexTy, adaptor.shape(), zero);
 
   auto loop = rewriter.create<scf::ForOp>(
       loc, zero, rank, one, op.initVals(),
       [&](OpBuilder &b, Location loc, Value iv, ValueRange args) {
-        Value extent =
-            b.create<tensor::ExtractOp>(loc, transformed.shape(), iv);
+        Value extent = b.create<tensor::ExtractOp>(loc, adaptor.shape(), iv);
 
         SmallVector<Value, 2> mappedValues{iv, extent};
         mappedValues.append(args.begin(), args.end());
 
         BlockAndValueMapping mapping;
         Block *reduceBody = op.getBody();
         mapping.map(reduceBody->getArguments(), mappedValues);
         for (auto &nested : reduceBody->without_terminator())

 ///   %false = constant false
 ///   scf.yield %false : i1
 /// }
 ///
 struct ShapeEqOpConverter : public OpConversionPattern<ShapeEqOp> {
   using OpConversionPattern<ShapeEqOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ShapeEqOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ShapeEqOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult
-ShapeEqOpConverter::matchAndRewrite(ShapeEqOp op, ArrayRef<Value> operands,
+ShapeEqOpConverter::matchAndRewrite(ShapeEqOp op, OpAdaptor adaptor,
                                     ConversionPatternRewriter &rewriter) const {
   if (!llvm::all_of(op.shapes(),
                     [](Value v) { return !v.getType().isa<ShapeType>(); }))
     return failure();
 
   Type i1Ty = rewriter.getI1Type();
   if (op.shapes().size() <= 1) {
     rewriter.replaceOpWithNewOp<ConstantOp>(op, i1Ty,
                                             rewriter.getBoolAttr(true));
     return success();
   }
 
-  ShapeEqOp::Adaptor transformed(operands);
   auto loc = op.getLoc();
   Type indexTy = rewriter.getIndexType();
   Value zero = rewriter.create<ConstantIndexOp>(loc, 0);
-  Value firstShape = transformed.shapes().front();
+  Value firstShape = adaptor.shapes().front();
   Value firstRank =
       rewriter.create<tensor::DimOp>(loc, indexTy, firstShape, zero);
   Value result = nullptr;
   // Generate a linear sequence of compares, all with firstShape as lhs.
-  for (Value shape : transformed.shapes().drop_front(1)) {
+  for (Value shape : adaptor.shapes().drop_front(1)) {
     Value rank = rewriter.create<tensor::DimOp>(loc, indexTy, shape, zero);
     Value eqRank =
         rewriter.create<CmpIOp>(loc, CmpIPredicate::eq, firstRank, rank);
     auto same = rewriter.create<IfOp>(
         loc, i1Ty, eqRank,
         [&](OpBuilder &b, Location loc) {
           Value one = b.create<ConstantIndexOp>(loc, 1);
           Value init = b.create<ConstantOp>(loc, i1Ty, b.getBoolAttr(true));

 }
 
 namespace {
 class ShapeOfOpConversion : public OpConversionPattern<ShapeOfOp> {
 public:
   using OpConversionPattern<ShapeOfOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ShapeOfOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ShapeOfOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult ShapeOfOpConversion::matchAndRewrite(
-    ShapeOfOp op, ArrayRef<Value> operands,
+    ShapeOfOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
 
   // For now, only error-free types are supported by this lowering.
   if (op.getType().isa<ShapeType>())
     return failure();
 
   // For ranked tensor arguments, lower to `tensor.from_elements`.
   auto loc = op.getLoc();
-  ShapeOfOp::Adaptor transformed(operands);
-  Value tensor = transformed.arg();
+  Value tensor = adaptor.arg();
   Type tensorTy = tensor.getType();
   if (tensorTy.isa<RankedTensorType>()) {
 
     // Build values for individual extents.
     SmallVector<Value, 8> extentValues;
     RankedTensorType rankedTensorTy = tensorTy.cast<RankedTensorType>();
     int64_t rank = rankedTensorTy.getRank();
     for (int64_t i = 0; i < rank; i++) {

 }
 
 namespace {
 class SplitAtOpConversion : public OpConversionPattern<SplitAtOp> {
 public:
   using OpConversionPattern<SplitAtOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(SplitAtOp op, ArrayRef<Value> operands,
+  matchAndRewrite(SplitAtOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult SplitAtOpConversion::matchAndRewrite(
-    SplitAtOp op, ArrayRef<Value> operands,
+    SplitAtOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   // Error conditions are not implemented, only lower if all operands and
   // results are extent tensors.
   if (llvm::any_of(ValueRange{op.operand(), op.head(), op.tail()},
                    [](Value v) { return v.getType().isa<ShapeType>(); }))
     return failure();
 
-  SplitAtOp::Adaptor transformed(op);
   ImplicitLocOpBuilder b(op.getLoc(), rewriter);
   Value zero = b.create<ConstantIndexOp>(0);
-  Value rank = b.create<tensor::DimOp>(transformed.operand(), zero);
+  Value rank = b.create<tensor::DimOp>(adaptor.operand(), zero);
 
   // index < 0 ? index + rank : index
-  Value originalIndex = transformed.index();
+  Value originalIndex = adaptor.index();
   Value add = b.create<AddIOp>(originalIndex, rank);
   Value indexIsNegative =
       b.create<CmpIOp>(CmpIPredicate::slt, originalIndex, zero);
   Value index = b.create<SelectOp>(indexIsNegative, add, originalIndex);
 
   Value one = b.create<ConstantIndexOp>(1);
   Value head =
-      b.create<tensor::ExtractSliceOp>(transformed.operand(), zero, index, one);
+      b.create<tensor::ExtractSliceOp>(adaptor.operand(), zero, index, one);
   Value tailSize = b.create<SubIOp>(rank, index);
-  Value tail = b.create<tensor::ExtractSliceOp>(transformed.operand(), index,
-                                                tailSize, one);
+  Value tail =
+      b.create<tensor::ExtractSliceOp>(adaptor.operand(), index, tailSize, one);
   rewriter.replaceOp(op, {head, tail});
   return success();
 }
 
 namespace {
 class ToExtentTensorOpConversion
     : public OpConversionPattern<ToExtentTensorOp> {
 public:
   using OpConversionPattern<ToExtentTensorOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ToExtentTensorOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ToExtentTensorOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    ToExtentTensorOpAdaptor adaptor(operands);
-
     if (!adaptor.input().getType().isa<RankedTensorType>())
       return rewriter.notifyMatchFailure(op, "input needs to be a tensor");
 
     rewriter.replaceOpWithNewOp<tensor::CastOp>(op, op.getType(),
                                                 adaptor.input());
     return success();
   }
 };

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 /// MemRef descriptors (LLVM struct data types) containing all the MemRef type
 /// information.
 static constexpr StringRef kEmitIfaceAttrName = "llvm.emit_c_interface";
 struct FuncOpConversion : public FuncOpConversionBase {
   FuncOpConversion(LLVMTypeConverter &converter)
       : FuncOpConversionBase(converter) {}
 
   LogicalResult
-  matchAndRewrite(FuncOp funcOp, ArrayRef<Value> operands,
+  matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto newFuncOp = convertFuncOpToLLVMFuncOp(funcOp, rewriter);
     if (!newFuncOp)
       return failure();
 
     if (getTypeConverter()->getOptions().emitCWrappers ||
         funcOp->getAttrOfType<UnitAttr>(kEmitIfaceAttrName)) {
       if (newFuncOp.isExternal())

 };
 
 /// FuncOp legalization pattern that converts MemRef arguments to bare pointers
 /// to the MemRef element type. This will impact the calling convention and ABI.
 struct BarePtrFuncOpConversion : public FuncOpConversionBase {
   using FuncOpConversionBase::FuncOpConversionBase;
 
   LogicalResult
-  matchAndRewrite(FuncOp funcOp, ArrayRef<Value> operands,
+  matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     // TODO: bare ptr conversion could be handled by argument materialization
     // and most of the code below would go away. But to do this, we would need a
     // way to distinguish between FuncOp and other regions in the
     // addArgumentMaterialization hook.
 
     // Store the type of memref-typed arguments before the conversion so that we

 /// Lower `std.assert`. The default lowering calls the `abort` function if the
 /// assertion is violated and has no effect otherwise. The failure message is
 /// ignored by the default lowering but should be propagated by any custom
 /// lowering.
 struct AssertOpLowering : public ConvertOpToLLVMPattern<AssertOp> {
   using ConvertOpToLLVMPattern<AssertOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(AssertOp op, ArrayRef<Value> operands,
+  matchAndRewrite(AssertOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = op.getLoc();
-    AssertOp::Adaptor transformed(operands);
 
     // Insert the `abort` declaration if necessary.
     auto module = op->getParentOfType<ModuleOp>();
     auto abortFunc = module.lookupSymbol<LLVM::LLVMFuncOp>("abort");
     if (!abortFunc) {
       OpBuilder::InsertionGuard guard(rewriter);
       rewriter.setInsertionPointToStart(module.getBody());
       auto abortFuncTy = LLVM::LLVMFunctionType::get(getVoidType(), {});
matchAndRewrite(AssertOp op, OpAdaptor adaptor,
     // Generate IR to call `abort`.
     Block *failureBlock = rewriter.createBlock(opBlock->getParent());
     rewriter.create<LLVM::CallOp>(loc, abortFunc, llvm::None);
     rewriter.create<LLVM::UnreachableOp>(loc);
 
     // Generate assertion test.
     rewriter.setInsertionPointToEnd(opBlock);
     rewriter.replaceOpWithNewOp<LLVM::CondBrOp>(
-        op, transformed.arg(), continuationBlock, failureBlock);
+        op, adaptor.arg(), continuationBlock, failureBlock);
 
     return success();
   }
 };
 
 struct ConstantOpLowering : public ConvertOpToLLVMPattern<ConstantOp> {
   using ConvertOpToLLVMPattern<ConstantOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(ConstantOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ConstantOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // If constant refers to a function, convert it to "addressof".
     if (auto symbolRef = op.getValue().dyn_cast<FlatSymbolRefAttr>()) {
       auto type = typeConverter->convertType(op.getResult().getType());
       if (!type || !LLVM::isCompatibleType(type))
         return rewriter.notifyMatchFailure(op, "failed to convert result type");
 
       auto newOp = rewriter.create<LLVM::AddressOfOp>(op.getLoc(), type,
                                                       symbolRef.getValue());
       for (const NamedAttribute &attr : op->getAttrs()) {
         if (attr.first.strref() == "value")
           continue;
         newOp->setAttr(attr.first, attr.second);
       }
       rewriter.replaceOp(op, newOp->getResults());
       return success();
     }
 
     // Calling into other scopes (non-flat reference) is not supported in LLVM.
     if (op.getValue().isa<SymbolRefAttr>())
       return rewriter.notifyMatchFailure(
           op, "referring to a symbol outside of the current module");
 
     return LLVM::detail::oneToOneRewrite(
-        op, LLVM::ConstantOp::getOperationName(), operands, *getTypeConverter(),
-        rewriter);
+        op, LLVM::ConstantOp::getOperationName(), adaptor.getOperands(),
+        *getTypeConverter(), rewriter);
   }
 };
 
 // A CallOp automatically promotes MemRefType to a sequence of alloca/store and
 // passes the pointer to the MemRef across function boundaries.
 template <typename CallOpType>
 struct CallOpInterfaceLowering : public ConvertOpToLLVMPattern<CallOpType> {
   using ConvertOpToLLVMPattern<CallOpType>::ConvertOpToLLVMPattern;
   using Super = CallOpInterfaceLowering<CallOpType>;
   using Base = ConvertOpToLLVMPattern<CallOpType>;
 
   LogicalResult
-  matchAndRewrite(CallOpType callOp, ArrayRef<Value> operands,
+  matchAndRewrite(CallOpType callOp, typename CallOpType::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    typename CallOpType::Adaptor transformed(operands);
-
     // Pack the result types into a struct.
     Type packedResult = nullptr;
     unsigned numResults = callOp.getNumResults();
     auto resultTypes = llvm::to_vector<4>(callOp.getResultTypes());
 
     if (numResults != 0) {
       if (!(packedResult =
                 this->getTypeConverter()->packFunctionResults(resultTypes)))
         return failure();
     }
 
     auto promoted = this->getTypeConverter()->promoteOperands(
-        callOp.getLoc(), /*opOperands=*/callOp->getOperands(), operands,
-        rewriter);
+        callOp.getLoc(), /*opOperands=*/callOp->getOperands(),
+        adaptor.getOperands(), rewriter);
     auto newOp = rewriter.create<LLVM::CallOp>(
         callOp.getLoc(), packedResult ? TypeRange(packedResult) : TypeRange(),
         promoted, callOp->getAttrs());
 
     SmallVector<Value, 4> results;
     if (numResults < 2) {
       // If < 2 results, packing did not do anything and we can just return.
       results.append(newOp.result_begin(), newOp.result_end());

 };
 
 struct UnrealizedConversionCastOpLowering
     : public ConvertOpToLLVMPattern<UnrealizedConversionCastOp> {
   using ConvertOpToLLVMPattern<
       UnrealizedConversionCastOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(UnrealizedConversionCastOp op, ArrayRef<Value> operands,
+  matchAndRewrite(UnrealizedConversionCastOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    UnrealizedConversionCastOp::Adaptor transformed(operands);
     SmallVector<Type> convertedTypes;
     if (succeeded(typeConverter->convertTypes(op.outputs().getTypes(),
                                               convertedTypes)) &&
-        convertedTypes == transformed.inputs().getTypes()) {
-      rewriter.replaceOp(op, transformed.inputs());
+        convertedTypes == adaptor.inputs().getTypes()) {
+      rewriter.replaceOp(op, adaptor.inputs());
       return success();
     }
 
     convertedTypes.clear();
-    if (succeeded(typeConverter->convertTypes(transformed.inputs().getTypes(),
+    if (succeeded(typeConverter->convertTypes(adaptor.inputs().getTypes(),
                                               convertedTypes)) &&
         convertedTypes == op.outputs().getType()) {
-      rewriter.replaceOp(op, transformed.inputs());
+      rewriter.replaceOp(op, adaptor.inputs());
       return success();
     }
     return failure();
   }
 };
 
 struct RankOpLowering : public ConvertOpToLLVMPattern<RankOp> {
   using ConvertOpToLLVMPattern<RankOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(RankOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RankOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
     Type operandType = op.memrefOrTensor().getType();
     if (auto unrankedMemRefType = operandType.dyn_cast<UnrankedMemRefType>()) {
-      UnrankedMemRefDescriptor desc(RankOp::Adaptor(operands).memrefOrTensor());
+      UnrankedMemRefDescriptor desc(adaptor.memrefOrTensor());
       rewriter.replaceOp(op, {desc.rank(rewriter, loc)});
       return success();
     }
     if (auto rankedMemRefType = operandType.dyn_cast<MemRefType>()) {
       rewriter.replaceOp(
           op, {createIndexConstant(rewriter, loc, rankedMemRefType.getRank())});
       return success();
     }

 // The lowering of index_cast becomes an integer conversion since index becomes
 // an integer.  If the bit width of the source and target integer types is the
 // same, just erase the cast.  If the target type is wider, sign-extend the
 // value, otherwise truncate it.
 struct IndexCastOpLowering : public ConvertOpToLLVMPattern<IndexCastOp> {
   using ConvertOpToLLVMPattern<IndexCastOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(IndexCastOp indexCastOp, ArrayRef<Value> operands,
+  matchAndRewrite(IndexCastOp indexCastOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    IndexCastOpAdaptor transformed(operands);
-
     auto targetType =
         typeConverter->convertType(indexCastOp.getResult().getType());
     auto targetElementType =
         typeConverter
             ->convertType(getElementTypeOrSelf(indexCastOp.getResult()))
             .cast<IntegerType>();
     auto sourceElementType =
-        getElementTypeOrSelf(transformed.in()).cast<IntegerType>();
+        getElementTypeOrSelf(adaptor.in()).cast<IntegerType>();
     unsigned targetBits = targetElementType.getWidth();
     unsigned sourceBits = sourceElementType.getWidth();
 
     if (targetBits == sourceBits)
-      rewriter.replaceOp(indexCastOp, transformed.in());
+      rewriter.replaceOp(indexCastOp, adaptor.in());
     else if (targetBits < sourceBits)
       rewriter.replaceOpWithNewOp<LLVM::TruncOp>(indexCastOp, targetType,
-                                                 transformed.in());
+                                                 adaptor.in());
     else
       rewriter.replaceOpWithNewOp<LLVM::SExtOp>(indexCastOp, targetType,
-                                                transformed.in());
+                                                adaptor.in());
     return success();
   }
 };
 
 // Convert std.cmp predicate into the LLVM dialect CmpPredicate.  The two
 // enums share the numerical values so just cast.
 template <typename LLVMPredType, typename StdPredType>
 static LLVMPredType convertCmpPredicate(StdPredType pred) {
   return static_cast<LLVMPredType>(pred);
 }
 
 struct CmpIOpLowering : public ConvertOpToLLVMPattern<CmpIOp> {
   using ConvertOpToLLVMPattern<CmpIOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(CmpIOp cmpiOp, ArrayRef<Value> operands,
+  matchAndRewrite(CmpIOp cmpiOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    CmpIOpAdaptor transformed(operands);
-    auto operandType = transformed.lhs().getType();
+    auto operandType = adaptor.lhs().getType();
     auto resultType = cmpiOp.getResult().getType();
 
     // Handle the scalar and 1D vector cases.
     if (!operandType.isa<LLVM::LLVMArrayType>()) {
       rewriter.replaceOpWithNewOp<LLVM::ICmpOp>(
           cmpiOp, typeConverter->convertType(resultType),
           convertCmpPredicate<LLVM::ICmpPredicate>(cmpiOp.getPredicate()),
-          transformed.lhs(), transformed.rhs());
+          adaptor.lhs(), adaptor.rhs());
       return success();
     }
 
     auto vectorType = resultType.dyn_cast<VectorType>();
     if (!vectorType)
       return rewriter.notifyMatchFailure(cmpiOp, "expected vector result type");
 
     return LLVM::detail::handleMultidimensionalVectors(
-        cmpiOp.getOperation(), operands, *getTypeConverter(),
+        cmpiOp.getOperation(), adaptor.getOperands(), *getTypeConverter(),
         [&](Type llvm1DVectorTy, ValueRange operands) {
-          CmpIOpAdaptor transformed(operands);
+          CmpIOpAdaptor adaptor(operands);
           return rewriter.create<LLVM::ICmpOp>(
               cmpiOp.getLoc(), llvm1DVectorTy,
               convertCmpPredicate<LLVM::ICmpPredicate>(cmpiOp.getPredicate()),
-              transformed.lhs(), transformed.rhs());
+              adaptor.lhs(), adaptor.rhs());
         },
         rewriter);
 
     return success();
   }
 };
 
 struct CmpFOpLowering : public ConvertOpToLLVMPattern<CmpFOp> {
   using ConvertOpToLLVMPattern<CmpFOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(CmpFOp cmpfOp, ArrayRef<Value> operands,
+  matchAndRewrite(CmpFOp cmpfOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    CmpFOpAdaptor transformed(operands);
-    auto operandType = transformed.lhs().getType();
+    auto operandType = adaptor.lhs().getType();
     auto resultType = cmpfOp.getResult().getType();
 
     // Handle the scalar and 1D vector cases.
     if (!operandType.isa<LLVM::LLVMArrayType>()) {
       rewriter.replaceOpWithNewOp<LLVM::FCmpOp>(
           cmpfOp, typeConverter->convertType(resultType),
           convertCmpPredicate<LLVM::FCmpPredicate>(cmpfOp.getPredicate()),
-          transformed.lhs(), transformed.rhs());
+          adaptor.lhs(), adaptor.rhs());
       return success();
     }
 
     auto vectorType = resultType.dyn_cast<VectorType>();
     if (!vectorType)
       return rewriter.notifyMatchFailure(cmpfOp, "expected vector result type");
 
     return LLVM::detail::handleMultidimensionalVectors(
-        cmpfOp.getOperation(), operands, *getTypeConverter(),
+        cmpfOp.getOperation(), adaptor.getOperands(), *getTypeConverter(),
         [&](Type llvm1DVectorTy, ValueRange operands) {
-          CmpFOpAdaptor transformed(operands);
+          CmpFOpAdaptor adaptor(operands);
           return rewriter.create<LLVM::FCmpOp>(
               cmpfOp.getLoc(), llvm1DVectorTy,
               convertCmpPredicate<LLVM::FCmpPredicate>(cmpfOp.getPredicate()),
-              transformed.lhs(), transformed.rhs());
+              adaptor.lhs(), adaptor.rhs());
         },
         rewriter);
   }
 };
 
 // Base class for LLVM IR lowering terminator operations with successors.
 template <typename SourceOp, typename TargetOp>
 struct OneToOneLLVMTerminatorLowering
     : public ConvertOpToLLVMPattern<SourceOp> {
   using ConvertOpToLLVMPattern<SourceOp>::ConvertOpToLLVMPattern;
   using Super = OneToOneLLVMTerminatorLowering<SourceOp, TargetOp>;
 
   LogicalResult
-  matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
+  matchAndRewrite(SourceOp op, typename SourceOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<TargetOp>(op, operands, op->getSuccessors(),
-                                          op->getAttrs());
+    rewriter.replaceOpWithNewOp<TargetOp>(op, adaptor.getOperands(),
+                                          op->getSuccessors(), op->getAttrs());
     return success();
   }
 };
 
 // Special lowering pattern for `ReturnOps`.  Unlike all other operations,
 // `ReturnOp` interacts with the function signature and must have as many
 // operands as the function has return values.  Because in LLVM IR, functions
 // can only return 0 or 1 value, we pack multiple values into a structure type.
 // Emit `UndefOp` followed by `InsertValueOp`s to create such structure if
 // necessary before returning it
 struct ReturnOpLowering : public ConvertOpToLLVMPattern<ReturnOp> {
   using ConvertOpToLLVMPattern<ReturnOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(ReturnOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ReturnOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
     unsigned numArguments = op.getNumOperands();
     SmallVector<Value, 4> updatedOperands;
 
     if (getTypeConverter()->getOptions().useBarePtrCallConv) {
       // For the bare-ptr calling convention, extract the aligned pointer to
       // be returned from the memref descriptor.
-      for (auto it : llvm::zip(op->getOperands(), operands)) {
+      for (auto it : llvm::zip(op->getOperands(), adaptor.getOperands())) {
         Type oldTy = std::get<0>(it).getType();
         Value newOperand = std::get<1>(it);
         if (oldTy.isa<MemRefType>()) {
           MemRefDescriptor memrefDesc(newOperand);
           newOperand = memrefDesc.alignedPtr(rewriter, loc);
         } else if (oldTy.isa<UnrankedMemRefType>()) {
           // Unranked memref is not supported in the bare pointer calling
           // convention.
           return failure();
         }
         updatedOperands.push_back(newOperand);
       }
     } else {
-      updatedOperands = llvm::to_vector<4>(operands);
+      updatedOperands = llvm::to_vector<4>(adaptor.getOperands());
       (void)copyUnrankedDescriptors(rewriter, loc, op.getOperands().getTypes(),
                                     updatedOperands,
                                     /*toDynamic=*/true);
     }
 
     // If ReturnOp has 0 or 1 operand, create it and return immediately.
     if (numArguments == 0) {
       rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, TypeRange(), ValueRange(),

 };
 
 // The Splat operation is lowered to an insertelement + a shufflevector
 // operation. Splat to only 1-d vector result types are lowered.
 struct SplatOpLowering : public ConvertOpToLLVMPattern<SplatOp> {
   using ConvertOpToLLVMPattern<SplatOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(SplatOp splatOp, ArrayRef<Value> operands,
+  matchAndRewrite(SplatOp splatOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     VectorType resultType = splatOp.getType().dyn_cast<VectorType>();
     if (!resultType || resultType.getRank() != 1)
       return failure();
 
-    SplatOp::Adaptor adaptor(operands);
-
     // First insert it into an undef vector so we can shuffle it.
     auto vectorType = typeConverter->convertType(splatOp.getType());
     Value undef = rewriter.create<LLVM::UndefOp>(splatOp.getLoc(), vectorType);
     auto zero = rewriter.create<LLVM::ConstantOp>(
         splatOp.getLoc(),
         typeConverter->convertType(rewriter.getIntegerType(32)),
         rewriter.getZeroAttr(rewriter.getIntegerType(32)));
 

 
 // The Splat operation is lowered to an insertelement + a shufflevector
 // operation. Splat to only 2+-d vector result types are lowered by the
 // SplatNdOpLowering, the 1-d case is handled by SplatOpLowering.
 struct SplatNdOpLowering : public ConvertOpToLLVMPattern<SplatOp> {
   using ConvertOpToLLVMPattern<SplatOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(SplatOp splatOp, ArrayRef<Value> operands,
+  matchAndRewrite(SplatOp splatOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    SplatOp::Adaptor adaptor(operands);
     VectorType resultType = splatOp.getType().dyn_cast<VectorType>();
     if (!resultType || resultType.getRank() == 1)
       return failure();
 
     // First insert it into an undef vector so we can shuffle it.
     auto loc = splatOp.getLoc();
     auto vectorTypeInfo =
         LLVM::detail::extractNDVectorTypeInfo(resultType, *getTypeConverter());

 }
 
 namespace {
 
 struct AtomicRMWOpLowering : public LoadStoreOpLowering<AtomicRMWOp> {
   using Base::Base;
 
   LogicalResult
-  matchAndRewrite(AtomicRMWOp atomicOp, ArrayRef<Value> operands,
+  matchAndRewrite(AtomicRMWOp atomicOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (failed(match(atomicOp)))
       return failure();
     auto maybeKind = matchSimpleAtomicOp(atomicOp);
     if (!maybeKind)
       return failure();
-    AtomicRMWOp::Adaptor adaptor(operands);
     auto resultType = adaptor.value().getType();
     auto memRefType = atomicOp.getMemRefType();
     auto dataPtr =
         getStridedElementPtr(atomicOp.getLoc(), memRefType, adaptor.memref(),
                              adaptor.indices(), rewriter);
     rewriter.replaceOpWithNewOp<LLVM::AtomicRMWOp>(
         atomicOp, resultType, *maybeKind, dataPtr, adaptor.value(),
         LLVM::AtomicOrdering::acq_rel);

 ///      |   <code after the AtomicRMWOp> |
 ///      +--------------------------------+
 ///
 struct GenericAtomicRMWOpLowering
     : public LoadStoreOpLowering<GenericAtomicRMWOp> {
   using Base::Base;
 
   LogicalResult
-  matchAndRewrite(GenericAtomicRMWOp atomicOp, ArrayRef<Value> operands,
+  matchAndRewrite(GenericAtomicRMWOp atomicOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto loc = atomicOp.getLoc();
-    GenericAtomicRMWOp::Adaptor adaptor(operands);
     Type valueType = typeConverter->convertType(atomicOp.getResult().getType());
 
     // Split the block into initial, loop, and ending parts.
     auto *initBlock = rewriter.getInsertionBlock();
     auto *loopBlock =
         rewriter.createBlock(initBlock->getParent(),
                              std::next(Region::iterator(initBlock)), valueType);
     auto *endBlock = rewriter.createBlock(

mlir/lib/Conversion/StandardToSPIRV/StandardToSPIRV.cpp

 
 /// Converts unary and binary standard operations to SPIR-V operations.
 template <typename StdOp, typename SPIRVOp>
 class UnaryAndBinaryOpPattern final : public OpConversionPattern<StdOp> {
 public:
   using OpConversionPattern<StdOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(StdOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(StdOp operation, typename StdOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    assert(operands.size() <= 2);
+    assert(adaptor.getOperands().size() <= 2);
     auto dstType = this->getTypeConverter()->convertType(operation.getType());
     if (!dstType)
       return failure();
     if (SPIRVOp::template hasTrait<OpTrait::spirv::UnsignedOp>() &&
         dstType != operation.getType()) {
       return operation.emitError(
           "bitwidth emulation is not implemented yet on unsigned op");
     }
-    rewriter.template replaceOpWithNewOp<SPIRVOp>(operation, dstType, operands);
+    rewriter.template replaceOpWithNewOp<SPIRVOp>(operation, dstType,
+                                                  adaptor.getOperands());
     return success();
   }
 };
 
 /// Converts std.remi_signed to SPIR-V ops.
 ///
 /// This cannot be merged into the template unary/binary pattern due to
 /// Vulkan restrictions over spv.SRem and spv.SMod.
 class SignedRemIOpPattern final : public OpConversionPattern<SignedRemIOp> {
 public:
   using OpConversionPattern<SignedRemIOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(SignedRemIOp remOp, ArrayRef<Value> operands,
+  matchAndRewrite(SignedRemIOp remOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts bitwise standard operations to SPIR-V operations. This is a special
 /// pattern other than the BinaryOpPatternPattern because if the operands are
 /// boolean values, SPIR-V uses different operations (`SPIRVLogicalOp`). For
 /// non-boolean operands, SPIR-V should use `SPIRVBitwiseOp`.
 template <typename StdOp, typename SPIRVLogicalOp, typename SPIRVBitwiseOp>
 class BitwiseOpPattern final : public OpConversionPattern<StdOp> {
 public:
   using OpConversionPattern<StdOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(StdOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(StdOp operation, typename StdOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    assert(operands.size() == 2);
+    assert(adaptor.getOperands().size() == 2);
     auto dstType =
         this->getTypeConverter()->convertType(operation.getResult().getType());
     if (!dstType)
       return failure();
-    if (isBoolScalarOrVector(operands.front().getType())) {
-      rewriter.template replaceOpWithNewOp<SPIRVLogicalOp>(operation, dstType,
-                                                           operands);
+    if (isBoolScalarOrVector(adaptor.getOperands().front().getType())) {
+      rewriter.template replaceOpWithNewOp<SPIRVLogicalOp>(
+          operation, dstType, adaptor.getOperands());
     } else {
-      rewriter.template replaceOpWithNewOp<SPIRVBitwiseOp>(operation, dstType,
-                                                           operands);
+      rewriter.template replaceOpWithNewOp<SPIRVBitwiseOp>(
+          operation, dstType, adaptor.getOperands());
     }
     return success();
   }
 };
 
 /// Converts composite std.constant operation to spv.Constant.
 class ConstantCompositeOpPattern final
     : public OpConversionPattern<ConstantOp> {
 public:
   using OpConversionPattern<ConstantOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ConstantOp constOp, ArrayRef<Value> operands,
+  matchAndRewrite(ConstantOp constOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts scalar std.constant operation to spv.Constant.
 class ConstantScalarOpPattern final : public OpConversionPattern<ConstantOp> {
 public:
   using OpConversionPattern<ConstantOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ConstantOp constOp, ArrayRef<Value> operands,
+  matchAndRewrite(ConstantOp constOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts floating-point comparison operations to SPIR-V ops.
 class CmpFOpPattern final : public OpConversionPattern<CmpFOp> {
 public:
   using OpConversionPattern<CmpFOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CmpFOp cmpFOp, ArrayRef<Value> operands,
+  matchAndRewrite(CmpFOp cmpFOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts floating point NaN check to SPIR-V ops. This pattern requires
 /// Kernel capability.
 class CmpFOpNanKernelPattern final : public OpConversionPattern<CmpFOp> {
 public:
   using OpConversionPattern<CmpFOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CmpFOp cmpFOp, ArrayRef<Value> operands,
+  matchAndRewrite(CmpFOp cmpFOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts floating point NaN check to SPIR-V ops. This pattern does not
 /// require additional capability.
 class CmpFOpNanNonePattern final : public OpConversionPattern<CmpFOp> {
 public:
   using OpConversionPattern<CmpFOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CmpFOp cmpFOp, ArrayRef<Value> operands,
+  matchAndRewrite(CmpFOp cmpFOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts integer compare operation on i1 type operands to SPIR-V ops.
 class BoolCmpIOpPattern final : public OpConversionPattern<CmpIOp> {
 public:
   using OpConversionPattern<CmpIOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CmpIOp cmpIOp, ArrayRef<Value> operands,
+  matchAndRewrite(CmpIOp cmpIOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts integer compare operation to SPIR-V ops.
 class CmpIOpPattern final : public OpConversionPattern<CmpIOp> {
 public:
   using OpConversionPattern<CmpIOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CmpIOp cmpIOp, ArrayRef<Value> operands,
+  matchAndRewrite(CmpIOp cmpIOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts std.return to spv.Return.
 class ReturnOpPattern final : public OpConversionPattern<ReturnOp> {
 public:
   using OpConversionPattern<ReturnOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ReturnOp returnOp, ArrayRef<Value> operands,
+  matchAndRewrite(ReturnOp returnOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts std.select to spv.Select.
 class SelectOpPattern final : public OpConversionPattern<SelectOp> {
 public:
   using OpConversionPattern<SelectOp>::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(SelectOp op, ArrayRef<Value> operands,
+  matchAndRewrite(SelectOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts std.splat to spv.CompositeConstruct.
 class SplatPattern final : public OpConversionPattern<SplatOp> {
 public:
   using OpConversionPattern<SplatOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(SplatOp op, ArrayRef<Value> operands,
+  matchAndRewrite(SplatOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts std.zexti to spv.Select if the type of source is i1 or vector of
 /// i1.
 class ZeroExtendI1Pattern final : public OpConversionPattern<ZeroExtendIOp> {
 public:
   using OpConversionPattern<ZeroExtendIOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ZeroExtendIOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ZeroExtendIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    auto srcType = operands.front().getType();
+    auto srcType = adaptor.getOperands().front().getType();
     if (!isBoolScalarOrVector(srcType))
       return failure();
 
     auto dstType =
         this->getTypeConverter()->convertType(op.getResult().getType());
     Location loc = op.getLoc();
     Value zero = spirv::ConstantOp::getZero(dstType, loc, rewriter);
     Value one = spirv::ConstantOp::getOne(dstType, loc, rewriter);
     rewriter.template replaceOpWithNewOp<spirv::SelectOp>(
-        op, dstType, operands.front(), one, zero);
+        op, dstType, adaptor.getOperands().front(), one, zero);
     return success();
   }
 };
 
 /// Converts tensor.extract into loading using access chains from SPIR-V local
 /// variables.
 class TensorExtractPattern final
     : public OpConversionPattern<tensor::ExtractOp> {
 public:
   TensorExtractPattern(TypeConverter &typeConverter, MLIRContext *context,
                        int64_t threshold, PatternBenefit benefit = 1)
       : OpConversionPattern(typeConverter, context, benefit),
         byteCountThreshold(threshold) {}
 
   LogicalResult
-  matchAndRewrite(tensor::ExtractOp extractOp, ArrayRef<Value> operands,
+  matchAndRewrite(tensor::ExtractOp extractOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     TensorType tensorType = extractOp.tensor().getType().cast<TensorType>();
 
     if (!tensorType.hasStaticShape())
       return rewriter.notifyMatchFailure(extractOp, "non-static tensor");
 
     if (tensorType.getNumElements() * tensorType.getElementTypeBitWidth() >
         byteCountThreshold * 8)
       return rewriter.notifyMatchFailure(extractOp,
                                          "exceeding byte count threshold");
 
     Location loc = extractOp.getLoc();
-    tensor::ExtractOp::Adaptor adaptor(operands);
 
     int64_t rank = tensorType.getRank();
     SmallVector<int64_t, 4> strides(rank, 1);
     for (int i = rank - 2; i >= 0; --i) {
       strides[i] = strides[i + 1] * tensorType.getDimSize(i + 1);
     }
 
     Type varType = spirv::PointerType::get(adaptor.tensor().getType(),

 
 /// Converts std.trunci to spv.Select if the type of result is i1 or vector of
 /// i1.
 class TruncI1Pattern final : public OpConversionPattern<TruncateIOp> {
 public:
   using OpConversionPattern<TruncateIOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(TruncateIOp op, ArrayRef<Value> operands,
+  matchAndRewrite(TruncateIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType =
         this->getTypeConverter()->convertType(op.getResult().getType());
     if (!isBoolScalarOrVector(dstType))
       return failure();
 
     Location loc = op.getLoc();
-    auto srcType = operands.front().getType();
+    auto srcType = adaptor.getOperands().front().getType();
     // Check if (x & 1) == 1.
     Value mask = spirv::ConstantOp::getOne(srcType, loc, rewriter);
-    Value maskedSrc =
-        rewriter.create<spirv::BitwiseAndOp>(loc, srcType, operands[0], mask);
+    Value maskedSrc = rewriter.create<spirv::BitwiseAndOp>(
+        loc, srcType, adaptor.getOperands()[0], mask);
     Value isOne = rewriter.create<spirv::IEqualOp>(loc, maskedSrc, mask);
 
     Value zero = spirv::ConstantOp::getZero(dstType, loc, rewriter);
     Value one = spirv::ConstantOp::getOne(dstType, loc, rewriter);
     rewriter.replaceOpWithNewOp<spirv::SelectOp>(op, dstType, isOne, one, zero);
     return success();
   }
 };
 
 /// Converts std.uitofp to spv.Select if the type of source is i1 or vector of
 /// i1.
 class UIToFPI1Pattern final : public OpConversionPattern<UIToFPOp> {
 public:
   using OpConversionPattern<UIToFPOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(UIToFPOp op, ArrayRef<Value> operands,
+  matchAndRewrite(UIToFPOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    auto srcType = operands.front().getType();
+    auto srcType = adaptor.getOperands().front().getType();
     if (!isBoolScalarOrVector(srcType))
       return failure();
 
     auto dstType =
         this->getTypeConverter()->convertType(op.getResult().getType());
     Location loc = op.getLoc();
     Value zero = spirv::ConstantOp::getZero(dstType, loc, rewriter);
     Value one = spirv::ConstantOp::getOne(dstType, loc, rewriter);
     rewriter.template replaceOpWithNewOp<spirv::SelectOp>(
-        op, dstType, operands.front(), one, zero);
+        op, dstType, adaptor.getOperands().front(), one, zero);
     return success();
   }
 };
 
 /// Converts type-casting standard operations to SPIR-V operations.
 template <typename StdOp, typename SPIRVOp>
 class TypeCastingOpPattern final : public OpConversionPattern<StdOp> {
 public:
   using OpConversionPattern<StdOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(StdOp operation, ArrayRef<Value> operands,
+  matchAndRewrite(StdOp operation, typename StdOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    assert(operands.size() == 1);
-    auto srcType = operands.front().getType();
+    assert(adaptor.getOperands().size() == 1);
+    auto srcType = adaptor.getOperands().front().getType();
     auto dstType =
         this->getTypeConverter()->convertType(operation.getResult().getType());
     if (isBoolScalarOrVector(srcType) || isBoolScalarOrVector(dstType))
       return failure();
     if (dstType == srcType) {
       // Due to type conversion, we are seeing the same source and target type.
       // Then we can just erase this operation by forwarding its operand.
-      rewriter.replaceOp(operation, operands.front());
+      rewriter.replaceOp(operation, adaptor.getOperands().front());
     } else {
       rewriter.template replaceOpWithNewOp<SPIRVOp>(operation, dstType,
-                                                    operands);
+                                                    adaptor.getOperands());
     }
     return success();
   }
 };
 
 /// Converts std.xor to SPIR-V operations.
 class XOrOpPattern final : public OpConversionPattern<XOrOp> {
 public:
   using OpConversionPattern<XOrOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(XOrOp xorOp, ArrayRef<Value> operands,
+  matchAndRewrite(XOrOp xorOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts std.xor to SPIR-V operations if the type of source is i1 or vector
 /// of i1.
 class BoolXOrOpPattern final : public OpConversionPattern<XOrOp> {
 public:
   using OpConversionPattern<XOrOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(XOrOp xorOp, ArrayRef<Value> operands,
+  matchAndRewrite(XOrOp xorOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // SignedRemIOpPattern
 //===----------------------------------------------------------------------===//
 
 LogicalResult SignedRemIOpPattern::matchAndRewrite(
-    SignedRemIOp remOp, ArrayRef<Value> operands,
+    SignedRemIOp remOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
-  Value result = emulateSignedRemainder(remOp.getLoc(), operands[0],
-                                        operands[1], operands[0], rewriter);
+  Value result = emulateSignedRemainder(
+      remOp.getLoc(), adaptor.getOperands()[0], adaptor.getOperands()[1],
+      adaptor.getOperands()[0], rewriter);
   rewriter.replaceOp(remOp, result);
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp with composite type.
 //===----------------------------------------------------------------------===//
 
 // TODO: This probably should be split into the vector case and tensor case,
 // so that the tensor case can be moved to TensorToSPIRV conversion. But,
 // std.constant is for the standard dialect though.
 LogicalResult ConstantCompositeOpPattern::matchAndRewrite(
-    ConstantOp constOp, ArrayRef<Value> operands,
+    ConstantOp constOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   auto srcType = constOp.getType().dyn_cast<ShapedType>();
   if (!srcType)
     return failure();
 
   // std.constant should only have vector or tenor types.
   assert((srcType.isa<VectorType, RankedTensorType>()));
 
LogicalResult ConstantCompositeOpPattern::matchAndRewrite(
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp with scalar type.
 //===----------------------------------------------------------------------===//
 
 LogicalResult ConstantScalarOpPattern::matchAndRewrite(
-    ConstantOp constOp, ArrayRef<Value> operands,
+    ConstantOp constOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   Type srcType = constOp.getType();
   if (!srcType.isIntOrIndexOrFloat())
     return failure();
 
   Type dstType = getTypeConverter()->convertType(srcType);
   if (!dstType)
     return failure();
LogicalResult ConstantScalarOpPattern::matchAndRewrite(
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CmpFOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-CmpFOpPattern::matchAndRewrite(CmpFOp cmpFOp, ArrayRef<Value> operands,
+CmpFOpPattern::matchAndRewrite(CmpFOp cmpFOp, OpAdaptor adaptor,
                                ConversionPatternRewriter &rewriter) const {
-  CmpFOpAdaptor cmpFOpOperands(operands);
-
   switch (cmpFOp.getPredicate()) {
 #define DISPATCH(cmpPredicate, spirvOp)                                        \
   case cmpPredicate:                                                           \
     rewriter.replaceOpWithNewOp<spirvOp>(cmpFOp, cmpFOp.getResult().getType(), \
-                                         cmpFOpOperands.lhs(),                 \
-                                         cmpFOpOperands.rhs());                \
+                                         adaptor.lhs(), adaptor.rhs());        \
     return success();
 
     // Ordered.
     DISPATCH(CmpFPredicate::OEQ, spirv::FOrdEqualOp);
     DISPATCH(CmpFPredicate::OGT, spirv::FOrdGreaterThanOp);
     DISPATCH(CmpFPredicate::OGE, spirv::FOrdGreaterThanEqualOp);
     DISPATCH(CmpFPredicate::OLT, spirv::FOrdLessThanOp);
     DISPATCH(CmpFPredicate::OLE, spirv::FOrdLessThanEqualOp);
#undef DISPATCH
 
   default:
     break;
   }
   return failure();
 }
 
 LogicalResult CmpFOpNanKernelPattern::matchAndRewrite(
-    CmpFOp cmpFOp, ArrayRef<Value> operands,
+    CmpFOp cmpFOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
-  CmpFOpAdaptor cmpFOpOperands(operands);
-
   if (cmpFOp.getPredicate() == CmpFPredicate::ORD) {
-    rewriter.replaceOpWithNewOp<spirv::OrderedOp>(cmpFOp, cmpFOpOperands.lhs(),
-                                                  cmpFOpOperands.rhs());
+    rewriter.replaceOpWithNewOp<spirv::OrderedOp>(cmpFOp, adaptor.lhs(),
+                                                  adaptor.rhs());
     return success();
   }
 
   if (cmpFOp.getPredicate() == CmpFPredicate::UNO) {
-    rewriter.replaceOpWithNewOp<spirv::UnorderedOp>(
-        cmpFOp, cmpFOpOperands.lhs(), cmpFOpOperands.rhs());
+    rewriter.replaceOpWithNewOp<spirv::UnorderedOp>(cmpFOp, adaptor.lhs(),
+                                                    adaptor.rhs());
     return success();
   }
 
   return failure();
 }
 
 LogicalResult CmpFOpNanNonePattern::matchAndRewrite(
-    CmpFOp cmpFOp, ArrayRef<Value> operands,
+    CmpFOp cmpFOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   if (cmpFOp.getPredicate() != CmpFPredicate::ORD &&
       cmpFOp.getPredicate() != CmpFPredicate::UNO)
     return failure();
 
-  CmpFOpAdaptor cmpFOpOperands(operands);
   Location loc = cmpFOp.getLoc();
 
-  Value lhsIsNan = rewriter.create<spirv::IsNanOp>(loc, cmpFOpOperands.lhs());
-  Value rhsIsNan = rewriter.create<spirv::IsNanOp>(loc, cmpFOpOperands.rhs());
+  Value lhsIsNan = rewriter.create<spirv::IsNanOp>(loc, adaptor.lhs());
+  Value rhsIsNan = rewriter.create<spirv::IsNanOp>(loc, adaptor.rhs());
 
   Value replace = rewriter.create<spirv::LogicalOrOp>(loc, lhsIsNan, rhsIsNan);
   if (cmpFOp.getPredicate() == CmpFPredicate::ORD)
     replace = rewriter.create<spirv::LogicalNotOp>(loc, replace);
 
   rewriter.replaceOp(cmpFOp, replace);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CmpIOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-BoolCmpIOpPattern::matchAndRewrite(CmpIOp cmpIOp, ArrayRef<Value> operands,
+BoolCmpIOpPattern::matchAndRewrite(CmpIOp cmpIOp, OpAdaptor adaptor,
                                    ConversionPatternRewriter &rewriter) const {
-  CmpIOpAdaptor cmpIOpOperands(operands);
-
   Type operandType = cmpIOp.lhs().getType();
   if (!isBoolScalarOrVector(operandType))
     return failure();
 
   switch (cmpIOp.getPredicate()) {
 #define DISPATCH(cmpPredicate, spirvOp)                                        \
   case cmpPredicate:                                                           \
     rewriter.replaceOpWithNewOp<spirvOp>(cmpIOp, cmpIOp.getResult().getType(), \
-                                         cmpIOpOperands.lhs(),                 \
-                                         cmpIOpOperands.rhs());                \
+                                         adaptor.lhs(), adaptor.rhs());        \
     return success();
 
     DISPATCH(CmpIPredicate::eq, spirv::LogicalEqualOp);
     DISPATCH(CmpIPredicate::ne, spirv::LogicalNotEqualOp);
 
 #undef DISPATCH
   default:;
   }
   return failure();
 }
 
 LogicalResult
-CmpIOpPattern::matchAndRewrite(CmpIOp cmpIOp, ArrayRef<Value> operands,
+CmpIOpPattern::matchAndRewrite(CmpIOp cmpIOp, OpAdaptor adaptor,
                                ConversionPatternRewriter &rewriter) const {
-  CmpIOpAdaptor cmpIOpOperands(operands);
-
   Type operandType = cmpIOp.lhs().getType();
   if (isBoolScalarOrVector(operandType))
     return failure();
 
   switch (cmpIOp.getPredicate()) {
 #define DISPATCH(cmpPredicate, spirvOp)                                        \
   case cmpPredicate:                                                           \
     if (spirvOp::template hasTrait<OpTrait::spirv::UnsignedOp>() &&            \
         operandType != this->getTypeConverter()->convertType(operandType)) {   \
       return cmpIOp.emitError(                                                 \
           "bitwidth emulation is not implemented yet on unsigned op");         \
     }                                                                          \
     rewriter.replaceOpWithNewOp<spirvOp>(cmpIOp, cmpIOp.getResult().getType(), \
-                                         cmpIOpOperands.lhs(),                 \
-                                         cmpIOpOperands.rhs());                \
+                                         adaptor.lhs(), adaptor.rhs());        \
     return success();
 
     DISPATCH(CmpIPredicate::eq, spirv::IEqualOp);
     DISPATCH(CmpIPredicate::ne, spirv::INotEqualOp);
     DISPATCH(CmpIPredicate::slt, spirv::SLessThanOp);
     DISPATCH(CmpIPredicate::sle, spirv::SLessThanEqualOp);
     DISPATCH(CmpIPredicate::sgt, spirv::SGreaterThanOp);
     DISPATCH(CmpIPredicate::sge, spirv::SGreaterThanEqualOp);
     DISPATCH(CmpIPredicate::ult, spirv::ULessThanOp);
     DISPATCH(CmpIPredicate::ule, spirv::ULessThanEqualOp);
     DISPATCH(CmpIPredicate::ugt, spirv::UGreaterThanOp);
     DISPATCH(CmpIPredicate::uge, spirv::UGreaterThanEqualOp);
 
 #undef DISPATCH
   }
   return failure();
 }
 
 //===----------------------------------------------------------------------===//
 // ReturnOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-ReturnOpPattern::matchAndRewrite(ReturnOp returnOp, ArrayRef<Value> operands,
+ReturnOpPattern::matchAndRewrite(ReturnOp returnOp, OpAdaptor adaptor,
                                  ConversionPatternRewriter &rewriter) const {
   if (returnOp.getNumOperands() > 1)
     return failure();
 
   if (returnOp.getNumOperands() == 1) {
-    rewriter.replaceOpWithNewOp<spirv::ReturnValueOp>(returnOp, operands[0]);
+    rewriter.replaceOpWithNewOp<spirv::ReturnValueOp>(returnOp,
+                                                      adaptor.getOperands()[0]);
   } else {
     rewriter.replaceOpWithNewOp<spirv::ReturnOp>(returnOp);
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SelectOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-SelectOpPattern::matchAndRewrite(SelectOp op, ArrayRef<Value> operands,
+SelectOpPattern::matchAndRewrite(SelectOp op, OpAdaptor adaptor,
                                  ConversionPatternRewriter &rewriter) const {
-  SelectOpAdaptor selectOperands(operands);
-  rewriter.replaceOpWithNewOp<spirv::SelectOp>(op, selectOperands.condition(),
-                                               selectOperands.true_value(),
-                                               selectOperands.false_value());
+  rewriter.replaceOpWithNewOp<spirv::SelectOp>(
+      op, adaptor.condition(), adaptor.true_value(), adaptor.false_value());
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SplatOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-SplatPattern::matchAndRewrite(SplatOp op, ArrayRef<Value> operands,
+SplatPattern::matchAndRewrite(SplatOp op, OpAdaptor adaptor,
                               ConversionPatternRewriter &rewriter) const {
   auto dstVecType = op.getType().dyn_cast<VectorType>();
   if (!dstVecType || !spirv::CompositeType::isValid(dstVecType))
     return failure();
-  SplatOp::Adaptor adaptor(operands);
   SmallVector<Value, 4> source(dstVecType.getNumElements(), adaptor.input());
   rewriter.replaceOpWithNewOp<spirv::CompositeConstructOp>(op, dstVecType,
                                                            source);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // XorOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-XOrOpPattern::matchAndRewrite(XOrOp xorOp, ArrayRef<Value> operands,
+XOrOpPattern::matchAndRewrite(XOrOp xorOp, OpAdaptor adaptor,
                               ConversionPatternRewriter &rewriter) const {
-  assert(operands.size() == 2);
+  assert(adaptor.getOperands().size() == 2);
 
-  if (isBoolScalarOrVector(operands.front().getType()))
+  if (isBoolScalarOrVector(adaptor.getOperands().front().getType()))
     return failure();
 
   auto dstType = getTypeConverter()->convertType(xorOp.getType());
   if (!dstType)
     return failure();
-  rewriter.replaceOpWithNewOp<spirv::BitwiseXorOp>(xorOp, dstType, operands);
+  rewriter.replaceOpWithNewOp<spirv::BitwiseXorOp>(xorOp, dstType,
+                                                   adaptor.getOperands());
 
   return success();
 }
 
 LogicalResult
-BoolXOrOpPattern::matchAndRewrite(XOrOp xorOp, ArrayRef<Value> operands,
+BoolXOrOpPattern::matchAndRewrite(XOrOp xorOp, OpAdaptor adaptor,
                                   ConversionPatternRewriter &rewriter) const {
-  assert(operands.size() == 2);
+  assert(adaptor.getOperands().size() == 2);
 
-  if (!isBoolScalarOrVector(operands.front().getType()))
+  if (!isBoolScalarOrVector(adaptor.getOperands().front().getType()))
     return failure();
 
   auto dstType = getTypeConverter()->convertType(xorOp.getType());
   if (!dstType)
     return failure();
   rewriter.replaceOpWithNewOp<spirv::LogicalNotEqualOp>(xorOp, dstType,
-                                                        operands);
+                                                        adaptor.getOperands());
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Pattern population
 //===----------------------------------------------------------------------===//
 
 namespace mlir {

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

LogicalResult matchAndRewrite(SrcOp op,
     return elementwiseMatchAndRewriteHelper(op, rewriter);
   }
 };
 
 class ConvConverter : public OpConversionPattern<tosa::Conv2DOp> {
 public:
   using OpConversionPattern<tosa::Conv2DOp>::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tosa::Conv2DOp op, ArrayRef<Value> args,
+  matchAndRewrite(tosa::Conv2DOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = op->getLoc();
     Value input = op->getOperand(0);
     Value weight = op->getOperand(1);
     Value bias = op->getOperand(2);
 
     ShapedType inputTy = input.getType().cast<ShapedType>();
     ShapedType weightTy = weight.getType().cast<ShapedType>();
public:
   }
 };
 
 class DepthwiseConvConverter
     : public OpConversionPattern<tosa::DepthwiseConv2DOp> {
 public:
   using OpConversionPattern<tosa::DepthwiseConv2DOp>::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tosa::DepthwiseConv2DOp op, ArrayRef<Value> args,
+  matchAndRewrite(tosa::DepthwiseConv2DOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = op->getLoc();
     Value input = op->getOperand(0);
     Value weight = op->getOperand(1);
     Value bias = op->getOperand(2);
 
     ShapedType inputTy = input.getType().cast<ShapedType>();
     ShapedType weightTy = weight.getType().cast<ShapedType>();
public:
   }
 };
 
 class TransposeConvConverter
     : public OpConversionPattern<tosa::TransposeConv2DOp> {
 public:
   using OpConversionPattern<tosa::TransposeConv2DOp>::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tosa::TransposeConv2DOp op, ArrayRef<Value> args,
+  matchAndRewrite(tosa::TransposeConv2DOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = op->getLoc();
     Value input = op->getOperand(0);
     Value weight = op->getOperand(1);
     Value bias = op->getOperand(2);
 
     ShapedType inputTy = input.getType().cast<ShapedType>();
     ShapedType weightTy = weight.getType().cast<ShapedType>();
matchAndRewrite(tosa::TransposeConv2DOp op, OpAdaptor adaptor,
     return failure();
   }
 };
 
 class MatMulConverter : public OpConversionPattern<tosa::MatMulOp> {
 public:
   using OpConversionPattern<tosa::MatMulOp>::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tosa::MatMulOp op, ArrayRef<Value> args,
+  matchAndRewrite(tosa::MatMulOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    tosa::MatMulOp::Adaptor adaptor(args);
-
     Location loc = op.getLoc();
 
     auto outputTy = op.getType().cast<ShapedType>();
     auto outputElementTy = outputTy.getElementType();
     auto zeroAttr = rewriter.getZeroAttr(outputElementTy);
     Value zero = rewriter.create<ConstantOp>(loc, zeroAttr);
     auto initTensor = rewriter.create<linalg::InitTensorOp>(
         loc, outputTy.getShape(), outputTy.getElementType());
public:
   }
 };
 
 class FullyConnectedConverter
     : public OpConversionPattern<tosa::FullyConnectedOp> {
 public:
   using OpConversionPattern<tosa::FullyConnectedOp>::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tosa::FullyConnectedOp op, ArrayRef<Value> args,
+  matchAndRewrite(tosa::FullyConnectedOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = op.getLoc();
     auto outputTy = op.getType().cast<ShapedType>();
     auto input = op.input();
     auto weight = op.weight();
     auto bias = op.bias();
 
     auto weightTy = weight.getType().cast<ShapedType>();
public:
   }
 };
 
 class ReshapeConverter : public OpConversionPattern<tosa::ReshapeOp> {
 public:
   using OpConversionPattern<tosa::ReshapeOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(tosa::ReshapeOp reshape, ArrayRef<Value> args,
+  matchAndRewrite(tosa::ReshapeOp reshape, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    typename tosa::ReshapeOp::Adaptor operands(args);
-
-    ShapedType operandTy = operands.input1().getType().cast<ShapedType>();
+    ShapedType operandTy = adaptor.input1().getType().cast<ShapedType>();
     ShapedType resultTy = reshape.getType().template cast<ShapedType>();
 
     if (operandTy == resultTy) {
-      rewriter.replaceOp(reshape, args[0]);
+      rewriter.replaceOp(reshape, adaptor.getOperands()[0]);
       return success();
     }
 
     if (!operandTy.hasStaticShape() || !resultTy.hasStaticShape())
       return failure();
 
     // Compute the reassociation maps for the linalg operation.
     ArrayRef<int64_t> expandedShape =
if (!isCollapsingSource) {
           getIdentityExprs(operandTy.getShape().size())};
       SmallVector<ReassociationExprs, 4> expandingMap = {
           // Use resultTy here because we need to expand to all result
           // dimensions.
           getIdentityExprs(resultTy.getShape().size())};
 
       auto collapsedTy = RankedTensorType::get({totalElems}, elemTy);
       Value collapsedOp = rewriter.create<linalg::TensorCollapseShapeOp>(
-          loc, collapsedTy, args[0], collapsingMap);
+          loc, collapsedTy, adaptor.getOperands()[0], collapsingMap);
       rewriter.replaceOpWithNewOp<linalg::TensorExpandShapeOp>(
           reshape, resultTy, collapsedOp, expandingMap);
 
       return success();
     }
 
-    if (resultTy.getRank() < args[0].getType().cast<ShapedType>().getRank())
+    if (resultTy.getRank() <
+        adaptor.getOperands()[0].getType().cast<ShapedType>().getRank())
       rewriter.replaceOpWithNewOp<linalg::TensorCollapseShapeOp>(
-          reshape, resultTy, args[0], reassociationMap);
+          reshape, resultTy, adaptor.getOperands()[0], reassociationMap);
     else
       rewriter.replaceOpWithNewOp<linalg::TensorExpandShapeOp>(
-          reshape, resultTy, args[0], reassociationMap);
+          reshape, resultTy, adaptor.getOperands()[0], reassociationMap);
 
     return success();
   }
 };
 
 class TransposeConverter : public OpRewritePattern<tosa::TransposeOp> {
 public:
   using OpRewritePattern<tosa::TransposeOp>::OpRewritePattern;
LogicalResult matchAndRewrite(SrcOp reduceOp,
     return reduceMatchAndRewriteHelper(reduceOp, reduceOp.axis(), rewriter);
   }
 };
 
 struct ConcatConverter : public OpConversionPattern<tosa::ConcatOp> {
   using OpConversionPattern<tosa::ConcatOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(tosa::ConcatOp op, ArrayRef<Value> args,
+  matchAndRewrite(tosa::ConcatOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto resultType = op.getType().dyn_cast<RankedTensorType>();
     if (!resultType || !resultType.hasStaticShape()) {
       return rewriter.notifyMatchFailure(op,
                                          "expected static shaped tensor type");
     }
 
     Location loc = op.getLoc();
     int axis = op.axis();
     Value axisValue =
         rewriter.create<ConstantOp>(loc, rewriter.getIndexAttr(axis));
     int rank = resultType.getRank();
     SmallVector<Value, 3> offsets, sizes, strides;
     sizes.reserve(rank);
     strides.resize(rank, rewriter.create<ConstantIndexOp>(loc, 1));
     offsets.resize(rank, rewriter.create<ConstantIndexOp>(loc, 0));
 
     for (int i = 0; i < rank; ++i) {
-      sizes.push_back(rewriter.create<tensor::DimOp>(loc, args[0], i));
+      sizes.push_back(
+          rewriter.create<tensor::DimOp>(loc, adaptor.getOperands()[0], i));
     }
 
     Value resultDimSize = sizes[axis];
-    for (auto arg : args.drop_front()) {
+    for (auto arg : adaptor.getOperands().drop_front()) {
       auto size = rewriter.create<tensor::DimOp>(loc, arg, axisValue);
       resultDimSize = rewriter.create<AddIOp>(loc, resultDimSize, size);
     }
     sizes[axis] = resultDimSize;
 
     Value init = rewriter.create<linalg::InitTensorOp>(
         loc, resultType.getShape(), resultType.getElementType());
 
     Value zeroVal = rewriter.create<ConstantOp>(
         loc, rewriter.getZeroAttr(resultType.getElementType()));
     Value result =
         rewriter.create<linalg::FillOp>(loc, zeroVal, init).getResult(0);
 
-    for (auto arg : args) {
+    for (auto arg : adaptor.getOperands()) {
       sizes[axis] = rewriter.create<tensor::DimOp>(loc, arg, axisValue);
       result = rewriter.create<tensor::InsertSliceOp>(loc, arg, result, offsets,
                                                       sizes, strides);
       offsets[axis] = rewriter.create<AddIOp>(loc, offsets[axis], sizes[axis]);
     }
     rewriter.replaceOp(op, result);
     return success();
   }

 // This converter translate a tile operation to a reshape, broadcast, reshape.
 // The first reshape minimally expands each tiled dimension to include a
 // proceding size-1 dim. This dim is then broadcasted to the appropriate
 // multiple.
 struct TileConverter : public OpConversionPattern<tosa::TileOp> {
   using OpConversionPattern<tosa::TileOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(tosa::TileOp op, ArrayRef<Value> args,
+  matchAndRewrite(tosa::TileOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = op.getLoc();
     auto input = op.input1();
     auto inputTy = input.getType().cast<ShapedType>();
     auto inputShape = inputTy.getShape();
     auto resultTy = op.getType().cast<ShapedType>();
     auto elementTy = inputTy.getElementType();
     int64_t rank = inputTy.getRank();
LogicalResult matchAndRewrite(tosa::ArgMaxOp argmaxOp,
     return success();
   }
 };
 
 class GatherConverter : public OpConversionPattern<tosa::GatherOp> {
 public:
   using OpConversionPattern<tosa::GatherOp>::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tosa::GatherOp op, ArrayRef<Value> args,
+  matchAndRewrite(tosa::GatherOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    auto input = args[0];
-    auto indices = args[1];
+    auto input = adaptor.getOperands()[0];
+    auto indices = adaptor.getOperands()[1];
 
     auto inputTy = input.getType().cast<ShapedType>();
     auto indicesTy = indices.getType().cast<ShapedType>();
     auto resultTy = op.getType().cast<ShapedType>();
 
     if (!inputTy.hasStaticShape() || !indicesTy.hasStaticShape())
       return rewriter.notifyMatchFailure(
           op, "require input type to have static shape");

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

 
 namespace {
 
 struct VectorBitcastConvert final
     : public OpConversionPattern<vector::BitCastOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(vector::BitCastOp bitcastOp, ArrayRef<Value> operands,
+  matchAndRewrite(vector::BitCastOp bitcastOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = getTypeConverter()->convertType(bitcastOp.getType());
     if (!dstType)
       return failure();
 
-    vector::BitCastOp::Adaptor adaptor(operands);
     if (dstType == adaptor.source().getType())
       rewriter.replaceOp(bitcastOp, adaptor.source());
     else
       rewriter.replaceOpWithNewOp<spirv::BitcastOp>(bitcastOp, dstType,
                                                     adaptor.source());
 
     return success();
   }
 };
 
 struct VectorBroadcastConvert final
     : public OpConversionPattern<vector::BroadcastOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(vector::BroadcastOp broadcastOp, ArrayRef<Value> operands,
+  matchAndRewrite(vector::BroadcastOp broadcastOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (broadcastOp.source().getType().isa<VectorType>() ||
         !spirv::CompositeType::isValid(broadcastOp.getVectorType()))
       return failure();
-    vector::BroadcastOp::Adaptor adaptor(operands);
     SmallVector<Value, 4> source(broadcastOp.getVectorType().getNumElements(),
                                  adaptor.source());
     rewriter.replaceOpWithNewOp<spirv::CompositeConstructOp>(
         broadcastOp, broadcastOp.getVectorType(), source);
     return success();
   }
 };
 
 struct VectorExtractOpConvert final
     : public OpConversionPattern<vector::ExtractOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(vector::ExtractOp extractOp, ArrayRef<Value> operands,
+  matchAndRewrite(vector::ExtractOp extractOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Only support extracting a scalar value now.
     VectorType resultVectorType = extractOp.getType().dyn_cast<VectorType>();
     if (resultVectorType && resultVectorType.getNumElements() > 1)
       return failure();
 
     auto dstType = getTypeConverter()->convertType(extractOp.getType());
     if (!dstType)
       return failure();
 
-    vector::ExtractOp::Adaptor adaptor(operands);
     if (adaptor.vector().getType().isa<spirv::ScalarType>()) {
       rewriter.replaceOp(extractOp, adaptor.vector());
       return success();
     }
 
     int32_t id = getFirstIntValue(extractOp.position());
     rewriter.replaceOpWithNewOp<spirv::CompositeExtractOp>(
         extractOp, adaptor.vector(), id);
     return success();
   }
 };
 
 struct VectorExtractStridedSliceOpConvert final
     : public OpConversionPattern<vector::ExtractStridedSliceOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(vector::ExtractStridedSliceOp extractOp,
-                  ArrayRef<Value> operands,
+  matchAndRewrite(vector::ExtractStridedSliceOp extractOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = getTypeConverter()->convertType(extractOp.getType());
     if (!dstType)
       return failure();
 
 
     uint64_t offset = getFirstIntValue(extractOp.offsets());
     uint64_t size = getFirstIntValue(extractOp.sizes());
     uint64_t stride = getFirstIntValue(extractOp.strides());
     if (stride != 1)
       return failure();
 
-    Value srcVector = operands.front();
+    Value srcVector = adaptor.getOperands().front();
 
     // Extract vector<1xT> case.
     if (dstType.isa<spirv::ScalarType>()) {
       rewriter.replaceOpWithNewOp<spirv::CompositeExtractOp>(extractOp,
                                                              srcVector, offset);
       return success();
     }
 
     SmallVector<int32_t, 2> indices(size);
     std::iota(indices.begin(), indices.end(), offset);
 
     rewriter.replaceOpWithNewOp<spirv::VectorShuffleOp>(
         extractOp, dstType, srcVector, srcVector,
         rewriter.getI32ArrayAttr(indices));
 
     return success();
   }
 };
 
 struct VectorFmaOpConvert final : public OpConversionPattern<vector::FMAOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(vector::FMAOp fmaOp, ArrayRef<Value> operands,
+  matchAndRewrite(vector::FMAOp fmaOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (!spirv::CompositeType::isValid(fmaOp.getVectorType()))
       return failure();
-    vector::FMAOp::Adaptor adaptor(operands);
     rewriter.replaceOpWithNewOp<spirv::GLSLFmaOp>(
         fmaOp, fmaOp.getType(), adaptor.lhs(), adaptor.rhs(), adaptor.acc());
     return success();
   }
 };
 
 struct VectorInsertOpConvert final
     : public OpConversionPattern<vector::InsertOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(vector::InsertOp insertOp, ArrayRef<Value> operands,
+  matchAndRewrite(vector::InsertOp insertOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (insertOp.getSourceType().isa<VectorType>() ||
         !spirv::CompositeType::isValid(insertOp.getDestVectorType()))
       return failure();
-    vector::InsertOp::Adaptor adaptor(operands);
     int32_t id = getFirstIntValue(insertOp.position());
     rewriter.replaceOpWithNewOp<spirv::CompositeInsertOp>(
         insertOp, adaptor.source(), adaptor.dest(), id);
     return success();
   }
 };
 
 struct VectorExtractElementOpConvert final
     : public OpConversionPattern<vector::ExtractElementOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(vector::ExtractElementOp extractElementOp,
-                  ArrayRef<Value> operands,
+  matchAndRewrite(vector::ExtractElementOp extractElementOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (!spirv::CompositeType::isValid(extractElementOp.getVectorType()))
       return failure();
-    vector::ExtractElementOp::Adaptor adaptor(operands);
     rewriter.replaceOpWithNewOp<spirv::VectorExtractDynamicOp>(
         extractElementOp, extractElementOp.getType(), adaptor.vector(),
         extractElementOp.position());
     return success();
   }
 };
 
 struct VectorInsertElementOpConvert final
     : public OpConversionPattern<vector::InsertElementOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(vector::InsertElementOp insertElementOp,
-                  ArrayRef<Value> operands,
+  matchAndRewrite(vector::InsertElementOp insertElementOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (!spirv::CompositeType::isValid(insertElementOp.getDestVectorType()))
       return failure();
-    vector::InsertElementOp::Adaptor adaptor(operands);
     rewriter.replaceOpWithNewOp<spirv::VectorInsertDynamicOp>(
         insertElementOp, insertElementOp.getType(), insertElementOp.dest(),
         adaptor.source(), insertElementOp.position());
     return success();
   }
 };
 
 struct VectorInsertStridedSliceOpConvert final
     : public OpConversionPattern<vector::InsertStridedSliceOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(vector::InsertStridedSliceOp insertOp,
-                  ArrayRef<Value> operands,
+  matchAndRewrite(vector::InsertStridedSliceOp insertOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    Value srcVector = operands.front();
-    Value dstVector = operands.back();
+    Value srcVector = adaptor.getOperands().front();
+    Value dstVector = adaptor.getOperands().back();
 
     // Insert scalar values not supported yet.
     if (srcVector.getType().isa<spirv::ScalarType>() ||
         dstVector.getType().isa<spirv::ScalarType>())
       return failure();
 
     uint64_t stride = getFirstIntValue(insertOp.strides());
     if (stride != 1)

mlir/lib/Dialect/AMX/Transforms/LegalizeForLLVMExport.cpp

Value castPtr(ConversionPatternRewriter &rewriter, Location loc, Value ptr) {
   auto i8Ptr =
       LLVM::LLVMPointerType::get(IntegerType::get(ptr.getContext(), 8));
   return rewriter.create<LLVM::BitcastOp>(loc, i8Ptr, ptr);
 }
 
 struct TileZeroConversion : public ConvertOpToLLVMPattern<TileZeroOp> {
   using ConvertOpToLLVMPattern<TileZeroOp>::ConvertOpToLLVMPattern;
   LogicalResult
-  matchAndRewrite(TileZeroOp op, ArrayRef<Value> operands,
+  matchAndRewrite(TileZeroOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     VectorType vType = op.getVectorType();
     // Determine m x n tile sizes.
     std::pair<Value, Value> tsz =
         getTileSizes(rewriter, *getTypeConverter(), vType, op.getLoc());
     // Replace operation with intrinsic.
     Type resType = typeConverter->convertType(vType);
     rewriter.replaceOpWithNewOp<amx::x86_amx_tilezero>(op, resType, tsz.first,
                                                        tsz.second);
     return success();
   }
 };
 
 struct TileLoadConversion : public ConvertOpToLLVMPattern<TileLoadOp> {
   using ConvertOpToLLVMPattern<TileLoadOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(TileLoadOp op, ArrayRef<Value> operands,
+  matchAndRewrite(TileLoadOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    TileLoadOp::Adaptor adaptor(operands);
     MemRefType mType = op.getMemRefType();
     VectorType vType = op.getVectorType();
     // Determine m x n tile sizes.
     std::pair<Value, Value> tsz =
         getTileSizes(rewriter, *getTypeConverter(), vType, op.getLoc());
     // Determine stride.
     if (failed(verifyStride(mType)))
       return failure();
matchAndRewrite(TileLoadOp op, OpAdaptor adaptor,
     return success();
   }
 };
 
 struct TileStoreConversion : public ConvertOpToLLVMPattern<TileStoreOp> {
   using ConvertOpToLLVMPattern<TileStoreOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(TileStoreOp op, ArrayRef<Value> operands,
+  matchAndRewrite(TileStoreOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    TileStoreOp::Adaptor adaptor(operands);
     MemRefType mType = op.getMemRefType();
     VectorType vType = op.getVectorType();
     // Determine m x n tile sizes.
     std::pair<Value, Value> tsz =
         getTileSizes(rewriter, *getTypeConverter(), vType, op.getLoc());
     // Determine stride.
     if (failed(verifyStride(mType)))
       return failure();
     Value stride = getStride(rewriter, *getTypeConverter(), mType,
                              adaptor.base(), op.getLoc());
     // Replace operation with intrinsic.
     Value ptr = getStridedElementPtr(op.getLoc(), mType, adaptor.base(),
                                      adaptor.indices(), rewriter);
     ptr = castPtr(rewriter, op.getLoc(), ptr);
     rewriter.replaceOpWithNewOp<amx::x86_amx_tilestored64>(
         op, tsz.first, tsz.second, ptr, stride, adaptor.val());
     return success();
   }
 };
 
 struct TileMulFConversion : public ConvertOpToLLVMPattern<TileMulFOp> {
   using ConvertOpToLLVMPattern<TileMulFOp>::ConvertOpToLLVMPattern;
   LogicalResult
-  matchAndRewrite(TileMulFOp op, ArrayRef<Value> operands,
+  matchAndRewrite(TileMulFOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    TileMulFOp::Adaptor adaptor(operands);
     VectorType aType = op.getLhsVectorType();
     VectorType bType = op.getRhsVectorType();
     VectorType cType = op.getVectorType();
     // Determine m x n x k tile sizes.
     std::pair<Value, Value> tsza =
         getTileSizes(rewriter, *getTypeConverter(), aType, op.getLoc());
     std::pair<Value, Value> tszb =
         getTileSizes(rewriter, *getTypeConverter(), bType, op.getLoc());
     // Replace operation with intrinsic.
     Type resType = typeConverter->convertType(cType);
     rewriter.replaceOpWithNewOp<amx::x86_amx_tdpbf16ps>(
         op, resType, tsza.first, tszb.second, tsza.second, adaptor.acc(),
         adaptor.lhs(), adaptor.rhs());
     return success();
   }
 };
 
 struct TileMulIConversion : public ConvertOpToLLVMPattern<TileMulIOp> {
   using ConvertOpToLLVMPattern<TileMulIOp>::ConvertOpToLLVMPattern;
   LogicalResult
-  matchAndRewrite(TileMulIOp op, ArrayRef<Value> operands,
+  matchAndRewrite(TileMulIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    TileMulIOp::Adaptor adaptor(operands);
     VectorType aType = op.getLhsVectorType();
     VectorType bType = op.getRhsVectorType();
     VectorType cType = op.getVectorType();
     // Determine m x n x k tile sizes.
     std::pair<Value, Value> tsza =
         getTileSizes(rewriter, *getTypeConverter(), aType, op.getLoc());
     std::pair<Value, Value> tszb =
         getTileSizes(rewriter, *getTypeConverter(), bType, op.getLoc());

mlir/lib/Dialect/ArmSVE/Transforms/LegalizeForLLVMExport.cpp

convertScalableVectorTypeToLLVM(ScalableVectorType svType,
   return sVectorType;
 }
 
 template <typename OpTy>
 class ForwardOperands : public OpConversionPattern<OpTy> {
   using OpConversionPattern<OpTy>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(OpTy op, ArrayRef<Value> operands,
+  matchAndRewrite(OpTy op, typename OpTy::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    if (ValueRange(operands).getTypes() == op->getOperands().getTypes())
+    if (adaptor.getOperands().getTypes() == op->getOperands().getTypes())
       return rewriter.notifyMatchFailure(op, "operand types already match");
 
-    rewriter.updateRootInPlace(op, [&]() { op->setOperands(operands); });
+    rewriter.updateRootInPlace(
+        op, [&]() { op->setOperands(adaptor.getOperands()); });
     return success();
   }
 };
 
 class ReturnOpTypeConversion : public OpConversionPattern<ReturnOp> {
 public:
   using OpConversionPattern<ReturnOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ReturnOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ReturnOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    rewriter.updateRootInPlace(op, [&]() { op->setOperands(operands); });
+    rewriter.updateRootInPlace(
+        op, [&]() { op->setOperands(adaptor.getOperands()); });
     return success();
   }
 };
 
 static Optional<Value> addUnrealizedCast(OpBuilder &builder,
                                          ScalableVectorType svType,
                                          ValueRange inputs, Location loc) {
   if (inputs.size() != 1 ||
OneToOneConvertToLLVMPattern<ScalableMaskedDivFOp,
                                  ScalableMaskedDivFIntrOp>;
 
 // Load operation is lowered to code that obtains a pointer to the indexed
 // element and loads from it.
 struct ScalableLoadOpLowering : public ConvertOpToLLVMPattern<ScalableLoadOp> {
   using ConvertOpToLLVMPattern<ScalableLoadOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(ScalableLoadOp loadOp, ArrayRef<Value> operands,
+  matchAndRewrite(ScalableLoadOp loadOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto type = loadOp.getMemRefType();
     if (!isConvertibleAndHasIdentityMaps(type))
       return failure();
 
-    ScalableLoadOp::Adaptor transformed(operands);
     LLVMTypeConverter converter(loadOp.getContext());
 
     auto resultType = loadOp.result().getType();
     LLVM::LLVMPointerType llvmDataTypePtr;
     if (resultType.isa<VectorType>()) {
       llvmDataTypePtr =
           LLVM::LLVMPointerType::get(resultType.cast<VectorType>());
     } else if (resultType.isa<ScalableVectorType>()) {
       llvmDataTypePtr = LLVM::LLVMPointerType::get(
           convertScalableVectorTypeToLLVM(resultType.cast<ScalableVectorType>(),
                                           converter)
               .getValue());
     }
-    Value dataPtr =
-        getStridedElementPtr(loadOp.getLoc(), type, transformed.base(),
-                             transformed.index(), rewriter);
+    Value dataPtr = getStridedElementPtr(loadOp.getLoc(), type, adaptor.base(),
+                                         adaptor.index(), rewriter);
     Value bitCastedPtr = rewriter.create<LLVM::BitcastOp>(
         loadOp.getLoc(), llvmDataTypePtr, dataPtr);
     rewriter.replaceOpWithNewOp<LLVM::LoadOp>(loadOp, bitCastedPtr);
     return success();
   }
 };
 
 // Store operation is lowered to code that obtains a pointer to the indexed
 // element, and stores the given value to it.
 struct ScalableStoreOpLowering
     : public ConvertOpToLLVMPattern<ScalableStoreOp> {
   using ConvertOpToLLVMPattern<ScalableStoreOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(ScalableStoreOp storeOp, ArrayRef<Value> operands,
+  matchAndRewrite(ScalableStoreOp storeOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto type = storeOp.getMemRefType();
     if (!isConvertibleAndHasIdentityMaps(type))
       return failure();
 
-    ScalableStoreOp::Adaptor transformed(operands);
     LLVMTypeConverter converter(storeOp.getContext());
 
     auto resultType = storeOp.value().getType();
     LLVM::LLVMPointerType llvmDataTypePtr;
     if (resultType.isa<VectorType>()) {
       llvmDataTypePtr =
           LLVM::LLVMPointerType::get(resultType.cast<VectorType>());
     } else if (resultType.isa<ScalableVectorType>()) {
       llvmDataTypePtr = LLVM::LLVMPointerType::get(
           convertScalableVectorTypeToLLVM(resultType.cast<ScalableVectorType>(),
                                           converter)
               .getValue());
     }
-    Value dataPtr =
-        getStridedElementPtr(storeOp.getLoc(), type, transformed.base(),
-                             transformed.index(), rewriter);
+    Value dataPtr = getStridedElementPtr(storeOp.getLoc(), type, adaptor.base(),
+                                         adaptor.index(), rewriter);
     Value bitCastedPtr = rewriter.create<LLVM::BitcastOp>(
         storeOp.getLoc(), llvmDataTypePtr, dataPtr);
-    rewriter.replaceOpWithNewOp<LLVM::StoreOp>(storeOp, transformed.value(),
+    rewriter.replaceOpWithNewOp<LLVM::StoreOp>(storeOp, adaptor.value(),
                                                bitCastedPtr);
     return success();
   }
 };
 
 static void
 populateBasicSVEArithmeticExportPatterns(LLVMTypeConverter &converter,
                                          OwningRewritePatternList &patterns) {

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

 //===----------------------------------------------------------------------===//
 
 namespace {
 class CreateGroupOpLowering : public OpConversionPattern<CreateGroupOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CreateGroupOp op, ArrayRef<Value> operands,
+  matchAndRewrite(CreateGroupOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<RuntimeCreateGroupOp>(
-        op, GroupType::get(op->getContext()), operands);
+        op, GroupType::get(op->getContext()), adaptor.getOperands());
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.add_to_group operation to async.runtime.add_to_group.
 //===----------------------------------------------------------------------===//
 
 namespace {
 class AddToGroupOpLowering : public OpConversionPattern<AddToGroupOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(AddToGroupOp op, ArrayRef<Value> operands,
+  matchAndRewrite(AddToGroupOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<RuntimeAddToGroupOp>(
-        op, rewriter.getIndexType(), operands);
+        op, rewriter.getIndexType(), adaptor.getOperands());
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.await and async.await_all operations to the async.runtime.await
 // or async.runtime.await_and_resume operations.
 //===----------------------------------------------------------------------===//
 
 namespace {
 template <typename AwaitType, typename AwaitableType>
 class AwaitOpLoweringBase : public OpConversionPattern<AwaitType> {
   using AwaitAdaptor = typename AwaitType::Adaptor;
 
 public:
   AwaitOpLoweringBase(MLIRContext *ctx,
                       llvm::DenseMap<FuncOp, CoroMachinery> &outlinedFunctions)
       : OpConversionPattern<AwaitType>(ctx),
         outlinedFunctions(outlinedFunctions) {}
 
   LogicalResult
-  matchAndRewrite(AwaitType op, ArrayRef<Value> operands,
+  matchAndRewrite(AwaitType op, typename AwaitType::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // We can only await on one the `AwaitableType` (for `await` it can be
     // a `token` or a `value`, for `await_all` it must be a `group`).
     if (!op.operand().getType().template isa<AwaitableType>())
       return rewriter.notifyMatchFailure(op, "unsupported awaitable type");
 
     // Check if await operation is inside the outlined coroutine function.
     auto func = op->template getParentOfType<FuncOp>();
     auto outlined = outlinedFunctions.find(func);
     const bool isInCoroutine = outlined != outlinedFunctions.end();
 
     Location loc = op->getLoc();
-    Value operand = AwaitAdaptor(operands).operand();
+    Value operand = adaptor.operand();
 
     Type i1 = rewriter.getI1Type();
 
     // Inside regular functions we use the blocking wait operation to wait for
     // the async object (token, value or group) to become available.
     if (!isInCoroutine) {
       ImplicitLocOpBuilder builder(loc, op, rewriter.getListener());
       builder.create<RuntimeAwaitOp>(loc, operand);

 public:
   YieldOpLowering(
       MLIRContext *ctx,
       const llvm::DenseMap<FuncOp, CoroMachinery> &outlinedFunctions)
       : OpConversionPattern<async::YieldOp>(ctx),
         outlinedFunctions(outlinedFunctions) {}
 
   LogicalResult
-  matchAndRewrite(async::YieldOp op, ArrayRef<Value> operands,
+  matchAndRewrite(async::YieldOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Check if yield operation is inside the async coroutine function.
     auto func = op->template getParentOfType<FuncOp>();
     auto outlined = outlinedFunctions.find(func);
     if (outlined == outlinedFunctions.end())
       return rewriter.notifyMatchFailure(
           op, "operation is not inside the async coroutine function");
 
     Location loc = op->getLoc();
     const CoroMachinery &coro = outlined->getSecond();
 
     // Store yielded values into the async values storage and switch async
     // values state to available.
-    for (auto tuple : llvm::zip(operands, coro.returnValues)) {
+    for (auto tuple : llvm::zip(adaptor.getOperands(), coro.returnValues)) {
       Value yieldValue = std::get<0>(tuple);
       Value asyncValue = std::get<1>(tuple);
       rewriter.create<RuntimeStoreOp>(loc, yieldValue, asyncValue);
       rewriter.create<RuntimeSetAvailableOp>(loc, asyncValue);
     }
 
     // Switch the coroutine completion token to available state.
     rewriter.replaceOpWithNewOp<RuntimeSetAvailableOp>(op, coro.asyncToken);

 class AssertOpLowering : public OpConversionPattern<AssertOp> {
 public:
   AssertOpLowering(MLIRContext *ctx,
                    llvm::DenseMap<FuncOp, CoroMachinery> &outlinedFunctions)
       : OpConversionPattern<AssertOp>(ctx),
         outlinedFunctions(outlinedFunctions) {}
 
   LogicalResult
-  matchAndRewrite(AssertOp op, ArrayRef<Value> operands,
+  matchAndRewrite(AssertOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Check if assert operation is inside the async coroutine function.
     auto func = op->template getParentOfType<FuncOp>();
     auto outlined = outlinedFunctions.find(func);
     if (outlined == outlinedFunctions.end())
       return rewriter.notifyMatchFailure(
           op, "operation is not inside the async coroutine function");
 
     Location loc = op->getLoc();
     CoroMachinery &coro = outlined->getSecond();
 
     Block *cont = rewriter.splitBlock(op->getBlock(), Block::iterator(op));
     rewriter.setInsertionPointToEnd(cont->getPrevNode());
-    rewriter.create<CondBranchOp>(loc, AssertOpAdaptor(operands).arg(),
+    rewriter.create<CondBranchOp>(loc, adaptor.arg(),
                                   /*trueDest=*/cont,
                                   /*trueArgs=*/ArrayRef<Value>(),
                                   /*falseDest=*/setupSetErrorBlock(coro),
                                   /*falseArgs=*/ArrayRef<Value>());
     rewriter.eraseOp(op);
 
     return success();
   }

mlir/lib/Dialect/Linalg/Transforms/Bufferize.cpp

 namespace {
 
 /// Conversion pattern that replaces `linalg.init_tensor` with allocation.
 class BufferizeInitTensorOp : public OpConversionPattern<InitTensorOp> {
 public:
   using OpConversionPattern<InitTensorOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(InitTensorOp op, ArrayRef<Value> operands,
+  matchAndRewrite(InitTensorOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    linalg::InitTensorOpAdaptor adaptor(operands, op->getAttrDictionary());
     rewriter.replaceOpWithNewOp<memref::AllocOp>(
         op, getTypeConverter()->convertType(op.getType()).cast<MemRefType>(),
         adaptor.sizes());
     return success();
   }
 };
 
 /// Conversion pattern that replaces `linalg.tensor_reshape` with
 /// `linalg.reshape`.
 template <typename TensorReshapeOp,
           typename Adaptor = typename TensorReshapeOp::Adaptor>
 class BufferizeTensorReshapeOp : public OpConversionPattern<TensorReshapeOp> {
 public:
   using OpConversionPattern<TensorReshapeOp>::OpConversionPattern;
   using ReshapeOp = typename std::conditional_t<
       std::is_same<TensorReshapeOp, TensorExpandShapeOp>::value,
       memref::ExpandShapeOp, memref::CollapseShapeOp>;
 
   LogicalResult
-  matchAndRewrite(TensorReshapeOp op, ArrayRef<Value> operands,
+  matchAndRewrite(TensorReshapeOp op, Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    Adaptor adaptor(operands, op->getAttrDictionary());
     rewriter.replaceOpWithNewOp<ReshapeOp>(op,
                                            this->getTypeConverter()
                                                ->convertType(op.getType())
                                                .template cast<MemRefType>(),
                                            adaptor.src(),
                                            adaptor.reassociation());
     return success();
   }
 };
 
 /// Conversion pattern that bufferizes `linalg.fill` operation.
 class BufferizeFillOp : public OpConversionPattern<FillOp> {
 public:
   using OpConversionPattern<FillOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(FillOp op, ArrayRef<Value> operands,
+  matchAndRewrite(FillOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    linalg::FillOpAdaptor adaptor(operands, op->getAttrDictionary());
     if (!op.output().getType().isa<TensorType>())
       return rewriter.notifyMatchFailure(op,
                                          "operand must be of a tensor type");
 
     rewriter.create<FillOp>(op.getLoc(), adaptor.value(), adaptor.output());
     rewriter.replaceOp(op, adaptor.output());
 
     return success();

 /// This pattern is arguable a std pattern once linalg::CopyOp becomes
 /// std::CopyOp.
 class ExtractSliceOpConverter
     : public OpConversionPattern<tensor::ExtractSliceOp> {
 public:
   using OpConversionPattern<tensor::ExtractSliceOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(tensor::ExtractSliceOp op, ArrayRef<Value> operands,
+  matchAndRewrite(tensor::ExtractSliceOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    tensor::ExtractSliceOpAdaptor adaptor(operands, op->getAttrDictionary());
     Value sourceMemref = adaptor.source();
     assert(sourceMemref.getType().isa<MemRefType>());
 
     MemRefType subviewMemRefType =
         getTypeConverter()->convertType(op.getType()).cast<MemRefType>();
     // op.sizes() capture exactly the dynamic alloc operands matching the
     // subviewMemRefType thanks to subview/slice canonicalization and
     // verification.

mlir/lib/Dialect/Linalg/Transforms/Detensorize.cpp

return genericOp &&
              });
 }
 
 /// A conversion patttern for detensoring `linalg.generic` ops.
 class DetensorizeGenericOp : public OpConversionPattern<GenericOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(GenericOp op, ArrayRef<Value> operands,
+  matchAndRewrite(GenericOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Block *originalBlock = op->getBlock();
 
     // Gather some information about the op before inling its region.
     Block *opEntryBlock = &*op.region().begin();
     YieldOp yieldOp = dyn_cast<YieldOp>(op.region().back().getTerminator());
 
     // Split the op's region before the op. This way, we have a clear insertion
     // point in which the op can be inlined.
     Block *newBlock = originalBlock->splitBlock(op);
     rewriter.inlineRegionBefore(op.region(), newBlock);
     // Now that op's region is inlined, the operands of its YieldOp are mapped
     // to the materialized target values. Therefore, we can replace the op's
     // uses with those of its YielOp's operands.
     rewriter.replaceOp(op, yieldOp->getOperands());
 
     // No need for these intermediate blocks, merge them into 1.
-    rewriter.mergeBlocks(opEntryBlock, originalBlock, operands);
+    rewriter.mergeBlocks(opEntryBlock, originalBlock, adaptor.getOperands());
     rewriter.mergeBlocks(newBlock, originalBlock, {});
 
     rewriter.eraseOp(&*Block::iterator(yieldOp));
 
     return success();
   }
 };
 

mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp

 using namespace mlir;
 using namespace mlir::scf;
 
 namespace {
 class ConvertForOpTypes : public OpConversionPattern<ForOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(ForOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ForOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     SmallVector<Type, 6> newResultTypes;
     for (auto type : op.getResultTypes()) {
       Type newType = typeConverter->convertType(type);
       if (!newType)
         return rewriter.notifyMatchFailure(op, "not a 1:1 type conversion");
       newResultTypes.push_back(newType);
     }
matchAndRewrite(ForOp op, OpAdaptor adaptor,
 
     // Convert the type of the entry block of the ForOp's body.
     if (failed(rewriter.convertRegionTypes(&newOp.getLoopBody(),
                                            *getTypeConverter()))) {
       return rewriter.notifyMatchFailure(op, "could not convert body types");
     }
     // Change the clone to use the updated operands. We could have cloned with
     // a BlockAndValueMapping, but this seems a bit more direct.
-    newOp->setOperands(operands);
+    newOp->setOperands(adaptor.getOperands());
     // Update the result types to the new converted types.
     for (auto t : llvm::zip(newOp.getResults(), newResultTypes))
       std::get<0>(t).setType(std::get<1>(t));
 
     rewriter.replaceOp(op, newOp.getResults());
     return success();
   }
 };
 } // namespace
 
 namespace {
 class ConvertIfOpTypes : public OpConversionPattern<IfOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(IfOp op, ArrayRef<Value> operands,
+  matchAndRewrite(IfOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // TODO: Generalize this to any type conversion, not just 1:1.
     //
     // We need to implement something more sophisticated here that tracks which
     // types convert to which other types and does the appropriate
     // materialization logic.
     // For example, it's possible that one result type converts to 0 types and
     // another to 2 types, so newResultTypes would at least be the right size to
matchAndRewrite(IfOp op, OpAdaptor adaptor,
     // then inline.
     IfOp newOp = cast<IfOp>(rewriter.cloneWithoutRegions(*op.getOperation()));
     rewriter.inlineRegionBefore(op.thenRegion(), newOp.thenRegion(),
                                 newOp.thenRegion().end());
     rewriter.inlineRegionBefore(op.elseRegion(), newOp.elseRegion(),
                                 newOp.elseRegion().end());
 
     // Update the operands and types.
-    newOp->setOperands(operands);
+    newOp->setOperands(adaptor.getOperands());
     for (auto t : llvm::zip(newOp.getResults(), newResultTypes))
       std::get<0>(t).setType(std::get<1>(t));
     rewriter.replaceOp(op, newOp.getResults());
     return success();
   }
 };
 } // namespace
 
 namespace {
 // When the result types of a ForOp/IfOp get changed, the operand types of the
 // corresponding yield op need to be changed. In order to trigger the
 // appropriate type conversions / materializations, we need a dummy pattern.
 class ConvertYieldOpTypes : public OpConversionPattern<scf::YieldOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(scf::YieldOp op, ArrayRef<Value> operands,
+  matchAndRewrite(scf::YieldOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<scf::YieldOp>(op, operands);
+    rewriter.replaceOpWithNewOp<scf::YieldOp>(op, adaptor.getOperands());
     return success();
   }
 };
 } // namespace
 
 namespace {
 class ConvertWhileOpTypes : public OpConversionPattern<WhileOp> {
 public:
   using OpConversionPattern<WhileOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(WhileOp op, ArrayRef<Value> operands,
+  matchAndRewrite(WhileOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto *converter = getTypeConverter();
     assert(converter);
     SmallVector<Type> newResultTypes;
     if (failed(converter->convertTypes(op.getResultTypes(), newResultTypes)))
       return failure();
 
-    WhileOp::Adaptor adaptor(operands);
     auto newOp = rewriter.create<WhileOp>(op.getLoc(), newResultTypes,
                                           adaptor.getOperands());
     for (auto i : {0u, 1u}) {
       auto &dstRegion = newOp.getRegion(i);
       rewriter.inlineRegionBefore(op.getRegion(i), dstRegion, dstRegion.end());
       if (failed(rewriter.convertRegionTypes(&dstRegion, *converter)))
         return rewriter.notifyMatchFailure(op, "could not convert body types");
     }
     rewriter.replaceOp(op, newOp.getResults());
     return success();
   }
 };
 } // namespace
 
 namespace {
 class ConvertConditionOpTypes : public OpConversionPattern<ConditionOp> {
 public:
   using OpConversionPattern<ConditionOp>::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(ConditionOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ConditionOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.updateRootInPlace(op, [&]() { op->setOperands(operands); });
+    rewriter.updateRootInPlace(
+        op, [&]() { op->setOperands(adaptor.getOperands()); });
     return success();
   }
 };
 } // namespace
 
 void mlir::scf::populateSCFStructuralTypeConversionsAndLegality(
     TypeConverter &typeConverter, RewritePatternSet &patterns,
     ConversionTarget &target) {

mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp

 /// variable ABI attributes attached to function arguments and converts all
 /// function argument uses to those global variables. This is necessary because
 /// Vulkan requires all shader entry points to be of void(void) type.
 class ProcessInterfaceVarABI final : public OpConversionPattern<spirv::FuncOp> {
 public:
   using OpConversionPattern<spirv::FuncOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(spirv::FuncOp funcOp, ArrayRef<Value> operands,
+  matchAndRewrite(spirv::FuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Pass to implement the ABI information specified as attributes.
 class LowerABIAttributesPass final
     : public SPIRVLowerABIAttributesBase<LowerABIAttributesPass> {
   void runOnOperation() override;
 };
 } // namespace
 
 LogicalResult ProcessInterfaceVarABI::matchAndRewrite(
-    spirv::FuncOp funcOp, ArrayRef<Value> operands,
+    spirv::FuncOp funcOp, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   if (!funcOp->getAttrOfType<spirv::EntryPointABIAttr>(
           spirv::getEntryPointABIAttrName())) {
     // TODO: Non-entry point functions are not handled.
     return failure();
   }
   TypeConverter::SignatureConversion signatureConverter(
       funcOp.getType().getNumInputs());

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

 namespace {
 /// A pattern for rewriting function signature to convert arguments of functions
 /// to be of valid SPIR-V types.
 class FuncOpConversion final : public OpConversionPattern<FuncOp> {
 public:
   using OpConversionPattern<FuncOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(FuncOp funcOp, ArrayRef<Value> operands,
+  matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult
-FuncOpConversion::matchAndRewrite(FuncOp funcOp, ArrayRef<Value> operands,
+FuncOpConversion::matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor,
                                   ConversionPatternRewriter &rewriter) const {
   auto fnType = funcOp.getType();
   if (fnType.getNumResults() > 1)
     return failure();
 
   TypeConverter::SignatureConversion signatureConverter(fnType.getNumInputs());
   for (auto argType : enumerate(fnType.getInputs())) {
     auto convertedType = getTypeConverter()->convertType(argType.value());

mlir/lib/Dialect/Shape/Transforms/StructuralTypeConversions.cpp

 using namespace mlir::shape;
 
 namespace {
 class ConvertAssumingOpTypes : public OpConversionPattern<AssumingOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(AssumingOp op, ArrayRef<Value> operands,
+  matchAndRewrite(AssumingOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     SmallVector<Type, 2> newResultTypes;
     newResultTypes.reserve(op.getNumResults());
     for (auto result : op.getResults()) {
       auto originalType = result.getType();
       Type convertedType = getTypeConverter()->convertType(originalType);
       newResultTypes.push_back(convertedType);
     }

 
 namespace {
 class ConvertAssumingYieldOpTypes
     : public OpConversionPattern<AssumingYieldOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(AssumingYieldOp op, ArrayRef<Value> operands,
+  matchAndRewrite(AssumingYieldOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
-    rewriter.replaceOpWithNewOp<AssumingYieldOp>(op, operands);
+    rewriter.replaceOpWithNewOp<AssumingYieldOp>(op, adaptor.getOperands());
     return success();
   }
 };
 } // namespace
 
 void mlir::populateShapeStructuralTypeConversionsAndLegality(
     TypeConverter &typeConverter, RewritePatternSet &patterns,
     ConversionTarget &target) {

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp

 // Conversion rules.
 //===----------------------------------------------------------------------===//
 
 /// Sparse conversion rule for returns.
 class SparseReturnConverter : public OpConversionPattern<ReturnOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(ReturnOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ReturnOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<ReturnOp>(op, operands);
+    rewriter.replaceOpWithNewOp<ReturnOp>(op, adaptor.getOperands());
     return success();
   }
 };
 
 /// Sparse conversion rule for dimension accesses.
 class SparseTensorToDimSizeConverter
     : public OpConversionPattern<tensor::DimOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tensor::DimOp op, ArrayRef<Value> operands,
+  matchAndRewrite(tensor::DimOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type resType = op.getType();
     auto enc = getSparseTensorEncoding(op.source().getType());
     if (!enc)
       return failure();
     // Permute the dim index.
     Optional<int64_t> index = op.getConstantIndex();
     if (!index.hasValue())
       return failure();
     int64_t idx = index.getValue();
     if (AffineMap p = enc.getDimOrdering())
       idx = p.getPermutedPosition(idx);
     // Generate the call.
     StringRef name = "sparseDimSize";
     SmallVector<Value, 2> params;
-    params.push_back(operands[0]);
+    params.push_back(adaptor.getOperands()[0]);
     params.push_back(
         rewriter.create<ConstantOp>(op.getLoc(), rewriter.getIndexAttr(idx)));
     rewriter.replaceOpWithNewOp<CallOp>(
         op, resType, getFunc(op, name, resType, params), params);
     return success();
   }
 };
 
 /// Sparse conversion rule for the new operator.
 class SparseTensorNewConverter : public OpConversionPattern<NewOp> {
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(NewOp op, ArrayRef<Value> operands,
+  matchAndRewrite(NewOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type resType = op.getType();
     auto enc = getSparseTensorEncoding(resType);
     if (!enc)
       return failure();
     Value perm;
-    rewriter.replaceOp(op, genNewCall(rewriter, op, enc, 0, perm, operands[0]));
+    rewriter.replaceOp(
+        op, genNewCall(rewriter, op, enc, 0, perm, adaptor.getOperands()[0]));
     return success();
   }
 };
 
 /// Sparse conversion rule for the convert operator.
 class SparseTensorConvertConverter : public OpConversionPattern<ConvertOp> {
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(ConvertOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ConvertOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type resType = op.getType();
     auto encDst = getSparseTensorEncoding(resType);
     auto encSrc = getSparseTensorEncoding(op.source().getType());
     if (encDst && encSrc) {
       // This is a sparse => sparse conversion, which is handled as follows:
       //   t = src->asCOO();         ; src to COO in dst order
       //   dst = newSparseTensor(t)
       // Using the coordinate scheme as an intermediate does not always
       // yield the fastest conversion but avoids the need for a full
       // O(N^2) conversion matrix.
       Value perm;
-      Value coo = genNewCall(rewriter, op, encDst, 3, perm, operands[0]);
+      Value coo =
+          genNewCall(rewriter, op, encDst, 3, perm, adaptor.getOperands()[0]);
       rewriter.replaceOp(op, genNewCall(rewriter, op, encDst, 1, perm, coo));
       return success();
     }
     if (!encDst || encSrc) {
       // TODO: sparse => dense
       return failure();
     }
     // This is a dense => sparse conversion, which is handled as follows:
matchAndRewrite(ConvertOp op, OpAdaptor adaptor,
     // using MLIR IR to avoid having to expose too much low-level
     // memref traversal details to the runtime support library.
     Location loc = op->getLoc();
     ShapedType shape = resType.cast<ShapedType>();
     auto memTp =
         MemRefType::get({ShapedType::kDynamicSize}, rewriter.getIndexType());
     Value perm;
     Value ptr = genNewCall(rewriter, op, encDst, 2, perm);
-    Value tensor = operands[0];
+    Value tensor = adaptor.getOperands()[0];
     Value arg = rewriter.create<ConstantOp>(
         loc, rewriter.getIndexAttr(shape.getRank()));
     Value ind = rewriter.create<memref::AllocaOp>(loc, memTp, ValueRange{arg});
     SmallVector<Value> lo;
     SmallVector<Value> hi;
     SmallVector<Value> st;
     Value zero = rewriter.create<ConstantOp>(loc, rewriter.getIndexAttr(0));
     Value one = rewriter.create<ConstantOp>(loc, rewriter.getIndexAttr(1));

 };
 
 /// Sparse conversion rule for pointer accesses.
 class SparseTensorToPointersConverter
     : public OpConversionPattern<ToPointersOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(ToPointersOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ToPointersOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type resType = op.getType();
     Type eltType = resType.cast<ShapedType>().getElementType();
     StringRef name;
     if (eltType.isIndex())
       name = "sparsePointers";
     else if (eltType.isInteger(64))
       name = "sparsePointers64";
     else if (eltType.isInteger(32))
       name = "sparsePointers32";
     else if (eltType.isInteger(16))
       name = "sparsePointers16";
     else if (eltType.isInteger(8))
       name = "sparsePointers8";
     else
       return failure();
     rewriter.replaceOpWithNewOp<CallOp>(
-        op, resType, getFunc(op, name, resType, operands), operands);
+        op, resType, getFunc(op, name, resType, adaptor.getOperands()),
+        adaptor.getOperands());
     return success();
   }
 };
 
 /// Sparse conversion rule for index accesses.
 class SparseTensorToIndicesConverter : public OpConversionPattern<ToIndicesOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(ToIndicesOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ToIndicesOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type resType = op.getType();
     Type eltType = resType.cast<ShapedType>().getElementType();
     StringRef name;
     if (eltType.isIndex())
       name = "sparseIndices";
     else if (eltType.isInteger(64))
       name = "sparseIndices64";
     else if (eltType.isInteger(32))
       name = "sparseIndices32";
     else if (eltType.isInteger(16))
       name = "sparseIndices16";
     else if (eltType.isInteger(8))
       name = "sparseIndices8";
     else
       return failure();
     rewriter.replaceOpWithNewOp<CallOp>(
-        op, resType, getFunc(op, name, resType, operands), operands);
+        op, resType, getFunc(op, name, resType, adaptor.getOperands()),
+        adaptor.getOperands());
     return success();
   }
 };
 
 /// Sparse conversion rule for value accesses.
 class SparseTensorToValuesConverter : public OpConversionPattern<ToValuesOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(ToValuesOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ToValuesOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type resType = op.getType();
     Type eltType = resType.cast<ShapedType>().getElementType();
     StringRef name;
     if (eltType.isF64())
       name = "sparseValuesF64";
     else if (eltType.isF32())
       name = "sparseValuesF32";
     else if (eltType.isInteger(64))
       name = "sparseValuesI64";
     else if (eltType.isInteger(32))
       name = "sparseValuesI32";
     else if (eltType.isInteger(16))
       name = "sparseValuesI16";
     else if (eltType.isInteger(8))
       name = "sparseValuesI8";
     else
       return failure();
     rewriter.replaceOpWithNewOp<CallOp>(
-        op, resType, getFunc(op, name, resType, operands), operands);
+        op, resType, getFunc(op, name, resType, adaptor.getOperands()),
+        adaptor.getOperands());
     return success();
   }
 };
 
 /// Sparse conversion rule for tensor reconstruction.
 class SparseTensorToTensorConverter : public OpConversionPattern<ToTensorOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
   // Simply fold the operator into the pointer to the sparse storage scheme.
-  matchAndRewrite(ToTensorOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ToTensorOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Check that all arguments of the tensor reconstruction operators are calls
     // into the support library that query exactly the same opaque pointer.
     Value ptr;
-    for (Value op : operands) {
+    for (Value op : adaptor.getOperands()) {
       if (auto call = op.getDefiningOp<CallOp>()) {
         Value arg = call.getOperand(0);
         if (!arg.getType().isa<LLVM::LLVMPointerType>())
           return failure();
         if (!ptr)
           ptr = arg;
         else if (arg != ptr)
           return failure();

mlir/lib/Dialect/StandardOps/Transforms/Bufferize.cpp

 
 using namespace mlir;
 
 namespace {
 class BufferizeIndexCastOp : public OpConversionPattern<IndexCastOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(IndexCastOp op, ArrayRef<Value> operands,
+  matchAndRewrite(IndexCastOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    IndexCastOp::Adaptor adaptor(operands);
     auto tensorType = op.getType().cast<RankedTensorType>();
     rewriter.replaceOpWithNewOp<IndexCastOp>(
         op, adaptor.in(),
         MemRefType::get(tensorType.getShape(), tensorType.getElementType()));
     return success();
   }
 };
 
 class BufferizeSelectOp : public OpConversionPattern<SelectOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(SelectOp op, ArrayRef<Value> operands,
+  matchAndRewrite(SelectOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (!op.condition().getType().isa<IntegerType>())
       return rewriter.notifyMatchFailure(op, "requires scalar condition");
 
-    SelectOp::Adaptor adaptor(operands);
     rewriter.replaceOpWithNewOp<SelectOp>(
         op, adaptor.condition(), adaptor.true_value(), adaptor.false_value());
     return success();
   }
 };
 } // namespace
 
 void mlir::populateStdBufferizePatterns(BufferizeTypeConverter &typeConverter,

mlir/lib/Dialect/StandardOps/Transforms/DecomposeCallGraphTypes.cpp

 /// Expand function arguments according to the provided TypeConverter and
 /// ValueDecomposer.
 struct DecomposeCallGraphTypesForFuncArgs
     : public DecomposeCallGraphTypesOpConversionPattern<FuncOp> {
   using DecomposeCallGraphTypesOpConversionPattern::
       DecomposeCallGraphTypesOpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(FuncOp op, ArrayRef<Value> operands,
+  matchAndRewrite(FuncOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     auto functionType = op.getType();
 
     // Convert function arguments using the provided TypeConverter.
     TypeConverter::SignatureConversion conversion(functionType.getNumInputs());
     for (auto argType : llvm::enumerate(functionType.getInputs())) {
       SmallVector<Type, 2> decomposedTypes;
       if (failed(typeConverter->convertType(argType.value(), decomposedTypes)))

 namespace {
 /// Expand return operands according to the provided TypeConverter and
 /// ValueDecomposer.
 struct DecomposeCallGraphTypesForReturnOp
     : public DecomposeCallGraphTypesOpConversionPattern<ReturnOp> {
   using DecomposeCallGraphTypesOpConversionPattern::
       DecomposeCallGraphTypesOpConversionPattern;
   LogicalResult
-  matchAndRewrite(ReturnOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ReturnOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     SmallVector<Value, 2> newOperands;
-    for (Value operand : operands)
+    for (Value operand : adaptor.getOperands())
       decomposer.decomposeValue(rewriter, op.getLoc(), operand.getType(),
                                 operand, newOperands);
     rewriter.replaceOpWithNewOp<ReturnOp>(op, newOperands);
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // DecomposeCallGraphTypesForCallOp
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// Expand call op operands and results according to the provided TypeConverter
 /// and ValueDecomposer.
 struct DecomposeCallGraphTypesForCallOp
     : public DecomposeCallGraphTypesOpConversionPattern<CallOp> {
   using DecomposeCallGraphTypesOpConversionPattern::
       DecomposeCallGraphTypesOpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CallOp op, ArrayRef<Value> operands,
+  matchAndRewrite(CallOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
 
     // Create the operands list of the new `CallOp`.
     SmallVector<Value, 2> newOperands;
-    for (Value operand : operands)
+    for (Value operand : adaptor.getOperands())
       decomposer.decomposeValue(rewriter, op.getLoc(), operand.getType(),
                                 operand, newOperands);
 
     // Create the new result types for the new `CallOp` and track the indices in
     // the new call op's results that correspond to the old call op's results.
     //
     // expandedResultIndices[i] = "list of new result indices that old result i
     // expanded to".

mlir/lib/Dialect/StandardOps/Transforms/FuncConversions.cpp

 namespace {
 /// Converts the operand and result types of the Standard's CallOp, used
 /// together with the FuncOpSignatureConversion.
 struct CallOpSignatureConversion : public OpConversionPattern<CallOp> {
   using OpConversionPattern<CallOp>::OpConversionPattern;
 
   /// Hook for derived classes to implement combined matching and rewriting.
   LogicalResult
-  matchAndRewrite(CallOp callOp, ArrayRef<Value> operands,
+  matchAndRewrite(CallOp callOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Convert the original function results.
     SmallVector<Type, 1> convertedResults;
     if (failed(typeConverter->convertTypes(callOp.getResultTypes(),
                                            convertedResults)))
       return failure();
 
     // Substitute with the new result types from the corresponding FuncType
     // conversion.
-    rewriter.replaceOpWithNewOp<CallOp>(callOp, callOp.callee(),
-                                        convertedResults, operands);
+    rewriter.replaceOpWithNewOp<CallOp>(
+        callOp, callOp.callee(), convertedResults, adaptor.getOperands());
     return success();
   }
 };
 } // end anonymous namespace
 
 void mlir::populateCallOpTypeConversionPattern(RewritePatternSet &patterns,
                                                TypeConverter &converter) {
   patterns.add<CallOpSignatureConversion>(converter, patterns.getContext());

 /// Only needed to support partial conversion of functions where this pattern
 /// ensures that the branch operation arguments matches up with the succesor
 /// block arguments.
 class ReturnOpTypeConversion : public OpConversionPattern<ReturnOp> {
 public:
   using OpConversionPattern<ReturnOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(ReturnOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ReturnOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     // For a return, all operands go to the results of the parent, so
     // rewrite them all.
-    Operation *operation = op.getOperation();
-    rewriter.updateRootInPlace(
-        op, [operands, operation]() { operation->setOperands(operands); });
+    rewriter.updateRootInPlace(op,
+                               [&] { op->setOperands(adaptor.getOperands()); });
     return success();
   }
 };
 } // end anonymous namespace
 
 void mlir::populateBranchOpInterfaceTypeConversionPattern(
     RewritePatternSet &patterns, TypeConverter &typeConverter,
     function_ref<bool(BranchOpInterface, int)> shouldConvertBranchOperand) {

mlir/lib/Dialect/StandardOps/Transforms/TensorConstantBufferize.cpp

 class BufferizeTensorConstantOp : public OpConversionPattern<ConstantOp> {
 public:
   BufferizeTensorConstantOp(GlobalCreator &globals,
                             TypeConverter &typeConverter, MLIRContext *context)
       : OpConversionPattern<ConstantOp>(typeConverter, context, /*benefit=*/1),
         globals(globals) {}
 
   LogicalResult
-  matchAndRewrite(ConstantOp op, ArrayRef<Value> operands,
+  matchAndRewrite(ConstantOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto type = op.getType().dyn_cast<RankedTensorType>();
     if (!type)
       return failure();
 
     auto globalMemref = globals.getGlobalFor(op);
     rewriter.replaceOpWithNewOp<memref::GetGlobalOp>(op, globalMemref.type(),
                                                      globalMemref.getName());

mlir/lib/Dialect/Tensor/Transforms/Bufferize.cpp

 
 using namespace mlir;
 
 namespace {
 class BufferizeCastOp : public OpConversionPattern<tensor::CastOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tensor::CastOp op, ArrayRef<Value> operands,
+  matchAndRewrite(tensor::CastOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto resultType = getTypeConverter()->convertType(op.getType());
-    rewriter.replaceOpWithNewOp<memref::CastOp>(op, resultType, operands[0]);
+    rewriter.replaceOpWithNewOp<memref::CastOp>(op, resultType,
+                                                adaptor.getOperands()[0]);
     return success();
   }
 };
 } // namespace
 
 namespace {
 class BufferizeDimOp : public OpConversionPattern<tensor::DimOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tensor::DimOp op, ArrayRef<Value> operands,
+  matchAndRewrite(tensor::DimOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    tensor::DimOp::Adaptor adaptor(operands);
     rewriter.replaceOpWithNewOp<memref::DimOp>(op, adaptor.source(),
                                                adaptor.index());
     return success();
   }
 };
 } // namespace
 
 namespace {
 class BufferizeExtractOp : public OpConversionPattern<tensor::ExtractOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tensor::ExtractOp op, ArrayRef<Value> operands,
+  matchAndRewrite(tensor::ExtractOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    tensor::ExtractOp::Adaptor adaptor(operands);
     rewriter.replaceOpWithNewOp<memref::LoadOp>(op, adaptor.tensor(),
                                                 adaptor.indices());
     return success();
   }
 };
 } // namespace
 
 namespace {
 class BufferizeFromElementsOp
     : public OpConversionPattern<tensor::FromElementsOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tensor::FromElementsOp op, ArrayRef<Value> operands,
+  matchAndRewrite(tensor::FromElementsOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     int numberOfElements = op.elements().size();
     auto resultType = MemRefType::get(
         {numberOfElements}, op.getType().cast<TensorType>().getElementType());
     Value result = rewriter.create<memref::AllocOp>(op.getLoc(), resultType);
     for (auto element : llvm::enumerate(op.elements())) {
       Value index =
           rewriter.create<ConstantIndexOp>(op.getLoc(), element.index());
       rewriter.create<memref::StoreOp>(op.getLoc(), element.value(), result,
                                        index);
     }
     rewriter.replaceOp(op, {result});
     return success();
   }
 };
 } // namespace
 
 namespace {
 class BufferizeGenerateOp : public OpConversionPattern<tensor::GenerateOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(tensor::GenerateOp op, ArrayRef<Value> operands,
+  matchAndRewrite(tensor::GenerateOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     // Allocate memory.
     Location loc = op.getLoc();
-    tensor::GenerateOp::Adaptor transformed(operands);
     RankedTensorType tensorType = op.getType().cast<RankedTensorType>();
     MemRefType memrefType =
         MemRefType::get(tensorType.getShape(), tensorType.getElementType());
-    Value result = rewriter.create<memref::AllocOp>(
-        loc, memrefType, transformed.dynamicExtents());
+    Value result = rewriter.create<memref::AllocOp>(loc, memrefType,
+                                                    adaptor.dynamicExtents());
 
     // Collect loop bounds.
     int64_t rank = tensorType.getRank();
     Value zero = rewriter.create<ConstantIndexOp>(loc, 0);
     Value one = rewriter.create<ConstantIndexOp>(loc, 1);
     SmallVector<Value, 4> lowerBounds(rank, zero);
     SmallVector<Value, 4> steps(rank, one);
     SmallVector<Value, 4> upperBounds;
     int nextDynamicIndex = 0;
     for (int i = 0; i < rank; i++) {
       Value upperBound =
           tensorType.isDynamicDim(i)
-              ? transformed.dynamicExtents()[nextDynamicIndex++]
+              ? adaptor.dynamicExtents()[nextDynamicIndex++]
               : rewriter.create<ConstantIndexOp>(loc, memrefType.getDimSize(i));
       upperBounds.push_back(upperBound);
     }
 
     // Generate tensor elements with a parallel loop that stores into
     // each element of the resulting memref.
     //
     // This is a bit tricky. We cannot simply clone the ops because when an op

mlir/lib/Dialect/X86Vector/Transforms/LegalizeForLLVMExport.cpp

explicit LowerToIntrinsic(LLVMTypeConverter &converter)
       : OpConversionPattern<OpTy>(converter, &converter.getContext()) {}
 
   LLVMTypeConverter &getTypeConverter() const {
     return *static_cast<LLVMTypeConverter *>(
         OpConversionPattern<OpTy>::getTypeConverter());
   }
 
   LogicalResult
-  matchAndRewrite(OpTy op, ArrayRef<Value> operands,
+  matchAndRewrite(OpTy op, typename OpTy::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type elementType = getSrcVectorElementType<OpTy>(op);
     unsigned bitwidth = elementType.getIntOrFloatBitWidth();
     if (bitwidth == 32)
       return LLVM::detail::oneToOneRewrite(op, Intr32OpTy::getOperationName(),
-                                           operands, getTypeConverter(),
-                                           rewriter);
+                                           adaptor.getOperands(),
+                                           getTypeConverter(), rewriter);
     if (bitwidth == 64)
       return LLVM::detail::oneToOneRewrite(op, Intr64OpTy::getOperationName(),
-                                           operands, getTypeConverter(),
-                                           rewriter);
+                                           adaptor.getOperands(),
+                                           getTypeConverter(), rewriter);
     return rewriter.notifyMatchFailure(
         op, "expected 'src' to be either f32 or f64");
   }
 };
 
 struct MaskCompressOpConversion
     : public ConvertOpToLLVMPattern<MaskCompressOp> {
   using ConvertOpToLLVMPattern<MaskCompressOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(MaskCompressOp op, ArrayRef<Value> operands,
+  matchAndRewrite(MaskCompressOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    MaskCompressOp::Adaptor adaptor(operands);
     auto opType = adaptor.a().getType();
 
     Value src;
     if (op.src()) {
       src = adaptor.src();
     } else if (op.constant_src()) {
       src = rewriter.create<ConstantOp>(op.getLoc(), opType,
                                         op.constant_srcAttr());
     } else {
       Attribute zeroAttr = rewriter.getZeroAttr(opType);
       src = rewriter.create<ConstantOp>(op->getLoc(), opType, zeroAttr);
     }
 
     rewriter.replaceOpWithNewOp<MaskCompressIntrOp>(op, opType, adaptor.a(),
                                                     src, adaptor.k());
 
     return success();
   }
 };
 
 struct RsqrtOpConversion : public ConvertOpToLLVMPattern<RsqrtOp> {
   using ConvertOpToLLVMPattern<RsqrtOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(RsqrtOp op, ArrayRef<Value> operands,
+  matchAndRewrite(RsqrtOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    RsqrtOp::Adaptor adaptor(operands);
-
     auto opType = adaptor.a().getType();
     rewriter.replaceOpWithNewOp<RsqrtIntrOp>(op, opType, adaptor.a());
     return success();
   }
 };
 
 struct DotOpConversion : public ConvertOpToLLVMPattern<DotOp> {
   using ConvertOpToLLVMPattern<DotOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(DotOp op, ArrayRef<Value> operands,
+  matchAndRewrite(DotOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    DotOp::Adaptor adaptor(operands);
     auto opType = adaptor.a().getType();
     Type llvmIntType = IntegerType::get(&getTypeConverter()->getContext(), 8);
     // Dot product of all elements, broadcasted to all elements.
     auto attr = rewriter.getI8IntegerAttr(static_cast<int8_t>(0xff));
     Value scale =
         rewriter.create<LLVM::ConstantOp>(op.getLoc(), llvmIntType, attr);
     rewriter.replaceOpWithNewOp<DotIntrOp>(op, opType, adaptor.a(), adaptor.b(),
                                            scale);

mlir/lib/Transforms/Bufferize.cpp

 
 namespace {
 // In a finalizing bufferize conversion, we know that all tensors have been
 // converted to memrefs, thus, this op becomes an identity.
 class BufferizeTensorLoadOp : public OpConversionPattern<memref::TensorLoadOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(memref::TensorLoadOp op, ArrayRef<Value> operands,
+  matchAndRewrite(memref::TensorLoadOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    memref::TensorLoadOp::Adaptor adaptor(operands);
     rewriter.replaceOp(op, adaptor.memref());
     return success();
   }
 };
 } // namespace
 
 namespace {
 // In a finalizing bufferize conversion, we know that all tensors have been
 // converted to memrefs, thus, this op becomes an identity.
 class BufferizeCastOp : public OpConversionPattern<memref::BufferCastOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(memref::BufferCastOp op, ArrayRef<Value> operands,
+  matchAndRewrite(memref::BufferCastOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    memref::BufferCastOp::Adaptor adaptor(operands);
     rewriter.replaceOp(op, adaptor.tensor());
     return success();
   }
 };
 } // namespace
 
 void mlir::populateEliminateBufferizeMaterializationsPatterns(
     BufferizeTypeConverter &typeConverter, RewritePatternSet &patterns) {