[mlir][vector] Use transform.apply_patterns in vector tests

[springerm]

Summary

All vector transform ops are now PatternDescriptorOpInterface ops that merely select the patterns. The patterns are applied by the apply_patterns op. This is to ensure that ops are properly tracked. (TrackingListener is used in the implementation of apply_patterns.) Furthermore, handles are no longer invalidated when applying patterns in the vector tests.

Depends On: D152167

[nicolasvasilache]

nice cleanup, thanks!

mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h

public:
   ///   6. Otherwise the transformation is considered successful.
   DiagnosedSilenceableFailure apply(TransformResults &transformResults,
                                     TransformState &state);
 
   /// Checks that the op matches the expectations of this trait.
   static LogicalResult verifyTrait(Operation *op);
 };
 
-/// Trait implementing the applyToOne function required by TransformEachOpTrait
-/// by greedily applying a set of patterns to each target payload operation.
-/// This requires the transform operation to implement TransformEachOpTrait and
-/// to provide the following method:
-///   - void populatePatterns(RewritePatternSet &)
-/// that populates the given object with the patterns to apply. This is an
-/// instance method that can depend on the transform operation attributes.
-///
-/// The payload operation is expected to have the IsolatedFromAboveTrait, which
-/// is a requirement of the pattern rewriter. If it does not, or if pattern
-/// application fails, the transform fails definitively as the rewriter will
-/// have likely left the payload IR in some intermediate state that precludes
-/// further transformation.
-template <typename OpTy>
-class TransformWithPatternsOpTrait
-    : public OpTrait::TraitBase<OpTy, TransformWithPatternsOpTrait> {
-public:
-  DiagnosedSilenceableFailure applyToOne(Operation *target,
-                                         ApplyToEachResultList &results,
-                                         TransformState &state);
-
-  static LogicalResult verifyTrait(Operation *op);
-};
-
 /// Side effect resource corresponding to the mapping between Transform IR
 /// values and Payload IR operations. An Allocate effect from this resource
 /// means creating a new mapping entry, it is always accompanied by a Write
 /// effect. A Read effect from this resource means accessing the mapping. A Free
 /// effect on this resource indicates the removal of the mapping entry,
 /// typically after a transformation that modifies the Payload IR operations
 /// associated with one of the Transform IR operation's operands. It is always
 /// accompanied by a Read effect. Read-after-Free and double-Free are not
applyTransformToEach(TransformOpTy transformOp, Range &&targets,
   }
   if (!silenceableStack.empty()) {
     return DiagnosedSilenceableFailure::silenceableFailure(
         std::move(silenceableStack));
   }
   return DiagnosedSilenceableFailure::success();
 }
 
-/// Applies patterns configured by `populatePatterns` greedily to the contents
-/// of `target`. Reports (definite) errors at the location of `transformOp`.
-/// Sets up `results` to point to `target` after pattern application on success.
-DiagnosedSilenceableFailure transformWithPatternsApply(
-    Operation *transformOp, Operation *target, ApplyToEachResultList &results,
-    TransformState &state,
-    function_ref<void(RewritePatternSet &)> populatePatterns);
-
 } // namespace detail
 } // namespace transform
 } // namespace mlir
 
 template <typename OpTy>
 mlir::DiagnosedSilenceableFailure
 mlir::transform::TransformEachOpTrait<OpTy>::apply(
     TransformResults &transformResults, TransformState &state) {
mlir::transform::TransformEachOpTrait<OpTy>::verifyTrait(Operation *op) {
   if (!op->getName().getInterface<TransformOpInterface>()) {
     return op->emitError() << "TransformEachOpTrait should only be attached to "
                               "ops that implement TransformOpInterface";
   }
 
   return success();
 }
 
-template <typename OpTy>
-mlir::DiagnosedSilenceableFailure
-mlir::transform::TransformWithPatternsOpTrait<OpTy>::applyToOne(
-    Operation *target, ApplyToEachResultList &results, TransformState &state) {
-  return detail::transformWithPatternsApply(
-      this->getOperation(), target, results, state,
-      [this](RewritePatternSet &patterns) {
-        cast<OpTy>(this->getOperation()).populatePatterns(patterns);
-      });
-}
-
-template <typename OpTy>
-mlir::LogicalResult
-mlir::transform::TransformWithPatternsOpTrait<OpTy>::verifyTrait(
-    Operation *op) {
-  if (!op->hasTrait<mlir::transform::TransformEachOpTrait>()) {
-    return op->emitOpError()
-           << "TransformWithPatternsOpTrait requires TransformEachOpTrait";
-  }
-  return success();
-}
-
 #endif // DIALECT_TRANSFORM_IR_TRANSFORMINTERFACES_H

mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.td

def FunctionalStyleTransformOpTrait
     : NativeOpTrait<"FunctionalStyleTransformOpTrait"> {
   let cppNamespace = "::mlir::transform";
 }
 
 def TransformEachOpTrait : NativeOpTrait<"TransformEachOpTrait"> {
   let cppNamespace = "::mlir::transform";
 }
 
-def TransformWithPatternsOpTrait : NativeOpTrait<"TransformWithPatternsOpTrait"> {
-  let cppNamespace = "::mlir::transform";
-}
-
 def NavigationTransformOpTrait : NativeOpTrait<"NavigationTransformOpTrait"> {
   let cppNamespace = "::mlir::transform";
 }
 
 def ParamProducerTransformOpTrait : NativeOpTrait<"ParamProducerTransformOpTrait"> {
   let cppNamespace = "::mlir::transform";
 }
 

mlir/include/mlir/Dialect/Vector/TransformOps/VectorTransformOps.td

 #define VECTOR_TRANSFORM_OPS
 
 include "mlir/Dialect/Transform/IR/TransformDialect.td"
 include "mlir/Dialect/Transform/IR/TransformInterfaces.td"
 include "mlir/Dialect/Vector/Transforms/VectorTransformsBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/IR/OpBase.td"
 
-// TODO: not isolated from above and better targetability of the op.
-// TODO: not a functional-style transform.
-class TransformWithPatternsOp<string opname, list<Trait> traits = []>
-    : Op<Transform_Dialect, opname,
-         !listconcat([TransformOpInterface,
-                      TransformEachOpTrait,
-                      TransformWithPatternsOpTrait,
-                      MemoryEffectsOpInterface,
-                      FunctionalStyleTransformOpTrait], traits)> {
-  let extraClassDeclaration = [{
-    void populatePatterns(RewritePatternSet &patterns);
-  }];
-}
-
-def ApplyRankReducingSubviewPatternsOp : 
-  TransformWithPatternsOp<"vector.apply_rank_reducing_subview_patterns"> {
+def ApplyRankReducingSubviewPatternsOp : Op<Transform_Dialect,
+    "apply_patterns.vector.apply_rank_reducing_subview_patterns",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
     Apply opt-in vector transfer permutation patterns that include:
       - TransferReadDropUnitDimsPattern
       - TransferWriteDropUnitDimsPattern
-    
-    These patterns have the effect of rewriting a vector.transfer with unit 
+    These patterns have the effect of rewriting a vector.transfer with unit
     dimensions into a rank-reduced version thanks to subview operations.
     This is complemented by shape_cast folding patterns.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target);
-  let results = (outs TransformHandleTypeInterface:$results);
-
-  let assemblyFormat = [{
-    $target
-    attr-dict
-    `:` functional-type($target, results)
-  }];
+  let assemblyFormat = "attr-dict";
 }
 
-def ApplyTransferPermutationPatternsOp : 
-  TransformWithPatternsOp<"vector.apply_transfer_permutation_patterns"> {
+def ApplyTransferPermutationPatternsOp : Op<Transform_Dialect,
+    "apply_patterns.vector.apply_transfer_permutation_patterns",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
     Apply opt-in vector transfer permutation patterns that include:
       - TransferReadPermutationLowering
       - TransferWritePermutationLowering
       - TransferOpReduceRank
       - TransferWriteNonPermutationLowering
-    
-    These patterns have the effect of rewriting a vector.transfer with an 
-    arbitrary permutation_map to a vector.transfer with a permutation_map that is
-    a minor identity followed by a vector.transpose.
+    These patterns have the effect of rewriting a vector.transfer with an
+    arbitrary permutation_map to a vector.transfer with a permutation_map that
+    is a minor identity followed by a vector.transpose.
 
     In other words, this makes the vector.transfer contiguous on the most minor
     dimensions and materializes the permutation_map as a vector.transpose.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target);
