[mlir][ODS] Refactor BuildableType to use $_builder as part of the format

[rriddle]

Summary

Currently BuildableType is assumed to be preceded by a builder. This prevents constructing types that don't have a callable 'get' method with the builder. This revision reworks the format to be like attribute builders, i.e. by accepting $_builder within the format itself.

Depends On D73735

[merge_guards_bot]

Unit tests: fail. 62354 tests passed, 1 failed and 839 were skipped.

failed: libc++.std/containers/sequences/array/array_creation/to_array.fail.cpp

clang-tidy: pass.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

mlir/include/mlir/IR/OpBase.td

 //===----------------------------------------------------------------------===//
 // Type definitions
 //===----------------------------------------------------------------------===//
 
 // A type, carries type constraints.
 class Type<Pred condition, string descr = ""> :
     TypeConstraint<condition, descr> {
   string typeDescription = "";
+  string builderCall = "";
 }
 
 // Allows providing an alternative name and description to an existing type def.
 class TypeAlias<Type t, string description = t.description> :
     Type<t.predicate, description> {
   let typeDescription = t.typeDescription;
+  let builderCall = t.builderCall;
 }
 
 // A type of a specific dialect.
 class DialectType<Dialect d, Pred condition, string descr = ""> :
     Type<condition, descr> {
   Dialect dialect = d;
 }
 
 // A variadic type constraint. It expands to zero or more of the base type. This
 // class is used for supporting variadic operands/results. An op can declare no
 // more than one variadic operand/result, and that operand/result must be the
 // last one in the operand/result list.
 class Variadic<Type type> : TypeConstraint<type.predicate, type.description> {
   Type baseType = type;
 }
 
 // A type that can be constructed using MLIR::Builder.
 // Note that this does not "inherit" from Type because it would require
 // duplicating Type subclasses for buildable and non-buildable cases to avoid
 // diamond "inheritance".
 // TODO(zinenko): we may extend this to a more general 'Buildable' trait,
 // making some Types and some Attrs buildable.
 class BuildableType<code builder> {
   // The builder call to invoke (if specified) to construct the BuildableType.
-  // Format: this will be affixed to the builder.
   code builderCall = builder;
 }
 
 // Any type at all.
 def AnyType : Type<CPred<"true">, "any type">;
 
 // None type
 def NoneType : Type<CPred<"$_self.isa<NoneType>()">, "none type">;
 
 // Any type from the given list
 class AnyTypeOf<list<Type> allowedTypes, string description = ""> : Type<
     // Satisfy any of the allowed type's condition
     Or<!foreach(allowedtype, allowedTypes, allowedtype.predicate)>,
     !if(!eq(description, ""),
         StrJoin<!foreach(t, allowedTypes, t.description), " or ">.result,
         description)>;
 
 // Integer types.
 // Any integer type irrespective of its width.
 def AnyInteger : Type<CPred<"$_self.isa<IntegerType>()">, "integer">;
 
 // Index type.
 def Index : Type<CPred<"$_self.isa<IndexType>()">, "index">,
-            BuildableType<"getIndexType()">;
+            BuildableType<"$_builder.getIndexType()">;
 
 // Integer type of a specific width.
 class I<int width>
     : Type<CPred<"$_self.isInteger(" # width # ")">,
                   width # "-bit integer">,
-      BuildableType<"getIntegerType(" # width # ")"> {
+      BuildableType<"$_builder.getIntegerType(" # width # ")"> {
   int bitwidth = width;
 }
 
 class IntOfWidths<list<int> widths> :
     AnyTypeOf<!foreach(w, widths, I<w>),
               StrJoinInt<widths, "/">.result # "-bit integer">;
 
 def I1  : I<1>;
 def I8  : I<8>;
 def I16 : I<16>;
 def I32 : I<32>;
 def I64 : I<64>;
 
 // Floating point types.
 
 // Any float type irrespective of its width.
 def AnyFloat : Type<CPred<"$_self.isa<FloatType>()">, "floating-point">;
 
 // Float type of a specific width.
 class F<int width>
     : Type<CPred<"$_self.isF" # width # "()">,
                 width # "-bit float">,
-      BuildableType<"getF" # width # "Type()"> {
+      BuildableType<"$_builder.getF" # width # "Type()"> {
   int bitwidth = width;
 }
 
 class FloatOfWidths<list<int> widths> :
     AnyTypeOf<!foreach(w, widths, F<w>),
               StrJoinInt<widths, "/">.result # "-bit float">;
 
 def F16 : F<16>;
 def F32 : F<32>;
 def F64 : F<64>;
 
 def BF16 : Type<CPred<"$_self.isBF16()">, "bfloat16 type">,
