[MLIR] Fix default builders generated by TableGen to use TypeRange for result types

[jurahul]

Summary

• Change the default builders to use TypeRange instead of ArrayRef<Type>
• Add ability to selectively skip either the default separate param or collective param builders, and use that in LinalgStructuredOps to skip default separate param ones, as they conflict with the new default one's since they both use TypeRange now.

[jpienaar]

Lets just focus on "Change the default builders to use TypeRange instead of ArrayRef<Type>" part as one change rather than having 2 unrelated changes in one. That part LGTM to, the other I'd prefer a follow up discussion.

Fix to me implies a bug, here this is just updating it to use TypeRange, don't believe there is any bug being addressed here.

mlir/include/mlir/IR/OpBase.td

2021

Do we really need all of these vs just being able to opt out?

Seems unrelated to the rest so I'd split this out either way and we can discuss in the follow up change.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1255

Lets keep a change restricted to one change and so just have this change here.

[jurahul]

mlir/include/mlir/IR/OpBase.td

2021

Yes, this was needed to get everything to compile. mlir-linalg-ods-gen.cpp defines custom builders that conflict with the "default separate" ones that ODS now generates because now both use TypeRange as the argument types. Before this change, ODS was using ArrayRef and the ones defined in mlir-linalg-ods-gen.cpp were using TypeRange, so compilation was successful. I did try skipping all default builders in mlir-linalg-ods-gen.cpp but that does not work either, as it looks like the code relies on default collective param builders being there. Hence this change.

We can definitely split this up, but then the ability to skip default separate param builds would need to come first, followed by the TypeRange change. Let me know if that works. Also, I added skipDefaultCollectiveParamBuilders to be complete, but there is no use for it today, so we can skip adding that as well.

[jpienaar]

mlir/include/mlir/IR/OpBase.td

2021

I don't think we want to maintain this level of customization wrt build method generations. Why does the makes redundant approach not address this? E.g., the custom builder here overlaps with generated one, shouldn't the user provided one get preference then?

[jurahul]

mlir/include/mlir/IR/OpBase.td

2021

Because it only works with internally generated build methods (the resolved ones). User generated ones are never checked against default generated ones yet (to avoid C++ parsing). One option is to extend the code to support that. @ftynse (D88012) put up a code review recently that had support for parsing the user supplied parameters for a prototype, may be we could incorporate that and eliminate the possibility of unresolved parameters (and extend redundancy checking to never eliminate a user defined build method).

[jurahul]

Eliminate the need to selectively skip default builders

[ftynse]

mlir/include/mlir/IR/OpBase.td

2021

Please tag me on the follow-up diff when it's up for review :)