-  let results = (outs TransformHandleTypeInterface:$results);
-
-  let assemblyFormat = [{
-    $target
-    attr-dict
-    `:` functional-type($target, results)
-  }];
+  let assemblyFormat = "attr-dict";
 }
 
-def LowerBroadcastOp : TransformWithPatternsOp<"vector.lower_broadcast"> {
+def LowerBroadcastOp : Op<Transform_Dialect,
+    "apply_patterns.vector.lower_broadcast",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that the vector outerproduct operations nested under the isolated
-    from above op `target` should be lowered to finer-grained vector primitives.
+    Indicates that vector broadcast operations should be lowered to
+    finer-grained vector primitives.
 
     This is usally a late step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target);
-  let results = (outs TransformHandleTypeInterface:$results);
-
-  let assemblyFormat = [{
-    $target
-    attr-dict
-    `:` functional-type($target, results)
-  }];
+  let assemblyFormat = "attr-dict";
 }
 
 // TODO: evolve lowering_strategy to proper enums.
-def LowerContractionOp : TransformWithPatternsOp<"vector.lower_contraction"> {
+def LowerContractionOp : Op<Transform_Dialect,
+    "apply_patterns.vector.lower_contraction",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that the vector contraction-like operations nested under the 
-    isolated from above op `target` should be lowered to finer-grained vector
-    primitives.
+    Indicates that vector contraction-like operations should be lowered to
+    finer-grained vector primitives.
 
     This is usually a late step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target,
-     DefaultValuedAttr<VectorContractLoweringAttr,
-       "vector::VectorContractLowering::OuterProduct">:$lowering_strategy
+  let arguments = (ins DefaultValuedAttr<VectorContractLoweringAttr,
   );
-  let results = (outs TransformHandleTypeInterface:$results);
-
   let assemblyFormat = [{
-    $target
-    (`lowering_strategy` `=` $lowering_strategy^)?
-    attr-dict
-    `:` functional-type($target, results)
+    (`lowering_strategy` `=` $lowering_strategy^)? attr-dict
   }];
 }
 
-def LowerMasksOp : TransformWithPatternsOp<"vector.lower_masks"> {
+def LowerMasksOp : Op<Transform_Dialect,
+    "apply_patterns.vector.lower_masks",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that the vector.create_mask and vector.constant_mask operations
-    nested under the isolated from above op `target` should be lowered to
-    finer-grained vector primitives.
+    Indicates that vector.create_mask and vector.constant_mask operations
+    should be lowered to finer-grained vector primitives.
 
     This is usually a late step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target);
-  let results = (outs TransformHandleTypeInterface:$results);
-
-  let assemblyFormat = [{
-    $target
-    attr-dict
-    `:` functional-type($target, results)
-  }];
+  let assemblyFormat = "attr-dict";
 }
 
-def LowerMaskedTransfersOp : TransformWithPatternsOp<"vector.lower_masked_transfers"> {
+def LowerMaskedTransfersOp : Op<Transform_Dialect,
+    "apply_patterns.vector.lower_masked_transfers",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that masked vector.transfer and vector.gather operations nested
-    under the isolated from above op `target` should be lowered to finer-grained
-    vector primitives.
+    Indicates that masked vector.transfer and vector.gather operations should
+    be lowered to finer-grained vector primitives.
 
     This is usually a late step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target);
-  let results = (outs TransformHandleTypeInterface:$results);
-
-  let assemblyFormat = [{
-    $target
-    attr-dict
-    `:` functional-type($target, results)
-  }];
+  let assemblyFormat = "attr-dict";
 }
 
-def MaterializeMasksOp : TransformWithPatternsOp<"vector.materialize_masks"> {
+def MaterializeMasksOp : Op<Transform_Dialect,
+    "apply_patterns.vector.materialize_masks",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that mask operations nested under the isolated from above op 
-    `target` should be lowered to fine-grained arithemtic operations.
+    Indicates that mask operations should be lowered to fine-grained arithemtic
+    operations.
 
     This is usually the last step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target);
-  let results = (outs TransformHandleTypeInterface:$results);
-
-  let assemblyFormat = [{
-    $target
-    attr-dict
-    `:` functional-type($target, results)
-  }];
+  let assemblyFormat = "attr-dict";
 }
 
 // TODO: evolve lowering_strategy to proper enums.
-def LowerMultiReductionOp
-    : TransformWithPatternsOp<"vector.lower_multi_reduction"> {
+def LowerMultiReductionOp : Op<Transform_Dialect,
+    "apply_patterns.vector.lower_multi_reduction",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that the vector multi_reduction-like operations nested under the 
-    isolated from above op `target` should be lowered to finer-grained vector
-    primitives.
+    Indicates that vector multi_reduction-like operations should be lowered to
+    finer-grained vector primitives.
 
     This is usually a late step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target,
-     DefaultValuedAttr<VectorMultiReductionLoweringAttr,
-       "vector::VectorMultiReductionLowering::InnerParallel">:
-         $lowering_strategy
+  let arguments = (ins DefaultValuedAttr<VectorMultiReductionLoweringAttr,
+      "vector::VectorMultiReductionLowering::InnerParallel">:$lowering_strategy
   );
-  let results = (outs TransformHandleTypeInterface:$results);
 
   let assemblyFormat = [{
-    $target
-    (`lowering_strategy` `=` $lowering_strategy^)?
-    attr-dict
-    `:` functional-type($target, results)
+    (`lowering_strategy` `=` $lowering_strategy^)? attr-dict
   }];
 }
 
-def LowerOuterProductOp : TransformWithPatternsOp<"vector.lower_outerproduct"> {
+def LowerOuterProductOp : Op<Transform_Dialect,
+    "apply_patterns.vector.lower_outerproduct",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that the vector outerproduct operations nested under the isolated
-    from above op `target` should be lowered to finer-grained vector primitives.
+    Indicates that the vector outerproduct operations should be lowered to
+    finer-grained vector primitives.
 
     This is usually a late step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target);
-  let results = (outs TransformHandleTypeInterface:$results);
-
-  let assemblyFormat = [{
-    $target
-    attr-dict
-    `:` functional-type($target, results)
-  }];
+  let assemblyFormat = "attr-dict";
 }
 
-def LowerShapeCastOp : TransformWithPatternsOp<"vector.lower_shape_cast"> {
+def LowerShapeCastOp : Op<Transform_Dialect,
+    "apply_patterns.vector.lower_shape_cast",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that the vector shape_cast operations nested under the 
-    isolated from above op `target` should be lowered to finer-grained vector
-    primitives.
+    Indicates that vector shape_cast operations should be lowered to
+    finer-grained vector primitives.
 
     This is usually a late step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target);
-  let results = (outs TransformHandleTypeInterface:$results);
-
-  let assemblyFormat = [{
-    $target
-    attr-dict
-    `:` functional-type($target, results)
-  }];
+  let assemblyFormat = "attr-dict";
 }
 
-def LowerTransferOp : TransformWithPatternsOp<"vector.lower_transfer"> {
+def LowerTransferOp : Op<Transform_Dialect,
+    "apply_patterns.vector.lower_transfer",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that the vector transfer operations nested under the 
-    isolated from above op `target` should be lowered to finer-grained vector
-    primitives.
+    Indicates that vector transfer operations should be lowered to finer-grained
+    vector primitives.
 
     This is usually a late step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target,
-     DefaultValuedAttr<I64Attr, "1">:$max_transfer_rank
-  );
-  let results = (outs TransformHandleTypeInterface:$results);
+  let arguments = (ins DefaultValuedAttr<I64Attr, "1">:$max_transfer_rank);
 
   let assemblyFormat = [{
-    $target
-    (`max_transfer_rank` `=` $max_transfer_rank^)?
-    attr-dict
-    `:` functional-type($target, results)
+    (`max_transfer_rank` `=` $max_transfer_rank^)? attr-dict
   }];
 }
 
 // TODO: evolve lowering_strategy to proper enums.
