[flang] update ODS syntax to use OpBuidlerDAG instead of OpBuilder

[ftynse]

Summary

Upstream MLIR has deprecated OpBuilder in ODS.

[ftynse]

Ping.

This updates the code to avoid using a deprecated API that will be removed soon.

[schweitz]

Looks good. Thanks for doing this.

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 : OpBuilder<
-  "OpBuilder &builder, OperationState &result, Type inType,"
-  "ValueRange lenParams = {}, ValueRange sizes = {},"
-  "ArrayRef<NamedAttribute> attributes = {}",
+def fir_AllocateOpBuilder :
+  OpBuilderDAG<(ins "Type":$inType, CArg<"ValueRange", "{}">:$lenParams,
+    CArg<"ValueRange", "{}">:$sizes,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
-    result.addTypes(getRefTy(inType));
-    result.addAttribute("in_type", TypeAttr::get(inType));
-    result.addOperands(sizes);
-    result.addAttributes(attributes);
+    $_state.addTypes(getRefTy(inType));
+    $_state.addAttribute("in_type", TypeAttr::get(inType));
+    $_state.addOperands(sizes);
+    $_state.addAttributes(attributes);
   }]>;
 
-def fir_NamedAllocateOpBuilder : OpBuilder<
-  "OpBuilder &builder, OperationState &result, Type inType, StringRef name,"
-  "ValueRange lenParams = {}, ValueRange sizes = {},"
-  "ArrayRef<NamedAttribute> attributes = {}",
+def fir_NamedAllocateOpBuilder :
+  OpBuilderDAG<(ins "Type":$inType, "StringRef":$name,
+    CArg<"ValueRange", "{}">:$lenParams, CArg<"ValueRange", "{}">:$sizes,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
-    result.addTypes(getRefTy(inType));
-    result.addAttribute("in_type", TypeAttr::get(inType));
-    result.addAttribute("name", builder.getStringAttr(name));
-    result.addOperands(sizes);
-    result.addAttributes(attributes);
+    $_state.addTypes(getRefTy(inType));
+    $_state.addAttribute("in_type", TypeAttr::get(inType));
+    $_state.addAttribute("name", $_builder.getStringAttr(name));
+    $_state.addOperands(sizes);
+    $_state.addAttributes(attributes);
   }]>;
 