I am supportive of the idea that user-defined builders should just override autogenerated builders. This sounds brittle though, we will have to rely on a relatively simple parser (I don't think we want a build dependency on clang) to demonstrate type equivalence. This could work as long as the argument types in autogenerated builders are relatively simple. If we get, e.g., an attribute with value type DenseMap<string, UserDefinedType>, which means a value of this type is passed into one of the autogenerated builders, and a user-defined builder that takes a UserDefinedMap instead, the type equivalence will depend on user code not having a visible alias using UserDefinedMap = DenseMap<string, UserDefinedType>. There is also the question of overload resolution, e.g. between Typename and const Typename & that are different types per se but are considered ambiguous by overload resolution if an instance of Typename is passed.

[jurahul]

mlir/include/mlir/IR/OpBase.td

2021

I've skirted the whole issue for now by following Jacque's suggestion of disabling all default builders for the LinalgStructuredOps and avoiding introducing the mechanism to selectively skip some of the default ones but not all.

I think the more robust approach is to change ODS OpBuilder to specify the builder parameters using DAG style specification (like you suggested) so we do not have to parse a C++ snippet to piece out the parameters. Yes, there is still the issue of seemingly different names causing problems with overload resolution.

mlir/include/mlir/IR/OpBase.td

class Op<Dialect dialect, string mnemonic, list<OpTrait> props = []> {
   // ```c++
   // static void build(OpBuilder &, OperationState &odsState,
   //                   ArrayRef<Type> resultTypes,
   //                   ArrayRef<Value> operands,
   //                   ArrayRef<NamedAttribute> attributes);
   // ```
   list<OpBuilder> builders = ?;
 
-  // Avoid generating default build functions.  Custom builders must be
-  // provided.
+  // Avoid generating default build functions. Custom builders must be
+  // provided. Implies skipDefaultSeparateParamBuilders = 1 and
+  // skipDefaultCollectiveParamBuilders = 1.
   bit skipDefaultBuilders = 0;
 
+  // Avoid generating default separate param builders.
+  bit skipDefaultSeparateParamBuilders = 0;
+
+  // Avoid generating default collective param builders.
+  bit skipDefaultCollectiveParamBuilders = 0;
+
   // Custom parser.
   code parser = ?;
 
   // Custom printer.
   code printer = ?;
 
   // Custom assembly format.
   string assemblyFormat = ?;

mlir/include/mlir/TableGen/Operator.h

public:
   using value_iterator = NamedTypeConstraint *;
   using value_range = llvm::iterator_range<value_iterator>;
 
   // Returns true if this op has variable length operands or results.
   bool isVariadic() const;
 
   // Returns true if default builders should not be generated.
   bool skipDefaultBuilders() const;
+  // Returns true if default separate param builders should not be generated.
+  bool skipDefaultSeparateParamBuilders() const;
+  // Returns true if default collective param builders should not be generated.
+  bool skipDefaultCollectiveParamBuilders() const;
 
   // Op result iterators.
   value_iterator result_begin();
   value_iterator result_end();
   value_range getResults();
 
   // Returns the number of results this op produces.
   int getNumResults() const;

mlir/lib/TableGen/Operator.cpp

 }
 
 const llvm::Record &Operator::getDef() const { return def; }
 
 bool Operator::skipDefaultBuilders() const {
   return def.getValueAsBit("skipDefaultBuilders");
 }
 
+bool Operator::skipDefaultSeparateParamBuilders() const {
+  return def.getValueAsBit("skipDefaultSeparateParamBuilders") ||
+         skipDefaultBuilders();
+}
+
+bool Operator::skipDefaultCollectiveParamBuilders() const {
+  return def.getValueAsBit("skipDefaultCollectiveParamBuilders") ||
+         skipDefaultBuilders();
+}
+
 auto Operator::result_begin() -> value_iterator { return results.begin(); }
 
 auto Operator::result_end() -> value_iterator { return results.end(); }
 
 auto Operator::getResults() -> value_range {
   return {result_begin(), result_end()};
 }
 

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

 // CHECK:   ::mlir::Value r();
 // CHECK:   ::mlir::Region &someRegion();
 // CHECK:   ::mlir::MutableArrayRef<Region> someRegions();
 // CHECK:   ::mlir::IntegerAttr attr1Attr()
 // CHECK:   uint32_t attr1();
 // CHECK:   ::mlir::FloatAttr attr2Attr()
 // CHECK:   ::llvm::Optional< ::llvm::APFloat > attr2();
 // CHECK:   static void build(Value val);
-// CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::llvm::ArrayRef<::mlir::Type> s, ::mlir::Value a, ::mlir::ValueRange b, ::mlir::IntegerAttr attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
-// CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::llvm::ArrayRef<::mlir::Type> s, ::mlir::Value a, ::mlir::ValueRange b, uint32_t attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
-// CHECK:   static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes, unsigned numRegions)
+// CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::TypeRange s, ::mlir::Value a, ::mlir::ValueRange b, ::mlir::IntegerAttr attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
+// CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::TypeRange s, ::mlir::Value a, ::mlir::ValueRange b, uint32_t attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
+// CHECK:   static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes, unsigned numRegions)
 // CHECK:   static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
 // CHECK:   void print(::mlir::OpAsmPrinter &p);
 // CHECK:   ::mlir::LogicalResult verify();
 // CHECK:   static void getCanonicalizationPatterns(::mlir::OwningRewritePatternList &results, ::mlir::MLIRContext *context);
 // CHECK:   ::mlir::LogicalResult fold(::llvm::ArrayRef<::mlir::Attribute> operands, ::llvm::SmallVectorImpl<::mlir::OpFoldResult> &results);
 // CHECK:   // Display a graph for debugging purposes.
 // CHECK:   void displayGraph();
 // CHECK: };

 // are generated as well.
 def NS_HCollectiveParamsOp : NS_Op<"op_collective_params", []> {
   let arguments = (ins AnyType:$a);
   let results = (outs AnyType:$b);
 }
 
 // CHECK_LABEL: class NS_HCollectiveParamsOp :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type b, ::mlir::Value a);
-// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {})
+// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a);
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {})
 
 // Check suppression of "separate arg, separate result" build method for an op
 // with single variadic arg and single variadic result (since it will be
 // ambiguous with the collective params build method).
 def NS_HCollectiveParamsSuppress0Op : NS_Op<"op_collective_suppress0", []> {
   let arguments = (ins Variadic<I32>:$a);
   let results = (outs Variadic<I32>:$b);
 }
 
 // CHECK_LABEL: class NS_HCollectiveParamsSuppress0Op :
-// CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> b, ::mlir::ValueRange a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::ValueRange a);
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
 
 // Check suppression of "separate arg, collective result" build method for an op
 // with single variadic arg and non variadic result (since it will be
 // ambiguous with the collective params build method).
 def NS_HCollectiveParamsSuppress1Op : NS_Op<"op_collective_suppress1", []> {
   let arguments = (ins Variadic<I32>:$a);
   let results = (outs I32:$b);
 }
 
 // CHECK_LABEL: class NS_HCollectiveParamsSuppress1Op :
-// CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> b, ::mlir::ValueRange a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::ValueRange a);
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
 
 // Check suppression of "separate arg, collective result" build method for an op
 // with single variadic arg and > 1 variadic result (since it will be
 // ambiguous with the collective params build method). Note that "separate arg,
 // separate result" build method should be generated in this case as its not
 // ambiguous with the collective params build method.
 def NS_HCollectiveParamsSuppress2Op : NS_Op<"op_collective_suppress2", [SameVariadicResultSize]> {
   let arguments = (ins Variadic<I32>:$a);
   let results = (outs Variadic<I32>:$b, Variadic<F32>:$c);
 }
 // CHECK_LABEL: class NS_HCollectiveParamsSuppress2Op :
-// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> b, ::llvm::ArrayRef<::mlir::Type> c, ::mlir::ValueRange a);
-// CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> b, ::mlir::ValueRange a);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::TypeRange c, ::mlir::ValueRange a);
+// CHECK-NOT: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange b, ::mlir::ValueRange a);
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
 
 // Check default value of `attributes` for the `genUseOperandAsResultTypeCollectiveParamBuilder` builder
 def NS_IOp : NS_Op<"op_with_same_operands_and_result_types_trait", [SameOperandsAndResultType]> {
   let arguments = (ins AnyType:$a, AnyType:$b);
   let results = (outs AnyType:$r);
 }
 // CHECK_LABEL: class NS_IOp :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::Value a, ::mlir::Value b);
-// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value a, ::mlir::Value b);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
 
 // Check default value of `attributes` for the `genInferredTypeCollectiveParamBuilder` builder
 def NS_JOp : NS_Op<"op_with_InferTypeOpInterface_interface", [DeclareOpInterfaceMethods<InferTypeOpInterface>]> {
   let arguments = (ins AnyType:$a, AnyType:$b);
   let results = (outs AnyType:$r);
 }
 // CHECK_LABEL: class NS_JOp :
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::Value a, ::mlir::Value b);
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value a, ::mlir::Value b);
-// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::Value a, ::mlir::Value b);
-// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
+// CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value a, ::mlir::Value b);
+// CHECK: static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
 // CHECK: static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});
 
 // Check that default builders can be suppressed.
 // ---
 
 def NS_SkipDefaultBuildersOp : NS_Op<"skip_default_builders", []> {
   let skipDefaultBuilders = 1;
   let builders = [OpBuilder<"Value val">];

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

 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 class NS_Op<string mnemonic, list<OpTrait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 def OpA : NS_Op<"one_normal_result_op", []> {
   let results = (outs I32:$result);
 }
 
 // CHECK-LABEL: void OpA::build
-// CHECK:         ::llvm::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands
+// CHECK:         ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands
 // CHECK:         assert(resultTypes.size() == 1u && "mismatched number of return types");
 // CHECK-NEXT:    odsState.addTypes(resultTypes);
 
 def OpB : NS_Op<"same_input_output_type_op", [SameOperandsAndResultType]> {
   let arguments = (ins I32:$x);
   let results = (outs I32:$y);
 }
 
 // CHECK-LABEL: OpB definitions
 // CHECK: void OpB::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type y, ::mlir::Value x)
 // CHECK:   odsState.addTypes(y);
 // CHECK: void OpB::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value x)
 // CHECK:   odsState.addTypes({x.getType()});
 
 def OpC : NS_Op<"three_normal_result_op", []> {
   let results = (outs I32:$x, /*unnamed*/I32, I32:$z);
 }
 
 // CHECK-LABEL: OpC definitions
 // CHECK:       void OpC::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type x, ::mlir::Type resultType1, ::mlir::Type z)
 // CHECK-NEXT:   odsState.addTypes(x)
 // CHECK-NEXT:   odsState.addTypes(resultType1)
 // CHECK-NEXT:   odsState.addTypes(z)
 
-// CHECK:      void OpC::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::llvm::ArrayRef<::mlir::Type> resultTypes) {
+// CHECK:      void OpC::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes) {
 // CHECK-NEXT:   assert(resultTypes.size() == 3u && "mismatched number of results");
 // CHECK-NEXT:   odsState.addTypes(resultTypes);
 
 def IntegerTypeAttr : TypeAttrBase<"IntegerType", "Integer type attribute">;
 def OpD : NS_Op<"type_attr_as_result_type", [FirstAttrDerivedResultType]> {
   let arguments = (ins I32:$x, IntegerTypeAttr:$attr, F32Attr:$f32);
   let results = (outs AnyTensor:$y);
 }

 // CHECK: void OpE::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes)
 // CHECK: odsState.addTypes({attr.second.getType()});
 
 def OpF : NS_Op<"one_variadic_result_op", []> {
   let results = (outs Variadic<I32>:$x);
 }
 
 // CHECK-LABEL: void OpF::build
-// CHECK-SAME:    ::llvm::ArrayRef<::mlir::Type> x
+// CHECK-SAME:    ::mlir::TypeRange x
 // CHECK-NOT:     assert
 // CHECK:         odsState.addTypes(x);
 
 def OpG : NS_Op<"one_normal_and_one_variadic_result_op", []> {
 
   let results = (outs I32:$x, Variadic<I32>:$y);
 }
 
 // CHECK-LABEL: OpG definitions
 
-// CHECK:      void OpG::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type x, ::llvm::ArrayRef<::mlir::Type> y)
+// CHECK:      void OpG::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type x, ::mlir::TypeRange y)
 // CHECK-NEXT:   odsState.addTypes(x);
 // CHECK-NEXT:   odsState.addTypes(y);
 
 // CHECK:       void OpG::build
-// CHECK:         ::llvm::ArrayRef<::mlir::Type> resultTypes
+// CHECK:         ::mlir::TypeRange resultTypes
 // CHECK:         assert(resultTypes.size() >= 1u && "mismatched number of return types");
 // CHECK-NEXT:    odsState.addTypes(resultTypes);
 
 def OpI : NS_Op<"mix_variadic_and_normal_results_op", [SameVariadicResultSize]> {
   let results = (outs Variadic<AnyTensor>:$output1, AnyTensor:$output2, Variadic<AnyTensor>:$output3);
 }
 
 // CHECK-LABEL: ::mlir::Operation::result_range OpI::output1

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

const char *header = R"FMT(  def {0} : LinalgStructuredBase_Op<"{1}", [
     AttrSizedOperandSegments,
     SingleBlockImplicitTerminator<"YieldOp">]> {
       let arguments = (ins Variadic<AnyShaped>:$inputs,
                            Variadic<AnyMemRef>:$output_buffers,
                            Variadic<AnyRankedTensor>:$init_tensors);
       let results = (outs Variadic<AnyRankedTensor>:$output_tensors);
       let regions = (region AnyRegion:$region);
 
+      let skipDefaultSeparateParamBuilders = 1;
       let builders = [ OpBuilder<
-        "OpBuilder &b, OperationState &result,"
+        "OpBuilder &b, OperationState &result, "
         "ValueRange inputs, ValueRange outputBuffers",
         [{{
           result.addOperands(inputs);
           result.addOperands(outputBuffers);
           result.addAttribute(
             "operand_segment_sizes",
             b.getI32VectorAttr({{static_cast<int32_t>(inputs.size()),
                                 static_cast<int32_t>(outputBuffers.size()),
                                 static_cast<int32_t>(0)}));
           buildNamedStructuredOpRegionAndAttributes<{0}>(
             b,
             result,
             TypeRange(inputs),
             TypeRange(outputBuffers),
             TypeRange(),
             TypeRange());
         }]>, OpBuilder<
-        "OpBuilder &b, OperationState &result, TypeRange resultTensorTypes,"
+        "OpBuilder &b, OperationState &result, TypeRange resultTensorTypes, "
         "ValueRange inputs, ValueRange outputBuffers, ValueRange initTensors",
         [{{
           result.addOperands(inputs);
           result.addOperands(outputBuffers);
           result.addOperands(initTensors);
           result.addTypes(resultTensorTypes);
           result.addAttribute(
             "operand_segment_sizes",

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

body << "    " << builderOpState << ".addTypes({"
        << llvm::join(resultTypes, ", ") << "});\n";
   body << "  }\n";
 }
 
 void OpEmitter::genBuilder() {
   // Handle custom builders if provided.
   // TODO: Create wrapper class for OpBuilder to hide the native
   // TableGen API calls here.
+  bool hasBuilder = false;
   {
     auto *listInit = dyn_cast_or_null<ListInit>(def.getValueInit("builders"));
-    if (listInit) {
+    if (listInit && !listInit->empty()) {
+      hasBuilder = true;
       for (Init *init : listInit->getValues()) {
         Record *builderDef = cast<DefInit>(init)->getDef();
         StringRef params = builderDef->getValueAsString("params");
         StringRef body = builderDef->getValueAsString("body");
         bool hasBody = !body.empty();
 
         OpMethod::Property properties =
             hasBody ? OpMethod::MP_Static : OpMethod::MP_StaticDeclaration;
         auto *method =
             opClass.addMethodAndPrune("void", "build", properties, params);
         if (hasBody)
           method->body() << body;
       }
     }
-    if (op.skipDefaultBuilders()) {
-      if (!listInit || listInit->empty())
-        PrintFatalError(
-            op.getLoc(),
-            "default builders are skipped and no custom builders provided");
-      return;
-    }
   }
 
   // Generate default builders that requires all result type, operands, and
   // attributes as parameters.
 
   // We generate three classes of builders here:
   // 1. one having a stand-alone parameter for each operand / attribute, and
+  if (!op.skipDefaultSeparateParamBuilders()) {
     genSeparateArgParamBuilder();
+    hasBuilder = true;
+  }
+
   // 2. one having an aggregated parameter for all result types / operands /
   //    attributes, and
+  if (!op.skipDefaultCollectiveParamBuilders()) {
     genCollectiveParamBuilder();
+    hasBuilder = true;
+  }
+
   // 3. one having a stand-alone parameter for each operand and attribute,
   //    use the first operand or attribute's type as all result types
   //    to facilitate different call patterns.
   if (op.getNumVariableLengthResults() == 0) {
     if (op.getTrait("::mlir::OpTrait::SameOperandsAndResultType")) {
+      if (!op.skipDefaultSeparateParamBuilders()) {
         genUseOperandAsResultTypeSeparateParamBuilder();
+        hasBuilder = true;
+      }
+
+      if (!op.skipDefaultCollectiveParamBuilders()) {
         genUseOperandAsResultTypeCollectiveParamBuilder();
+        hasBuilder = true;
+      }
     }
-    if (op.getTrait("::mlir::OpTrait::FirstAttrDerivedResultType"))
+    if (op.getTrait("::mlir::OpTrait::FirstAttrDerivedResultType") &&
+        !op.skipDefaultBuilders()) {
       genUseAttrAsResultTypeBuilder();
+      hasBuilder = true;
+    }
   }
+
+  if (hasBuilder)
+    return;
+
+  PrintFatalError(
+      op.getLoc(),
+      "default builders are skipped and no custom builders provided");
 }
 
 void OpEmitter::genCollectiveParamBuilder() {
   int numResults = op.getNumResults();
   int numVariadicResults = op.getNumVariableLengthResults();
   int numNonVariadicResults = numResults - numVariadicResults;
 
   int numOperands = op.getNumOperands();
   int numVariadicOperands = op.getNumVariableLengthOperands();
   int numNonVariadicOperands = numOperands - numVariadicOperands;
 
   SmallVector<OpMethodParameter, 4> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
-  paramList.emplace_back("::llvm::ArrayRef<::mlir::Type>", "resultTypes");
+  paramList.emplace_back("::mlir::TypeRange", "resultTypes");
   paramList.emplace_back("::mlir::ValueRange", "operands");
   // Provide default value for `attributes` when its the last parameter
   StringRef attributesDefaultValue = op.getNumVariadicRegions() ? "" : "{}";
   paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
                          "attributes", attributesDefaultValue);
   if (op.getNumVariadicRegions())
     paramList.emplace_back("unsigned", "numRegions");
 
void OpEmitter::buildParamList(SmallVectorImpl<OpMethodParameter> &paramList,
   case TypeParamKind::Separate: {
     // Add parameters for all return types
     for (int i = 0; i < numResults; ++i) {
       const auto &result = op.getResult(i);
       std::string resultName = std::string(result.name);
       if (resultName.empty())
         resultName = std::string(formatv("resultType{0}", i));
 
-      StringRef type = result.isVariadic() ? "::llvm::ArrayRef<::mlir::Type>"
-                                           : "::mlir::Type";
+      StringRef type =
+          result.isVariadic() ? "::mlir::TypeRange" : "::mlir::Type";
       OpMethodParameter::Property properties = OpMethodParameter::PP_None;
       if (result.isOptional())
         properties = OpMethodParameter::PP_Optional;
 
       paramList.emplace_back(type, resultName, properties);
       resultTypeNames.emplace_back(std::move(resultName));
     }
   } break;
   case TypeParamKind::Collective: {
-    paramList.emplace_back("::llvm::ArrayRef<::mlir::Type>", "resultTypes");
+    paramList.emplace_back("::mlir::TypeRange", "resultTypes");
     resultTypeNames.push_back("resultTypes");
   } break;
   }
 
   // Add parameters for all arguments (operands and attributes).
 
   int numOperands = 0;
   int numAttrs = 0;