-def LowerTransposeOp : TransformWithPatternsOp<"vector.lower_transpose"> {
+def LowerTransposeOp : Op<Transform_Dialect,
+    "apply_patterns.vector.lower_transpose",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that the vector transpose-like operations nested under the 
-    isolated from above op `target` should be lowered to finer-grained vector
-    primitives.
+    Indicates that vector transpose-like operations should be lowered to
+    finer-grained vector primitives.
 
     This is usually a late step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target,
+  let arguments = (ins
      DefaultValuedAttr<VectorTransposeLoweringAttr,
        "vector::VectorTransposeLowering::EltWise">:$lowering_strategy,
      DefaultValuedAttr<BoolAttr, "false">:$avx2_lowering_strategy
   );
-  let results = (outs TransformHandleTypeInterface:$results);
 
   let assemblyFormat = [{
-    $target
     oilist (
       `lowering_strategy` `=` $lowering_strategy
       | `avx2_lowering_strategy` `=` $avx2_lowering_strategy
     )
     attr-dict
-    `:` functional-type($target, results)
   }];
 }
 
 // TODO: evolve split_transfer_strategy to proper enums.
-def SplitTransferFullPartialOp
-    : TransformWithPatternsOp<"vector.split_transfer_full_partial"> {
+def SplitTransferFullPartialOp : Op<Transform_Dialect,
+    "apply_patterns.vector.split_transfer_full_partial",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that the vector transfer operations nested under the 
-    isolated from above op `target` should be split to full and partial parts.
+    Indicates that vector transfer operations should be split to full and
+    partial parts.
 
     This is usually a late step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target,
+  let arguments = (ins
      DefaultValuedAttr<VectorTransferSplitAttr,
        "vector::VectorTransferSplit::LinalgCopy">:$split_transfer_strategy
   );
-  let results = (outs TransformHandleTypeInterface:$results);
 
   let assemblyFormat = [{
-    $target
-    (`split_transfer_strategy` `=` $split_transfer_strategy^)?
-    attr-dict
-    `:` functional-type($target, results)
+    (`split_transfer_strategy` `=` $split_transfer_strategy^)? attr-dict
   }];
 }
 
-def TransferToScfOp : TransformWithPatternsOp<"vector.transfer_to_scf"> {
+def TransferToScfOp : Op<Transform_Dialect,
+    "apply_patterns.vector.transfer_to_scf",
+    [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
-    Indicates that the vector transfer operations nested under the 
-    isolated from above op `target` should be rewritten with scf.for loops over
-    finer-grained vector primitives.
+    Indicates that vector transfer operations should be rewritten with scf.for
+    loops over finer-grained vector primitives.
 
     This is usually a late step that is run after bufferization as part of the
     process of lowering to e.g. LLVM or NVVM.
   }];
 
-  let arguments = (ins TransformHandleTypeInterface:$target,
+  let arguments = (ins
      DefaultValuedAttr<I64Attr, "1">:$max_transfer_rank,
      DefaultValuedAttr<BoolAttr, "false">:$full_unroll
   );
-  let results = (outs TransformHandleTypeInterface:$results);
 
   let assemblyFormat = [{
-    $target
     oilist (
         `max_transfer_rank` `=` $max_transfer_rank
       | `full_unroll` `=` $full_unroll
     )
     attr-dict
-    `:` functional-type($target, results)
   }];
 }
 
 #endif // VECTOR_TRANSFORM_OPS

mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp

if (llvm::isa<TransformParamTypeInterface>(result.getType()))
       continue;
     return op->emitOpError()
            << "ParamProducerTransformOpTrait attached to this op expects "
               "result types to implement TransformParamTypeInterface";
   }
   return success();
 }
 
-DiagnosedSilenceableFailure transform::detail::transformWithPatternsApply(
-    Operation *transformOp, Operation *target, ApplyToEachResultList &results,
-    TransformState &state,
-    function_ref<void(RewritePatternSet &)> populatePatterns) {
-  if (!target->hasTrait<OpTrait::IsIsolatedFromAbove>()) {
-    return emitDefiniteFailure(transformOp)
-           << "applies only to isolated-from-above targets because it needs to "
-              "apply patterns greedily";
-  }
-  RewritePatternSet patterns(transformOp->getContext());
-  populatePatterns(patterns);
-  if (failed(applyPatternsAndFoldGreedily(target, std::move(patterns))))
-    return emitDefiniteFailure(transformOp) << "failed to apply patterns";
-
-  results.push_back(target);
-  return DiagnosedSilenceableFailure::success();
-}
-
 //===----------------------------------------------------------------------===//
 // Memory effects.
 //===----------------------------------------------------------------------===//
 
 void transform::consumesHandle(
     ValueRange handles,
     SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
   for (Value handle : handles) {

mlir/lib/Dialect/Transform/IR/TransformOps.cpp

if (!getRegion().empty()) {
     }
   }
 
   // Configure the GreedyPatternRewriteDriver.
   ErrorCheckingTrackingListener listener(state, *this);
   GreedyRewriteConfig config;
   config.listener = &listener;
 
+  LogicalResult result = failure();
+  if (target->hasTrait<OpTrait::IsIsolatedFromAbove>()) {
+    // Op is isolated from above. Apply patterns and also perform region
+    // simplification.
+    result = applyPatternsAndFoldGreedily(target, std::move(patterns), config);
+  } else {
     // Manually gather list of ops because the other GreedyPatternRewriteDriver
-  // overloads only accepts ops that are isolated from above. This way, patterns
-  // can be applied to ops that are not isolated from above.
+    // overloads only accepts ops that are isolated from above. This way,
+    // patterns can be applied to ops that are not isolated from above. Regions
+    // are not being simplified. Furthermore, only a single greedy rewrite
+    // iteration is performed.
     SmallVector<Operation *> ops;
     target->walk([&](Operation *nestedOp) {
       if (target != nestedOp)
         ops.push_back(nestedOp);
     });
-  LogicalResult result =
-      applyOpPatternsAndFold(ops, std::move(patterns), config);
+    result = applyOpPatternsAndFold(ops, std::move(patterns), config);
+  }
+
   // A failure typically indicates that the pattern application did not
   // converge.
   if (failed(result)) {
     return emitSilenceableFailure(target)
            << "greedy pattern application failed";
   }
 
   // Check listener state for tracking errors.

mlir/test/Dialect/LLVM/transform-e2e.mlir

%b = transform.bufferization.one_shot_bufferize layout{IdentityLayoutMap}
       %module_op {bufferize_function_boundaries = true}
       : (!transform.any_op) -> !transform.any_op
 
   %f = transform.structured.match ops{["func.func"]} in %b
     : (!transform.any_op) -> !transform.any_op
 
   // TODO: group these lower-level controls into various properly named vector
   // lowering TD macros.
-  %func = transform.vector.lower_contraction %f
-    lowering_strategy = "outerproduct"
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_2 = transform.vector.apply_transfer_permutation_patterns %func
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_3 = transform.vector.lower_multi_reduction %func_2
-    lowering_strategy = "innerparallel"
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_4 = transform.vector.split_transfer_full_partial %func_3
-    split_transfer_strategy = "linalg-copy"
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_5 = transform.vector.transfer_to_scf %func_4
-    max_transfer_rank = 1 full_unroll = true
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_6 = transform.vector.lower_transfer %func_5
-    max_transfer_rank = 1
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_7 = transform.vector.lower_shape_cast %func_6
-    : (!transform.any_op) -> !transform.any_op
-
-  %func_8 = transform.vector.lower_transpose %func_7
-    lowering_strategy = "shuffle_1d"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_contraction lowering_strategy = "outerproduct"
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.apply_transfer_permutation_patterns
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_multi_reduction lowering_strategy = "innerparallel"
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.split_transfer_full_partial split_transfer_strategy = "linalg-copy"
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.transfer_to_scf max_transfer_rank = 1 full_unroll = true
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_transfer max_transfer_rank = 1
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_shape_cast
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_transpose lowering_strategy = "shuffle_1d"
+  } : !transform.any_op
 }