-def fir_OneResultOpBuilder : OpBuilder<
-  "OpBuilder &, OperationState &result, Type resultType,"
-  "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
+def fir_OneResultOpBuilder :
+  OpBuilderDAG<(ins "Type":$resultType, "ValueRange":$operands,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
   [{
     if (resultType)
-      result.addTypes(resultType);
-    result.addOperands(operands);
-    result.addAttributes(attributes);
+      $_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<OpBuilder b1, OpBuilder b2> {
-  list<OpBuilder> builders = [b1, b2];
+class fir_TwoBuilders<OpBuilderDAG b1, OpBuilderDAG b2> {
+  list<OpBuilderDAG> 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 AnyReferenceLike:$memref);
 
-  let builders = [OpBuilder<
-    "OpBuilder &builder, OperationState &result, Value refVal",
+  let builders = [
+    OpBuilderDAG<(ins "Value":$refVal),
     [{
       if (!refVal) {
-        mlir::emitError(result.location, "LoadOp has null argument");
+        mlir::emitError($_state.location, "LoadOp has null argument");
         return;
       }
       auto refTy = refVal.getType().cast<fir::ReferenceType>();
-      result.addOperands(refVal);
-      result.addTypes(refTy.getEleTy());
-    }]
-  >];
+      $_state.addOperands(refVal);
+      $_state.addTypes(refTy.getEleTy());
+    }]>];
 
   let parser = [{
     mlir::Type type;
     mlir::OpAsmParser::OperandType oper;
     if (parser.parseOperand(oper) ||
         parser.parseOptionalAttrDict(result.attributes) ||
         parser.parseColonType(type) ||
         parser.resolveOperand(oper, type, result.operands))
string extraSwitchClassDeclaration = [{
     unsigned targetOffsetSize();
   }];
 }
 
 class fir_IntegralSwitchTerminatorOp<string mnemonic,
     list<OpTrait> traits = []> : fir_SwitchTerminatorOp<mnemonic, traits> {
 
   let skipDefaultBuilders = 1;
-  let builders = [OpBuilder<
-    "OpBuilder &builder, OperationState &result, Value selector,"
-    "ArrayRef<int64_t> compareOperands, ArrayRef<Block *> destinations,"
-    "ArrayRef<ValueRange> destOperands = {},"
-    "ArrayRef<NamedAttribute> attributes = {}",
+  let builders = [
+    OpBuilderDAG<(ins "Value":$selector, "ArrayRef<int64_t>":$compareOperands,
+      "ArrayRef<Block *>":$destinations,
+      CArg<"ArrayRef<ValueRange>", "{}">:$destOperands,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
     [{
-      result.addOperands(selector);
+      $_state.addOperands(selector);
       llvm::SmallVector<mlir::Attribute, 8> ivalues;
       for (auto iv : compareOperands)
-        ivalues.push_back(builder.getI64IntegerAttr(iv));
-      ivalues.push_back(builder.getUnitAttr());
-      result.addAttribute(getCasesAttr(), builder.getArrayAttr(ivalues));
+        ivalues.push_back($_builder.getI64IntegerAttr(iv));
+      ivalues.push_back($_builder.getUnitAttr());
+      $_state.addAttribute(getCasesAttr(), $_builder.getArrayAttr(ivalues));
       const auto count = destinations.size();
       for (auto d : destinations)
-        result.addSuccessors(d);
+        $_state.addSuccessors(d);
       const auto opCount = destOperands.size();
       llvm::SmallVector<int32_t, 8> argOffs;
       int32_t sumArgs = 0;
       for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
         if (i < opCount) {
-          result.addOperands(destOperands[i]);
+          $_state.addOperands(destOperands[i]);
           const auto argSz = destOperands[i].size();
           argOffs.push_back(argSz);
           sumArgs += argSz;
         } else {
           argOffs.push_back(0);
         }
       }
-      result.addAttribute(getOperandSegmentSizeAttr(),
-                          builder.getI32VectorAttr({1, 0, sumArgs}));
-      result.addAttribute(getTargetOffsetAttr(),
-                          builder.getI32VectorAttr(argOffs));
-      result.addAttributes(attributes);
-    }]
-  >];
+      $_state.addAttribute(getOperandSegmentSizeAttr(),
+                          $_builder.getI32VectorAttr({1, 0, sumArgs}));
+      $_state.addAttribute(getTargetOffsetAttr(),
+                          $_builder.getI32VectorAttr(argOffs));
+      $_state.addAttributes(attributes);
+    }]>];
 
   let parser = [{
     mlir::OpAsmParser::OperandType selector;
     mlir::Type type;
     if (parseSelector(parser, result, selector, type))
       return mlir::failure();
 
     llvm::SmallVector<mlir::Attribute, 8> ivalues;
```mlir
             #fir.interval, %2, %3, ^bb3(%2,%arg2 : i32,i32),
             #fir.upper, %arg, ^bb4(%1 : i32),
             unit, ^bb5]
     ```
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"OpBuilder &builder, OperationState &result, Value selector,"
-    "ArrayRef<mlir::Attribute> compareAttrs, ArrayRef<ValueRange> cmpOperands,"
-    "ArrayRef<Block *> destinations, ArrayRef<ValueRange> destOperands = {},"
-    "ArrayRef<NamedAttribute> attributes = {}">,
-    OpBuilder<"OpBuilder &builder, OperationState &result, Value selector,"
-    "ArrayRef<mlir::Attribute> compareAttrs, ArrayRef<Value> cmpOpList,"
-    "ArrayRef<Block *> destinations, ArrayRef<ValueRange> destOperands = {},"
-    "ArrayRef<NamedAttribute> attributes = {}">];
+    OpBuilderDAG<(ins "Value":$selector,
+      "ArrayRef<mlir::Attribute>":$compareAttrs,
+      "ArrayRef<ValueRange>":$cmpOperands, "ArrayRef<Block *>":$destinations,
+      CArg<"ArrayRef<ValueRange>", "{}">:$destOperands,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>,
+    OpBuilderDAG<(ins "Value":$selector,
+      "ArrayRef<mlir::Attribute>":$compareAttrs, "ArrayRef<Value>":$cmpOpList,
+      "ArrayRef<Block *>":$destinations,
+      CArg<"ArrayRef<ValueRange>", "{}">:$destOperands,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>];
 
   let parser = "return parseSelectCase(parser, result);";
 
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
     p << " : " << getSelector().getType() << " [";
     auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
```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 = [OpBuilder<
-    "OpBuilder &builder, OperationState &result, Value selector,"
-    "ArrayRef<mlir::Attribute> typeOperands,"
-    "ArrayRef<Block *> destinations, ArrayRef<ValueRange> destOperands = {},"
-    "ArrayRef<NamedAttribute> attributes = {}",
+  let builders = [
+    OpBuilderDAG<(ins "Value":$selector,
+      "ArrayRef<mlir::Attribute>":$typeOperands,
+      "ArrayRef<Block *>":$destinations,
+      CArg<"ArrayRef<ValueRange>", "{}">:$destOperands,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes),
     [{
-      result.addOperands(selector);
-      result.addAttribute(getCasesAttr(), builder.getArrayAttr(typeOperands));
+      $_state.addOperands(selector);
+      $_state.addAttribute(getCasesAttr(), $_builder.getArrayAttr(typeOperands));
       const auto count = destinations.size();
       for (auto d : destinations)
-        result.addSuccessors(d);
+        $_state.addSuccessors(d);
       const auto opCount = destOperands.size();
       llvm::SmallVector<int32_t, 8> argOffs;
       int32_t sumArgs = 0;
       for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
         if (i < opCount) {
-          result.addOperands(destOperands[i]);
+          $_state.addOperands(destOperands[i]);
           const auto argSz = destOperands[i].size();
           argOffs.push_back(argSz);
           sumArgs += argSz;
         } else {
           argOffs.push_back(0);
         }
       }
-      result.addAttribute(getOperandSegmentSizeAttr(),
-                          builder.getI32VectorAttr({1, 0, sumArgs}));
-      result.addAttribute(getTargetOffsetAttr(),
-                          builder.getI32VectorAttr(argOffs));
-      result.addAttributes(attributes);
-    }]
-  >];
+      $_state.addAttribute(getOperandSegmentSizeAttr(),
+                          $_builder.getI32VectorAttr({1, 0, sumArgs}));
+      $_state.addAttribute(getTargetOffsetAttr(),
+                          $_builder.getI32VectorAttr(argOffs));
+      $_state.addAttributes(attributes);
+    }]>];
 
   let parser = "return parseSelectType(parser, result);";
 
   let printer = [{
     p << getOperationName() << ' ';
     p.printOperand(getSelector());
     p << " : " << getSelector().getType() << " [";
     auto cases = getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
let verifier = [{
     } else {
       return emitOpError("must have base type");
     }
     return mlir::success();
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
-              "Type type, Value ref, ValueRange coor,"
-        "ArrayRef<NamedAttribute> attrs = {}">,
-    OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
-              "Type type, ValueRange operands,"
-        "ArrayRef<NamedAttribute> attrs = {}">];
+    OpBuilderDAG<(ins "Type":$type, "Value":$ref, "ValueRange":$coor,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+    OpBuilderDAG<(ins "Type":$type, "ValueRange":$operands,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
         
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef baseType() { return "base_type"; }
     mlir::Type getBaseType();
   }];
 }
 
 def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]> {
if (getNumOperands()) {
           p.printType(op.getType());
         else
           p << "()";
         sep = ", ";
       }
     }
   }];
 
-  let builders = [OpBuilder<
-    "OpBuilder &builder, OperationState &result, StringRef fieldName,"
-    "Type recTy, ValueRange operands = {}",
+  let builders = [
+    OpBuilderDAG<(ins "StringRef":$fieldName, "Type":$recTy,
+      CArg<"ValueRange", "{}">:$operands),
     [{
-      result.addAttribute(fieldAttrName(), builder.getStringAttr(fieldName));
-      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
-      result.addOperands(operands);
-    }]
-  >];
+      $_state.addAttribute(fieldAttrName(), $_builder.getStringAttr(fieldName));
+      $_state.addAttribute(typeAttrName(), TypeAttr::get(recTy));
+      $_state.addOperands(operands);
+    }]>];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
     static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
   }];
 }
 
 def fir_GenDimsOp : fir_OneResultOp<"gendims", [NoSideEffect]> {
def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
   }];
 
   let printer = [{
     p << getOperationName() << ' '
       << getAttrOfType<mlir::StringAttr>(fieldAttrName()).getValue() << ", "
       << getAttr(typeAttrName());
   }];
 
-  let builders = [OpBuilder<
-    "OpBuilder &builder, OperationState &result, StringRef fieldName, Type recTy",
+  let builders = [
+    OpBuilderDAG<(ins "StringRef":$fieldName, "Type":$recTy),
     [{
-      result.addAttribute(fieldAttrName(), builder.getStringAttr(fieldName));
-      result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
-    }]
-  >];
+      $_state.addAttribute(fieldAttrName(), $_builder.getStringAttr(fieldName));
+      $_state.addAttribute(typeAttrName(), TypeAttr::get(recTy));
+    }]>];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
     static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
     mlir::Type getOnType() {
       return getAttrOfType<TypeAttr>(typeAttrName()).getValue();
     }
   }];
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 = [
-    OpBuilder<"OpBuilder &builder, OperationState &result", "/* do nothing */">
+    OpBuilderDAG<(ins),
+    [{/* do nothing */}]>
   ];
 
   let assemblyFormat = "($results^ `:` type($results))? attr-dict";
 
   let verifier = [{ return ::verify(*this); }];
 }
 
 def FirRegionTerminator : SingleBlockImplicitTerminator<"ResultOp">;
def fir_LoopOp : region_Op<"do_loop",
   );
   let results = (outs
     Variadic<AnyType>:$results
   );
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
-              "mlir::Value lowerBound, mlir::Value upperBound,"
-              "mlir::Value step, bool unordered = false,"
-              "ValueRange iterArgs = llvm::None,"
-              "ArrayRef<NamedAttribute> attributes = {}">
+    OpBuilderDAG<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
+      "mlir::Value":$step, CArg<"bool", "false">:$unordered,
+      CArg<"ValueRange", "llvm::None">:$iterArgs,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
   ];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef unorderedAttrName() { return "unordered"; }
 
     mlir::Value getInductionVar() { return getBody()->getArgument(0); }
     mlir::OpBuilder getBodyBuilder() {
       return OpBuilder(getBody(), std::prev(getBody()->end()));
def fir_WhereOp : region_Op<"if", [NoRegionArguments]> {
 
   let regions = (region
     SizedRegion<1>:$whereRegion,
     AnyRegion:$otherRegion
   );
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"OpBuilder &builder, OperationState &result, "
-              "Value cond, bool withOtherRegion">,
-    OpBuilder<"OpBuilder &builder, OperationState &result, "
-              "TypeRange resultTypes, Value cond, bool withOtherRegion">
+    OpBuilderDAG<(ins "Value":$cond, "bool":$withOtherRegion)>,
+    OpBuilderDAG<(ins "TypeRange":$resultTypes, "Value":$cond,
+      "bool":$withOtherRegion)>
   ];
 
   let extraClassDeclaration = [{
     mlir::OpBuilder getWhereBodyBuilder() {
       assert(!whereRegion().empty() && "Unexpected empty 'where' region.");
       mlir::Block &body = whereRegion().front();
       return mlir::OpBuilder(&body, std::prev(body.end()));
     }
def fir_IterWhileOp : region_Op<"iterate_while",
   let results = (outs
     I1:$iterateResult,
     Variadic<AnyType>:$results
   );
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
-              "mlir::Value lowerBound, mlir::Value upperBound,"
-        "mlir::Value step, mlir::Value iterate,"
-              "ValueRange iterArgs = llvm::None,"
-              "ArrayRef<NamedAttribute> attributes = {}">
+    OpBuilderDAG<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
+      "mlir::Value":$step, "mlir::Value":$iterate,
+      CArg<"ValueRange", "llvm::None">:$iterArgs,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attributes)>
   ];
   
   let extraClassDeclaration = [{
     mlir::Block *getBody() { return &region().front(); }
     mlir::Value getIterateVar() { return getBody()->getArgument(1); }
     mlir::Value getInductionVar() { return getBody()->getArgument(0); }
     mlir::OpBuilder getBodyBuilder() {
       return mlir::OpBuilder(getBody(), std::prev(getBody()->end()));
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 = [OpBuilder<
-    "OpBuilder &builder, OperationState &result, CmpFPredicate predicate,"
-    "Value lhs, Value rhs", [{
-      buildCmpFOp(builder, result, predicate, lhs, rhs);
+  let builders = [
+    OpBuilderDAG<(ins "CmpFPredicate":$predicate, "Value":$lhs, "Value":$rhs),
+    [{
+      buildCmpFOp($_builder, $_state, predicate, lhs, rhs);
   }]>];
 
   let parser = [{ return parseCmpfOp(parser, result); }];
 
   let printer = [{ printCmpfOp(p, *this); }];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef getPredicateAttrName() {
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 = [OpBuilder<
-    "OpBuilder &builder, OperationState &result, CmpFPredicate predicate,"
-    "Value lhs, Value rhs", [{
-      buildCmpCOp(builder, result, predicate, lhs, rhs);
+  let builders = [
+    OpBuilderDAG<(ins "CmpFPredicate":$predicate, "Value":$lhs, "Value":$rhs),
+    [{
+      buildCmpCOp($_builder, $_state, predicate, lhs, rhs);
   }]>];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef getPredicateAttrName() {
       return "predicate";
     }
 
     CmpFPredicate getPredicate() {
def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
   }];
 
   let printer = [{
     p << getOperationName() << ' ' << getAttr("in_type");
     p.printOptionalAttrDict(getAttrs(), {"in_type"});
   }];
 
   let builders = [
-    OpBuilder<"OpBuilder &, OperationState &result, mlir::TypeAttr inty">
+    OpBuilderDAG<(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 {
let printer = [{
     p.printType(getType());
     if (hasInitializationBody())
       p.printRegion(getOperation()->getRegion(0), /*printEntryBlockArgs=*/false,
                     /*printBlockTerminators=*/true);
   }];
 
   let skipDefaultBuilders = 1;
   let builders = [
-    OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
-              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}">,
-    OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
-              "StringRef name, bool isConstant, Type type,"
-        "ArrayRef<NamedAttribute> attrs = {}">,
-    OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
-              "StringRef name, Type type, StringAttr linkage = {},"
-        "ArrayRef<NamedAttribute> attrs = {}">,
-    OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
-              "StringRef name, bool isConstant, Type type,"
-        "StringAttr linkage = {},"
-        "ArrayRef<NamedAttribute> attrs = {}">,
-    OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
-              "StringRef name, Type type, Attribute initVal,"
-        "StringAttr linkage = {},"
-        "ArrayRef<NamedAttribute> attrs = {}">,
-    OpBuilder<"mlir::OpBuilder &builder, OperationState &result,"
-              "StringRef name, bool isConstant, Type type,"
-        "Attribute initVal, StringAttr linkage = {},"
-        "ArrayRef<NamedAttribute> attrs = {}">,
+    OpBuilderDAG<(ins "StringRef":$name, "Type":$type,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+    OpBuilderDAG<(ins "StringRef":$name, "bool":$isConstant, "Type":$type,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+    OpBuilderDAG<(ins "StringRef":$name, "Type":$type,
+      CArg<"StringAttr", "{}">:$linkage,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+    OpBuilderDAG<(ins "StringRef":$name, "bool":$isConstant, "Type":$type,
+      CArg<"StringAttr", "{}">:$linkage,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+    OpBuilderDAG<(ins "StringRef":$name, "Type":$type, "Attribute":$initVal,
+      CArg<"StringAttr", "{}">:$linkage,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
+    OpBuilderDAG<(ins "StringRef":$name, "bool":$isConstant, "Type":$type,
+      "Attribute":$initVal, CArg<"StringAttr", "{}">:$linkage,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>,
   ];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef symbolAttrName() { return "symref"; }
     static constexpr llvm::StringRef constantAttrName() { return "constant"; }
     static constexpr llvm::StringRef initValAttrName() { return "initVal"; }
     static constexpr llvm::StringRef linkageAttrName() { return "linkName"; }
     static constexpr llvm::StringRef typeAttrName() { return "type"; }
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 = [
-    OpBuilder<"mlir::OpBuilder &builder, OperationState *result,"
-              "StringRef name, Type type, ArrayRef<NamedAttribute> attrs = {}",
+    OpBuilderDAG<(ins "StringRef":$name, "Type":$type,
+      CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs),
     [{
-      result->addAttribute(mlir::SymbolTable::getSymbolAttrName(),
-                           builder.getStringAttr(name));
-      result->addAttributes(attrs);
+      $_state.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
+                           $_builder.getStringAttr(name));
+      $_state.addAttributes(attrs);
     }]>
   ];
 
   let extraClassDeclaration = [{
     /// Append a dispatch table entry to the table.
     void appendTableEntry(mlir::Operation *op);
 
     mlir::Region &getRegion() {