-           BuildableType<"getBF16Type()">;
+           BuildableType<"$_builder.getBF16Type()">;
 
 class Complex<Type type>
     : Type<And<[
           CPred<"$_self.isa<ComplexType>()">,
           SubstLeaves<"$_self", "$_self.cast<ComplexType>().getElementType()",
            type.predicate>]>,
            "complex type with " # type.description # " elements"> {
   Type elementType = type;

 
 class 0DTensorOf<list<Type> allowedTypes> : TensorRankOf<allowedTypes, [0]>;
 class 1DTensorOf<list<Type> allowedTypes> : TensorRankOf<allowedTypes, [1]>;
 class 2DTensorOf<list<Type> allowedTypes> : TensorRankOf<allowedTypes, [2]>;
 class 3DTensorOf<list<Type> allowedTypes> : TensorRankOf<allowedTypes, [3]>;
 class 4DTensorOf<list<Type> allowedTypes> : TensorRankOf<allowedTypes, [4]>;
 
 // Unranked Memref type
-def AnyUnrankedMemRef : 
-    ShapedContainerType<[AnyType], 
+def AnyUnrankedMemRef :
+    ShapedContainerType<[AnyType],
                         IsUnrankedMemRefTypePred, "unranked.memref">;
 // Memref type.
 
 // Memrefs are blocks of data with fixed type and rank.
 class MemRefOf<list<Type> allowedTypes> :
     ShapedContainerType<allowedTypes, IsMemRefTypePred, "memref">;
 
 def AnyMemRef : MemRefOf<[AnyType]>;

 //===----------------------------------------------------------------------===//
 // Primitive attribute kinds
 
 // A generic attribute that must be constructed around a specific type
 // `attrValType`. Backed by MLIR attribute kind `attrKind`.
 class TypedAttrBase<BuildableType attrValType, string attrKind,
                     Pred condition, string descr> :
     Attr<condition, descr> {
-  let constBuilderCall = "$_builder.get" # attrKind # "($_builder." #
+  let constBuilderCall = "$_builder.get" # attrKind # "(" #
                          attrValType.builderCall # ", $0)";
   let storageType = attrKind;
 }
 
 // Any attribute.
 def AnyAttr : Attr<CPred<"true">, "any attribute"> {
   let storageType = "Attribute";
   let returnType = "Attribute";

mlir/lib/TableGen/Type.cpp

 //===- Type.cpp - Type class ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Type wrapper to simplify using TableGen Record defining a MLIR Type.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Type.h"
+#include "mlir/ADT/TypeSwitch.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 TypeConstraint::TypeConstraint(const llvm::Record *record)
     : Constraint(Constraint::CK_Type, record) {
   assert(def->isSubClassOf("TypeConstraint") &&

 
 // Returns the builder call for this constraint if this is a buildable type,
 // returns None otherwise.
 Optional<StringRef> TypeConstraint::getBuilderCall() const {
   const llvm::Record *baseType = def;
   if (isVariadic())
     baseType = baseType->getValueAsDef("baseType");
 
-  if (!baseType->isSubClassOf("BuildableType"))
-    return None;
-  return baseType->getValueAsString("builderCall");
+  // Check to see if this type constraint has a builder call.
+  const llvm::RecordVal *builderCall = baseType->getValue("builderCall");
+  if (!builderCall || !builderCall->getValue())
+    return llvm::None;
+  return TypeSwitch<llvm::Init *, Optional<StringRef>>(builderCall->getValue())
+      .Case<llvm::StringInit, llvm::CodeInit>([&](auto *init) {
+        StringRef value = init->getValue();
+        return value.empty() ? Optional<StringRef>() : value;
+      })
+      .Default([](auto *) { return llvm::None; });
 }
 
 Type::Type(const llvm::Record *record) : TypeConstraint(record) {}
 
 StringRef Type::getTypeDescription() const {
   return def->getValueAsString("typeDescription");
 }
 
 Dialect Type::getDialect() const {
   return Dialect(def->getValueAsDef("dialect"));
 }

mlir/tools/mlir-tblgen/OpFormatGen.cpp

void OperationFormat::genParser(Operator &op, OpClass &opClass) {
   // have been parsed.
   genParserTypeResolution(op, body);
   body << "  return success();\n";
 }
 
 void OperationFormat::genParserTypeResolution(Operator &op,
                                               OpMethodBody &body) {
   // Initialize the set of buildable types.
+  if (!buildableTypes.empty()) {
+    body << "  Builder &builder = parser.getBuilder();\n";
+
+    FmtContext typeBuilderCtx;
+    typeBuilderCtx.withBuilder("builder");
     for (auto &it : buildableTypes)
-    body << "  Type odsBuildableType" << it.second << " = parser.getBuilder()."
-         << it.first << ";\n";
+      body << "  Type odsBuildableType" << it.second << " = "
+           << tgfmt(it.first, &typeBuilderCtx) << ";\n";
+  }
 
   // Resolve each of the result types.
   if (allResultTypes) {
     body << "  result.addTypes(allResultTypes);\n";
   } else {
     for (unsigned i = 0, e = op.getNumResults(); i != e; ++i) {
       body << "  result.addTypes(";
       if (Optional<int> val = resultTypes[i].getBuilderIdx())