[mlir][pdl] Make `pdl` the default dialect when parsing/printing

[Mogball]

Summary

PDLDialect being a somewhat user-facing dialect and whose ops contain exclusively other PDL ops in their regions can take advantage of OpAsmOpInterface to provide nicer IR.

[jpienaar]

Nice :-)

mlir/include/mlir/Dialect/PDL/IR/PDLOps.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_PDL_IR_PDLOPS
 #define MLIR_DIALECT_PDL_IR_PDLOPS
 
 include "mlir/Dialect/PDL/IR/PDLTypes.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
+include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // PDL Ops
 //===----------------------------------------------------------------------===//
 
 class PDL_Op<string mnemonic, list<OpTrait> traits = []>
     : Op<PDL_Dialect, mnemonic, traits> {
def PDL_OperationOp : PDL_Op<"operation", [AttrSizedOperandSegments]> {
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::PatternOp
 //===----------------------------------------------------------------------===//
 
 def PDL_PatternOp : PDL_Op<"pattern", [
-    IsolatedFromAbove, SingleBlock, Symbol
+    IsolatedFromAbove, SingleBlock, Symbol,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getDefaultDialect"]>
   ]> {
   let summary = "Define a rewrite pattern";
   let description = [{
     `pdl.pattern` operations provide a transformable representation for a
     `RewritePattern`. The attributes on this operation correspond to the various
     metadata on a `RewritePattern`, such as the benefit. The match section of
     the pattern is specified within the region body, with the rewrite provided
     by a terminating `pdl.rewrite`.

 }
 
 //===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
 def PDL_RewriteOp : PDL_Op<"rewrite", [
      Terminator, HasParent<"pdl::PatternOp">, NoTerminator, NoRegionArguments,
-     SingleBlock, AttrSizedOperandSegments
+     SingleBlock, AttrSizedOperandSegments,
+     DeclareOpInterfaceMethods<OpAsmOpInterface, ["getDefaultDialect"]>
   ]> {
   let summary = "Specify the rewrite of a matched pattern";
   let description = [{
     `pdl.rewrite` operations terminate the region of a `pdl.pattern` and specify
     the main rewrite of a `pdl.pattern`, on the optional root operation. The
     rewrite is specified either via a string name (`name`) to a native
     rewrite function, or via the region body. The rewrite region, if specified,
     must contain a single block. If the rewrite is external it functions

mlir/lib/Dialect/PDL/IR/PDL.cpp

void PatternOp::build(OpBuilder &builder, OperationState &state,
   state.regions[0]->emplaceBlock();
 }
 
 /// Returns the rewrite operation of this pattern.
 RewriteOp PatternOp::getRewriter() {
   return cast<RewriteOp>(body().front().getTerminator());
 }
 
+/// The default dialect is `pdl`.
+StringRef PatternOp::getDefaultDialect() {
+  return PDLDialect::getDialectNamespace();
+}
+
 //===----------------------------------------------------------------------===//
 // pdl::ReplaceOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(ReplaceOp op) {
   if (op.replOperation() && !op.replValues().empty())
     return op.emitOpError() << "expected no replacement values to be provided"
                                " when the replacement operation is present";
static LogicalResult verify(RewriteOp op) {
   if (op.externalConstParams()) {
     return op.emitOpError() << "expected no external constant parameters when "
                                "the rewrite is specified inline";
   }
 
   return success();
 }
 
+/// The default dialect is `pdl`.
+StringRef RewriteOp::getDefaultDialect() {
+  return PDLDialect::getDialectNamespace();
+}
+
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(TypeOp op) {
   if (!op.typeAttr())
     return verifyHasBindingUse(op);
   return success();

mlir/test/Conversion/PDLToPDLInterp/pdl-to-pdl-interp-matcher.mlir

module @simple {
   // CHECK:   pdl_interp.record_match @rewriters::@pdl_generated_rewriter
   // CHECK-SAME: benefit(1), loc([%[[ROOT]]]), root("foo.op") -> ^bb1
 
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[REWRITE_ROOT:.*]]: !pdl.operation)
   // CHECK:     pdl_interp.apply_rewrite "rewriter"(%[[REWRITE_ROOT]]
   // CHECK:     pdl_interp.finalize
   pdl.pattern : benefit(1) {
-    %root = pdl.operation "foo.op"
-    pdl.rewrite %root with "rewriter"
+    %root = operation "foo.op"
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @attributes
 module @attributes {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // Check the value of "attr".
   // CHECK-DAG:   %[[ATTR:.*]] = pdl_interp.get_attribute "attr" of %[[ROOT]]
   // CHECK-DAG:   pdl_interp.is_not_null %[[ATTR]] : !pdl.attribute
   // CHECK-DAG:   pdl_interp.check_attribute %[[ATTR]] is 10 : i64
 
   // Check the type of "attr1".
   // CHECK-DAG:   %[[ATTR1:.*]] = pdl_interp.get_attribute "attr1" of %[[ROOT]]
   // CHECK-DAG:   pdl_interp.is_not_null %[[ATTR1]] : !pdl.attribute
   // CHECK-DAG:   %[[ATTR1_TYPE:.*]] = pdl_interp.get_attribute_type of %[[ATTR1]]
   // CHECK-DAG:   pdl_interp.check_type %[[ATTR1_TYPE]] is i64
   pdl.pattern : benefit(1) {
-    %type = pdl.type : i64
-    %attr = pdl.attribute 10 : i64
-    %attr1 = pdl.attribute : %type
-    %root = pdl.operation {"attr" = %attr, "attr1" = %attr1}
-    pdl.rewrite %root with "rewriter"
+    %type = type : i64
+    %attr = attribute 10 : i64
+    %attr1 = attribute : %type
+    %root = operation {"attr" = %attr, "attr1" = %attr1}
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @constraints
 module @constraints {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK-DAG:   %[[INPUT:.*]] = pdl_interp.get_operand 0 of %[[ROOT]]
   // CHECK-DAG:   %[[INPUT1:.*]] = pdl_interp.get_operand 1 of %[[ROOT]]
   // CHECK-DAG:   %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
   // CHECK:       pdl_interp.apply_constraint "multi_constraint" [true](%[[INPUT]], %[[INPUT1]], %[[RESULT]]
 
   pdl.pattern : benefit(1) {
-    %input0 = pdl.operand
-    %input1 = pdl.operand
-    %root = pdl.operation(%input0, %input1 : !pdl.value, !pdl.value)
-    %result0 = pdl.result 0 of %root
+    %input0 = operand
+    %input1 = operand
+    %root = operation(%input0, %input1 : !pdl.value, !pdl.value)
+    %result0 = result 0 of %root
 
     pdl.apply_native_constraint "multi_constraint"[true](%input0, %input1, %result0 : !pdl.value, !pdl.value, !pdl.value)
-    pdl.rewrite %root with "rewriter"
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @inputs
 module @inputs {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK-DAG: pdl_interp.check_operand_count of %[[ROOT]] is 2
 
   // Get the input and check the type.
   // CHECK-DAG:   %[[INPUT:.*]] = pdl_interp.get_operand 0 of %[[ROOT]]
   // CHECK-DAG:   pdl_interp.is_not_null %[[INPUT]] : !pdl.value
   // CHECK-DAG:   %[[INPUT_TYPE:.*]] = pdl_interp.get_value_type of %[[INPUT]]
   // CHECK-DAG:   pdl_interp.check_type %[[INPUT_TYPE]] is i64
 
   // Get the second operand and check that it is equal to the first.
   // CHECK-DAG:  %[[INPUT1:.*]] = pdl_interp.get_operand 1 of %[[ROOT]]
   // CHECK-DAG:  pdl_interp.are_equal %[[INPUT]], %[[INPUT1]] : !pdl.value
   pdl.pattern : benefit(1) {
-    %type = pdl.type : i64
-    %input = pdl.operand : %type
-    %root = pdl.operation(%input, %input : !pdl.value, !pdl.value)
-    pdl.rewrite %root with "rewriter"
+    %type = type : i64
+    %input = operand : %type
+    %root = operation(%input, %input : !pdl.value, !pdl.value)
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @variadic_inputs
 module @variadic_inputs {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
module @variadic_inputs {
   // CHECK-DAG:   %[[INPUT_TYPE:.*]] = pdl_interp.get_value_type of %[[VAR_INPUTS]] : !pdl.range<type>
   // CHECK-DAG:   pdl_interp.check_types %[[INPUT_TYPE]] are [i64]
 
   // The third operand is at an unknown offset due to operand 2, but is expected
   // to be of size 1.
   // CHECK-DAG:  %[[INPUT2:.*]] = pdl_interp.get_operands 2 of %[[ROOT]] : !pdl.value
   // CHECK-DAG:  pdl_interp.are_equal %[[INPUT]], %[[INPUT2]] : !pdl.value
   pdl.pattern : benefit(1) {
-    %types = pdl.types : [i64]
-    %inputs = pdl.operands : %types
-    %input = pdl.operand
-    %root = pdl.operation(%input, %inputs, %input : !pdl.value, !pdl.range<value>, !pdl.value)
-    pdl.rewrite %root with "rewriter"
+    %types = types : [i64]
+    %inputs = operands : %types
+    %input = operand
+    %root = operation(%input, %inputs, %input : !pdl.value, !pdl.range<value>, !pdl.value)
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @single_operand_range
 module @single_operand_range {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
 
   // Check that the operand range is treated as all of the operands of the
   // operation.
   // CHECK-DAG:   %[[RESULTS:.*]] = pdl_interp.get_operands of %[[ROOT]]
   // CHECK-DAG:   %[[RESULT_TYPES:.*]] = pdl_interp.get_value_type of %[[RESULTS]] : !pdl.range<type>
   // CHECK-DAG:   pdl_interp.check_types %[[RESULT_TYPES]] are [i64]
 
   // The operand count is unknown, so there is no need to check for it.
   // CHECK-NOT: pdl_interp.check_operand_count
   pdl.pattern : benefit(1) {
-    %types = pdl.types : [i64]
-    %operands = pdl.operands : %types
-    %root = pdl.operation(%operands : !pdl.range<value>)
-    pdl.rewrite %root with "rewriter"
+    %types = types : [i64]
+    %operands = operands : %types
+    %root = operation(%operands : !pdl.range<value>)
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @results
 module @results {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:   pdl_interp.check_result_count of %[[ROOT]] is 2
 
   // Get the result and check the type.
   // CHECK-DAG:   %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
   // CHECK-DAG:   pdl_interp.is_not_null %[[RESULT]] : !pdl.value
   // CHECK-DAG:   %[[RESULT_TYPE:.*]] = pdl_interp.get_value_type of %[[RESULT]]
   // CHECK-DAG:   pdl_interp.check_type %[[RESULT_TYPE]] is i32
 
   // The second result doesn't have any constraints, so we don't generate an
   // access for it.
   // CHECK-NOT:   pdl_interp.get_result 1 of %[[ROOT]]
   pdl.pattern : benefit(1) {
-    %type1 = pdl.type : i32
-    %type2 = pdl.type
-    %root = pdl.operation -> (%type1, %type2 : !pdl.type, !pdl.type)
-    pdl.rewrite %root with "rewriter"
+    %type1 = type : i32
+    %type2 = type
+    %root = operation -> (%type1, %type2 : !pdl.type, !pdl.type)
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @variadic_results
 module @variadic_results {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
module @variadic_results {
   // CHECK-DAG:   %[[RESULT_TYPE:.*]] = pdl_interp.get_value_type of %[[VAR_RESULTS]] : !pdl.range<type>
   // CHECK-DAG:   pdl_interp.check_types %[[RESULT_TYPE]] are [i64]
 
   // The third result is at an unknown offset due to result 1, but is expected
   // to be of size 1.
   // CHECK-DAG:  %[[RESULT2:.*]] = pdl_interp.get_results 2 of %[[ROOT]] : !pdl.value
   // CHECK-DAG:   pdl_interp.is_not_null %[[RESULT2]] : !pdl.value
   pdl.pattern : benefit(1) {
-    %types = pdl.types : [i64]
-    %type = pdl.type
-    %root = pdl.operation -> (%type, %types, %type : !pdl.type, !pdl.range<type>, !pdl.type)
-    pdl.rewrite %root with "rewriter"
+    %types = types : [i64]
+    %type = type
+    %root = operation -> (%type, %types, %type : !pdl.type, !pdl.range<type>, !pdl.type)
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @single_result_range
 module @single_result_range {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
 
   // Check that the result range is treated as all of the results of the
   // operation.
   // CHECK-DAG:   %[[RESULTS:.*]] = pdl_interp.get_results of %[[ROOT]]
   // CHECK-DAG:   %[[RESULT_TYPES:.*]] = pdl_interp.get_value_type of %[[RESULTS]] : !pdl.range<type>
   // CHECK-DAG:   pdl_interp.check_types %[[RESULT_TYPES]] are [i64]
 
   // The result count is unknown, so there is no need to check for it.
   // CHECK-NOT: pdl_interp.check_result_count
   pdl.pattern : benefit(1) {
-    %types = pdl.types : [i64]
-    %root = pdl.operation -> (%types : !pdl.range<type>)
-    pdl.rewrite %root with "rewriter"
+    %types = types : [i64]
+    %root = operation -> (%types : !pdl.range<type>)
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @results_as_operands
 module @results_as_operands {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
module @results_as_operands {
   // CHECK-DAG:   %[[DEF_OP_1:.*]] = pdl_interp.get_defining_op of %[[OPERAND_1]]
   // CHECK-DAG:   %[[RESULT_1:.*]] = pdl_interp.get_result 1 of %[[DEF_OP_1]]
   // CHECK-DAG:   pdl_interp.are_equal %[[RESULT_1]], %[[OPERAND_1]]
 
   // Check that the parent operation of both results is the same.
   // CHECK-DAG:   pdl_interp.are_equal %[[DEF_OP_0]], %[[DEF_OP_1]]
 
   pdl.pattern : benefit(1) {
-    %type1 = pdl.type : i32
-    %type2 = pdl.type
-    %inputOp = pdl.operation -> (%type1, %type2 : !pdl.type, !pdl.type)
-    %result1 = pdl.result 0 of %inputOp
-    %result2 = pdl.result 1 of %inputOp
+    %type1 = type : i32
+    %type2 = type
+    %inputOp = operation -> (%type1, %type2 : !pdl.type, !pdl.type)
+    %result1 = result 0 of %inputOp
+    %result2 = result 1 of %inputOp
 
-    %root = pdl.operation(%result1, %result2 : !pdl.value, !pdl.value)
-    pdl.rewrite %root with "rewriter"
+    %root = operation(%result1, %result2 : !pdl.value, !pdl.value)
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @single_result_range_as_operands
 module @single_result_range_as_operands {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK-DAG:  %[[OPERANDS:.*]] = pdl_interp.get_operands of %[[ROOT]] : !pdl.range<value>
   // CHECK-DAG:  %[[OP:.*]] = pdl_interp.get_defining_op of %[[OPERANDS]] : !pdl.range<value>
   // CHECK-DAG:  pdl_interp.is_not_null %[[OP]]
   // CHECK-DAG:  %[[RESULTS:.*]] = pdl_interp.get_results of %[[OP]] : !pdl.range<value>
   // CHECK-DAG:  pdl_interp.are_equal %[[RESULTS]], %[[OPERANDS]] : !pdl.range<value>
 
   pdl.pattern : benefit(1) {
-    %types = pdl.types
-    %inputOp = pdl.operation -> (%types : !pdl.range<type>)
-    %results = pdl.results of %inputOp
+    %types = types
+    %inputOp = operation -> (%types : !pdl.range<type>)
+    %results = results of %inputOp
 
-    %root = pdl.operation(%results : !pdl.range<value>)
-    pdl.rewrite %root with "rewriter"
+    %root = operation(%results : !pdl.range<value>)
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @switch_single_result_type
 module @switch_single_result_type {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:   %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
   // CHECK:   %[[RESULT_TYPE:.*]] = pdl_interp.get_value_type of %[[RESULT]]
   // CHECK:   pdl_interp.switch_type %[[RESULT_TYPE]] to [i32, i64]
   pdl.pattern : benefit(1) {
-    %type = pdl.type : i32
-    %root = pdl.operation -> (%type : !pdl.type)
-    pdl.rewrite %root with "rewriter"
+    %type = type : i32
+    %root = operation -> (%type : !pdl.type)
+    rewrite %root with "rewriter"
   }
   pdl.pattern : benefit(1) {
-    %type = pdl.type : i64
-    %root = pdl.operation -> (%type : !pdl.type)
-    pdl.rewrite %root with "rewriter"
+    %type = type : i64
+    %root = operation -> (%type : !pdl.type)
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @switch_result_types
 module @switch_result_types {
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:   %[[RESULTS:.*]] = pdl_interp.get_results of %[[ROOT]]
   // CHECK:   %[[RESULT_TYPES:.*]] = pdl_interp.get_value_type of %[[RESULTS]]
   // CHECK:   pdl_interp.switch_types %[[RESULT_TYPES]] to {{\[\[}}i32], [i64, i32]]
   pdl.pattern : benefit(1) {
-    %types = pdl.types : [i32]
-    %root = pdl.operation -> (%types : !pdl.range<type>)
-    pdl.rewrite %root with "rewriter"
+    %types = types : [i32]
+    %root = operation -> (%types : !pdl.range<type>)
+    rewrite %root with "rewriter"
   }
   pdl.pattern : benefit(1) {
-    %types = pdl.types : [i64, i32]
-    %root = pdl.operation -> (%types : !pdl.range<type>)
-    pdl.rewrite %root with "rewriter"
+    %types = types : [i64, i32]
+    %root = operation -> (%types : !pdl.range<type>)
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @switch_operand_count_at_least
 module @switch_operand_count_at_least {
   // Check that when there are multiple "at_least" checks, the failure branch
   // goes to the next one in increasing order.
 
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK: pdl_interp.check_operand_count of %[[ROOT]] is at_least 1 -> ^[[PATTERN_1_NEXT_BLOCK:.*]],
   // CHECK: ^bb2:
   // CHECK-NEXT: pdl_interp.check_operand_count of %[[ROOT]] is at_least 2
   // CHECK: ^[[PATTERN_1_NEXT_BLOCK]]:
   // CHECK-NEXT: {{.*}} -> ^{{.*}}, ^bb2
   pdl.pattern : benefit(1) {
-    %operand = pdl.operand
-    %operands = pdl.operands
-    %root = pdl.operation(%operand, %operands : !pdl.value, !pdl.range<value>)
-    pdl.rewrite %root with "rewriter"
+    %operand = operand
+    %operands = operands
+    %root = operation(%operand, %operands : !pdl.value, !pdl.range<value>)
+    rewrite %root with "rewriter"
   }
   pdl.pattern : benefit(1) {
-    %operand = pdl.operand
-    %operand2 = pdl.operand
-    %operands = pdl.operands
-    %root = pdl.operation(%operand, %operand2, %operands : !pdl.value, !pdl.value, !pdl.range<value>)
-    pdl.rewrite %root with "rewriter"
+    %operand = operand
+    %operand2 = operand
+    %operands = operands
+    %root = operation(%operand, %operand2, %operands : !pdl.value, !pdl.value, !pdl.range<value>)
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @switch_result_count_at_least
 module @switch_result_count_at_least {
   // Check that when there are multiple "at_least" checks, the failure branch
   // goes to the next one in increasing order.
 
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK: pdl_interp.check_result_count of %[[ROOT]] is at_least 1 -> ^[[PATTERN_1_NEXT_BLOCK:.*]],
   // CHECK: ^[[PATTERN_2_BLOCK:[a-zA-Z_0-9]*]]:
   // CHECK: pdl_interp.check_result_count of %[[ROOT]] is at_least 2
   // CHECK: ^[[PATTERN_1_NEXT_BLOCK]]:
   // CHECK-NEXT: pdl_interp.get_result
   // CHECK-NEXT: pdl_interp.is_not_null {{.*}} -> ^{{.*}}, ^[[PATTERN_2_BLOCK]]
   pdl.pattern : benefit(1) {
-    %type = pdl.type
-    %types = pdl.types
-    %root = pdl.operation -> (%type, %types : !pdl.type, !pdl.range<type>)
-    pdl.rewrite %root with "rewriter"
+    %type = type
+    %types = types
+    %root = operation -> (%type, %types : !pdl.type, !pdl.range<type>)
+    rewrite %root with "rewriter"
   }
   pdl.pattern : benefit(1) {
-    %type = pdl.type
-    %type2 = pdl.type
-    %types = pdl.types
-    %root = pdl.operation -> (%type, %type2, %types : !pdl.type, !pdl.type, !pdl.range<type>)
-    pdl.rewrite %root with "rewriter"
+    %type = type
+    %type2 = type
+    %types = types
+    %root = operation -> (%type, %type2, %types : !pdl.type, !pdl.type, !pdl.range<type>)
+    rewrite %root with "rewriter"
   }
 }
 
 
 // -----
 
 // CHECK-LABEL: module @predicate_ordering
 module @predicate_ordering {
   // Check that the result is checked for null first, before applying the
   // constraint. The null check is prevalent in both patterns, so should be
   // prioritized first.
 
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:   %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[ROOT]]
   // CHECK-NEXT: pdl_interp.is_not_null %[[RESULT]]
   // CHECK:   %[[RESULT_TYPE:.*]] = pdl_interp.get_value_type of %[[RESULT]]
   // CHECK: pdl_interp.apply_constraint "typeConstraint" [](%[[RESULT_TYPE]]
 
   pdl.pattern : benefit(1) {
-    %resultType = pdl.type
+    %resultType = type
     pdl.apply_native_constraint "typeConstraint"[](%resultType : !pdl.type)
-    %root = pdl.operation -> (%resultType : !pdl.type)
-    pdl.rewrite %root with "rewriter"
+    %root = operation -> (%resultType : !pdl.type)
+    rewrite %root with "rewriter"
   }
 
   pdl.pattern : benefit(1) {
-    %resultType = pdl.type
-    %apply = pdl.operation -> (%resultType : !pdl.type)
-    pdl.rewrite %apply with "rewriter"
+    %resultType = type
+    %apply = operation -> (%resultType : !pdl.type)
+    rewrite %apply with "rewriter"
   }
 }
 
 
 // -----
 
 // CHECK-LABEL: module @multi_root
 module @multi_root {
module @multi_root {
   // CHECK-DAG:   %[[OP2:.*]] = pdl_interp.get_defining_op of %[[VAL2]]
   // CHECK-DAG:   pdl_interp.is_not_null %[[OP1]] : !pdl.operation -> ^{{.*}}, ^[[CONTINUE]]
   // CHECK-DAG:   pdl_interp.is_not_null %[[OP2]] : !pdl.operation
   // CHECK-DAG:   pdl_interp.is_not_null %[[VAL1]] : !pdl.value
   // CHECK-DAG:   pdl_interp.is_not_null %[[VAL2]] : !pdl.value
   // CHECK-DAG:   pdl_interp.is_not_null %[[ROOT2]] : !pdl.operation
 
   pdl.pattern @rewrite_multi_root : benefit(1) {
-    %input1 = pdl.operand
-    %input2 = pdl.operand
-    %type = pdl.type
-    %op1 = pdl.operation(%input1 : !pdl.value) -> (%type : !pdl.type)
-    %val1 = pdl.result 0 of %op1
-    %root1 = pdl.operation(%val1 : !pdl.value)
-    %op2 = pdl.operation(%input2 : !pdl.value) -> (%type : !pdl.type)
-    %val2 = pdl.result 0 of %op2
-    %root2 = pdl.operation(%val1, %val2 : !pdl.value, !pdl.value)
-    pdl.rewrite %root1 with "rewriter"(%root2 : !pdl.operation)
+    %input1 = operand
+    %input2 = operand
+    %type = type
+    %op1 = operation(%input1 : !pdl.value) -> (%type : !pdl.type)
+    %val1 = result 0 of %op1
+    %root1 = operation(%val1 : !pdl.value)
+    %op2 = operation(%input2 : !pdl.value) -> (%type : !pdl.type)
+    %val2 = result 0 of %op2
+    %root2 = operation(%val1, %val2 : !pdl.value, !pdl.value)
+    rewrite %root1 with "rewriter"(%root2 : !pdl.operation)
   }
 }
 
 
 // -----
 
 // CHECK-LABEL: module @overlapping_roots
 module @overlapping_roots {
   // Check the lowering of a degenerate two-root pattern, where one root
   // is in the subtree rooted at another.
 
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK-DAG: %[[VAL:.*]] = pdl_interp.get_operand 0 of %[[ROOT]]
   // CHECK-DAG: %[[OP:.*]] = pdl_interp.get_defining_op of %[[VAL]]
   // CHECK-DAG: %[[INPUT1:.*]] = pdl_interp.get_operand 0 of %[[OP]]
   // CHECK-DAG: %[[INPUT2:.*]] = pdl_interp.get_operand 1 of %[[OP]]
   // CHECK-DAG: pdl_interp.is_not_null %[[VAL]] : !pdl.value
   // CHECK-DAG: pdl_interp.is_not_null %[[OP]] : !pdl.operation
   // CHECK-DAG: pdl_interp.is_not_null %[[INPUT1]] : !pdl.value
   // CHECK-DAG: pdl_interp.is_not_null %[[INPUT2]] : !pdl.value
 
   pdl.pattern @rewrite_overlapping_roots : benefit(1) {
-    %input1 = pdl.operand
-    %input2 = pdl.operand
-    %type = pdl.type
-    %op = pdl.operation(%input1, %input2 : !pdl.value, !pdl.value) -> (%type : !pdl.type)
-    %val = pdl.result 0 of %op
-    %root = pdl.operation(%val : !pdl.value)
-    pdl.rewrite with "rewriter"(%root : !pdl.operation)
+    %input1 = operand
+    %input2 = operand
+    %type = type
+    %op = operation(%input1, %input2 : !pdl.value, !pdl.value) -> (%type : !pdl.type)
+    %val = result 0 of %op
+    %root = operation(%val : !pdl.value)
+    rewrite with "rewriter"(%root : !pdl.operation)
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @force_overlapped_root
 module @force_overlapped_root {
   // Check the lowering of a degenerate two-root pattern, where one root
module @force_overlapped_root {
   // CHECK-DAG: %[[INPUT1:.*]] = pdl_interp.get_operand 0 of %[[ROOT]]
   // CHECK-DAG: pdl_interp.is_not_null %[[INPUT1]] : !pdl.value
   // CHECK-DAG: %[[OPS:.*]] = pdl_interp.get_users of %[[VAL]] : !pdl.value
   // CHECK-DAG: pdl_interp.foreach %[[OP:.*]] : !pdl.operation in %[[OPS]]
   // CHECK-DAG:   pdl_interp.is_not_null %[[OP]] : !pdl.operation
   // CHECK-DAG:   pdl_interp.check_operand_count of %[[OP]] is 1
 
   pdl.pattern @rewrite_forced_overlapped_root : benefit(1) {
-    %input1 = pdl.operand
-    %input2 = pdl.operand
-    %type = pdl.type
-    %root = pdl.operation(%input1, %input2 : !pdl.value, !pdl.value) -> (%type : !pdl.type)
-    %val = pdl.result 0 of %root
-    %op = pdl.operation(%val : !pdl.value)
-    pdl.rewrite %root with "rewriter"(%op : !pdl.operation)
+    %input1 = operand
+    %input2 = operand
+    %type = type
+    %root = operation(%input1, %input2 : !pdl.value, !pdl.value) -> (%type : !pdl.type)
+    %val = result 0 of %root
+    %op = operation(%val : !pdl.value)
+    rewrite %root with "rewriter"(%op : !pdl.operation)
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @variadic_results_all
 module @variadic_results_all {
   // Check the correct lowering when using all results of an operation
   // and passing it them as operands to another operation.
 
   // CHECK: func @matcher(%[[ROOT:.*]]: !pdl.operation)
   // CHECK-DAG: pdl_interp.check_operand_count of %[[ROOT]] is 0
   // CHECK-DAG: %[[VALS:.*]] = pdl_interp.get_results of %[[ROOT]] : !pdl.range<value>
   // CHECK-DAG: %[[VAL0:.*]] = pdl_interp.extract 0 of %[[VALS]]
   // CHECK-DAG: %[[OPS:.*]] = pdl_interp.get_users of %[[VAL0]] : !pdl.value
   // CHECK-DAG: pdl_interp.foreach %[[OP:.*]] : !pdl.operation in %[[OPS]]
   // CHECK-DAG:   %[[OPERANDS:.*]] = pdl_interp.get_operands of %[[OP]]
   // CHECK-DAG    pdl_interp.are_equal %[[VALS]], %[[OPERANDS]] -> ^{{.*}}, ^[[CONTINUE:.*]]
   // CHECK-DAG:   pdl_interp.is_not_null %[[OP]]
   // CHECK-DAG:   pdl_interp.check_result_count of %[[OP]] is 0
   pdl.pattern @variadic_results_all : benefit(1) {
-    %types = pdl.types
-    %root = pdl.operation -> (%types : !pdl.range<type>)
-    %vals = pdl.results of %root
-    %op = pdl.operation(%vals : !pdl.range<value>)
-    pdl.rewrite %root with "rewriter"(%op : !pdl.operation)
+    %types = types
+    %root = operation -> (%types : !pdl.range<type>)
+    %vals = results of %root
+    %op = operation(%vals : !pdl.range<value>)
+    rewrite %root with "rewriter"(%op : !pdl.operation)
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @variadic_results_at
 module @variadic_results_at {
   // Check the correct lowering when using selected results of an operation
module @variadic_results_at {
   // CHECK-DAG:   %[[OPERANDS:.*]] = pdl_interp.get_operands 1 of %[[ROOT2]]
   // CHECK-DAG:   pdl_interp.are_equal %[[OPERANDS]], %[[VALS]] : !pdl.range<value> -> ^{{.*}}, ^[[CONTINUE:.*]]
   // CHECK-DAG:   pdl_interp.is_not_null %[[ROOT2]]
   // CHECK-DAG:   pdl_interp.check_operand_count of %[[ROOT2]] is at_least 1
   // CHECK-DAG:   pdl_interp.check_result_count of %[[ROOT2]] is 0
   // CHECK-DAG:   pdl_interp.check_operand_count of %[[OP]] is 0
   // CHECK-DAG:   pdl_interp.check_result_count of %[[OP]] is at_least 1
   pdl.pattern @variadic_results_at : benefit(1) {
-    %type = pdl.type
-    %types = pdl.types
-    %val = pdl.operand
-    %op = pdl.operation -> (%types, %type : !pdl.range<type>, !pdl.type)
-    %vals = pdl.results 0 of %op -> !pdl.range<value>
-    %root1 = pdl.operation(%vals, %val : !pdl.range<value>, !pdl.value)
-    %root2 = pdl.operation(%val, %vals : !pdl.value, !pdl.range<value>)
-    pdl.rewrite with "rewriter"(%root1, %root2 : !pdl.operation, !pdl.operation)
+    %type = type
+    %types = types
+    %val = operand
+    %op = operation -> (%types, %type : !pdl.range<type>, !pdl.type)
+    %vals = results 0 of %op -> !pdl.range<value>
+    %root1 = operation(%vals, %val : !pdl.range<value>, !pdl.value)
+    %root2 = operation(%val, %vals : !pdl.value, !pdl.range<value>)
+    rewrite with "rewriter"(%root1, %root2 : !pdl.operation, !pdl.operation)
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @attribute_literal
 module @attribute_literal {
   // CHECK: func @matcher(%{{.*}}: !pdl.operation)
   // CHECK: %[[ATTR:.*]] = pdl_interp.create_attribute 10 : i64
   // CHECK: pdl_interp.apply_constraint "constraint"(%[[ATTR]] : !pdl.attribute)
 
   // Check the correct lowering of an attribute that hasn't been bound.
   pdl.pattern : benefit(1) {
-    %attr = pdl.attribute 10
+    %attr = attribute 10
     pdl.apply_native_constraint "constraint"(%attr: !pdl.attribute)
 
-    %root = pdl.operation
-    pdl.rewrite %root with "rewriter"
+    %root = operation
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @type_literal
 module @type_literal {
   // CHECK: func @matcher(%{{.*}}: !pdl.operation)
   // CHECK: %[[TYPE:.*]] = pdl_interp.create_type i32
   // CHECK: %[[TYPES:.*]] = pdl_interp.create_types [i32, i64]
   // CHECK: pdl_interp.apply_constraint "constraint"(%[[TYPE]], %[[TYPES]] : !pdl.type, !pdl.range<type>)
 
   // Check the correct lowering of a type that hasn't been bound.
   pdl.pattern : benefit(1) {
-    %type = pdl.type : i32
-    %types = pdl.types : [i32, i64]
+    %type = type : i32
+    %types = types : [i32, i64]
     pdl.apply_native_constraint "constraint"(%type, %types: !pdl.type, !pdl.range<type>)
 
-    %root = pdl.operation
-    pdl.rewrite %root with "rewriter"
+    %root = operation
+    rewrite %root with "rewriter"
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @common_connector
 module @common_connector {
   // Check the correct lowering when multiple roots are using the same
module @common_connector {
   // CHECK-DAG:   pdl_interp.foreach %[[ROOTB:.*]] : !pdl.operation in %[[ROOTS]] {
   // CHECK-DAG:     pdl_interp.is_not_null %[[ROOTB]] : !pdl.operation -> ^{{.*}}, ^[[CONTB:.*]]
   // CHECK-DAG:     %[[ROOTA_OP:.*]] = pdl_interp.get_operand 0 of %[[ROOTA]]
   // CHECK-DAG:     pdl_interp.are_equal %[[ROOTA_OP]], %[[VAL0]] : !pdl.value
   // CHECK-DAG:     %[[ROOTB_OP:.*]] = pdl_interp.get_operand 0 of %[[ROOTB]]
   // CHECK-DAG:     pdl_interp.are_equal %[[ROOTB_OP]], %[[VAL0]] : !pdl.value
   // CHECK-DAG    } -> ^[[CONTA:.*]]
   pdl.pattern @common_connector : benefit(1) {
-      %type = pdl.type
-      %op = pdl.operation -> (%type, %type : !pdl.type, !pdl.type)
-      %val0 = pdl.result 0 of %op
-      %val1 = pdl.result 1 of %op
-      %rootA = pdl.operation (%val0 : !pdl.value)
-      %rootB = pdl.operation (%val0 : !pdl.value)
-      %inter = pdl.operation (%val1 : !pdl.value) -> (%type : !pdl.type)
-      %val2 = pdl.result 0 of %inter
-      %rootC = pdl.operation (%val2 : !pdl.value)
-      pdl.rewrite with "rewriter"(%rootA, %rootB, %rootC : !pdl.operation, !pdl.operation, !pdl.operation)
+      %type = type
+      %op = operation -> (%type, %type : !pdl.type, !pdl.type)
+      %val0 = result 0 of %op
+      %val1 = result 1 of %op
+      %rootA = operation (%val0 : !pdl.value)
+      %rootB = operation (%val0 : !pdl.value)
+      %inter = operation (%val1 : !pdl.value) -> (%type : !pdl.type)
+      %val2 = result 0 of %inter
+      %rootC = operation (%val2 : !pdl.value)
+      rewrite with "rewriter"(%rootA, %rootB, %rootC : !pdl.operation, !pdl.operation, !pdl.operation)
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @common_connector_range
 module @common_connector_range {
   // Check the correct lowering when multiple roots are using the same
module @common_connector_range {
   // CHECK-DAG:   pdl_interp.foreach %[[ROOTB:.*]] : !pdl.operation in %[[ROOTS]] {
   // CHECK-DAG:     pdl_interp.is_not_null %[[ROOTB]] : !pdl.operation -> ^{{.*}}, ^[[CONTB:.*]]
   // CHECK-DAG:     %[[ROOTA_OPS:.*]] = pdl_interp.get_operands of %[[ROOTA]]
   // CHECK-DAG:     pdl_interp.are_equal %[[ROOTA_OPS]], %[[VALS0]] : !pdl.range<value>
   // CHECK-DAG:     %[[ROOTB_OPS:.*]] = pdl_interp.get_operands of %[[ROOTB]]
   // CHECK-DAG:     pdl_interp.are_equal %[[ROOTB_OPS]], %[[VALS0]] : !pdl.range<value>
   // CHECK-DAG    } -> ^[[CONTA:.*]]
   pdl.pattern @common_connector_range : benefit(1) {
-    %types = pdl.types
-    %op = pdl.operation -> (%types, %types : !pdl.range<type>, !pdl.range<type>)
-    %vals0 = pdl.results 0 of %op -> !pdl.range<value>
-    %vals1 = pdl.results 1 of %op -> !pdl.range<value>
-    %rootA = pdl.operation (%vals0 : !pdl.range<value>)
-    %rootB = pdl.operation (%vals0 : !pdl.range<value>)
-    %inter = pdl.operation (%vals1 : !pdl.range<value>) -> (%types : !pdl.range<type>)
-    %vals2 = pdl.results of %inter
-    %rootC = pdl.operation (%vals2 : !pdl.range<value>)
-    pdl.rewrite with "rewriter"(%rootA, %rootB, %rootC : !pdl.operation, !pdl.operation, !pdl.operation)
+    %types = types
+    %op = operation -> (%types, %types : !pdl.range<type>, !pdl.range<type>)
+    %vals0 = results 0 of %op -> !pdl.range<value>
+    %vals1 = results 1 of %op -> !pdl.range<value>
+    %rootA = operation (%vals0 : !pdl.range<value>)
+    %rootB = operation (%vals0 : !pdl.range<value>)
+    %inter = operation (%vals1 : !pdl.range<value>) -> (%types : !pdl.range<type>)
+    %vals2 = results of %inter
+    %rootC = operation (%vals2 : !pdl.range<value>)
+    rewrite with "rewriter"(%rootA, %rootB, %rootC : !pdl.operation, !pdl.operation, !pdl.operation)
   }
 }

mlir/test/Conversion/PDLToPDLInterp/pdl-to-pdl-interp-rewriter.mlir

 // RUN: mlir-opt -split-input-file -convert-pdl-to-pdl-interp %s | FileCheck %s
 
 // -----
 
 // CHECK-LABEL: module @external
 module @external {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation, %[[INPUT:.*]]: !pdl.value)
   // CHECK:     pdl_interp.apply_rewrite "rewriter" [true](%[[ROOT]], %[[INPUT]] : !pdl.operation, !pdl.value)
   pdl.pattern : benefit(1) {
-    %input = pdl.operand
-    %root = pdl.operation "foo.op"(%input : !pdl.value)
-    pdl.rewrite %root with "rewriter"[true](%input : !pdl.value)
+    %input = operand
+    %root = operation "foo.op"(%input : !pdl.value)
+    rewrite %root with "rewriter"[true](%input : !pdl.value)
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @erase
 module @erase {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:     pdl_interp.erase %[[ROOT]]
   // CHECK:     pdl_interp.finalize
   pdl.pattern : benefit(1) {
-    %root = pdl.operation "foo.op"
-    pdl.rewrite %root {
-      pdl.erase %root
+    %root = operation "foo.op"
+    rewrite %root {
+      erase %root
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @operation_attributes
 module @operation_attributes {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ATTR:.*]]: !pdl.attribute, %[[ROOT:.*]]: !pdl.operation)
   // CHECK:     %[[ATTR1:.*]] = pdl_interp.create_attribute true
   // CHECK:     pdl_interp.create_operation "foo.op" {"attr" = %[[ATTR]], "attr1" = %[[ATTR1]]}
   pdl.pattern : benefit(1) {
-    %attr = pdl.attribute
-    %root = pdl.operation "foo.op" {"attr" = %attr}
-    pdl.rewrite %root {
-      %attr1 = pdl.attribute true
-      %newOp = pdl.operation "foo.op" {"attr" = %attr, "attr1" = %attr1}
-      pdl.erase %root
+    %attr = attribute
+    %root = operation "foo.op" {"attr" = %attr}
+    rewrite %root {
+      %attr1 = attribute true
+      %newOp = operation "foo.op" {"attr" = %attr, "attr1" = %attr1}
+      erase %root
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @operation_operands
 module @operation_operands {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[OPERAND:.*]]: !pdl.value, %[[ROOT:.*]]: !pdl.operation)
   // CHECK:     %[[NEWOP:.*]] = pdl_interp.create_operation "foo.op"(%[[OPERAND]] : !pdl.value)
   // CHECK:     %[[OPERAND1:.*]] = pdl_interp.get_result 0 of %[[NEWOP]]
   // CHECK:     pdl_interp.create_operation "foo.op2"(%[[OPERAND1]] : !pdl.value)
   pdl.pattern : benefit(1) {
-    %operand = pdl.operand
-    %root = pdl.operation "foo.op"(%operand : !pdl.value)
-    pdl.rewrite %root {
-      %type = pdl.type : i32
-      %newOp = pdl.operation "foo.op"(%operand : !pdl.value) -> (%type : !pdl.type)
-      %result = pdl.result 0 of %newOp
-      %newOp1 = pdl.operation "foo.op2"(%result : !pdl.value)
-      pdl.erase %root
+    %operand = operand
+    %root = operation "foo.op"(%operand : !pdl.value)
+    rewrite %root {
+      %type = type : i32
+      %newOp = operation "foo.op"(%operand : !pdl.value) -> (%type : !pdl.type)
+      %result = result 0 of %newOp
+      %newOp1 = operation "foo.op2"(%result : !pdl.value)
+      erase %root
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @operation_infer_types_from_replaceop
 module @operation_infer_types_from_replaceop {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation
   // CHECK:     %[[RESULTS:.*]] = pdl_interp.get_results of %[[ROOT]]
   // CHECK:     %[[RESULT_TYPES:.*]] = pdl_interp.get_value_type of %[[RESULTS]]
   // CHECK:     pdl_interp.create_operation "foo.op" -> (%[[RESULT_TYPES]] : !pdl.range<type>)
   pdl.pattern : benefit(1) {
-    %rootType = pdl.type
-    %rootType1 = pdl.type
-    %root = pdl.operation "foo.op" -> (%rootType, %rootType1 : !pdl.type, !pdl.type)
-    pdl.rewrite %root {
-      %newType1 = pdl.type
-      %newOp = pdl.operation "foo.op" -> (%rootType, %newType1 : !pdl.type, !pdl.type)
-      pdl.replace %root with %newOp
+    %rootType = type
+    %rootType1 = type
+    %root = operation "foo.op" -> (%rootType, %rootType1 : !pdl.type, !pdl.type)
+    rewrite %root {
+      %newType1 = type
+      %newOp = operation "foo.op" -> (%rootType, %newType1 : !pdl.type, !pdl.type)
+      replace %root with %newOp
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @operation_infer_types_from_otherop_individual_results
 module @operation_infer_types_from_otherop_individual_results {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[TYPE:.*]]: !pdl.type, %[[TYPES:.*]]: !pdl.range<type>
   // CHECK:     pdl_interp.create_operation "foo.op" -> (%[[TYPE]], %[[TYPES]] : !pdl.type, !pdl.range<type>)
   pdl.pattern : benefit(1) {
-    %rootType = pdl.type
-    %rootTypes = pdl.types
-    %root = pdl.operation "foo.op" -> (%rootType, %rootTypes : !pdl.type, !pdl.range<type>)
-    pdl.rewrite %root {
-      %newOp = pdl.operation "foo.op" -> (%rootType, %rootTypes : !pdl.type, !pdl.range<type>)
+    %rootType = type
+    %rootTypes = types
+    %root = operation "foo.op" -> (%rootType, %rootTypes : !pdl.type, !pdl.range<type>)
+    rewrite %root {
+      %newOp = operation "foo.op" -> (%rootType, %rootTypes : !pdl.type, !pdl.range<type>)
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @operation_infer_types_from_otherop_results
 module @operation_infer_types_from_otherop_results {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[TYPES:.*]]: !pdl.range<type>
   // CHECK:     pdl_interp.create_operation "foo.op" -> (%[[TYPES]] : !pdl.range<type>)
   pdl.pattern : benefit(1) {
-    %rootTypes = pdl.types
-    %root = pdl.operation "foo.op" -> (%rootTypes : !pdl.range<type>)
-    pdl.rewrite %root {
-      %newOp = pdl.operation "foo.op" -> (%rootTypes : !pdl.range<type>)
+    %rootTypes = types
+    %root = operation "foo.op" -> (%rootTypes : !pdl.range<type>)
+    rewrite %root {
+      %newOp = operation "foo.op" -> (%rootTypes : !pdl.range<type>)
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @replace_with_op
 module @replace_with_op {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:     %[[NEWOP:.*]] = pdl_interp.create_operation
   // CHECK:     %[[RESULTS:.*]] = pdl_interp.get_results of %[[NEWOP]]
   // CHECK:     pdl_interp.replace %[[ROOT]] with (%[[RESULTS]] : !pdl.range<value>)
   pdl.pattern : benefit(1) {
-    %type = pdl.type : i32
-    %root = pdl.operation "foo.op" -> (%type : !pdl.type)
-    pdl.rewrite %root {
-      %newOp = pdl.operation "foo.op" -> (%type : !pdl.type)
-      pdl.replace %root with %newOp
+    %type = type : i32
+    %root = operation "foo.op" -> (%type : !pdl.type)
+    rewrite %root {
+      %newOp = operation "foo.op" -> (%type : !pdl.type)
+      replace %root with %newOp
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @replace_with_values
 module @replace_with_values {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter({{.*}}, %[[ROOT:.*]]: !pdl.operation)
   // CHECK:     %[[NEWOP:.*]] = pdl_interp.create_operation
   // CHECK:     %[[RESULT:.*]] = pdl_interp.get_result 0 of %[[NEWOP]]
   // CHECK:     %[[RESULTS:.*]] = pdl_interp.get_results 1 of %[[NEWOP]] : !pdl.range<value>
   // CHECK:     %[[RESULTS_2:.*]] = pdl_interp.get_results 2 of %[[NEWOP]] : !pdl.value
   // CHECK:     pdl_interp.replace %[[ROOT]] with (%[[RESULT]], %[[RESULTS]], %[[RESULTS_2]] : !pdl.value, !pdl.range<value>, !pdl.value)
   pdl.pattern : benefit(1) {
-    %types = pdl.types
-    %root = pdl.operation "foo.op" -> (%types : !pdl.range<type>)
-    pdl.rewrite %root {
-      %newOp = pdl.operation "foo.op" -> (%types : !pdl.range<type>)
-      %newResult = pdl.result 0 of %newOp
-      %newResults = pdl.results 1 of %newOp -> !pdl.range<value>
-      %newResults2 = pdl.results 2 of %newOp -> !pdl.value
-      pdl.replace %root with (%newResult, %newResults, %newResults2 : !pdl.value, !pdl.range<value>, !pdl.value)
+    %types = types
+    %root = operation "foo.op" -> (%types : !pdl.range<type>)
+    rewrite %root {
+      %newOp = operation "foo.op" -> (%types : !pdl.range<type>)
+      %newResult = result 0 of %newOp
+      %newResults = results 1 of %newOp -> !pdl.range<value>
+      %newResults2 = results 2 of %newOp -> !pdl.value
+      replace %root with (%newResult, %newResults, %newResults2 : !pdl.value, !pdl.range<value>, !pdl.value)
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @replace_with_no_results
 module @replace_with_no_results {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:     pdl_interp.create_operation "foo.op"
   // CHECK:     pdl_interp.erase %[[ROOT]]
   pdl.pattern : benefit(1) {
-    %root = pdl.operation "foo.op"
-    pdl.rewrite %root {
-      %newOp = pdl.operation "foo.op"
-      pdl.replace %root with %newOp
+    %root = operation "foo.op"
+    rewrite %root {
+      %newOp = operation "foo.op"
+      replace %root with %newOp
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @apply_native_rewrite
 module @apply_native_rewrite {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter(%[[ROOT:.*]]: !pdl.operation)
   // CHECK:     %[[TYPE:.*]] = pdl_interp.apply_rewrite "functor" [true](%[[ROOT]] : !pdl.operation) : !pdl.type
   // CHECK:     pdl_interp.create_operation "foo.op" -> (%[[TYPE]] : !pdl.type)
   pdl.pattern : benefit(1) {
-    %type = pdl.type
-    %root = pdl.operation "foo.op" -> (%type : !pdl.type)
-    pdl.rewrite %root {
-      %newType = pdl.apply_native_rewrite "functor"[true](%root : !pdl.operation) : !pdl.type
-      %newOp = pdl.operation "foo.op" -> (%newType : !pdl.type)
+    %type = type
+    %root = operation "foo.op" -> (%type : !pdl.type)
+    rewrite %root {
+      %newType = apply_native_rewrite "functor"[true](%root : !pdl.operation) : !pdl.type
+      %newOp = operation "foo.op" -> (%newType : !pdl.type)
     }
   }
 }
 
 // -----
 
 // CHECK-LABEL: module @unbound_rewrite_op
 module @unbound_rewrite_op {
   // CHECK: module @rewriters
   // CHECK:   func @pdl_generated_rewriter()
   // CHECK:     %[[UNUSED:.*]] = pdl_interp.create_operation "bar.op"
   // CHECK:     pdl_interp.finalize
   pdl.pattern : benefit(1) {
-    %root = pdl.operation "foo.op"
-    pdl.rewrite %root {
-      %unused = pdl.operation "bar.op"
+    %root = operation "foo.op"
+    rewrite %root {
+      %unused = operation "bar.op"
     }
   }
 }
 
 // -----

mlir/test/Dialect/PDL/canonicalize.mlir

 // RUN: mlir-opt -canonicalize %s | FileCheck %s
 
 pdl.pattern @operation_op : benefit(1) {
-  %root = pdl.operation "foo.op"
-  pdl.rewrite %root {
-    // CHECK: pdl.operation "bar.unused"
-    %unused_rewrite = pdl.operation "bar.unused"
-    pdl.erase %root
+  %root = operation "foo.op"
+  rewrite %root {
+    // CHECK: operation "bar.unused"
+    %unused_rewrite = operation "bar.unused"
+    erase %root
   }
 }

mlir/test/Dialect/PDL/invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyNativeConstraintOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
-  %op = pdl.operation "foo.op"
+  %op = operation "foo.op"
 
   // expected-error@below {{expected at least one argument}}
   "pdl.apply_native_constraint"() {name = "foo", params = []} : () -> ()
-  pdl.rewrite %op with "rewriter"
+  rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::ApplyNativeRewriteOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
-  %op = pdl.operation "foo.op"
-  pdl.rewrite %op {
+  %op = operation "foo.op"
+  rewrite %op {
     // expected-error@below {{expected at least one argument}}
     "pdl.apply_native_rewrite"() {name = "foo", params = []} : () -> ()
   }
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
-  %type = pdl.type
+  %type = type
 
   // expected-error@below {{expected only one of [`type`, `value`] to be set}}
-  %attr = pdl.attribute : %type 10
+  %attr = attribute : %type 10
 
-  %op = pdl.operation "foo.op" {"attr" = %attr} -> (%type : !pdl.type)
-  pdl.rewrite %op with "rewriter"
+  %op = operation "foo.op" {"attr" = %attr} -> (%type : !pdl.type)
+  rewrite %op with "rewriter"
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
-  %op = pdl.operation "foo.op"
-  pdl.rewrite %op {
-    %type = pdl.type
+  %op = operation "foo.op"
+  rewrite %op {
+    %type = type
 
     // expected-error@below {{expected constant value when specified within a `pdl.rewrite`}}
-    %attr = pdl.attribute : %type
+    %attr = attribute : %type
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
-  %op = pdl.operation "foo.op"
-  pdl.rewrite %op {
+  %op = operation "foo.op"
+  rewrite %op {
     // expected-error@below {{expected constant value when specified within a `pdl.rewrite`}}
-    %attr = pdl.attribute
+    %attr = attribute
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected a bindable user when defined in the matcher body of a `pdl.pattern`}}
-  %unused = pdl.attribute
+  %unused = attribute
 
-  %op = pdl.operation "foo.op"
-  pdl.rewrite %op with "rewriter"
+  %op = operation "foo.op"
+  rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected a bindable user when defined in the matcher body of a `pdl.pattern`}}
-  %unused = pdl.operand
+  %unused = operand
 
-  %op = pdl.operation "foo.op"
-  pdl.rewrite %op with "rewriter"
+  %op = operation "foo.op"
+  rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::OperandsOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected a bindable user when defined in the matcher body of a `pdl.pattern`}}
-  %unused = pdl.operands
+  %unused = operands
 
-  %op = pdl.operation "foo.op"
-  pdl.rewrite %op with "rewriter"
+  %op = operation "foo.op"
+  rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::OperationOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
-  %op = pdl.operation "foo.op"
-  pdl.rewrite %op {
+  %op = operation "foo.op"
+  rewrite %op {
     // expected-error@below {{must have an operation name when nested within a `pdl.rewrite`}}
-    %newOp = pdl.operation
+    %newOp = operation
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected the same number of attribute values and attribute names, got 1 names and 0 values}}
   %op = "pdl.operation"() {
     attributeNames = ["attr"],
     operand_segment_sizes = dense<0> : vector<3xi32>
   } : () -> (!pdl.operation)
-  pdl.rewrite %op with "rewriter"
+  rewrite %op with "rewriter"
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
-  %op = pdl.operation "foo.op"
-  pdl.rewrite %op {
-    %type = pdl.type
+  %op = operation "foo.op"
+  rewrite %op {
+    %type = type
 
     // expected-error@below {{op must have inferable or constrained result types when nested within `pdl.rewrite`}}
     // expected-note@below {{result type #0 was not constrained}}
-    %newOp = pdl.operation "foo.op" -> (%type : !pdl.type)
+    %newOp = operation "foo.op" -> (%type : !pdl.type)
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected a bindable user when defined in the matcher body of a `pdl.pattern`}}
-  %unused = pdl.operation "foo.op"
+  %unused = operation "foo.op"
 
-  %op = pdl.operation "foo.op"
-  pdl.rewrite %op with "rewriter"
+  %op = operation "foo.op"
+  rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::PatternOp
 //===----------------------------------------------------------------------===//
 
 // expected-error@below {{expected body to terminate with `pdl.rewrite`}}
 pdl.pattern : benefit(1) {
   // expected-note@below {{see terminator defined here}}
   return
 }
 
 // -----
 
 // expected-error@below {{the pattern must contain at least one `pdl.operation`}}
 pdl.pattern : benefit(1) {
-  pdl.rewrite with "foo"
+  rewrite with "foo"
 }
 
 // -----
 // expected-error@below {{expected only `pdl` operations within the pattern body}}
 pdl.pattern : benefit(1) {
   // expected-note@below {{see non-`pdl` operation defined here}}
   "test.foo.other_op"() : () -> ()
 
-  %root = pdl.operation "foo.op"
-  pdl.rewrite %root with "foo"
+  %root = operation "foo.op"
+  rewrite %root with "foo"
 }
 
 // -----
 // expected-error@below {{the operations must form a connected component}}
 pdl.pattern : benefit(1) {
-  %op1 = pdl.operation "foo.op"
-  %op2 = pdl.operation "bar.op"
+  %op1 = operation "foo.op"
+  %op2 = operation "bar.op"
   // expected-note@below {{see a disconnected value / operation here}}
-  %val = pdl.result 0 of %op2
-  pdl.rewrite %op1 with "foo"(%val : !pdl.value)
+  %val = result 0 of %op2
+  rewrite %op1 with "foo"(%val : !pdl.value)
 }
 
 // -----
 // expected-error@below {{the operations must form a connected component}}
 pdl.pattern : benefit(1) {
-  %type = pdl.type
-  %op1 = pdl.operation "foo.op" -> (%type : !pdl.type)
-  %val = pdl.result 0 of %op1
-  %op2 = pdl.operation "bar.op"(%val : !pdl.value)
+  %type = type
+  %op1 = operation "foo.op" -> (%type : !pdl.type)
+  %val = result 0 of %op1
+  %op2 = operation "bar.op"(%val : !pdl.value)
   // expected-note@below {{see a disconnected value / operation here}}
-  %op3 = pdl.operation "baz.op"
-  pdl.rewrite {
-    pdl.erase %op1
-    pdl.erase %op2
-    pdl.erase %op3
+  %op3 = operation "baz.op"
+  rewrite {
+    erase %op1
+    erase %op2
+    erase %op3
   }
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
-  %type = pdl.type : i32
-  %root = pdl.operation "foo.op" -> (%type : !pdl.type)
-  pdl.rewrite %root {
-    %newOp = pdl.operation "foo.op" -> (%type : !pdl.type)
-    %newResult = pdl.result 0 of %newOp
+  %type = type : i32
+  %root = operation "foo.op" -> (%type : !pdl.type)
+  rewrite %root {
+    %newOp = operation "foo.op" -> (%type : !pdl.type)
+    %newResult = result 0 of %newOp
 
     // expected-error@below {{expected no replacement values to be provided when the replacement operation is present}}
     "pdl.replace"(%root, %newOp, %newResult) {
       operand_segment_sizes = dense<1> : vector<3xi32>
     } : (!pdl.operation, !pdl.operation, !pdl.value) -> ()
   }
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::ResultsOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
-  %root = pdl.operation "foo.op"
+  %root = operation "foo.op"
   // expected-error@below {{expected `pdl.range<value>` result type when no index is specified, but got: '!pdl.value'}}
   %results = "pdl.results"(%root) : (!pdl.operation) -> !pdl.value
-  pdl.rewrite %root with "rewriter"
+  rewrite %root with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::RewriteOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
-  %op = pdl.operation "foo.op"
+  %op = operation "foo.op"
 
   // expected-error@below {{expected rewrite region to be non-empty if external name is not specified}}
   "pdl.rewrite"(%op) ({}) {
     operand_segment_sizes = dense<[1,0]> : vector<2xi32>
   } : (!pdl.operation) -> ()
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
-  %op = pdl.operation "foo.op"
+  %op = operation "foo.op"
 
   // expected-error@below {{expected no external arguments when the rewrite is specified inline}}
   "pdl.rewrite"(%op, %op) ({
     ^bb1:
   }) {
     operand_segment_sizes = dense<1> : vector<2xi32>
   }: (!pdl.operation, !pdl.operation) -> ()
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
-  %op = pdl.operation "foo.op"
+  %op = operation "foo.op"
 
   // expected-error@below {{expected no external constant parameters when the rewrite is specified inline}}
   "pdl.rewrite"(%op) ({
     ^bb1:
   }) {
     operand_segment_sizes = dense<[1,0]> : vector<2xi32>,
     externalConstParams = []} : (!pdl.operation) -> ()
 }
 
 // -----
 
 pdl.pattern : benefit(1) {
-  %op = pdl.operation "foo.op"
+  %op = operation "foo.op"
 
   // expected-error@below {{expected rewrite region to be empty when rewrite is external}}
   "pdl.rewrite"(%op) ({
     ^bb1:
   }) {
     name = "foo",
     operand_segment_sizes = dense<[1,0]> : vector<2xi32>
   } : (!pdl.operation) -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected a bindable user when defined in the matcher body of a `pdl.pattern`}}
-  %unused = pdl.type
+  %unused = type
 
-  %op = pdl.operation "foo.op"
-  pdl.rewrite %op with "rewriter"
+  %op = operation "foo.op"
+  rewrite %op with "rewriter"
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl::TypesOp
 //===----------------------------------------------------------------------===//
 
 pdl.pattern : benefit(1) {
   // expected-error@below {{expected a bindable user when defined in the matcher body of a `pdl.pattern`}}
-  %unused = pdl.types
+  %unused = types
 
-  %op = pdl.operation "foo.op"
-  pdl.rewrite %op with "rewriter"
+  %op = operation "foo.op"
+  rewrite %op with "rewriter"
 }

mlir/test/Dialect/PDL/ops.mlir

 // RUN: mlir-opt -split-input-file %s | mlir-opt
 // Verify the generic form can be parsed.
 // RUN: mlir-opt -split-input-file -mlir-print-op-generic %s | mlir-opt
 
 // -----
 
 pdl.pattern @operations : benefit(1) {
   // Operation with attributes and results.
-  %attribute = pdl.attribute
-  %type = pdl.type
-  %op0 = pdl.operation {"attr" = %attribute} -> (%type : !pdl.type)
+  %attribute = attribute
+  %type = type
+  %op0 = operation {"attr" = %attribute} -> (%type : !pdl.type)
   %op0_result = pdl.result 0 of %op0
 
   // Operation with input.
-  %input = pdl.operand
-  %root = pdl.operation(%op0_result, %input : !pdl.value, !pdl.value)
-  pdl.rewrite %root with "rewriter"
+  %input = operand
+  %root = operation(%op0_result, %input : !pdl.value, !pdl.value)
+  rewrite %root with "rewriter"
 }
 
 // -----
 
 pdl.pattern @rewrite_with_args : benefit(1) {
-  %input = pdl.operand
-  %root = pdl.operation(%input : !pdl.value)
-  pdl.rewrite %root with "rewriter"(%input : !pdl.value)
+  %input = operand
+  %root = operation(%input : !pdl.value)
+  rewrite %root with "rewriter"(%input : !pdl.value)
 }
 
 // -----
 
 pdl.pattern @rewrite_with_params : benefit(1) {
-  %root = pdl.operation
-  pdl.rewrite %root with "rewriter"["I am param"]
+  %root = operation
+  rewrite %root with "rewriter"["I am param"]
 }
 
 // -----
 
 pdl.pattern @rewrite_with_args_and_params : benefit(1) {
-  %input = pdl.operand
-  %root = pdl.operation(%input : !pdl.value)
-  pdl.rewrite %root with "rewriter"["I am param"](%input : !pdl.value)
+  %input = operand
+  %root = operation(%input : !pdl.value)
+  rewrite %root with "rewriter"["I am param"](%input : !pdl.value)
 }
 
 // -----
 
 pdl.pattern @rewrite_multi_root_optimal : benefit(2) {
-  %input1 = pdl.operand
-  %input2 = pdl.operand
-  %type = pdl.type
-  %op1 = pdl.operation(%input1 : !pdl.value) -> (%type : !pdl.type)
-  %val1 = pdl.result 0 of %op1
-  %root1 = pdl.operation(%val1 : !pdl.value)
-  %op2 = pdl.operation(%input2 : !pdl.value) -> (%type : !pdl.type)
-  %val2 = pdl.result 0 of %op2
-  %root2 = pdl.operation(%val1, %val2 : !pdl.value, !pdl.value)
-  pdl.rewrite with "rewriter"["I am param"](%root1, %root2 : !pdl.operation, !pdl.operation)
+  %input1 = operand
+  %input2 = operand
+  %type = type
+  %op1 = operation(%input1 : !pdl.value) -> (%type : !pdl.type)
+  %val1 = result 0 of %op1
+  %root1 = operation(%val1 : !pdl.value)
+  %op2 = operation(%input2 : !pdl.value) -> (%type : !pdl.type)
+  %val2 = result 0 of %op2
+  %root2 = operation(%val1, %val2 : !pdl.value, !pdl.value)
+  rewrite with "rewriter"["I am param"](%root1, %root2 : !pdl.operation, !pdl.operation)
 }
 
 // -----
 
 pdl.pattern @rewrite_multi_root_forced : benefit(2) {
-  %input1 = pdl.operand
-  %input2 = pdl.operand
-  %type = pdl.type
-  %op1 = pdl.operation(%input1 : !pdl.value) -> (%type : !pdl.type)
-  %val1 = pdl.result 0 of %op1
-  %root1 = pdl.operation(%val1 : !pdl.value)
-  %op2 = pdl.operation(%input2 : !pdl.value) -> (%type : !pdl.type)
-  %val2 = pdl.result 0 of %op2
-  %root2 = pdl.operation(%val1, %val2 : !pdl.value, !pdl.value)
-  pdl.rewrite %root1 with "rewriter"["I am param"](%root2 : !pdl.operation)
+  %input1 = operand
+  %input2 = operand
+  %type = type
+  %op1 = operation(%input1 : !pdl.value) -> (%type : !pdl.type)
+  %val1 = result 0 of %op1
+  %root1 = operation(%val1 : !pdl.value)
+  %op2 = operation(%input2 : !pdl.value) -> (%type : !pdl.type)
+  %val2 = result 0 of %op2
+  %root2 = operation(%val1, %val2 : !pdl.value, !pdl.value)
+  rewrite %root1 with "rewriter"["I am param"](%root2 : !pdl.operation)
 }
 
 // -----
 
 // Check that the result type of an operation within a rewrite can be inferred
 // from a pdl.replace.
 pdl.pattern @infer_type_from_operation_replace : benefit(1) {
-  %type1 = pdl.type : i32
-  %type2 = pdl.type
-  %root = pdl.operation -> (%type1, %type2 : !pdl.type, !pdl.type)
-  pdl.rewrite %root {
-    %type3 = pdl.type
-    %newOp = pdl.operation "foo.op" -> (%type1, %type3 : !pdl.type, !pdl.type)
-    pdl.replace %root with %newOp
+  %type1 = type : i32
+  %type2 = type
+  %root = operation -> (%type1, %type2 : !pdl.type, !pdl.type)
+  rewrite %root {
+    %type3 = type
+    %newOp = operation "foo.op" -> (%type1, %type3 : !pdl.type, !pdl.type)
+    replace %root with %newOp
   }
 }
 
 // -----
 
 // Check that the result type of an operation within a rewrite can be inferred
 // from the result types of an operation within the match block.
 pdl.pattern @infer_type_from_type_used_in_match : benefit(1) {
-  %type1 = pdl.type : i32
-  %type2 = pdl.type
-  %root = pdl.operation -> (%type1, %type2 : !pdl.type, !pdl.type)
-  pdl.rewrite %root {
-    %newOp = pdl.operation "foo.op" -> (%type1, %type2 : !pdl.type, !pdl.type)
+  %type1 = type : i32
+  %type2 = type
+  %root = operation -> (%type1, %type2 : !pdl.type, !pdl.type)
+  rewrite %root {
+    %newOp = operation "foo.op" -> (%type1, %type2 : !pdl.type, !pdl.type)
   }
 }
 
 // -----
 
 // Check that the result type of an operation within a rewrite can be inferred
 // from the result types of an operation within the match block.
 pdl.pattern @infer_type_from_type_used_in_match : benefit(1) {
-  %types = pdl.types
-  %root = pdl.operation -> (%types : !pdl.range<type>)
-  pdl.rewrite %root {
-    %otherTypes = pdl.types : [i32, i64]
-    %newOp = pdl.operation "foo.op" -> (%types, %otherTypes : !pdl.range<type>, !pdl.range<type>)
+  %types = types
+  %root = operation -> (%types : !pdl.range<type>)
+  rewrite %root {
+    %otherTypes = types : [i32, i64]
+    %newOp = operation "foo.op" -> (%types, %otherTypes : !pdl.range<type>, !pdl.range<type>)
   }
 }
 
 // -----
 
 // Check that the result type of an operation within a rewrite can be inferred
 // from the type of an operand within the match block.
 pdl.pattern @infer_type_from_type_used_in_match : benefit(1) {
-  %type1 = pdl.type
-  %type2 = pdl.type
-  %operand1 = pdl.operand : %type1
-  %operand2 = pdl.operand : %type2
-  %root = pdl.operation (%operand1, %operand2 : !pdl.value, !pdl.value)
-  pdl.rewrite %root {
-    %newOp = pdl.operation "foo.op" -> (%type1, %type2 : !pdl.type, !pdl.type)
+  %type1 = type
+  %type2 = type
+  %operand1 = operand : %type1
+  %operand2 = operand : %type2
+  %root = operation (%operand1, %operand2 : !pdl.value, !pdl.value)
+  rewrite %root {
+    %newOp = operation "foo.op" -> (%type1, %type2 : !pdl.type, !pdl.type)
   }
 }
 
 // -----
 
 // Check that the result type of an operation within a rewrite can be inferred
 // from the types of operands within the match block.
 pdl.pattern @infer_type_from_type_used_in_match : benefit(1) {
-  %types = pdl.types
-  %operands = pdl.operands : %types
-  %root = pdl.operation (%operands : !pdl.range<value>)
-  pdl.rewrite %root {
-    %newOp = pdl.operation "foo.op" -> (%types : !pdl.range<type>)
+  %types = types
+  %operands = operands : %types
+  %root = operation (%operands : !pdl.range<value>)
+  rewrite %root {
+    %newOp = operation "foo.op" -> (%types : !pdl.range<type>)
   }
 }
 
 // -----
 
 pdl.pattern @apply_rewrite_with_no_results : benefit(1) {
-  %root = pdl.operation
-  pdl.rewrite %root {
-    pdl.apply_native_rewrite "NativeRewrite"(%root : !pdl.operation)
+  %root = operation
+  rewrite %root {
+    apply_native_rewrite "NativeRewrite"(%root : !pdl.operation)
   }
 }
 
 // -----
 
 pdl.pattern @attribute_with_dict : benefit(1) {
-  %root = pdl.operation
-  pdl.rewrite %root {
-    %attr = pdl.attribute {some_unit_attr} attributes {pdl.special_attribute}
-    pdl.apply_native_rewrite "NativeRewrite"(%attr : !pdl.attribute)
+  %root = operation
+  rewrite %root {
+    %attr = attribute {some_unit_attr} attributes {pdl.special_attribute}
+    apply_native_rewrite "NativeRewrite"(%attr : !pdl.attribute)
   }
 }

mlir/test/python/dialects/pdl_ops.py

with Context(), Location.unknown():
     with InsertionPoint(module.body):
       f()
     print(module)
   return f
 
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @operations : benefit(1)  {
-# CHECK:     %0 = pdl.attribute
-# CHECK:     %1 = pdl.type
-# CHECK:     %2 = pdl.operation  {"attr" = %0} -> (%1 : !pdl.type)
-# CHECK:     %3 = pdl.result 0 of %2
-# CHECK:     %4 = pdl.operand
-# CHECK:     %5 = pdl.operation(%3, %4 : !pdl.value, !pdl.value)
-# CHECK:     pdl.rewrite %5 with "rewriter"
+# CHECK:     %0 = attribute
+# CHECK:     %1 = type
+# CHECK:     %2 = operation  {"attr" = %0} -> (%1 : !pdl.type)
+# CHECK:     %3 = result 0 of %2
+# CHECK:     %4 = operand
+# CHECK:     %5 = operation(%3, %4 : !pdl.value, !pdl.value)
+# CHECK:     rewrite %5 with "rewriter"
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_operations():
   pattern = PatternOp(1, "operations")
   with InsertionPoint(pattern.body):
     attr = AttributeOp()
     ty = TypeOp()
     op0 = OperationOp(attributes={"attr": attr}, types=[ty])
     op0_result = ResultOp(op0, 0)
     input = OperandOp()
     root = OperationOp(args=[op0_result, input])
     RewriteOp(root, "rewriter")
 
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_with_args : benefit(1)  {
-# CHECK:     %0 = pdl.operand
-# CHECK:     %1 = pdl.operation(%0 : !pdl.value)
-# CHECK:     pdl.rewrite %1 with "rewriter"(%0 : !pdl.value)
+# CHECK:     %0 = operand
+# CHECK:     %1 = operation(%0 : !pdl.value)
+# CHECK:     rewrite %1 with "rewriter"(%0 : !pdl.value)
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_rewrite_with_args():
   pattern = PatternOp(1, "rewrite_with_args")
   with InsertionPoint(pattern.body):
     input = OperandOp()
     root = OperationOp(args=[input])
     RewriteOp(root, "rewriter", args=[input])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_with_params : benefit(1)  {
-# CHECK:     %0 = pdl.operation
-# CHECK:     pdl.rewrite %0 with "rewriter" ["I am param"]
+# CHECK:     %0 = operation
+# CHECK:     rewrite %0 with "rewriter" ["I am param"]
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_rewrite_with_params():
   pattern = PatternOp(1, "rewrite_with_params")
   with InsertionPoint(pattern.body):
     op = OperationOp()
     RewriteOp(op, "rewriter", params=[StringAttr.get("I am param")])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_with_args_and_params : benefit(1)  {
-# CHECK:     %0 = pdl.operand
-# CHECK:     %1 = pdl.operation(%0 : !pdl.value)
-# CHECK:     pdl.rewrite %1 with "rewriter" ["I am param"](%0 : !pdl.value)
+# CHECK:     %0 = operand
+# CHECK:     %1 = operation(%0 : !pdl.value)
+# CHECK:     rewrite %1 with "rewriter" ["I am param"](%0 : !pdl.value)
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_rewrite_with_args_and_params():
   pattern = PatternOp(1, "rewrite_with_args_and_params")
   with InsertionPoint(pattern.body):
     input = OperandOp()
     root = OperationOp(args=[input])
     RewriteOp(root, "rewriter", params=[StringAttr.get("I am param")], args=[input])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_multi_root_optimal : benefit(1)  {
-# CHECK:     %0 = pdl.operand
-# CHECK:     %1 = pdl.operand
-# CHECK:     %2 = pdl.type
-# CHECK:     %3 = pdl.operation(%0 : !pdl.value)  -> (%2 : !pdl.type)
-# CHECK:     %4 = pdl.result 0 of %3
-# CHECK:     %5 = pdl.operation(%4 : !pdl.value)
-# CHECK:     %6 = pdl.operation(%1 : !pdl.value)  -> (%2 : !pdl.type)
-# CHECK:     %7 = pdl.result 0 of %6
-# CHECK:     %8 = pdl.operation(%4, %7 : !pdl.value, !pdl.value)
-# CHECK:     pdl.rewrite with "rewriter" ["I am param"](%5, %8 : !pdl.operation, !pdl.operation)
+# CHECK:     %0 = operand
+# CHECK:     %1 = operand
+# CHECK:     %2 = type
+# CHECK:     %3 = operation(%0 : !pdl.value)  -> (%2 : !pdl.type)
+# CHECK:     %4 = result 0 of %3
+# CHECK:     %5 = operation(%4 : !pdl.value)
+# CHECK:     %6 = operation(%1 : !pdl.value)  -> (%2 : !pdl.type)
+# CHECK:     %7 = result 0 of %6
+# CHECK:     %8 = operation(%4, %7 : !pdl.value, !pdl.value)
+# CHECK:     rewrite with "rewriter" ["I am param"](%5, %8 : !pdl.operation, !pdl.operation)
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_rewrite_multi_root_optimal():
   pattern = PatternOp(1, "rewrite_multi_root_optimal")
   with InsertionPoint(pattern.body):
     input1 = OperandOp()
     input2 = OperandOp()
     ty = TypeOp()
     op1 = OperationOp(args=[input1], types=[ty])
     val1 = ResultOp(op1, 0)
     root1 = OperationOp(args=[val1])
     op2 = OperationOp(args=[input2], types=[ty])
     val2 = ResultOp(op2, 0)
     root2 = OperationOp(args=[val1, val2])
     RewriteOp(name="rewriter", params=[StringAttr.get("I am param")], args=[root1, root2])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_multi_root_forced : benefit(1)  {
-# CHECK:     %0 = pdl.operand
-# CHECK:     %1 = pdl.operand
-# CHECK:     %2 = pdl.type
-# CHECK:     %3 = pdl.operation(%0 : !pdl.value)  -> (%2 : !pdl.type)
-# CHECK:     %4 = pdl.result 0 of %3
-# CHECK:     %5 = pdl.operation(%4 : !pdl.value)
-# CHECK:     %6 = pdl.operation(%1 : !pdl.value)  -> (%2 : !pdl.type)
-# CHECK:     %7 = pdl.result 0 of %6
-# CHECK:     %8 = pdl.operation(%4, %7 : !pdl.value, !pdl.value)
-# CHECK:     pdl.rewrite %5 with "rewriter" ["I am param"](%8 : !pdl.operation)
+# CHECK:     %0 = operand
+# CHECK:     %1 = operand
+# CHECK:     %2 = type
+# CHECK:     %3 = operation(%0 : !pdl.value)  -> (%2 : !pdl.type)
+# CHECK:     %4 = result 0 of %3
+# CHECK:     %5 = operation(%4 : !pdl.value)
+# CHECK:     %6 = operation(%1 : !pdl.value)  -> (%2 : !pdl.type)
+# CHECK:     %7 = result 0 of %6
+# CHECK:     %8 = operation(%4, %7 : !pdl.value, !pdl.value)
+# CHECK:     rewrite %5 with "rewriter" ["I am param"](%8 : !pdl.operation)
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_rewrite_multi_root_forced():
   pattern = PatternOp(1, "rewrite_multi_root_forced")
   with InsertionPoint(pattern.body):
     input1 = OperandOp()
     input2 = OperandOp()
     ty = TypeOp()
     op1 = OperationOp(args=[input1], types=[ty])
     val1 = ResultOp(op1, 0)
     root1 = OperationOp(args=[val1])
     op2 = OperationOp(args=[input2], types=[ty])
     val2 = ResultOp(op2, 0)
     root2 = OperationOp(args=[val1, val2])
     RewriteOp(root1, name="rewriter", params=[StringAttr.get("I am param")], args=[root2])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_add_body : benefit(1)  {
-# CHECK:     %0 = pdl.type : i32
-# CHECK:     %1 = pdl.type
-# CHECK:     %2 = pdl.operation  -> (%0, %1 : !pdl.type, !pdl.type)
-# CHECK:     pdl.rewrite %2  {
-# CHECK:       %3 = pdl.type
-# CHECK:       %4 = pdl.operation "foo.op"  -> (%0, %3 : !pdl.type, !pdl.type)
-# CHECK:       pdl.replace %2 with %4
+# CHECK:     %0 = type : i32
+# CHECK:     %1 = type
+# CHECK:     %2 = operation  -> (%0, %1 : !pdl.type, !pdl.type)
+# CHECK:     rewrite %2  {
+# CHECK:       %3 = type
+# CHECK:       %4 = operation "foo.op"  -> (%0, %3 : !pdl.type, !pdl.type)
+# CHECK:       replace %2 with %4
 # CHECK:     }
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_rewrite_add_body():
   pattern = PatternOp(1, "rewrite_add_body")
   with InsertionPoint(pattern.body):
     ty1 = TypeOp(IntegerType.get_signless(32))
     ty2 = TypeOp()
     root = OperationOp(types=[ty1, ty2])
     rewrite = RewriteOp(root)
     with InsertionPoint(rewrite.add_body()):
       ty3 = TypeOp()
       newOp = OperationOp(name="foo.op", types=[ty1, ty3])
       ReplaceOp(root, with_op=newOp)
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_type : benefit(1)  {
-# CHECK:     %0 = pdl.type : i32
-# CHECK:     %1 = pdl.type
-# CHECK:     %2 = pdl.operation  -> (%0, %1 : !pdl.type, !pdl.type)
-# CHECK:     pdl.rewrite %2  {
-# CHECK:       %3 = pdl.operation "foo.op"  -> (%0, %1 : !pdl.type, !pdl.type)
+# CHECK:     %0 = type : i32
+# CHECK:     %1 = type
+# CHECK:     %2 = operation  -> (%0, %1 : !pdl.type, !pdl.type)
+# CHECK:     rewrite %2  {
+# CHECK:       %3 = operation "foo.op"  -> (%0, %1 : !pdl.type, !pdl.type)
 # CHECK:     }
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_rewrite_type():
   pattern = PatternOp(1, "rewrite_type")
   with InsertionPoint(pattern.body):
     ty1 = TypeOp(IntegerType.get_signless(32))
     ty2 = TypeOp()
     root = OperationOp(types=[ty1, ty2])
     rewrite = RewriteOp(root)
     with InsertionPoint(rewrite.add_body()):
       newOp = OperationOp(name="foo.op", types=[ty1, ty2])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_types : benefit(1)  {
-# CHECK:     %0 = pdl.types
-# CHECK:     %1 = pdl.operation  -> (%0 : !pdl.range<type>)
-# CHECK:     pdl.rewrite %1  {
-# CHECK:       %2 = pdl.types : [i32, i64]
-# CHECK:       %3 = pdl.operation "foo.op"  -> (%0, %2 : !pdl.range<type>, !pdl.range<type>)
+# CHECK:     %0 = types
+# CHECK:     %1 = operation  -> (%0 : !pdl.range<type>)
+# CHECK:     rewrite %1  {
+# CHECK:       %2 = types : [i32, i64]
+# CHECK:       %3 = operation "foo.op"  -> (%0, %2 : !pdl.range<type>, !pdl.range<type>)
 # CHECK:     }
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_rewrite_types():
   pattern = PatternOp(1, "rewrite_types")
   with InsertionPoint(pattern.body):
     types = TypesOp()
     root = OperationOp(types=[types])
     rewrite = RewriteOp(root)
     with InsertionPoint(rewrite.add_body()):
       otherTypes = TypesOp([IntegerType.get_signless(32), IntegerType.get_signless(64)])
       newOp = OperationOp(name="foo.op", types=[types, otherTypes])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @rewrite_operands : benefit(1)  {
-# CHECK:     %0 = pdl.types
-# CHECK:     %1 = pdl.operands : %0
-# CHECK:     %2 = pdl.operation(%1 : !pdl.range<value>)
-# CHECK:     pdl.rewrite %2  {
-# CHECK:       %3 = pdl.operation "foo.op"  -> (%0 : !pdl.range<type>)
+# CHECK:     %0 = types
+# CHECK:     %1 = operands : %0
+# CHECK:     %2 = operation(%1 : !pdl.range<value>)
+# CHECK:     rewrite %2  {
+# CHECK:       %3 = operation "foo.op"  -> (%0 : !pdl.range<type>)
 # CHECK:     }
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_rewrite_operands():
   pattern = PatternOp(1, "rewrite_operands")
   with InsertionPoint(pattern.body):
     types = TypesOp()
     operands = OperandsOp(types)
     root = OperationOp(args=[operands])
     rewrite = RewriteOp(root)
     with InsertionPoint(rewrite.add_body()):
       newOp = OperationOp(name="foo.op", types=[types])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @native_rewrite : benefit(1)  {
-# CHECK:     %0 = pdl.operation
-# CHECK:     pdl.rewrite %0  {
-# CHECK:       pdl.apply_native_rewrite "NativeRewrite"(%0 : !pdl.operation)
+# CHECK:     %0 = operation
+# CHECK:     rewrite %0  {
+# CHECK:       apply_native_rewrite "NativeRewrite"(%0 : !pdl.operation)
 # CHECK:     }
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_native_rewrite():
   pattern = PatternOp(1, "native_rewrite")
   with InsertionPoint(pattern.body):
     root = OperationOp()
     rewrite = RewriteOp(root)
     with InsertionPoint(rewrite.add_body()):
       ApplyNativeRewriteOp([], "NativeRewrite", args=[root])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @attribute_with_value : benefit(1)  {
-# CHECK:     %0 = pdl.operation
-# CHECK:     pdl.rewrite %0  {
-# CHECK:       %1 = pdl.attribute "value"
-# CHECK:       pdl.apply_native_rewrite "NativeRewrite"(%1 : !pdl.attribute)
+# CHECK:     %0 = operation
+# CHECK:     rewrite %0  {
+# CHECK:       %1 = attribute "value"
+# CHECK:       apply_native_rewrite "NativeRewrite"(%1 : !pdl.attribute)
 # CHECK:     }
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_attribute_with_value():
   pattern = PatternOp(1, "attribute_with_value")
   with InsertionPoint(pattern.body):
     root = OperationOp()
     rewrite = RewriteOp(root)
     with InsertionPoint(rewrite.add_body()):
       attr = AttributeOp(value=Attribute.parse('"value"'))
       ApplyNativeRewriteOp([], "NativeRewrite", args=[attr])
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @erase : benefit(1)  {
-# CHECK:     %0 = pdl.operation
-# CHECK:     pdl.rewrite %0  {
-# CHECK:       pdl.erase %0
+# CHECK:     %0 = operation
+# CHECK:     rewrite %0  {
+# CHECK:       erase %0
 # CHECK:     }
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_erase():
   pattern = PatternOp(1, "erase")
   with InsertionPoint(pattern.body):
     root = OperationOp()
     rewrite = RewriteOp(root)
     with InsertionPoint(rewrite.add_body()):
       EraseOp(root)
 
 # CHECK: module  {
 # CHECK:   pdl.pattern @operation_results : benefit(1)  {
-# CHECK:     %0 = pdl.types
-# CHECK:     %1 = pdl.operation  -> (%0 : !pdl.range<type>)
-# CHECK:     %2 = pdl.results of %1
-# CHECK:     %3 = pdl.operation(%2 : !pdl.range<value>)
-# CHECK:     pdl.rewrite %3 with "rewriter"
+# CHECK:     %0 = types
+# CHECK:     %1 = operation  -> (%0 : !pdl.range<type>)
+# CHECK:     %2 = results of %1
+# CHECK:     %3 = operation(%2 : !pdl.range<value>)
+# CHECK:     rewrite %3 with "rewriter"
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_operation_results():
   valueRange = RangeType.get(ValueType.get())
   pattern = PatternOp(1, "operation_results")
   with InsertionPoint(pattern.body):
     types = TypesOp()
     inputOp = OperationOp(types=[types])
     results = ResultsOp(valueRange, inputOp)
     root = OperationOp(args=[results])
     RewriteOp(root, name="rewriter")
 
 # CHECK: module  {
 # CHECK:   pdl.pattern : benefit(1)  {
-# CHECK:     %0 = pdl.type
-# CHECK:     pdl.apply_native_constraint "typeConstraint" [](%0 : !pdl.type)
-# CHECK:     %1 = pdl.operation  -> (%0 : !pdl.type)
-# CHECK:     pdl.rewrite %1 with "rewrite"
+# CHECK:     %0 = type
+# CHECK:     apply_native_constraint "typeConstraint" [](%0 : !pdl.type)
+# CHECK:     %1 = operation  -> (%0 : !pdl.type)
+# CHECK:     rewrite %1 with "rewrite"
 # CHECK:   }
 # CHECK: }
 @constructAndPrintInModule
 def test_apply_native_constraint():
   pattern = PatternOp(1)
   with InsertionPoint(pattern.body):
     resultType = TypeOp()
     ApplyNativeConstraintOp("typeConstraint", args=[resultType], params=[])
     root = OperationOp(types=[resultType])
     RewriteOp(root, name="rewrite")