[mlir][DeclarativeParser] Add support for attributes with buildable types.

[rriddle]

Summary

This revision adds support in the declarative assembly form for printing attributes with buildable types without the type.

[rriddle]

Update handling of elements attrs.

[antiagainst]

It seems the parsers/printers modified in this patch does not use the attribute-type-ellison feature introduced in this patch? Can we touch parsers/printers really uses this feature? Also should we document this? Otherwise it's subtle behavior users might find very confusing. (The modifications to parsers/printers in this patch can be split out.)

mlir/include/mlir/IR/OpBase.td

632

Let's put some comments here as for what this field mean and what it's used for. We already have storageType, returnType. It can be quite confusing for somebody reading the code later. ;)

690

We removed the BuildType requirement but mentioned it in the comment?

1237

Should we also pass this through other attribute "decorators" like OptionalAttr and defaultValuedAttr?

mlir/lib/IR/AsmPrinter.cpp

863

Nit: double space before parser. ;)

[rriddle]

Resolve comments

[rriddle]

In D74276#1865578, @antiagainst wrote:

It seems the parsers/printers modified in this patch does not use the attribute-type-ellison feature introduced in this patch? Can we touch parsers/printers really uses this feature?

Oops, got carried away late at night and forgot to split. Thanks for the catch!

mlir/include/mlir/IR/OpBase.td

690

An early revision reworked buildable types to be usable/settable outside of the BuildableType class. Changing BuildableType -> Type just allows for more buildable types to be used.

[jpienaar]

Nice, thanks

mlir/docs/OpDefinitions.md

The following are the set of valid punctuation:
   `:`, `,`, `=`, `<`, `>`, `(`, `)`, `[`, `]`, `->`
 
 #### Variables
 
 A variable is an entity that has been registered on the operation itself, i.e.
 an argument(attribute or operand), result, etc. In the `CallOp` example above,
 the variables would be `$callee`  and `$args`.
 
+Attribute variables are printed with their respective value type, unless that
+value type is buildable. In those cases, the type of the attribute is elided.
+
 #### Requirements
 
 The format specification has a certain set of requirements that must be adhered
 to:
 
 1. The output and operation name are never shown as they are fixed and cannot be
    altered.
 1. All operands within the operation must appear within the format, either

mlir/include/mlir/IR/OpBase.td

class Attr<Pred condition, string descr = ""> :
   // For example, `$_builder.getStringAttr("$0")` for `StringAttr:"foo"` will
   // expand to `builder.getStringAttr("foo")`.
   string constBuilderCall = ?;
 
   // Default value for attribute.
   // Requires a constBuilderCall defined.
   string defaultValue = ?;
 
+  // The value type of this attribute. This corresponds to the mlir::Type that
+  // this attribute returns via `getType()`.
+  Type valueType = ?;
+
   // Whether the attribute is optional. Typically requires a custom
   // convertFromStorage method to handle the case where the attribute is
   // not present.
   bit isOptional = 0;
 
   // What is the base-level Attr instantiation that this Attr is built upon.
   // Unset means this is a base-level Attr.
   //
class DefaultValuedAttr<Attr attr, string val> :
   // Construct this attribute with the input attribute and change only
   // the default value.
   // Note: this has to be kept up to date with Attr above.
   let storageType = attr.storageType;
   let returnType = attr.returnType;
   let convertFromStorage = attr.convertFromStorage;
   let constBuilderCall = attr.constBuilderCall;
   let defaultValue = val;
+  let valueType = attr.valueType;
 
   let baseAttr = attr;
 }
 
 // Decorates an attribute as optional. The return type of the generated
 // attribute accessor method will be Optional<>.
 class OptionalAttr<Attr attr> : Attr<attr.predicate, attr.description> {
   // Rewrite the attribute to be optional.
   // Note: this has to be kept up to date with Attr above.
   let storageType = attr.storageType;
   let returnType = "Optional<" # attr.returnType #">";
   let convertFromStorage = "$_self ? " # returnType # "(" #
                            attr.convertFromStorage # ") : (llvm::None)";
+  let valueType = attr.valueType;
   let isOptional = 1;
 
   let baseAttr = attr;
 }
 
 //===----------------------------------------------------------------------===//
 // Primitive attribute kinds
 
-// A generic attribute that must be constructed around a specific type
+// A generic attribute that must be constructed around a specific buildable type
 // `attrValType`. Backed by MLIR attribute kind `attrKind`.
