[mlir][ods] Default-valued parameters in attribute or type defs

[Mogball]

Summary

Optional parameters with defaultValue set will be populated with that value if they aren't encountered during parsing. Moreover, parameters equal to their default values are elided when printing.

Depends on D118210

[rriddle]

mlir/docs/Tutorials/DefiningAttributesAndTypes.md

525

527

Parameters have a comparator field, which I assume should be what this is driven through (which could mean the == of the type, but doesn't have to be).

529–534

Would be good to show example outputs here.

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

65

This should use the comparator field. Would likely be good to add a test with something like APInt.

87

302

Storing a twine value is playing with fire a bit, Twine generally takes variables by reference. I would inline this (param.getCppStorageType() + "()").str()/ generate the string right here.

[Mogball]

review comments + new test case for APFloat with comparator

[lattner]

This is really cool Jeff!

[rriddle]

mlir/docs/Tutorials/DefiningAttributesAndTypes.md

541–542

Can you give an example on how this interacts with optional groups?

mlir/test/lib/Dialect/Test/TestTypeDefs.td

334–335

nit: Prefer the original namespace if we need to specify it (i.e. llvm in this case).

350–351

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

65

Is the llvm:: here necessary?

[rriddle]

mlir/include/mlir/IR/OpBase.td

3148–3152

It looks like this requires that the parameter be statically constructible. Conceptually though, we could at least provide an instance of the context to allow for building things like default attributes/types.

[Mogball]

mlir/include/mlir/IR/OpBase.td

3148–3152

getContext() would work, but I didn't want to add a substitution because I wonder if the default values should be also added to the getters:

SomeAttr get(MLIRContext *ctx, int value = 5);

Evidently, having a context in the default value string would not be valid here. If default values were not set in the getters, then the default values of the parameters would not exist outside of the parser/printer. If I wanted to get an attribute with default-valued parameters in C++, there would be no way to do so.

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

65

Yes. Otherwise it conflicts with VariableElement::Optional.

[Mogball]

review comments

[rriddle]

mlir/include/mlir/IR/OpBase.td

3148–3152

I wouldn't worry about that given that you can just do what the C++ compiler will do for you anyways:

// This:
SomeAttr get(MLIRContext *ctx, int value = 5);

// Just turns into (generally speaking):
SomeAttr get(MLIRContext *ctx, int value);
SomeAttr get(MLIRContext *ctx) { return get(ctx, 5); }

[rriddle]

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

69

Should we just set this as the default value of the comparator field?

[Mogball]

mlir/include/mlir/IR/OpBase.td

3148–3152

Oh, true.

[Mogball]

review comments

[Mogball]

Add the context substitution and add a test case

[rriddle]

Really awesome stuff!

mlir/docs/Tutorials/DefiningAttributesAndTypes.md

546

Is ctxt what we use everywhere else? IMO, we should really unify around _ctx (which more closely aligns with what we shorten it to in C++).

mlir/include/mlir/IR/OpBase.td

3152

[Mogball]

mlir/docs/Tutorials/DefiningAttributesAndTypes.md

546

It's actually inconsistent. There is one use of _ctx and four (including this one) of _ctxt. I also thought it was weird that it's _ctxt and not _ctx. I'll swap this one to _ctx

[Mogball]

change _ctxt to _ctx

mlir/docs/Tutorials/DefiningAttributesAndTypes.md

 ( `(` $a^ `)` ) : (`x`)?
 ```
 
 In the above assembly format, if `a` is present (non-null), then it will be
 printed as `(5 : i32)`. If it is not present, it will be `x`. Directives that
 are used inside optional groups are allowed only if all captured parameters are
 also optional.
 
+#### Default-Valued Parameters
+
+Optional parameters can be given default values by setting `defaultValue`, a
+string of the C++ default value, or by using `DefaultValuedParameter`. If a
+value for the parameter was not encountered during parsing, it is set to this
+default value. If a parameter is equal to its default value, it is not printed.
+The `comparator` field of the parameter is used, but if one is not specified,
+the equality operator is used.
+
+For example:
+
+```
+let parameters = (ins DefaultValuedParameter<"Optional<int>", "5">:$a)
+let mnemonic = "default_valued";
+let assemblyFormat = "(`<` $a^ `>`)?";
+```
+
+Which will look like:
+
+```
+!test.default_valued     // a = 5
+!test.default_valued<10> // a = 10
+```
+
+For optional `Attribute` or `Type` parameters, the current MLIR context is
+available through `$_ctx`. E.g.
+
+```
+DefaultValuedParameter<"IntegerType", "IntegerType::get($_ctx, 32)">
+```
+
 ### Assembly Format Directives
 
 Attribute and type assembly formats have the following directives:
 
 *   `params`: capture all parameters of an attribute or type.
 *   `qualified`: mark a parameter to be printed with its leading dialect and
     mnemonic.
 *   `struct`: generate a "struct-like" parser and printer for a list of

mlir/include/mlir/IR/OpBase.td

let predicate = CPred<"$_self.isa<" # dialect.cppNamespace #
                                  "::" # cppClassName # ">()">;
 }
 
 // 'Parameters' should be subclasses of this or simple strings (which is a
 // shorthand for AttrOrTypeParameter<"C++Type">).
 class AttrOrTypeParameter<string type, string desc, string accessorType = ""> {
   // Custom memory allocation code for storage constructor.
   code allocator = ?;
-  // Custom comparator used to compare two instances for equality.
+  // Comparator used to compare two instances for equality. By default, it uses
+  // the C++ equality operator.
   code comparator = ?;
   // The C++ type of this parameter.
   string cppType = type;
   // The C++ type of the accessor for this parameter.
   string cppAccessorType = !if(!empty(accessorType), type, accessorType);
   // The C++ storage type of of this parameter if it is a reference, e.g.
   // `std::string` for `StringRef` or `SmallVector` for `ArrayRef`.
   string cppStorageType = ?;
class AttrOrTypeParameter<string type, string desc, string accessorType = ""> {
   // The default parameter printer is `$_printer << $_self`. Overload the stream
   // operator of `AsmPrinter` as necessary to print your type. Or you can
   // provide a custom printer.
   string printer = ?;
   // Mark a parameter as optional. The C++ type of parameters marked as optional
   // must be default constructible and be contextually convertible to `bool`.
   // Any `Optional<T>` and any attribute type satisfies these requirements.
   bit isOptional = 0;
+  // Provide a default value for the parameter. Parameters with default values
+  // are considered optional. If a value was not parsed for the parameter, it
+  // will be set to the default value. Parameters equal to their default values
+  // are elided when printing. Equality is checked using the `comparator` field,
+  // which by default is the C++ equality operator. The current MLIR context is
+  // made available through `$_ctx`, e.g., for constructing default values for
+  // attributes and types.
+  string defaultValue = ?;
 }
 class AttrParameter<string type, string desc, string accessorType = "">
  : AttrOrTypeParameter<type, desc, accessorType>;
 class TypeParameter<string type, string desc, string accessorType = "">
  : AttrOrTypeParameter<type, desc, accessorType>;
 
 // For StringRefs, which require allocation.
 class StringRefParameter<string desc = ""> :

 }
 
 // An optional parameter.
 class OptionalParameter<string type, string desc = ""> :
     AttrOrTypeParameter<type, desc> {
   let isOptional = 1;
 }
 
+// A parameter with a default value.
+class DefaultValuedParameter<string type, string value, string desc = ""> :
+    AttrOrTypeParameter<type, desc> {
+  let isOptional = 1;
+  let defaultValue = value;
+}
+
 // This is a special parameter used for AttrDefs that represents a `mlir::Type`
 // that is also used as the value `Type` of the attribute. Only one parameter
 // of the attribute may be of this type.
 class AttributeSelfTypeParameter<string desc,
                                  string derivedType = "::mlir::Type"> :
     AttrOrTypeParameter<derivedType, desc> {}
 
 #endif // OP_BASE

mlir/include/mlir/TableGen/AttrOrTypeDef.h

 
 /// A wrapper class for tblgen AttrOrTypeParameter, arrays of which belong to
 /// AttrOrTypeDefs to parameterize them.
 class AttrOrTypeParameter {
 public:
   explicit AttrOrTypeParameter(const llvm::DagInit *def, unsigned index)
       : def(def), index(index) {}
 
+  /// Returns true if the parameter is anonymous (has no name).
+  bool isAnonymous() const;
+
   /// Get the parameter name.
   StringRef getName() const;
 
   /// If specified, get the custom allocator code for this parameter.
   Optional<StringRef> getAllocator() const;
 
   /// If specified, get the custom comparator code for this parameter.
-  Optional<StringRef> getComparator() const;
+  StringRef getComparator() const;
 
   /// Get the C++ type of this parameter.
   StringRef getCppType() const;
 
   /// Get the C++ accessor type of this parameter.
   StringRef getCppAccessorType() const;
 
   /// Get the C++ storage type of this parameter.
public:
   Optional<StringRef> getSummary() const;
 
   /// Get the assembly syntax documentation.
   StringRef getSyntax() const;
 
   /// Returns true if the parameter is optional.
   bool isOptional() const;
 
+  /// Get the default value of the parameter if it has one.
+  Optional<StringRef> getDefaultValue() const;
+
   /// Return the underlying def of this parameter.
   llvm::Init *getDef() const;
 
   /// The parameter is pointer-comparable.
   bool operator==(const AttrOrTypeParameter &other) const {
     return def == other.def && index == other.index;
   }
   bool operator!=(const AttrOrTypeParameter &other) const {

mlir/lib/TableGen/AttrOrTypeDef.cpp

auto AttrOrTypeParameter::getDefValue(StringRef name) const {
   Optional<decltype(std::declval<InitT>().getValue())> result;
   if (auto *param = dyn_cast<llvm::DefInit>(getDef()))
     if (auto *init = param->getDef()->getValue(name))
       if (auto *value = dyn_cast_or_null<InitT>(init->getValue()))
         result = value->getValue();
   return result;
 }
 
+bool AttrOrTypeParameter::isAnonymous() const {
+  return !def->getArgName(index);
+}
+
 StringRef AttrOrTypeParameter::getName() const {
   return def->getArgName(index)->getValue();
 }
 
 Optional<StringRef> AttrOrTypeParameter::getAllocator() const {
   return getDefValue<llvm::StringInit>("allocator");
 }
 
-Optional<StringRef> AttrOrTypeParameter::getComparator() const {
-  return getDefValue<llvm::StringInit>("comparator");
+StringRef AttrOrTypeParameter::getComparator() const {
+  return getDefValue<llvm::StringInit>("comparator")
+      .getValueOr("$_lhs == $_rhs");
 }
 
 StringRef AttrOrTypeParameter::getCppType() const {
   llvm::Init *parameterType = getDef();
   if (auto *stringType = dyn_cast<llvm::StringInit>(parameterType))
     return stringType->getValue();
   if (auto *param = dyn_cast<llvm::DefInit>(parameterType))
     return param->getDef()->getValueAsString("cppType");

 
 StringRef AttrOrTypeParameter::getSyntax() const {
   if (auto *stringType = dyn_cast<llvm::StringInit>(getDef()))
     return stringType->getValue();
   return getDefValue<llvm::StringInit>("syntax").getValueOr(getCppType());
 }
 
 bool AttrOrTypeParameter::isOptional() const {
-  return getDefValue<llvm::BitInit>("isOptional").getValueOr(false);
+  // Parameters with default values are automatically optional.
+  return getDefValue<llvm::BitInit>("isOptional").getValueOr(false) ||
+         getDefaultValue().hasValue();
+}
+
+Optional<StringRef> AttrOrTypeParameter::getDefaultValue() const {
+  return getDefValue<llvm::StringInit>("defaultValue");
 }
 
 llvm::Init *AttrOrTypeParameter::getDef() const { return def->getArg(index); }
 
 //===----------------------------------------------------------------------===//
 // AttributeSelfTypeParameter
 //===----------------------------------------------------------------------===//
 
 bool AttributeSelfTypeParameter::classof(const AttrOrTypeParameter *param) {
   llvm::Init *paramDef = param->getDef();
   if (auto *paramDefInit = dyn_cast<llvm::DefInit>(paramDef))
     return paramDefInit->getDef()->isSubClassOf("AttributeSelfTypeParameter");
   return false;
 }

mlir/test/lib/Dialect/Test/TestTypeDefs.td

 
 def TestTypeOptionalGroup : Test_Type<"TestTypeOptionalGroup"> {
   let parameters = (ins "int":$a, OptionalParameter<"mlir::Optional<int>">:$b);
   let mnemonic = "optional_group";
   let assemblyFormat = "`<` (`(` $b^ `)`) : (`x`)? $a `>`";
 }
 
 def TestTypeOptionalGroupParams : Test_Type<"TestTypeOptionalGroupParams"> {
-  let parameters = (ins OptionalParameter<"mlir::Optional<int>">:$a,
+  let parameters = (ins DefaultValuedParameter<"mlir::Optional<int>", "10">:$a,
                         OptionalParameter<"mlir::Optional<int>">:$b);
   let mnemonic = "optional_group_params";
   let assemblyFormat = "`<` (`(` params^ `)`) : (`x`)? `>`";
 }
 
 def TestTypeOptionalGroupStruct : Test_Type<"TestTypeOptionalGroupStruct"> {
   let parameters = (ins OptionalParameter<"mlir::Optional<int>">:$a,
                         OptionalParameter<"mlir::Optional<int>">:$b);
   let mnemonic = "optional_group_struct";
   let assemblyFormat = "`<` (`(` struct(params)^ `)`) : (`x`)? `>`";
 }
 
 def TestTypeSpaces : Test_Type<"TestTypeSpaceS"> {
   let parameters = (ins "int":$a, "int":$b);
   let mnemonic = "spaces";
   let assemblyFormat = "`<` ` ` $a `\\n` `(` `)` `` `(` `)` $b `>`";
 }
 
+class DefaultValuedAPFloat<string value>
+    : DefaultValuedParameter<"llvm::Optional<llvm::APFloat>",
+                             "llvm::Optional<llvm::APFloat>(" # value # ")"> {
+  let comparator = "$_lhs->bitwiseIsEqual(*$_rhs)";
+  let parser = [{ [&]() -> mlir::FailureOr<llvm::Optional<llvm::APFloat>> {
+    mlir::FloatAttr attr;
+    auto result = $_parser.parseOptionalAttribute(attr);
+    if (result.hasValue() && mlir::succeeded(*result))
+      return {attr.getValue()};
+    if (!result.hasValue())
+      return llvm::Optional<llvm::APFloat>();
+    return mlir::failure();
+  }() }];
+  let printer = "$_printer << *$_self";
+}
+
+def TestTypeAPFloat : Test_Type<"TestTypeAPFloat"> {
+  let parameters = (ins
+    DefaultValuedAPFloat<"APFloat::getZero(APFloat::IEEEdouble())">:$a
+  );
+  let mnemonic = "ap_float";
+  let assemblyFormat = "`<` $a `>`";
+}
+
+def TestTypeDefaultValuedType : Test_Type<"TestTypeDefaultValuedType"> {
+  let parameters = (ins
+    DefaultValuedParameter<"mlir::IntegerType",
+                           "mlir::IntegerType::get($_ctx, 32)">:$type
+  );
+  let mnemonic = "default_valued_type";
+  let assemblyFormat = "`<` (`(` $type^ `)`)? `>`";
+}
+
 #endif // TEST_TYPEDEFS

mlir/test/mlir-tblgen/attr-or-type-format-roundtrip.mlir

 // CHECK: !test.optional_group_params<x>
 // CHECK: !test.optional_group_params<(5)>
 // CHECK: !test.optional_group_params<(5, 6)>
 // CHECK: !test.optional_group_struct<x>
 // CHECK: !test.optional_group_struct<(b = 5)>
 // CHECK: !test.optional_group_struct<(a = 10, b = 5)>
 // CHECK: !test.spaces< 5
 // CHECK-NEXT: ()() 6>
+// CHECK: !test.ap_float<5.000000e+00>
+// CHECK: !test.ap_float<>
+// CHECK: !test.default_valued_type<(i64)>
+// CHECK: !test.default_valued_type<>
+
 func private @test_roundtrip_default_parsers_struct(
   !test.no_parser<255, [1, 2, 3, 4, 5], "foobar", 4>
 ) -> (
   !test.struct_capture_all<v3 = 3, v1 = 1, v2 = 2, v0 = 0>,
   !test.optional_param<, 6>,
   !test.optional_param<5, 6>,
   !test.optional_params<"a">,
   !test.optional_params<5, "a">,
) -> (
   !test.optional_group<(5) 6>,
   !test.optional_group<x 6>,
   !test.optional_group_params<x>,
   !test.optional_group_params<(5)>,
   !test.optional_group_params<(5, 6)>,
   !test.optional_group_struct<x>,
   !test.optional_group_struct<(b = 5)>,
   !test.optional_group_struct<(b = 5, a = 10)>,
-  !test.spaces<5 ()() 6>
+  !test.spaces<5 ()() 6>,
+  !test.ap_float<5.0>,
+  !test.ap_float<>,
+  !test.default_valued_type<(i64)>,
+  !test.default_valued_type<>
 )

mlir/test/mlir-tblgen/attr-or-type-format.td

let parameters = (ins
       "IntegerAttr":$v2,
       "IntegerAttr":$v3
   );
 
   let mnemonic = "type_e";
   let assemblyFormat = "`{` struct($v0, $v2) `}` `{` struct($v1, $v3) `}`";
 }
 
+// TYPE: ::mlir::Type TestFType::parse(::mlir::AsmParser &odsParser) {
+// TYPE:   _result_a.getValueOr(int())
+
 // TYPE: void TestFType::print(::mlir::AsmPrinter &odsPrinter) const {
 // TYPE if (getA()) {
-// TYPE   printer << ' ';
-// TYPE   printer.printStrippedAttrOrType(getA());
+// TYPE   odsPrinter << ' ';
+// TYPE   odsPrinter.printStrippedAttrOrType(getA());
 def TypeD : TestType<"TestF"> {
   let parameters = (ins OptionalParameter<"int">:$a);
   let mnemonic = "type_f";
   let assemblyFormat = "$a";
 }
 
 // TYPE: ::mlir::Type TestGType::parse(::mlir::AsmParser &odsParser) {
 // TYPE:   if (::mlir::failed(_result_a))
 // TYPE:     return {};
 // TYPE:   if (::mlir::succeeded(_result_a) && *_result_a)
 // TYPE:     if (odsParser.parseComma())
 // TYPE:       return {};
 
-// TYPE: if (getA())
+// TYPE: if ((getA()))
 // TYPE:   odsPrinter.printStrippedAttrOrType(getA());
 // TYPE: odsPrinter << ", ";
 // TYPE: odsPrinter.printStrippedAttrOrType(getB());
 
 def TypeE : TestType<"TestG"> {
   let parameters = (ins OptionalParameter<"int">:$a, "int":$b);
   let mnemonic = "type_g";
   let assemblyFormat = "params";
 }
 
 
 // TYPE: ::mlir::Type TestHType::parse(::mlir::AsmParser &odsParser) {
 // TYPE:   do {
 // TYPE:     if (!_loop_body(_paramKey)) return {};
 // TYPE:   } while(!odsParser.parseOptionalComma());
 // TYPE:   if (!_seen_b)
 // TYPE:     return {};
 
 // TYPE: void TestHType::print(::mlir::AsmPrinter &odsPrinter) const {
-// TYPE:   if (getA()) {
+// TYPE:   if ((getA())) {
 // TYPE:     odsPrinter << "a = ";
 // TYPE:     odsPrinter.printStrippedAttrOrType(getA());
 // TYPE:     odsPrinter << ", ";
 // TYPE:   }
 
 def TypeF : TestType<"TestH"> {
   let parameters = (ins OptionalParameter<"int">:$a, "int":$b);
   let mnemonic = "type_h";

 // TYPE:       return {};
 // TYPE:     if (odsParser.parseRParen()) return {};
 // TYPE:   }
 // TYPE:   _result_a = ::mlir::FieldParser<int>::parse(odsParser);
 // TYPE:   if (::mlir::failed(_result_a))
 // TYPE:     return {};
 
 // TYPE: void TestJType::print(::mlir::AsmPrinter &odsPrinter) const {
-// TYPE:   if (getB()) {
+// TYPE:   if ((getB())) {
 // TYPE:     odsPrinter << "(";
-// TYPE:     if (getB())
+// TYPE:     if ((getB()))
 // TYPE:       odsPrinter.printStrippedAttrOrType(getB());
 // TYPE:     odsPrinter << ")";
 // TYPE:   } else {
 // TYPE:     odsPrinter << ' ' << "x";
 // TYPE:   }
 // TYPE:   odsPrinter.printStrippedAttrOrType(getA());
 
 def TypeH : TestType<"TestJ"> {
   let parameters = (ins "int":$a, OptionalParameter<"int">:$b);
   let mnemonic = "type_j";
   let assemblyFormat = "(`(` $b^ `)`) : (`x`)? $a";
 }
+
+// TYPE: ::mlir::Type TestKType::parse(::mlir::AsmParser &odsParser) {
+// TYPE:   _result_a.getValueOr(10)
+
+// TYPE: void TestKType::print(::mlir::AsmPrinter &odsPrinter) const {
+// TYPE:   if ((getA() && !(getA() == 10)))
+
+def TypeI : TestType<"TestK"> {
+  let parameters = (ins DefaultValuedParameter<"int", "10">:$a);
+  let mnemonic = "type_k";
+  let assemblyFormat = "$a";
+}

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

private:
   StringRef defType;
 };
 } // namespace
 
 DefGen::DefGen(const AttrOrTypeDef &def)
     : def(def), params(def.getParameters()), defCls(def.getCppClassName()),
       valueType(isa<AttrDef>(def) ? "Attribute" : "Type"),
       defType(isa<AttrDef>(def) ? "Attr" : "Type") {
+  // Check that all parameters have names.
+  for (const AttrOrTypeParameter &param : def.getParameters())
+    if (param.isAnonymous())
+      llvm::PrintFatalError("all parameters must have a name");
+
   // If a storage class is needed, create one.
   if (def.getNumParameters() > 0)
     storageCls.emplace(def.getStorageClassName(), /*isStruct=*/true);
 
   // Create the parent class with any indicated traits.
   createParentWithTraits();
   // Emit top-level declarations.
   emitTopLevelDeclarations();
Method *eq = storageCls->addConstMethod<Method::Inline>(
       "bool", "operator==", MethodParameter("const KeyTy &", "tblgenKey"));
   auto &body = eq->body().indent();
   auto scope = body.scope("return (", ");");
   const auto eachFn = [&](auto it) {
     FmtContext ctx({{"_lhs", isa<AttributeSelfTypeParameter>(it.value())
                                  ? "getType()"
                                  : it.value().getName()},
                     {"_rhs", strfmt("std::get<{0}>(tblgenKey)", it.index())}});
-    Optional<StringRef> comparator = it.value().getComparator();
-    body << tgfmt(comparator ? *comparator : "$_lhs == $_rhs", &ctx);
+    body << tgfmt(it.value().getComparator(), &ctx);
   };
   llvm::interleave(llvm::enumerate(params), body, eachFn, ") && (");
 }
 
 void DefGen::emitHashKey() {
   Method *hash = storageCls->addStaticInlineMethod(
       "::llvm::hash_code", "hashKey",
       MethodParameter("const KeyTy &", "tblgenKey"));

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

public:
   }
 
   /// Returns true if the element contains an optional parameter.
   bool isOptional() const { return param.isOptional(); }
 
   /// Returns the name of the parameter.
   StringRef getName() const { return param.getName(); }
 
+  /// Generate the code to check whether the parameter should be printed.
+  auto genPrintGuard(FmtContext &ctx) const {
+    return [&](raw_ostream &os) -> raw_ostream & {
+      std::string self = getParameterAccessorName(getName()) + "()";
+      ctx.withSelf(self);
+      os << tgfmt("($_self", &ctx);
+      if (llvm::Optional<StringRef> defaultValue =
+              getParam().getDefaultValue()) {
+        // Use the `comparator` field if it exists, else the equality operator.
+        std::string valueStr = tgfmt(*defaultValue, &ctx).str();
+        ctx.addSubst("_lhs", self).addSubst("_rhs", valueStr);
+        os << " && !(" << tgfmt(getParam().getComparator(), &ctx) << ")";
+      }
+      return os << ")";
+    };
+  }
+
 private:
   bool shouldBeQualifiedFlag = false;
   AttrOrTypeParameter param;
 };
 
 /// Shorthand functions that can be used with ranged-based conditions.
 static bool paramIsOptional(ParameterElement *el) { return el->isOptional(); }
 static bool paramNotOptional(ParameterElement *el) { return !el->isOptional(); }
 
+/// raw_ostream doesn't have an overload for stream functors. Declare one here.
+template <typename StreamFunctor>
+static raw_ostream &operator<<(raw_ostream &os, StreamFunctor &&fcn) {
+  return fcn(os);
+}
+
 /// Base class for a directive that contains references to multiple variables.
 template <DirectiveElement::Kind DirectiveKind>
 class ParamsDirectiveBase : public DirectiveElementBase<DirectiveKind> {
 public:
   using Base = ParamsDirectiveBase<DirectiveKind>;
 
   ParamsDirectiveBase(std::vector<ParameterElement *> &&params)
       : params(std::move(params)) {}

 
 //===----------------------------------------------------------------------===//
 // ParserGen
 //===----------------------------------------------------------------------===//
 
 void DefFormat::genParser(MethodBody &os) {
   FmtContext ctx;
   ctx.addSubst("_parser", "odsParser");
+  ctx.addSubst("_ctx", "odsParser.getContext()");
   if (isa<AttrDef>(def))
     ctx.addSubst("_type", "odsType");
   os.indent();
 
   // Declare variables to store all of the parameters. Allocated parameters
   // such as `ArrayRef` and `StringRef` must provide a `storageType`. Store
   // FailureOr<T> to defer type construction for parameters that are parsed in
   // a loop (parsers return FailureOr anyways).
void DefFormat::genParser(MethodBody &os) {
   if (def.genVerifyDecl()) {
     os << tgfmt("return $_parser.getChecked<$0>($_loc, $_parser.getContext()",
                 &ctx, def.getCppClassName());
   } else {
     os << tgfmt("return $0::get($_parser.getContext()", &ctx,
                 def.getCppClassName());
   }
   for (const AttrOrTypeParameter &param : params) {
-    if (param.isOptional())
-      os << formatv(",\n    _result_{0}.getValueOr({1}())", param.getName(),
-                    param.getCppStorageType());
+    if (param.isOptional()) {
+      os << formatv(",\n    _result_{0}.getValueOr(", param.getName());
+      if (Optional<StringRef> defaultValue = param.getDefaultValue())
+        os << tgfmt(*defaultValue, &ctx);
       else
+        os << param.getCppStorageType() << "()";
+      os << ")";
+    } else {
       os << formatv(",\n    *_result_{0}", param.getName());
     }
+  }
   os << ");";
 }
 
 void DefFormat::genElementParser(FormatElement *el, FmtContext &ctx,
                                  MethodBody &os) {
   if (auto *literal = dyn_cast<LiteralElement>(el))
     return genLiteralParser(literal->getSpelling(), ctx, os);
   if (auto *var = dyn_cast<ParameterElement>(el))

 
 //===----------------------------------------------------------------------===//
 // PrinterGen
 //===----------------------------------------------------------------------===//
 
 void DefFormat::genPrinter(MethodBody &os) {
   FmtContext ctx;
   ctx.addSubst("_printer", "odsPrinter");
+  ctx.addSubst("_ctx", "getContext()");
   os.indent();
 
   /// Generate printers.
   shouldEmitSpace = true;
   lastWasPunctuation = false;
   for (FormatElement *el : elements)
     genElementPrinter(el, ctx, os);
 }
void DefFormat::genLiteralPrinter(StringRef value, FmtContext &ctx,
   lastWasPunctuation = !(value.front() == '_' || isalpha(value.front()));
 }
 
 void DefFormat::genVariablePrinter(ParameterElement *el, FmtContext &ctx,
                                    MethodBody &os, bool skipGuard) {
   const AttrOrTypeParameter &param = el->getParam();
   ctx.withSelf(getParameterAccessorName(param.getName()) + "()");
 
-  // Guard the printer on the presence of optional parameters.
+  // Guard the printer on the presence of optional parameters and that they
+  // aren't equal to their default values (if they have one).
   if (el->isOptional() && !skipGuard) {
-    os << tgfmt("if ($_self) {\n", &ctx);
+    os << "if (" << el->genPrintGuard(ctx) << ") {\n";
     os.indent();
   }
 
   // Insert a space before the next parameter, if necessary.
   if (shouldEmitSpace || !lastWasPunctuation)
     os << tgfmt("$_printer << ' ';\n", &ctx);
   shouldEmitSpace = true;
   lastWasPunctuation = false;
 
   if (el->shouldBeQualified())
     os << tgfmt(qualifiedParameterPrinter, &ctx) << ";\n";
   else if (auto printer = param.getPrinter())
     os << tgfmt(*printer, &ctx) << ";\n";
   else
     os << tgfmt(defaultParameterPrinter, &ctx) << ";\n";
 
   if (el->isOptional() && !skipGuard)
     os.unindent() << "}\n";
 }
 
-void DefFormat::genCommaSeparatedPrinter(
-    ArrayRef<ParameterElement *> params, FmtContext &ctx, MethodBody &os,
-    function_ref<void(ParameterElement *)> extra) {
-  // Emit a space if necessary, but only if the struct is present.
-  if (shouldEmitSpace || !lastWasPunctuation) {
-    bool allOptional = llvm::all_of(params, paramIsOptional);
-    if (allOptional) {
-      os << "if (";
-      llvm::interleave(
-          params, os,
-          [&](ParameterElement *param) {
-            os << getParameterAccessorName(param->getName()) << "()";
-          },
-          " || ");
-      os << ") {\n";
-      os.indent();
-    }
+/// Generate code to guard printing on the presence of any optional parameters.
+template <typename ParameterRange>
+static void guardOnAny(FmtContext &ctx, MethodBody &os,
+                       ParameterRange &&params) {
+      [&](ParameterElement *param) { os << param->genPrintGuard(ctx); },
+
+void DefFormat::genCommaSeparatedPrinter(
+    ArrayRef<ParameterElement *> params, FmtContext &ctx, MethodBody &os,
+    function_ref<void(ParameterElement *)> extra) {
+  // Emit a space if necessary, but only if the struct is present.
+  if (shouldEmitSpace || !lastWasPunctuation) {
+    bool allOptional = llvm::all_of(params, paramIsOptional);
+    if (allOptional)
+      guardOnAny(ctx, os, params);
     os << tgfmt("$_printer << ' ';\n", &ctx);
     if (allOptional)
       os.unindent() << "}\n";
   }
 
   // The first printed element does not need to emit a comma.
   os << "{\n";
   os.indent() << "bool _firstPrinted = true;\n";
   for (ParameterElement *param : params) {
     if (param->isOptional()) {
-      os << tgfmt("if ($_self()) {\n",
-                  &ctx.withSelf(getParameterAccessorName(param->getName())));
+      os << "if (" << param->genPrintGuard(ctx) << ") {\n";
       os.indent();
     }
     os << tgfmt("if (!_firstPrinted) $_printer << \", \";\n", &ctx);
     os << "_firstPrinted = false;\n";
     extra(param);
     shouldEmitSpace = false;
     lastWasPunctuation = true;
     genVariablePrinter(param, ctx, os);
void DefFormat::genStructPrinter(StructDirective *el, FmtContext &ctx,
   genCommaSeparatedPrinter(
       llvm::to_vector(el->getParams()), ctx, os, [&](ParameterElement *param) {
         os << tgfmt("$_printer << \"$0 = \";\n", &ctx, param->getName());
       });
 }
 
 void DefFormat::genOptionalGroupPrinter(OptionalElement *el, FmtContext &ctx,
                                         MethodBody &os) {
-  // Emit the check on whether the group should be printed.
-  const auto guardOn = [&](auto params) {
-    os << "if (";
-    llvm::interleave(
-        params, os,
-        [&](ParameterElement *el) {
-          os << getParameterAccessorName(el->getName()) << "()";
-        },
-        " || ");
-    os << ") {\n";
-    os.indent();
-  };
   FormatElement *anchor = el->getAnchor();
   if (auto *param = dyn_cast<ParameterElement>(anchor)) {
-    guardOn(llvm::makeArrayRef(param));
+    guardOnAny(ctx, os, llvm::makeArrayRef(param));
   } else if (auto *params = dyn_cast<ParamsDirective>(anchor)) {
-    guardOn(params->getParams());
+    guardOnAny(ctx, os, params->getParams());
   } else {
-    auto *strct = dyn_cast<StructDirective>(anchor);
-    guardOn(strct->getParams());
+    auto *strct = cast<StructDirective>(anchor);
+    guardOnAny(ctx, os, strct->getParams());
   }
   // Generate the printer for the contained elements.
   {
     llvm::SaveAndRestore<bool> shouldEmitSpaceFlag(shouldEmitSpace);
     llvm::SaveAndRestore<bool> lastWasPunctuationFlag(lastWasPunctuation);
     for (FormatElement *element : el->getThenElements())
       genElementPrinter(element, ctx, os);
   }