[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.

88

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

3137–3141

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

3137–3141

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

3137–3141

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

3137–3141

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

3141

[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
+```
+
 ### 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
     key-value pairs.
 

mlir/include/mlir/IR/OpBase.td

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
+  // or otherwise the default C++ equals operator.
+  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;
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");
 }
 

 
 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 `>`";
+}
+
 #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<>
+
 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<>
 )

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();

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.
+        StringRef comparator =
+            getParam().getComparator().getValueOr("$_lhs == $_rhs");
+        ctx.addSubst("_lhs", self).addSubst("_rhs", *defaultValue);
+        os << " && !(" << tgfmt(comparator, &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)) {}
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());
-    else
+    if (param.isOptional()) {
+      std::string defaultCtor = (param.getCppStorageType() + "()").str();
+      os << formatv(",\n    _result_{0}.getValueOr({1})", param.getName(),
+                    param.getDefaultValue().getValueOr(defaultCtor));
+    } 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))
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);
   }