-class TypedAttrBase<BuildableType attrValType, string attrKind,
-                    Pred condition, string descr> :
+class TypedAttrBase<Type attrValType, string attrKind, Pred condition,
+                    string descr> :
     Attr<condition, descr> {
   let constBuilderCall = "$_builder.get" # attrKind # "(" #
                          attrValType.builderCall # ", $0)";
   let storageType = attrKind;
+  let valueType = attrValType;
 }
 
 // Any attribute.
 def AnyAttr : Attr<CPred<"true">, "any attribute"> {
   let storageType = "Attribute";
   let returnType = "Attribute";
   let convertFromStorage = "$_self";
   let constBuilderCall = "$0";
And<!listconcat([attr.predicate],
                       !foreach(pred, constraints, pred.predicate))>,
     !foldl(/*init*/attr.description, /*list*/constraints,
            prev, cur, prev # " " # cur.description)> {
   let storageType = attr.storageType;
   let returnType = attr.returnType;
   let convertFromStorage = attr.convertFromStorage;
   let constBuilderCall = attr.constBuilderCall;
   let defaultValue = attr.defaultValue;
+  let valueType = attr.valueType;
   let isOptional = attr.isOptional;
 
   let baseAttr = attr;
 }
 
 // An AttrConstraint that holds if all attr constraints specified in
 // 'constraints' hold.
 class AllAttrConstraintsOf<list<AttrConstraint> constraints> : AttrConstraint<

mlir/include/mlir/IR/OpImplementation.h

void printOperands(IteratorType it, IteratorType end) {
     for (++it; it != end; ++it) {
       getStream() << ", ";
       printOperand(*it);
     }
   }
   virtual void printType(Type type) = 0;
   virtual void printAttribute(Attribute attr) = 0;
 
+  /// Print the given attribute without its type. The corresponding parser must
+  /// provide a valid type for the attribute.
+  virtual void printAttributeWithoutType(Attribute attr) = 0;
+
   /// Print a successor, and use list, of a terminator operation given the
   /// terminator and the successor index.
   virtual void printSuccessorAndUseList(Operation *term, unsigned index) = 0;
 
   /// If the specified operation has attributes, print out an attribute
   /// dictionary with their values.  elidedAttrs allows the client to ignore
   /// specific well known attributes, commonly used if the attribute value is
   /// printed some other way (like as a fixed operand).

mlir/include/mlir/TableGen/Attribute.h

 
 namespace llvm {
 class DefInit;
 class Record;
 } // end namespace llvm
 
 namespace mlir {
 namespace tblgen {
+class Type;
 
 // Wrapper class with helper methods for accessing attribute constraints defined
 // in TableGen.
 class AttrConstraint : public Constraint {
 public:
   explicit AttrConstraint(const llvm::Record *record);
 
   static bool classof(const Constraint *c) { return c->getKind() == CK_Attr; }
public:
 
   // Returns the storage type if set. Returns the default storage type
   // ("Attribute") otherwise.
   StringRef getStorageType() const;
 
   // Returns the return type for this attribute.
   StringRef getReturnType() const;
 
+  // Return the type constraint corresponding to the type of this attribute, or
+  // None if this is not a TypedAttr.
+  llvm::Optional<Type> getValueType() const;
+
   // Returns the template getter method call which reads this attribute's
   // storage and returns the value as of the desired return type.
   // The call will contain a `{0}` which will be expanded to this attribute.
   StringRef getConvertFromStorageCall() const;
 
   // Returns true if this attribute can be built from a constant value.
   bool isConstBuildable() const;
 

mlir/lib/IR/AsmPrinter.cpp

public:
   /// Returns the output stream of the printer.
   raw_ostream &getStream() { return os; }
 
   template <typename Container, typename UnaryFunctor>
   inline void interleaveComma(const Container &c, UnaryFunctor each_fn) const {
     mlir::interleaveComma(c, os, each_fn);
   }
 
-  /// Print the given attribute. If 'mayElideType' is true, some attributes are
-  /// printed without the type when the type matches the default used in the
-  /// parser (for example i64 is the default for integer attributes).
-  void printAttribute(Attribute attr, bool mayElideType = false);
+  /// This enum descripes the different kinds of elision for the type of an
+  /// attribute when printing it.
+  enum class AttrTypeElision {
+    /// The type must not be elided,
+    Never,
+    /// The type may be elided when it matches the default used in the parser
+    /// (for example i64 is the default for integer attributes).
+    May,
+    /// The type must be elided.
+    Must
+  };
+
+  /// Print the given attribute.
+  void printAttribute(Attribute attr,
+                      AttrTypeElision typeElision = AttrTypeElision::Never);
 
   void printType(Type type);
   void printLocation(LocationAttr loc);
 
   void printAffineMap(AffineMap map);
   void
   printAffineExpr(AffineExpr expr,
                   function_ref<void(unsigned, bool)> printValueName = nullptr);

 //
 // Unfortunately, neither of the strings of an opaque ElementsAttr literal will
 // accept the string "elided". The first string must be a registered dialect
 // name and the latter must be a hex constant.
 static void printElidedElementsAttr(raw_ostream &os) {
   os << R"(opaque<"", "0xDEADBEEF">)";
 }
 
-void ModulePrinter::printAttribute(Attribute attr, bool mayElideType) {
+void ModulePrinter::printAttribute(Attribute attr,
+                                   AttrTypeElision typeElision) {
   if (!attr) {
     os << "<<NULL ATTRIBUTE>>";
     return;
   }
 
   // Check for an alias for this attribute.
   if (state) {
     Twine alias = state->getAliasState().getAttributeAlias(attr);
     if (!alias.isTriviallyEmpty()) {
       os << '#' << alias;
       return;
     }
   }
 
+  auto attrType = attr.getType();
   switch (attr.getKind()) {
   default:
     return printDialectAttribute(attr);
 
   case StandardAttributes::Opaque: {
     auto opaqueAttr = attr.cast<OpaqueAttr>();
     printDialectSymbol(os, "#", opaqueAttr.getDialectNamespace(),
                        opaqueAttr.getAttrData());
interleaveComma(attr.cast<DictionaryAttr>().getValue(),
                       os << " = ";
                       printAttribute(attr.second);
                     });
     os << '}';
     break;
   case StandardAttributes::Integer: {
     auto intAttr = attr.cast<IntegerAttr>();
     // Print all integer attributes as signed unless i1.
-    bool isSigned = intAttr.getType().isIndex() ||
-                    intAttr.getType().getIntOrFloatBitWidth() != 1;
+    bool isSigned = attrType.isIndex() || attrType.getIntOrFloatBitWidth() != 1;
     intAttr.getValue().print(os, isSigned);
 
     // IntegerAttr elides the type if I64.
-    if (mayElideType && intAttr.getType().isInteger(64))
+    if (typeElision == AttrTypeElision::May && attrType.isInteger(64))
       return;
     break;
   }
   case StandardAttributes::Float: {
     auto floatAttr = attr.cast<FloatAttr>();
     printFloatValue(floatAttr.getValue(), os);
 
     // FloatAttr elides the type if F64.
-    if (mayElideType && floatAttr.getType().isF64())
+    if (typeElision == AttrTypeElision::May && attrType.isF64())
       return;
     break;
   }
   case StandardAttributes::String:
     os << '"';
     printEscapedString(attr.cast<StringAttr>().getValue(), os);
     os << '"';
     break;
   case StandardAttributes::Array:
     os << '[';
     interleaveComma(attr.cast<ArrayAttr>().getValue(), [&](Attribute attr) {
-      printAttribute(attr, /*mayElideType=*/true);
+      printAttribute(attr, AttrTypeElision::May);
     });
     os << ']';
     break;
   case StandardAttributes::AffineMap:
     os << "affine_map<";
     attr.cast<AffineMapAttr>().getValue().print(os);
     os << '>';
 
void ModulePrinter::printAttribute(Attribute attr,
   case StandardAttributes::FusedLocation:
   case StandardAttributes::NameLocation:
   case StandardAttributes::OpaqueLocation:
   case StandardAttributes::UnknownLocation:
     printLocation(attr.cast<LocationAttr>());
     break;
   }
 
-  // Print the type if it isn't a 'none' type.
-  auto attrType = attr.getType();
-  if (!attrType.isa<NoneType>()) {
+  // Don't print the type if we must elide it, or if it is a None type.
+  if (typeElision != AttrTypeElision::Must && !attrType.isa<NoneType>()) {
     os << " : ";
     printType(attrType);
   }
 }
 
 /// Print the integer element of the given DenseElementsAttr at 'index'.
 static void printDenseIntElement(DenseElementsAttr attr, raw_ostream &os,
                                  unsigned index) {
public:
   /// Print the given type.
   void printType(Type type) override { ModulePrinter::printType(type); }
 
   /// Print the given attribute.
   void printAttribute(Attribute attr) override {
     ModulePrinter::printAttribute(attr);
   }
 
+  /// Print the given attribute without its type. The corresponding parser must
+  /// provide a valid type for the attribute.
+  void printAttributeWithoutType(Attribute attr) override {
+    ModulePrinter::printAttribute(attr, AttrTypeElision::Must);
+  }
+
   /// Print the ID for the given value.
   void printOperand(Value value) override { printValueID(value); }
 
   /// Print an optional attribute dictionary with a given set of elided values.
   void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
                              ArrayRef<StringRef> elidedAttrs = {}) override {
     ModulePrinter::printOptionalAttrDict(attrs, elidedAttrs);
   }

mlir/lib/Parser/Parser.cpp

public:
   /// Parse a float attribute.
   Attribute parseFloatAttr(Type type, bool isNegative);
 
   /// Parse a decimal or a hexadecimal literal, which can be either an integer
   /// or a float attribute.
   Attribute parseDecOrHexAttr(Type type, bool isNegative);
 
   /// Parse an opaque elements attribute.
-  Attribute parseOpaqueElementsAttr();
+  Attribute parseOpaqueElementsAttr(Type attrType);
 
   /// Parse a dense elements attribute.
-  Attribute parseDenseElementsAttr();
-  ShapedType parseElementsLiteralType();
+  Attribute parseDenseElementsAttr(Type attrType);
+  ShapedType parseElementsLiteralType(Type type);
 
   /// Parse a sparse elements attribute.
-  Attribute parseSparseElementsAttr();
+  Attribute parseSparseElementsAttr(Type attrType);
 
   //===--------------------------------------------------------------------===//
   // Location Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse an inline location.
   ParseResult parseLocation(LocationAttr &loc);
 
case Token::kw_false:
     consumeToken(Token::kw_false);
     return builder.getBoolAttr(false);
   case Token::kw_true:
     consumeToken(Token::kw_true);
     return builder.getBoolAttr(true);
 
   // Parse a dense elements attribute.
   case Token::kw_dense:
-    return parseDenseElementsAttr();
+    return parseDenseElementsAttr(type);
 
   // Parse a dictionary attribute.
   case Token::l_brace: {
     SmallVector<NamedAttribute, 4> elements;
     if (parseAttributeDict(elements))
       return nullptr;
     return builder.getDictionaryAttr(elements);
   }
Attribute Parser::parseAttribute(Type type) {
   // Parse a location attribute.
   case Token::kw_loc: {
     LocationAttr attr;
     return failed(parseLocation(attr)) ? Attribute() : attr;
   }
 
   // Parse an opaque elements attribute.
   case Token::kw_opaque:
-    return parseOpaqueElementsAttr();
+    return parseOpaqueElementsAttr(type);
 
   // Parse a sparse elements attribute.
   case Token::kw_sparse:
-    return parseSparseElementsAttr();
+    return parseSparseElementsAttr(type);
 
   // Parse a string attribute.
   case Token::string: {
     auto val = getToken().getStringValue();
     consumeToken(Token::string);
     // Parse the optional trailing colon type if one wasn't explicitly provided.
     if (!type && consumeIf(Token::colon) && !(type = parseType()))
       return Attribute();
Attribute Parser::parseDecOrHexAttr(Type type, bool isNegative) {
   if (isNegative ? (int64_t)-val.getValue() >= 0 : (int64_t)val.getValue() < 0)
     return emitError(loc, "integer constant out of range for attribute"),
            nullptr;
 
   return builder.getIntegerAttr(type, isNegative ? -apInt : apInt);
 }
 
 /// Parse an opaque elements attribute.
-Attribute Parser::parseOpaqueElementsAttr() {
+Attribute Parser::parseOpaqueElementsAttr(Type attrType) {
   consumeToken(Token::kw_opaque);
   if (parseToken(Token::less, "expected '<' after 'opaque'"))
     return nullptr;
 
   if (getToken().isNot(Token::string))
     return (emitError("expected dialect namespace"), nullptr);
 
   auto name = getToken().getStringValue();
Attribute Parser::parseOpaqueElementsAttr(Type attrType) {
   if (val.size() < 2 || val[0] != '0' || val[1] != 'x')
     return (emitError("opaque string should start with '0x'"), nullptr);
 
   val = val.substr(2);
   if (!llvm::all_of(val, llvm::isHexDigit))
     return (emitError("opaque string only contains hex digits"), nullptr);
 
   consumeToken(Token::string);
-  if (parseToken(Token::greater, "expected '>'") ||
-      parseToken(Token::colon, "expected ':'"))
+  if (parseToken(Token::greater, "expected '>'"))
     return nullptr;
 
-  auto type = parseElementsLiteralType();
+  auto type = parseElementsLiteralType(attrType);
   if (!type)
     return nullptr;
 
   return OpaqueElementsAttr::get(dialect, type, llvm::fromHex(val));
 }
 
 namespace {
 class TensorLiteralParser {
ParseResult TensorLiteralParser::parseList(SmallVectorImpl<int64_t> &dims) {
   // Return the sublists' dimensions with 'size' prepended.
   dims.clear();
   dims.push_back(size);
   dims.append(newDims.begin(), newDims.end());
   return success();
 }
 
 /// Parse a dense elements attribute.
-Attribute Parser::parseDenseElementsAttr() {
+Attribute Parser::parseDenseElementsAttr(Type attrType) {
   consumeToken(Token::kw_dense);
   if (parseToken(Token::less, "expected '<' after 'dense'"))
     return nullptr;
 
   // Parse the literal data.
   TensorLiteralParser literalParser(*this);
   if (literalParser.parse())
     return nullptr;
 
-  if (parseToken(Token::greater, "expected '>'") ||
-      parseToken(Token::colon, "expected ':'"))
+  if (parseToken(Token::greater, "expected '>'"))
     return nullptr;
 
   auto typeLoc = getToken().getLoc();
-  auto type = parseElementsLiteralType();
+  auto type = parseElementsLiteralType(attrType);
   if (!type)
     return nullptr;
   return literalParser.getAttr(typeLoc, type);
 }
 
 /// Shaped type for elements attribute.
 ///
 ///   elements-literal-type ::= vector-type | ranked-tensor-type
 ///
 /// This method also checks the type has static shape.
-ShapedType Parser::parseElementsLiteralType() {
-  auto type = parseType();
-  if (!type)
+ShapedType Parser::parseElementsLiteralType(Type type) {
+  // If the user didn't provide a type, parse the colon type for the literal.
+  if (!type) {
+    if (parseToken(Token::colon, "expected ':'"))
       return nullptr;
+    if (!(type = parseType()))
+      return nullptr;
+  }
 
   if (!type.isa<RankedTensorType>() && !type.isa<VectorType>()) {
     emitError("elements literal must be a ranked tensor or vector type");
     return nullptr;
   }
 
   auto sType = type.cast<ShapedType>();
   if (!sType.hasStaticShape())
     return (emitError("elements literal type must have static shape"), nullptr);
 
   return sType;
 }
 
 /// Parse a sparse elements attribute.
-Attribute Parser::parseSparseElementsAttr() {
+Attribute Parser::parseSparseElementsAttr(Type attrType) {
   consumeToken(Token::kw_sparse);
   if (parseToken(Token::less, "Expected '<' after 'sparse'"))
     return nullptr;
 
   /// Parse indices
   auto indicesLoc = getToken().getLoc();
   TensorLiteralParser indiceParser(*this);
   if (indiceParser.parse())
     return nullptr;
 
   if (parseToken(Token::comma, "expected ','"))
     return nullptr;
 
   /// Parse values.
   auto valuesLoc = getToken().getLoc();
   TensorLiteralParser valuesParser(*this);
   if (valuesParser.parse())
     return nullptr;
 
-  if (parseToken(Token::greater, "expected '>'") ||
-      parseToken(Token::colon, "expected ':'"))
+  if (parseToken(Token::greater, "expected '>'"))
     return nullptr;
 
-  auto type = parseElementsLiteralType();
+  auto type = parseElementsLiteralType(attrType);
   if (!type)
     return nullptr;
 
   // If the indices are a splat, i.e. the literal parser parsed an element and
   // not a list, we set the shape explicitly. The indices are represented by a
   // 2-dimensional shape where the second dimension is the rank of the type.
   // Given that the parsed indices is a splat, we know that we only have one
   // indice and thus one for the first dimension.

mlir/lib/TableGen/Attribute.cpp

StringRef tblgen::Attribute::getStorageType() const {
   return type;
 }
 
 StringRef tblgen::Attribute::getReturnType() const {
   const auto *init = def->getValueInit("returnType");
   return getValueAsString(init);
 }
 
+// Return the type constraint corresponding to the type of this attribute, or
+// None if this is not a TypedAttr.
+llvm::Optional<tblgen::Type> tblgen::Attribute::getValueType() const {
+  if (auto *defInit = dyn_cast<llvm::DefInit>(def->getValueInit("valueType")))
+    return tblgen::Type(defInit->getDef());
+  return llvm::None;
+}
+
 StringRef tblgen::Attribute::getConvertFromStorageCall() const {
   const auto *init = def->getValueInit("convertFromStorage");
   return getValueAsString(init);
 }
 
 bool tblgen::Attribute::isConstBuildable() const {
   const auto *init = def->getValueInit("constBuilderCall");
   return !getValueAsString(init).empty();

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 
 //===----------------------------------------------------------------------===//
 // Parser Gen
 
 /// The code snippet used to generate a parser call for an attribute.
 ///
 /// {0}: The storage type of the attribute.
 /// {1}: The name of the attribute.
+/// {2}: The type for the attribute.
 const char *const attrParserCode = R"(
   {0} {1}Attr;
-  if (parser.parseAttribute({1}Attr, "{1}", result.attributes))
+  if (parser.parseAttribute({1}Attr{2}, "{1}", result.attributes))
     return failure();
 )";
 
 /// The code snippet used to generate a parser call for an operand.
 ///
 /// {0}: The name of the operand.
 const char *const variadicOperandParserCode = R"(
   llvm::SMLoc {0}OperandsLoc = parser.getCurrentLocation();

 }
 
 void OperationFormat::genParser(Operator &op, OpClass &opClass) {
   auto &method = opClass.newMethod(
       "ParseResult", "parse", "OpAsmParser &parser, OperationState &result",
       OpMethod::MP_Static);
   auto &body = method.body();
 
+  // A format context used when parsing attributes with buildable types.
+  FmtContext attrTypeCtx;
+  attrTypeCtx.withBuilder("parser.getBuilder()");
+
   // Generate parsers for each of the elements.
   for (auto &element : elements) {
     /// Literals.
     if (LiteralElement *literal = dyn_cast<LiteralElement>(element.get())) {
       genLiteralParser(literal->getLiteral(), body);
 
       /// Arguments.
     } else if (auto *attr = dyn_cast<AttributeVariable>(element.get())) {
       const NamedAttribute *var = attr->getVar();
-      body << formatv(attrParserCode, var->attr.getStorageType(), var->name);
+
+      // If this attribute has a buildable type, use that when parsing the
+      // attribute.
+      std::string attrTypeStr;
+      if (Optional<Type> attrType = var->attr.getValueType()) {
+        if (Optional<StringRef> typeBuilder = attrType->getBuilderCall()) {
+          llvm::raw_string_ostream os(attrTypeStr);
+          os << ", " << tgfmt(*typeBuilder, &attrTypeCtx);
+        }
+      }
+
+      body << formatv(attrParserCode, var->attr.getStorageType(), var->name,
+                      attrTypeStr);
     } else if (auto *operand = dyn_cast<OperandVariable>(element.get())) {
       bool isVariadic = operand->getVar()->isVariadic();
       body << formatv(isVariadic ? variadicOperandParserCode
                                  : operandParserCode,
                       operand->getVar()->name);
 
       /// Directives.
     } else if (isa<AttrDictDirective>(element.get())) {
for (auto &element : elements) {
     // Optionally insert a space before the next element. The AttrDict printer
     // already adds a space as necessary.
     if (shouldEmitSpace || !lastWasPunctuation)
       body << "  p << \" \";\n";
     lastWasPunctuation = false;
     shouldEmitSpace = true;
 
     if (auto *attr = dyn_cast<AttributeVariable>(element.get())) {
-      body << "  p << " << attr->getVar()->name << "Attr();\n";
+      const NamedAttribute *var = attr->getVar();
+
+      // Elide the attribute type if it is buildable..
+      Optional<Type> attrType = var->attr.getValueType();
+      if (attrType && attrType->getBuilderCall())
+        body << "  p.printAttributeWithoutType(" << var->name << "Attr());\n";
+      else
+        body << "  p.printAttribute(" << var->name << "Attr());\n";
     } else if (auto *operand = dyn_cast<OperandVariable>(element.get())) {
       body << "  p << " << operand->getVar()->name << "();\n";
     } else if (isa<OperandsDirective>(element.get())) {
       body << "  p << getOperation()->getOperands();\n";
     } else if (auto *dir = dyn_cast<TypeDirective>(element.get())) {
       body << "  p << ";
       genTypeOperandPrinter(dir->getOperand(), body) << ";\n";
     } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element.get())) {