[mlir][OpFormatGen] Add support for eliding UnitAttr when used to anchor an optional group

[rriddle]

Summary

Unit attributes are given meaning by their existence, and thus have no meaningful value beyond "is it present". As such, in the format of an operation unit attributes are generally used to guard the printing of other elements and aren't generally printed themselves; as the presence of the group when parsing means that the unit attribute should be added. This revision adds support to the declarative format for eliding unit attributes in situations where they anchor an optional group, but aren't the first element.

For example,

let assemblyFormat = "(`is_optional` $unit_attr^)? attr-dict";

would print foo.op is_optional when $unit_attr is present, instead of the current foo.op is_optional unit.

[jpienaar]

mlir/docs/OpDefinitions.md

750

Do we have test for when it is and isn't the first element?

[rriddle]

Add another test

[rriddle]

mlir/docs/OpDefinitions.md

750

I had one for when it wasn't, added one for when it is.

[jpienaar]

Thanks

mlir/tools/mlir-tblgen/OpFormatGen.cpp

668

Tab?

1093

Tabs

mlir/docs/OpDefinitions.md

-   Any attribute variable may be used, but only optional attributes can be
         marked as the anchor.
     -   Only variadic or optional operand arguments can be used.
     -   The operands to a type directive must be defined within the optional
         group.
 
 An example of an operation with an optional group is `std.return`, which has a
 variadic number of operands.
 