mlir/test/Dialect/Linalg/transform-op-matmul-to-outerproduct.mlir

 // CHECK:           return
 // CHECK:         }
 
 transform.sequence failures(propagate) {
 ^bb1(%arg1: !transform.any_op):
   %0 = transform.structured.match ops{["linalg.matmul"]} in %arg1 : (!transform.any_op) -> !transform.any_op
   %1 = get_closest_isolated_parent %0 : (!transform.any_op) -> !transform.any_op
   %2 = transform.structured.vectorize %1 : (!transform.any_op) -> !transform.any_op
-  transform.vector.lower_contraction %2 lowering_strategy = "outerproduct" : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %2 {
+    transform.apply_patterns.vector.lower_contraction lowering_strategy = "outerproduct"
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/transform-vector.mlir

%b = transform.bufferization.one_shot_bufferize
       {bufferize_function_boundaries = true, allow_return_allocs = true}
       : (!transform.any_op) -> !transform.any_op
 
   %f = transform.structured.match ops{["func.func"]} in %b
     : (!transform.any_op) -> !transform.any_op
 
   // TODO: group these lower-level controls into various properly named vector
   // lowering TD macros.
-  %func = transform.vector.lower_contraction %f
-    lowering_strategy = "outerproduct"
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_2 = transform.vector.apply_transfer_permutation_patterns %func
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_3 = transform.vector.lower_multi_reduction %func_2
-    lowering_strategy = "innerparallel"
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_4 = transform.vector.split_transfer_full_partial %func_3
-    split_transfer_strategy = "linalg-copy"
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_5 = transform.vector.transfer_to_scf %func_4
-    max_transfer_rank = 1 full_unroll = true
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_6 = transform.vector.lower_transfer %func_5
-    max_transfer_rank = 1
-      : (!transform.any_op) -> !transform.any_op
-
-  %func_7 = transform.vector.lower_shape_cast %func_6
-    : (!transform.any_op) -> !transform.any_op
-
-  %func_8 = transform.vector.lower_transpose %func_7
-    lowering_strategy = "shuffle_1d"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_contraction lowering_strategy = "outerproduct"
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.apply_transfer_permutation_patterns
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_multi_reduction lowering_strategy = "innerparallel"
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.split_transfer_full_partial split_transfer_strategy = "linalg-copy"
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.transfer_to_scf max_transfer_rank = 1 full_unroll = true
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_transfer max_transfer_rank = 1
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_shape_cast
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_transpose lowering_strategy = "shuffle_1d"
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-broadcast-lowering-transforms.mlir

func.func @broadcast_stretch_in_middle(%arg0: vector<4x1x2xf32>) -> vector<4x3x2xf32> {
   return %0 : vector<4x3x2xf32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
   %f = transform.structured.match ops{["func.func"]} in %module_op 
     : (!transform.any_op) -> !transform.any_op
 
-  transform.vector.lower_broadcast %f
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_broadcast
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-contract-matvec-transforms.mlir

func.func @redpar_vecmattrans2x2(%arg0: memref<vector<2x2xf32>>, %arg1: memref<vector<2xf32>>,
   %b = memref.load %arg2[] : memref<vector<2xf32>>
   %0 = vector.contract #redpar_vecmattrans_trait %x, %A, %b : vector<2xf32>, vector<2x2xf32> into vector<2xf32>
   memref.store %0, %arg2[] : memref<vector<2xf32>>
   return
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.lower_contraction %module_op
-    lowering_strategy = "outerproduct"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_contraction lowering_strategy = "outerproduct"
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-contract-to-dot-transforms.mlir

func.func @contract_one_sided_unit_reduction_dim(%arg0 : vector<1x2xi32>, %arg1 : vector<2x2xi32>, %arg2 : vector<2xi32>) -> vector<2xi32> {
   return %res : vector<2xi32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
   %f = transform.structured.match ops{["func.func"]} in %module_op 
     : (!transform.any_op) -> !transform.any_op
 
-  %f2 = transform.vector.lower_contraction %f
-    lowering_strategy = "dot"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_contraction lowering_strategy = "dot"
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-contract-to-matrix-intrinsics-transforms.mlir

func.func @matmul(%arg0: vector<2x4xf32>,
   return %0 : vector<2x3xf32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
   %f = transform.structured.match ops{["func.func"]} in %module_op 
     : (!transform.any_op) -> !transform.any_op
 
-  %f2 = transform.vector.lower_contraction %f
-    lowering_strategy = "matmulintrinsics"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_contraction lowering_strategy = "matmulintrinsics"
+  } : !transform.any_op
 
-  %f3 = transform.vector.lower_shape_cast %f2
-    : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_shape_cast
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-contract-to-outerproduct-transforms.mlir

 }
 
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
   %f = transform.structured.match ops{["func.func"]} in %module_op 
     : (!transform.any_op) -> !transform.any_op
 
-  %f2 = transform.vector.lower_contraction %f
-    lowering_strategy = "outerproduct"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_contraction lowering_strategy = "outerproduct"
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-contract-to-parallel-arith-transforms.mlir

func.func @parallel_contract_lowering_scalar(%arg0: vector<1x1xf32>, %arg1: vector<1x1xf32>, %arg2: f32) -> f32 {
   return %0 : f32
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
   %f = transform.structured.match ops{["func.func"]} in %module_op 
     : (!transform.any_op) -> !transform.any_op
 
-  %f2 = transform.vector.lower_contraction %f
-    lowering_strategy = "parallelarith"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_contraction lowering_strategy = "parallelarith"
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-mask-lowering-transforms.mlir

func.func @genbool_var_3d(%arg0: index, %arg1: index, %arg2: index) -> vector<2x1x7xi1> {
   return %0 : vector<2x1x7xi1>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
   %f = transform.structured.match ops{["func.func"]} in %module_op 
     : (!transform.any_op) -> !transform.any_op
 
-  transform.vector.lower_masks %f
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_masks
+  } : !transform.any_op
 }
 
 // -----
 
 // CHECK-LABEL: func @transfer_read_3d(
 func.func @transfer_read_3d(
     %t: tensor<?x?x?xf32>, %arg0: index, %arg1: index, %arg2: index)
   -> vector<2x1x7xf32> {
func.func @transfer_read_3d(
   return %1: vector<2x1x7xf32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
   %f = transform.structured.match ops{["func.func"]} in %module_op 
     : (!transform.any_op) -> !transform.any_op
 
-  transform.vector.lower_masked_transfers %f
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_masked_transfers
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-multi-reduction-lowering.mlir

 }
 
 // CHECK-LABEL: func @vector_multi_reduction_parallel_middle
 //  CHECK-SAME:   %[[INPUT:.+]]: vector<3x4x5xf32>, %[[ACC:.+]]: vector<4xf32>
 //       CHECK: vector.transpose %[[INPUT]], [1, 0, 2] : vector<3x4x5xf32> to vector<4x3x5xf32>
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.lower_multi_reduction %module_op
-    lowering_strategy = "innerreduction"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_multi_reduction lowering_strategy = "innerreduction"
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-multi-reduction-outer-lowering.mlir

func.func @vector_multi_reduction_to_scalar(%arg0: vector<2x3xf32>, %acc: f32) -> f32 {
   %0 = vector.multi_reduction <add>, %arg0, %acc [0, 1] : vector<2x3xf32> to f32
   return %0 : f32
 }
 // CHECK-LABEL: func @vector_multi_reduction_to_scalar
 //       CHECK:   return %{{.+}}
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.lower_multi_reduction %module_op
-    lowering_strategy = "innerparallel"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_multi_reduction lowering_strategy = "innerparallel"
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-outerproduct-lowering-transforms.mlir

 // CHECK:      %[[T3:.*]] = vector.insert %[[T2]], %[[C0]] [0] : vector<3xf32> into vector<2x3xf32>
 // CHECK:      %[[T4:.*]] = vector.extract %[[A]][1] : vector<2xf32>
 // CHECK:      %[[T5:.*]] = vector.splat %[[T4]] : vector<3xf32>
 // CHECK:      %[[T6:.*]] = arith.mulf %[[T5]], %[[B]] : vector<3xf32>
 // CHECK:      %[[T7:.*]] = vector.insert %[[T6]], %[[T3]] [1] : vector<3xf32> into vector<2x3xf32>
 // CHECK:      return %[[T7]] : vector<2x3xf32>
 
 func.func @outerproduct_noacc(%arg0: vector<2xf32>,
                               %arg1: vector<3xf32>) -> vector<2x3xf32> {
   %0 = vector.outerproduct %arg0, %arg1 : vector<2xf32>, vector<3xf32>
   return %0: vector<2x3xf32>
 }
 
 // CHECK-LABEL: func @outerproduct_acc
 // CHECK-SAME: %[[A:.*0]]: vector<2xf32>,
 // CHECK-SAME: %[[B:.*1]]: vector<3xf32>,
 // CHECK-SAME: %[[C:.*2]]: vector<2x3xf32>
 // CHECK:      %[[C0:.*]] = arith.constant dense<0.000000e+00> : vector<2x3xf32>
 // CHECK:      %[[T0:.*]] = vector.extract %[[A]][0] : vector<2xf32>
 // CHECK:      %[[T1:.*]] = vector.splat %[[T0]] : vector<3xf32>
 // CHECK:      %[[T2:.*]] = vector.extract %[[C]][0] : vector<2x3xf32>
 // CHECK:      %[[T3:.*]] = vector.fma %[[T1]], %[[B]], %[[T2]] : vector<3xf32>
 // CHECK:      %[[T4:.*]] = vector.insert %[[T3]], %[[C0]] [0] : vector<3xf32> into vector<2x3xf32>
 // CHECK:      %[[T5:.*]] = vector.extract %[[A]][1] : vector<2xf32>
 // CHECK:      %[[T6:.*]] = vector.splat %[[T5]] : vector<3xf32>
 // CHECK:      %[[T7:.*]] = vector.extract %[[C]][1] : vector<2x3xf32>
 // CHECK:      %[[T8:.*]] = vector.fma %[[T6]], %[[B]], %[[T7]] : vector<3xf32>
 // CHECK:      %[[T9:.*]] = vector.insert %[[T8]], %[[T4]] [1] : vector<3xf32> into vector<2x3xf32>
 // CHECK:      return %[[T9]] : vector<2x3xf32>
 
 func.func @outerproduct_acc(%arg0: vector<2xf32>,
                             %arg1: vector<3xf32>,
                             %arg2: vector<2x3xf32>) -> vector<2x3xf32> {
   %0 = vector.outerproduct %arg0, %arg1, %arg2 : vector<2xf32>, vector<3xf32>
   return %0: vector<2x3xf32>
 }
 
 // CHECK-LABEL: func @outerproduct_noacc_int
 // CHECK-SAME: %[[A:.*0]]: vector<2xi32>,
 // CHECK-SAME: %[[B:.*1]]: vector<3xi32>
 // CHECK:      %[[C0:.*]] = arith.constant dense<0> : vector<2x3xi32>
 // CHECK:      %[[T0:.*]] = vector.extract %[[A]][0] : vector<2xi32>
 // CHECK:      %[[T1:.*]] = vector.splat %[[T0]] : vector<3xi32>
 // CHECK:      %[[T2:.*]] = arith.muli %[[T1]], %[[B]] : vector<3xi32>
 // CHECK:      %[[T3:.*]] = vector.insert %[[T2]], %[[C0]] [0] : vector<3xi32> into vector<2x3xi32>
 // CHECK:      %[[T4:.*]] = vector.extract %[[A]][1] : vector<2xi32>
 // CHECK:      %[[T5:.*]] = vector.splat %[[T4]] : vector<3xi32>
 // CHECK:      %[[T6:.*]] = arith.muli %[[T5]], %[[B]] : vector<3xi32>
 // CHECK:      %[[T7:.*]] = vector.insert %[[T6]], %[[T3]] [1] : vector<3xi32> into vector<2x3xi32>
 // CHECK:      return %[[T7]] : vector<2x3xi32>
 func.func @outerproduct_noacc_int(%arg0: vector<2xi32>,
                                   %arg1: vector<3xi32>) -> vector<2x3xi32> {
   %0 = vector.outerproduct %arg0, %arg1 : vector<2xi32>, vector<3xi32>
   return %0: vector<2x3xi32>
 }
 
 // CHECK-LABEL: func @outerproduct_acc_int
 // CHECK-SAME: %[[A:.*0]]: vector<2xi32>,
 // CHECK-SAME: %[[B:.*1]]: vector<3xi32>,
 // CHECK-SAME: %[[C:.*2]]: vector<2x3xi32>
 // CHECK:      %[[C0:.*]] = arith.constant dense<0> : vector<2x3xi32>
 // CHECK:      %[[T0:.*]] = vector.extract %[[A]][0] : vector<2xi32>
 // CHECK:      %[[T1:.*]] = vector.splat %[[T0]] : vector<3xi32>
 // CHECK:      %[[T2:.*]] = vector.extract %[[C]][0] : vector<2x3xi32>
 // CHECK:      %[[T3:.*]] = arith.muli %[[T1]], %[[B]] : vector<3xi32>
 // CHECK:      %[[T4:.*]] = arith.addi %[[T3]], %[[T2]] : vector<3xi32>
 // CHECK:      %[[T5:.*]] = vector.insert %[[T4]], %[[C0]] [0] : vector<3xi32> into vector<2x3xi32>
 // CHECK:      %[[T6:.*]] = vector.extract %[[A]][1] : vector<2xi32>
 // CHECK:      %[[T7:.*]] = vector.splat %[[T6]] : vector<3xi32>
 // CHECK:      %[[T8:.*]] = vector.extract %[[C]][1] : vector<2x3xi32>
 // CHECK:      %[[T9:.*]] = arith.muli %[[T7]], %[[B]] : vector<3xi32>
 // CHECK:      %[[T10:.*]] = arith.addi %[[T9]], %[[T8]] : vector<3xi32>
 // CHECK:      %[[T11:.*]] = vector.insert %[[T10]], %[[T5]] [1] : vector<3xi32> into vector<2x3xi32>
 // CHECK:      return %[[T11]] : vector<2x3xi32>
 func.func @outerproduct_acc_int(%arg0: vector<2xi32>,
                                 %arg1: vector<3xi32>,
                                 %arg2: vector<2x3xi32>) -> vector<2x3xi32> {
   %0 = vector.outerproduct %arg0, %arg1, %arg2 : vector<2xi32>, vector<3xi32>
   return %0: vector<2x3xi32>
 }
 
 // CHECK-LABEL: func @axpy_fp(
 // CHECK-SAME: %[[A:.*0]]: vector<16xf32>,
 // CHECK-SAME: %[[B:.*1]]: f32)
 // CHECK: %[[T0:.*]] = vector.splat %[[B]] : vector<16xf32>
 // CHECK: %[[T1:.*]] = arith.mulf %[[A]], %[[T0]] : vector<16xf32>
 // CHECK: return %[[T1]] : vector<16xf32>
 func.func @axpy_fp(%arg0: vector<16xf32>, %arg1: f32) -> vector<16xf32> {
-   %0 = vector.outerproduct %arg0, %arg1: vector<16xf32>, f32
-   return %0: vector<16xf32>
 }
 
 // CHECK-LABEL: func @axpy_fp_add(
 // CHECK-SAME: %[[A:.*0]]: vector<16xf32>,
 // CHECK-SAME: %[[B:.*1]]: f32,
 // CHECK-SAME: %[[C:.*2]]: vector<16xf32>)
 // CHECK: %[[T0:.*]] = vector.splat %[[B]] : vector<16xf32>
 // CHECK: %[[T1:.*]] = vector.fma %[[A]], %[[T0]], %[[C]] : vector<16xf32>
 // CHECK: return %[[T1]] : vector<16xf32>
 func.func @axpy_fp_add(%arg0: vector<16xf32>, %arg1: f32, %arg2 : vector<16xf32>) -> vector<16xf32> {
-   %0 = vector.outerproduct %arg0, %arg1, %arg2: vector<16xf32>, f32
-   return %0: vector<16xf32>
 }
 
 // CHECK-LABEL: func @axpy_int(
 // CHECK-SAME: %[[A:.*0]]: vector<16xi32>,
 // CHECK-SAME: %[[B:.*1]]: i32)
 // CHECK: %[[T0:.*]] = vector.splat %[[B]] : vector<16xi32>
 // CHECK: %[[T1:.*]] = arith.muli %[[A]], %[[T0]] : vector<16xi32>
 // CHECK: return %[[T1]] : vector<16xi32>
 func.func @axpy_int(%arg0: vector<16xi32>, %arg1: i32) -> vector<16xi32> {
-   %0 = vector.outerproduct %arg0, %arg1: vector<16xi32>, i32
-   return %0: vector<16xi32>
 }
 
 // CHECK-LABEL: func @axpy_int_add(
 // CHECK-SAME: %[[A:.*0]]: vector<16xi32>,
 // CHECK-SAME: %[[B:.*1]]: i32,
 // CHECK-SAME: %[[C:.*2]]: vector<16xi32>)
 // CHECK: %[[T0:.*]] = vector.splat %[[B]] : vector<16xi32>
 // CHECK: %[[T1:.*]] = arith.muli %[[A]], %[[T0]] : vector<16xi32>
 // CHECK: %[[T2:.*]] = arith.addi %[[T1]], %[[C]] : vector<16xi32>
 // CHECK: return %[[T2]] : vector<16xi32>
 func.func @axpy_int_add(%arg0: vector<16xi32>, %arg1: i32, %arg2: vector<16xi32>) -> vector<16xi32> {
-   %0 = vector.outerproduct %arg0, %arg1, %arg2: vector<16xi32>, i32
-   return %0: vector<16xi32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
   %f = transform.structured.match ops{["func.func"]} in %module_op 
     : (!transform.any_op) -> !transform.any_op
 
-  %f2 = transform.vector.lower_outerproduct %f
-      : (!transform.any_op) -> !transform.any_op
-
-  %f3 = transform.vector.lower_broadcast %f2
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_outerproduct
+  } : !transform.any_op
+
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_broadcast
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-shape-cast-lowering-transforms.mlir

func.func @shape_cast_1d0d(%arg0 : vector<1xf32>) -> vector<f32> {
   return %s : vector<f32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
   %f = transform.structured.match ops{["func.func"]} in %module_op
     : (!transform.any_op) -> !transform.any_op
 
-  %f2 = transform.vector.lower_shape_cast %f
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %f {
+    transform.apply_patterns.vector.lower_shape_cast
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-transfer-drop-unit-dims-patterns.mlir

 
 // CHECK-LABEL: func @transfer_read_rank_reducing
 //  CHECK-SAME:     %[[ARG:.+]]: memref<1x1x3x2xi8
 //       CHECK:   %[[SUBVIEW:.+]] = memref.subview %[[ARG]][0, 0, 0, 0] [1, 1, 3, 2] [1, 1, 1, 1]
 //  CHECK-SAME:     memref<1x1x3x2xi8, {{.*}}> to memref<3x2xi8, {{.*}}>
 //       CHECK:   vector.transfer_read %[[SUBVIEW]]
 
 transform.sequence failures(propagate) {
-^bb1(%module_op: !pdl.operation):
-  transform.vector.apply_rank_reducing_subview_patterns %module_op
-      : (!pdl.operation) -> !pdl.operation
+^bb1(%module_op: !transform.any_op):
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.apply_rank_reducing_subview_patterns
+  } : !transform.any_op
 }
 
 // -----
 
 func.func @transfer_write_rank_reducing(%arg : memref<1x1x3x2xi8, strided<[6, 6, 2, 1], offset: ?>>, %vec : vector<3x2xi8>) {
     %c0 = arith.constant 0 : index
     vector.transfer_write %vec, %arg [%c0, %c0, %c0, %c0] :
       vector<3x2xi8>, memref<1x1x3x2xi8, strided<[6, 6, 2, 1], offset: ?>>
     return
 }
 
 // CHECK-LABEL: func @transfer_write_rank_reducing
 //  CHECK-SAME:     %[[ARG:.+]]: memref<1x1x3x2xi8
 //       CHECK:   %[[SUBVIEW:.+]] = memref.subview %[[ARG]][0, 0, 0, 0] [1, 1, 3, 2] [1, 1, 1, 1]
 //  CHECK-SAME:     memref<1x1x3x2xi8, {{.*}}> to memref<3x2xi8, {{.*}}>
 //       CHECK:   vector.transfer_write %{{.*}}, %[[SUBVIEW]]
 
 transform.sequence failures(propagate) {
-^bb1(%module_op: !pdl.operation):
-  transform.vector.apply_rank_reducing_subview_patterns %module_op
-      : (!pdl.operation) -> !pdl.operation
+^bb1(%module_op: !transform.any_op):
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.apply_rank_reducing_subview_patterns
+  } : !transform.any_op
 }
 
 // -----
 
 func.func @transfer_read_and_vector_rank_reducing(
       %arg : memref<1x1x3x2x1xf32>) -> vector<3x2x1xf32> {
     %c0 = arith.constant 0 : index
     %cst = arith.constant 0.0 : f32
     %v = vector.transfer_read %arg[%c0, %c0, %c0, %c0, %c0], %cst :
       memref<1x1x3x2x1xf32>, vector<3x2x1xf32>
     return %v : vector<3x2x1xf32>
 }
 
 // CHECK-LABEL: func @transfer_read_and_vector_rank_reducing
 //  CHECK-SAME:     %[[ARG:.+]]: memref<1x1x3x2x1xf32>
 //       CHECK:   %[[SUBVIEW:.+]] = memref.subview %[[ARG]][0, 0, 0, 0, 0] [1, 1, 3, 2, 1] [1, 1, 1, 1, 1]
 //  CHECK-SAME:     memref<1x1x3x2x1xf32> to memref<3x2xf32>
 //       CHECK:   vector.transfer_read %[[SUBVIEW]]{{.*}} {in_bounds = [true, true]} : memref<3x2xf32>, vector<3x2xf32>
 
 transform.sequence failures(propagate) {
-^bb1(%module_op: !pdl.operation):
-  transform.vector.apply_rank_reducing_subview_patterns %module_op
-      : (!pdl.operation) -> !pdl.operation
+^bb1(%module_op: !transform.any_op):
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.apply_rank_reducing_subview_patterns
+  } : !transform.any_op
 }
 
 // -----
 
 func.func @transfer_write_and_vector_rank_reducing(
       %arg : memref<1x1x3x2x1xf32>,
       %vec : vector<3x2x1xf32>) {
     %c0 = arith.constant 0 : index
     vector.transfer_write %vec, %arg [%c0, %c0, %c0, %c0, %c0] :
       vector<3x2x1xf32>, memref<1x1x3x2x1xf32>
     return
 }
 
 // CHECK-LABEL: func @transfer_write_and_vector_rank_reducing
 //  CHECK-SAME:     %[[ARG:.+]]: memref<1x1x3x2x1xf32>
 //       CHECK:   %[[SUBVIEW:.+]] = memref.subview %[[ARG]][0, 0, 0, 0, 0] [1, 1, 3, 2, 1] [1, 1, 1, 1, 1]
 //  CHECK-SAME:     memref<1x1x3x2x1xf32> to memref<3x2xf32>
 //       CHECK:   vector.transfer_write %{{.*}}, %[[SUBVIEW]]{{.*}} {in_bounds = [true, true]} : vector<3x2xf32>, memref<3x2xf32>
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.apply_rank_reducing_subview_patterns %module_op
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.apply_rank_reducing_subview_patterns
+  } : !transform.any_op
 }
 
 // -----
 
 func.func @transfer_read_and_vector_rank_reducing_to_0d(
       %arg : memref<1x1x1x1x1xf32>) -> vector<1x1x1xf32> {
     %c0 = arith.constant 0 : index
     %cst = arith.constant 0.0 : f32
     %v = vector.transfer_read %arg[%c0, %c0, %c0, %c0, %c0], %cst :
       memref<1x1x1x1x1xf32>, vector<1x1x1xf32>
     return %v : vector<1x1x1xf32>
 }
 
 // CHECK-LABEL: func @transfer_read_and_vector_rank_reducing_to_0d
 //  CHECK-SAME:     %[[MEMREF:.+]]: memref<1x1x1x1x1xf32>
 //       CHECK:   %[[SUBVIEW:.+]] = memref.subview %[[MEMREF]][0, 0, 0, 0, 0] [1, 1, 1, 1, 1] [1, 1, 1, 1, 1] : memref<1x1x1x1x1xf32> to memref<f32>
 //       CHECK:   %[[READ:.+]] = vector.transfer_read %[[SUBVIEW]]{{.*}} : memref<f32>, vector<f32>
 //       CHECK:   vector.shape_cast %[[READ]] : vector<f32> to vector<1x1x1xf32>
 
 transform.sequence failures(propagate) {
-^bb1(%module_op: !pdl.operation):
-  transform.vector.apply_rank_reducing_subview_patterns %module_op
-      : (!pdl.operation) -> !pdl.operation
+^bb1(%module_op: !transform.any_op):
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.apply_rank_reducing_subview_patterns
+  } : !transform.any_op
 }
 
 // -----
 
 func.func @transfer_write_and_vector_rank_reducing_to_0d(
       %arg : memref<1x1x1x1x1xf32>,
       %vec : vector<1x1x1xf32>) {
     %c0 = arith.constant 0 : index
     vector.transfer_write %vec, %arg [%c0, %c0, %c0, %c0, %c0] :
       vector<1x1x1xf32>, memref<1x1x1x1x1xf32>
     return
 }
 
 // CHECK-LABEL: func @transfer_write_and_vector_rank_reducing_to_0d
 //  CHECK-SAME:     %[[MEMREF:.+]]: memref<1x1x1x1x1xf32>, %[[VECTOR:.+]]: vector<1x1x1xf32>
 //       CHECK:   %[[SUBVIEW:.+]] = memref.subview %[[MEMREF]][0, 0, 0, 0, 0] [1, 1, 1, 1, 1] [1, 1, 1, 1, 1] : memref<1x1x1x1x1xf32> to memref<f32>
 //       CHECK:   %[[SHCAST:.+]] = vector.shape_cast %[[VECTOR]] : vector<1x1x1xf32> to vector<f32>
 //       CHECK:   vector.transfer_write %[[SHCAST]], %[[SUBVIEW]]{{.*}} : vector<f32>, memref<f32>
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.apply_rank_reducing_subview_patterns %module_op
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.apply_rank_reducing_subview_patterns
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-transfer-full-partial-split-copy-transform.mlir

func.func @split_vector_transfer_read_strided_2d(
   %1 = vector.transfer_read %A[%i, %j], %f0 :
     memref<7x8xf32, strided<[?, 1], offset: ?>>, vector<4x8xf32>
 
   return %1 : vector<4x8xf32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.split_transfer_full_partial %module_op
-    split_transfer_strategy = "linalg-copy"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.split_transfer_full_partial split_transfer_strategy = "linalg-copy"
+  } : !transform.any_op
 }
 
 // -----
 
 func.func @split_vector_transfer_write_2d(%V: vector<4x8xf32>, %A: memref<?x8xf32>, %i: index, %j: index) {
   vector.transfer_write %V, %A[%i, %j] :
     vector<4x8xf32>, memref<?x8xf32>
   return

 // CHECK:             memref.copy %[[VAL_22]], %[[DEST_VIEW]]
 // CHECK-SAME:            : memref<?x?xf32, strided<[8, 1], offset: ?>> to memref<?x?xf32, strided{{.*}}>
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.split_transfer_full_partial %module_op
-    split_transfer_strategy = "linalg-copy"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.split_transfer_full_partial split_transfer_strategy = "linalg-copy"
+  } : !transform.any_op
 }
 
 // -----
 
 func.func @split_vector_transfer_write_strided_2d(
     %V: vector<4x8xf32>, %A: memref<7x8xf32, strided<[?, 1], offset: ?>>,
     %i: index, %j: index) {
   vector.transfer_write %V, %A[%i, %j] :

 // CHECK:             memref.copy %[[VAL_22]], %[[DEST_VIEW]]
 // CHECK-SAME:            : memref<?x?xf32, strided<[8, 1], offset: ?>> to memref<?x?xf32, strided<[?, 1], offset: ?>>
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.split_transfer_full_partial %module_op
-    split_transfer_strategy = "linalg-copy"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.split_transfer_full_partial split_transfer_strategy = "linalg-copy"
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-transfer-full-partial-split.mlir

%1 = vector.transfer_read %A[%i, %j], %f0 :
     memref<7x8xf32, strided<[?, 1], offset: ?>>, vector<4x8xf32>
 
   // CHECK: return %[[res]] : vector<4x8xf32>
   return %1 : vector<4x8xf32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.split_transfer_full_partial %module_op
-    split_transfer_strategy = "vector-transfer"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.split_transfer_full_partial split_transfer_strategy = "vector-transfer"
+  } : !transform.any_op
 }
 
 // -----
 
 func.func @split_vector_transfer_write_2d(%V: vector<4x8xf32>, %A: memref<?x8xf32>, %i: index, %j: index) {
   vector.transfer_write %V, %A[%i, %j] :
     vector<4x8xf32>, memref<?x8xf32>
   return

 // CHECK-SAME:            : vector<4x8xf32>, memref<?x8xf32>
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }
 
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.split_transfer_full_partial %module_op
-    split_transfer_strategy = "vector-transfer"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.split_transfer_full_partial split_transfer_strategy = "vector-transfer"
+  } : !transform.any_op
 }
 
 // -----
 
 func.func @split_vector_transfer_write_strided_2d(
     %V: vector<4x8xf32>, %A: memref<7x8xf32, strided<[?, 1], offset: ?>>,
     %i: index, %j: index) {
   vector.transfer_write %V, %A[%i, %j] :

 // CHECK:             vector.transfer_write %[[VAL_20]], %[[DEST]][%[[I]], %[[J]]]
 // CHECK-SAME:            : vector<4x8xf32>, memref<7x8xf32, strided<[?, 1], offset: ?>>
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.split_transfer_full_partial %module_op
-    split_transfer_strategy = "vector-transfer"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.split_transfer_full_partial split_transfer_strategy = "vector-transfer"
+  } : !transform.any_op
 }
 
 // -----
 
 func.func private @fake_side_effecting_fun(%0: vector<2x2xf32>) -> ()
 
 // CHECK-LABEL: transfer_read_within_async_execute
 func.func @transfer_read_within_async_execute(%A : memref<?x?xf32>) -> !async.token {
scf.for %i = %lb to %ub step %step {
     %0 = vector.transfer_read %A[%c0, %c0], %f0 : memref<?x?xf32>, vector<2x2xf32>
     func.call @fake_side_effecting_fun(%0) : (vector<2x2xf32>) -> ()
   }
   return
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.split_transfer_full_partial %module_op
-    split_transfer_strategy = "vector-transfer"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.split_transfer_full_partial split_transfer_strategy = "vector-transfer"
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-transfer-to-vector-load-store.mlir

%res = vector.transfer_read %mem[%i, %i, %i, %i, %i], %cf0
     {in_bounds = [true, true, true, true], permutation_map = #broadcast_2d_in_4d} 
       : memref<10x20x30x8x8xf32>, vector<3x2x4x5xf32>
   return %res : vector<3x2x4x5xf32>
 }
 
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  %m2 = transform.vector.lower_transfer %module_op
-    max_transfer_rank = 99
-      : (!transform.any_op) -> !transform.any_op
-  transform.vector.apply_transfer_permutation_patterns %m2
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_transfer max_transfer_rank = 99
+    transform.apply_patterns.vector.apply_transfer_permutation_patterns
+  } : !transform.any_op
 }
 
 // -----
 
 #map0 = affine_map<(d0, d1, d2, d3) -> (d1, d0, 0, 0)>
 #map1 = affine_map<(d0, d1, d2, d3) -> (0, d1, 0, d0)>
 #map2 = affine_map<(d0, d1, d2, d3) -> (d3, d1, 0, 0)>
 #map3 = affine_map<(d0, d1) -> (d1, d0, 0, 0)>
