[mlir] use OpBuilderDAG instead of OpBuilder

[ftynse]

Summary

A recent commit introduced a new syntax for specifying builder arguments in
ODS, which is better amenable to automated processing, and deprecated the old
form. Transition all dialects as well as Linalg ODS generator to use the new
syntax.

Add a deprecation notice to ODS generator.

[rriddle]

mlir/examples/toy/Ch2/include/toy/Ops.td

72

Can we keep this on the previous line still?

mlir/examples/toy/Ch3/include/toy/Ops.td

71

Same here and others. Keeping the brace on the previous line seems like a common stylistic thing that we do.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1236

Can you state which format is deprecated? and maybe hint at which one should be used instead?

[ftynse]

Address review

[rriddle]

LGTM

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1235

nit: Add braces here given the body isn't trivial.

[ftynse]

mlir/examples/toy/Ch3/include/toy/Ops.td

71

Some files don't do this, so I kept them as is, basically reducing the style-only diff I introduced.

I wish we had tblgen-format :)

[ftynse]

Address more review and rebase

mlir/docs/Tutorials/Toy/Ch-2.md

 def ConstantOp : Toy_Op<"constant"> {
   ...
 
   // Add custom build methods for the constant operation. These methods populate
   // the `state` that MLIR uses to create operations, i.e. these are used when
   // using `builder.create<ConstantOp>(...)`.
   let builders = [
     // Build a constant with a given constant tensor value.
-    OpBuilder<"DenseElementsAttr value", [{
+    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
       // Call into an autogenerated `build` method.
       build(builder, result, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value. This builder
     // creates a declaration for `ConstantOp::build` with the given parameters.
-    OpBuilder<"double value">
+    OpBuilderDAG<(ins "double":$value)>
   ];
 }
 ```
 
 #### Specifying a Custom Assembly Format
 
 At this point we can generate our "Toy IR". For example, the following:
 

mlir/examples/toy/Ch2/include/toy/Ops.td

def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
   let parser = [{ return ::parseConstantOp(parser, result); }];
   let printer = [{ return ::print(p, *this); }];
 
   // Add custom build methods for the constant operation. These method populates
   // the `state` that MLIR uses to create operations, i.e. these are used when
   // using `builder.create<ConstantOp>(...)`.
   let builders = [
     // Build a constant with a given constant tensor value.
-    OpBuilder<"DenseElementsAttr value", [{
+    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilder<"double value">
+    OpBuilderDAG<(ins "double":$value)>
   ];
 
   // Invoke a static verify method to verify this constant operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 def AddOp : Toy_Op<"add"> {
   let summary = "element-wise addition operation";
   let description = [{
     The "add" operation performs element-wise addition between two tensors.
     The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building an AddOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def GenericCallOp : Toy_Op<"generic_call"> {
   let summary = "generic call operation";
   let description = [{
     Generic calls represent calls to a user defined function that needs to
     be specialized for the shape of its arguments. The callee name is attached
def GenericCallOp : Toy_Op<"generic_call"> {
 
   // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
-    OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
+    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
   ];
 }
 
 def MulOp : Toy_Op<"mul"> {
   let summary = "element-wise multiplication operation";
   let description = [{
     The "mul" operation performs element-wise multiplication between two
     tensors. The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building a MulOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def PrintOp : Toy_Op<"print"> {
   let summary = "print operation";
   let description = [{
     The "print" builtin operation prints a given input tensor, and produces
     no results.
def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
   // value must match the return type of the enclosing function.
   let arguments = (ins Variadic<F64Tensor>:$input);
 
   // The return operation only emits the input in the format if it is present.
   let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
 
   // Allow building a ReturnOp with no return operand.
   let builders = [
-    OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
   ];
 
   // Provide extra utility definitions on the c++ operation class definition.
   let extraClassDeclaration = [{
     bool hasOperand() { return getNumOperands() != 0; }
   }];
 
   // Invoke a static verify method to verify this return operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 def TransposeOp : Toy_Op<"transpose"> {
   let summary = "transpose operation";
 
   let arguments = (ins F64Tensor:$input);
   let results = (outs F64Tensor);
 
   let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];
 
   // Allow building a TransposeOp with from the input operand.
   let builders = [
-    OpBuilder<"Value input">
+    OpBuilderDAG<(ins "Value":$input)>
   ];
 
   // Invoke a static verify method to verify this transpose operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 #endif // TOY_OPS

mlir/examples/toy/Ch3/include/toy/Ops.td

def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
   let parser = [{ return ::parseConstantOp(parser, result); }];
   let printer = [{ return ::print(p, *this); }];
 
   // Add custom build methods for the constant operation. These method populates
   // the `state` that MLIR uses to create operations, i.e. these are used when
   // using `builder.create<ConstantOp>(...)`.
   let builders = [
     // Build a constant with a given constant tensor value.
-    OpBuilder<"DenseElementsAttr value", [{
+    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilder<"double value">
+    OpBuilderDAG<(ins "double":$value)>
   ];
 
   // Invoke a static verify method to verify this constant operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 def AddOp : Toy_Op<"add", [NoSideEffect]> {
   let summary = "element-wise addition operation";
   let description = [{
     The "add" operation performs element-wise addition between two tensors.
     The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building an AddOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def GenericCallOp : Toy_Op<"generic_call"> {
   let summary = "generic call operation";
   let description = [{
     Generic calls represent calls to a user defined function that needs to
     be specialized for the shape of its arguments. The callee name is attached
def GenericCallOp : Toy_Op<"generic_call"> {
 
   // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
-    OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
+    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
   ];
 }
 
 def MulOp : Toy_Op<"mul", [NoSideEffect]> {
   let summary = "element-wise multiplication operation";
   let description = [{
     The "mul" operation performs element-wise multiplication between two
     tensors. The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building a MulOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def PrintOp : Toy_Op<"print"> {
   let summary = "print operation";
   let description = [{
     The "print" builtin operation prints a given input tensor, and produces
     no results.
def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
   // value must match the return type of the enclosing function.
   let arguments = (ins Variadic<F64Tensor>:$input);
 
   // The return operation only emits the input in the format if it is present.
   let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
 
   // Allow building a ReturnOp with no return operand.
   let builders = [
-    OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
   ];
 
   // Provide extra utility definitions on the c++ operation class definition.
   let extraClassDeclaration = [{
     bool hasOperand() { return getNumOperands() != 0; }
   }];
 
   // Invoke a static verify method to verify this return operation.
let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];
 
   // Enable registering canonicalization patterns with this operation.
   let hasCanonicalizer = 1;
 
   // Allow building a TransposeOp with from the input operand.
   let builders = [
-    OpBuilder<"Value input">
+    OpBuilderDAG<(ins "Value":$input)>
   ];
 
   // Invoke a static verify method to verify this transpose operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 #endif // TOY_OPS

mlir/examples/toy/Ch4/include/toy/Ops.td

def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
   let parser = [{ return ::parseConstantOp(parser, result); }];
   let printer = [{ return ::print(p, *this); }];
 
   // Add custom build methods for the constant operation. These method populates
   // the `state` that MLIR uses to create operations, i.e. these are used when
   // using `builder.create<ConstantOp>(...)`.
   let builders = [
     // Build a constant with a given constant tensor value.
-    OpBuilder<"DenseElementsAttr value", [{
+    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilder<"double value">
+    OpBuilderDAG<(ins "double":$value)>
   ];
 
   // Invoke a static verify method to verify this constant operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 def AddOp : Toy_Op<"add",
     [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise addition operation";
   let description = [{
     The "add" operation performs element-wise addition between two tensors.
     The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building an AddOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def CastOp : Toy_Op<"cast",
     [DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect,
      SameOperandsAndResultShape]> {
   let summary = "shape cast operation";
   let description = [{
def GenericCallOp : Toy_Op<"generic_call",
 
   // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
-    OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
+    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
   ];
 }
 
 def MulOp : Toy_Op<"mul",
     [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise multiplication operation";
   let description = [{
     The "mul" operation performs element-wise multiplication between two
     tensors. The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building a MulOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def PrintOp : Toy_Op<"print"> {
   let summary = "print operation";
   let description = [{
     The "print" builtin operation prints a given input tensor, and produces
     no results.
def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
   // value must match the return type of the enclosing function.
   let arguments = (ins Variadic<F64Tensor>:$input);
 
   // The return operation only emits the input in the format if it is present.
   let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
 
   // Allow building a ReturnOp with no return operand.
   let builders = [
-    OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
   ];
 
   // Provide extra utility definitions on the c++ operation class definition.
   let extraClassDeclaration = [{
     bool hasOperand() { return getNumOperands() != 0; }
   }];
 
   // Invoke a static verify method to verify this return operation.
let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];
 
   // Enable registering canonicalization patterns with this operation.
   let hasCanonicalizer = 1;
 
   // Allow building a TransposeOp with from the input operand.
   let builders = [
-    OpBuilder<"Value input">
+    OpBuilderDAG<(ins "Value":$input)>
   ];
 
   // Invoke a static verify method to verify this transpose operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 #endif // TOY_OPS

mlir/examples/toy/Ch5/include/toy/Ops.td

def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
   let parser = [{ return ::parseConstantOp(parser, result); }];
   let printer = [{ return ::print(p, *this); }];
 
   // Add custom build methods for the constant operation. These method populates
   // the `state` that MLIR uses to create operations, i.e. these are used when
   // using `builder.create<ConstantOp>(...)`.
   let builders = [
     // Build a constant with a given constant tensor value.
-    OpBuilder<"DenseElementsAttr value", [{
+    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilder<"double value">
+    OpBuilderDAG<(ins "double":$value)>
   ];
 
   // Invoke a static verify method to verify this constant operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 def AddOp : Toy_Op<"add",
     [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise addition operation";
   let description = [{
     The "add" operation performs element-wise addition between two tensors.
     The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building an AddOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def CastOp : Toy_Op<"cast",
     [DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect,
      SameOperandsAndResultShape]> {
   let summary = "shape cast operation";
   let description = [{
def GenericCallOp : Toy_Op<"generic_call",
 
   // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
-    OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
+    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
   ];
 }
 
 def MulOp : Toy_Op<"mul",
     [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise multiplication operation";
   let description = [{
     The "mul" operation performs element-wise multiplication between two
     tensors. The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building a MulOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def PrintOp : Toy_Op<"print"> {
   let summary = "print operation";
   let description = [{
     The "print" builtin operation prints a given input tensor, and produces
     no results.
def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
   // value must match the return type of the enclosing function.
   let arguments = (ins Variadic<F64Tensor>:$input);
 
   // The return operation only emits the input in the format if it is present.
   let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
 
   // Allow building a ReturnOp with no return operand.
   let builders = [
-    OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
   ];
 
   // Provide extra utility definitions on the c++ operation class definition.
   let extraClassDeclaration = [{
     bool hasOperand() { return getNumOperands() != 0; }
   }];
 
   // Invoke a static verify method to verify this return operation.
let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];
 
   // Enable registering canonicalization patterns with this operation.
   let hasCanonicalizer = 1;
 
   // Allow building a TransposeOp with from the input operand.
   let builders = [
-    OpBuilder<"Value input">
+    OpBuilderDAG<(ins "Value":$input)>
   ];
 
   // Invoke a static verify method to verify this transpose operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 #endif // TOY_OPS

mlir/examples/toy/Ch6/include/toy/Ops.td

def ConstantOp : Toy_Op<"constant", [NoSideEffect]> {
   let parser = [{ return ::parseConstantOp(parser, result); }];
   let printer = [{ return ::print(p, *this); }];
 
   // Add custom build methods for the constant operation. These method populates
   // the `state` that MLIR uses to create operations, i.e. these are used when
   // using `builder.create<ConstantOp>(...)`.
   let builders = [
     // Build a constant with a given constant tensor value.
-    OpBuilder<"DenseElementsAttr value", [{
+    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilder<"double value">
+    OpBuilderDAG<(ins "double":$value)>
   ];
 
   // Invoke a static verify method to verify this constant operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 def AddOp : Toy_Op<"add",
     [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise addition operation";
   let description = [{
     The "add" operation performs element-wise addition between two tensors.
     The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building an AddOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def CastOp : Toy_Op<"cast",
     [DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect,
      SameOperandsAndResultShape]> {
   let summary = "shape cast operation";
   let description = [{
def GenericCallOp : Toy_Op<"generic_call",
 
   // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
-    OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
+    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
   ];
 }
 
 def MulOp : Toy_Op<"mul",
     [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise multiplication operation";
   let description = [{
     The "mul" operation performs element-wise multiplication between two
     tensors. The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building a MulOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def PrintOp : Toy_Op<"print"> {
   let summary = "print operation";
   let description = [{
     The "print" builtin operation prints a given input tensor, and produces
     no results.
def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
   // value must match the return type of the enclosing function.
   let arguments = (ins Variadic<F64Tensor>:$input);
 
   // The return operation only emits the input in the format if it is present.
   let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
 
   // Allow building a ReturnOp with no return operand.
   let builders = [
-    OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
   ];
 
   // Provide extra utility definitions on the c++ operation class definition.
   let extraClassDeclaration = [{
     bool hasOperand() { return getNumOperands() != 0; }
   }];
 
   // Invoke a static verify method to verify this return operation.
let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];
 
   // Enable registering canonicalization patterns with this operation.
   let hasCanonicalizer = 1;
 
   // Allow building a TransposeOp with from the input operand.
   let builders = [
-    OpBuilder<"Value input">
+    OpBuilderDAG<(ins "Value":$input)>
   ];
 
   // Invoke a static verify method to verify this transpose operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 #endif // TOY_OPS

mlir/examples/toy/Ch7/include/toy/Ops.td

def ConstantOp : Toy_Op<"constant",
   let parser = [{ return ::parseConstantOp(parser, result); }];
   let printer = [{ return ::print(p, *this); }];
 
   // Add custom build methods for the constant operation. These method populates
   // the `state` that MLIR uses to create operations, i.e. these are used when
   // using `builder.create<ConstantOp>(...)`.
   let builders = [
     // Build a constant with a given constant tensor value.
-    OpBuilder<"DenseElementsAttr value", [{
+    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilder<"double value">
+    OpBuilderDAG<(ins "double":$value)>
   ];
 
   // Invoke a static verify method to verify this constant operation.
   let verifier = [{ return ::verify(*this); }];
 
   // Set the folder bit so that we can implement constant folders.
   let hasFolder = 1;
 }
def AddOp : Toy_Op<"add",
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building an AddOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def CastOp : Toy_Op<"cast",
     [DeclareOpInterfaceMethods<ShapeInferenceOpInterface>, NoSideEffect,
      SameOperandsAndResultShape]> {
   let summary = "shape cast operation";
   let description = [{
def GenericCallOp : Toy_Op<"generic_call",
 
   // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
-    OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
+    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
   ];
 }
 
 def MulOp : Toy_Op<"mul",
     [NoSideEffect, DeclareOpInterfaceMethods<ShapeInferenceOpInterface>]> {
   let summary = "element-wise multiplication operation";
   let description = [{
     The "mul" operation performs element-wise multiplication between two
     tensors. The shapes of the tensor operands are expected to match.
   }];
 
   let arguments = (ins F64Tensor:$lhs, F64Tensor:$rhs);
   let results = (outs F64Tensor);
 
   // Specify a parser and printer method.
   let parser = [{ return ::parseBinaryOp(parser, result); }];
   let printer = [{ return ::printBinaryOp(p, *this); }];
 
   // Allow building a MulOp with from the two input operands.
   let builders = [
-    OpBuilder<"Value lhs, Value rhs">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def PrintOp : Toy_Op<"print"> {
   let summary = "print operation";
   let description = [{
     The "print" builtin operation prints a given input tensor, and produces
     no results.
def ReturnOp : Toy_Op<"return", [NoSideEffect, HasParent<"FuncOp">,
   // value must match the return type of the enclosing function.
   let arguments = (ins Variadic<Toy_Type>:$input);
 
   // The return operation only emits the input in the format if it is present.
   let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
 
   // Allow building a ReturnOp with no return operand.
   let builders = [
-    OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
   ];
 
   // Provide extra utility definitions on the c++ operation class definition.
   let extraClassDeclaration = [{
     bool hasOperand() { return getNumOperands() != 0; }
   }];
 
   // Invoke a static verify method to verify this return operation.
def StructAccessOp : Toy_Op<"struct_access", [NoSideEffect]> {
   let results = (outs Toy_Type:$output);
 
   let assemblyFormat = [{
     $input `[` $index `]` attr-dict `:` type($input) `->` type($output)
   }];
 
   // Allow building a StructAccessOp with just a struct value and an index.
   let builders = [
-    OpBuilder<"Value input, size_t index">
+    OpBuilderDAG<(ins "Value":$input, "size_t":$index)>
   ];
 
   let verifier = [{ return ::verify(*this); }];
 
   // Set the folder bit so that we can fold constant accesses.
   let hasFolder = 1;
 }
 
let assemblyFormat = [{
     `(` $input `:` type($input) `)` attr-dict `to` type(results)
   }];
 
   // Enable registering canonicalization patterns with this operation.
   let hasCanonicalizer = 1;
 
   // Allow building a TransposeOp with from the input operand.
   let builders = [
-    OpBuilder<"Value input">
+    OpBuilderDAG<(ins "Value":$input)>
   ];
 
   // Invoke a static verify method to verify this transpose operation.
   let verifier = [{ return ::verify(*this); }];
 }
 
 #endif // TOY_OPS

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

def AffineApplyOp : Affine_Op<"apply", [NoSideEffect]> {
   }];
   let arguments = (ins AffineMapAttr:$map, Variadic<Index>:$mapOperands);
   let results = (outs Index);
 
   // TODO: The auto-generated builders should check to see if the return type
   // has a constant builder. That way we wouldn't need to explicitly specify the
   // result types here.
   let builders = [
-    OpBuilder<"AffineMap map, ValueRange mapOperands", [{
+    OpBuilderDAG<(ins "AffineMap":$map, "ValueRange":$mapOperands),
+    [{
       build($_builder, $_state, $_builder.getIndexType(), map, mapOperands);
     }]>
   ];
 
   let extraClassDeclaration = [{
     /// Returns the affine map to be applied by this operation.
     AffineMap getAffineMap() { return map(); }
 
let description = [{
     match the initial values in the `iter_args` binding and the yield operands.
   }];
   let arguments = (ins Variadic<AnyType>);
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"int64_t lowerBound, int64_t upperBound, int64_t step = 1, "
-              "ValueRange iterArgs = llvm::None, function_ref<void(OpBuilder "
-              "&, Location, Value, ValueRange)> bodyBuilder = nullptr">,
-    OpBuilder<"ValueRange lbOperands, AffineMap lbMap, "
-              "ValueRange ubOperands, AffineMap ubMap, "
-              "int64_t step = 1, ValueRange iterArgs = llvm::None, "
-              "function_ref<void(OpBuilder &, Location, Value, ValueRange)> "
-              "bodyBuilder = nullptr">
+    OpBuilderDAG<(ins "int64_t":$lowerBound, "int64_t":$upperBound,
+      CArg<"int64_t", "1">:$step, CArg<"ValueRange", "llvm::None">:$iterArgs,
+      CArg<"function_ref<void(OpBuilder &, Location, Value, ValueRange)>",
+           "nullptr">:$bodyBuilder)>,
+    OpBuilderDAG<(ins "ValueRange":$lbOperands, "AffineMap":$lbMap,
+      "ValueRange":$ubOperands, "AffineMap":$ubMap, CArg<"int64_t", "1">:$step,
+      CArg<"ValueRange", "llvm::None">:$iterArgs,
+      CArg<"function_ref<void(OpBuilder &, Location, Value, ValueRange)>",
+           "nullptr">:$bodyBuilder)>
   ];
 
   let extraClassDeclaration = [{
     /// Defining the function type we use for building the body of affine.for.
     using BodyBuilderFn =
         function_ref<void(OpBuilder &, Location, Value, ValueRange)>;
 
     static StringRef getStepAttrName() { return "step"; }
def AffineIfOp : Affine_Op<"if",
   }];
   let arguments = (ins Variadic<AnyType>);
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$thenRegion, AnyRegion:$elseRegion);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilder<"IntegerSet set, ValueRange args, bool withElseRegion">,
-    OpBuilder<"TypeRange resultTypes, IntegerSet set, ValueRange args,"
-              "bool withElseRegion">,
+    OpBuilderDAG<(ins "IntegerSet":$set, "ValueRange":$args,
+      "bool":$withElseRegion)>,
+    OpBuilderDAG<(ins "TypeRange":$resultTypes, "IntegerSet":$set,
+      "ValueRange":$args, "bool":$withElseRegion)>,
   ];
 
   let extraClassDeclaration = [{
     static StringRef getConditionAttrName() { return "condition"; }
 
     IntegerSet getIntegerSet();
     void setIntegerSet(IntegerSet newSet);
 
let description = [{
     %1 = affine.load %0[%i0 + symbol(%n), %i1 + symbol(%m)] : memref<100x100xf32>
     ```
   }];
 
   let results = (outs AnyType:$result);
 
   let builders = [
     /// Builds an affine load op with the specified map and operands.
-    OpBuilder<"AffineMap map, ValueRange operands">,
+    OpBuilderDAG<(ins "AffineMap":$map, "ValueRange":$operands)>,
     /// Builds an affine load op with an identity map and operands.
-    OpBuilder<"Value memref, ValueRange indices = {}">,
+    OpBuilderDAG<(ins "Value":$memref, CArg<"ValueRange", "{}">:$indices)>,
     /// Builds an affine load op with the specified map and its operands.
-    OpBuilder<"Value memref, AffineMap map, ValueRange mapOperands">
+    OpBuilderDAG<(ins "Value":$memref, "AffineMap":$map,
+      "ValueRange":$mapOperands)>
   ];
 
   let extraClassDeclaration = extraClassDeclarationBase;
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
 class AffineMinMaxOpBase<string mnemonic, list<OpTrait> traits = []> :
     Op<Affine_Dialect, mnemonic, traits> {
   let arguments = (ins AffineMapAttr:$map, Variadic<Index>:$operands);
   let results = (outs Index);
 
   let builders = [
-    OpBuilder<"AffineMap affineMap, ValueRange mapOperands",
+    OpBuilderDAG<(ins "AffineMap":$affineMap, "ValueRange":$mapOperands),
     [{
       build($_builder, $_state, $_builder.getIndexType(), affineMap, mapOperands);
     }]>
   ];
 
   let extraClassDeclaration = [{
     static StringRef getMapAttrName() { return "map"; }
     AffineMap getAffineMap() { return map(); }
let arguments = (ins
      AffineMapAttr:$lowerBoundsMap,
      AffineMapAttr:$upperBoundsMap,
      I64ArrayAttr:$steps,
      Variadic<Index>:$mapOperands);
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$region);
 
   let builders = [
-    OpBuilder<"TypeRange resultTypes, "
-              "ArrayRef<AtomicRMWKind> reductions, "
-              "ArrayRef<int64_t> ranges">,
-    OpBuilder<"TypeRange resultTypes, "
-              "ArrayRef<AtomicRMWKind> reductions, "
-              "AffineMap lbMap, ValueRange lbArgs, "
-              "AffineMap ubMap, ValueRange ubArgs">,
-    OpBuilder<"TypeRange resultTypes, "
-              "ArrayRef<AtomicRMWKind> reductions, "
-              "AffineMap lbMap, ValueRange lbArgs, "
-              "AffineMap ubMap, ValueRange ubArgs, "
-              "ArrayRef<int64_t> steps">
+    OpBuilderDAG<(ins "TypeRange":$resultTypes,
+      "ArrayRef<AtomicRMWKind>":$reductions, "ArrayRef<int64_t>":$ranges)>,
+    OpBuilderDAG<(ins "TypeRange":$resultTypes,
+      "ArrayRef<AtomicRMWKind>":$reductions, "AffineMap":$lbMap,
+      "ValueRange":$lbArgs, "AffineMap":$ubMap, "ValueRange":$ubArgs)>,
+    OpBuilderDAG<(ins "TypeRange":$resultTypes,
+      "ArrayRef<AtomicRMWKind>":$reductions, "AffineMap":$lbMap,
+      "ValueRange":$lbArgs, "AffineMap":$ubMap, "ValueRange":$ubArgs,
+      "ArrayRef<int64_t>":$steps)>
   ];
 
   let extraClassDeclaration = [{
     /// Get the number of dimensions.
     unsigned getNumDims();
 
     AffineValueMap getRangesValueMap();
 
def AffinePrefetchOp : Affine_Op<"prefetch"> {
   }];
 
   let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices,
                    BoolAttr:$isWrite,
                    Confined<I32Attr, [IntMinValue<0>,
                      IntMaxValue<3>]>:$localityHint,
                    BoolAttr:$isDataCache);
 
-  let builders = [OpBuilder<
-    "Value memref, AffineMap map, ArrayRef<Value> mapOperands, bool isWrite,"
-    "unsigned localityHint, bool isDataCache",
+  let builders = [
+    OpBuilderDAG<(ins "Value":$memref, "AffineMap":$map,
+      "ArrayRef<Value>":$mapOperands, "bool":$isWrite, "unsigned":$localityHint,
+      "bool":$isDataCache),
     [{
       assert(map.getNumInputs() == mapOperands.size()
              && "inconsistent index info");
       auto localityHintAttr = $_builder.getI32IntegerAttr(localityHint);
       auto isWriteAttr = $_builder.getBoolAttr(isWrite);
       auto isDataCacheAttr = $_builder.getBoolAttr(isDataCache);
       $_state.addOperands(memref);
       $_state.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
def AffineStoreOp : AffineStoreOpBase<"store"> {
   }];
   let arguments = (ins AnyType:$value,
       Arg<AnyMemRef, "the reference to store to",
       [MemWrite]>:$memref,
       Variadic<Index>:$indices);
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"Value valueToStore, Value memref, ValueRange indices">,
-    OpBuilder<"Value valueToStore, Value memref, AffineMap map, "
-              "ValueRange mapOperands">
+    OpBuilderDAG<(ins "Value":$valueToStore, "Value":$memref,
+      "ValueRange":$indices)>,
+    OpBuilderDAG<(ins "Value":$valueToStore, "Value":$memref, "AffineMap":$map,
+      "ValueRange":$mapOperands)>
   ];
 
   let extraClassDeclaration = extraClassDeclarationBase;
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
let description = [{
     Otherwise, it has to be present in the syntax to indicate which values are
     yielded.
     ```
   }];
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
   let builders = [
-    OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
   ];
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 
 def AffineVectorLoadOp : AffineLoadOpBase<"vector_load"> {
   let summary = "affine vector load operation";
   let description = [{

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

def Async_AwaitOp : Async_Op<"await", [NoSideEffect]> {
   }];
 
   let arguments = (ins Async_AnyValueOrTokenType:$operand);
   let results = (outs Optional<AnyType>:$result);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilder<"Value operand, ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilderDAG<(ins "Value":$operand,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
   ];
 
   let extraClassDeclaration = [{
     Optional<Type> getResultType() {
       if (getResultTypes().empty()) return None;
       return getResultTypes()[0];
     }
   }];

mlir/include/mlir/Dialect/GPU/GPUOps.td

let description = [{
     attribution.
   }];
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilder<"StringRef name, "
-              "FunctionType type, TypeRange workgroupAttributions = {}, "
-              "TypeRange privateAttributions = {}, "
-              "ArrayRef<NamedAttribute> attrs = {}">
+    OpBuilderDAG<(ins "StringRef":$name, "FunctionType":$type,
+      CArg<"TypeRange", "{}">:$workgroupAttributions,
+      CArg<"TypeRange", "{}">:$privateAttributions,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = [{
     /// Returns `true` if the GPU function defined by this Op is a kernel, i.e.
     /// it is intended to be launched from host.
     bool isKernel() {
       return getAttrOfType<UnitAttr>(GPUDialect::getKernelFuncAttrName()) !=
              nullptr;
module attributes {gpu.container_module} {
           args(%arg0 : f32, %arg1 : memref<?xf32, 1>)  // Kernel arguments.
     }
     ```
   }];
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilder<"GPUFuncOp kernelFunc, "
-              "KernelDim3 gridSize, KernelDim3 blockSize, "
-              "ValueRange kernelOperands">
+    OpBuilderDAG<(ins "GPUFuncOp":$kernelFunc, "KernelDim3":$gridSize,
+      "KernelDim3":$blockSize, "ValueRange":$kernelOperands)>
   ];
 
   let extraClassDeclaration = [{
     /// The number of operands passed to the kernel function.
     unsigned getNumKernelOperands();
 
     /// The name of the kernel's containing module.
     StringRef getKernelModuleName();
let description = [{
     easier just to have that information by construction.
   }];
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilder<"Value gridSizeX,"
-              "Value gridSizeY, Value gridSizeZ, Value blockSizeX,"
-              "Value blockSizeY, Value blockSizeZ">
+    OpBuilderDAG<(ins "Value":$gridSizeX, "Value":$gridSizeY,
+      "Value":$gridSizeZ, "Value":$blockSizeX, "Value":$blockSizeY,
+      "Value":$blockSizeZ)>
   ];
 
   let extraClassDeclaration = [{
     /// Get the SSA values corresponding to kernel block identifiers.
     KernelDim3 getBlockIds();
     /// Get the SSA values corresponding to kernel thread identifiers.
     KernelDim3 getThreadIds();
     /// Get the SSA values corresponding to kernel grid size.
def GPU_ReturnOp : GPU_Op<"return", [HasParent<"GPUFuncOp">, NoSideEffect,
     Arguments<(ins Variadic<AnyType>:$operands)>, Results<(outs)> {
   let summary = "Terminator for GPU functions.";
   let description = [{
     A terminator operation for regions that appear in the body of  `gpu.func`
     functions. The operands to the `gpu.return` are the result values returned
     by an invocation of the `gpu.func`.
   }];
 
-  let builders = [OpBuilder<"", " // empty">];
+  let builders = [OpBuilderDAG<(ins), [{ // empty}]>];
 
   let parser = [{ return parseReturnOp(parser, result); }];
   let printer = [{ p << getOperationName(); }];
   let verifier = [{ return ::verify(*this); }];
 }
 
 def GPU_TerminatorOp : GPU_Op<"terminator", [HasParent<"LaunchOp">,
                                              NoSideEffect, Terminator]>,
```
       gpu.module @symbol_name {
       gpu.func {}
         ...
       gpu.module_end
     }
 
     ```
   }];
-  let builders = [OpBuilder<"StringRef name">];
+  let builders = [OpBuilderDAG<(ins "StringRef":$name)>];
   let parser = [{ return ::parseGPUModuleOp(parser, result); }];
   let printer = [{ return ::print(p, *this); }];
   let regions = (region SizedRegion<1>:$body);
 
   // We need to ensure the block inside the region is properly terminated;
   // the auto-generated builders do not guarantee that.
   let skipDefaultBuilders = 1;
 }

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 class LLVM_Builder<string builder> {
   string llvmBuilder = builder;
 }
 
-def LLVM_OneResultOpBuilder : OpBuilder<
-  "Type resultType, ValueRange operands, "
-  "ArrayRef<NamedAttribute> attributes = {}",
+def LLVM_OneResultOpBuilder :
+  OpBuilderDAG<(ins "Type":$resultType, "ValueRange":$operands,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
     if (resultType) $_state.addTypes(resultType);
     $_state.addOperands(operands);
     for (auto namedAttr : attributes) {
       $_state.addAttribute(namedAttr.first, namedAttr.second);
     }
   }]>;
 
-def LLVM_ZeroResultOpBuilder : OpBuilder<
-  "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
+def LLVM_ZeroResultOpBuilder :
+  OpBuilderDAG<(ins "ValueRange":$operands,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
     $_state.addOperands(operands);
     for (auto namedAttr : attributes) {
       $_state.addAttribute(namedAttr.first, namedAttr.second);
     }
   }]>;
 
-class LLVM_TwoBuilders<OpBuilder b1, OpBuilder b2> {
-  list<OpBuilder> builders = [b1, b2];
+class LLVM_TwoBuilders<OpBuilderDAG b1, OpBuilderDAG b2> {
+  list<OpBuilderDAG> builders = [b1, b2];
 }
 
 // Base class for LLVM operations with one result.
 class LLVM_OneResultOp<string mnemonic, list<OpTrait> traits = []> :
     LLVM_Op<mnemonic, traits>, Results<(outs LLVM_Type:$res)> {
   let builders = [LLVM_OneResultOpBuilder];
 }
 
 // Compatibility builder that takes an instance of wrapped llvm::VoidType
 // to indicate no result.
-def LLVM_VoidResultTypeOpBuilder : OpBuilder<
-  "Type resultType, ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
+def LLVM_VoidResultTypeOpBuilder :
+  OpBuilderDAG<(ins "Type":$resultType, "ValueRange":$operands,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
     auto llvmType = resultType.dyn_cast<LLVMType>(); (void)llvmType;
     assert(llvmType && "result must be an LLVM type");
     assert(llvmType.isVoidTy() &&
            "for zero-result operands, only 'void' is accepted as result type");
     build($_builder, $_state, operands, attributes);
   }]>;
 
 // Base class for LLVM operations with zero results.
 class LLVM_ZeroResultOp<string mnemonic, list<OpTrait> traits = []> :
     LLVM_Op<mnemonic, traits>, Results<(outs)>,
     LLVM_TwoBuilders<LLVM_VoidResultTypeOpBuilder, LLVM_ZeroResultOpBuilder>;
 
 // Opaque builder used for terminator operations that contain successors.
-def LLVM_TerminatorPassthroughOpBuilder : OpBuilder<
-  "ValueRange operands, SuccessorRange destinations, "
-  "ArrayRef<NamedAttribute> attributes = {}",
+def LLVM_TerminatorPassthroughOpBuilder :
+  OpBuilderDAG<(ins "ValueRange":$operands, "SuccessorRange":$destinations,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
     $_state.addOperands(operands);
     $_state.addSuccessors(destinations);
     $_state.addAttributes(attributes);
   }]>;
 
 // Base class for LLVM terminator operations.  All terminator operations have
 // zero results and an optional list of successors.

 // Other integer operations.
 def LLVM_ICmpOp : LLVM_OneResultOp<"icmp", [NoSideEffect]> {
   let arguments = (ins ICmpPredicate:$predicate,
                    LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$lhs,
                    LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$rhs);
   let llvmBuilder = [{
     $res = builder.CreateICmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
   }];
-  let builders = [OpBuilder<
-    "ICmpPredicate predicate, Value lhs, Value rhs", [{
+  let builders = [
+    OpBuilderDAG<(ins "ICmpPredicate":$predicate, "Value":$lhs, "Value":$rhs),
+    [{
       build($_builder, $_state, LLVMType::getInt1Ty(lhs.getType().getContext()),
             $_builder.getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs);
     }]>];
   let parser = [{ return parseCmpOp<ICmpPredicate>(parser, result); }];
   let printer = [{ printICmpOp(p, *this); }];
 }
 
 // Predicate for float comparisons

 // Other integer operations.
 def LLVM_FCmpOp : LLVM_OneResultOp<"fcmp", [NoSideEffect]> {
   let arguments = (ins FCmpPredicate:$predicate,
                    LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$lhs,
                    LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$rhs);
   let llvmBuilder = [{
     $res = builder.CreateFCmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
   }];
-  let builders = [OpBuilder<
-    "FCmpPredicate predicate, Value lhs, Value rhs", [{
+  let builders = [
+    OpBuilderDAG<(ins "FCmpPredicate":$predicate, "Value":$lhs, "Value":$rhs),
+    [{
       build($_builder, $_state, LLVMType::getInt1Ty(lhs.getType().getContext()),
             $_builder.getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs);
     }]>];
   let parser = [{ return parseCmpOp<FCmpPredicate>(parser, result); }];
   let printer = [{ printFCmpOp(p, *this); }];
 }
 
 // Floating point binary operations.
def LLVM_AllocaOp :
   let arguments = (ins LLVM_AnyInteger:$arraySize,
                    OptionalAttr<I64Attr>:$alignment);
   string llvmBuilder = [{
     auto *inst = builder.CreateAlloca(
       $_resultType->getPointerElementType(), $arraySize);
     }] # setAlignmentCode # [{
     $res = inst;
   }];
-  let builders = [OpBuilder<
-    "Type resultType, Value arraySize, unsigned alignment",
+  let builders = [
+    OpBuilderDAG<(ins "Type":$resultType, "Value":$arraySize,
+      "unsigned":$alignment),
     [{
       if (alignment == 0)
         return build($_builder, $_state, resultType, arraySize, IntegerAttr());
       build($_builder, $_state, resultType, arraySize,
         $_builder.getI64IntegerAttr(alignment));
   }]>];
   let parser = [{ return parseAllocaOp(parser, result); }];
   let printer = [{ printAllocaOp(p, *this); }];
def LLVM_LoadOp :
   let arguments = (ins LLVM_PointerTo<LLVM_LoadableType>:$addr,
                    OptionalAttr<I64Attr>:$alignment, UnitAttr:$volatile_,
                    UnitAttr:$nontemporal);
   string llvmBuilder = [{
     auto *inst = builder.CreateLoad($addr, $volatile_);
   }] # setAlignmentCode # setNonTemporalMetadataCode # [{
     $res = inst;
   }];
-  let builders = [OpBuilder<
-    "Value addr, unsigned alignment = 0, bool isVolatile = false, "
-    "bool isNonTemporal = false",
+  let builders = [
+    OpBuilderDAG<(ins "Value":$addr, CArg<"unsigned", "0">:$alignment,
+      CArg<"bool", "false">:$isVolatile, CArg<"bool", "false">:$isNonTemporal),
     [{
       auto type = addr.getType().cast<LLVMType>().getPointerElementTy();
       build($_builder, $_state, type, addr, alignment, isVolatile, isNonTemporal);
     }]>,
-    OpBuilder<
-    "Type t, Value addr, unsigned alignment = 0, bool isVolatile = false, "
-    "bool isNonTemporal = false">];
+    OpBuilderDAG<(ins "Type":$t, "Value":$addr,
+      CArg<"unsigned", "0">:$alignment, CArg<"bool", "false">:$isVolatile,
+      CArg<"bool", "false">:$isNonTemporal)>];
   let parser = [{ return parseLoadOp(parser, result); }];
   let printer = [{ printLoadOp(p, *this); }];
 }
 def LLVM_StoreOp :
     MemoryOpWithAlignmentAndAttributes,
     LLVM_ZeroResultOp<"store"> {
   let arguments = (ins LLVM_LoadableType:$value,
                    LLVM_PointerTo<LLVM_LoadableType>:$addr,
                    OptionalAttr<I64Attr>:$alignment, UnitAttr:$volatile_,
                    UnitAttr:$nontemporal);
   string llvmBuilder = [{
     auto *inst = builder.CreateStore($value, $addr, $volatile_);
   }] # setAlignmentCode # setNonTemporalMetadataCode;
-  let builders = [OpBuilder<
-    "Value value, Value addr, unsigned alignment = 0, bool isVolatile = false, "
-    "bool isNonTemporal = false">
+  let builders = [
+    OpBuilderDAG<(ins "Value":$value, "Value":$addr,
+      CArg<"unsigned", "0">:$alignment, CArg<"bool", "false">:$isVolatile,
+      CArg<"bool", "false">:$isNonTemporal)>
     ];
   let parser = [{ return parseStoreOp(parser, result); }];
   let printer = [{ printStoreOp(p, *this); }];
 }
 
 // Casts.
 class LLVM_CastOp<string mnemonic, string builderFunc, Type type,
                   list<OpTrait> traits = []> :
def LLVM_InvokeOp : LLVM_Op<"invoke", [
                     Results<(outs Variadic<LLVM_Type>)> {
   let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$callee,
                    Variadic<LLVM_Type>:$operands,
                    Variadic<LLVM_Type>:$normalDestOperands,
                    Variadic<LLVM_Type>:$unwindDestOperands);
   let successors = (successor AnySuccessor:$normalDest,
                               AnySuccessor:$unwindDest);
 
-  let builders = [OpBuilder<
-    "TypeRange tys, FlatSymbolRefAttr callee, ValueRange ops, Block* normal, "
-    "ValueRange normalOps, Block* unwind, ValueRange unwindOps",
+  let builders = [
+    OpBuilderDAG<(ins "TypeRange":$tys, "FlatSymbolRefAttr":$callee,
+      "ValueRange":$ops, "Block*":$normal, "ValueRange":$normalOps,
+      "Block*":$unwind, "ValueRange":$unwindOps),
     [{
       $_state.addAttribute("callee", callee);
       build($_builder, $_state, tys, ops, normal, normalOps, unwind, unwindOps);
     }]>,
-    OpBuilder<
-    "TypeRange tys, ValueRange ops, Block* normal, "
-    "ValueRange normalOps, Block* unwind, ValueRange unwindOps",
+    OpBuilderDAG<(ins "TypeRange":$tys, "ValueRange":$ops, "Block*":$normal,
+      "ValueRange":$normalOps, "Block*":$unwind, "ValueRange":$unwindOps),
     [{
       build($_builder, $_state, tys, /*callee=*/FlatSymbolRefAttr(), ops, normalOps,
             unwindOps, normal, unwind);
     }]>];
   let verifier = [{ return ::verify(*this);  }];
   let parser = [{ return parseInvokeOp(parser, result); }];
   let printer = [{ printInvokeOp(p, *this); }];
 }
 
 def LLVM_LandingpadOp : LLVM_OneResultOp<"landingpad"> {
   let arguments = (ins UnitAttr:$cleanup, Variadic<LLVM_Type>);
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return parseLandingpadOp(parser, result); }];
   let printer = [{ printLandingpadOp(p, *this); }];
 }
 
 def LLVM_CallOp : LLVM_Op<"call">,
                   Results<(outs Variadic<LLVM_Type>)> {
   let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$callee,
                    Variadic<LLVM_Type>);
-  let builders = [OpBuilder<
-    "LLVMFuncOp func, ValueRange operands, "
-    "ArrayRef<NamedAttribute> attributes = {}",
+  let builders = [
+    OpBuilderDAG<(ins "LLVMFuncOp":$func, "ValueRange":$operands,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
     [{
       LLVMType resultType = func.getType().getFunctionResultType();
       if (!resultType.isVoidTy())
         $_state.addTypes(resultType);
       $_state.addAttribute("callee", $_builder.getSymbolRefAttr(func));
       $_state.addAttributes(attributes);
       $_state.addOperands(operands);
     }]>];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return parseCallOp(parser, result); }];
   let printer = [{ printCallOp(p, *this); }];
 }
 def LLVM_ExtractElementOp : LLVM_OneResultOp<"extractelement", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyVector:$vector, LLVM_AnyInteger:$position);
   string llvmBuilder = [{
     $res = builder.CreateExtractElement($vector, $position);
   }];
-  let builders = [OpBuilder<
-    "Value vector, Value position, ArrayRef<NamedAttribute> attrs = {}">];
+  let builders = [
+    OpBuilderDAG<(ins "Value":$vector, "Value":$position,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
   let parser = [{ return parseExtractElementOp(parser, result); }];
   let printer = [{ printExtractElementOp(p, *this); }];
 }
 def LLVM_ExtractValueOp : LLVM_OneResultOp<"extractvalue", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyAggregate:$container, ArrayAttr:$position);
   string llvmBuilder = [{
     $res = builder.CreateExtractValue($container, extractPosition($position));
   }];

 }
 def LLVM_InsertValueOp : LLVM_OneResultOp<"insertvalue", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyAggregate:$container, LLVM_PrimitiveType:$value,
                    ArrayAttr:$position);
   string llvmBuilder = [{
     $res = builder.CreateInsertValue($container, $value,
                                      extractPosition($position));
   }];
-  let builders = [OpBuilder<
-    "Value container, Value value, ArrayAttr position",
+  let builders = [
+    OpBuilderDAG<(ins "Value":$container, "Value":$value, "ArrayAttr":$position),
     [{
       build($_builder, $_state, container.getType(), container, value, position);
     }]>];
   let parser = [{ return parseInsertValueOp(parser, result); }];
   let printer = [{ printInsertValueOp(p, *this); }];
 }
 def LLVM_ShuffleVectorOp : LLVM_OneResultOp<"shufflevector", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyVector:$v1, LLVM_AnyVector:$v2, ArrayAttr:$mask);
   string llvmBuilder = [{
       SmallVector<unsigned, 4> position = extractPosition($mask);
       SmallVector<int, 4> mask(position.begin(), position.end());
       $res = builder.CreateShuffleVector($v1, $v2, mask);
   }];
-  let builders = [OpBuilder<
-    "Value v1, Value v2, ArrayAttr mask, ArrayRef<NamedAttribute> attrs = {}">];
+  let builders = [
+    OpBuilderDAG<(ins "Value":$v1, "Value":$v2, "ArrayAttr":$mask,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
   let verifier = [{
     auto wrappedVectorType1 = v1().getType().cast<LLVMType>();
     auto wrappedVectorType2 = v2().getType().cast<LLVMType>();
     if (!wrappedVectorType2.isVectorTy())
       return emitOpError("expected LLVM IR Dialect vector type for operand #2");
     if (wrappedVectorType1.getVectorElementType() !=
         wrappedVectorType2.getVectorElementType())
       return emitOpError("expected matching LLVM IR Dialect element types");
     return success();
   }];
   let parser = [{ return parseShuffleVectorOp(parser, result); }];
   let printer = [{ printShuffleVectorOp(p, *this); }];
 }
 
 // Misc operations.
 def LLVM_SelectOp
     : LLVM_OneResultOp<"select",
           [NoSideEffect, AllTypesMatch<["trueValue", "falseValue", "res"]>]>,
       LLVM_Builder<
           "$res = builder.CreateSelect($condition, $trueValue, $falseValue);"> {
   let arguments = (ins LLVM_ScalarOrVectorOf<LLVM_i1>:$condition,
                    LLVM_Type:$trueValue, LLVM_Type:$falseValue);
-  let builders = [OpBuilder<
-    "Value condition, Value lhs, Value rhs", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$condition, "Value":$lhs, "Value":$rhs),
+    [{
       build($_builder, $_state, lhs.getType(), condition, lhs, rhs);
     }]>];
   let assemblyFormat = "operands attr-dict `:` type($condition) `,` type($res)";
 }
 def LLVM_FreezeOp : LLVM_OneResultOp<"freeze", [SameOperandsAndResultType]> {
   let arguments = (ins LLVM_Type:$val);
   let assemblyFormat = "$val attr-dict `:` type($val)";
   string llvmBuilder = "builder.CreateFreeze($val);";
def LLVM_CondBrOp : LLVM_TerminatorOp<"cond_br",
   let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
   let assemblyFormat = [{
     $condition ( `weights` `(` $branch_weights^ `)` )? `,`
     $trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,`
     $falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)?
     attr-dict
   }];
 
-  let builders = [OpBuilder<
-     "Value condition, Block *trueDest, ValueRange trueOperands,"
-     "Block *falseDest, ValueRange falseOperands,"
-     "Optional<std::pair<uint32_t, uint32_t>> weights = {}", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$condition, "Block *":$trueDest,
+      "ValueRange":$trueOperands, "Block *":$falseDest,
+      "ValueRange":$falseOperands,
+      CArg<"Optional<std::pair<uint32_t, uint32_t>>", "{}">:$weights),
+    [{
         ElementsAttr weightsAttr;
         if (weights) {
           weightsAttr =
               $_builder.getI32VectorAttr({static_cast<int32_t>(weights->first),
                                        static_cast<int32_t>(weights->second)});
         }
         build($_builder, $_state, condition, trueOperands, falseOperands, weightsAttr,
               trueDest, falseDest);
-  }]>, OpBuilder<
-    "Value condition, Block *trueDest, Block *falseDest, "
-    "ValueRange falseOperands = {}", [{
+  }]>,
+  OpBuilderDAG<(ins "Value":$condition, "Block *":$trueDest,
+    "Block *":$falseDest, CArg<"ValueRange", "{}">:$falseOperands),
+  [{
       build($_builder, $_state, condition, trueDest, ValueRange(), falseDest,
             falseOperands);
   }]>, LLVM_TerminatorPassthroughOpBuilder];
 }
 def LLVM_ReturnOp : LLVM_TerminatorOp<"return", [NoSideEffect]> {
   let arguments = (ins Variadic<LLVM_Type>:$args);
   string llvmBuilder = [{
     if ($_numOperands != 0)

 
 
 def LLVM_AddressOfOp : LLVM_OneResultOp<"mlir.addressof"> {
   let arguments = (ins FlatSymbolRefAttr:$global_name);
 
   let summary = "Creates a pointer pointing to a global or a function";
 
   let builders = [
-    OpBuilder<"LLVMType resType, "
-              "StringRef name, ArrayRef<NamedAttribute> attrs = {}", [{
+    OpBuilderDAG<(ins "LLVMType":$resType, "StringRef":$name,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+    [{
       $_state.addAttribute("global_name",$_builder.getSymbolRefAttr(name));
       $_state.addAttributes(attrs);
       $_state.addTypes(resType);}]>,
-
-    OpBuilder<"GlobalOp global, "
-              "ArrayRef<NamedAttribute> attrs = {}", [{
+    OpBuilderDAG<(ins "GlobalOp":$global,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+    [{
       build($_builder, $_state,
             global.getType().getPointerTo(global.addr_space()),
             global.sym_name(), attrs);}]>,
-
-    OpBuilder<"LLVMFuncOp func, "
-              "ArrayRef<NamedAttribute> attrs = {}", [{
+    OpBuilderDAG<(ins "LLVMFuncOp":$func,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+    [{
       build($_builder, $_state,
             func.getType().getPointerTo(), func.getName(), attrs);}]>
   ];
 
   let extraClassDeclaration = [{
     /// Return the llvm.mlir.global operation that defined the value referenced
     /// here.
     GlobalOp getGlobal();
Examples:
         %0 = llvm.constant(0 : i32) : !llvm.i32
         %1 = llvm.inttoptr %0 : !llvm.i32 to !llvm<"i32*">
         llvm.return %1 : !llvm<"i32*">
       }
   }];
   let regions = (region AnyRegion:$initializer);
 
   let builders = [
-    OpBuilder<"LLVMType type, "
-              "bool isConstant, Linkage linkage, StringRef name, "
-              "Attribute value, unsigned addrSpace = 0, "
-              "ArrayRef<NamedAttribute> attrs = {}">
+    OpBuilderDAG<(ins "LLVMType":$type, "bool":$isConstant, "Linkage":$linkage,
+      "StringRef":$name, "Attribute":$value, CArg<"unsigned", "0">:$addrSpace,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = [{
     /// Return the LLVM type of the global.
     LLVMType getType() {
       return type().cast<LLVMType>();
     }
     /// Return the initializer attribute if it exists, or a null attribute.
let arguments = (ins DefaultValuedAttr<Linkage, "Linkage::External">:$linkage,
                    OptionalAttr<FlatSymbolRefAttr>:$personality,
                    OptionalAttr<ArrayAttr>:$passthrough);
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilder<"StringRef name, "
-              "LLVMType type, Linkage linkage = Linkage::External, "
-              "ArrayRef<NamedAttribute> attrs = {}, "
-              "ArrayRef<MutableDictionaryAttr> argAttrs = {}">
+    OpBuilderDAG<(ins "StringRef":$name, "LLVMType":$type,
+      CArg<"Linkage", "Linkage::External">:$linkage,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
+      CArg<"ArrayRef<MutableDictionaryAttr>", "{}">:$argAttrs)>
   ];
 
   let extraClassDeclaration = [{
     // Add an entry block to an empty function, and set up the block arguments
     // to match the signature of the function.
     Block *addEntryBlock();
 
     LLVMType getType() {

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

let description = [{
     type does not pass function boundaries at the moment.
 
     Example:
 
     ```mlir
     %3 = linalg.range %0:%1:%2 : !linalg.range
     ````
   }];
-  let builders = [OpBuilder<
-    "Value min, Value max, Value step",
+  let builders = [
+    OpBuilderDAG<(ins "Value":$min, "Value":$max, "Value":$step),
     [{
       auto rangeType = RangeType::get($_builder.getContext());
       build($_builder, $_state, rangeType, min, max, step);
     }]>];
 
   // Fully specified by traits.
   let verifier = ?;
   let assemblyFormat = "$min `:` $max `:` $step attr-dict `:` type(results)";
 }
 
 class Linalg_ReshapeLikeOp<string mnemonic, list<OpTrait> traits = []> :
     Linalg_Op<mnemonic, !listconcat(traits, [NoSideEffect])> {
   let builders = [
     // Builders for a contracting reshape whose result type is computed from
     // `src` and `reassociation`.
-    OpBuilder<"Value src, "
-              "ArrayRef<ReassociationExprs> reassociation, "
-              "ArrayRef<NamedAttribute> attrs = {}">,
-    OpBuilder<"Value src, "
-              "ArrayRef<ReassociationIndices> reassociation, "
-              "ArrayRef<NamedAttribute> attrs = {}", [{
+    OpBuilderDAG<(ins "Value":$src,
+      "ArrayRef<ReassociationExprs>":$reassociation,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+    OpBuilderDAG<(ins "Value":$src,
+      "ArrayRef<ReassociationIndices>":$reassociation,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+    [{
       auto reassociationMaps =
           convertReassociationIndicesToMaps($_builder, reassociation);
       build($_builder, $_state, src, reassociationMaps, attrs);
     }]>,
 
     // Builders for a reshape whose result type is passed explicitly. This may
     // be either a contracting or expanding reshape.
-    OpBuilder<"Type resultType, Value src, "
-              "ArrayRef<ReassociationExprs> reassociation, "
-              "ArrayRef<NamedAttribute> attrs = {}">,
-    OpBuilder<"Type resultType, Value src, "
-              "ArrayRef<ReassociationIndices> reassociation, "
-              "ArrayRef<NamedAttribute> attrs = {}", [{
+    OpBuilderDAG<(ins "Type":$resultType, "Value":$src,
+      "ArrayRef<ReassociationExprs>":$reassociation,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+    OpBuilderDAG<(ins "Type":$resultType, "Value":$src,
+      "ArrayRef<ReassociationIndices>":$reassociation,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
+    [{
       auto reassociationMaps =
           convertReassociationIndicesToMaps($_builder, reassociation);
       build($_builder, $_state, resultType, src, reassociationMaps, attrs);
     }]>
   ];
 
   code commonExtraClassDeclaration = [{
     static StringRef getReassociationAttrName() { return "reassociation"; }
Examples:
       3. rank-reducing `slice` (from 2-D to 0-D):
 
       ```mlir
       %4 = linalg.slice %0[%1, %2] : memref<?x?xf32, stride_spec>,
         index, index, memref<?x?xf32, stride_spec>
       ```
   }];
 
-  let builders = [OpBuilder<"Value base, ValueRange indexings">];
+  let builders = [OpBuilderDAG<(ins "Value":$base, "ValueRange":$indexings)>];
 
   let extraClassDeclaration = [{
     enum { FirstIndexingOperand = 1 };
     unsigned getRank() { return getShapedType().getRank(); }
     Type getElementType() { return getShapedType().getElementType(); }
     ShapedType getShapedType() { return getType().cast<ShapedType>(); }
     unsigned getBaseViewRank() { return getBaseViewType().getRank(); }
     ShapedType getBaseViewType() { return view().getType().cast<ShapedType>();}

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

def CopyOp : LinalgStructured_Op<"copy", [
   let arguments = (ins
     AnyStridedMemRef:$input,
     AnyStridedMemRef:$output,
     OptionalAttr<AffineMapAttr>:$inputPermutation,
     OptionalAttr<AffineMapAttr>:$outputPermutation);
 
   // TODO: this should go away once the usage of OptionalAttr triggers emission
   // of builders with default arguments left unspecified.
-  let builders = [OpBuilder<
-    "Value input, Value output", [{
+  let builders = [OpBuilderDAG<(ins "Value":$input, "Value":$output),
+    [{
       return build(
         $_builder, $_state, input, output, AffineMapAttr(), AffineMapAttr());
     }]>];
 
   let extraClassDeclaration = libraryCallName # [{
     // Rank-polymorphic.
     //   filling_value -> O(ivs) with parallel iterators.
     ArrayAttr iterator_types() {
       unsigned nPar = getInputShapedType(0).getRank();
       return Builder(getContext()).getStrArrayAttr(
         SmallVector<StringRef, 8>(nPar, getParallelIteratorTypeName()));
let description = [{
     }
     ```
     where symbol s0 will be substituted with `dim %filter, %c0` i.e. the first
     and only dimension of the second operand as specified by the symbol_source
     attribute.
   }];
 
   let builders = [
-    OpBuilder<
-      "TypeRange resultTensorTypes,"
-      "ValueRange inputs, ValueRange outputBuffers, ValueRange initTensors, "
-      "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
-      "StringRef doc, StringRef libraryCall, IntegerAttr symbolSource, "
-      "function_ref<void(OpBuilder &, Location, ValueRange)> = nullptr">,
-    OpBuilder<
-      "ValueRange inputs, ValueRange outputBuffers, "
-      "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
-      "StringRef doc, StringRef libraryCall, IntegerAttr symbolSource, "
-      "function_ref<void(OpBuilder &, Location, ValueRange)> = nullptr">,
-    OpBuilder<
-      "TypeRange resultTensorTypes,"
-      "ValueRange inputs, ValueRange outputBuffers, ValueRange initTensors, "
-      "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
-      "function_ref<void(OpBuilder &, Location, ValueRange)> = nullptr">,
-    OpBuilder<
-      "ValueRange inputs, "
-      "ValueRange outputBuffers, ArrayRef<AffineMap> indexingMaps, "
-      "ArrayRef<StringRef> iteratorTypes, "
-      "function_ref<void(OpBuilder &, Location, ValueRange)> = nullptr">
+    OpBuilderDAG<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
+      "ValueRange":$outputBuffers, "ValueRange":$initTensors,
+      "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
+      "StringRef":$doc, "StringRef":$libraryCall, "IntegerAttr":$symbolSource,
+      CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">)>,
+    OpBuilderDAG<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
+      "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
+      "StringRef":$doc, "StringRef":$libraryCall, "IntegerAttr":$symbolSource,
+      CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">)>,
+    OpBuilderDAG<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
+      "ValueRange":$outputBuffers, "ValueRange":$initTensors,
+      "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
+      CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">)>,
+    OpBuilderDAG<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
+      "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
+      CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">)>
   ];
   let verifier = [{ return ::verify(*this); }];
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 
 /// GenericOp with Indexing (i.e. multi-for style in which the region is passed
let description = [{
     }
     ```
     where symbol s0 will be substituted with `dim %filter, %c0` i.e. the first
     and only dimension of the second operand as specified by the symbol_source
     attribute.
   }];
 
   let builders = [
-    OpBuilder<
-      "TypeRange resultTensorTypes,"
-      "ValueRange inputs, ValueRange outputBuffers, ValueRange initTensors, "
-      "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
-      "StringRef doc, StringRef libraryCall, IntegerAttr symbolSource, "
-      "function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)> = nullptr">,
-    OpBuilder<
-      "ValueRange inputs, ValueRange outputBuffers, "
-      "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
-      "StringRef doc, StringRef libraryCall, IntegerAttr symbolSource, "
-      "function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)> = nullptr">,
-    OpBuilder<
-      "TypeRange resultTensorTypes,"
-      "ValueRange inputs, ValueRange outputBuffers, ValueRange initTensors, "
-      "ArrayRef<AffineMap> indexingMaps, ArrayRef<StringRef> iteratorTypes, "
-      "function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)> = nullptr">,
-    OpBuilder<
-      "ValueRange inputs, "
-      "ValueRange outputBuffers, ArrayRef<AffineMap> indexingMaps, "
-      "ArrayRef<StringRef> iteratorTypes, "
-      "function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)> = nullptr">
+    OpBuilderDAG<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
+      "ValueRange":$outputBuffers, "ValueRange":$initTensors,
+      "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
+      "StringRef":$doc, "StringRef":$libraryCall, "IntegerAttr":$symbolSource,
+      CArg<"function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)>",
+           "nullptr">)>,
+    OpBuilderDAG<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
+      "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
+      "StringRef":$doc, "StringRef":$libraryCall, "IntegerAttr":$symbolSource,
+      CArg<"function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)>",
+           "nullptr">)>,
+    OpBuilderDAG<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
+      "ValueRange":$outputBuffers, "ValueRange":$initTensors,
+      "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
+      CArg<"function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)>",
+           "nullptr">)>,
+    OpBuilderDAG<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
+      "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
+      CArg<"function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)>",
+           "nullptr">)>
   ];
   let verifier = [{ return ::verify(*this); }];
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Named Linalg ops, implemented as a declarative configurations of generic ops.
 //===----------------------------------------------------------------------===//
 
 // This file is auto-generated from a TC def specification.
 include "mlir/Dialect/Linalg/IR/LinalgNamedStructuredOps.td"
 
 #endif // LINALG_STRUCTURED_OPS

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

def OpenACC_YieldOp : OpenACC_Op<"yield", [Terminator,
   let description = [{
     `acc.yield` is a special terminator operation for block inside regions in
     acc ops (parallel and loop). It returns values to the immediately enclosing
     acc op.
   }];
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
-  let builders = [
-    OpBuilder<"", [{ /* nothing to do */ }]>
-  ];
+  let builders = [OpBuilderDAG<(ins), [{ /* nothing to do */ }]>];
 
   let verifier = ?;
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 
 //===----------------------------------------------------------------------===//
 // 2.14.1. Init Directive

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

def PDL_ApplyConstraintOp
   let arguments = (ins StrAttr:$name,
                        Variadic<PDL_PositionalValue>:$args,
                        OptionalAttr<ArrayAttr>:$constParams);
   let assemblyFormat = [{
     $name ($constParams^)? `(` $args `:` type($args) `)` attr-dict
   }];
 
   let builders = [
-    OpBuilder<"StringRef name, "
-              "ValueRange args = {}, ArrayRef<Attribute> params = {}", [{
+    OpBuilderDAG<(ins "StringRef":$name, CArg<"ValueRange", "{}">:$args,
+      CArg<"ArrayRef<Attribute>", "{}">:$params), [{
       build($_builder, $_state, $_builder.getStringAttr(name), args,
             params.empty() ? ArrayAttr() : $_builder.getArrayAttr(params));
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::AttributeOp
def PDL_AttributeOp : PDL_Op<"attribute"> {
   }];
 
   let arguments = (ins Optional<PDL_Type>:$type,
                        OptionalAttr<AnyAttr>:$value);
   let results = (outs PDL_Attribute:$attr);
   let assemblyFormat = "attr-dict (`:` $type^)? ($value^)?";
 
   let builders = [
-    OpBuilder<"Value type = Value()", [{
+    OpBuilderDAG<(ins CArg<"Value", "Value()">:$type), [{
       build($_builder, $_state, $_builder.getType<AttributeType>(), type,
             Attribute());
     }]>,
-    OpBuilder<"Attribute attr", [{
+    OpBuilderDAG<(ins "Attribute":$attr), [{
       build($_builder, $_state, $_builder.getType<AttributeType>(), Value(), attr);
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::CreateNativeOp
 //===----------------------------------------------------------------------===//
let description = [{
     ```
   }];
 
   let arguments = (ins Optional<PDL_Type>:$type);
   let results = (outs PDL_Value:$val);
   let assemblyFormat = "(`:` $type^)? attr-dict";
 
   let builders = [
-    OpBuilder<"", [{
+    OpBuilderDAG<(ins), [{
       build($_builder, $_state, $_builder.getType<ValueType>(), Value());
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperationOp
 //===----------------------------------------------------------------------===//
def PDL_OperationOp
   let arguments = (ins OptionalAttr<StrAttr>:$name,
                        Variadic<PDL_Value>:$operands,
                        Variadic<PDL_Attribute>:$attributes,
                        StrArrayAttr:$attributeNames,
                        Variadic<PDL_Type>:$types);
   let results = (outs PDL_Operation:$op,
                       Variadic<PDL_Value>:$results);
   let builders = [
-    OpBuilder<"Optional<StringRef> name  = llvm::None, "
-              "ValueRange operandValues = llvm::None, "
-              "ArrayRef<StringRef> attrNames = llvm::None, "
-              "ValueRange attrValues  = llvm::None, "
-              "ValueRange resultTypes = llvm::None", [{
+    OpBuilderDAG<(ins CArg<"Optional<StringRef>", "llvm::None">:$name,
+      CArg<"ValueRange", "llvm::None">:$operandValues,
+      CArg<"ArrayRef<StringRef>", "llvm::None">:$attrNames,
+      CArg<"ValueRange", "llvm::None">:$attrValues,
+      CArg<"ValueRange", "llvm::None">:$resultTypes), [{
       auto nameAttr = name ? StringAttr() : $_builder.getStringAttr(*name);
       build($_builder, $_state, $_builder.getType<OperationType>(), {}, nameAttr,
             operandValues, attrValues, $_builder.getStrArrayAttr(attrNames),
             resultTypes);
       $_state.types.append(resultTypes.size(), $_builder.getType<ValueType>());
     }]>,
   ];
   let extraClassDeclaration = [{
let arguments = (ins OptionalAttr<StrAttr>:$rootKind,
                        OptionalAttr<SymbolNameAttr>:$sym_name);
   let regions = (region SizedRegion<1>:$body);
   let assemblyFormat = [{
     ($sym_name^)? `:` `benefit` `(` $benefit `)`
     (`,` `root` `(` $rootKind^ `)`)? attr-dict-with-keyword $body
   }];
 
   let builders = [
-    OpBuilder<"Optional<StringRef> rootKind = llvm::None, "
-              "Optional<uint16_t> benefit = 1, "
-              "Optional<StringRef> name = llvm::None">,
+    OpBuilderDAG<(ins CArg<"Optional<StringRef>", "llvm::None">:$rootKind,
+      CArg<"Optional<uint16_t>", "1">:$benefit,
+      CArg<"Optional<StringRef>", "llvm::None">:$name)>,
   ];
   let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
     // SymbolOpInterface Methods
     //===------------------------------------------------------------------===//
 
     /// A PatternOp may optionally define a symbol.
     bool isOptionalSymbol() { return true; }
let description = [{
     ```
   }];
 
   let arguments = (ins OptionalAttr<TypeAttr>:$type);
   let results = (outs PDL_Type:$result);
   let assemblyFormat = "attr-dict (`:` $type^)?";
 
   let builders = [
-    OpBuilder<"Type ty = Type()", [{
+    OpBuilderDAG<(ins CArg<"Type", "Type()">:$ty), [{
       build($_builder, $_state, $_builder.getType<AttributeType>(),
             ty ? TypeAttr::get(ty) : TypeAttr());
     }]>,
   ];
 }
 
 #endif // MLIR_DIALECT_PDL_IR_PDLOPS

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

let description = [{
     ```
   }];
 
   let arguments = (ins AnyAttr:$value);
   let results = (outs PDL_Attribute:$attribute);
   let assemblyFormat = "$value attr-dict";
 
   let builders = [
-    OpBuilder<"Attribute value", [{
+    OpBuilderDAG<(ins "Attribute":$value), [{
       build($_builder, $_state, $_builder.getType<pdl::AttributeType>(), value);
     }]>];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CreateNativeOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_CreateNativeOp : PDLInterp_Op<"create_native"> {
   let summary = "Call a native creation method to construct an `Attribute`, "
def PDLInterp_CreateOperationOp
   let arguments = (ins StrAttr:$name,
                        Variadic<PDL_Value>:$operands,
                        Variadic<PDL_Attribute>:$attributes,
                        StrArrayAttr:$attributeNames,
                        Variadic<PDL_Type>:$types);
   let results = (outs PDL_Operation:$operation);
 
   let builders = [
-    OpBuilder<"StringRef name, ValueRange types, ValueRange operands, "
-              "ValueRange attributes, ArrayAttr attributeNames", [{
+    OpBuilderDAG<(ins "StringRef":$name, "ValueRange":$types,
+      "ValueRange":$operands, "ValueRange":$attributes,
+      "ArrayAttr":$attributeNames), [{
       build($_builder, $_state, $_builder.getType<pdl::OperationType>(), name,
             operands, attributes, attributeNames, types);
     }]>];
   let parser = [{ return ::parseCreateOperationOp(parser, result); }];
   let printer = [{ ::print(p, *this); }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CreateTypeOp
 //===----------------------------------------------------------------------===//
 
let description = [{
     ```
   }];
 
   let arguments = (ins TypeAttr:$value);
   let results = (outs PDL_Type:$result);
   let assemblyFormat = "$value attr-dict";
 
   let builders = [
-    OpBuilder<"TypeAttr type", [{
+    OpBuilderDAG<(ins "TypeAttr":$type), [{
       build($_builder, $_state, $_builder.getType<pdl::TypeType>(), type);
     }]>
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::EraseOp
 //===----------------------------------------------------------------------===//
let description = [{
     ```
   }];
 
   let arguments = (ins PDL_Attribute:$value);
   let results = (outs PDL_Type:$result);
   let assemblyFormat = "`of` $value attr-dict";
 
   let builders = [
-    OpBuilder<"Value value", [{
+    OpBuilderDAG<(ins "Value":$value), [{
       build($_builder, $_state, $_builder.getType<pdl::TypeType>(), value);
     }]>
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetDefiningOpOp
 //===----------------------------------------------------------------------===//
let description = [{
     ```
   }];
 
   let arguments = (ins PDL_Value:$value);
   let results = (outs PDL_Type:$result);
   let assemblyFormat = "`of` $value attr-dict";
 
   let builders = [
-    OpBuilder<"Value value", [{
+    OpBuilderDAG<(ins "Value":$value), [{
       build($_builder, $_state, $_builder.getType<pdl::TypeType>(), value);
     }]>
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::InferredTypeOp
 //===----------------------------------------------------------------------===//
let description = [{
     ```mlir
     pdl_interp.inferred_type
     ```
   }];
   let results = (outs PDL_Type:$type);
   let assemblyFormat = "attr-dict";
 
   let builders = [
-    OpBuilder<"", [{
+    OpBuilderDAG<(ins), [{
       build($_builder, $_state, $_builder.getType<pdl::TypeType>());
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::IsNotNullOp
 //===----------------------------------------------------------------------===//
let description = [{
     ```
   }];
   let arguments = (ins PDL_Attribute:$attribute, ArrayAttr:$caseValues);
   let assemblyFormat = [{
     $attribute `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
-    OpBuilder<"Value attribute, ArrayRef<Attribute> caseValues,"
-              "Block *defaultDest, BlockRange dests", [{
+    OpBuilderDAG<(ins "Value":$attribute, "ArrayRef<Attribute>":$caseValues,
+      "Block *":$defaultDest, "BlockRange":$dests), [{
     build($_builder, $_state, attribute, $_builder.getArrayAttr(caseValues),
           defaultDest, dests);
   }]>];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchOperandCountOp
 //===----------------------------------------------------------------------===//
def PDLInterp_SwitchOperandCountOp
   }];
 
   let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
   let assemblyFormat = [{
     `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
-    OpBuilder<"Value operation, ArrayRef<int32_t> counts, "
-              "Block *defaultDest, BlockRange dests", [{
+    OpBuilderDAG<(ins "Value":$operation, "ArrayRef<int32_t>":$counts,
+      "Block *":$defaultDest, "BlockRange":$dests), [{
     build($_builder, $_state, operation, $_builder.getI32VectorAttr(counts),
           defaultDest, dests);
   }]>];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchOperationNameOp
 //===----------------------------------------------------------------------===//
def PDLInterp_SwitchOperationNameOp
 
   let arguments = (ins PDL_Operation:$operation,
                        StrArrayAttr:$caseValues);
   let assemblyFormat = [{
     `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
-    OpBuilder<"Value operation, ArrayRef<OperationName> names, "
-              "Block *defaultDest, BlockRange dests", [{
+    OpBuilderDAG<(ins "Value":$operation, "ArrayRef<OperationName>":$names,
+      "Block *":$defaultDest, "BlockRange":$dests), [{
       auto stringNames = llvm::to_vector<8>(llvm::map_range(names,
           [](OperationName name) { return name.getStringRef(); }));
       build($_builder, $_state, operation, $_builder.getStrArrayAttr(stringNames),
             defaultDest, dests);
     }]>,
   ];
 }
 
def PDLInterp_SwitchResultCountOp
   }];
 
   let arguments = (ins PDL_Operation:$operation, I32ElementsAttr:$caseValues);
   let assemblyFormat = [{
     `of` $operation `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
-    OpBuilder<"Value operation, ArrayRef<int32_t> counts, Block *defaultDest, "
-              "BlockRange dests", [{
+    OpBuilderDAG<(ins "Value":$operation, "ArrayRef<int32_t>":$counts,
+      "Block *":$defaultDest, "BlockRange":$dests), [{
     build($_builder, $_state, operation, $_builder.getI32VectorAttr(counts),
           defaultDest, dests);
   }]>];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchTypeOp
 //===----------------------------------------------------------------------===//
def PDLInterp_SwitchTypeOp : PDLInterp_SwitchOp<"switch_type", [NoSideEffect]> {
   }];
 
   let arguments = (ins PDL_Type:$value, TypeArrayAttr:$caseValues);
   let assemblyFormat = [{
     $value `to` $caseValues `(` $cases `)` attr-dict `->` $defaultDest
   }];
 
   let builders = [
-    OpBuilder<"Value edge, TypeRange types, Block *defaultDest, "
-              "BlockRange dests", [{
+    OpBuilderDAG<(ins "Value":$edge, "TypeRange":$types, "Block *":$defaultDest,
+      "BlockRange":$dests), [{
       build($_builder, $_state, edge, $_builder.getTypeArrayAttr(types),
             defaultDest, dests);
     }]>,
   ];
 
   let extraClassDeclaration = [{
     auto getCaseTypes() { return caseValues().getAsValueRange<TypeAttr>(); }
   }];
 }
 
 #endif // MLIR_DIALECT_PDLINTERP_IR_PDLINTERPOPS

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

let arguments = (ins Index:$lowerBound,
                        Index:$upperBound,
                        Index:$step,
                        Variadic<AnyType>:$initArgs);
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"Value lowerBound, Value upperBound, Value step, "
-              "ValueRange iterArgs = llvm::None, "
-              "function_ref<void(OpBuilder &, Location, Value, ValueRange)>"
-              "    = nullptr">
+    OpBuilderDAG<(ins "Value":$lowerBound, "Value":$upperBound, "Value":$step,
+      CArg<"ValueRange", "llvm::None">:$iterArgs,
+      CArg<"function_ref<void(OpBuilder &, Location, Value, ValueRange)>",
+           "nullptr">)>
   ];
 
   let extraClassDeclaration = [{
     using BodyBuilderFn =
         function_ref<void(OpBuilder &, Location, Value, ValueRange)>;
 
     Value getInductionVar() { return getBody()->getArgument(0); }
     Block::BlockArgListType getRegionIterArgs() {
let description = [{
     ```
   }];
   let arguments = (ins I1:$condition);
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$thenRegion, AnyRegion:$elseRegion);
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"Value cond, bool withElseRegion">,
-    OpBuilder<"TypeRange resultTypes, Value cond, bool withElseRegion">,
-    OpBuilder<
-        "TypeRange resultTypes, Value cond, "
-        "function_ref<void(OpBuilder &, Location)> thenBuilder "
-        "    = buildTerminatedBody, "
-        "function_ref<void(OpBuilder &, Location)> elseBuilder = nullptr">,
-    OpBuilder<
-        "Value cond, "
-        "function_ref<void(OpBuilder &, Location)> thenBuilder "
-        "    = buildTerminatedBody, "
-        "function_ref<void(OpBuilder &, Location)> elseBuilder = nullptr">
+    OpBuilderDAG<(ins "Value":$cond, "bool":$withElseRegion)>,
+    OpBuilderDAG<(ins "TypeRange":$resultTypes, "Value":$cond,
+      "bool":$withElseRegion)>,
+    OpBuilderDAG<(ins "TypeRange":$resultTypes, "Value":$cond,
+      CArg<"function_ref<void(OpBuilder &, Location)>",
+           "buildTerminatedBody">:$thenBuilder,
+      CArg<"function_ref<void(OpBuilder &, Location)>",
+           "nullptr">:$elseBuilder)>,
+    OpBuilderDAG<(ins "Value":$cond,
+      CArg<"function_ref<void(OpBuilder &, Location)>",
+           "buildTerminatedBody">:$thenBuilder,
+      CArg<"function_ref<void(OpBuilder &, Location)>",
+           "nullptr">:$elseBuilder)>
   ];
 
   let extraClassDeclaration = [{
     OpBuilder getThenBodyBuilder(OpBuilder::Listener *listener = nullptr) {
       Block* body = getBody(0);
       return results().empty() ? OpBuilder::atBlockTerminator(body, listener)
                                : OpBuilder::atBlockEnd(body, listener);
     }
let arguments = (ins Variadic<Index>:$lowerBound,
                        Variadic<Index>:$upperBound,
                        Variadic<Index>:$step,
                        Variadic<AnyType>:$initVals);
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"ValueRange lowerBounds, ValueRange upperBounds, "
-              "ValueRange steps, ValueRange initVals, "
-              "function_ref<void (OpBuilder &, Location, "
-                                 "ValueRange, ValueRange)>"
-              "  bodyBuilderFn = nullptr">,
-    OpBuilder<"ValueRange lowerBounds, ValueRange upperBounds, "
-              "ValueRange steps, "
-              "function_ref<void (OpBuilder &, Location, ValueRange)>"
-              "  bodyBuilderFn = nullptr">,
+    OpBuilderDAG<(ins "ValueRange":$lowerBounds, "ValueRange":$upperBounds,
+      "ValueRange":$steps, "ValueRange":$initVals,
+      CArg<"function_ref<void (OpBuilder &, Location, ValueRange, ValueRange)>",
+           "nullptr">:$bodyBuilderFn)>,
+    OpBuilderDAG<(ins "ValueRange":$lowerBounds, "ValueRange":$upperBounds,
+      "ValueRange":$steps,
+      CArg<"function_ref<void (OpBuilder &, Location, ValueRange)>",
+           "nullptr">:$bodyBuilderFn)>,
   ];
 
   let extraClassDeclaration = [{
     ValueRange getInductionVars() {
       return getBody()->getArguments();
     }
     unsigned getNumLoops() { return step().size(); }
     unsigned getNumReductions() { return initVals().size(); }
scf.reduce(%operand) : f32 {
         %res = addf %lhs, %rhs : f32
         scf.reduce.return %res : f32
     }
     ```
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"Value operand, "
-              "function_ref<void (OpBuilder &, Location, Value, Value)>"
-              "  bodyBuilderFn = nullptr">
+    OpBuilderDAG<(ins "Value":$operand,
+      CArg<"function_ref<void (OpBuilder &, Location, Value, Value)>",
+           "nullptr">:$bodyBuilderFn)>
   ];
 
   let arguments = (ins AnyType:$operand);
   let regions = (region SizedRegion<1>:$reductionOperator);
 }
 
 def ReduceReturnOp :
     SCF_Op<"reduce.return", [HasParent<"ReduceOp">, NoSideEffect,
let description = [{
     operation's results.
     If the parent operation defines no values, then the "scf.yield" may be
     left out in the custom syntax and the builders will insert one implicitly.
     Otherwise, it has to be present in the syntax to indicate which values are
     yielded.
   }];
 
   let arguments = (ins Variadic<AnyType>:$results);
-  let builders = [
-    OpBuilder<"", [{ /* nothing to do */ }]>
-  ];
+  let builders = [OpBuilderDAG<(ins), [{ /* nothing to do */ }]>];
   // Override default verifier (defined in SCF_Op), no custom verification
   // needed.
   let verifier = ?;
 }
 #endif // MLIR_DIALECT_SCF_SCFOPS

mlir/include/mlir/Dialect/SPIRV/SPIRVAtomicOps.td

let arguments = (ins
     SPV_Integer:$value
   );
 
   let results = (outs
     SPV_Integer:$result
   );
 
   let builders = [
-    OpBuilder<
-      [{Value pointer, ::mlir::spirv::Scope scope,
-        ::mlir::spirv::MemorySemantics memory, Value value}],
-      [{build($_builder, $_state, value.getType(), pointer, scope, memory, value);}]
-    >
+    OpBuilderDAG<(ins "Value":$pointer, "::mlir::spirv::Scope":$scope,
+      "::mlir::spirv::MemorySemantics":$memory, "Value":$value),
+    [{build($_builder, $_state, value.getType(), pointer, scope, memory, value);}]>
   ];
 }
 
 // -----
 
 def SPV_AtomicAndOp : SPV_AtomicUpdateWithValueOp<"AtomicAnd", []> {
   let summary = [{
     Perform the following steps atomically with respect to any other atomic

mlir/include/mlir/Dialect/SPIRV/SPIRVCompositeOps.td

let arguments = (ins
     I32ArrayAttr:$indices
   );
 
   let results = (outs
     SPV_Type:$component
   );
 
   let builders = [
-    OpBuilder<[{Value composite, ArrayRef<int32_t> indices}]>
+    OpBuilderDAG<(ins "Value":$composite, "ArrayRef<int32_t>":$indices)>
   ];
 
   let hasFolder = 1;
 }
 
 // -----
 
 def SPV_CompositeInsertOp : SPV_Op<"CompositeInsert", [NoSideEffect]> {
let arguments = (ins
     I32ArrayAttr:$indices
   );
 
   let results = (outs
     SPV_Composite:$result
   );
 
   let builders = [
-    OpBuilder<[{Value object, Value composite, ArrayRef<int32_t> indices}]>
+    OpBuilderDAG<(ins "Value":$object, "Value":$composite,
+      "ArrayRef<int32_t>":$indices)>
   ];
 }
 
 #endif // SPIRV_COMPOSITE_OPS

mlir/include/mlir/Dialect/SPIRV/SPIRVControlFlowOps.td

def SPV_BranchOp : SPV_Op<"Branch", [
 
   let results = (outs);
 
   let successors = (successor AnySuccessor:$target);
 
   let verifier = [{ return success(); }];
 
   let builders = [
-    OpBuilder<
-      "Block *successor, ValueRange arguments = {}", [{
-        $_state.addSuccessors(successor);
-        $_state.addOperands(arguments);
-      }]
-    >
+    OpBuilderDAG<(ins "Block *":$successor, CArg<"ValueRange", "{}">:$arguments),
+    [{
+    }]>
   ];
 
   let skipDefaultBuilders = 1;
 
   let extraClassDeclaration = [{
     /// Returns the branch target block.
     Block *getTarget() { return target(); }
 
def SPV_BranchConditionalOp : SPV_Op<"BranchConditional", [
   );
 
   let results = (outs);
 
   let successors = (successor AnySuccessor:$trueTarget,
                               AnySuccessor:$falseTarget);
 
   let builders = [
-    OpBuilder<
-      "Value condition, "
-      "Block *trueBlock, ValueRange trueArguments, "
-      "Block *falseBlock, ValueRange falseArguments, "
-      "Optional<std::pair<uint32_t, uint32_t>> weights = {}",
-      [{
-        ArrayAttr weightsAttr;
-        if (weights) {
-          weightsAttr =
-              $_builder.getI32ArrayAttr({static_cast<int32_t>(weights->first),
-                                       static_cast<int32_t>(weights->second)});
-        }
-        build($_builder, $_state, condition, trueArguments, falseArguments,
-              weightsAttr, trueBlock, falseBlock);
-      }]
-    >
+    OpBuilderDAG<(ins "Value":$condition, "Block *":$trueBlock,
+      "ValueRange":$trueArguments, "Block *":$falseBlock,
+      "ValueRange":$falseArguments,
+      CArg<"Optional<std::pair<uint32_t, uint32_t>>", "{}">:$weights),
+    }]>
   ];
 
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
     /// Branch indices into the successor list.
     enum { kTrueIndex = 0, kFalseIndex = 1 };
 
def SPV_LoopOp : SPV_Op<"loop", [InFunctionScope]> {
   let arguments = (ins
     SPV_LoopControlAttr:$loop_control
   );
 
   let results = (outs);
 
   let regions = (region AnyRegion:$body);
 
-  let builders = [OpBuilder<"">];
+  let builders = [OpBuilderDAG<(ins)>];
 
   let extraClassDeclaration = [{
     // Returns the entry block.
     Block *getEntryBlock();
 
     // Returns the loop header block.
     Block *getHeaderBlock();
 

mlir/include/mlir/Dialect/SPIRV/SPIRVLogicalOps.td

class SPV_LogicalBinaryOp<string mnemonic, Type operandsType,
       SPV_BinaryOp<mnemonic, SPV_Bool, operandsType,
                    !listconcat(traits,
                                [NoSideEffect, SameTypeOperands,
                                 SameOperandsAndResultShape])> {
   let parser = [{ return ::parseLogicalBinaryOp(parser, result); }];
   let printer = [{ return ::printLogicalOp(getOperation(), p); }];
 
   let builders = [
-    OpBuilder<
-      "Value lhs, Value rhs",
-      "::buildLogicalBinaryOp($_builder, $_state, lhs, rhs);">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs),
+    [{::buildLogicalBinaryOp($_builder, $_state, lhs, rhs);}]>
   ];
 }
 
 class SPV_LogicalUnaryOp<string mnemonic, Type operandType,
                          list<OpTrait> traits = []> :
       // Result type is SPV_Bool.
       SPV_UnaryOp<mnemonic, SPV_Bool, operandType,
                   !listconcat(traits, [NoSideEffect, SameTypeOperands,
let arguments = (ins
     SPV_SelectType:$true_value,
     SPV_SelectType:$false_value
   );
 
   let results = (outs
     SPV_SelectType:$result
   );
 
-  let builders = [OpBuilder<[{Value cond, Value trueValue,
-                              Value falseValue}]>];
+  let builders = [
+    OpBuilderDAG<(ins "Value":$cond, "Value":$trueValue, "Value":$falseValue)>];
 
   let assemblyFormat = [{
     operands attr-dict `:` type($condition) `,` type($result)
   }];
 }
 
 // -----
 

mlir/include/mlir/Dialect/SPIRV/SPIRVNonUniformOps.td

def SPV_GroupNonUniformElectOp : SPV_Op<"GroupNonUniformElect", []> {
   let arguments = (ins
     SPV_ScopeAttr:$execution_scope
   );
 
   let results = (outs
     SPV_Bool:$result
   );
 
-  let builders = [
-    OpBuilder<[{spirv::Scope}]>
-  ];
+  let builders = [OpBuilderDAG<(ins "spirv::Scope")>];
 
   let assemblyFormat = "$execution_scope attr-dict `:` type($result)";
 }
 
 // -----
 
 def SPV_GroupNonUniformFAddOp :
     SPV_GroupNonUniformArithmeticOp<"GroupNonUniformFAdd", SPV_Float, []> {

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.td

let arguments = (ins
     SPV_AnyPtr:$base_ptr,
     Variadic<SPV_Integer>:$indices
   );
 
   let results = (outs
     SPV_AnyPtr:$component_ptr
   );
 
-  let builders = [OpBuilder<[{Value basePtr, ValueRange indices}]>];
+  let builders = [OpBuilderDAG<(ins "Value":$basePtr, "ValueRange":$indices)>];
 
   let hasCanonicalizer = 1;
 }
 
 // -----
 
 def SPV_ControlBarrierOp : SPV_Op<"ControlBarrier", []> {
   let summary = [{
def SPV_ExecutionModeOp : SPV_Op<"ExecutionMode", [InModuleScope]> {
   );
 
   let results = (outs);
 
   let verifier = [{ return success(); }];
 
   let autogenSerialization = 0;
 
-  let builders = [OpBuilder<[{spirv::FuncOp function,
-                              spirv::ExecutionMode executionMode,
-                              ArrayRef<int32_t> params}]>];
+  let builders = [
+    OpBuilderDAG<(ins "spirv::FuncOp":$function,
+      "spirv::ExecutionMode":$executionMode, "ArrayRef<int32_t>":$params)>];
 }
 
 // -----
 
 def SPV_LoadOp : SPV_Op<"Load", []> {
   let summary = "Load through a pointer.";
 
   let description = [{
let arguments = (ins
     OptionalAttr<I32Attr>:$alignment
   );
 
   let results = (outs
     SPV_Type:$value
   );
 
   let builders = [
-    OpBuilder<[{
-      Value basePtr, IntegerAttr memory_access = {},
-      IntegerAttr alignment = {}
-    }]>
+    OpBuilderDAG<(ins "Value":$basePtr,
+      CArg<"IntegerAttr", "{}">:$memory_access,
+      CArg<"IntegerAttr", "{}">:$alignment)>
   ];
 }
 
 // -----
 
 def SPV_MemoryBarrierOp : SPV_Op<"MemoryBarrier", []> {
   let summary = "Control the order that memory accesses are observed.";
 
let arguments = (ins
     SPV_Type:$value,
     OptionalAttr<SPV_MemoryAccessAttr>:$memory_access,
     OptionalAttr<I32Attr>:$alignment
   );
 
   let results = (outs);
 
   let builders = [
-    OpBuilder<
-      "Value ptr, Value value, ArrayRef<NamedAttribute> namedAttrs = {}", [{
+    OpBuilderDAG<(ins "Value":$ptr, "Value":$value,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$namedAttrs),
+    [{
       $_state.addOperands(ptr);
       $_state.addOperands(value);
       $_state.addAttributes(namedAttrs);
     }]>
   ];
 }
 
 // -----

mlir/include/mlir/Dialect/SPIRV/SPIRVStructureOps.td

def SPV_AddressOfOp : SPV_Op<"_address_of", [InFunctionScope, NoSideEffect]> {
   let results = (outs
     SPV_AnyPtr:$pointer
   );
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
-  let builders = [OpBuilder<[{spirv::GlobalVariableOp var}]>];
+  let builders = [OpBuilderDAG<(ins "spirv::GlobalVariableOp":$var)>];
 
   let assemblyFormat = "$variable attr-dict `:` type($pointer)";
 }
 
 // -----
 
 def SPV_ConstantOp : SPV_Op<"constant", [ConstantLike, NoSideEffect]> {
   let summary = "The op that declares a SPIR-V normal constant";
let arguments = (ins
     FlatSymbolRefAttr:$fn,
     SymbolRefArrayAttr:$interface
   );
 
   let results = (outs);
 
   let autogenSerialization = 0;
 
-  let builders = [OpBuilder<[{spirv::ExecutionModel executionModel,
-                              spirv::FuncOp function,
-                              ArrayRef<Attribute> interfaceVars}]>];
+  let builders = [
+    OpBuilderDAG<(ins "spirv::ExecutionModel":$executionModel,
+      "spirv::FuncOp":$function, "ArrayRef<Attribute>":$interfaceVars)>];
 }
 
 // -----
 
 def SPV_FuncOp : SPV_Op<"func", [
     AutomaticAllocationScope, DeclareOpInterfaceMethods<CallableOpInterface>,
     FunctionLike, InModuleScope, IsolatedFromAbove, Symbol
   ]> {
def SPV_FuncOp : SPV_Op<"func", [
   );
 
   let results = (outs);
 
   let regions = (region AnyRegion:$body);
 
   let verifier = [{ return success(); }];
 
-  let builders = [OpBuilder<[{
-    StringRef name, FunctionType type,
-    spirv::FunctionControl control = spirv::FunctionControl::None,
-    ArrayRef<NamedAttribute> attrs = {}
-  }]>];
+  let builders = [
+    OpBuilderDAG<(ins "StringRef":$name, "FunctionType":$type,
+      CArg<"spirv::FunctionControl", "spirv::FunctionControl::None">:$control,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
   private:
     // This trait needs access to the hooks defined below.
let arguments = (ins
     TypeAttr:$type,
     StrAttr:$sym_name,
     OptionalAttr<FlatSymbolRefAttr>:$initializer
   );
 
   let results = (outs);
 
   let builders = [
-    OpBuilder<
-      "TypeAttr type, ArrayRef<NamedAttribute> namedAttrs", [{
+    OpBuilderDAG<(ins "TypeAttr":$type, "ArrayRef<NamedAttribute>":$namedAttrs),
+    [{
       $_state.addAttribute("type", type);
       $_state.addAttributes(namedAttrs);
     }]>,
-    OpBuilder<[{Type type, StringRef name, unsigned descriptorSet,
-                unsigned binding}]>,
-    OpBuilder<[{Type type, StringRef name, spirv::BuiltIn builtin}]>
+    OpBuilderDAG<(ins "Type":$type, "StringRef":$name,
+      "unsigned":$descriptorSet, "unsigned":$binding)>,
+    OpBuilderDAG<(ins "Type":$type, "StringRef":$name,
+      "spirv::BuiltIn":$builtin)>
   ];
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
     ::mlir::spirv::StorageClass storageClass() {
let arguments = (ins
     OptionalAttr<StrAttr>:$sym_name
   );
 
   let results = (outs);
 
   let regions = (region SizedRegion<1>:$body);
 
   let builders = [
-    OpBuilder<[{Optional<StringRef> name = llvm::None}]>,
-    OpBuilder<[{spirv::AddressingModel addressing_model,
-                spirv::MemoryModel memory_model,
-                Optional<StringRef> name = llvm::None}]>
+    OpBuilderDAG<(ins CArg<"Optional<StringRef>", "llvm::None">:$name)>,
+    OpBuilderDAG<(ins "spirv::AddressingModel":$addressing_model,
+      "spirv::MemoryModel":$memory_model,
+      CArg<"Optional<StringRef>", "llvm::None">:$name)>
   ];
 
   // We need to ensure the block inside the region is properly terminated;
   // the auto-generated builders do not guarantee that.
   let skipDefaultBuilders = 1;
 
   let hasOpcode = 0;
 

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

let description = [{
     ```mlir
     %x = shape.const_size 10
     ```
   }];
 
   let arguments = (ins IndexAttr:$value);
   let results = (outs Shape_SizeType:$result);
 
-  let builders = [
-    OpBuilder<"int64_t value">
-  ];
+  let builders = [OpBuilderDAG<(ins "int64_t":$value)>];
 
   let assemblyFormat = "$value attr-dict";
   let hasFolder = 1;
 }
 
 def Shape_ShapeEqOp : Shape_Op<"shape_eq", [Commutative, NoSideEffect]> {
   let summary = "Returns whether the input shapes or extent tensors are equal";
   let description = [{
def Shape_GetExtentOp : Shape_Op<"get_extent", [NoSideEffect]> {
   let arguments = (ins Shape_ShapeOrExtentTensorType:$shape,
                        Shape_SizeOrIndexType:$dim);
   let results = (outs Shape_SizeOrIndexType:$extent);
   let assemblyFormat = "$shape `,` $dim `:` type($shape) `,` type($dim) `->` "
                        "type($extent) attr-dict";
 
   let builders = [
     // Builder that allows passing a constant dimension as a simple integer.
-    OpBuilder<"Value shape, "
-              "int64_t dim">
+    OpBuilderDAG<(ins "Value":$shape, "int64_t":$dim)>
   ];
 
   let extraClassDeclaration = [{
     /// Get the `dim` value as integer if it is constant.
     Optional<int64_t> getConstantDim();
   }];
 
   let hasFolder = 1;
let description = [{
     `size` and potential errors will be propagated. Otherwise, if the argument
     is and extent tensor `tensor<?xindex>` then the result will be of type
     `index`.
   }];
 
   let arguments = (ins Shape_ShapeOrExtentTensorType:$shape);
   let results = (outs Shape_SizeOrIndexType:$result);
 
-  let builders = [
-    OpBuilder<"Value shape">,
-  ];
+  let builders = [OpBuilderDAG<(ins "Value":$shape)>];
 
   let assemblyFormat = "$shape `:` type($shape) `->` type($result) attr-dict";
 
   let hasFolder = 1;
   let verifier = [{ return ::verifySizeOrIndexOp(*this); }];
 }
 
 def Shape_ReduceOp : Shape_Op<"reduce",
let description = [{
     ```
   }];
 
   let arguments = (ins Shape_ShapeOrExtentTensorType:$shape,
                        Variadic<AnyType>:$initVals);
   let results = (outs Variadic<AnyType>:$result);
   let regions = (region SizedRegion<1>:$region);
 
-  let builders = [
-    OpBuilder<"Value shape, ValueRange initVals">,
-  ];
+  let builders = [OpBuilderDAG<(ins "Value":$shape, "ValueRange":$initVals)>];
 
   let verifier = [{ return ::verify(*this); }];
   let printer = [{ return ::print(p, *this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 def Shape_ShapeOfOp : Shape_Op<"shape_of", [NoSideEffect]> {
   let summary = "Returns shape of a value or shaped type operand";
 
   let description = [{
     The operation takes a value or a shaped operand as an argument and it
     returns a shape or extent tensor.
   }];
 
   let arguments = (ins AnyTypeOf<[AnyShaped, Shape_ValueShapeType]>:$arg);
   let results = (outs Shape_ShapeOrExtentTensorType:$result);
 
   let assemblyFormat = "$arg `:` type($arg) `->` type($result) attr-dict";
 
-  let builders = [
-    OpBuilder<"Value arg">
-  ];
+  let builders = [OpBuilderDAG<(ins "Value":$arg)>];
 
   let verifier = [{ return ::verifyShapeOrExtentTensorOp(*this); }];
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
 def Shape_SizeToIndexOp : Shape_Op<"size_to_index", [NoSideEffect]> {
   let summary = "Casts between index types of the shape and standard dialect";
def Shape_YieldOp : Shape_Op<"yield",
     [HasParent<"ReduceOp">,
      NoSideEffect,
      ReturnLike,
      Terminator]> {
   let summary = "Returns the value to parent op";
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
-  let builders = [
-    OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+  let builders = [OpBuilderDAG<(ins),
+    [{ build($_builder, $_state, llvm::None); }]>
   ];
 
   let verifier = [{ return ::verify(*this); }];
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 
 // TODO: Add Ops: if_static, if_ranked
 
let description = [{
     This yield operation represents a return operation within the assert_and_exec
     region. The operation takes variable number of operands and produces no
     results. The operand number and types must match the return signature of
     the region that contains the operation.
   }];
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
-  let builders = [
-    OpBuilder<"", [{ /* nothing to do */ }]>
-  ];
+  let builders = [OpBuilderDAG<(ins), [{ /* nothing to do */ }]>];
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 
 def Shape_CstrBroadcastableOp : Shape_Op<"cstr_broadcastable", [Commutative]> {
   let summary = "Determines if 2 shapes can be successfully broadcasted";
   let description = [{
     Given two input shapes or extent tensors, return a witness specifying if

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

 // Base class for standard cast operations. Requires single operand and result,
 // but does not constrain them to specific types.
 class CastOp<string mnemonic, list<OpTrait> traits = []> :
     Std_Op<mnemonic,
            !listconcat(traits, [NoSideEffect, SameOperandsAndResultShape])> {
 
   let results = (outs AnyType);
 
-  let builders = [OpBuilder<
-    "Value source, Type destType", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$source, "Type":$destType), [{
        impl::buildCastOp($_builder, $_state, source, destType);
-  }]>];
+    }]>
+  ];
 
   let parser = [{
     return impl::parseCastOp(parser, result);
   }];
   let printer = [{
     return printStandardCastOp(this->getOperation(), p);
   }];
   let verifier = [{ return ::verifyCastOp(*this); }];
class AllocLikeOp<string mnemonic,
                   Resource resource,
                   list<OpTrait> traits = []> :
     Std_Op<mnemonic, !listconcat([MemoryEffects<[MemAlloc<resource>]>], traits)> {
 
   let arguments = (ins Variadic<Index>:$value,
                    Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$alignment);
   let results = (outs Res<AnyMemRef, "", [MemAlloc<resource>]>);
 
-  let builders = [OpBuilder<
-    "MemRefType memrefType", [{
-       $_state.types.push_back(memrefType);
-     }]>,
-    OpBuilder<
-    "MemRefType memrefType, ValueRange operands, "
-    "IntegerAttr alignment = IntegerAttr()", [{
-       $_state.addOperands(operands);
-       $_state.types.push_back(memrefType);
-       if (alignment)
-         $_state.addAttribute(getAlignmentAttrName(), alignment);
-     }]>];
+  let builders = [
+    OpBuilderDAG<(ins "MemRefType":$memrefType), [{
+    OpBuilderDAG<(ins "MemRefType":$memrefType, "ValueRange":$operands,
+      CArg<"IntegerAttr", "IntegerAttr()">:$alignment), [{
 
   let extraClassDeclaration = [{
     static StringRef getAlignmentAttrName() { return "alignment"; }
 
     MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
 
     /// Returns the number of symbolic operands (the ones in square brackets),
     /// which bind to the symbols of the memref's layout map.
let arguments = (ins
       Variadic<Index>:$indices);
 
   let results = (outs
       AnyTypeOf<[AnySignlessInteger, AnyFloat]>:$result);
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
-  let builders = [
-    OpBuilder<"Value memref, ValueRange ivs">
-  ];
+  let builders = [OpBuilderDAG<(ins "Value":$memref, "ValueRange":$ivs)>];
 
   let extraClassDeclaration = [{
     // The value stored in memref[ivs].
     Value getCurrentValue() {
       return body().getArgument(0);
     }
     MemRefType getMemRefType() {
       return memref().getType().cast<MemRefType>();
^bb2:
       br ^bb3(%2 : tensor<*xf32>)
     ^bb3(%3: tensor<*xf32>):
     ```
   }];
 
   let arguments = (ins Variadic<AnyType>:$destOperands);
   let successors = (successor AnySuccessor:$dest);
 
-  let builders = [OpBuilder<"Block *dest, ValueRange destOperands = {}", [{
+  let builders = [
+    OpBuilderDAG<(ins "Block *":$dest,
+                  CArg<"ValueRange", "{}">:$destOperands), [{
       $_state.addSuccessors(dest);
       $_state.addOperands(destOperands);
     }]>];
 
   // BranchOp is fully verified by traits.
   let verifier = ?;
 
   let extraClassDeclaration = [{
     Block *getDest();
     void setDest(Block *block);
 
let description = [{
     ```mlir
     %2 = call @my_add(%0, %1) : (f32, f32) -> f32
     ```
   }];
 
   let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<AnyType>:$operands);
   let results = (outs Variadic<AnyType>);
 
-  let builders = [OpBuilder<
-    "FuncOp callee, ValueRange operands = {}", [{
+  let builders = [
+    OpBuilderDAG<(ins "FuncOp":$callee, CArg<"ValueRange", "{}">:$operands), [{
       $_state.addOperands(operands);
       $_state.addAttribute("callee",$_builder.getSymbolRefAttr(callee));
       $_state.addTypes(callee.getType().getResults());
-  }]>, OpBuilder<
-    "SymbolRefAttr callee, TypeRange results, ValueRange operands = {}", [{
+    }]>,
+    OpBuilderDAG<(ins "SymbolRefAttr":$callee, "TypeRange":$results,
+      CArg<"ValueRange", "{}">:$operands), [{
       $_state.addOperands(operands);
       $_state.addAttribute("callee", callee);
       $_state.addTypes(results);
-  }]>, OpBuilder<
-    "StringRef callee, TypeRange results, ValueRange operands = {}", [{
+    }]>,
+    OpBuilderDAG<(ins "StringRef":$callee, "TypeRange":$results,
+      CArg<"ValueRange", "{}">:$operands), [{
       build($_builder, $_state, $_builder.getSymbolRefAttr(callee), results,
             operands);
     }]>];
 
   let extraClassDeclaration = [{
     StringRef getCallee() { return callee(); }
     FunctionType getCalleeType();
 
     /// Get the argument operands to the called function.
     operand_range getArgOperands() {
       return {arg_operand_begin(), arg_operand_end()};
let description = [{
     %31 = call_indirect %15(%0, %1)
             : (tensor<16xf32>, tensor<16xf32>) -> tensor<16xf32>
     ```
   }];
 
   let arguments = (ins FunctionType:$callee, Variadic<AnyType>:$operands);
   let results = (outs Variadic<AnyType>:$results);
 
-  let builders = [OpBuilder<
-    "Value callee, ValueRange operands = {}", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$callee, CArg<"ValueRange", "{}">:$operands), [{
       $_state.operands.push_back(callee);
       $_state.addOperands(operands);
       $_state.addTypes(callee.getType().cast<FunctionType>().getResults());
     }]>];
 
   let extraClassDeclaration = [{
     Value getCallee() { return getOperand(0); }
 
     /// Get the argument operands to the called function.
     operand_range getArgOperands() {
       return {arg_operand_begin(), arg_operand_end()};
     }
def CmpFOp : Std_Op<"cmpf",
 
   let arguments = (ins
     CmpFPredicateAttr:$predicate,
     FloatLike:$lhs,
     FloatLike:$rhs
   );
   let results = (outs BoolLike:$result);
 
-  let builders = [OpBuilder<
-    "CmpFPredicate predicate, Value lhs, Value rhs", [{
+  let builders = [
+    OpBuilderDAG<(ins "CmpFPredicate":$predicate, "Value":$lhs,
+                  "Value":$rhs), [{
       ::buildCmpFOp($_builder, $_state, predicate, lhs, rhs);
     }]>];
 
   let extraClassDeclaration = [{
     static StringRef getPredicateAttrName() { return "predicate"; }
     static CmpFPredicate getPredicateByName(StringRef name);
 
     CmpFPredicate getPredicate() {
       return (CmpFPredicate)getAttrOfType<IntegerAttr>(getPredicateAttrName())
           .getInt();
def CmpIOp : Std_Op<"cmpi",
 
   let arguments = (ins
       CmpIPredicateAttr:$predicate,
       SignlessIntegerLike:$lhs,
       SignlessIntegerLike:$rhs
   );
   let results = (outs BoolLike:$result);
 
-  let builders = [OpBuilder<
-    "CmpIPredicate predicate, Value lhs, Value rhs", [{
+  let builders = [
+    OpBuilderDAG<(ins "CmpIPredicate":$predicate, "Value":$lhs,
+                 "Value":$rhs), [{
       ::buildCmpIOp($_builder, $_state, predicate, lhs, rhs);
     }]>];
 
   let extraClassDeclaration = [{
     static StringRef getPredicateAttrName() { return "predicate"; }
     static CmpIPredicate getPredicateByName(StringRef name);
 
     CmpIPredicate getPredicate() {
       return (CmpIPredicate)getAttrOfType<IntegerAttr>(getPredicateAttrName())
           .getInt();
let description = [{
     ```
   }];
 
   let arguments = (ins I1:$condition,
                        Variadic<AnyType>:$trueDestOperands,
                        Variadic<AnyType>:$falseDestOperands);
   let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
 
-  let builders = [OpBuilder<
-    "Value condition, Block *trueDest, ValueRange trueOperands,"
-    "Block *falseDest, ValueRange falseOperands", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$condition, "Block *":$trueDest,
+      "ValueRange":$trueOperands, "Block *":$falseDest,
+      "ValueRange":$falseOperands), [{
       build($_builder, $_state, condition, trueOperands, falseOperands, trueDest,
             falseDest);
-  }]>, OpBuilder<
-    "Value condition, Block *trueDest, Block *falseDest, "
-    "ValueRange falseOperands = {}", [{
+    }]>,
+    OpBuilderDAG<(ins "Value":$condition, "Block *":$trueDest,
+      "Block *":$falseDest, CArg<"ValueRange", "{}">:$falseOperands), [{
       build($_builder, $_state, condition, trueDest, ValueRange(), falseDest,
             falseOperands);
     }]>];
 
   // CondBranchOp is fully verified by traits.
   let verifier = ?;
 
   let extraClassDeclaration = [{
     // These are the indices into the dests list.
     enum { trueIndex = 0, falseIndex = 1 };
 
let description = [{
     the compiler is multithreaded, and disallowing SSA values to directly
     reference a function simplifies this
     ([rationale](../Rationale/Rationale.md#multithreading-the-compiler)).
   }];
 
   let arguments = (ins AnyAttr:$value);
   let results = (outs AnyType);
 
-  let builders = [OpBuilder<"Attribute value",
+  let builders = [
+    OpBuilderDAG<(ins "Attribute":$value),
     [{ build($_builder, $_state, value.getType(), value); }]>];
 
   let extraClassDeclaration = [{
     Attribute getValue() { return getAttr("value"); }
 
     /// Returns true if a constant operation can be built with the given value
     /// and result type.
     static bool isBuildableWith(Attribute value, Type type);
let arguments = (ins AnyTypeOf<[AnyRankedOrUnrankedMemRef, AnyTensor],
                        Index:$index);
   let results = (outs Index:$result);
 
   let assemblyFormat = [{
     attr-dict $memrefOrTensor `,` $index `:` type($memrefOrTensor)
   }];
 
   let builders = [
-    OpBuilder<"Value memrefOrTensor, int64_t index">,
-    OpBuilder<"Value memrefOrTensor, Value index">
+    OpBuilderDAG<(ins "Value":$memrefOrTensor, "int64_t":$index)>,
+    OpBuilderDAG<(ins "Value":$memrefOrTensor, "Value":$index)>
   ];
 
   let extraClassDeclaration = [{
     /// Helper function to get the index as a simple integer if it is constant.
     Optional<int64_t> getConstantIndex();
   }];
 
   let hasFolder = 1;
def DynamicTensorFromElementsOp : Std_Op<"dynamic_tensor_from_elements",
   }];
 
   let arguments = (ins Variadic<Index>:$dynamicExtents);
   let results = (outs AnyRankedTensor:$result);
   let regions = (region SizedRegion<1>:$body);
 
   let builders = [
     // Build op and populate its body per callback function.
-    OpBuilder<"Type resultTy, ValueRange dynamicExtents, "
-              "function_ref<void(OpBuilder &, Location, ValueRange)>">,
+    OpBuilderDAG<(ins "Type":$resultTy, "ValueRange":$dynamicExtents,
+      "function_ref<void(OpBuilder &, Location, ValueRange)>")>,
   ];
 
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ExpOp
 //===----------------------------------------------------------------------===//
let description = [{
     %5 = extract_element %ut[%1, %2] : tensor<*xi32>
     ```
   }];
 
   let arguments = (ins AnyTypeOf<[AnyVector, AnyTensor]>:$aggregate,
                        Variadic<Index>:$indices);
   let results = (outs AnyType:$result);
 
-  let builders = [OpBuilder<
-    "Value aggregate, ValueRange indices = {}", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$aggregate, CArg<"ValueRange", "{}">:$indices), [{
       auto resType = aggregate.getType().cast<ShapedType>()
                                          .getElementType();
       build($_builder, $_state, resType, aggregate, indices);
     }]>];
 
   let extraClassDeclaration = [{
     Value getAggregate() { return getOperand(0); }
 
def TensorFromElementsOp : Std_Op<"tensor_from_elements", [
 
   let assemblyFormat = "$elements attr-dict `:` type($result)";
 
   // This op is fully verified by its traits.
   let verifier = ?;
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"Type elementType, ValueRange elements">,
+    OpBuilderDAG<(ins "Type":$elementType, "ValueRange":$elements)>,
     // Special case builder for when `elements` has size >=1.
-    OpBuilder<"ValueRange elements">
+    OpBuilderDAG<(ins "ValueRange":$elements)>
   ];
 
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // FPExtOp
 //===----------------------------------------------------------------------===//
let description = [{
     in these contexts.
   }];
 
   let arguments = (ins Arg<AnyMemRef, "the reference to load from",
                            [MemRead]>:$memref,
                        Variadic<Index>:$indices);
   let results = (outs AnyType:$result);
 
-  let builders = [OpBuilder<
-    "Value memref, ValueRange indices = {}", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$memref, CArg<"ValueRange", "{}">:$indices), [{
       auto memrefType = memref.getType().cast<MemRefType>();
       $_state.addOperands(memref);
       $_state.addOperands(indices);
       $_state.types.push_back(memrefType.getElementType());
     }]>];
 
   let extraClassDeclaration = [{
     Value getMemRef() { return getOperand(0); }
     void setMemRef(Value value) { setOperand(0, value); }
     MemRefType getMemRefType() {
       return getMemRef().getType().cast<MemRefType>();
     }
 
def MemRefReshapeOp: Std_Op<"memref_reshape", [
   }];
 
   let arguments = (ins
     AnyRankedOrUnrankedMemRef:$source,
     MemRefRankOf<[AnySignlessInteger], [1]>:$shape
   );
   let results = (outs AnyRankedOrUnrankedMemRef:$result);
 
-  let builders = [OpBuilder<
-     "MemRefType resultType, Value operand, Value shape", [{
+  let builders = [OpBuilderDAG<
+     (ins "MemRefType":$resultType, "Value":$operand, "Value":$shape), [{
        $_state.addOperands(operand);
        $_state.addOperands(shape);
        $_state.addTypes(resultType);
      }]>];
 
   let extraClassDeclaration = [{
     MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
     Value getViewSource() { return source(); }
let description = [{
     ```
   }];
 
   let arguments = (ins AnyTypeOf<[AnyRankedOrUnrankedMemRef, AnyTensor],
                                  "any tensor or memref type">:$memrefOrTensor);
   let results = (outs Index);
   let verifier = ?;
 
-  let builders = [OpBuilder<
-    "Value tensor", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$tensor), [{
       auto indexType = $_builder.getIndexType();
       build($_builder, $_state, indexType, tensor);
     }]>];
 
   let hasFolder = 1;
   let assemblyFormat = "$memrefOrTensor attr-dict `:` type($memrefOrTensor)";
 }
 
func @foo() : (i32, f8) {
       ...
       return %0, %1 : i32, f8
     }
     ```
   }];
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
-  let builders = [OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>];
+  let builders = [
+    OpBuilderDAG<(ins),
+    [{ build($_builder, $_state, llvm::None); }]>];
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 
 //===----------------------------------------------------------------------===//
 // RsqrtOp
 //===----------------------------------------------------------------------===//
 
let description = [{
     ```
   }];
 
   let arguments = (ins BoolLike:$condition,
                        AnyType:$true_value,
                        AnyType:$false_value);
   let results = (outs AnyType:$result);
 
-  let builders = [OpBuilder<
-    "Value condition, Value trueValue, Value falseValue", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$condition, "Value":$trueValue,
+      "Value":$falseValue), [{
       $_state.addOperands({condition, trueValue, falseValue});
       $_state.addTypes(trueValue.getType());
     }]>];
 
   let extraClassDeclaration = [{
       Value getCondition() { return condition(); }
       Value getTrueValue() { return true_value(); }
       Value getFalseValue() { return false_value(); }
   }];
 
   let hasFolder = 1;
let description = [{
 
     %5 = sexti %0 : vector<2 x i32> to vector<2 x i64>
     ```
   }];
 
   let arguments = (ins SignlessIntegerLike:$value);
   let results = (outs SignlessIntegerLike);
 
-  let builders = [OpBuilder<"Value value, Type destType", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$value, "Type":$destType), [{
       $_state.addOperands(value);
       $_state.addTypes(destType);
     }]>];
 
   let parser = [{
     return impl::parseCastOp(parser, result);
   }];
   let printer = [{
     return printStandardCastOp(this->getOperation(), p);
   }];
 }
let description = [{
     %t = splat %s [%m, %n] : tensor<?x?xi32>
     ```
   }];
 
   let arguments = (ins AnyTypeOf<[AnySignlessInteger, AnyFloat],
                                  "integer or float type">:$input);
   let results = (outs AnyTypeOf<[AnyVector, AnyStaticShapeTensor]>:$aggregate);
 
-  let builders =
-      [OpBuilder<"Value element, Type aggregateType",
-                  [{ build($_builder, $_state, aggregateType, element); }]>];
+  let builders = [
+    OpBuilderDAG<(ins "Value":$element, "Type":$aggregateType),
 
   let hasFolder = 1;
 
   let assemblyFormat = "$input attr-dict `:` type($aggregate)";
 }
 
 //===----------------------------------------------------------------------===//
 // SqrtOp
let description = [{
     in these contexts.
   }];
 
   let arguments = (ins AnyType:$value,
                        Arg<AnyMemRef, "the reference to store to",
                            [MemWrite]>:$memref,
                        Variadic<Index>:$indices);
 
-  let builders = [OpBuilder<
-    "Value valueToStore, Value memref", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$valueToStore, "Value":$memref), [{
       $_state.addOperands(valueToStore);
       $_state.addOperands(memref);
     }]>];
 
   let extraClassDeclaration = [{
       Value getValueToStore() { return getOperand(0); }
 
       Value getMemRef() { return getOperand(1); }
       void setMemRef(Value value) { setOperand(1, value); }
       MemRefType getMemRefType() {
         return getMemRef().getType().cast<MemRefType>();
let arguments = (ins
     I64ArrayAttr:$static_offsets,
     I64ArrayAttr:$static_sizes,
     I64ArrayAttr:$static_strides
   );
   let results = (outs AnyMemRef:$result);
 
   let builders = [
     // Build a SubViewOp with mixed static and dynamic entries.
-    OpBuilder<
-      "Value source, ArrayRef<int64_t> staticOffsets, "
-      "ArrayRef<int64_t> staticSizes, ArrayRef<int64_t> staticStrides, "
-      "ValueRange offsets, ValueRange sizes, ValueRange strides, "
-      "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilderDAG<(ins "Value":$source, "ArrayRef<int64_t>":$staticOffsets,
+      "ArrayRef<int64_t>":$staticSizes, "ArrayRef<int64_t>":$staticStrides,
+      "ValueRange":$offsets, "ValueRange":$sizes, "ValueRange":$strides,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with all dynamic entries.
-    OpBuilder<
-      "Value source, ValueRange offsets, ValueRange sizes, ValueRange strides, "
-      "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilderDAG<(ins "Value":$source, "ValueRange":$offsets,
+      "ValueRange":$sizes, "ValueRange":$strides,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with mixed static and dynamic entries
     // and custom result type.
-    OpBuilder<
-      "MemRefType resultType, Value source, ArrayRef<int64_t> staticOffsets, "
-      "ArrayRef<int64_t> staticSizes, ArrayRef<int64_t> staticStrides, "
-      "ValueRange offsets, ValueRange sizes, "
-      "ValueRange strides, ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
+      "ArrayRef<int64_t>":$staticOffsets, "ArrayRef<int64_t>":$staticSizes,
+      "ArrayRef<int64_t>":$staticStrides, "ValueRange":$offsets,
+      "ValueRange":$sizes, "ValueRange":$strides,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with all dynamic entries and custom result type.
-    OpBuilder<
-      "MemRefType resultType, Value source, ValueRange offsets, "
-      "ValueRange sizes, ValueRange strides, "
-      "ArrayRef<NamedAttribute> attrs = {}">
+    OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
+      "ValueRange":$offsets, "ValueRange":$sizes, "ValueRange":$strides,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// Returns the type of the base memref operand.
     MemRefType getSourceType() {
       return source().getType().cast<MemRefType>();
     }
 
let arguments = (ins
     I64ArrayAttr:$static_offsets,
     I64ArrayAttr:$static_sizes,
     I64ArrayAttr:$static_strides
   );
   let results = (outs AnyRankedTensor:$result);
 
   let builders = [
     // Build a SubViewOp with mixed static and dynamic entries.
-    OpBuilder<
-      "Value source, ArrayRef<int64_t> staticOffsets, "
-      "ArrayRef<int64_t> staticSizes, ArrayRef<int64_t> staticStrides, "
-      "ValueRange offsets, ValueRange sizes, ValueRange strides, "
-      "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilderDAG<(ins "Value":$source, "ArrayRef<int64_t>":$staticOffsets,
+      "ArrayRef<int64_t>":$staticSizes, "ArrayRef<int64_t>":$staticStrides,
+      "ValueRange":$offsets, "ValueRange":$sizes, "ValueRange":$strides,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with all dynamic entries.
-    OpBuilder<
-      "Value source, ValueRange offsets, ValueRange sizes, ValueRange strides, "
-      "ArrayRef<NamedAttribute> attrs = {}">
+    OpBuilderDAG<(ins "Value":$source, "ValueRange":$offsets,
+      "ValueRange":$sizes, "ValueRange":$strides,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// Returns the type of the base tensor operand.
     RankedTensorType getSourceType() {
       return source().getType().cast<RankedTensorType>();
     }
 
let arguments = (ins
     I64ArrayAttr:$static_offsets,
     I64ArrayAttr:$static_sizes,
     I64ArrayAttr:$static_strides
   );
   let results = (outs AnyRankedTensor:$result);
 
   let builders = [
     // Build a SubViewOp with mixed static and dynamic entries.
-    OpBuilder<
-      "Value source, Value dest, ArrayRef<int64_t> staticOffsets, "
-      "ArrayRef<int64_t> staticSizes, ArrayRef<int64_t> staticStrides, "
-      "ValueRange offsets, ValueRange sizes, ValueRange strides, "
-      "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilderDAG<(ins "Value":$source, "Value":$dest,
+      "ArrayRef<int64_t>":$staticOffsets, "ArrayRef<int64_t>":$staticSizes,
+      "ArrayRef<int64_t>":$staticStrides, "ValueRange":$offsets,
+      "ValueRange":$sizes, "ValueRange":$strides,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with all dynamic entries.
-    OpBuilder<
-      "Value source, Value dest, ValueRange offsets, ValueRange sizes, "
-      "ValueRange strides, ArrayRef<NamedAttribute> attrs = {}">
+    OpBuilderDAG<(ins "Value":$source, "Value":$dest, "ValueRange":$offsets,
+      "ValueRange":$sizes, "ValueRange":$strides,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     /// Returns the type of the base tensor operand.
     RankedTensorType getSourceType() {
       return source().getType().cast<RankedTensorType>();
     }
 
def TensorLoadOp : Std_Op<"tensor_load",
   }];
 
   let arguments = (ins Arg<AnyRankedOrUnrankedMemRef,
                        "the reference to load from", [MemRead]>:$memref);
   let results = (outs AnyTensor:$result);
   // TensorLoadOp is fully verified by traits.
   let verifier = ?;
 
-  let builders = [OpBuilder<
-    "Value memref", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$memref), [{
       $_state.addOperands(memref);
       $_state.addTypes(getTensorTypeFromMemRefType(memref.getType()));
     }]>];
 
   let extraClassDeclaration = [{
     /// The result of a tensor_load is always a tensor.
     TensorType getType() {
       Type resultType = getResult().getType();
       if (resultType.isa<TensorType>())
         return resultType.cast<TensorType>();
       return {};
let description = [{
 
     Example:
 
     ```mlir
     %1 = transpose %0 (i, j) -> (j, i) : memref<?x?xf32> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d1 * s0 + d0)>>
     ```
   }];
 
-  let builders = [OpBuilder<
-    "Value in, AffineMapAttr permutation, "
-    "ArrayRef<NamedAttribute> attrs = {}">];
+  let builders = [
+    OpBuilderDAG<(ins "Value":$in, "AffineMapAttr":$permutation,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
 
   let extraClassDeclaration = [{
     static StringRef getPermutationAttrName() { return "permutation"; }
     ShapedType getShapedType() { return in().getType().cast<ShapedType>(); }
   }];
 
   let hasFolder = 1;
 }
```mlir
 
       %5 = trunci %0 : vector<2 x i32> to vector<2 x i16>
     ```
   }];
 
   let arguments = (ins SignlessIntegerLike:$value);
   let results = (outs SignlessIntegerLike);
 
-  let builders = [OpBuilder<
-    "Value value, Type destType", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$value, "Type":$destType), [{
       $_state.addOperands(value);
       $_state.addTypes(destType);
     }]>];
 
   let parser = [{
     return impl::parseCastOp(parser, result);
   }];
   let printer = [{
     return printStandardCastOp(this->getOperation(), p);
   }];
 }
```mlir
 
       %5 = zexti %0 : vector<2 x i32> to vector<2 x i64>
     ```
   }];
 
   let arguments = (ins SignlessIntegerLike:$value);
   let results = (outs SignlessIntegerLike);
 
-  let builders = [OpBuilder<
-    "Value value, Type destType", [{
+  let builders = [
+    OpBuilderDAG<(ins "Value":$value, "Type":$destType), [{
       $_state.addOperands(value);
       $_state.addTypes(destType);
     }]>];
 
   let parser = [{
     return impl::parseCastOp(parser, result);
   }];
   let printer = [{
     return printStandardCastOp(this->getOperation(), p);
   }];
 }
 
 #endif // STANDARD_OPS

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

let description = [{
 
     // Vector contraction with mixed typed. lhs/rhs have different element
     // types than accumulator/result.
     %6 = vector.contract #contraction_trait %0, %1, %2
       : vector<10xf16>, vector<10xf16> into f32
     ```
   }];
   let builders = [
-    OpBuilder<"Value lhs, Value rhs, Value acc, ArrayAttr indexingMaps, "
-              "ArrayAttr iteratorTypes">,
-    OpBuilder<"Value lhs, Value rhs, Value acc, "
-              "ArrayRef<ArrayRef<AffineExpr>> indexingExprs, "
-        "ArrayRef<StringRef> iteratorTypes">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs, "Value":$acc,
+      "ArrayAttr":$indexingMaps, "ArrayAttr":$iteratorTypes)>,
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs, "Value":$acc,
+      "ArrayRef<ArrayRef<AffineExpr>>":$indexingExprs,
+      "ArrayRef<StringRef>":$iteratorTypes)>
   ];
   let extraClassDeclaration = [{
     VectorType getLhsType() {
       return lhs().getType().cast<VectorType>();
     }
     VectorType getRhsType() {
       return rhs().getType().cast<VectorType>();
     }
%0 = vector.shuffle %a, %b[0, 3]
                : vector<2xf32>, vector<2xf32>       ; yields vector<2xf32>
     %1 = vector.shuffle %c, %b[0, 1, 2]
                : vector<2x16xf32>, vector<1x16xf32> ; yields vector<3x16xf32>
     %2 = vector.shuffle %a, %b[3, 2, 1, 0]
                : vector<2xf32>, vector<2xf32>       ; yields vector<4xf32>
     ```
   }];
   let builders = [
-    OpBuilder<"Value v1, Value v2, ArrayRef<int64_t>">
+    OpBuilderDAG<(ins "Value":$v1, "Value":$v2, "ArrayRef<int64_t>")>
   ];
   let extraClassDeclaration = [{
     static StringRef getMaskAttrName() { return "mask"; }
     VectorType getV1VectorType() {
       return v1().getType().cast<VectorType>();
     }
     VectorType getV2VectorType() {
       return v2().getType().cast<VectorType>();
let description = [{
     %1 = vector.extractelement %0[%c : i32]: vector<16xf32>
     ```
   }];
   let assemblyFormat = [{
     $vector `[` $position `:` type($position) `]` attr-dict `:` type($vector)
   }];
 
   let builders = [
-    OpBuilder<"Value source, int64_t position">,
-    OpBuilder<"Value source, Value position">
+    OpBuilderDAG<(ins "Value":$source, "int64_t":$position)>,
+    OpBuilderDAG<(ins "Value":$source, "Value":$position)>
   ];
   let extraClassDeclaration = [{
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
   }];
 }
 
let description = [{
     Example:
 
     ```mlir
     %1 = vector.extract %0[3]: vector<4x8x16xf32>
     %2 = vector.extract %0[3, 3, 3]: vector<4x8x16xf32>
     ```
   }];
   let builders = [
-    OpBuilder<"Value source, ArrayRef<int64_t> position">,
+    OpBuilderDAG<(ins "Value":$source, "ArrayRef<int64_t>":$position)>,
     // Convenience builder which assumes the values in `position` are defined by
     // ConstantIndexOp.
-    OpBuilder<"Value source, ValueRange position">
+    OpBuilderDAG<(ins "Value":$source, "ValueRange":$position)>
   ];
   let extraClassDeclaration = [{
     static StringRef getPositionAttrName() { return "position"; }
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
   }];
   let hasFolder = 1;
let description = [{
     %2 = vector.transfer_read ...: vector<4x3xf32>
 
     %3 = vector.extract_slices %2, [2, 2], [1, 1]
       : vector<4x3xf32> into tuple<vector<2x2xf32>, vector<2x1xf32>,
                                    vector<2x2xf32>, vector<2x1xf32>>
     ```
   }];
   let builders = [
-    OpBuilder<"TupleType tupleType, Value vector, ArrayRef<int64_t> sizes, "
-              "ArrayRef<int64_t> strides">
+    OpBuilderDAG<(ins "TupleType":$tupleType, "Value":$vector,
+      "ArrayRef<int64_t>":$sizes, "ArrayRef<int64_t>":$strides)>
   ];
   let extraClassDeclaration = [{
     VectorType getSourceVectorType() {
       return vector().getType().cast<VectorType>();
     }
     TupleType getResultTupleType() {
       return getResult().getType().cast<TupleType>();
     }
let description = [{
     ```
 
     Example:
 
     ```mlir
     %ev = vector.extract_map %v[%id] : vector<32xf32> to vector<1xf32>
     ```
   }];
-  let builders = [OpBuilder<
-    "Value vector, Value id, int64_t multiplicity">];
+  let builders = [
+    OpBuilderDAG<(ins "Value":$vector, "Value":$id, "int64_t":$multiplicity)>];
   let extraClassDeclaration = [{
     VectorType getSourceVectorType() {
       return vector().getType().cast<VectorType>();
     }
     VectorType getResultType() {
       return getResult().getType().cast<VectorType>();
     }
     int64_t multiplicity() {
let description = [{
     ```mlir
     %3 = vector.fma %0, %1, %2: vector<8x16xf32>
     ```
   }];
   // Fully specified by traits.
   let verifier = ?;
   let assemblyFormat = "$lhs `,` $rhs `,` $acc attr-dict `:` type($lhs)";
   let builders = [
-    OpBuilder<"Value lhs, Value rhs, Value acc",
-      "build($_builder, $_state, lhs.getType(), lhs, rhs, acc);">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs, "Value":$acc),
+    [{build($_builder, $_state, lhs.getType(), lhs, rhs, acc);}]>
   ];
   let extraClassDeclaration = [{
     VectorType getVectorType() { return lhs().getType().cast<VectorType>(); }
   }];
 }
 
 def Vector_InsertElementOp :
   Vector_Op<"insertelement", [NoSideEffect,
let description = [{
     ```
   }];
   let assemblyFormat = [{
     $source `,` $dest `[` $position `:` type($position) `]` attr-dict `:`
     type($result)
   }];
 
   let builders = [
-    OpBuilder<"Value source, Value dest, int64_t position">,
-    OpBuilder<"Value source, Value dest, Value position">
+    OpBuilderDAG<(ins "Value":$source, "Value":$dest, "int64_t":$position)>,
+    OpBuilderDAG<(ins "Value":$source, "Value":$dest, "Value":$position)>
   ];
   let extraClassDeclaration = [{
     Type getSourceType() { return source().getType(); }
     VectorType getDestVectorType() {
       return dest().getType().cast<VectorType>();
     }
   }];
 
let description = [{
     %5 = vector.insert %3, %4[3, 3, 3] : f32 into vector<4x8x16xf32>
     ```
   }];
   let assemblyFormat = [{
     $source `,` $dest $position attr-dict `:` type($source) `into` type($dest)
   }];
 
   let builders = [
-    OpBuilder<"Value source, Value dest, ArrayRef<int64_t> position">,
+    OpBuilderDAG<(ins "Value":$source, "Value":$dest,
+      "ArrayRef<int64_t>":$position)>,
     // Convenience builder which assumes all values are constant indices.
-    OpBuilder<"Value source, Value dest, ValueRange position">
+    OpBuilderDAG<(ins "Value":$source, "Value":$dest, "ValueRange":$position)>
   ];
   let extraClassDeclaration = [{
     static StringRef getPositionAttrName() { return "position"; }
     Type getSourceType() { return source().getType(); }
     VectorType getDestVectorType() {
       return dest().getType().cast<VectorType>();
     }
   }];
let description = [{
     %4 = vector.insert_map %2, %0[%idx1] : vector<2xi32> into vector<4xi32>
     ```
     Example:
 
     ```mlir
     %v = vector.insert_map %ev %v[%id] : vector<1xf32> into vector<32xf32>
     ```
   }];
-  let builders = [OpBuilder<
-    "Value vector, Value dest, Value id, int64_t multiplicity">];
+  let builders = [OpBuilderDAG<(ins "Value":$vector, "Value":$dest,
+                                "Value":$id, "int64_t":$multiplicity)>];
   let extraClassDeclaration = [{
     VectorType getSourceVectorType() {
       return vector().getType().cast<VectorType>();
     }
     VectorType getResultType() {
       return getResult().getType().cast<VectorType>();
     }
     int64_t multiplicity() {
let description = [{
     ```
   }];
 
   let assemblyFormat = [{
     $source `,` $dest attr-dict `:` type($source) `into` type($dest)
   }];
 
   let builders = [
-    OpBuilder<"Value source, Value dest, ArrayRef<int64_t> offsets, "
-              "ArrayRef<int64_t> strides">
+    OpBuilderDAG<(ins "Value":$source, "Value":$dest,
+      "ArrayRef<int64_t>":$offsets, "ArrayRef<int64_t>":$strides)>
   ];
   let extraClassDeclaration = [{
     static StringRef getOffsetsAttrName() { return "offsets"; }
     static StringRef getStridesAttrName() { return "strides"; }
     VectorType getSourceVectorType() {
       return source().getType().cast<VectorType>();
     }
     VectorType getDestVectorType() {
let description = [{
 
     %6 = vector.outerproduct %4, %5: vector<10xf32>, f32
     return %6: vector<10xf32>
 
     ```
   }];
   let builders = [
     // Build an op without mask, use the type of `acc` as the return type.
-    OpBuilder<"Value lhs, Value rhs, Value acc">
+    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs, "Value":$acc)>
   ];
   let extraClassDeclaration = [{
     VectorType getOperandVectorTypeLHS() {
       return lhs().getType().cast<VectorType>();
     }
     Type getOperandTypeRHS() {
       return rhs().getType();
     }
%1 = vector.extract_strided_slice %0
       vector<4x8x16xf32> to vector<2x4x16xf32>
 
     // TODO: Evolve to a range form syntax similar to:
     %1 = vector.extract_strided_slice %0[0:2:1][2:4:1]
       vector<4x8x16xf32> to vector<2x4x16xf32>
     ```
   }];
   let builders = [
-    OpBuilder<"Value source, ArrayRef<int64_t> offsets, "
-              "ArrayRef<int64_t> sizes, ArrayRef<int64_t> strides">
+    OpBuilderDAG<(ins "Value":$source, "ArrayRef<int64_t>":$offsets,
+      "ArrayRef<int64_t>":$sizes, "ArrayRef<int64_t>":$strides)>
   ];
   let extraClassDeclaration = [{
     static StringRef getOffsetsAttrName() { return "offsets"; }
     static StringRef getSizesAttrName() { return "sizes"; }
     static StringRef getStridesAttrName() { return "strides"; }
     VectorType getVectorType(){ return vector().getType().cast<VectorType>(); }
     void getOffsets(SmallVectorImpl<int64_t> &results);
   }];
let description = [{
     %4 = vector.transfer_read %arg1[%c3, %c3], %vf0
       {permutation_map = (d0, d1)->(d0, d1)}
         : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>
     ```
   }];
 
   let builders = [
     // Builder that sets padding to zero.
-    OpBuilder<"VectorType vector, Value memref, ValueRange indices, "
-              "AffineMap permutationMap, ArrayRef<bool> maybeMasked = {}">,
+    OpBuilderDAG<(ins "VectorType":$vector, "Value":$memref,
+      "ValueRange":$indices, "AffineMap":$permutationMap,
+      CArg<"ArrayRef<bool>", "{}">:$maybeMasked)>,
     // Builder that sets permutation map (resp. padding) to
     // 'getMinorIdentityMap' (resp. zero).
-    OpBuilder<"VectorType vector, Value memref, ValueRange indices, "
-              "ArrayRef<bool> maybeMasked = {}">
+    OpBuilderDAG<(ins "VectorType":$vector, "Value":$memref,
+      "ValueRange":$indices, CArg<"ArrayRef<bool>", "{}">:$maybeMasked)>
   ];
 
   let hasFolder = 1;
 }
 
 def Vector_TransferWriteOp :
   Vector_Op<"transfer_write", [
       DeclareOpInterfaceMethods<VectorTransferOpInterface>,
let description = [{
     vector.transfer_write %4, %arg1[%c3, %c3]
       {permutation_map = (d0, d1)->(d0, d1)}
         : vector<1x1x4x3xf32>, memref<?x?xvector<4x3xf32>>
     ```
   }];
 
   let builders = [
     // Builder that sets permutation map to 'getMinorIdentityMap'.
-    OpBuilder<"Value vector, Value memref, ValueRange indices, "
-              "ArrayRef<bool> maybeMasked = {}">,
-    OpBuilder<"Value vector, Value memref, ValueRange indices, "
-              "AffineMap permutationMap">,
+    OpBuilderDAG<(ins "Value":$vector, "Value":$memref, "ValueRange":$indices,
+      CArg<"ArrayRef<bool>", "{}">:$maybeMasked)>,
+    OpBuilderDAG<(ins "Value":$vector, "Value":$memref, "ValueRange":$indices,
+      "AffineMap":$permutationMap)>,
   ];
 
   let hasFolder = 1;
 }
 
 def Vector_MaskedLoadOp :
   Vector_Op<"maskedload">,
     Arguments<(ins AnyMemRef:$base,
let description = [{
     ```mlir
     %A  = alloc() : memref<5x4x3xf32>
     %VA = vector.type_cast %A : memref<5x4x3xf32> to memref<vector<5x4x3xf32>>
     ```
   }];
 
   /// Build the canonical memRefType with a single vector.
   /// E.g. memref<4 x 5 x vector<6 x f32>> -> memref<vector<4 x 5 x 6 x f32>>.
-  let builders = [
-    OpBuilder<"Value source">
-  ];
+  let builders = [OpBuilderDAG<(ins "Value":$source)>];
 
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
       return memref().getType().cast<MemRefType>();
     }
     MemRefType getResultMemRefType() {
       return getResult().getType().cast<MemRefType>();
     }
let description = [{
     %1 = vector.transpose %0, [1, 0] : vector<2x3xf32> to vector<3x2xf32>
 
      [ [a, b, c],       [ [a, d],
        [d, e, f] ]  ->    [b, e],
                           [c, f] ]
     ```
   }];
   let builders = [
-    OpBuilder<"Value vector, ArrayRef<int64_t> transp">
+    OpBuilderDAG<(ins "Value":$vector, "ArrayRef<int64_t>":$transp)>
   ];
   let extraClassDeclaration = [{
     VectorType getVectorType() {
       return vector().getType().cast<VectorType>();
     }
     VectorType getResultType() {
       return result().getType().cast<VectorType>();
     }
let description = [{
 
     ```mlir
     %C = vector.matrix_multiply %A, %B
       { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } :
       (vector<64xf64>, vector<48xf64>) -> vector<12xf64>
     ```
   }];
   let builders = [
-   OpBuilder<"Value lhs, Value rhs, unsigned lhsRows, unsigned lhsColumns, "
-             "unsigned rhsColumns",
+   OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs, "unsigned":$lhsRows,
+     "unsigned":$lhsColumns, "unsigned":$rhsColumns),
    [{
      $_state.addOperands({lhs, rhs});
      $_state.addAttribute("lhs_rows",$_builder.getI32IntegerAttr(lhsRows));
      $_state.addAttribute("lhs_columns",$_builder.getI32IntegerAttr(lhsColumns));
      $_state.addAttribute("rhs_columns",$_builder.getI32IntegerAttr(rhsColumns));
      $_state.addTypes(VectorType::get(lhsRows * rhsColumns,
        lhs.getType().cast<VectorType>().getElementType()));
    }]>,

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

 
 // Test for memrefs normalization of an op with a reference to a function
 // symbol.
 def OpFuncRef : TEST_Op<"op_funcref"> {
   let summary = "Test op with a reference to a function symbol";
   let description = [{
     The "test.op_funcref" is a test op with a reference to a function symbol.
   }];
-  let builders = [OpBuilder<[{FuncOp function}]>];
+  let builders = [OpBuilderDAG<(ins "FuncOp":$function)>];
 }
 
 // Pattern add the argument plus a increasing static number hidden in
 // OpMTest function. That value is set into the optional argument.
 // That way, we will know if operations is called once or twice.
 def OpMGetNullAttr : NativeCodeCall<"Attribute()">;
 def OpMAttributeIsNull : Constraint<CPred<"! ($_self)">, "Attribute is null">;
 def OpMVal : NativeCodeCall<"OpMTest($_builder, $0)">;
let results = (outs
     I32:$output1,
     Variadic<I32>:$output2,
     Variadic<I32>:$output3
   );
 
   // We will use this op in a nested result pattern, where we cannot deduce the
   // result type. So need to provide a builder not requiring result types.
   let builders = [
-    OpBuilder<
-      "IntegerAttr count",
-      [{
-        auto i32Type = $_builder.getIntegerType(32);
-        $_state.addTypes(i32Type); // $output1
-        SmallVector<Type, 4> types(count.getInt(), i32Type);
-        $_state.addTypes(types); // $output2
-        $_state.addTypes(types); // $output3
-        $_state.addAttribute("count", count);
-      }]>
+    OpBuilderDAG<(ins "IntegerAttr":$count),
   ];
 }
 
 // Generates an op with variadic results using nested pattern.
 def : Pat<(OneI32ResultOp),
           (MixedVOperandOp3
               (MixedVResultOp3:$results__0 ConstantAttr<I32Attr, "2">),
               (replaceWithValue $results__1),

 def LegalOpB : TEST_Op<"legal_op_b">, Results<(outs I32)>;
 
 // Check that the conversion infrastructure can properly undo the creation of
 // operations where an operation was created before its parent, in this case,
 // in the parent's builder.
 def IllegalOpTerminator : TEST_Op<"illegal_op_terminator", [Terminator]>;
 def IllegalOpWithRegion : TEST_Op<"illegal_op_with_region"> {
   let skipDefaultBuilders = 1;
-  let builders = [OpBuilder<"",
-                  [{ Region *bodyRegion = $_state.addRegion();
-                     OpBuilder::InsertionGuard g($_builder);
-                     Block *body = $_builder.createBlock(bodyRegion);
-                     $_builder.setInsertionPointToEnd(body);
-                     $_builder.create<IllegalOpTerminator>($_state.location);
-                  }]>];
+  let builders = [OpBuilderDAG<(ins),
+    [{
+       Region *bodyRegion = $_state.addRegion();
 }
 def IllegalOpWithRegionAnchor : TEST_Op<"illegal_op_with_region_anchor">;
 
 // Check that smaller pattern depths are chosen, i.e. prioritize more direct
 // mappings.
 def : Pat<(ILLegalOpA), (LegalOpA Test_LegalizerEnum_Success)>;
 
 def : Pat<(ILLegalOpA), (ILLegalOpB)>;

 
 //===----------------------------------------------------------------------===//
 // Test Type Legalization
 //===----------------------------------------------------------------------===//
 
 def TestRegionBuilderOp : TEST_Op<"region_builder">;
 def TestReturnOp : TEST_Op<"return", [ReturnLike, Terminator]> {
   let arguments = (ins Variadic<AnyType>);
-  let builders = [
-    OpBuilder<"", [{ build($_builder, $_state, {}); }]>
+  let builders = [OpBuilderDAG<(ins),
+    [{ build($_builder, $_state, {}); }]>
   ];
 }
 def TestCastOp : TEST_Op<"cast">,
   Arguments<(ins Variadic<AnyType>)>, Results<(outs AnyType)>;
 def TestInvalidOp : TEST_Op<"invalid", [Terminator]>,
   Arguments<(ins Variadic<AnyType>)>;
 def TestTypeProducerOp : TEST_Op<"type_producer">,
   Results<(outs AnyType)>;

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-gen.cpp

const char *header = R"FMT(  def {0} : LinalgStructuredBase_Op<"{1}", [
     SingleBlockImplicitTerminator<"YieldOp">]> {
       let arguments = (ins Variadic<AnyShaped>:$inputs,
                            Variadic<AnyMemRef>:$output_buffers,
                            Variadic<AnyRankedTensor>:$init_tensors);
       let results = (outs Variadic<AnyRankedTensor>:$result_tensors);
       let regions = (region AnyRegion:$region);
 
       let skipDefaultBuilders = 1;
-      let builders = [ OpBuilder<
-        "ValueRange inputs, ValueRange outputBuffers",
+      let builders = [ OpBuilderDAG<
+        (ins "ValueRange":$inputs, "ValueRange":$outputBuffers),
         [{{
           $_state.addOperands(inputs);
           $_state.addOperands(outputBuffers);
           $_state.addAttribute(
             "operand_segment_sizes",
             $_builder.getI32VectorAttr({{
               static_cast<int32_t>(inputs.size()),
               static_cast<int32_t>(outputBuffers.size()),
               static_cast<int32_t>(0)}));
           buildNamedStructuredOpRegionAndAttributes<{0}>(
             $_builder,
             $_state,
             TypeRange(inputs),
             TypeRange(outputBuffers),
             TypeRange(),
             TypeRange());
-        }]>, OpBuilder<
-        "TypeRange resultTensorTypes, ValueRange inputs, "
-        "ValueRange outputBuffers, ValueRange initTensors",
+        }]>, OpBuilderDAG<
+        (ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
+             "ValueRange":$outputBuffers, "ValueRange":$initTensors),
         [{{
           $_state.addOperands(inputs);
           $_state.addOperands(outputBuffers);
           $_state.addOperands(initTensors);
           $_state.addTypes(resultTensorTypes);
           $_state.addAttribute(
             "operand_segment_sizes",
             $_builder.getI32VectorAttr({{
               static_cast<int32_t>(inputs.size()),
               static_cast<int32_t>(outputBuffers.size()),
               static_cast<int32_t>(initTensors.size())}));
           buildNamedStructuredOpRegionAndAttributes<{0}>(
             $_builder,
             $_state,
             TypeRange(inputs),
             TypeRange(outputBuffers),
             TypeRange(initTensors),
             resultTensorTypes);
-        }]>, OpBuilder<
-        "TypeRange resultTensorTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes = {{}",
+        }]>, OpBuilderDAG<
+        (ins "TypeRange":$resultTensorTypes, "ValueRange":$operands,
+             CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
         [{{
           $_state.addOperands(operands);
           $_state.addAttributes(attributes);
           $_state.addTypes(resultTensorTypes);
           (void)$_state.addRegion();
         }]>
       ];
       let printer = [{{ return ::printNamedStructuredOp(p, *this); }];

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

void OpEmitter::genBuilder() {
   {
     auto *listInit = dyn_cast_or_null<ListInit>(def.getValueInit("builders"));
     if (listInit) {
       for (Init *init : listInit->getValues()) {
         Record *builderDef = cast<DefInit>(init)->getDef();
         llvm::Optional<StringRef> params =
             builderDef->getValueAsOptionalString("params");
         FmtContext fctx;
+        if (params.hasValue()) {
+          PrintWarning(op.getLoc(),
+                       "Op uses a deprecated, string-based OpBuilder format; "
+                       "use OpBuilderDAG with '(ins <...>)' instead");
+        }
         std::string paramStr =
             params.hasValue() ? builderSignatureFromString(params->trim(), fctx)
                               : builderSignatureFromDAG(
                                     builderDef->getValueAsDag("dagParams"),
                                     op.getLoc(), fctx);
 
         StringRef body = builderDef->getValueAsString("body");
         bool hasBody = !body.empty();