[mlir] ODS: change OpBuilderDAG to OpBuilder

[ftynse]

Summary

We no longer have the non-DAG version.

flang/include/flang/Optimizer/Dialect/FIROps.td

class fir_SimpleOp<string mnemonic, list<OpTrait> traits>
   : fir_Op<mnemonic, traits> {
 
   let assemblyFormat = [{
     operands attr-dict `:` functional-type(operands, results)
   }];
 }
 
 // Base builder for allocate operations
-def fir_AllocateOpBuilder : OpBuilderDAG<(ins
+def fir_AllocateOpBuilder : OpBuilder<(ins
     "mlir::Type":$inType,
     CArg<"mlir::ValueRange", "{}">:$lenParams,
     CArg<"mlir::ValueRange", "{}">:$sizes,
     CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes),
   [{
     $_state.addTypes(getRefTy(inType));
     $_state.addAttribute("in_type", TypeAttr::get(inType));
     $_state.addOperands(sizes);
     $_state.addAttributes(attributes);
   }]>;
 
-def fir_NamedAllocateOpBuilder : OpBuilderDAG<(ins
+def fir_NamedAllocateOpBuilder : OpBuilder<(ins
     "mlir::Type":$inType,
     "llvm::StringRef":$name,
     CArg<"mlir::ValueRange", "{}">:$lenParams,
     CArg<"mlir::ValueRange","{}">:$sizes,
     CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes),
   [{
     $_state.addTypes(getRefTy(inType));
     $_state.addAttribute("in_type", TypeAttr::get(inType));
     if (!name.empty())
       $_state.addAttribute("name", $_builder.getStringAttr(name));
     $_state.addOperands(sizes);
     $_state.addAttributes(attributes);
   }]>;
 
-def fir_OneResultOpBuilder : OpBuilderDAG<(ins
+def fir_OneResultOpBuilder : OpBuilder<(ins
     "mlir::Type":$resultType,
     "mlir::ValueRange":$operands,
     CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes),
   [{
     if (resultType)
       $_state.addTypes(resultType);
     $_state.addOperands(operands);
     $_state.addAttributes(attributes);
   }]>;
 
 // Base class of FIR operations that return 1 result
 class fir_OneResultOp<string mnemonic, list<OpTrait> traits = []> :
     fir_Op<mnemonic, traits>, Results<(outs fir_Type:$res)> {
   let builders = [fir_OneResultOpBuilder];
 }
 
 // Base class of FIR operations that have 1 argument and return 1 result
 class fir_SimpleOneResultOp<string mnemonic, list<OpTrait> traits = []> :
     fir_SimpleOp<mnemonic, traits> {
   let builders = [fir_OneResultOpBuilder];
 }
 
-class fir_TwoBuilders<OpBuilderDAG b1, OpBuilderDAG b2> {
-  list<OpBuilderDAG> builders = [b1, b2];
+class fir_TwoBuilders<OpBuilder b1, OpBuilder b2> {
+  list<OpBuilder> builders = [b1, b2];
 }
 
 class fir_AllocatableBaseOp<string mnemonic, list<OpTrait> traits = []> :
     fir_Op<mnemonic, traits>, Results<(outs fir_Type:$res)> {
   let arguments = (ins
     OptionalAttr<StrAttr>:$name,
     OptionalAttr<BoolAttr>:$target
   );
let description = [{
     ```
 
     The ssa-value has an undefined value if the memory reference is undefined
     or null.
   }];
 
   let arguments = (ins Arg<AnyReferenceLike, "", [MemRead]>:$memref);
 
-  let builders = [OpBuilderDAG<(ins "mlir::Value":$refVal),
+  let builders = [OpBuilder<(ins "mlir::Value":$refVal),
     [{
       if (!refVal) {
         mlir::emitError($_state.location, "LoadOp has null argument");
         return;
       }
       auto eleTy = fir::dyn_cast_ptrEleTy(refVal.getType());
       if (!eleTy) {
         mlir::emitError($_state.location, "not a memory reference type");
string extraSwitchClassDeclaration = [{
     unsigned targetOffsetSize();
   }];
 }
 
 class fir_IntegralSwitchTerminatorOp<string mnemonic,
     list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
 
   let skipDefaultBuilders = 1;
-  let builders = [OpBuilderDAG<(ins "mlir::Value":$selector,
+  let builders = [OpBuilder<(ins "mlir::Value":$selector,
     "llvm::ArrayRef<int64_t>":$compareOperands,
     "llvm::ArrayRef<mlir::Block *>":$destinations,
     CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
     CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes),
     [{
       $_state.addOperands(selector);
       llvm::SmallVector<mlir::Attribute, 8> ivalues;
       for (auto iv : compareOperands)
```mlir
             #fir.interval, %2, %3, ^bb3(%2,%arg2 : i32,i32),
             #fir.upper, %arg, ^bb4(%1 : i32),
             unit, ^bb5]
     ```
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilderDAG<(ins "mlir::Value":$selector,
+    OpBuilder<(ins "mlir::Value":$selector,
       "llvm::ArrayRef<mlir::Attribute>":$compareAttrs,
       "llvm::ArrayRef<mlir::ValueRange>":$cmpOperands,
       "llvm::ArrayRef<mlir::Block *>":$destinations,
       CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
-    OpBuilderDAG<(ins "mlir::Value":$selector,
+    OpBuilder<(ins "mlir::Value":$selector,
       "llvm::ArrayRef<mlir::Attribute>":$compareAttrs,
       "llvm::ArrayRef<mlir::Value>":$cmpOpList,
       "llvm::ArrayRef<mlir::Block *>":$destinations,
       CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
 
   let parser = "return parseSelectCase(parser, result);";
 
```mlir
           #fir.instance<!fir.type<type2>>, ^bb2(%2 : i32),
           #fir.subsumed<!fir.type<type3>>, ^bb3(%2 : i32),
           #fir.instance<!fir.type<type4>>, ^bb4(%1,%3 : i32,f32),
           unit, ^bb5]
     ```
   }];
 
   let skipDefaultBuilders = 1;
-  let builders = [OpBuilderDAG<(ins "mlir::Value":$selector,
+  let builders = [OpBuilder<(ins "mlir::Value":$selector,
     "llvm::ArrayRef<mlir::Attribute>":$typeOperands,
     "llvm::ArrayRef<mlir::Block *>":$destinations,
     CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
     CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes),
     [{
       $_state.addOperands(selector);
       $_state.addAttribute(getCasesAttr(),
         $_builder.getArrayAttr(typeOperands));
let arguments = (ins
     Optional<fir_SliceType>:$slice,
     Variadic<AnyIntegerType>:$lenParams,
     OptionalAttr<AffineMapAttr>:$accessMap
   );
 
   let results = (outs fir_BoxType);
 
   let builders = [
-    OpBuilderDAG<(ins "llvm::ArrayRef<mlir::Type>":$resultTypes,
+    OpBuilder<(ins "llvm::ArrayRef<mlir::Type>":$resultTypes,
       "mlir::Value":$memref, CArg<"mlir::Value", "{}">:$shape,
       CArg<"mlir::Value", "{}">:$slice,
       CArg<"mlir::ValueRange", "{}">:$lenParams),
     [{ return build($_builder, $_state, resultTypes, memref, shape, slice,
                     lenParams, mlir::AffineMapAttr{}); }]>
   ];
 
   let assemblyFormat = [{
def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
 
   let results = (outs fir_ReferenceType);
 
   let parser =  [{ return parseCoordinateCustom(parser, result); }];
   let printer = [{ ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
 
   let builders = [
-    OpBuilderDAG<(ins "mlir::Type":$resultType,
+    OpBuilder<(ins "mlir::Type":$resultType,
       "mlir::Value":$ref, "mlir::ValueRange":$coor),
     [{ return build($_builder, $_state, resultType, ref, coor,
            mlir::TypeAttr::get(ref.getType())); }]>,
   ];
 
   let extraClassDeclaration = [{
     /// Get the type of the base object.
     mlir::Type getBaseType() { return baseType(); }
if (getNumOperands()) {
           p.printType(op.getType());
         else
           p << "()";
         sep = ", ";
       }
     }
   }];
 
-  let builders = [OpBuilderDAG<(ins "llvm::StringRef":$fieldName,
+  let builders = [OpBuilder<(ins "llvm::StringRef":$fieldName,
       "mlir::Type":$recTy, CArg<"mlir::ValueRange","{}">:$operands),
     [{
       $_state.addAttribute(fieldAttrName(),
         $_builder.getStringAttr(fieldName));
       $_state.addAttribute(typeAttrName(), TypeAttr::get(recTy));
       $_state.addOperands(operands);
     }]
   >];
def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
   }];
 
   let printer = [{
     p << getOperationName() << ' '
       << (*this)->getAttrOfType<mlir::StringAttr>(fieldAttrName()).getValue()
       << ", " << (*this)->getAttr(typeAttrName());
   }];
 
-  let builders = [OpBuilderDAG<(ins "llvm::StringRef":$fieldName,
+  let builders = [OpBuilder<(ins "llvm::StringRef":$fieldName,
       "mlir::Type":$recTy),
     [{
       $_state.addAttribute(fieldAttrName(), $_builder.getStringAttr(fieldName));
       $_state.addAttribute(typeAttrName(), TypeAttr::get(recTy));
     }]
   >];
 
   let extraClassDeclaration = [{
def fir_ResultOp : fir_Op<"result",
   let description = [{
     Result takes a list of ssa-values produced in the block and forwards them
     as a result to the operation that owns the region of the block. The
     operation can retain the values or return them to its parent block
     depending upon its semantics.
   }];
 
   let arguments = (ins Variadic<AnyType>:$results);
-  let builders = [OpBuilderDAG<(ins), [{ /* do nothing */ }]>];
+  let builders = [OpBuilder<(ins), [{ /* do nothing */ }]>];
 
   let assemblyFormat = "($results^ `:` type($results))? attr-dict";
 
   let verifier = [{ return ::verify(*this); }];
 }
 
 def FirRegionTerminator : SingleBlockImplicitTerminator<"ResultOp">;
 
let arguments = (ins
     OptionalAttr<UnitAttr>:$unordered,
     OptionalAttr<UnitAttr>:$finalValue
   );
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilderDAG<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
+    OpBuilder<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
       "mlir::Value":$step, CArg<"bool", "false">:$unordered,
       CArg<"bool", "false">:$finalCountValue,
       CArg<"mlir::ValueRange", "llvm::None">:$iterArgs,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>
   ];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef unorderedAttrName() { return "unordered"; }
def fir_IfOp : region_Op<"if", [NoRegionArguments]> {
 
   let regions = (region
     SizedRegion<1>:$thenRegion,
     AnyRegion:$elseRegion
   );
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilderDAG<(ins "mlir::Value":$cond, "bool":$withElseRegion)>,
-    OpBuilderDAG<(ins "mlir::TypeRange":$resultTypes, "mlir::Value":$cond,
+    OpBuilder<(ins "mlir::Value":$cond, "bool":$withElseRegion)>,
+    OpBuilder<(ins "mlir::TypeRange":$resultTypes, "mlir::Value":$cond,
         "bool":$withElseRegion)>
   ];
 
   let extraClassDeclaration = [{
     mlir::OpBuilder getThenBodyBuilder() {
       assert(!thenRegion().empty() && "Unexpected empty 'where' region.");
       mlir::Block &body = thenRegion().front();
       return mlir::OpBuilder(&body, std::prev(body.end()));
let arguments = (ins
     Variadic<AnyType>:$initArgs,
     OptionalAttr<UnitAttr>:$finalValue
   );
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilderDAG<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
+    OpBuilder<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
       "mlir::Value":$step, "mlir::Value":$iterate,
       CArg<"bool", "false">:$finalCountValue,
       CArg<"mlir::ValueRange", "llvm::None">:$iterArgs,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>
   ];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef finalValueAttrName() {
let arguments = (ins
     Variadic<AnyType>:$args
   );
   let results = (outs Variadic<AnyType>);
 
   let parser = "return parseCallOp(parser, result);";
   let printer = "printCallOp(p, *this);";
 
   let builders = [
-    OpBuilderDAG<(ins "mlir::FuncOp":$callee,
+    OpBuilder<(ins "mlir::FuncOp":$callee,
         CArg<"mlir::ValueRange", "{}">:$operands),
     [{
       $_state.addOperands(operands);
       $_state.addAttribute(calleeAttrName(),
         $_builder.getSymbolRefAttr(callee));
       $_state.addTypes(callee.getType().getResults());
     }]>,
-    OpBuilderDAG<(ins "mlir::SymbolRefAttr":$callee,
+    OpBuilder<(ins "mlir::SymbolRefAttr":$callee,
         "llvm::ArrayRef<mlir::Type>":$results,
         CArg<"mlir::ValueRange", "{}">:$operands),
     [{
       $_state.addOperands(operands);
       $_state.addAttribute(calleeAttrName(), callee);
       $_state.addTypes(results);
     }]>,
-    OpBuilderDAG<(ins "llvm::StringRef":$callee,
+    OpBuilder<(ins "llvm::StringRef":$callee,
         "llvm::ArrayRef<mlir::Type>":$results,
         CArg<"mlir::ValueRange", "{}">:$operands),
     [{
       build($_builder, $_state, $_builder.getSymbolRefAttr(callee), results,
             operands);
     }]>];
 
   let extraClassDeclaration = [{
let description = [{
     Extends the standard floating-point comparison to handle the extended
     floating-point types found in FIR.
   }];
 
   let arguments = (ins AnyRealLike:$lhs, AnyRealLike:$rhs);
 
   let results = (outs AnyLogicalLike);
 
-  let builders = [OpBuilderDAG<(ins "mlir::CmpFPredicate":$predicate,
+  let builders = [OpBuilder<(ins "mlir::CmpFPredicate":$predicate,
     "mlir::Value":$lhs, "mlir::Value":$rhs), [{
       buildCmpFOp($_builder, $_state, predicate, lhs, rhs);
   }]>];
 
   let parser = [{ return parseCmpfOp(parser, result); }];
 
   let printer = [{ printCmpfOp(p, *this); }];
 
def fir_CmpcOp : fir_Op<"cmpc",
   let arguments = (ins fir_ComplexType:$lhs, fir_ComplexType:$rhs);
 
   let results = (outs AnyLogicalLike);
 
   let parser = "return parseCmpcOp(parser, result);";
 
   let printer = "printCmpcOp(p, *this);";
 
-  let builders = [OpBuilderDAG<(ins "mlir::CmpFPredicate":$predicate,
+  let builders = [OpBuilder<(ins "mlir::CmpFPredicate":$predicate,
     "mlir::Value":$lhs, "mlir::Value":$rhs), [{
       buildCmpCOp($_builder, $_state, predicate, lhs, rhs);
   }]>];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef getPredicateAttrName() {
       return "predicate";
     }
let parser = [{
     return mlir::success();
   }];
 
   let printer = [{
     p << getOperationName() << ' ' << (*this)->getAttr("in_type");
     p.printOptionalAttrDict((*this)->getAttrs(), {"in_type"});
   }];
 
-  let builders = [OpBuilderDAG<(ins "mlir::TypeAttr":$inty)>];
+  let builders = [OpBuilder<(ins "mlir::TypeAttr":$inty)>];
 
   let verifier = [{
     mlir::Type resultTy = getType();
     if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
       if (tdesc.getOfTy() != getInType())
         return emitOpError("wrapped type mismatched");
     } else {
       return emitOpError("must be !fir.tdesc type");
let printer = [{
     p.printType(getType());
     if (hasInitializationBody())
       p.printRegion((*this)->getRegion(0), /*printEntryBlockArgs=*/false,
                     /*printBlockTerminators=*/true);
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilderDAG<(ins "llvm::StringRef":$name, "mlir::Type":$type,
+    OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
-    OpBuilderDAG<(ins "llvm::StringRef":$name, "bool":$isConstant,
+    OpBuilder<(ins "llvm::StringRef":$name, "bool":$isConstant,
       "mlir::Type":$type,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
-    OpBuilderDAG<(ins "llvm::StringRef":$name, "mlir::Type":$type,
+    OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
       CArg<"mlir::StringAttr", "{}">:$linkage,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
-    OpBuilderDAG<(ins "llvm::StringRef":$name, "bool":$isConstant,
+    OpBuilder<(ins "llvm::StringRef":$name, "bool":$isConstant,
       "mlir::Type":$type, CArg<"mlir::StringAttr", "{}">:$linkage,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
-    OpBuilderDAG<(ins "llvm::StringRef":$name, "mlir::Type":$type,
+    OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
       "mlir::Attribute":$initVal, CArg<"mlir::StringAttr", "{}">:$linkage,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
-    OpBuilderDAG<(ins "llvm::StringRef":$name, "bool":$isConstant,
+    OpBuilder<(ins "llvm::StringRef":$name, "bool":$isConstant,
       "mlir::Type":$type, "mlir::Attribute":$initVal,
       CArg<"mlir::StringAttr", "{}">:$linkage,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
   ];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef symbolAttrName() { return "symref"; }
     static constexpr llvm::StringRef constantAttrName() { return "constant"; }
for (auto &op : getBlock())
         return emitOpError("dispatch table must contain dt_entry");
     return mlir::success();
   }];
 
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilderDAG<(ins "llvm::StringRef":$name, "mlir::Type":$type,
+    OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs),
     [{
       $_state.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                            $_builder.getStringAttr(name));
       $_state.addAttributes(attrs);
     }]>
   ];
 

mlir/docs/OpDefinitions.md

 However, if the above cases cannot satisfy all needs, you can define additional
 convenience build methods in the `builders` field as follows.
 
 ```tablegen
 def MyOp : Op<"my_op", []> {
   let arguments = (ins F32Attr:$attr);
 
   let builders = [
-    OpBuilderDAG<(ins "float":$val)>
+    OpBuilder<(ins "float":$val)>
   ];
 }
 ```
 
 The `builders` field is a list of custom builders that are added to the Op
 class. In this example, we provide a convenience builder that takes a floating
 point value instead of an attribute. The `ins` prefix is common to many function
 declarations in ODS, which use a TableGen [`dag`](#tablegen-syntax). What

 Implementations of the builder can be provided directly in ODS, using TableGen
 code block as follows.
 
 ```tablegen
 def MyOp : Op<"my_op", []> {
   let arguments = (ins F32Attr:$attr);
 
   let builders = [
-    OpBuilderDAG<(ins "float":$val), [{
+    OpBuilder<(ins "float":$val), [{
       $_state.addAttribute("attr", $_builder.getF32FloatAttr(val));
     }]>
   ];
 }
 ```
 
 The equivalents of `builder` and `state` arguments are available as `$_builder`
 and `$_state` special variables. The named arguments listed in the `ins` part
 are available directly, e.g. `val`. The body of the builder will be generated by
 substituting special variables and should otherwise be valid C++. While there is
 no limitation on the code size, we encourage one to define only short builders
 inline in ODS and put definitions of longer builders in C++ files.
 
 Finally, if some arguments need a default value, they can be defined using
 `CArg` to wrap the type and this value as follows.
 
 ```tablegen
 def MyOp : Op<"my_op", []> {
   let arguments = (ins F32Attr:$attr);
 
   let builders = [
-    OpBuilderDAG<(ins CArg<"float", "0.5f">:$val), [{
+    OpBuilder<(ins CArg<"float", "0.5f">:$val), [{
       $_state.addAttribute("attr", $_builder.getF32FloatAttr(val));
     }]>
   ];
 }
 ```
 
 The generated code will use default value in the declaration, but not in the
 definition, as required by C++.

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.
-    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
+    OpBuilder<(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.
-    OpBuilderDAG<(ins "double":$value)>
+    OpBuilder<(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.
-    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
+    OpBuilder<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilderDAG<(ins "double":$value)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$input)>
+    OpBuilder<(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.
-    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
+    OpBuilder<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilderDAG<(ins "double":$value)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$input)>
+    OpBuilder<(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.
-    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
+    OpBuilder<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilderDAG<(ins "double":$value)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def CastOp : Toy_Op<"cast", [
      DeclareOpInterfaceMethods<CastOpInterface>,
      DeclareOpInterfaceMethods<ShapeInferenceOpInterface>,
      NoSideEffect,
      SameOperandsAndResultShape
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 = [
-    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$input)>
+    OpBuilder<(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.
-    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
+    OpBuilder<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilderDAG<(ins "double":$value)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def CastOp : Toy_Op<"cast", [
      DeclareOpInterfaceMethods<CastOpInterface>,
      DeclareOpInterfaceMethods<ShapeInferenceOpInterface>,
      NoSideEffect,
      SameOperandsAndResultShape
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 = [
-    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$input)>
+    OpBuilder<(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.
-    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
+    OpBuilder<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilderDAG<(ins "double":$value)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def CastOp : Toy_Op<"cast", [
      DeclareOpInterfaceMethods<CastOpInterface>,
      DeclareOpInterfaceMethods<ShapeInferenceOpInterface>,
      NoSideEffect,
      SameOperandsAndResultShape
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 = [
-    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$input)>
+    OpBuilder<(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.
-    OpBuilderDAG<(ins "DenseElementsAttr":$value), [{
+    OpBuilder<(ins "DenseElementsAttr":$value), [{
       build($_builder, $_state, value.getType(), value);
     }]>,
 
     // Build a constant with a given constant floating-point value.
-    OpBuilderDAG<(ins "double":$value)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 def CastOp : Toy_Op<"cast", [
      DeclareOpInterfaceMethods<CastOpInterface>,
      DeclareOpInterfaceMethods<ShapeInferenceOpInterface>,
      NoSideEffect,
      SameOperandsAndResultShape
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 = [
-    OpBuilderDAG<(ins "StringRef":$callee, "ArrayRef<Value>":$arguments)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$input, "size_t":$index)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$input)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "AffineMap":$map, "ValueRange":$mapOperands),
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "int64_t":$lowerBound, "int64_t":$upperBound,
+    OpBuilder<(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,
+    OpBuilder<(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.
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 = [
-    OpBuilderDAG<(ins "IntegerSet":$set, "ValueRange":$args,
+    OpBuilder<(ins "IntegerSet":$set, "ValueRange":$args,
       "bool":$withElseRegion)>,
-    OpBuilderDAG<(ins "TypeRange":$resultTypes, "IntegerSet":$set,
+    OpBuilder<(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.
-    OpBuilderDAG<(ins "AffineMap":$map, "ValueRange":$operands)>,
+    OpBuilder<(ins "AffineMap":$map, "ValueRange":$operands)>,
     /// Builds an affine load op with an identity map and operands.
-    OpBuilderDAG<(ins "Value":$memref, CArg<"ValueRange", "{}">:$indices)>,
+    OpBuilder<(ins "Value":$memref, CArg<"ValueRange", "{}">:$indices)>,
     /// Builds an affine load op with the specified map and its operands.
-    OpBuilderDAG<(ins "Value":$memref, "AffineMap":$map,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "AffineMap":$affineMap, "ValueRange":$mapOperands),
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "TypeRange":$resultTypes,
+    OpBuilder<(ins "TypeRange":$resultTypes,
       "ArrayRef<AtomicRMWKind>":$reductions, "ArrayRef<int64_t>":$ranges)>,
-    OpBuilderDAG<(ins "TypeRange":$resultTypes,
+    OpBuilder<(ins "TypeRange":$resultTypes,
       "ArrayRef<AtomicRMWKind>":$reductions, "AffineMap":$lbMap,
       "ValueRange":$lbArgs, "AffineMap":$ubMap, "ValueRange":$ubArgs)>,
-    OpBuilderDAG<(ins "TypeRange":$resultTypes,
+    OpBuilder<(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();
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 = [
-    OpBuilderDAG<(ins "Value":$memref, "AffineMap":$map,
+    OpBuilder<(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);
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 = [
-    OpBuilderDAG<(ins "Value":$valueToStore, "Value":$memref,
+    OpBuilder<(ins "Value":$valueToStore, "Value":$memref,
       "ValueRange":$indices)>,
-    OpBuilderDAG<(ins "Value":$valueToStore, "Value":$memref, "AffineMap":$map,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins), [{ build($_builder, $_state, llvm::None); }]>
+    OpBuilder<(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 = [{
let description = [{
     * Consider adding a permutation map to permute the slice that is read from memory
     (see [vector.transfer_read](../Vector/#vectortransfer_read-vectortransferreadop)).
   }];
 
   let results = (outs AnyVector:$result);
 
   let builders = [
     /// Builds an affine vector load op with the specified map and operands.
-    OpBuilderDAG<(ins "VectorType":$resultType, "AffineMap":$map,
+    OpBuilder<(ins "VectorType":$resultType, "AffineMap":$map,
       "ValueRange":$operands)>,
     /// Builds an affine vector load op with an identity map and operands.
-    OpBuilderDAG<(ins "VectorType":$resultType, "Value":$memref,
+    OpBuilder<(ins "VectorType":$resultType, "Value":$memref,
       CArg<"ValueRange", "{}">:$indices)>,
     /// Builds an affine vector load op with the specified map and its operands.
-    OpBuilderDAG<(ins "VectorType":$resultType, "Value":$memref,
+    OpBuilder<(ins "VectorType":$resultType, "Value":$memref,
       "AffineMap":$map, "ValueRange":$mapOperands)>
   ];
 
   let extraClassDeclaration = extraClassDeclarationBase # [{
     VectorType getVectorType() {
       return result().getType().cast<VectorType>();
     }
   }];
def AffineVectorStoreOp : AffineStoreOpBase<"vector_store"> {
 
   let arguments = (ins AnyVector:$value,
       Arg<AnyMemRef, "the reference to store to",
       [MemWrite]>:$memref,
       Variadic<Index>:$indices);
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilderDAG<(ins "Value":$valueToStore, "Value":$memref,
+    OpBuilder<(ins "Value":$valueToStore, "Value":$memref,
       "ValueRange":$indices)>,
-    OpBuilderDAG<(ins "Value":$valueToStore, "Value":$memref, "AffineMap":$map,
+    OpBuilder<(ins "Value":$valueToStore, "Value":$memref, "AffineMap":$map,
       "ValueRange":$mapOperands)>
   ];
 
   let extraClassDeclaration = extraClassDeclarationBase # [{
     VectorType getVectorType() {
       return value().getType().cast<VectorType>();
     }
   }];
 }
 
 #endif // AFFINE_OPS

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

def Async_ExecuteOp :
   let regions = (region SizedRegion<1>:$body);
 
   let printer = [{ return ::print(p, *this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
   let verifier = [{ return ::verify(*this); }];
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilderDAG<(ins "TypeRange":$resultTypes, "ValueRange":$dependencies,
+    OpBuilder<(ins "TypeRange":$resultTypes, "ValueRange":$dependencies,
       "ValueRange":$operands,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>",
            "nullptr">:$bodyBuilder)>,
   ];
 
   let extraClassDeclaration = [{
     using BodyBuilderFn =
         function_ref<void(OpBuilder &, Location, ValueRange)>;
def Async_AwaitOp : Async_Op<"await"> {
   }];
 
   let arguments = (ins Async_AnyValueOrTokenType:$operand);
   let results = (outs Optional<AnyType>:$result);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$operand,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "StringRef":$name, "FunctionType":$type,
+    OpBuilder<(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.
module attributes {gpu.container_module} {
                %arg1 : memref<?xf32, 1>)
     }
     ```
   }];
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilderDAG<(ins "GPUFuncOp":$kernelFunc, "KernelDim3":$gridSize,
+    OpBuilder<(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.
let description = [{
     easier just to have that information by construction.
   }];
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$gridSizeX, "Value":$gridSizeY,
+    OpBuilder<(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.
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 = [OpBuilderDAG<(ins), [{ // empty}]>];
+  let builders = [OpBuilder<(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 = [OpBuilderDAG<(ins "StringRef":$name)>];
+  let builders = [OpBuilder<(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

let constBuilderCall =
           "::mlir::LLVM::FMFAttr::get($0, $_builder.getContext())";
 }
 
 class LLVM_Builder<string builder> {
   string llvmBuilder = builder;
 }
 
 def LLVM_OneResultOpBuilder :
-  OpBuilderDAG<(ins "Type":$resultType, "ValueRange":$operands,
+  OpBuilder<(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 :
-  OpBuilderDAG<(ins "ValueRange":$operands,
+  OpBuilder<(ins "ValueRange":$operands,
     CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
     $_state.addOperands(operands);
     for (auto namedAttr : attributes) {
       $_state.addAttribute(namedAttr.first, namedAttr.second);
     }
   }]>;
 
 // Compatibility builder that takes an instance of wrapped llvm::VoidType
 // to indicate no result.
 def LLVM_VoidResultTypeOpBuilder :
-  OpBuilderDAG<(ins "Type":$resultType, "ValueRange":$operands,
+  OpBuilder<(ins "Type":$resultType, "ValueRange":$operands,
     CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
     assert(isCompatibleType(resultType) && "result must be an LLVM type");
     assert(resultType.isa<LLVMVoidType>() &&
            "for zero-result operands, only 'void' is accepted as result type");
     build($_builder, $_state, operands, attributes);
   }]>;
 
 
 // Opaque builder used for terminator operations that contain successors.
 def LLVM_TerminatorPassthroughOpBuilder :
-  OpBuilderDAG<(ins "ValueRange":$operands, "SuccessorRange":$destinations,
+  OpBuilder<(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
def LLVM_ICmpOp : LLVM_Op<"icmp", [NoSideEffect]> {
   let arguments = (ins ICmpPredicate:$predicate,
                    LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$lhs,
                    LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$rhs);
   let results = (outs LLVM_ScalarOrVectorOf<I1>:$res);
   let llvmBuilder = [{
     $res = builder.CreateICmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
   }];
   let builders = [
-    OpBuilderDAG<(ins "ICmpPredicate":$predicate, "Value":$lhs, "Value":$rhs),
+    OpBuilder<(ins "ICmpPredicate":$predicate, "Value":$lhs, "Value":$rhs),
     [{
       build($_builder, $_state, IntegerType::get(lhs.getType().getContext(), 1),
             $_builder.getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs);
     }]>];
   let parser = [{ return parseCmpOp<ICmpPredicate>(parser, result); }];
   let printer = [{ printICmpOp(p, *this); }];
 }
 
let arguments = (ins FCmpPredicate:$predicate,
                    LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$lhs,
                    LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$rhs,
                    DefaultValuedAttr<LLVM_FMFAttr, "{}">:$fastmathFlags);
   let results = (outs LLVM_ScalarOrVectorOf<I1>:$res);
   let llvmBuilder = [{
     $res = builder.CreateFCmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
   }];
   let builders = [
-    OpBuilderDAG<(ins "FCmpPredicate":$predicate, "Value":$lhs, "Value":$rhs,
+    OpBuilder<(ins "FCmpPredicate":$predicate, "Value":$lhs, "Value":$rhs,
                   CArg<"FastmathFlags", "{}">:$fmf),
     [{
       build($_builder, $_state, IntegerType::get(lhs.getType().getContext(), 1),
             $_builder.getI64IntegerAttr(static_cast<int64_t>(predicate)), lhs, rhs,
             ::mlir::LLVM::FMFAttr::get(fmf, $_builder.getContext()));
     }]>];
   let parser = [{ return parseCmpOp<FCmpPredicate>(parser, result); }];
   let printer = [{ printFCmpOp(p, *this); }];
def LLVM_AllocaOp : LLVM_Op<"alloca">, MemoryOpWithAlignmentBase {
   let results = (outs LLVM_AnyPointer:$res);
   string llvmBuilder = [{
     auto *inst = builder.CreateAlloca(
       $_resultType->getPointerElementType(), $arraySize);
     }] # setAlignmentCode # [{
     $res = inst;
   }];
   let builders = [
-    OpBuilderDAG<(ins "Type":$resultType, "Value":$arraySize,
+    OpBuilder<(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 arguments = (ins LLVM_PointerTo<LLVM_LoadableType>:$addr,
                    UnitAttr:$nontemporal);
   let results = (outs LLVM_Type:$res);
   string llvmBuilder = [{
     auto *inst = builder.CreateLoad($addr, $volatile_);
   }] # setAlignmentCode # setNonTemporalMetadataCode # [{
     $res = inst;
   }];
   let builders = [
-    OpBuilderDAG<(ins "Value":$addr, CArg<"unsigned", "0">:$alignment,
+    OpBuilder<(ins "Value":$addr, CArg<"unsigned", "0">:$alignment,
       CArg<"bool", "false">:$isVolatile, CArg<"bool", "false">:$isNonTemporal),
     [{
       auto type = addr.getType().cast<LLVMPointerType>().getElementType();
       build($_builder, $_state, type, addr, alignment, isVolatile, isNonTemporal);
     }]>,
-    OpBuilderDAG<(ins "Type":$t, "Value":$addr,
+    OpBuilder<(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 : LLVM_Op<"store">, MemoryOpWithAlignmentAndAttributes {
   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 = [
-    OpBuilderDAG<(ins "Value":$value, "Value":$addr,
+    OpBuilder<(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.
let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$callee,
                    Variadic<LLVM_Type>:$operands,
                    Variadic<LLVM_Type>:$normalDestOperands,
                    Variadic<LLVM_Type>:$unwindDestOperands);
   let results = (outs Variadic<LLVM_Type>);
   let successors = (successor AnySuccessor:$normalDest,
                               AnySuccessor:$unwindDest);
 
   let builders = [
-    OpBuilderDAG<(ins "TypeRange":$tys, "FlatSymbolRefAttr":$callee,
+    OpBuilder<(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);
     }]>,
-    OpBuilderDAG<(ins "TypeRange":$tys, "ValueRange":$ops, "Block*":$normal,
+    OpBuilder<(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); }];
let description = [{
     llvm.call %1(%0) : (f32) -> ()
     ```
   }];
   let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$callee,
                    Variadic<LLVM_Type>,
                    DefaultValuedAttr<LLVM_FMFAttr, "{}">:$fastmathFlags);
   let results = (outs Variadic<LLVM_Type>);
   let builders = [
-    OpBuilderDAG<(ins "LLVMFuncOp":$func, "ValueRange":$operands,
+    OpBuilder<(ins "LLVMFuncOp":$func, "ValueRange":$operands,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
     [{
       Type resultType = func.getType().getReturnType();
       if (!resultType.isa<LLVM::LLVMVoidType>())
         $_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_Op<"extractelement", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyVector:$vector, LLVM_AnyInteger:$position);
   let results = (outs LLVM_Type:$res);
   string llvmBuilder = [{
     $res = builder.CreateExtractElement($vector, $position);
   }];
   let builders = [
-    OpBuilderDAG<(ins "Value":$vector, "Value":$position,
+    OpBuilder<(ins "Value":$vector, "Value":$position,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
   let parser = [{ return parseExtractElementOp(parser, result); }];
   let printer = [{ printExtractElementOp(p, *this); }];
 }
 def LLVM_ExtractValueOp : LLVM_Op<"extractvalue", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyAggregate:$container, ArrayAttr:$position);
   let results = (outs LLVM_Type:$res);
   string llvmBuilder = [{
def LLVM_InsertValueOp : LLVM_Op<"insertvalue", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyAggregate:$container, LLVM_PrimitiveType:$value,
                    ArrayAttr:$position);
   let results = (outs LLVM_AnyAggregate:$res);
   string llvmBuilder = [{
     $res = builder.CreateInsertValue($container, $value,
                                      extractPosition($position));
   }];
   let builders = [
-    OpBuilderDAG<(ins "Value":$container, "Value":$value, "ArrayAttr":$position),
+    OpBuilder<(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_Op<"shufflevector", [NoSideEffect]> {
   let arguments = (ins LLVM_AnyVector:$v1, LLVM_AnyVector:$v2, ArrayAttr:$mask);
   let results = (outs LLVM_AnyVector:$res);
   string llvmBuilder = [{
       SmallVector<unsigned, 4> position = extractPosition($mask);
       SmallVector<int, 4> mask(position.begin(), position.end());
       $res = builder.CreateShuffleVector($v1, $v2, mask);
   }];
   let builders = [
-    OpBuilderDAG<(ins "Value":$v1, "Value":$v2, "ArrayAttr":$mask,
+    OpBuilder<(ins "Value":$v1, "Value":$v2, "ArrayAttr":$mask,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
   let verifier = [{
     auto type1 = v1().getType();
     auto type2 = v2().getType();
     if (::mlir::LLVM::getVectorElementType(type1) !=
             ::mlir::LLVM::getVectorElementType(type2))
       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_Op<"select",
           [NoSideEffect, AllTypesMatch<["trueValue", "falseValue", "res"]>]>,
       LLVM_Builder<
           "$res = builder.CreateSelect($condition, $trueValue, $falseValue);"> {
   let arguments = (ins LLVM_ScalarOrVectorOf<I1>:$condition,
                    LLVM_Type:$trueValue, LLVM_Type:$falseValue);
   let results = (outs LLVM_Type:$res);
   let builders = [
-    OpBuilderDAG<(ins "Value":$condition, "Value":$lhs, "Value":$rhs),
+    OpBuilder<(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_Op<"freeze", [SameOperandsAndResultType]> {
   let arguments = (ins LLVM_Type:$val);
   let results = (outs LLVM_Type:$res);
def LLVM_CondBrOp : LLVM_TerminatorOp<"cond_br",
   let assemblyFormat = [{
     $condition ( `weights` `(` $branch_weights^ `)` )? `,`
     $trueDest (`(` $trueDestOperands^ `:` type($trueDestOperands) `)`)? `,`
     $falseDest (`(` $falseDestOperands^ `:` type($falseDestOperands) `)`)?
     attr-dict
   }];
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$condition, "Block *":$trueDest,
+    OpBuilder<(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);
   }]>,
-  OpBuilderDAG<(ins "Value":$condition, "Block *":$trueDest,
+  OpBuilder<(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);
let assemblyFormat = [{
     $defaultDestination (`(` $defaultOperands^ `:` type($defaultOperands) `)`)?
     `[` `\n` custom<SwitchOpCases>($case_values, $caseDestinations,
                                    $caseOperands, type($caseOperands),
                                    $case_operand_offsets) `]`
     attr-dict
   }];
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$value,
+    OpBuilder<(ins "Value":$value,
       "Block *":$defaultDestination,
       "ValueRange":$defaultOperands,
       CArg<"ArrayRef<int32_t>", "{}">:$caseValues,
       CArg<"BlockRange", "{}">:$caseDestinations,
       CArg<"ArrayRef<ValueRange>", "{}">:$caseOperands,
       CArg<"ArrayRef<int32_t>", "{}">:$branchWeights)>,
     LLVM_TerminatorPassthroughOpBuilder
   ];
let description = [{
     }
 
     // Define the global.
     llvm.mlir.global @const(42 : i32) : i32
     ```
   }];
 
   let builders = [
-    OpBuilderDAG<(ins "GlobalOp":$global,
+    OpBuilder<(ins "GlobalOp":$global,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
     [{
       build($_builder, $_state,
             LLVM::LLVMPointerType::get(global.getType(), global.addr_space()),
             global.sym_name());
       $_state.addAttributes(attrs);
     }]>,
-    OpBuilderDAG<(ins "LLVMFuncOp":$func,
+    OpBuilder<(ins "LLVMFuncOp":$func,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
     [{
       build($_builder, $_state,
             LLVM::LLVMPointerType::get(func.getType()), func.getName());
       $_state.addAttributes(attrs);
     }]>
   ];
 
let description = [{
     // By default, "external" linkage is assumed and the global participates in
     // symbol resolution at link-time.
     llvm.mlir.global @glob(0 : f32) : f32
     ```
   }];
   let regions = (region AnyRegion:$initializer);
 
   let builders = [
-    OpBuilderDAG<(ins "Type":$type, "bool":$isConstant, "Linkage":$linkage,
+    OpBuilder<(ins "Type":$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.
     Type getType() {
       return type();
let arguments = (ins DefaultValuedAttr<Linkage, "Linkage::External">:$linkage,
                    OptionalAttr<FlatSymbolRefAttr>:$personality,
                    OptionalAttr<ArrayAttr>:$passthrough);
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    OpBuilderDAG<(ins "StringRef":$name, "Type":$type,
+    OpBuilder<(ins "StringRef":$name, "Type":$type,
       CArg<"Linkage", "Linkage::External">:$linkage,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
       CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)>
   ];
 
   let extraClassDeclaration = [{
     // Add an entry block to an empty function, and set up the block arguments
     // to match the signature of the function.

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

let extraClassDeclaration = [{
     // Return the Value of the dynamic size of the tensor at dimension
     // `idx`. Asserts that the shape is dynamic at that `idx.
     Value getDynamicSize(unsigned idx) {
       return getOperand(getIndexOfDynamicSize(idx));
     }
   }];
 
   let builders = [
-    OpBuilderDAG<(ins "ValueRange":$shape,
+    OpBuilder<(ins "ValueRange":$shape,
                   "ArrayRef<int64_t>":$staticShape, "Type":$elementType),
     [{
       build($_builder, $_state,
             InitTensorOp::inferResultType(staticShape, elementType),
             shape, $_builder.getI64ArrayAttr(staticShape));
     }]>,
-    OpBuilderDAG<(ins "ValueRange":$shape, "Type":$elementType),
+    OpBuilder<(ins "ValueRange":$shape, "Type":$elementType),
     [{
       SmallVector<int64_t, 4> staticShape(
         shape.size(), ShapedType::kDynamicSize);
       build($_builder, $_state, shape, staticShape, elementType);
     }]>,
-    OpBuilderDAG<(ins "ArrayRef<int64_t>":$staticShape, "Type":$elementType),
+    OpBuilder<(ins "ArrayRef<int64_t>":$staticShape, "Type":$elementType),
     [{
       build($_builder, $_state, ValueRange{}, staticShape, elementType);
     }]>,
-    OpBuilderDAG<(ins "ArrayRef<OpFoldResult>":$sizes, "Type":$elementType,
+    OpBuilder<(ins "ArrayRef<OpFoldResult>":$sizes, "Type":$elementType,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let hasCanonicalizer = 1;
 }
 
 def Linalg_PadTensorOp : Linalg_Op<"pad_tensor",
     [AttrSizedOperandSegments, NoSideEffect]> {
let extraClassDeclaration = [{
     }
     SmallVector<OpFoldResult> getMixedHighPad() {
       return getMixedPadImpl(static_high(), high());
     }
   }];
 
   let builders = [
     // Build a PadTensorOp with mixed static and dynamic entries.
-    OpBuilderDAG<(ins "Value":$source, "ArrayRef<int64_t>":$staticLow,
+    OpBuilder<(ins "Value":$source, "ArrayRef<int64_t>":$staticLow,
       "ArrayRef<int64_t>":$staticHigh, "ValueRange":$low, "ValueRange":$high,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a PadTensorOp with all dynamic entries.
-    OpBuilderDAG<(ins "Value":$source, "ValueRange":$low, "ValueRange":$high,
+    OpBuilder<(ins "Value":$source, "ValueRange":$low, "ValueRange":$high,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a PadTensorOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
-    OpBuilderDAG<(ins "Type":$resultType, "Value":$source,
+    OpBuilder<(ins "Type":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$low, "ArrayRef<OpFoldResult>":$high,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 }
 
 def Linalg_RangeOp :
     Linalg_Op<"range", [NoSideEffect]>,
     Arguments<(ins Index:$min, Index:$max, Index:$step)>,
     Results<(outs Range)> {
   let summary = "Create a `range` type value, used to create `view`s";
   let description = [{
     The `linalg.range` op creates a `!linalg.range` from 3 values of type
     `index` that represent the min, max and step values of the `range`. This
     type does not pass function boundaries at the moment.
 
     Example:
 
     ```mlir
     %3 = linalg.range %0:%1:%2 : !linalg.range
     ````
   }];
   let builders = [
-    OpBuilderDAG<(ins "Value":$min, "Value":$max, "Value":$step),
+    OpBuilder<(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`.
-    OpBuilderDAG<(ins "Value":$src,
+    OpBuilder<(ins "Value":$src,
       "ArrayRef<ReassociationExprs>":$reassociation,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
-    OpBuilderDAG<(ins "Value":$src,
+    OpBuilder<(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.
-    OpBuilderDAG<(ins "Type":$resultType, "Value":$src,
+    OpBuilder<(ins "Type":$resultType, "Value":$src,
       "ArrayRef<ReassociationExprs>":$reassociation,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
-    OpBuilderDAG<(ins "Type":$resultType, "Value":$src,
+    OpBuilder<(ins "Type":$resultType, "Value":$src,
       "ArrayRef<ReassociationIndices>":$reassociation,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
     [{
       auto reassociationMaps =
           convertReassociationIndicesToMaps($_builder, reassociation);
       build($_builder, $_state, resultType, src, reassociationMaps, attrs);
     }]>
   ];
let description = [{
     `linalg` generic op.
 
     Example:
 
     ```mlir
     linalg.yield %f0, %f1 : f32, f32
     ```
   }];
-  let builders = [OpBuilderDAG<(ins), [{ /* nothing to do */ }]>];
+  let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
 }
 
 def Linalg_TiledLoopOp : Linalg_Op<"tiled_loop", [
      AttrSizedOperandSegments,
      DeclareOpInterfaceMethods<LoopLikeOpInterface>,
      RecursiveSideEffects,
      SingleBlockImplicitTerminator<"linalg::YieldOp">
     ]> {
let arguments = (ins Variadic<Index>:$lowerBound,
                        Variadic<Index>:$step,
                        Variadic<AnyRankedTensor>:$inputs,
                        Variadic<AnyRankedTensor>:$outputs,
                        ArrayAttr:$iterator_types);
   let results = (outs Variadic<AnyRankedTensor>:$results);
   let regions = (region SizedRegion<1>:$region);
 
   let builders = [
-    OpBuilderDAG<(ins "ValueRange":$lowerBounds, "ValueRange":$upperBounds,
+    OpBuilder<(ins "ValueRange":$lowerBounds, "ValueRange":$upperBounds,
       "ValueRange":$steps, "ValueRange":$inputs, "ValueRange":$outputs,
       "ArrayRef<StringRef>":$iteratorTypes,
       CArg<"function_ref<void (OpBuilder &, Location, ValueRange)>",
            "nullptr">:$bodyBuilderFn)>,
   ];
 
   let extraClassDeclaration = [{
     ValueRange getInductionVars() {
       return getBody()->getArguments();
     }
     unsigned getNumLoops() { return step().size(); }
   }];
 }
 
 
 #endif // LINALG_OPS

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

def CopyOp : LinalgStructured_Op<"copy", [CopyOpInterface]> {
   let arguments = (ins
     AnyStridedMemRef:$input,
     AnyStridedMemRef:$output,
     OptionalAttr<AffineMapAttr>:$inputPermutation,
     OptionalAttr<AffineMapAttr>:$outputPermutation);
   let regions = (region AnyRegion:$region);
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$input, "Value":$output,
+    OpBuilder<(ins "Value":$input, "Value":$output,
       CArg<"AffineMap", "AffineMap()">:$inputPermutation,
       CArg<"AffineMap", "AffineMap()">:$outputPermutation,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
 
   let extraClassDeclaration = structuredOpsDecls # [{
     ValueRange inputs() { return getOperands().take_front(); }
     ValueRange outputs() { return getOperands().take_back(); }
 
def FillOp : LinalgStructured_Op<"fill", []> {
 
   let assemblyFormat = [{
     `(` $output `,` $value `)` attr-dict `:`
         type($output) `,` type($value) (`->` type($result)^)?
       custom<FillOpRegion>($region, ref(type($output)), ref($value))
   }];
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$output, "Value":$value)>
+    OpBuilder<(ins "Value":$output, "Value":$value)>
   ];
 
   let verifier = [{ return ::verify(*this); }];
 
   let hasFolder = 1;
   let hasCanonicalizer = 1;
 }
 
%C = linalg.generic #trait_attribute
       outs(%C : tensor<?x?xf32>)
       {other-optional-attributes}
       {region}
       -> (tensor<?x?xf32>)
     ```
   }];
 
   let builders = [
-    OpBuilderDAG<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
+    OpBuilder<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
       "ValueRange":$outputs, "ArrayRef<AffineMap>":$indexingMaps,
       "ArrayRef<StringRef>":$iteratorTypes, "StringRef":$doc,
       "StringRef":$libraryCall,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">)>,
-    OpBuilderDAG<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
+    OpBuilder<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
       "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
       "StringRef":$doc, "StringRef":$libraryCall,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">)>,
-    OpBuilderDAG<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
+    OpBuilder<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
       "ValueRange":$outputs, "ArrayRef<AffineMap>":$indexingMaps,
       "ArrayRef<StringRef>":$iteratorTypes,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange)>", "nullptr">)>,
-    OpBuilderDAG<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
+    OpBuilder<(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;
 }
%C = linalg.indexed_generic #trait_attribute
       outs(%C : tensor<?x?xf32>)
       {other-optional-attributes}
       {region_with_index_arguments}
       -> (tensor<?x?xf32>)
     ```
   }];
 
   let builders = [
-    OpBuilderDAG<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
+    OpBuilder<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
       "ValueRange":$outputs, "ArrayRef<AffineMap>":$indexingMaps,
       "ArrayRef<StringRef>":$iteratorTypes, "StringRef":$doc,
       "StringRef":$libraryCall,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)>",
            "nullptr">)>,
-    OpBuilderDAG<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
+    OpBuilder<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
       "ArrayRef<AffineMap>":$indexingMaps, "ArrayRef<StringRef>":$iteratorTypes,
       "StringRef":$doc, "StringRef":$libraryCall,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)>",
            "nullptr">)>,
-    OpBuilderDAG<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
+    OpBuilder<(ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
       "ValueRange":$outputs, "ArrayRef<AffineMap>":$indexingMaps,
       "ArrayRef<StringRef>":$iteratorTypes,
       CArg<"function_ref<void(OpBuilder &, Location, ValueRange, ValueRange)>",
            "nullptr">)>,
-    OpBuilderDAG<(ins "ValueRange":$inputs, "ValueRange":$outputBuffers,
+    OpBuilder<(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;

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 = [OpBuilderDAG<(ins), [{ /* nothing to do */ }]>];
+  let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
 
   let verifier = ?;
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 
 //===----------------------------------------------------------------------===//
 // 2.14.1. Init Directive

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

let arguments = (ins Optional<AnyType>:$if_expr_var,
              Variadic<AnyType>:$copyin_vars,
              Variadic<AnyType>:$allocate_vars,
              Variadic<AnyType>:$allocators_vars,
              OptionalAttr<ProcBindKind>:$proc_bind_val);
 
   let regions = (region AnyRegion:$region);
 
   let builders = [
-    OpBuilderDAG<(ins CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
+    OpBuilder<(ins CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
   ];
   let parser = [{ return parseParallelOp(parser, result); }];
   let printer = [{ return printParallelOp(p, *this); }];
   let verifier = [{ return ::verifyParallelOp(*this); }];
 }
 
 def TerminatorOp : OpenMP_Op<"terminator", [Terminator]> {
   let summary = "terminator for OpenMP regions";
let arguments = (ins Variadic<IntLikeType>:$lowerBound,
              Optional<AnyType>:$schedule_chunk_var,
              Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$collapse_val,
              UnitAttr:$nowait,
              Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$ordered_val,
              OptionalAttr<OrderKind>:$order_val,
              UnitAttr:$inclusive);
 
   let builders = [
-    OpBuilderDAG<(ins "ValueRange":$lowerBound, "ValueRange":$upperBound,
+    OpBuilder<(ins "ValueRange":$lowerBound, "ValueRange":$upperBound,
                   "ValueRange":$step,
                   CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
   ];
 
   let regions = (region AnyRegion:$region);
 
   let extraClassDeclaration = [{
     /// Returns the number of loops in the workshape loop nest.

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 = [
-    OpBuilderDAG<(ins "StringRef":$name, CArg<"ValueRange", "{}">:$args,
+    OpBuilder<(ins "StringRef":$name, CArg<"ValueRange", "{}">:$args,
       CArg<"ArrayRef<Attribute>", "{}">:$params), [{
       build($_builder, $_state, $_builder.getStringAttr(name), args,
             params.empty() ? ArrayAttr() : $_builder.getArrayAttr(params));
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
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 = [
-    OpBuilderDAG<(ins CArg<"Value", "Value()">:$type), [{
+    OpBuilder<(ins CArg<"Value", "Value()">:$type), [{
       build($_builder, $_state, $_builder.getType<AttributeType>(), type,
             Attribute());
     }]>,
-    OpBuilderDAG<(ins "Attribute":$attr), [{
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins), [{
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins CArg<"Optional<StringRef>", "llvm::None">:$name,
+    OpBuilder<(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);
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 = [
-    OpBuilderDAG<(ins CArg<"Optional<StringRef>", "llvm::None">:$rootKind,
+    OpBuilder<(ins CArg<"Optional<StringRef>", "llvm::None">:$rootKind,
       CArg<"Optional<uint16_t>", "1">:$benefit,
       CArg<"Optional<StringRef>", "llvm::None">:$name)>,
   ];
   let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
     // SymbolOpInterface Methods
     //===------------------------------------------------------------------===//
 
let description = [{
     ```
   }];
 
   let arguments = (ins OptionalAttr<TypeAttr>:$type);
   let results = (outs PDL_Type:$result);
   let assemblyFormat = "attr-dict (`:` $type^)?";
 
   let builders = [
-    OpBuilderDAG<(ins CArg<"Type", "Type()">:$ty), [{
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Attribute":$value), [{
+    OpBuilder<(ins "Attribute":$value), [{
       build($_builder, $_state, $_builder.getType<pdl::AttributeType>(), value);
     }]>];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CreateNativeOp
 //===----------------------------------------------------------------------===//
 
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 = [
-    OpBuilderDAG<(ins "StringRef":$name, "ValueRange":$types,
+    OpBuilder<(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); }];
 }
let description = [{
     ```
   }];
 
   let arguments = (ins TypeAttr:$value);
   let results = (outs PDL_Type:$result);
   let assemblyFormat = "$value attr-dict";
 
   let builders = [
-    OpBuilderDAG<(ins "TypeAttr":$type), [{
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$value), [{
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$value), [{
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins), [{
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$attribute, "ArrayRef<Attribute>":$caseValues,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$operation, "ArrayRef<int32_t>":$counts,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$operation, "ArrayRef<OperationName>":$names,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$operation, "ArrayRef<int32_t>":$counts,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$edge, "TypeRange":$types, "Block *":$defaultDest,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$lowerBound, "Value":$upperBound, "Value":$step,
+    OpBuilder<(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)>;
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 = [
-    OpBuilderDAG<(ins "Value":$cond, "bool":$withElseRegion)>,
-    OpBuilderDAG<(ins "TypeRange":$resultTypes, "Value":$cond,
+    OpBuilder<(ins "Value":$cond, "bool":$withElseRegion)>,
+    OpBuilder<(ins "TypeRange":$resultTypes, "Value":$cond,
       "bool":$withElseRegion)>,
-    OpBuilderDAG<(ins "TypeRange":$resultTypes, "Value":$cond,
+    OpBuilder<(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,
+    OpBuilder<(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) {
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 = [
-    OpBuilderDAG<(ins "ValueRange":$lowerBounds, "ValueRange":$upperBounds,
+    OpBuilder<(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,
+    OpBuilder<(ins "ValueRange":$lowerBounds, "ValueRange":$upperBounds,
       "ValueRange":$steps,
       CArg<"function_ref<void (OpBuilder &, Location, ValueRange)>",
            "nullptr">:$bodyBuilderFn)>,
   ];
 
   let extraClassDeclaration = [{
     ValueRange getInductionVars() {
       return getBody()->getArguments();
scf.reduce(%operand) : f32 {
         %res = addf %lhs, %rhs : f32
         scf.reduce.return %res : f32
     }
     ```
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilderDAG<(ins "Value":$operand,
+    OpBuilder<(ins "Value":$operand,
       CArg<"function_ref<void (OpBuilder &, Location, Value, Value)>",
            "nullptr">:$bodyBuilderFn)>
   ];
 
   let arguments = (ins AnyType:$operand);
   let regions = (region SizedRegion<1>:$reductionOperator);
 }
 
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 = [OpBuilderDAG<(ins), [{ /* nothing to do */ }]>];
+  let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
 
   let assemblyFormat =
       [{  attr-dict ($results^ `:` type($results))? }];
 
   // Override default verifier (defined in SCF_Op), no custom verification
   // needed.
   let verifier = ?;
 }
 
 #endif // MLIR_DIALECT_SCF_SCFOPS

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

let arguments = (ins
     SPV_Integer:$value
   );
 
   let results = (outs
     SPV_Integer:$result
   );
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$pointer, "::mlir::spirv::Scope":$scope,
+    OpBuilder<(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", []> {

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

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

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

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

mlir/include/mlir/Dialect/SPIRV/IR/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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs),
+    OpBuilder<(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,
                                        SameOperandsAndResultShape])> {
   let parser = [{ return ::parseLogicalUnaryOp(parser, result); }];
   let printer = [{ return ::printLogicalOp(getOperation(), p); }];
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$value),
+    OpBuilder<(ins "Value":$value),
     [{::buildLogicalUnaryOp($_builder, $_state, value);}]>
   ];
 }
 
 // -----
 
 def SPV_FOrdEqualOp : SPV_LogicalBinaryOp<"FOrdEqual", SPV_Float, [Commutative]> {
   let summary = "Floating-point comparison for being ordered and equal.";
let arguments = (ins
     SPV_SelectType:$false_value
   );
 
   let results = (outs
     SPV_SelectType:$result
   );
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$cond, "Value":$trueValue, "Value":$falseValue)>];
+    OpBuilder<(ins "Value":$cond, "Value":$trueValue, "Value":$falseValue)>];
 
   let assemblyFormat = [{
     operands attr-dict `:` type($condition) `,` type($result)
   }];
 }
 
 // -----
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVMemoryOps.td

let arguments = (ins
     SPV_AnyPtr:$base_ptr,
     Variadic<SPV_Integer>:$indices
   );
 
   let results = (outs
     SPV_AnyPtr:$component_ptr
   );
 
-  let builders = [OpBuilderDAG<(ins "Value":$basePtr, "ValueRange":$indices)>];
+  let builders = [OpBuilder<(ins "Value":$basePtr, "ValueRange":$indices)>];
 
   let hasCanonicalizer = 1;
 }
 
 // -----
 
 def SPV_CopyMemoryOp : SPV_Op<"CopyMemory", []> {
   let summary = [{
let arguments = (ins
     OptionalAttr<I32Attr>:$alignment
   );
 
   let results = (outs
     SPV_Type:$value
   );
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$basePtr,
+    OpBuilder<(ins "Value":$basePtr,
       CArg<"IntegerAttr", "{}">:$memory_access,
       CArg<"IntegerAttr", "{}">:$alignment)>
   ];
 }
 
 // -----
 
 def SPV_StoreOp : SPV_Op<"Store", []> {
let arguments = (ins
     SPV_Type:$value,
     OptionalAttr<SPV_MemoryAccessAttr>:$memory_access,
     OptionalAttr<I32Attr>:$alignment
   );
 
   let results = (outs);
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$ptr, "Value":$value,
+    OpBuilder<(ins "Value":$ptr, "Value":$value,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$namedAttrs),
     [{
       $_state.addOperands(ptr);
       $_state.addOperands(value);
       $_state.addAttributes(namedAttrs);
     }]>
   ];
 }

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

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

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

def SPV_AddressOfOp : SPV_Op<"mlir.addressof", [InFunctionScope, NoSideEffect]> {
   let results = (outs
     SPV_AnyPtr:$pointer
   );
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
-  let builders = [OpBuilderDAG<(ins "spirv::GlobalVariableOp":$var)>];
+  let builders = [OpBuilder<(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
     SymbolRefArrayAttr:$interface
   );
 
   let results = (outs);
 
   let autogenSerialization = 0;
 
   let builders = [
-    OpBuilderDAG<(ins "spirv::ExecutionModel":$executionModel,
+    OpBuilder<(ins "spirv::ExecutionModel":$executionModel,
       "spirv::FuncOp":$function, "ArrayRef<Attribute>":$interfaceVars)>];
 }
 
 // -----
 
 def SPV_ExecutionModeOp : SPV_Op<"ExecutionMode", [InModuleScope]> {
   let summary = "Declare an execution mode for an entry point.";
 
def SPV_ExecutionModeOp : SPV_Op<"ExecutionMode", [InModuleScope]> {
 
   let results = (outs);
 
   let verifier = [{ return success(); }];
 
   let autogenSerialization = 0;
 
   let builders = [
-    OpBuilderDAG<(ins "spirv::FuncOp":$function,
+    OpBuilder<(ins "spirv::FuncOp":$function,
       "spirv::ExecutionMode":$executionMode, "ArrayRef<int32_t>":$params)>];
 }
 
 // -----
 
 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 = [
-    OpBuilderDAG<(ins "StringRef":$name, "FunctionType":$type,
+    OpBuilder<(ins "StringRef":$name, "FunctionType":$type,
       CArg<"spirv::FunctionControl", "spirv::FunctionControl::None">:$control,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
let arguments = (ins
     TypeAttr:$type,
     StrAttr:$sym_name,
     OptionalAttr<FlatSymbolRefAttr>:$initializer
   );
 
   let results = (outs);
 
   let builders = [
-    OpBuilderDAG<(ins "TypeAttr":$type, "ArrayRef<NamedAttribute>":$namedAttrs),
+    OpBuilder<(ins "TypeAttr":$type, "ArrayRef<NamedAttribute>":$namedAttrs),
     [{
       $_state.addAttribute("type", type);
       $_state.addAttributes(namedAttrs);
     }]>,
-    OpBuilderDAG<(ins "Type":$type, "StringRef":$name,
+    OpBuilder<(ins "Type":$type, "StringRef":$name,
       "unsigned":$descriptorSet, "unsigned":$binding)>,
-    OpBuilderDAG<(ins "Type":$type, "StringRef":$name,
+    OpBuilder<(ins "Type":$type, "StringRef":$name,
       "spirv::BuiltIn":$builtin)>
   ];
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
let arguments = (ins
     OptionalAttr<StrAttr>:$sym_name
   );
 
   let results = (outs);
 
   let regions = (region SizedRegion<1>:$body);
 
   let builders = [
-    OpBuilderDAG<(ins CArg<"Optional<StringRef>", "llvm::None">:$name)>,
-    OpBuilderDAG<(ins "spirv::AddressingModel":$addressing_model,
+    OpBuilder<(ins CArg<"Optional<StringRef>", "llvm::None">:$name)>,
+    OpBuilder<(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;
 

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

def Shape_BroadcastOp : Shape_Op<"broadcast", [Commutative, NoSideEffect]> {
   let arguments = (ins Variadic<Shape_ShapeOrExtentTensorType>:$shapes,
                        OptionalAttr<StrAttr>:$error);
   let results = (outs Shape_ShapeOrExtentTensorType:$result);
 
   let assemblyFormat = [{
     $shapes attr-dict `:` type($shapes) `->` type($result)
   }];
 
-  let builders = [OpBuilderDAG<(ins "::mlir::Type":$result,
+  let builders = [OpBuilder<(ins "::mlir::Type":$result,
                                 "::mlir::Value":$lhs, "::mlir::Value":$rhs,
                                 "/*optional*/ ::mlir::StringAttr":$error), [{
       build($_builder, $_state, result, ::llvm::makeArrayRef({lhs, rhs}), error);
     }]>
   ];
 
   let hasFolder = 1;
   let verifier = [{ return ::verify(*this); }];
let description = [{
     ```mlir
     %x = shape.const_size 10
     ```
   }];
 
   let arguments = (ins IndexAttr:$value);
   let results = (outs Shape_SizeType:$result);
 
-  let builders = [OpBuilderDAG<(ins "int64_t":$value)>];
+  let builders = [OpBuilder<(ins "int64_t":$value)>];
 
   let assemblyFormat = "$value attr-dict";
   let hasFolder = 1;
 }
 
 def Shape_DivOp : Shape_Op<"div", [NoSideEffect]> {
   let summary = "Division of sizes and indices";
   let description = [{
let description = [{
     %false = shape.is_broadcastable [2,2], [3,2]
     ```
   }];
 
   let arguments = (ins Variadic<Shape_ShapeOrExtentTensorType>:$shapes);
   let results = (outs I1:$result);
 
   let builders = [
-  OpBuilderDAG<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
+  OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
     [{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>,
   ];
   let extraClassDeclaration = [{
     // TODO: This should really be automatic. Figure out how to not need this defined.
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
     ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
     ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
     ::llvm::SmallVectorImpl<::mlir::Type>&inferredReturnTypes) {
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 attr-dict `:` type($shape) `,` type($dim) `->` "
                        "type($extent)";
 
   let builders = [
     // Builder that allows passing a constant dimension as a simple integer.
-    OpBuilderDAG<(ins "Value":$shape, "int64_t":$dim)>
+    OpBuilder<(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 = [OpBuilderDAG<(ins "Value":$shape)>];
+  let builders = [OpBuilder<(ins "Value":$shape)>];
 
   let assemblyFormat = "$shape attr-dict `:` type($shape) `->` type($result)";
 
   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 = [OpBuilderDAG<(ins "Value":$shape, "ValueRange":$initVals)>];
+  let builders = [OpBuilder<(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 attr-dict `:` type($arg) `->` type($result)";
 
-  let builders = [OpBuilderDAG<(ins "Value":$arg)>];
+  let builders = [OpBuilder<(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, FunctionLibraryOp">,
      NoSideEffect,
      ReturnLike,
      Terminator]> {
   let summary = "Returns the value to parent op";
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
-  let builders = [OpBuilderDAG<(ins),
+  let builders = [OpBuilder<(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
     `shape.assuming` operation region. The operation takes variable number of
     operands and produces no results. The operand number and types must match
     the number and types of parent `shape.assuming` results.
   }];
 
   let arguments = (ins Variadic<AnyType>:$operands);
 
-  let builders = [OpBuilderDAG<(ins), [{ /* nothing to do */ }]>];
+  let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 
 def Shape_CstrBroadcastableOp : Shape_Op<"cstr_broadcastable",
                                          [Commutative, InferTypeOpInterface]> {
   let summary = "Determines if 2+ shapes can be successfully broadcasted";
   let description = [{
def Shape_CstrBroadcastableOp : Shape_Op<"cstr_broadcastable",
   }];
 
   let arguments = (ins Variadic<Shape_ShapeOrExtentTensorType>:$shapes);
   let results = (outs Shape_WitnessType:$result);
 
   let assemblyFormat = "$shapes attr-dict `:` type($shapes)";
 
   let builders = [
-  OpBuilderDAG<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
+  OpBuilder<(ins "::mlir::Value":$lhs, "::mlir::Value":$rhs),
     [{ build($_builder, $_state, ::llvm::makeArrayRef({lhs, rhs})); }]>,
   ];
 
   let extraClassDeclaration = [{
     // TODO: This should really be automatic. Figure out how to not need this defined.
     static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *context,
     ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
     ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
def Shape_FunctionLibraryOp : Shape_Op<"function_library",
   let arguments = (ins DictionaryAttr:$mapping);
   let regions = (region AnyRegion:$body);
 
   let extraClassDeclaration = [{
     /// Returns an associated shape function for an operation if defined.
     FuncOp getShapeFunction(Operation *op);
   }];
 
-  let builders = [OpBuilderDAG<(ins "StringRef":$name)>];
+  let builders = [OpBuilder<(ins "StringRef":$name)>];
   let skipDefaultBuilders = 1;
 
   let printer = [{ ::print(p, *this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeFunctionLibraryTerminatorOp

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

 class CastOp<string mnemonic, list<OpTrait> traits = []> :
     Std_Op<mnemonic, traits # [
       NoSideEffect, SameOperandsAndResultShape,
       DeclareOpInterfaceMethods<CastOpInterface>
     ]> {
   let results = (outs AnyType);
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$source, "Type":$destType), [{
+    OpBuilder<(ins "Value":$source, "Type":$destType), [{
        impl::buildCastOp($_builder, $_state, source, destType);
     }]>
   ];
 
   let parser = [{
     return impl::parseCastOp(parser, result);
   }];
   let printer = [{
class AllocLikeOp<string mnemonic,
   let arguments = (ins Variadic<Index>:$dynamicSizes,
                    // The symbolic operands (the ones in square brackets) bind
                    // to the symbols of the memref's layout map.
                    Variadic<Index>:$symbolOperands,
                    Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$alignment);
   let results = (outs Res<AnyMemRef, "", [MemAlloc<resource>]>:$memref);
 
   let builders = [
-    OpBuilderDAG<(ins "MemRefType":$memrefType,
+    OpBuilder<(ins "MemRefType":$memrefType,
                   CArg<"IntegerAttr", "IntegerAttr()">:$alignment), [{
       return build($_builder, $_state, memrefType, {}, alignment);
     }]>,
-    OpBuilderDAG<(ins "MemRefType":$memrefType, "ValueRange":$dynamicSizes,
+    OpBuilder<(ins "MemRefType":$memrefType, "ValueRange":$dynamicSizes,
                   CArg<"IntegerAttr", "IntegerAttr()">:$alignment), [{
       return build($_builder, $_state, memrefType, dynamicSizes, {}, alignment);
     }]>,
-    OpBuilderDAG<(ins "MemRefType":$memrefType, "ValueRange":$dynamicSizes,
+    OpBuilder<(ins "MemRefType":$memrefType, "ValueRange":$dynamicSizes,
                   "ValueRange":$symbolOperands,
                   CArg<"IntegerAttr", "{}">:$alignment), [{
       $_state.types.push_back(memrefType);
       $_state.addOperands(dynamicSizes);
       $_state.addOperands(symbolOperands);
       $_state.addAttribute(getOperandSegmentSizeAttr(),
           $_builder.getI32VectorAttr({
               static_cast<int32_t>(dynamicSizes.size()),
let arguments = (ins
       Variadic<Index>:$indices);
 
   let results = (outs
       AnyTypeOf<[AnySignlessInteger, AnyFloat]>:$result);
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
-  let builders = [OpBuilderDAG<(ins "Value":$memref, "ValueRange":$ivs)>];
+  let builders = [OpBuilder<(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>();
let description = [{
     ^bb3(%3: tensor<*xf32>):
     ```
   }];
 
   let arguments = (ins Variadic<AnyType>:$destOperands);
   let successors = (successor AnySuccessor:$dest);
 
   let builders = [
-    OpBuilderDAG<(ins "Block *":$dest,
+    OpBuilder<(ins "Block *":$dest,
                   CArg<"ValueRange", "{}">:$destOperands), [{
       $_state.addSuccessors(dest);
       $_state.addOperands(destOperands);
     }]>];
 
   // BranchOp is fully verified by traits.
   let verifier = ?;
 
let description = [{
     %2 = call @my_add(%0, %1) : (f32, f32) -> f32
     ```
   }];
 
   let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<AnyType>:$operands);
   let results = (outs Variadic<AnyType>);
 
   let builders = [
-    OpBuilderDAG<(ins "FuncOp":$callee, CArg<"ValueRange", "{}">:$operands), [{
+    OpBuilder<(ins "FuncOp":$callee, CArg<"ValueRange", "{}">:$operands), [{
       $_state.addOperands(operands);
       $_state.addAttribute("callee",$_builder.getSymbolRefAttr(callee));
       $_state.addTypes(callee.getType().getResults());
     }]>,
-    OpBuilderDAG<(ins "SymbolRefAttr":$callee, "TypeRange":$results,
+    OpBuilder<(ins "SymbolRefAttr":$callee, "TypeRange":$results,
       CArg<"ValueRange", "{}">:$operands), [{
       $_state.addOperands(operands);
       $_state.addAttribute("callee", callee);
       $_state.addTypes(results);
     }]>,
-    OpBuilderDAG<(ins "StringRef":$callee, "TypeRange":$results,
+    OpBuilder<(ins "StringRef":$callee, "TypeRange":$results,
       CArg<"ValueRange", "{}">:$operands), [{
       build($_builder, $_state, $_builder.getSymbolRefAttr(callee), results,
             operands);
     }]>];
 
   let extraClassDeclaration = [{
     StringRef getCallee() { return callee(); }
     FunctionType getCalleeType();
%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 = [
-    OpBuilderDAG<(ins "Value":$callee, CArg<"ValueRange", "{}">:$operands), [{
+    OpBuilder<(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); }
 
def CmpFOp : Std_Op<"cmpf", [NoSideEffect, SameTypeOperands,
   let arguments = (ins
     CmpFPredicateAttr:$predicate,
     FloatLike:$lhs,
     FloatLike:$rhs
   );
   let results = (outs BoolLike:$result);
 
   let builders = [
-    OpBuilderDAG<(ins "CmpFPredicate":$predicate, "Value":$lhs,
+    OpBuilder<(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);
 
def CmpIOp : Std_Op<"cmpi", [NoSideEffect, SameTypeOperands,
   let arguments = (ins
       CmpIPredicateAttr:$predicate,
       SignlessIntegerLike:$lhs,
       SignlessIntegerLike:$rhs
   );
   let results = (outs BoolLike:$result);
 
   let builders = [
-    OpBuilderDAG<(ins "CmpIPredicate":$predicate, "Value":$lhs,
+    OpBuilder<(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);
 
def CondBranchOp : Std_Op<"cond_br",
   }];
 
   let arguments = (ins I1:$condition,
                        Variadic<AnyType>:$trueDestOperands,
                        Variadic<AnyType>:$falseDestOperands);
   let successors = (successor AnySuccessor:$trueDest, AnySuccessor:$falseDest);
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$condition, "Block *":$trueDest,
+    OpBuilder<(ins "Value":$condition, "Block *":$trueDest,
       "ValueRange":$trueOperands, "Block *":$falseDest,
       "ValueRange":$falseOperands), [{
       build($_builder, $_state, condition, trueOperands, falseOperands, trueDest,
             falseDest);
     }]>,
-    OpBuilderDAG<(ins "Value":$condition, "Block *":$trueDest,
+    OpBuilder<(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 description = [{
     reference a function simplifies this
     ([rationale](../Rationale/Rationale.md#multithreading-the-compiler)).
   }];
 
   let arguments = (ins AnyAttr:$value);
   let results = (outs AnyType);
 
   let builders = [
-    OpBuilderDAG<(ins "Attribute":$value),
+    OpBuilder<(ins "Attribute":$value),
     [{ build($_builder, $_state, value.getType(), value); }]>];
 
   let extraClassDeclaration = [{
     Attribute getValue() { return (*this)->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 = [
-    OpBuilderDAG<(ins "Value":$memrefOrTensor, "int64_t":$index)>,
-    OpBuilderDAG<(ins "Value":$memrefOrTensor, "Value":$index)>
+    OpBuilder<(ins "Value":$memrefOrTensor, "int64_t":$index)>,
+    OpBuilder<(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 hasCanonicalizer = 1;
def LoadOp : Std_Op<"load",
   }];
 
   let arguments = (ins Arg<AnyMemRef, "the reference to load from",
                            [MemRead]>:$memref,
                        Variadic<Index>:$indices);
   let results = (outs AnyType:$result);
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$memref, CArg<"ValueRange", "{}">:$indices), [{
+    OpBuilder<(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); }
let assemblyFormat = [{
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let parser=?;
   let printer=?;
 
   let builders = [
     // Build a ReinterpretCastOp with mixed static and dynamic entries.
-    OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
+    OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "OpFoldResult":$offset, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a ReinterpretCastOp with static entries.
-    OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
+    OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "int64_t":$offset, "ArrayRef<int64_t>":$sizes,
       "ArrayRef<int64_t>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a ReinterpretCastOp with dynamic entries.
-    OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
+    OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "Value":$offset, "ValueRange":$sizes,
       "ValueRange":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = extraBaseClassDeclaration # [{
     // The result of the op is always a ranked memref.
     MemRefType getType() { return getResult().getType().cast<MemRefType>(); }
def MemRefReshapeOp: Std_Op<"memref_reshape", [
   }];
 
   let arguments = (ins
     AnyRankedOrUnrankedMemRef:$source,
     MemRefRankOf<[AnySignlessInteger, Index], [1]>:$shape
   );
   let results = (outs AnyRankedOrUnrankedMemRef:$result);
 
-  let builders = [OpBuilderDAG<
+  let builders = [OpBuilder<
      (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>(); }
def RankOp : Std_Op<"rank", [NoSideEffect]> {
   }];
 
   let arguments = (ins AnyTypeOf<[AnyRankedOrUnrankedMemRef, AnyTensor],
                                  "any tensor or memref type">:$memrefOrTensor);
   let results = (outs Index);
   let verifier = ?;
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$tensor), [{
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins),
+    OpBuilder<(ins),
     [{ build($_builder, $_state, llvm::None); }]>];
 
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 
 //===----------------------------------------------------------------------===//
 // SelectOp
 //===----------------------------------------------------------------------===//
def SelectOp : Std_Op<"select", [NoSideEffect,
   }];
 
   let arguments = (ins BoolLike:$condition,
                        AnyType:$true_value,
                        AnyType:$false_value);
   let results = (outs AnyType:$result);
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$condition, "Value":$trueValue,
+    OpBuilder<(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(); }
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 = [
-    OpBuilderDAG<(ins "Value":$value, "Type":$destType), [{
+    OpBuilder<(ins "Value":$value, "Type":$destType), [{
       $_state.addOperands(value);
       $_state.addTypes(destType);
     }]>];
 
   let parser = [{
     return impl::parseCastOp(parser, result);
   }];
   let printer = [{
let description = [{
     ```
   }];
 
   let arguments = (ins AnyTypeOf<[AnySignlessInteger, AnyFloat],
                                  "integer or float type">:$input);
   let results = (outs AnyTypeOf<[AnyVector, AnyStaticShapeTensor]>:$aggregate);
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$element, "Type":$aggregateType),
+    OpBuilder<(ins "Value":$element, "Type":$aggregateType),
     [{ build($_builder, $_state, aggregateType, element); }]>];
 
   let hasFolder = 1;
 
   let assemblyFormat = "$input attr-dict `:` type($aggregate)";
 }
 
 //===----------------------------------------------------------------------===//
def StoreOp : Std_Op<"store",
   }];
 
   let arguments = (ins AnyType:$value,
                        Arg<AnyMemRef, "the reference to store to",
                            [MemWrite]>:$memref,
                        Variadic<Index>:$indices);
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$valueToStore, "Value":$memref), [{
+    OpBuilder<(ins "Value":$valueToStore, "Value":$memref), [{
       $_state.addOperands(valueToStore);
       $_state.addOperands(memref);
     }]>];
 
   let extraClassDeclaration = [{
       Value getValueToStore() { return getOperand(0); }
 
       Value getMemRef() { return getOperand(1); }
let assemblyFormat = [{
     custom<OperandsOrIntegersSizesList>($sizes, $static_sizes)
     custom<OperandsOrIntegersOffsetsOrStridesList>($strides, $static_strides)
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let builders = [
     // Build a SubViewOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
-    OpBuilderDAG<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
+    OpBuilder<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
       "ArrayRef<OpFoldResult>":$sizes, "ArrayRef<OpFoldResult>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with mixed static and dynamic entries and inferred
     // result type.
-    OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
+    OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with static entries and custom result type. If the
     // type passed is nullptr, it is inferred.
-    OpBuilderDAG<(ins "Value":$source, "ArrayRef<int64_t>":$offsets,
+    OpBuilder<(ins "Value":$source, "ArrayRef<int64_t>":$offsets,
       "ArrayRef<int64_t>":$sizes, "ArrayRef<int64_t>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with static entries and inferred result type.
-    OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
+    OpBuilder<(ins "MemRefType":$resultType, "Value":$source,
       "ArrayRef<int64_t>":$offsets, "ArrayRef<int64_t>":$sizes,
       "ArrayRef<int64_t>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with dynamic entries and custom result type. If the
     // type passed is nullptr, it is inferred.
-    OpBuilderDAG<(ins "Value":$source, "ValueRange":$offsets,
+    OpBuilder<(ins "Value":$source, "ValueRange":$offsets,
       "ValueRange":$sizes, "ValueRange":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubViewOp with dynamic entries and inferred result type.
-    OpBuilderDAG<(ins "MemRefType":$resultType, "Value":$source,
+    OpBuilder<(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 assemblyFormat = [{
     custom<OperandsOrIntegersSizesList>($sizes, $static_sizes)
     custom<OperandsOrIntegersOffsetsOrStridesList>($strides, $static_strides)
     attr-dict `:` type($source) `to` type($result)
   }];
 
   let builders = [
     // Build a SubTensorOp with mixed static and dynamic entries and inferred
     // result type.
-    OpBuilderDAG<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
+    OpBuilder<(ins "Value":$source, "ArrayRef<OpFoldResult>":$offsets,
       "ArrayRef<OpFoldResult>":$sizes, "ArrayRef<OpFoldResult>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubTensorOp with mixed static and dynamic entries and custom
     // result type. If the type passed is nullptr, it is inferred.
-    OpBuilderDAG<(ins "RankedTensorType":$resultType, "Value":$source,
+    OpBuilder<(ins "RankedTensorType":$resultType, "Value":$source,
       "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubTensorOp with dynamic entries and custom result type. If the
     // type passed is nullptr, it is inferred.
-    OpBuilderDAG<(ins "Value":$source, "ValueRange":$offsets,
+    OpBuilder<(ins "Value":$source, "ValueRange":$offsets,
       "ValueRange":$sizes, "ValueRange":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubTensorOp with dynamic entries and inferred result type.
-    OpBuilderDAG<(ins "RankedTensorType":$resultType, "Value":$source,
+    OpBuilder<(ins "RankedTensorType":$resultType, "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 assemblyFormat = [{
     custom<OperandsOrIntegersOffsetsOrStridesList>($strides, $static_strides)
     attr-dict `:` type($source) `into` type($dest)
   }];
 
   let verifier = ?;
 
   let builders = [
     // Build a SubTensorInsertOp with mixed static and dynamic entries.
-    OpBuilderDAG<(ins "Value":$source, "Value":$dest,
+    OpBuilder<(ins "Value":$source, "Value":$dest,
       "ArrayRef<OpFoldResult>":$offsets, "ArrayRef<OpFoldResult>":$sizes,
       "ArrayRef<OpFoldResult>":$strides,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
     // Build a SubTensorInsertOp with dynamic entries.
-    OpBuilderDAG<(ins "Value":$source, "Value":$dest,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$memref), [{
+    OpBuilder<(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();
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 = [
-    OpBuilderDAG<(ins "Value":$in, "AffineMapAttr":$permutation,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$value, "Type":$destType), [{
+    OpBuilder<(ins "Value":$value, "Type":$destType), [{
       $_state.addOperands(value);
       $_state.addTypes(destType);
     }]>];
 
   let parser = [{
     return impl::parseCastOp(parser, result);
   }];
   let printer = [{
```mlir
       %5 = zexti %0 : vector<2 x i32> to vector<2 x i64>
     ```
   }];
 
   let arguments = (ins SignlessIntegerLike:$value);
   let results = (outs SignlessIntegerLike);
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$value, "Type":$destType), [{
+    OpBuilder<(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/Tensor/IR/TensorOps.td

let description = [{
     ```
   }];
 
   let arguments = (ins AnyTensor:$tensor, Variadic<Index>:$indices);
   let results = (outs AnyType:$result);
   let assemblyFormat = "$tensor `[` $indices `]` attr-dict `:` type($tensor)";
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$tensor, CArg<"ValueRange", "{}">:$indices), [{
+    OpBuilder<(ins "Value":$tensor, CArg<"ValueRange", "{}">:$indices), [{
       auto resType = tensor.getType().cast<ShapedType>().getElementType();
       build($_builder, $_state, resType, tensor, indices);
     }]>];
 
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
def Tensor_FromElementsOp : Tensor_Op<"from_elements", [
 
   let assemblyFormat = "$elements attr-dict `:` type($result)";
 
   // This op is fully verified by its traits.
   let verifier = ?;
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilderDAG<(ins "Type":$elementType, "ValueRange":$elements)>,
+    OpBuilder<(ins "Type":$elementType, "ValueRange":$elements)>,
     // Special case builder for when `elements` has size >=1.
-    OpBuilderDAG<(ins "ValueRange":$elements)>
+    OpBuilder<(ins "ValueRange":$elements)>
   ];
 
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // GenerateOp
 //===----------------------------------------------------------------------===//
def Tensor_GenerateOp : Tensor_Op<"generate",
 
   let arguments = (ins Variadic<Index>:$dynamicExtents);
   let results = (outs AnyRankedTensor:$result);
   let regions = (region SizedRegion<1>:$body);
   let assemblyFormat = "$dynamicExtents $body attr-dict `:` type($result)";
 
   let builders = [
     // Build op and populate its body per callback function.
-    OpBuilderDAG<(ins "Type":$resultTy, "ValueRange":$dynamicExtents,
+    OpBuilder<(ins "Type":$resultTy, "ValueRange":$dynamicExtents,
       "function_ref<void(OpBuilder &, Location, ValueRange)>")>,
   ];
 
   let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // YieldOp
 //===----------------------------------------------------------------------===//
 
 def Tensor_YieldOp : Tensor_Op<"yield",
     [NoSideEffect, ReturnLike, Terminator,
      HasParent<"::mlir::tensor::GenerateOp">]> {
   let summary = "Yield a value from a region";
   let description = [{
      This operation is used to yield a single value from a within a region. It
      is used to create dynamically sized tensors
      (see `tensor.generate` op).
   }];
 
   let arguments = (ins AnyType:$value);
   let assemblyFormat = "$value attr-dict `:` type($value)";
   // Dummy builder to appease code in templated ensureTerminator that
   // GenerateOp's auto-generated parser calls.
-  let builders = [OpBuilderDAG<(ins), [{ /* nothing to do */ }]>];
+  let builders = [OpBuilder<(ins), [{ /* nothing to do */ }]>];
   let verifier = ?;
 }
 
 #endif // TENSOR_OPS

mlir/include/mlir/Dialect/Tosa/IR/TosaOpBase.td

 
 //===----------------------------------------------------------------------===//
 // TOSA Operator Quantization Builders.
 //===----------------------------------------------------------------------===//
 
 // This builder is called on all convolution operators except for TransposeConv,
 // which has specialized output shape semantics. The builder also defines the
 // bitwidth of the output given the bit width of the input & weight content.
-def Tosa_ConvOpQuantInfoBuilder : OpBuilderDAG<
+def Tosa_ConvOpQuantInfoBuilder : OpBuilder<
   (ins "Type":$outputType, "Value":$input, "Value":$weight, "Value":$bias,
        "ArrayAttr":$pad, "ArrayAttr":$stride, "ArrayAttr":$dilation),
   [{
     buildConvOpWithQuantInfo($_builder, $_state, outputType,
                              input, weight, bias,
                              pad, stride, dilation);
   }]>;
 
 // Handles tosa.transpose_conv2d which has an outpad and output shape attribute.
-def Tosa_TransConvOpQuantInfoBuilder : OpBuilderDAG<
+def Tosa_TransConvOpQuantInfoBuilder : OpBuilder<
   (ins "Type":$outputType, "Value":$input, "Value":$weight, "Value":$bias,
        "ArrayAttr":$outpad, "ArrayAttr":$stride, "ArrayAttr":$dilation,
        "ArrayAttr":$outputShape),
   [{
     buildTransConvOpWithQuantInfo($_builder, $_state, outputType,
                                   input, weight, bias,
                                   outpad, stride, dilation,
                                   outputShape);
   }]>;
 
 // The tosa.fully_connected op has its own builder as it does not have
 // strides/dilation/padding.
-def Tosa_FCOpQuantInfoBuilder : OpBuilderDAG<
+def Tosa_FCOpQuantInfoBuilder : OpBuilder<
   (ins "Type":$outputType, "Value":$input, "Value":$weight, "Value":$bias),
   [{
     buildFCOpWithQuantInfo($_builder, $_state, outputType,
                            input, weight, bias);
   }]>;
 
 // The tosa.matmul op is also intended to be generated where a fully_connected
 // op must be constructed where the weight is not a constant. In this case,
 // the fully_connected op must be expressed using matmul.
 // TODO: Add link to the leglization document explaining this.
-def Tosa_MatMulOpQuantInfoBuilder : OpBuilderDAG<
+def Tosa_MatMulOpQuantInfoBuilder : OpBuilder<
   (ins "Type":$outputType, "Value":$a, "Value":$b),
   [{
     buildMatMulOpWithQuantInfo($_builder, $_state, outputType,
                                a, b);
   }]>;
 
 // Both the tosa.avg_pool2d and unary ops use the same
 // UnaruOpQuantizationAttr but the avg_pool operator has its own builder as it
 // has additional parameters not part of the unary ops.
-def Tosa_AvgPool2dOpQuantInfoBuilder : OpBuilderDAG<
+def Tosa_AvgPool2dOpQuantInfoBuilder : OpBuilder<
   (ins "Type":$outputType, "Value":$input, "ArrayAttr":$kernel,
        "ArrayAttr":$stride, "ArrayAttr":$pad),
   [{
     buildAvgPool2dOpWithQuantInfo($_builder, $_state, outputType,
                                   input, kernel, stride, pad);
   }]>;
 
 // This builder is called on single-parameter unary operators that have a scale
 // relationship between their input and output, expressed by the
 // UnaryOpQuantizationAttr.
-def Tosa_UnaryOpQuantInfoBuilder : OpBuilderDAG<
+def Tosa_UnaryOpQuantInfoBuilder : OpBuilder<
   (ins "Type":$outputType, "Value":$input),
   [{
     buildUnaryOpWithQuantInfo($_builder, $_state, outputType, input);
   }]>;
 
 // This builder is called on the TOSA pad operator that needs to create its own
 // OptionalAttr quantization_attr parameter to scale the padding values
 // correctly.
-def Tosa_PadOpQuantInfoBuilder : OpBuilderDAG<
+def Tosa_PadOpQuantInfoBuilder : OpBuilder<
   (ins "Type":$outputType, "Value":$input, "Value":$paddings),
   [{
     buildPadOpWithQuantInfo($_builder, $_state, outputType,
                             input, paddings);
   }]>;
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator.
 //===----------------------------------------------------------------------===//
 
 class Tosa_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Tosa_Dialect, mnemonic, !listconcat(traits, [TosaOpInterface])> {
 }
 
 #endif // TOSA_OP_BASE

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

#contraction_trait = {
       iterator_types = ["reduction"],
       kind = #vector.kind<max>
     }
     %7 = vector.contract #contraction_trait %0, %1, %2
       : vector<10xf32>, vector<10xf32> into f32
     ```
   }];
   let builders = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs, "Value":$acc,
+    OpBuilder<(ins "Value":$lhs, "Value":$rhs, "Value":$acc,
       "ArrayAttr":$indexingMaps, "ArrayAttr":$iteratorTypes)>,
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs, "Value":$acc,
+    OpBuilder<(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() {
%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 = [
-    OpBuilderDAG<(ins "Value":$v1, "Value":$v2, "ArrayRef<int64_t>")>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$source, "int64_t":$position)>,
-    OpBuilderDAG<(ins "Value":$source, "Value":$position)>
+    OpBuilder<(ins "Value":$source, "int64_t":$position)>,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$source, "ArrayRef<int64_t>":$position)>,
+    OpBuilder<(ins "Value":$source, "ArrayRef<int64_t>":$position)>,
     // Convenience builder which assumes the values in `position` are defined by
     // ConstantIndexOp.
-    OpBuilderDAG<(ins "Value":$source, "ValueRange":$position)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "TupleType":$tupleType, "Value":$vector,
+    OpBuilder<(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 = [{
 
     ```mlir
     %ev = vector.extract_map %v[%id] : vector<32xf32> to vector<1xf32>
     %ev1 = vector.extract_map %v1[%id1, %id2] : vector<64x4x32xf32>
       to vector<4x4x2xf32>
     ```
   }];
   let builders = [
-    OpBuilderDAG<(ins "Value":$vector, "ValueRange":$ids,
+    OpBuilder<(ins "Value":$vector, "ValueRange":$ids,
                   "ArrayRef<int64_t>":$multiplicity,
                   "AffineMap":$map)>];
   let extraClassDeclaration = [{
     VectorType getSourceVectorType() {
       return vector().getType().cast<VectorType>();
     }
     VectorType getResultType() {
       return getResult().getType().cast<VectorType>();
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 = [
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs, "Value":$acc),
+    OpBuilder<(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 :
let description = [{
     ```
   }];
   let assemblyFormat = [{
     $source `,` $dest `[` $position `:` type($position) `]` attr-dict `:`
     type($result)
   }];
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$source, "Value":$dest, "int64_t":$position)>,
-    OpBuilderDAG<(ins "Value":$source, "Value":$dest, "Value":$position)>
+    OpBuilder<(ins "Value":$source, "Value":$dest, "int64_t":$position)>,
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$source, "Value":$dest,
+    OpBuilder<(ins "Value":$source, "Value":$dest,
       "ArrayRef<int64_t>":$position)>,
     // Convenience builder which assumes all values are constant indices.
-    OpBuilderDAG<(ins "Value":$source, "Value":$dest, "ValueRange":$position)>
+    OpBuilder<(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 = [{
     Example:
 
     ```mlir
     %v = vector.insert_map %ev %v[%id] : vector<1xf32> into vector<32xf32>
     %v1 = vector.insert_map %ev1, %v1[%arg0, %arg1] : vector<2x4x1xf32>
       into vector<64x4x32xf32>
     ```
   }];
-  let builders = [OpBuilderDAG<(ins "Value":$vector, "Value":$dest,
+  let builders = [OpBuilder<(ins "Value":$vector, "Value":$dest,
                                 "ValueRange":$ids)>];
   let extraClassDeclaration = [{
     VectorType getSourceVectorType() {
       return vector().getType().cast<VectorType>();
     }
     VectorType getResultType() {
       return getResult().getType().cast<VectorType>();
     }
let description = [{
     ```
   }];
 
   let assemblyFormat = [{
     $source `,` $dest attr-dict `:` type($source) `into` type($dest)
   }];
 
   let builders = [
-    OpBuilderDAG<(ins "Value":$source, "Value":$dest,
+    OpBuilder<(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>();
     }
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.
-    OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs, "Value":$acc)>
+    OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$source, "ArrayRef<int64_t>":$offsets,
+    OpBuilder<(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)}
         : tensor<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>
     ```
   }];
 
   let builders = [
     // Builder that sets padding to zero.
-    OpBuilderDAG<(ins "VectorType":$vector, "Value":$source,
+    OpBuilder<(ins "VectorType":$vector, "Value":$source,
       "ValueRange":$indices, "AffineMap":$permutationMap,
       CArg<"ArrayRef<bool>", "{}">:$maybeMasked)>,
     // Builder that sets padding to 'getMinorIdentityMap'.
-    OpBuilderDAG<(ins "VectorType":$vector, "Value":$source,
+    OpBuilder<(ins "VectorType":$vector, "Value":$source,
       "ValueRange":$indices, "Value":$padding,
       CArg<"ArrayRef<bool>", "{}">:$maybeMasked)>,
     // Builder that sets permutation map (resp. padding) to
     // 'getMinorIdentityMap' (resp. zero).
-    OpBuilderDAG<(ins "VectorType":$vector, "Value":$source,
+    OpBuilder<(ins "VectorType":$vector, "Value":$source,
       "ValueRange":$indices, CArg<"ArrayRef<bool>", "{}">:$maybeMasked)>
   ];
 
   let hasFolder = 1;
 }
 
 def Vector_TransferWriteOp :
   Vector_Op<"transfer_write", [
let description = [{
     %5 = vector.transfer_write %4, %arg1[%c3, %c3]
       {permutation_map = (d0, d1)->(d0, d1)}
         : vector<1x1x4x3xf32>, tensor<?x?xvector<4x3xf32>>
     ```
   }];
 
   let builders = [
     // Builder that sets permutation map to 'getMinorIdentityMap'.
-    OpBuilderDAG<(ins "Value":$vector, "Value":$source, "ValueRange":$indices,
+    OpBuilder<(ins "Value":$vector, "Value":$source, "ValueRange":$indices,
       CArg<"ArrayRef<bool>", "{}">:$maybeMasked)>,
-    OpBuilderDAG<(ins "Value":$vector, "Value":$source, "ValueRange":$indices,
+    OpBuilder<(ins "Value":$vector, "Value":$source, "ValueRange":$indices,
       "AffineMap":$permutationMap)>,
-    OpBuilderDAG<(ins "Value":$vector, "Value":$source, "ValueRange":$indices,
+    OpBuilder<(ins "Value":$vector, "Value":$source, "ValueRange":$indices,
       "AffineMapAttr":$permutationMap, "ArrayAttr":$masked)>,
-    OpBuilderDAG<(ins "Value":$vector, "Value":$source, "ValueRange":$indices,
+    OpBuilder<(ins "Value":$vector, "Value":$source, "ValueRange":$indices,
       "AffineMap":$permutationMap, "ArrayAttr":$masked)>,
   ];
 
   let hasFolder = 1;
 }
 
 def Vector_LoadOp : Vector_Op<"load"> {
   let summary = "reads an n-D slice of memory into an n-D vector";
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 = [OpBuilderDAG<(ins "Value":$source)>];
+  let builders = [OpBuilder<(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 = [
-    OpBuilderDAG<(ins "Value":$vector, "ArrayRef<int64_t>":$transp)>
+    OpBuilder<(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 = [
-   OpBuilderDAG<(ins "Value":$lhs, "Value":$rhs, "unsigned":$lhsRows,
+   OpBuilder<(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/include/mlir/IR/BuiltinOps.td

let description = [{
     ```
   }];
 
   let arguments = (ins SymbolNameAttr:$sym_name,
                        TypeAttr:$type,
                        OptionalAttr<StrAttr>:$sym_visibility);
   let regions = (region AnyRegion:$body);
 
-  let builders = [OpBuilderDAG<(ins
+  let builders = [OpBuilder<(ins
     "StringRef":$name, "FunctionType":$type,
     CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
     CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)
   >];
   let extraClassDeclaration = [{
     static FuncOp create(Location location, StringRef name, FunctionType type,
                          ArrayRef<NamedAttribute> attrs = {});
     static FuncOp create(Location location, StringRef name, FunctionType type,
let description = [{
     ```
   }];
 
   let arguments = (ins OptionalAttr<SymbolNameAttr>:$sym_name,
                        OptionalAttr<StrAttr>:$sym_visibility);
   let regions = (region SizedRegion<1>:$body);
 
   let assemblyFormat = "($sym_name^)? attr-dict-with-keyword $body";
-  let builders = [OpBuilderDAG<(ins CArg<"Optional<StringRef>", "{}">:$name)>];
+  let builders = [OpBuilder<(ins CArg<"Optional<StringRef>", "{}">:$name)>];
   let extraClassDeclaration = [{
     /// Construct a module from the given location with an optional name.
     static ModuleOp create(Location loc, Optional<StringRef> name = llvm::None);
 
     /// Return the name of this module if present.
     Optional<StringRef> getName() { return sym_name(); }
 
     //===------------------------------------------------------------------===//

mlir/include/mlir/IR/OpBase.td

 // The type string is used verbatim to produce code and, therefore, must be a
 // valid C++ type. It is used inside the C++ namespace of the parent Op's
 // dialect; explicit namespace qualification like `::mlir` may be necessary if
 // Ops are not placed inside the `mlir` namespace. The default value string is
 // used verbatim to produce code and must be a valid C++ initializer the given
 // type. For example, the following signature specification
 //
 // ```
-// OpBuilderDAG<(ins "int":$integerArg, CArg<"float", "3.0f">:$floatArg)>
+// OpBuilder<(ins "int":$integerArg, CArg<"float", "3.0f">:$floatArg)>
 // ```
 //
 // has an integer parameter and a float parameter with a default value.
 //
 // If an empty string is passed in for `body`, then *only* the builder
 // declaration will be generated; this provides a way to define complicated
 // builders entirely in C++.
-class OpBuilderDAG<dag p, code b = ""> {
+class OpBuilder<dag p, code b = ""> {
   dag dagParams = p;
   code body = b;
 }
 
 // A base decorator class that may optionally be added to OpVariables.
 class OpVariableDecorator;
 
 // Class for providing additional information on the variables, i.e. arguments
class Op<Dialect dialect, string mnemonic, list<OpTrait> props = []> {
   // * where the attributes follow the same declaration order as in the op.
   //
   // ```c++
   // static void build(OpBuilder &, OperationState &odsState,
   //                   TypeRange resultTypes,
   //                   ValueRange operands,
   //                   ArrayRef<NamedAttribute> attributes);
   // ```
-  list<OpBuilderDAG> builders = ?;
+  list<OpBuilder> builders = ?;
 
   // Avoid generating default build functions.  Custom builders must be
   // provided.
   bit skipDefaultBuilders = 0;
 
   // Custom parser.
   code parser = ?;
 

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 = [OpBuilderDAG<(ins "FuncOp":$function)>];
+  let builders = [OpBuilder<(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 = [
-    OpBuilderDAG<(ins "IntegerAttr":$count),
+    OpBuilder<(ins "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);
     }]>

 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 = [OpBuilderDAG<(ins),
+  let builders = [OpBuilder<(ins),
     [{
        Region *bodyRegion = $_state.addRegion();
        OpBuilder::InsertionGuard g($_builder);
        Block *body = $_builder.createBlock(bodyRegion);
        $_builder.setInsertionPointToEnd(body);
        $_builder.create<IllegalOpTerminator>($_state.location);
     }]>];
 }

 
 //===----------------------------------------------------------------------===//
 // Test Type Legalization
 //===----------------------------------------------------------------------===//
 
 def TestRegionBuilderOp : TEST_Op<"region_builder">;
 def TestReturnOp : TEST_Op<"return", [ReturnLike, Terminator]> {
   let arguments = (ins Variadic<AnyType>);
-  let builders = [OpBuilderDAG<(ins),
+  let builders = [OpBuilder<(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">,
def RegionYieldOp : TEST_Op<"region_yield",
   let description = [{
     This operation is used in a region and yields the corresponding type for
     that operation.
   }];
   let arguments = (ins AnyType:$result);
   let assemblyFormat = [{
     $result `:` type($result) attr-dict
   }];
-  let builders = [OpBuilderDAG<(ins),
+  let builders = [OpBuilder<(ins),
     [{ build($_builder, $_state, {}); }]>
   ];
 }
 
 class BufferBasedOpBase<string mnemonic, list<OpTrait> traits>
     : TEST_Op<mnemonic, traits> {
   let description = [{
     A buffer based operation, that uses memRefs as input and output.

mlir/test/mlir-linalg-ods-gen/test-linalg-ods-gen.tc

 It has one output.
 """
 {
   C(m) = std_addf<k>(C(m), std_mulf(A(m, k), B(k)));
 }
 
 // Test attribute builder
 // ODS-LABEL: def Test7Op
-// ODS:         OpBuilderDAG<
+// ODS:         OpBuilder<
 // ODS:           (ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
 // ODS:            "ValueRange":$outputs, "Attribute":$attr_a, "Attribute":$attr_b)
 // ODS:           $_state.addAttribute("attr_a", attr_a);
 // ODS:           $_state.addAttribute("attr_b", attr_b);
 //
 ods_def<Test7Op>:
 def test7(A: f32(M, K), B: f32(K)) -> (C: f32(M))
      attr(attr_a: f32, attr_b: 4xi32)

mlir/test/mlir-tblgen/op-decl-and-defs.td

let results = (outs
     I32:$r,
     Variadic<F32>:$s
   );
 
   let regions = (region
     AnyRegion:$someRegion,
     VariadicRegion<AnyRegion>:$someRegions
   );
-  let builders = [OpBuilderDAG<(ins "Value":$val)>,
-                  OpBuilderDAG<(ins CArg<"int", "0">:$integer)>];
+  let builders = [OpBuilder<(ins "Value":$val)>,
+                  OpBuilder<(ins CArg<"int", "0">:$integer)>];
   let parser = [{ foo }];
   let printer = [{ bar }];
   let verifier = [{ baz }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 
   let extraClassDeclaration = [{

 // CHECK:     class ResultWithDialectTypeOp :
 // CHECK-SAME: ::mlir::OpTrait::OneTypedResult<::mlir::dialect2::Dialect2TypeType>
 
 // Check that default builders can be suppressed.
 // ---
 
 def NS_SkipDefaultBuildersOp : NS_Op<"skip_default_builders", []> {
   let skipDefaultBuilders = 1;
-  let builders = [OpBuilderDAG<(ins "Value":$val)>];
+  let builders = [OpBuilder<(ins "Value":$val)>];
 }
 
 // CHECK-LABEL: NS::SkipDefaultBuildersOp declarations
 // CHECK:     class SkipDefaultBuildersOp
 // CHECK-NOT:   static void build(::mlir::Builder
 // CHECK:       static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, Value
 
 // Check leading underscore in op name

mlir/test/mlir-tblgen/op-error.td

 // RUN: not mlir-tblgen -gen-op-decls -I %S/../../include -DERROR1 %s 2>&1 | FileCheck --check-prefix=ERROR1 %s
 // RUN: not mlir-tblgen -gen-op-decls -I %S/../../include -DERROR2 %s 2>&1 | FileCheck --check-prefix=ERROR2 %s
 // RUN: not mlir-tblgen -gen-op-decls -I %S/../../include -DERROR3 %s 2>&1 | FileCheck --check-prefix=ERROR3 %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test_dialect";
 }
 
 #ifdef ERROR1
 // ERROR1: error: expected 'ins'
 def OpInsMissing : Op<Test_Dialect, "ins_missing"> {
   let builders = [
-    OpBuilderDAG<(outs)>
+    OpBuilder<(outs)>
   ];
 }
 #endif
 
 #ifdef ERROR2
 // ERROR2: error: expected an argument with default value after other arguments with default values
 def OpDefaultValueNotTrailing : Op<Test_Dialect, "default_value"> {
   let builders = [
-    OpBuilderDAG<(ins CArg<"int", "42">, "int")>
+    OpBuilder<(ins CArg<"int", "42">, "int")>
   ];
 }
 #endif
 
 #ifdef ERROR3
 // ERROR3: error: expected an argument with default value after other arguments with default values
 def OpDefaultValueNotTrailing : Op<Test_Dialect, "default_value"> {
   let builders = [
-    OpBuilderDAG<(ins CArg<"int", "42">, CArg<"int">)>
+    OpBuilder<(ins CArg<"int", "42">, CArg<"int">)>
   ];
 }
 #endif

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

/*extraInterfaces=*/{2}]> {
         Variadic<AnyShaped>:$inputs,
         Variadic<AnyShaped>:$outputs{4}
       );
       let results = (outs Variadic<AnyRankedTensor>:$result_tensors);
       let regions = (region AnyRegion:$region);
 
       let skipDefaultBuilders = 1;
       let builders = [
-        OpBuilderDAG<
+        OpBuilder<
         (ins "ValueRange":$inputs, "ValueRange":$outputs),
         [{{
           $_state.addOperands(inputs);
           $_state.addOperands(outputs);
           $_state.addAttribute(
             "operand_segment_sizes",
             $_builder.getI32VectorAttr({{
               static_cast<int32_t>(inputs.size()),
               static_cast<int32_t>(outputs.size())}));
           createAndFillStructuredOpRegion<{0}>(
             $_builder,
             $_state,
             TypeRange(inputs),
             TypeRange(outputs)/*, TODO: support captures*/);
         }]>,
-        OpBuilderDAG<
+        OpBuilder<
         (ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
              "ValueRange":$outputs),
         [{{
           $_state.addOperands(inputs);
           $_state.addOperands(outputs);
           $_state.addTypes(resultTensorTypes);
           $_state.addAttribute(
             "operand_segment_sizes",
             $_builder.getI32VectorAttr({{
               static_cast<int32_t>(inputs.size()),
               static_cast<int32_t>(outputs.size())}));
           createAndFillStructuredOpRegion<{0}>(
             $_builder,
             $_state,
             TypeRange(inputs),
             TypeRange(outputs)/*, TODO: support captures*/);
         }]>,
-        OpBuilderDAG<
+        OpBuilder<
         (ins "TypeRange":$resultTensorTypes, "ValueRange":$operands,
              CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
         [{{
           $_state.addOperands(operands);
           $_state.addAttributes(attributes);
           $_state.addTypes(resultTensorTypes);
           (void)$_state.addRegion();
         }]>
for (const auto &attr : registeredAttrs) {
       attrParams.push_back(llvm::formatv("\"Attribute\":${0}", name));
       attrStmts.push_back(
           llvm::formatv("$_state.addAttribute(\"{0}\", {0});", name));
     }
     std::string attrParamsList = llvm::join(attrParams, ", ");
     std::string attrStmtsList = llvm::join(attrStmts, "\n");
 
     const char *builderFmt = R"FMT(
-      , OpBuilderDAG<
+      , OpBuilder<
       (ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
            "ValueRange":$outputs, {1}),
       [{{
         $_state.addOperands(inputs);
         $_state.addOperands(outputs);
         $_state.addTypes(resultTensorTypes);
         $_state.addAttribute(
           "operand_segment_sizes",

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

let arguments = (ins
       Variadic<AnyShaped>:$inputs,
       Variadic<AnyShaped>:$outputs{4}
     );
     let results = (outs Variadic<AnyRankedTensor>:$result_tensors);
     let regions = (region AnyRegion:$region);
 
     let skipDefaultBuilders = 1;
     let builders = [
-      OpBuilderDAG<
+      OpBuilder<
       (ins "ValueRange":$inputs, "ValueRange":$outputs),
       [{{
         $_state.addOperands(inputs);
         $_state.addOperands(outputs);
         $_state.addAttribute(
           "operand_segment_sizes",
           $_builder.getI32VectorAttr({{
             static_cast<int32_t>(inputs.size()),
             static_cast<int32_t>(outputs.size())}));
         createAndFillStructuredOpRegion<{0}>(
           $_builder,
           $_state,
           TypeRange(inputs),
           TypeRange(outputs)/*, TODO: support captures*/);
       }]>,
-      OpBuilderDAG<
+      OpBuilder<
       (ins "TypeRange":$resultTensorTypes, "ValueRange":$inputs,
             "ValueRange":$outputs),
       [{{
         $_state.addOperands(inputs);
         $_state.addOperands(outputs);
         $_state.addTypes(resultTensorTypes);
         $_state.addAttribute(
           "operand_segment_sizes",
           $_builder.getI32VectorAttr({{
             static_cast<int32_t>(inputs.size()),
             static_cast<int32_t>(outputs.size())}));
         createAndFillStructuredOpRegion<{0}>(
           $_builder,
           $_state,
           TypeRange(inputs),
           TypeRange(outputs)/*, TODO: support captures*/);
       }]>,
-      OpBuilderDAG<
+      OpBuilder<
       (ins "TypeRange":$resultTensorTypes, "ValueRange":$operands,
             CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
       [{{
         $_state.addOperands(operands);
         $_state.addAttributes(attributes);
         $_state.addTypes(resultTensorTypes);
         (void)$_state.addRegion();
       }]>