func.func @transfer_write_broadcast_unit_dim(
   // CHECK: %[[NEW_VEC3:.*]] = vector.transpose %[[NEW_VEC2]], [1, 2, 0] : vector<1x8x16xf32> to vector<8x16x1xf32>
   // CHECK: vector.transfer_write %[[NEW_VEC3]], %[[ARG0]][%[[C0]], %[[C0]], %[[C0]], %[[C0]]] : vector<8x16x1xf32>, memref<?x?x?x?xf32>
 
   return %0 : tensor<?x?x?x?xf32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  %m2 = transform.vector.lower_transfer %module_op
-    max_transfer_rank = 99
-      : (!transform.any_op) -> !transform.any_op
-  transform.vector.apply_transfer_permutation_patterns %m2
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_transfer max_transfer_rank = 99
+    transform.apply_patterns.vector.apply_transfer_permutation_patterns
+  } : !transform.any_op
 }

mlir/test/Dialect/Vector/vector-transpose-lowering.mlir

func.func @transpose1023_1x1x8x8xf32(%arg0: vector<1x1x8x8xf32>) -> vector<1x1x8x8xf32> {
   //      CHECK: vector.extract {{.*}}[0, 0] : vector<1x1x8x8xf32>
   // CHECK-NEXT: vector.insert {{.*}} [0, 0] : vector<8x8xf32> into vector<1x1x8x8xf32>
   %0 = vector.transpose %arg0, [1, 0, 2, 3] : vector<1x1x8x8xf32> to vector<1x1x8x8xf32>
   return %0 : vector<1x1x8x8xf32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.lower_transpose %module_op
-    lowering_strategy = "eltwise"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_transpose lowering_strategy = "eltwise"
+  } : !transform.any_op
 }
 
 // -----
 
 // CHECK-LABEL: func @transpose
 func.func @transpose(%arg0: vector<2x4xf32>) -> vector<4x2xf32> {
   //      CHECK: vector.shape_cast %{{.*}} : vector<2x4xf32> to vector<8xf32>
   //            0 4
   // 0 1 2 3    1 5
   // 4 5 6 7 -> 2 6
   //            3 7
   // CHECK-NEXT: vector.shuffle %{{.*}} [0, 4, 1, 5, 2, 6, 3, 7] : vector<8xf32>, vector<8xf32>
   // CHECK-NEXT: vector.shape_cast %{{.*}} : vector<8xf32> to vector<4x2xf32>
   %0 = vector.transpose %arg0, [1, 0] : vector<2x4xf32> to vector<4x2xf32>
   return %0 : vector<4x2xf32>
 }
 
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.lower_transpose %module_op
-    lowering_strategy = "shuffle_1d"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_transpose lowering_strategy = "shuffle_1d"
+  } : !transform.any_op
 }
 
 // -----
 
 // CHECK-LABEL: func @transpose(
 func.func @transpose(%arg0: vector<2x4xf32>) -> vector<4x2xf32> {
   // CHECK:       vector.shape_cast {{.*}} : vector<2x4xf32> to vector<8xf32>
   // CHECK:       vector.flat_transpose %{{.*}} {columns = 2 : i32, rows = 4 : i32} : vector<8xf32> -> vector<8xf32>
   // CHECK:       vector.shape_cast {{.*}} : vector<8xf32> to vector<4x2xf32>
   %0 = vector.transpose %arg0, [1, 0] : vector<2x4xf32> to vector<4x2xf32>
   return %0 : vector<4x2xf32>
 }
 
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.lower_transpose %module_op
-    lowering_strategy = "flat_transpose"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_transpose lowering_strategy = "flat_transpose"
+  } : !transform.any_op
 }
 
 // -----
 
 // CHECK-LABEL: func @transpose4x8
 func.func @transpose4x8xf32(%arg0: vector<4x8xf32>) -> vector<8x4xf32> {
   //      CHECK: vector.extract {{.*}}[0]
   // CHECK-NEXT: vector.extract {{.*}}[1]
func.func @transpose210_1x8x8xf32(%arg0: vector<1x8x8xf32>) -> vector<8x8x1xf32> {
   // CHECK-NEXT: vector.insert {{.*}}[7]
   // CHECK-NEXT: vector.shape_cast %{{.*}} : vector<8x8xf32> to vector<8x8x1xf32>
   %0 = vector.transpose %arg0, [2, 1, 0] : vector<1x8x8xf32> to vector<8x8x1xf32>
   return %0 : vector<8x8x1xf32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.lower_transpose %module_op
-    avx2_lowering_strategy = true
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_transpose avx2_lowering_strategy = true
+  } : !transform.any_op
 }
 
 // -----
 
 func.func @transpose_shuffle16x16xf32(%arg0: vector<16x16xf32>) -> vector<16x16xf32> {
   // CHECK: vector.shuffle {{.*}} [0, 16, 1, 17, 4, 20, 5, 21, 8, 24, 9, 25, 12, 28, 13, 29] : vector<16xf32>, vector<16xf32>
   // CHECK: vector.shuffle {{.*}} [2, 18, 3, 19, 6, 22, 7, 23, 10, 26, 11, 27, 14, 30, 15, 31] : vector<16xf32>, vector<16xf32>
   // CHECK: vector.shuffle {{.*}} [0, 16, 1, 17, 4, 20, 5, 21, 8, 24, 9, 25, 12, 28, 13, 29] : vector<16xf32>, vector<16xf32>
func.func @transpose_shuffle16x16xf32(%arg0: vector<16x16xf32>) -> vector<16x16xf32> {
   // CHECK: vector.shuffle {{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
   // CHECK: vector.shuffle {{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
   %0 = vector.transpose %arg0, [1, 0] : vector<16x16xf32> to vector<16x16xf32>
   return %0 : vector<16x16xf32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.lower_transpose %module_op
-    lowering_strategy = "shuffle_16x16"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_transpose lowering_strategy = "shuffle_16x16"
+  } : !transform.any_op
 }
 
 // -----
 
 // CHECK-LABEL: func @transpose021_shuffle16x16xf32
 func.func @transpose021_shuffle16x16xf32(%arg0: vector<1x16x16xf32>) -> vector<1x16x16xf32> {
   // CHECK: vector.shuffle {{.*}} [0, 16, 1, 17, 4, 20, 5, 21, 8, 24, 9, 25, 12, 28, 13, 29] : vector<16xf32>, vector<16xf32>
   // CHECK: vector.shuffle {{.*}} [2, 18, 3, 19, 6, 22, 7, 23, 10, 26, 11, 27, 14, 30, 15, 31] : vector<16xf32>, vector<16xf32>
func.func @transpose021_shuffle16x16xf32(%arg0: vector<1x16x16xf32>) -> vector<1x16x16xf32> {
   // CHECK: vector.shuffle {{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
   // CHECK: vector.shuffle {{.*}} [4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 28, 29, 30, 31] : vector<16xf32>, vector<16xf32>
   %0 = vector.transpose %arg0, [0, 2, 1] : vector<1x16x16xf32> to vector<1x16x16xf32>
   return %0 : vector<1x16x16xf32>
 }
 
 transform.sequence failures(propagate) {
 ^bb1(%module_op: !transform.any_op):
-  transform.vector.lower_transpose %module_op
-    lowering_strategy = "shuffle_16x16"
-      : (!transform.any_op) -> !transform.any_op
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_transpose lowering_strategy = "shuffle_16x16"
+  } : !transform.any_op
 }

mlir/test/Integration/Dialect/Vector/CPU/test-shuffle16x16.mlir

func.func @entry() {
   // CHECK-SAME:  ( 12, 28, 44, 60, 76, 92, 108, 124, 140, 156, 172, 188, 204, 220, 236, 252 ),
   // CHECK-SAME:  ( 13, 29, 45, 61, 77, 93, 109, 125, 141, 157, 173, 189, 205, 221, 237, 253 ),
   // CHECK-SAME:  ( 14, 30, 46, 62, 78, 94, 110, 126, 142, 158, 174, 190, 206, 222, 238, 254 ),
   // CHECK-SAME:  ( 15, 31, 47, 63, 79, 95, 111, 127, 143, 159, 175, 191, 207, 223, 239, 255 ) )
   return
 }
 
 transform.sequence failures(propagate) {
-^bb1(%module_op: !pdl.operation):
-  transform.vector.lower_transpose %module_op
-    lowering_strategy = "shuffle_16x16"
-      : (!pdl.operation) -> !pdl.operation
+^bb1(%module_op: !transform.any_op):
+  transform.apply_patterns [] to %module_op {
+    transform.apply_patterns.vector.lower_transpose lowering_strategy = "shuffle_16x16"
+  } : !transform.any_op
 }