-```
+```tablegen
 def ReturnOp : ... {
   let arguments = (ins Variadic<AnyType>:$operands);
 
   // We only print the operands and types if there are a non-zero number
   // of operands.
   let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
 }
 ```
 
+##### Unit Attributes
+
+In MLIR, the [`unit` Attribute](LangRef.md#unit-attribute) is special in that it
+only has one possible value, i.e. it derives meaning from its existence. When a
+unit attribute is used to anchor an optional group and is not the first element
+of the group, the presence of the unit attribute can be directly correlated with
+the presence of the optional group itself. As such, in these situations the unit
+attribute will not be printed or present in the output and will be automatically
+inferred when parsing by the presence of the optional group itself.
+
+For example, the following operation:
+
+```tablegen
+def FooOp : ... {
+  let arguments = (ins UnitAttr:$is_read_only);
+
+  let assemblyFormat = "attr-dict (`is_read_only` $is_read_only^)?";
+}
+```
+
+would be formatted as such:
+
+```mlir
+// When the unit attribute is present:
+foo.op is_read_only
+
+// When the unit attribute is not present:
+foo.op
+```
+
 #### 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/test/lib/Dialect/Test/TestOps.td

 def FormatInferVariadicTypeFromNonVariadic
     : TEST_Op<"format_infer_variadic_type_from_non_variadic",
               [SameOperandsAndResultType]> {
   let arguments = (ins Variadic<AnyType>:$operands);
   let results = (outs AnyType:$result);
   let assemblyFormat = "$operands attr-dict `:` type($result)";
 }
 
+def FormatOptionalUnitAttr : TEST_Op<"format_optional_unit_attribute"> {
+  let arguments = (ins UnitAttr:$is_optional);
+  let assemblyFormat = "(`is_optional` $is_optional^)? attr-dict";
+}
+
 //===----------------------------------------------------------------------===//
 // AllTypesMatch type inference
 //===----------------------------------------------------------------------===//
 
 def FormatAllTypesMatchVarOp : TEST_Op<"format_all_types_match_var", [
     AllTypesMatch<["value1", "value2", "result"]>
   ]> {
   let arguments = (ins AnyType:$value1, AnyType:$value2);

mlir/test/mlir-tblgen/op-format.mlir

"foo.successor_test_region"() ( {
 
   ^bb2:
     // CHECK: test.format_successor_a_op {attr}
     test.format_successor_a_op {attr}
 
 }) { arg_names = ["i", "j", "k"] } : () -> ()
 
 //===----------------------------------------------------------------------===//
+// Format optional attributes
+//===----------------------------------------------------------------------===//
+
+// CHECK: test.format_optional_unit_attribute is_optional
+test.format_optional_unit_attribute is_optional
+
+// CHECK: test.format_optional_unit_attribute
+// CHECK-NOT: is_optional
+test.format_optional_unit_attribute
+
+//===----------------------------------------------------------------------===//
 // Format optional operands and results
 //===----------------------------------------------------------------------===//
 
 // CHECK: test.format_optional_operand_result_a_op(%[[I64]] : i64) : i64
 test.format_optional_operand_result_a_op(%i64 : i64) : i64
 
 // CHECK: test.format_optional_operand_result_a_op( : ) : i64
 test.format_optional_operand_result_a_op( : ) : i64

mlir/tools/mlir-tblgen/OpFormatGen.cpp

using VariableElement<NamedAttribute,
                         Element::Kind::AttributeVariable>::VariableElement;
 
   /// Return the constant builder call for the type of this attribute, or None
   /// if it doesn't have one.
   Optional<StringRef> getTypeBuilder() const {
     Optional<Type> attrType = var->attr.getValueType();
     return attrType ? attrType->getBuilderCall() : llvm::None;
   }
+
+  /// Return if this attribute refers to a UnitAttr.
+  bool isUnitAttr() const {
+    return var->attr.getBaseAttr().getAttrDefName() == "UnitAttr";
+  }
 };
 
 /// This class represents a variable that refers to an operand argument.
 using OperandVariable =
     VariableElement<NamedTypeConstraint, Element::Kind::OperandVariable>;
 
 /// This class represents a variable that refers to a result.
 using ResultVariable =
if (auto *attrVar = dyn_cast<AttributeVariable>(firstElement)) {
       body << "  if (succeeded(parser.parseOptional";
       genLiteralParser(literal->getLiteral(), body);
       body << ")) {\n";
     } else if (auto *opVar = dyn_cast<OperandVariable>(firstElement)) {
       genElementParser(opVar, body, attrTypeCtx);
       body << "  if (!" << opVar->getVar()->name << "Operands.empty()) {\n";
     }
 
+    // If the anchor is a unit attribute, we don't need to print it. When
+    // parsing, we will add this attribute if this group is present.
+    Element *elidedAnchorElement = nullptr;
+    auto *anchorAttr = dyn_cast<AttributeVariable>(optional->getAnchor());
+    if (anchorAttr && anchorAttr != firstElement && anchorAttr->isUnitAttr()) {
+      elidedAnchorElement = anchorAttr;
+
+      // Add the anchor unit attribute to the operation state.
+      body << "    result.addAttribute(\"" << anchorAttr->getVar()->name
+           << "\", parser.getBuilder().getUnitAttr());\n";
+    }
+
     // Generate the rest of the elements normally.
-    for (auto &childElement : llvm::drop_begin(elements, 1))
+    for (Element &childElement : llvm::drop_begin(elements, 1)) {
+      if (&childElement != elidedAnchorElement)
         genElementParser(&childElement, body, attrTypeCtx);
+    }
     body << "  }\n";
 
     /// Literals.
   } else if (LiteralElement *literal = dyn_cast<LiteralElement>(element)) {
     body << "  if (parser.parse";
     genLiteralParser(literal->getLiteral(), body);
     body << ")\n    return failure();\n";
 
if (auto *operand = dyn_cast<OperandVariable>(anchor)) {
         body << "  if (" << var->name << "()) {\n";
       else if (var->isVariadic())
         body << "  if (!" << var->name << "().empty()) {\n";
     } else {
       body << "  if (getAttr(\""
            << cast<AttributeVariable>(anchor)->getVar()->name << "\")) {\n";
     }
 
+    // If the anchor is a unit attribute, we don't need to print it. When
+    // parsing, we will add this attribute if this group is present.
+    auto elements = optional->getElements();
+    Element *elidedAnchorElement = nullptr;
+    auto *anchorAttr = dyn_cast<AttributeVariable>(anchor);
+    if (anchorAttr && anchorAttr != &*elements.begin() &&
+        anchorAttr->isUnitAttr()) {
+      elidedAnchorElement = anchorAttr;
+    }
+
     // Emit each of the elements.
-    for (Element &childElement : optional->getElements())
+    for (Element &childElement : elements) {
+      if (&childElement != elidedAnchorElement) {
         genElementPrinter(&childElement, body, fmt, op, shouldEmitSpace,
                           lastWasPunctuation);
+      }
+    }
     body << "  }\n";
     return;
   }
 
   // Emit the attribute dictionary.
   if (auto *attrDict = dyn_cast<AttrDictDirective>(element)) {
     genAttrDictPrinter(fmt, op, body, attrDict->isWithKeyword());
     lastWasPunctuation = false;