[mlir][ods] Generalize default/optional parameters

[Mogball]

Summary

This patch consolidates the notions of an optional parameter and a
default parameter. An optional parameter is a parameter equal to its
default value, which for a "purely optional" parameter is its "null"
value.

This allows the existing comparator and defaultValue fields to be
used enabled more complex "optional" parameters, such as empty arrays.

Depends on D133812

[Mogball]

updated a missing change

[Mogball]

rebase

mlir/docs/AttributesAndTypes.md

 example, `StringRefParameter` uses `std::string` as its storage type, whereas
 `ArrayRefParameter` uses `SmallVector` as its storage type. The parsers for
 these parameters are expected to return `FailureOr<$cppStorageType>`.
 
 To add a custom conversion between the `cppStorageType` and the C++ type of the
 parameter, parameters can override `convertFromStorage`, which by default is
 `"$_self"` (i.e., it attempts an implicit conversion from `cppStorageType`).
 
-###### Optional Parameters
+###### Optional and Default-Valued Parameters
 
+An optional parameter can be omitted from the assembly format of an attribute or
+a type. An optional parameter is omitted when it is equal to its default value.
 Optional parameters in the assembly format can be indicated by setting
-`isOptional`. The C++ type of an optional parameter is required to satisfy the
-following requirements:
-
-- is default-constructible
-- is contextually convertible to `bool`
-- only the default-constructed value is `false`
-
-The parameter parser should return the default-constructed value to indicate "no
-value present". The printer will guard on the presence of a value to print the
-parameter.
-
-If a value was not parsed for an optional parameter, then the parameter will be
-set to its default-constructed C++ value. For example, `Optional<int>` will be
-set to `llvm::None` and `Attribute` will be set to `nullptr`.
+`defaultValue`, a string of the C++ default value. 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.
+
+When using `OptionalParameter`, the default value is set to the C++
+default-constructed value for the C++ storage type. For example, `Optional<int>`
+will be set to `llvm::None` and `Attribute` will be set to `nullptr`. The
+presence of these parameters is tested by comparing them to their "null" values.
 
 Only optional parameters or directives that only capture optional parameters can
 be used in optional groups. An optional group is a set of elements optionally
 printed based on the presence of an anchor. The group in which the anchor is
 placed is printed if it is present, otherwise the other one is printed. Suppose
 parameter `a` is an `IntegerAttr`.
 
 ```
 ( `(` $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:
+An optional parameter can also be specified with `DefaultValuedParameter`, which
+specifies that a parameter should be omitted when it is equal to some given
+value.
 
 ```tablegen
 let parameters = (ins DefaultValuedParameter<"Optional<int>", "5">:$a)
 let mnemonic = "default_valued";
 let assemblyFormat = "(`<` $a^ `>`)?";
 ```
 
 Which will look like:

mlir/include/mlir/IR/AttrTypeBase.td

class AttrOrTypeParameter<string type, string desc, string accessorType = ""> {
   // 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 = ?;
+  string cppStorageType = cppType;
   // The C++ code to convert from the storage type to the parameter type.
   string convertFromStorage = "$_self";
   // One-line human-readable description of the argument.
   string summary = desc;
   // The format string for the asm syntax (documentation only).
   string syntax = ?;
   // The default parameter parser is `::mlir::FieldParser<T>::parse($_parser)`,
   // which returns `FailureOr<T>`. Specialize `FieldParser` to support parsing
   // for your type. Or you can provide a customer printer. For attributes,
   // "$_type" will be replaced with the required attribute type.
   string parser = ?;
   // 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 `$_ctxt`, e.g., for constructing default values for
   // attributes and types.
   string defaultValue = "";
for (size_t i = 0, e = $_self.size(); i < e; ++i)
       tmpFields.push_back($_self[i].allocateInto($_allocator));
     $_dst = $_allocator.copyInto(ArrayRef<}] # arrayOf # [{>(tmpFields));
   }];
 }
 
 // An optional parameter.
 class OptionalParameter<string type, string desc = ""> :
     AttrOrTypeParameter<type, desc> {
-  let isOptional = 1;
+  let defaultValue = cppStorageType # "()";
 }
 
 // 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 attribute parameter that represents the "self" type of the
 // attribute. It is specially handled by the assembly format generator to derive
 // its value from the optional trailing type after each attribute.
 //
 // By default, the self type parameter is optional and has a default value of

mlir/lib/TableGen/AttrOrTypeDef.cpp

 
 StringRef AttrOrTypeParameter::getSyntax() const {
   if (auto *stringType = dyn_cast<llvm::StringInit>(getDef()))
     return stringType->getValue();
   return getDefValue<llvm::StringInit>("syntax").value_or(getCppType());
 }
 
 bool AttrOrTypeParameter::isOptional() const {
-  // Parameters with default values are automatically optional.
-  return getDefValue<llvm::BitInit>("isOptional").value_or(false) ||
-         getDefaultValue();
+  return getDefaultValue().has_value();
 }
 
 Optional<StringRef> AttrOrTypeParameter::getDefaultValue() const {
   Optional<StringRef> result = getDefValue<llvm::StringInit>("defaultValue");
   return result && !result->empty() ? result : llvm::None;
 }
 
 llvm::Init *AttrOrTypeParameter::getDef() const { return def->getArg(index); }

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

 
 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>> {
+    : DefaultValuedParameter<"llvm::APFloat", "llvm::APFloat(" # value # ")"> {
+  let comparator = "$_lhs.bitwiseIsEqual($_rhs)";
+  let parser = [{ [&]() -> mlir::FailureOr<llvm::APFloat> {
     mlir::FloatAttr attr;
     auto result = $_parser.parseOptionalAttribute(attr);
     if (result.has_value() && mlir::succeeded(*result))
-      return {attr.getValue()};
+      return attr.getValue();
     if (!result.has_value())
-      return llvm::Optional<llvm::APFloat>();
+      return llvm::APFloat(}] # value # [{);
     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 `>`";

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

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 (::mlir::succeeded(_result_a) && !((*_result_a) == int()))
 // TYPE:     if (odsParser.parseComma())
 // TYPE:       return {};
 
-// TYPE: if ((getA()))
+// TYPE: if (!(getA() == int()))
 // 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() == int())) {
 // 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() == int())) {
 // TYPE:     odsPrinter << "(";
-// TYPE:     if ((getB()))
+// TYPE:     if (!(getB() == int()))
 // 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.value_or(10)
 
 // TYPE: void TestKType::print(::mlir::AsmPrinter &odsPrinter) const {
-// TYPE:   if ((getA() && !(getA() == 10)))
+// TYPE:   if (!(getA() == 10))
 
 def TypeI : TestType<"TestK"> {
   let parameters = (ins DefaultValuedParameter<"int", "10">:$a);
   let mnemonic = "type_k";
   let assemblyFormat = "$a";
 }
 
 // TYPE: ::mlir::Type TestLType::parse

 }
 
 // TYPE-LABEL: ::mlir::Type TestOType::parse
 // TYPE: if (odsParser.parseOptionalQuestion())
 // TYPE: _result_a =
 // TYPE: else
 
 // TYPE-LABEL: void TestOType::print
-// TYPE: if (!((getA())))
+// TYPE: if (!(!(getA() == int())))
 // TYPE: odsPrinter << ' ' << "?"
 // TYPE: else
 // TYPE: odsPrinter.printStrippedAttrOrType(getA())
 
 def TypeM : TestType<"TestO"> {
   let parameters = (ins OptionalParameter<"int">:$a);
   let mnemonic = "type_m";
   let assemblyFormat = "(`?`) : ($a^)?";
 }
 
 // TYPE-LABEL: ::mlir::Type TestPType::parse
 // TYPE: if (odsParser.parseOptionalQuestion())
 // TYPE: bool _seen_a
 // TYPE: bool _seen_b
 // TYPE: _loop_body(_paramKey))
 // TYPE: else {
 // TYPE-NEXT: }
 
 // TYPE-LABEL: void TestPType::print
-// TYPE: if (!((getA()) || (getB())))
+// TYPE: if (!(!(getA() == int()) || !(getB() == int())))
 // TYPE-NEXT: odsPrinter << "?"
 
 def TypeN : TestType<"TestP"> {
   let parameters = (ins OptionalParameter<"int">:$a,
                         OptionalParameter<"int">:$b);
   let mnemonic = "type_n";
   let assemblyFormat = "`<` (`?`) : (struct($a, $b)^)? `>`";
 }

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(); }
 
+  /// Return the code to check whether the parameter is present.
+  auto genIsPresent(FmtContext &ctx, const Twine &self) const {
+    assert(isOptional() && "cannot guard on a mandatory parameter");
+    std::string valueStr = tgfmt(*param.getDefaultValue(), &ctx).str();
+    ctx.addSubst("_lhs", self).addSubst("_rhs", valueStr);
+    return tgfmt(getParam().getComparator(), &ctx);
+  }
+
   /// Generate the code to check whether the parameter should be printed.
   MethodBody &genPrintGuard(FmtContext &ctx, MethodBody &os) const {
+    assert(isOptional() && "cannot guard on a mandatory parameter");
     std::string self = param.getAccessorName() + "()";
-    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 << ")";
+    return os << "!(" << genIsPresent(ctx, self) << ")";
   }
 
 private:
   bool shouldBeQualifiedFlag = false;
   AttrOrTypeParameter param;
 };
 
 /// Shorthand functions that can be used with ranged-based conditions.
void DefFormat::genParser(MethodBody &os) {
   } else {
     os << tgfmt("return $0::get($_parser.getContext()", &ctx,
                 def.getCppClassName());
   }
   for (const AttrOrTypeParameter &param : params) {
     os << ",\n    ";
     std::string paramSelfStr;
     llvm::raw_string_ostream selfOs(paramSelfStr);
-    if (param.isOptional()) {
-      selfOs << formatv("(_result_{0}.value_or(", param.getName());
-      if (Optional<StringRef> defaultValue = param.getDefaultValue())
-        selfOs << tgfmt(*defaultValue, &ctx);
-      else
-        selfOs << param.getCppStorageType() << "()";
-      selfOs << "))";
+    if (Optional<StringRef> defaultValue = param.getDefaultValue()) {
+      selfOs << formatv("(_result_{0}.value_or(", param.getName())
+             << tgfmt(*defaultValue, &ctx) << "))";
     } else {
       selfOs << formatv("(*_result_{0})", param.getName());
     }
     ctx.addSubst(param.getName(), selfOs.str());
     os << param.getCppType() << "("
        << tgfmt(param.getConvertFromStorage(), &ctx.withSelf(selfOs.str()))
        << ")";
   }
if (!param->isOptional())
       lastReq = param;
   IteratorT lastReqIt = lastReq ? llvm::find(params, lastReq) : params.begin();
 
   auto eachFn = [&](ParameterElement *el) { genVariableParser(el, ctx, os); };
   auto betweenFn = [&](IteratorT it) {
     ParameterElement *el = *std::prev(it);
     // Parse a comma if the last optional parameter had a value.
     if (el->isOptional()) {
-      os << formatv("if (::mlir::succeeded(_result_{0}) && *_result_{0}) {{\n",
-                    el->getName());
+      os << formatv("if (::mlir::succeeded(_result_{0}) && !({1})) {{\n",
+                    el->getName(),
+                    el->genIsPresent(ctx, "(*_result_" + el->getName() + ")"));
       os.indent();
     }
     if (it <= lastReqIt) {
       genLiteralParser(",", ctx, os);
     } else {
       genLiteralParser(",", ctx, os, /*isOptional=*/true);
       os << ") break;\n";
     }
)";
   // {0}: Name of the parameter.
   const char *const checkParam = R"(
     if (!_seen_{0}) {
       {1}"struct is missing required parameter: ") << "{0}";
       return {{};
     }
 )";
 
-  // Optional parameters in a struct must be parsed successfully if the
-  // keyword is present.
-  //
-  // {0}: Name of the parameter.
-  // {1}: Emit error string
-  const char *const checkOptionalParam = R"(
-    if (::mlir::succeeded(_result_{0}) && !*_result_{0}) {{
-      {1}"expected a value for parameter '{0}'");
-      return {{};
-    }
-)";
-
   // First iteration of the loop parsing an optional struct.
   const char *const optionalStructFirst = R"(
   ::llvm::StringRef _paramKey;
   if (!$_parser.parseOptionalKeyword(&_paramKey)) {
     if (!_loop_body(_paramKey)) return {};
     while (!$_parser.parseOptionalComma()) {
 )";
 
   os << "// Parse parameter struct\n";
 
   // Declare a "seen" variable for each key.
   for (ParameterElement *param : el->getParams())
     os << formatv("bool _seen_{0} = false;\n", param->getName());
 
   // Generate the body of the parsing loop inside a lambda.
   os << "{\n";
   os.indent()
       << "const auto _loop_body = [&](::llvm::StringRef _paramKey) -> bool {\n";
   genLiteralParser("=", ctx, os.indent());
   for (ParameterElement *param : el->getParams()) {
     os << formatv("if (!_seen_{0} && _paramKey == \"{0}\") {\n"
                   "  _seen_{0} = true;\n",
                   param->getName());
     genVariableParser(param, ctx, os.indent());
-    if (param->isOptional()) {
-      os.getStream().printReindented(strfmt(checkOptionalParam,
-                                            param->getName(),
-                                            tgfmt(parserErrorStr, &ctx).str()));
-    }
     os.unindent() << "} else ";
     // Print the check for duplicate or unknown parameter.
   }
   os.getStream().printReindented(strfmt(loopEnd, tgfmt(parserErrorStr, &ctx)));
   os << "return true;\n";
   os.unindent() << "};\n";
 
   // Generate the parsing loop. If optional parameters are present, then the