[mlir][ODS] Add support for optional operands and results with a new Optional directive.

[rriddle]

Summary

This revision adds support for specifying operands or results as "optional". This is a special case of variadic where the number of elements is either 0 or 1. Operands and results of this kind will have accessors generated using Value instead of the range types, making it more natural to interface with.

[antiagainst]

Nice! Thnks River!

mlir/docs/OpDefinitions.md

225

nit: space before (

228

Also mention AttrSizedOperandSegments?

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

1103

Nit: else would be better here. We don't have a large body of code following this anyway.

mlir/tools/mlir-tblgen/OpFormatGen.cpp

488

remove trailing s

[rriddle]

Resolve comments

mlir/docs/OpDefinitions.md

 
 #### Variadic operands
 
 To declare a variadic operand, wrap the `TypeConstraint` for the operand with
 `Variadic<...>`.
 
 Normally operations have no variadic operands or just one variadic operand. For
 the latter case, it is easy to deduce which dynamic operands are for the static
-variadic operand definition. But if an operation has more than one variadic
-operands, it would be impossible to attribute dynamic operands to the
-corresponding static variadic operand definitions without further information
-from the operation. Therefore, the `SameVariadicOperandSize` trait is needed to
-indicate that all variadic operands have the same number of dynamic values.
+variadic operand definition. Though, if an operation has more than one variable
+length operands (either optional or variadic), it would be impossible to
+attribute dynamic operands to the corresponding static variadic operand
+definitions without further information from the operation. Therefore, either
+the `SameVariadicOperandSize` or `AttrSizedOperandSegments` trait is needed to
+indicate that all variable length operands have the same number of dynamic
+values.
+
+#### Optional operands
+
+To declare an optional operand, wrap the `TypeConstraint` for the operand with
+`Optional<...>`.
+
+Normally operations have no optional operands or just one optional operand. For
+the latter case, it is easy to deduce which dynamic operands are for the static
+operand definition. Though, if an operation has more than one variable length
+operands (either optional or variadic), it would be impossible to attribute
+dynamic operands to the corresponding static variadic operand definitions
+without further information from the operation. Therefore, either the
+`SameVariadicOperandSize` or `AttrSizedOperandSegments` trait is needed to
+indicate that all variable length operands have the same number of dynamic
+values.
 
 #### Optional attributes
 
 To declare an optional attribute, wrap the `AttrConstraint` for the attribute
 with `OptionalAttr<...>`.
 
 #### Attributes with default values
 
*   Exactly one argument variable within the group must be marked as the anchor
     -   The anchor is the element whose presence controls whether the group
         should be printed/parsed.
     -   An element is marked as the anchor by adding a trailing `^`.
     -   The first element is *not* required to be the anchor of the group.
 *   Literals, variables, and type directives are the only valid elements within
     the group.
     -   Any attribute variable may be used, but only optional attributes can be
         marked as the anchor.
-    -   Only variadic, i.e. optional, operand arguments can be used.
+    -   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.
 
 ```
 def ReturnOp : ... {

mlir/include/mlir/IR/OpBase.td

 
 // A type of a specific dialect.
 class DialectType<Dialect d, Pred condition, string descr = ""> :
     Type<condition, descr> {
   Dialect dialect = d;
 }
 
 // A variadic type constraint. It expands to zero or more of the base type. This
-// class is used for supporting variadic operands/results. An op can declare no
-// more than one variadic operand/result, and that operand/result must be the
-// last one in the operand/result list.
+// class is used for supporting variadic operands/results.
 class Variadic<Type type> : TypeConstraint<type.predicate, type.description> {
   Type baseType = type;
 }
 
+// An optional type constraint. It expands to either zero or one of the base
+// type. This class is used for supporting optional operands/results.
+class Optional<Type type> : TypeConstraint<type.predicate, type.description> {
+  Type baseType = type;
+}
+
 // A type that can be constructed using MLIR::Builder.
 // Note that this does not "inherit" from Type because it would require
 // duplicating Type subclasses for buildable and non-buildable cases to avoid
 // diamond "inheritance".
 // TODO(zinenko): we may extend this to a more general 'Buildable' trait,
 // making some Types and some Attrs buildable.
 class BuildableType<code builder> {
   // The builder call to invoke (if specified) to construct the BuildableType.

mlir/include/mlir/IR/OpImplementation.h

public:
 
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a type.
   virtual ParseResult parseType(Type &result) = 0;
 
+  /// Parse an optional type.
+  virtual OptionalParseResult parseOptionalType(Type &result) = 0;
+
   /// Parse a type of a specific type.
   template <typename TypeT>
   ParseResult parseType(TypeT &result) {
     llvm::SMLoc loc = getCurrentLocation();
 
     // Parse any kind of type.
     Type type;
     if (parseType(type))

mlir/include/mlir/TableGen/Argument.h

struct NamedAttribute {
   llvm::StringRef name;
   Attribute attr;
 };
 
 // A struct wrapping an op operand/result's constraint and its name together
 struct NamedTypeConstraint {
   // Returns true if this operand/result has constraint to be satisfied.
   bool hasPredicate() const;
+  // Returns true if this is an optional type constraint. This is a special case
+  // of variadic for 0 or 1 type.
+  bool isOptional() const;
   // Returns true if this operand/result is variadic.
   bool isVariadic() const;
+  // Returns true if this is a variable length type constraint. This is either
+  // variadic or optional.
+  bool isVariableLength() const { return isOptional() || isVariadic(); }
 
   llvm::StringRef name;
   TypeConstraint constraint;
 };
 
 // Operation argument: either attribute or operand
 using Argument = llvm::PointerUnion<NamedAttribute *, NamedTypeConstraint *>;
 
 } // end namespace tblgen
 } // end namespace mlir
 
 #endif // MLIR_TABLEGEN_ARGUMENT_H_

mlir/include/mlir/TableGen/Operator.h

struct VariableDecoratorIterator
     static VariableDecorator unwrap(llvm::Init *init);
   };
   using var_decorator_iterator = VariableDecoratorIterator;
   using var_decorator_range = llvm::iterator_range<VariableDecoratorIterator>;
 
   using value_iterator = NamedTypeConstraint *;
   using value_range = llvm::iterator_range<value_iterator>;
 
-  // Returns true if this op has variadic operands or results.
+  // Returns true if this op has variable length operands or results.
   bool isVariadic() const;
 
   // Returns true if default builders should not be generated.
   bool skipDefaultBuilders() const;
 
   // Op result iterators.
   value_iterator result_begin();
   value_iterator result_end();
public:
 
   // Returns the `index`-th result's type constraint.
   TypeConstraint getResultTypeConstraint(int index) const;
   // Returns the `index`-th result's name.
   StringRef getResultName(int index) const;
   // Returns the `index`-th result's decorators.
   var_decorator_range getResultDecorators(int index) const;
 
-  // Returns the number of variadic results in this operation.
-  unsigned getNumVariadicResults() const;
+  // Returns the number of variable length results in this operation.
+  unsigned getNumVariableLengthResults() const;
 
   // Op attribute iterators.
   using attribute_iterator = const NamedAttribute *;
   attribute_iterator attribute_begin() const;
   attribute_iterator attribute_end() const;
   llvm::iterator_range<attribute_iterator> getAttributes() const;
 
   int getNumAttributes() const { return attributes.size(); }
public:
 
   int getNumOperands() const { return operands.size(); }
   NamedTypeConstraint &getOperand(int index) { return operands[index]; }
   const NamedTypeConstraint &getOperand(int index) const {
     return operands[index];
   }
 
   // Returns the number of variadic operands in this operation.
-  unsigned getNumVariadicOperands() const;
+  unsigned getNumVariableLengthOperands() const;
 
   // Returns the total number of arguments.
   int getNumArgs() const { return arguments.size(); }
 
   using arg_iterator = const Argument *;
   using arg_range = llvm::iterator_range<arg_iterator>;
 
   // Op argument (attribute or operand) iterators.

mlir/include/mlir/TableGen/Type.h

 // TableGen.
 class TypeConstraint : public Constraint {
 public:
   explicit TypeConstraint(const llvm::Record *record);
   explicit TypeConstraint(const llvm::DefInit *init);
 
   static bool classof(const Constraint *c) { return c->getKind() == CK_Type; }
 
+  // Returns true if this is an optional type constraint.
+  bool isOptional() const;
+
   // Returns true if this is a variadic type constraint.
   bool isVariadic() const;
 
+  // Returns true if this is a variable length type constraint. This is either
+  // variadic or optional.
+  bool isVariableLength() const { return isOptional() || isVariadic(); }
+
   // Returns the builder call for this constraint if this is a buildable type,
   // returns None otherwise.
   Optional<StringRef> getBuilderCall() const;
 };
 
 // Wrapper class with helper methods for accessing Types defined in TableGen.
 class Type : public TypeConstraint {
 public:

mlir/lib/Parser/Parser.cpp

public:
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   ParseResult parseFunctionResultTypes(SmallVectorImpl<Type> &elements);
   ParseResult parseTypeListNoParens(SmallVectorImpl<Type> &elements);
   ParseResult parseTypeListParens(SmallVectorImpl<Type> &elements);
 
+  /// Optionally parse a type.
+  OptionalParseResult parseOptionalType(Type &type);
+
   /// Parse an arbitrary type.
   Type parseType();
 
   /// Parse a complex type.
   Type parseComplexType();
 
   /// Parse an extended type.
   Type parseExtendedType();
if (consumeIf(expectedToken))
     return success();
   return emitError(message);
 }
 
 //===----------------------------------------------------------------------===//
 // Type Parsing
 //===----------------------------------------------------------------------===//
 
+/// Optionally parse a type.
+OptionalParseResult Parser::parseOptionalType(Type &type) {
+  // There are many different starting tokens for a type, check them here.
+  switch (getToken().getKind()) {
+  case Token::l_paren:
+  case Token::kw_memref:
+  case Token::kw_tensor:
+  case Token::kw_complex:
+  case Token::kw_tuple:
+  case Token::kw_vector:
+  case Token::inttype:
+  case Token::kw_bf16:
+  case Token::kw_f16:
+  case Token::kw_f32:
+  case Token::kw_f64:
+  case Token::kw_index:
+  case Token::kw_none:
+  case Token::exclamation_identifier:
+    return failure(!(type = parseType()));
+
+  default:
+    return llvm::None;
+  }
+}
+
 /// Parse an arbitrary type.
 ///
 ///   type ::= function-type
 ///          | non-function-type
 ///
 Type Parser::parseType() {
   if (getToken().is(Token::l_paren))
     return parseFunctionType();
public:
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a type.
   ParseResult parseType(Type &result) override {
     return failure(!(result = parser.parseType()));
   }
 
+  /// Parse an optional type.
+  OptionalParseResult parseOptionalType(Type &result) override {
+    return parser.parseOptionalType(result);
+  }
+
   /// Parse an arrow followed by a type list.
   ParseResult parseArrowTypeList(SmallVectorImpl<Type> &result) override {
     if (parseArrow() || parser.parseFunctionResultTypes(result))
       return failure();
     return success();
   }
 
   /// Parse an optional arrow followed by a type list.

mlir/lib/TableGen/Argument.cpp

 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 
 bool tblgen::NamedTypeConstraint::hasPredicate() const {
   return !constraint.getPredicate().isNull();
 }
 
+bool tblgen::NamedTypeConstraint::isOptional() const {
+  return constraint.isOptional();
+}
+
 bool tblgen::NamedTypeConstraint::isVariadic() const {
   return constraint.isVariadic();
 }

mlir/lib/TableGen/Operator.cpp

StringRef tblgen::Operator::getExtraClassDeclaration() const {
   constexpr auto attr = "extraClassDeclaration";
   if (def.isValueUnset(attr))
     return {};
   return def.getValueAsString(attr);
 }
 
 const llvm::Record &tblgen::Operator::getDef() const { return def; }
 
-bool tblgen::Operator::isVariadic() const {
-  return getNumVariadicOperands() != 0 || getNumVariadicResults() != 0;
-}
-
 bool tblgen::Operator::skipDefaultBuilders() const {
   return def.getValueAsBit("skipDefaultBuilders");
 }
 
 auto tblgen::Operator::result_begin() -> value_iterator {
   return results.begin();
 }
 
auto tblgen::Operator::getResultDecorators(int index) const
     -> var_decorator_range {
   Record *result =
       cast<DefInit>(def.getValueAsDag("results")->getArg(index))->getDef();
   if (!result->isSubClassOf("OpVariable"))
     return var_decorator_range(nullptr, nullptr);
   return *result->getValueAsListInit("decorators");
 }
 
-unsigned tblgen::Operator::getNumVariadicResults() const {
-  return std::count_if(
-      results.begin(), results.end(),
-      [](const NamedTypeConstraint &c) { return c.constraint.isVariadic(); });
+unsigned tblgen::Operator::getNumVariableLengthResults() const {
+  return llvm::count_if(results, [](const NamedTypeConstraint &c) {
+    return c.constraint.isVariableLength();
+  });
 }
 
-unsigned tblgen::Operator::getNumVariadicOperands() const {
-  return std::count_if(
-      operands.begin(), operands.end(),
-      [](const NamedTypeConstraint &c) { return c.constraint.isVariadic(); });
+unsigned tblgen::Operator::getNumVariableLengthOperands() const {
+  return llvm::count_if(operands, [](const NamedTypeConstraint &c) {
+    return c.constraint.isVariableLength();
+  });
 }
 
 tblgen::Operator::arg_iterator tblgen::Operator::arg_begin() const {
   return arguments.begin();
 }
 
 tblgen::Operator::arg_iterator tblgen::Operator::arg_end() const {
   return arguments.end();

mlir/lib/TableGen/Pattern.cpp

case Kind::Attr: {
     LLVM_DEBUG(llvm::dbgs() << repl << " (Attr)\n");
     return std::string(repl);
   }
   case Kind::Operand: {
     assert(index < 0);
     auto *operand = op->getArg(*argIndex).get<NamedTypeConstraint *>();
     // If this operand is variadic, then return a range. Otherwise, return the
     // value itself.
-    if (operand->isVariadic()) {
+    if (operand->isVariableLength()) {
       auto repl = formatv(fmt, name);
       LLVM_DEBUG(llvm::dbgs() << repl << " (VariadicOperand)\n");
       return std::string(repl);
     }
     auto repl = formatv(fmt, formatv("(*{0}.begin())", name));
     LLVM_DEBUG(llvm::dbgs() << repl << " (SingleOperand)\n");
     return std::string(repl);
   }

mlir/lib/TableGen/Type.cpp

TypeConstraint::TypeConstraint(const llvm::Record *record)
     : Constraint(Constraint::CK_Type, record) {
   assert(def->isSubClassOf("TypeConstraint") &&
          "must be subclass of TableGen 'TypeConstraint' class");
 }
 
 TypeConstraint::TypeConstraint(const llvm::DefInit *init)
     : TypeConstraint(init->getDef()) {}
 
+bool TypeConstraint::isOptional() const {
+  return def->isSubClassOf("Optional");
+}
+
 bool TypeConstraint::isVariadic() const {
   return def->isSubClassOf("Variadic");
 }
 
 // Returns the builder call for this constraint if this is a buildable type,
 // returns None otherwise.
 Optional<StringRef> TypeConstraint::getBuilderCall() const {
   const llvm::Record *baseType = def;
-  if (isVariadic())
+  if (isVariableLength())
     baseType = baseType->getValueAsDef("baseType");
 
   // Check to see if this type constraint has a builder call.
   const llvm::RecordVal *builderCall = baseType->getValue("builderCall");
   if (!builderCall || !builderCall->getValue())
     return llvm::None;
   return TypeSwitch<llvm::Init *, Optional<StringRef>>(builderCall->getValue())
       .Case<llvm::StringInit, llvm::CodeInit>([&](auto *init) {

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

 // Test that we don't need to provide types in the format if they are buildable.
 def FormatBuildableTypeOp : TEST_Op<"format_buildable_type_op"> {
   let arguments = (ins I64:$buildable);
   let results = (outs I64:$buildable_res);
   let assemblyFormat = "$buildable attr-dict";
 }
 
 // Test various mixings of result type formatting.
-class FormatResultBase<string name, string fmt> : TEST_Op<name> {
+class FormatResultBase<string suffix, string fmt>
+    : TEST_Op<"format_result_" # suffix # "_op"> {
   let results = (outs I64:$buildable_res, AnyMemRef:$result);
   let assemblyFormat = fmt;
 }
-def FormatResultAOp : FormatResultBase<"format_result_a_op", [{
+def FormatResultAOp : FormatResultBase<"a", [{
   type($result) attr-dict
 }]>;
-def FormatResultBOp : FormatResultBase<"format_result_b_op", [{
+def FormatResultBOp : FormatResultBase<"b", [{
   type(results) attr-dict
 }]>;
-def FormatResultCOp : FormatResultBase<"format_result_c_op", [{
+def FormatResultCOp : FormatResultBase<"c", [{
   functional-type($buildable_res, $result) attr-dict
 }]>;
 
 // Test various mixings of operand type formatting.
-class FormatOperandBase<string name, string fmt> : TEST_Op<name> {
+class FormatOperandBase<string suffix, string fmt>
+    : TEST_Op<"format_operand_" # suffix # "_op"> {
   let arguments = (ins I64:$buildable, AnyMemRef:$operand);
   let assemblyFormat = fmt;
 }
 
-def FormatOperandAOp : FormatOperandBase<"format_operand_a_op", [{
+def FormatOperandAOp : FormatOperandBase<"a", [{
   operands `:` type(operands) attr-dict
 }]>;
-def FormatOperandBOp : FormatOperandBase<"format_operand_b_op", [{
+def FormatOperandBOp : FormatOperandBase<"b", [{
   operands `:` type($operand) attr-dict
 }]>;
-def FormatOperandCOp : FormatOperandBase<"format_operand_c_op", [{
+def FormatOperandCOp : FormatOperandBase<"c", [{
   $buildable `,` $operand `:` type(operands) attr-dict
 }]>;
-def FormatOperandDOp : FormatOperandBase<"format_operand_d_op", [{
+def FormatOperandDOp : FormatOperandBase<"d", [{
   $buildable `,` $operand `:` type($operand) attr-dict
 }]>;
-def FormatOperandEOp : FormatOperandBase<"format_operand_e_op", [{
+def FormatOperandEOp : FormatOperandBase<"e", [{
   $buildable `,` $operand `:` type($buildable) `,` type($operand) attr-dict
 }]>;
 
 def FormatSuccessorAOp : TEST_Op<"format_successor_a_op", [Terminator]> {
   let successors = (successor VariadicSuccessor<AnySuccessor>:$targets);
   let assemblyFormat = "$targets attr-dict";
 }
 
+// Test various mixings of optional operand and result type formatting.
+class FormatOptionalOperandResultOpBase<string suffix, string fmt>
+    : TEST_Op<"format_optional_operand_result_" # suffix # "_op",
+              [AttrSizedOperandSegments]> {
+  let arguments = (ins Optional<I64>:$optional, Variadic<I64>:$variadic);
+  let results = (outs Optional<I64>:$optional_res);
+  let assemblyFormat = fmt;
+}
+
+def FormatOptionalOperandResultAOp : FormatOptionalOperandResultOpBase<"a", [{
+  `(` $optional `:` type($optional) `)` `:` type($optional_res)
+  (`[` $variadic^ `]`)? attr-dict
+}]>;
+
+def FormatOptionalOperandResultBOp : FormatOptionalOperandResultOpBase<"b", [{
+  (`(` $optional^ `:` type($optional) `)`)? `:` type($optional_res)
+  (`[` $variadic^ `]`)? attr-dict
+}]>;
+
 //===----------------------------------------------------------------------===//
 // Test SideEffects
 //===----------------------------------------------------------------------===//
 
 def SideEffectOp : TEST_Op<"side_effect_op",
     [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let results = (outs AnyType:$result);
 }
 
 #endif // TEST_OPS

mlir/test/mlir-tblgen/op-decl.td

 
 def NS_DOp : NS_Op<"op_with_two_operands", []> {
   let arguments = (ins I32:$input1, I32:$input2);
 }
 
 // CHECK-LABEL: NS::DOp declarations
 // CHECK: OpTrait::NOperands<2>::Impl
 
+def NS_EOp : NS_Op<"op_with_optionals", []> {
+  let arguments = (ins Optional<I32>:$a);
+  let results = (outs Optional<F32>:$b);
+}
+
+// CHECK-LABEL: NS::EOp declarations
+// CHECK:   Value a();
+// CHECK:   Value b();
+// CHECK:   static void build(Builder *odsBuilder, OperationState &odsState, /*optional*/Type b, /*optional*/Value a)
+
 // Check that default builders can be suppressed.
 // ---
 
 def NS_SkipDefaultBuildersOp : NS_Op<"skip_default_builders", []> {
   let skipDefaultBuilders = 1;
   let builders = [OpBuilder<"Value val">];
 }
 

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

 // CHECK: error: only one element can be marked as the anchor of an optional group
 def OptionalInvalidF : TestFormat_Op<"optional_invalid_f", [{
   ($attr^ $attr2^) attr-dict
 }]>, Arguments<(ins OptionalAttr<I64Attr>:$attr, OptionalAttr<I64Attr>:$attr2)>;
 // CHECK: error: only optional attributes can be used to anchor an optional group
 def OptionalInvalidG : TestFormat_Op<"optional_invalid_g", [{
   ($attr^) attr-dict
 }]>, Arguments<(ins I64Attr:$attr)>;
-// CHECK: error: only variadic operands can be used within an optional group
+// CHECK: error: only variable length operands can be used within an optional group
 def OptionalInvalidH : TestFormat_Op<"optional_invalid_h", [{
   ($arg^) attr-dict
 }]>, Arguments<(ins I64:$arg)>;
 // CHECK: error: only variables can be used to anchor an optional group
 def OptionalInvalidI : TestFormat_Op<"optional_invalid_i", [{
   ($arg type($arg)^) attr-dict
 }]>, Arguments<(ins Variadic<I64>:$arg)>;
 // CHECK: error: only literals, types, and variables can be used within an optional group

 }]>, Results<(outs Variadic<I64>:$result)>;
 // CHECK: error: successor #0, named 'successor', not found
 // CHECK: note: suggest adding a '$successor' directive to the custom assembly format
 def ZCoverageInvalidF : TestFormat_Op<"variable_invalid_f", [{
    attr-dict
 }]> {
   let successors = (successor AnySuccessor:$successor);
 }
+// CHECK: error: type of operand #0, named 'operand', is not buildable and a buildable type cannot be inferred
+// CHECK: note: suggest adding a type constraint to the operation or adding a 'type($operand)' directive to the custom assembly format
+def ZCoverageInvalidG : TestFormat_Op<"variable_invalid_g", [{
+  operands attr-dict
+}]>, Arguments<(ins Optional<I64>:$operand)>;
+// CHECK: error: type of result #0, named 'result', is not buildable and a buildable type cannot be inferred
+// CHECK: note: suggest adding a type constraint to the operation or adding a 'type($result)' directive to the custom assembly format
+def ZCoverageInvalidH : TestFormat_Op<"variable_invalid_h", [{
+  attr-dict
+}]>, Results<(outs Optional<I64>:$result)>;
+
 // CHECK-NOT: error
 def ZCoverageValidA : TestFormat_Op<"variable_valid_a", [{
   $operand type($operand) type($result) attr-dict
 }]>, Arguments<(ins AnyMemRef:$operand)>, Results<(outs AnyMemRef:$result)>;
 def ZCoverageValidB : TestFormat_Op<"variable_valid_b", [{
   $operand type(operands) type(results) attr-dict
 }]>, Arguments<(ins AnyMemRef:$operand)>, Results<(outs AnyMemRef:$result)>;
 def ZCoverageValidC : TestFormat_Op<"variable_valid_c", [{

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

 test.format_attr_op 10
 
 // CHECK: test.format_attr_dict_w_keyword attributes {attr = 10 : i64}
 test.format_attr_dict_w_keyword attributes {attr = 10 : i64}
 
 // CHECK: test.format_buildable_type_op %[[I64]]
 %ignored = test.format_buildable_type_op %i64
 
+//===----------------------------------------------------------------------===//
+// Format results
+//===----------------------------------------------------------------------===//
+
 // CHECK: test.format_result_a_op memref<1xf64>
 %ignored_a:2 = test.format_result_a_op memref<1xf64>
 
 // CHECK: test.format_result_b_op i64, memref<1xf64>
 %ignored_b:2 = test.format_result_b_op i64, memref<1xf64>
 
 // CHECK: test.format_result_c_op (i64) -> memref<1xf64>
 %ignored_c:2 = test.format_result_c_op (i64) -> memref<1xf64>
 
+//===----------------------------------------------------------------------===//
+// Format operands
+//===----------------------------------------------------------------------===//
+
 // CHECK: test.format_operand_a_op %[[I64]], %[[MEMREF]] : i64, memref<1xf64>
 test.format_operand_a_op %i64, %memref : i64, memref<1xf64>
 
 // CHECK: test.format_operand_b_op %[[I64]], %[[MEMREF]] : memref<1xf64>
 test.format_operand_b_op %i64, %memref : memref<1xf64>
 
 // CHECK: test.format_operand_c_op %[[I64]], %[[MEMREF]] : i64, memref<1xf64>
 test.format_operand_c_op %i64, %memref : i64, memref<1xf64>
 
 // CHECK: test.format_operand_d_op %[[I64]], %[[MEMREF]] : memref<1xf64>
 test.format_operand_d_op %i64, %memref : memref<1xf64>
 
 // CHECK: test.format_operand_e_op %[[I64]], %[[MEMREF]] : i64, memref<1xf64>
 test.format_operand_e_op %i64, %memref : i64, memref<1xf64>
 
+//===----------------------------------------------------------------------===//
+// Format successors
+//===----------------------------------------------------------------------===//
+
 "foo.successor_test_region"() ( {
   ^bb0:
     // CHECK: test.format_successor_a_op ^bb1 {attr}
     test.format_successor_a_op ^bb1 {attr}
 
   ^bb1:
     // CHECK: test.format_successor_a_op ^bb1, ^bb2 {attr}
     test.format_successor_a_op ^bb1, ^bb2 {attr}
 
   ^bb2:
     // CHECK: test.format_successor_a_op {attr}
     test.format_successor_a_op {attr}
 
 }) { arg_names = ["i", "j", "k"] } : () -> ()
 
+//===----------------------------------------------------------------------===//
+// 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
+
+// CHECK: test.format_optional_operand_result_a_op(%[[I64]] : i64) :
+// CHECK-NOT: i64
+test.format_optional_operand_result_a_op(%i64 : i64) :
+
+// CHECK: test.format_optional_operand_result_a_op(%[[I64]] : i64) : [%[[I64]], %[[I64]]]
+test.format_optional_operand_result_a_op(%i64 : i64) : [%i64, %i64]
+
+// CHECK: test.format_optional_operand_result_b_op(%[[I64]] : i64) : i64
+test.format_optional_operand_result_b_op(%i64 : i64) : i64
+
+// CHECK: test.format_optional_operand_result_b_op : i64
+test.format_optional_operand_result_b_op( : ) : i64
+
+// CHECK: test.format_optional_operand_result_b_op : i64
+test.format_optional_operand_result_b_op : i64

mlir/test/mlir-tblgen/predicate.td

 def I32OrF32 : Type<CPred<"$_self.isInteger(32) || $_self.isF32()">,
                     "32-bit integer or floating-point type">;
 
 def OpA : NS_Op<"op_for_CPred_containing_multiple_same_placeholder", []> {
   let arguments = (ins I32OrF32:$x);
 }
 
 // CHECK-LABEL: OpA::verify
-// CHECK: for (Value v : getODSOperands(0)) {
+// CHECK: auto valueGroup0 = getODSOperands(0);
+// CHECK: for (Value v : valueGroup0) {
 // CHECK:   if (!((v.getType().isInteger(32) || v.getType().isF32())))
 
 def OpB : NS_Op<"op_for_And_PredOpTrait", [
     PredOpTrait<"both first and second holds",
                 And<[CPred<"first">, CPred<"second">]>>]> {
 }
 
 // CHECK-LABEL: OpB::verify

 // CHECK-SAME:   llvm::ArrayRef<unsigned>({0, 2, 3})))
 // CHECK:   return emitOpError("failed to verify that operands indexed at 0, 2, 3 should all have the same type");
 
 def OpK : NS_Op<"op_for_AnyTensorOf", []> {
   let arguments = (ins TensorOf<[F32, I32]>:$x);
 }
 
 // CHECK-LABEL: OpK::verify
-// CHECK: for (Value v : getODSOperands(0)) {
+// CHECK: auto valueGroup0 = getODSOperands(0);
+// CHECK: for (Value v : valueGroup0) {
 // CHECK: if (!(((v.getType().isa<TensorType>())) && (((v.getType().cast<ShapedType>().getElementType().isF32())) || ((v.getType().cast<ShapedType>().getElementType().isSignlessInteger(32))))))

mlir/tools/mlir-tblgen/LLVMIRConversionGen.cpp

 
 // Check if `name` is the name of the variadic operand of `op`.  The variadic
 // operand can only appear at the last position in the list of operands.
 static bool isVariadicOperandName(const tblgen::Operator &op, StringRef name) {
   unsigned numOperands = op.getNumOperands();
   if (numOperands == 0)
     return false;
   const auto &operand = op.getOperand(numOperands - 1);
-  return operand.isVariadic() && operand.name == name;
+  return operand.isVariableLength() && operand.name == name;
 }
 
 // Check if `result` is a known name of a result of `op`.
 static bool isResultName(const tblgen::Operator &op, StringRef name) {
   for (int i = 0, e = op.getNumResults(); i < e; ++i)
     if (op.getResultName(i) == name)
       return true;
   return false;

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 // of ops, in particular for one-operand ops that may not have the
 // `getOperand(unsigned)` method.
 static void generateNamedOperandGetters(const Operator &op, Class &opClass,
                                         StringRef rangeType,
                                         StringRef rangeBeginCall,
                                         StringRef rangeSizeCall,
                                         StringRef getOperandCallPattern) {
   const int numOperands = op.getNumOperands();
-  const int numVariadicOperands = op.getNumVariadicOperands();
+  const int numVariadicOperands = op.getNumVariableLengthOperands();
   const int numNormalOperands = numOperands - numVariadicOperands;
 
   const auto *sameVariadicSize =
       op.getTrait("OpTrait::SameVariadicOperandSize");
   const auto *attrSizedOperands =
       op.getTrait("OpTrait::AttrSizedOperandSegments");
 
   if (numVariadicOperands > 1 && !sameVariadicSize && !attrSizedOperands) {
if (numVariadicOperands == 0) {
     m.body() << formatv(attrSizedSegmentValueRangeCalcCode,
                         "operand_segment_sizes", rangeBeginCall);
   } else {
     // Because the op can have arbitrarily interleaved variadic and non-variadic
     // operands, we need to embed a list in the "sink" getter method for
     // calculation at run-time.
     llvm::SmallVector<StringRef, 4> isVariadic;
     isVariadic.reserve(numOperands);
-    for (int i = 0; i < numOperands; ++i) {
-      isVariadic.push_back(llvm::toStringRef(op.getOperand(i).isVariadic()));
-    }
+    for (int i = 0; i < numOperands; ++i)
+      isVariadic.push_back(op.getOperand(i).isVariableLength() ? "true"
+                                                               : "false");
     std::string isVariadicList = llvm::join(isVariadic, ", ");
 
     m.body() << formatv(sameVariadicSizeValueRangeCalcCode, isVariadicList,
                         numNormalOperands, numVariadicOperands, rangeSizeCall,
                         rangeBeginCall, "operand");
   }
 
   // Then we emit nicer named getter methods by redirecting to the "sink" getter
   // method.
 
   for (int i = 0; i != numOperands; ++i) {
     const auto &operand = op.getOperand(i);
     if (operand.name.empty())
       continue;
 
-    if (operand.isVariadic()) {
+    if (operand.isOptional()) {
+      auto &m = opClass.newMethod("Value", operand.name);
+      m.body() << "  auto operands = getODSOperands(" << i << ");\n"
+               << "  return operands.empty() ? Value() : *operands.begin();";
+    } else if (operand.isVariadic()) {
       auto &m = opClass.newMethod(rangeType, operand.name);
       m.body() << "  return getODSOperands(" << i << ");";
     } else {
-      auto &m = opClass.newMethod("Value ", operand.name);
+      auto &m = opClass.newMethod("Value", operand.name);
       m.body() << "  return *getODSOperands(" << i << ").begin();";
     }
   }
 }
 
 void OpEmitter::genNamedOperandGetters() {
   if (op.getTrait("OpTrait::AttrSizedOperandSegments"))
     opClass.setHasOperandAdaptorClass(false);
 
   generateNamedOperandGetters(
       op, opClass, /*rangeType=*/"Operation::operand_range",
       /*rangeBeginCall=*/"getOperation()->operand_begin()",
       /*rangeSizeCall=*/"getOperation()->getNumOperands()",
       /*getOperandCallPattern=*/"getOperation()->getOperand({0})");
 }
 
 void OpEmitter::genNamedResultGetters() {
   const int numResults = op.getNumResults();
-  const int numVariadicResults = op.getNumVariadicResults();
+  const int numVariadicResults = op.getNumVariableLengthResults();
   const int numNormalResults = numResults - numVariadicResults;
 
   // If we have more than one variadic results, we need more complicated logic
   // to calculate the value range for each result.
 
   const auto *sameVariadicSize = op.getTrait("OpTrait::SameVariadicResultSize");
   const auto *attrSizedResults =
       op.getTrait("OpTrait::AttrSizedResultSegments");
m.body() << "  return {std::next(getOperation()->result_begin(), index), "
                 "std::next(getOperation()->result_begin(), index + 1)};";
   } else if (attrSizedResults) {
     m.body() << formatv(attrSizedSegmentValueRangeCalcCode,
                         "result_segment_sizes",
                         "getOperation()->result_begin()");
   } else {
     llvm::SmallVector<StringRef, 4> isVariadic;
     isVariadic.reserve(numResults);
-    for (int i = 0; i < numResults; ++i) {
-      isVariadic.push_back(llvm::toStringRef(op.getResult(i).isVariadic()));
-    }
+    for (int i = 0; i < numResults; ++i)
+      isVariadic.push_back(op.getResult(i).isVariableLength() ? "true"
+                                                              : "false");
     std::string isVariadicList = llvm::join(isVariadic, ", ");
 
     m.body() << formatv(sameVariadicSizeValueRangeCalcCode, isVariadicList,
                         numNormalResults, numVariadicResults,
                         "getOperation()->getNumResults()",
                         "getOperation()->result_begin()", "result");
   }
 
   for (int i = 0; i != numResults; ++i) {
     const auto &result = op.getResult(i);
     if (result.name.empty())
       continue;
 
-    if (result.isVariadic()) {
+    if (result.isOptional()) {
+      auto &m = opClass.newMethod("Value", result.name);
+      m.body() << "  auto results = getODSResults(" << i << ");\n"
+               << "  return results.empty() ? Value() : *results.begin();";
+    } else if (result.isVariadic()) {
       auto &m = opClass.newMethod("Operation::result_range", result.name);
       m.body() << "  return getODSResults(" << i << ");";
     } else {
-      auto &m = opClass.newMethod("Value ", result.name);
+      auto &m = opClass.newMethod("Value", result.name);
       m.body() << "  return *getODSResults(" << i << ").begin();";
     }
   }
 }
 
 void OpEmitter::genNamedRegionGetters() {
   unsigned numRegions = op.getNumRegions();
   for (unsigned i = 0; i < numRegions; ++i) {
if (inferType) {
       return;
     }
 
     switch (paramKind) {
     case TypeParamKind::None:
       return;
     case TypeParamKind::Separate:
       for (int i = 0, e = op.getNumResults(); i < e; ++i) {
+        if (op.getResult(i).isOptional())
+          body << "  if (" << resultNames[i] << ")\n  ";
         body << "  " << builderOpState << ".addTypes(" << resultNames[i]
              << ");\n";
       }
       return;
     case TypeParamKind::Collective:
       body << "  "
            << "assert(resultTypes.size() "
-           << (op.getNumVariadicResults() == 0 ? "==" : ">=") << " "
-           << (op.getNumResults() - op.getNumVariadicResults())
+           << (op.getNumVariableLengthResults() == 0 ? "==" : ">=") << " "
+           << (op.getNumResults() - op.getNumVariableLengthResults())
            << "u && \"mismatched number of results\");\n";
       body << "  " << builderOpState << ".addTypes(resultTypes);\n";
       return;
-    };
+    }
     llvm_unreachable("unhandled TypeParamKind");
   };
 
   bool canInferType =
       op.getTrait("InferTypeOpInterface::Trait") && op.getNumRegions() == 0;
   for (auto attrType : attrBuilderType) {
     emit(attrType, TypeParamKind::Separate, /*inferType=*/false);
     if (canInferType)
       emit(attrType, TypeParamKind::None, /*inferType=*/true);
     // Emit separate arg build with collective type, unless there is only one
     // variadic result, in which case the above would have already generated
     // the same build method.
-    if (!(op.getNumResults() == 1 && op.getResult(0).isVariadic()))
+    if (!(op.getNumResults() == 1 && op.getResult(0).isVariableLength()))
       emit(attrType, TypeParamKind::Collective, /*inferType=*/false);
   }
 }
 
 void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {
   // If this op has a variadic result, we cannot generate this builder because
   // we don't know how many results to create.
-  if (op.getNumVariadicResults() != 0)
+  if (op.getNumVariableLengthResults() != 0)
     return;
 
   int numResults = op.getNumResults();
 
   // Signature
   std::string params =
       std::string("Builder *odsBuilder, OperationState &") + builderOpState +
       ", ValueRange operands, ArrayRef<NamedAttribute> attributes";
void OpEmitter::genBuilder() {
   // 1. one having a stand-alone parameter for each operand / attribute, and
   genSeparateArgParamBuilder();
   // 2. one having an aggregated parameter for all result types / operands /
   //    attributes, and
   genCollectiveParamBuilder();
   // 3. one having a stand-alone parameter for each operand and attribute,
   //    use the first operand or attribute's type as all result types
   //    to facilitate different call patterns.
-  if (op.getNumVariadicResults() == 0) {
+  if (op.getNumVariableLengthResults() == 0) {
     if (op.getTrait("OpTrait::SameOperandsAndResultType")) {
       genUseOperandAsResultTypeSeparateParamBuilder();
       genUseOperandAsResultTypeCollectiveParamBuilder();
     }
     if (op.getTrait("OpTrait::FirstAttrDerivedResultType"))
       genUseAttrAsResultTypeBuilder();
   }
 }
 
 void OpEmitter::genCollectiveParamBuilder() {
   int numResults = op.getNumResults();
-  int numVariadicResults = op.getNumVariadicResults();
+  int numVariadicResults = op.getNumVariableLengthResults();
   int numNonVariadicResults = numResults - numVariadicResults;
 
   int numOperands = op.getNumOperands();
-  int numVariadicOperands = op.getNumVariadicOperands();
+  int numVariadicOperands = op.getNumVariableLengthOperands();
   int numNonVariadicOperands = numOperands - numVariadicOperands;
   // Signature
   std::string params = std::string("Builder *, OperationState &") +
                        builderOpState +
                        ", ArrayRef<Type> resultTypes, ValueRange operands, "
                        "ArrayRef<NamedAttribute> attributes";
   if (op.getNumVariadicRegions())
     params += ", unsigned numRegions";
void OpEmitter::buildParamList(std::string &paramList,
   case TypeParamKind::Separate: {
     // Add parameters for all return types
     for (int i = 0; i < numResults; ++i) {
       const auto &result = op.getResult(i);
       std::string resultName = std::string(result.name);
       if (resultName.empty())
         resultName = std::string(formatv("resultType{0}", i));
 
-      paramList.append(result.isVariadic() ? ", ArrayRef<Type> " : ", Type ");
+      if (result.isOptional())
+        paramList.append(", /*optional*/Type ");
+      else if (result.isVariadic())
+        paramList.append(", ArrayRef<Type> ");
+      else
+        paramList.append(", Type ");
       paramList.append(resultName);
 
       resultTypeNames.emplace_back(std::move(resultName));
     }
   } break;
   case TypeParamKind::Collective: {
     paramList.append(", ArrayRef<Type> resultTypes");
     resultTypeNames.push_back("resultTypes");
for (int i = op.getNumArgs() - 1; i >= 0; --i) {
       defaultValuedAttrStartIndex = i;
     }
   }
 
   for (int i = 0, e = op.getNumArgs(); i < e; ++i) {
     auto argument = op.getArg(i);
     if (argument.is<tblgen::NamedTypeConstraint *>()) {
       const auto &operand = op.getOperand(numOperands);
-      paramList.append(operand.isVariadic() ? ", ValueRange " : ", Value ");
+      if (operand.isOptional())
+        paramList.append(", /*optional*/Value ");
+      else if (operand.isVariadic())
+        paramList.append(", ValueRange ");
+      else
+        paramList.append(", Value ");
       paramList.append(getArgumentName(op, numOperands));
       ++numOperands;
     } else {
       const auto &namedAttr = op.getAttribute(numAttrs);
       const auto &attr = namedAttr.attr;
       paramList.append(", ");
 
       if (attr.isOptional())
if (region.isVariadic())
       paramList += llvm::formatv(", unsigned {0}Count", region.name).str();
   }
 }
 
 void OpEmitter::genCodeForAddingArgAndRegionForBuilder(OpMethodBody &body,
                                                        bool isRawValueAttr) {
   // Push all operands to the result.
   for (int i = 0, e = op.getNumOperands(); i < e; ++i) {
-    body << "  " << builderOpState << ".addOperands(" << getArgumentName(op, i)
-         << ");\n";
+    std::string argName = getArgumentName(op, i);
+    if (op.getOperand(i).isOptional())
+      body << "  if (" << argName << ")\n  ";
+    body << "  " << builderOpState << ".addOperands(" << argName << ");\n";
   }
 
   // If the operation has the operand segment size attribute, add it here.
   if (op.getTrait("OpTrait::AttrSizedOperandSegments")) {
     body << "  " << builderOpState
          << ".addAttribute(\"operand_segment_sizes\", "
             "odsBuilder->getI32VectorAttr({";
     interleaveComma(llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
-      if (op.getOperand(i).isVariadic())
+      if (op.getOperand(i).isOptional())
+        body << "(" << getArgumentName(op, i) << " ? 1 : 0)";
+      else if (op.getOperand(i).isVariadic())
         body << "static_cast<int32_t>(" << getArgumentName(op, i) << ".size())";
       else
         body << "1";
     });
     body << "}));\n";
   }
 
   // Push all attributes to the result.
void OpEmitter::genCanonicalizerDecls() {
   const char *const params =
       "OwningRewritePatternList &results, MLIRContext *context";
   opClass.newMethod("void", "getCanonicalizationPatterns", params,
                     OpMethod::MP_Static, /*declOnly=*/true);
 }
 
 void OpEmitter::genFolderDecls() {
   bool hasSingleResult =
-      op.getNumResults() == 1 && op.getNumVariadicResults() == 0;
+      op.getNumResults() == 1 && op.getNumVariableLengthResults() == 0;
 
   if (def.getValueAsBit("hasFolder")) {
     if (hasSingleResult) {
       const char *const params = "ArrayRef<Attribute> operands";
       opClass.newMethod("OpFoldResult", "fold", params, OpMethod::MP_None,
                         /*declOnly=*/true);
     } else {
       const char *const params = "ArrayRef<Attribute> operands, "
void OpEmitter::genOperandResultVerifier(OpMethodBody &body,
                                          Operator::value_range values,
                                          StringRef valueKind) {
   FmtContext fctx;
 
   body << "  {\n";
   body << "    unsigned index = 0; (void)index;\n";
 
   for (auto staticValue : llvm::enumerate(values)) {
-    if (!staticValue.value().hasPredicate())
+    bool hasPredicate = staticValue.value().hasPredicate();
+    bool isOptional = staticValue.value().isOptional();
+    if (!hasPredicate && !isOptional)
       continue;
-
-    // Emit a loop to check all the dynamic values in the pack.
-    body << formatv("    for (Value v : getODS{0}{1}s({2})) {{\n",
+    body << formatv("    auto valueGroup{2} = getODS{0}{1}s({2});\n",
                     // Capitalize the first letter to match the function name
                     valueKind.substr(0, 1).upper(), valueKind.substr(1),
                     staticValue.index());
 
-    auto constraint = staticValue.value().constraint;
+    // If the constraint is optional check that the value group has at most 1
+    // value.
+    if (isOptional) {
+      body << formatv("    if (valueGroup{0}.size() > 1)\n"
+                      "      return emitOpError(\"{1} group starting at #\") "
+                      "<< index << \" requires 0 or 1 element, but found \" << "
+                      "valueGroup{0}.size();\n",
+                      staticValue.index(), valueKind);
+    }
 
+    // Otherwise, if there is no predicate there is nothing left to do.
+    if (!hasPredicate)
+      continue;
+
+    // Emit a loop to check all the dynamic values in the pack.
+    body << "    for (Value v : valueGroup" << staticValue.index() << ") {\n";
+
+    auto constraint = staticValue.value().constraint;
     body << "      (void)v;\n"
          << "      if (!("
          << tgfmt(constraint.getConditionTemplate(),
                   &fctx.withSelf("v.getType()"))
          << ")) {\n"
          << formatv("        return emitOpError(\"{0} #\") << index "
                     "<< \" must be {1}, but got \" << v.getType();\n",
                     valueKind, constraint.getDescription())

 void OpEmitter::genTraits() {
   // Add region size trait.
   unsigned numRegions = op.getNumRegions();
   unsigned numVariadicRegions = op.getNumVariadicRegions();
   addSizeCountTrait(opClass, "Region", numRegions, numVariadicRegions);
 
   // Add result size trait.
   int numResults = op.getNumResults();
-  int numVariadicResults = op.getNumVariadicResults();
+  int numVariadicResults = op.getNumVariableLengthResults();
   addSizeCountTrait(opClass, "Result", numResults, numVariadicResults);
 
   // Add successor size trait.
   unsigned numSuccessors = op.getNumSuccessors();
   unsigned numVariadicSuccessors = op.getNumVariadicSuccessors();
   addSizeCountTrait(opClass, "Successor", numSuccessors, numVariadicSuccessors);
 
   // Add variadic size trait and normal op traits.
   int numOperands = op.getNumOperands();
-  int numVariadicOperands = op.getNumVariadicOperands();
+  int numVariadicOperands = op.getNumVariableLengthOperands();
 
   // Add operand size trait.
   if (numVariadicOperands != 0) {
     if (numOperands == numVariadicOperands)
       opClass.addTrait("OpTrait::VariadicOperands");
     else
       opClass.addTrait("OpTrait::AtLeastNOperands<" +
                        Twine(numOperands - numVariadicOperands) + ">::Impl");

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 
 /// The code snippet used to generate a parser call for an operand.
 ///
 /// {0}: The name of the operand.
 const char *const variadicOperandParserCode = R"(
   if (parser.parseOperandList({0}Operands))
     return failure();
 )";
+const char *const optionalOperandParserCode = R"(
+  {
+    OpAsmParser::OperandType operand;
+    OptionalParseResult parseResult = parser.parseOptionalOperand(operand);
+    if (parseResult.hasValue()) {
+      if (failed(*parseResult))
+        return failure();
+      {0}Operands.push_back(operand);
+    }
+  }
+)";
 const char *const operandParserCode = R"(
   if (parser.parseOperand({0}RawOperands[0]))
     return failure();
 )";
 
 /// The code snippet used to generate a parser call for a type list.
 ///
 /// {0}: The name for the type list.
 const char *const variadicTypeParserCode = R"(
   if (parser.parseTypeList({0}Types))
     return failure();
 )";
+const char *const optionalTypeParserCode = R"(
+  {
+    Type optionalType;
+    OptionalParseResult parseResult = parser.parseOptionalType(optionalType);
+    if (parseResult.hasValue()) {
+      if (failed(*parseResult))
+        return failure();
+      {0}Types.push_back(optionalType);
+    }
+  }
+)";
 const char *const typeParserCode = R"(
   if (parser.parseType({0}RawTypes[0]))
     return failure();
 )";
 
 /// The code snippet used to generate a parser call for a functional type.
 ///
 /// {0}: The name for the input type list.

 ///
 /// {0}: The name of the successor.
 const char *successorParserCode = R"(
   Block *{0}Successor = nullptr;
   if (parser.parseSuccessor({0}Successor))
     return failure();
 )";
 
+namespace {
+/// The type of length for a given parse argument.
+enum class ArgumentLengthKind {
+  /// The argument is variadic, and may contain 0->N elements.
+  Variadic,
+  /// The argument is optional, and may contain 0 or 1 elements.
+  Optional,
+  /// The argument is a single element, i.e. always represents 1 element.
+  Single
+};
+} // end anonymous namespace
+
+/// Get the length kind for the given constraint.
+static ArgumentLengthKind
+getArgumentLengthKind(const NamedTypeConstraint *var) {
+  if (var->isOptional())
+    return ArgumentLengthKind::Optional;
+  if (var->isVariadic())
+    return ArgumentLengthKind::Variadic;
+  return ArgumentLengthKind::Single;
+}
+
 /// Get the name used for the type list for the given type directive operand.
-/// 'isVariadic' is set to true if the operand has variadic types.
-static StringRef getTypeListName(Element *arg, bool &isVariadic) {
+/// 'lengthKind' to the corresponding kind for the given argument.
+static StringRef getTypeListName(Element *arg, ArgumentLengthKind &lengthKind) {
   if (auto *operand = dyn_cast<OperandVariable>(arg)) {
-    isVariadic = operand->getVar()->isVariadic();
+    lengthKind = getArgumentLengthKind(operand->getVar());
     return operand->getVar()->name;
   }
   if (auto *result = dyn_cast<ResultVariable>(arg)) {
-    isVariadic = result->getVar()->isVariadic();
+    lengthKind = getArgumentLengthKind(result->getVar());
     return result->getVar()->name;
   }
-  isVariadic = true;
+  lengthKind = ArgumentLengthKind::Variadic;
   if (isa<OperandsDirective>(arg))
     return "allOperand";
   if (isa<ResultsDirective>(arg))
     return "allResult";
   llvm_unreachable("unknown 'type' directive argument");
 }
 
 /// Generate the parser for a literal value.

 
 /// Generate the storage code required for parsing the given element.
 static void genElementParserStorage(Element *element, OpMethodBody &body) {
   if (auto *optional = dyn_cast<OptionalElement>(element)) {
     for (auto &childElement : optional->getElements())
       genElementParserStorage(&childElement, body);
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
     StringRef name = operand->getVar()->name;
-    if (operand->getVar()->isVariadic()) {
+    if (operand->getVar()->isVariableLength()) {
       body << "  SmallVector<OpAsmParser::OperandType, 4> " << name
            << "Operands;\n";
     } else {
       body << "  OpAsmParser::OperandType " << name << "RawOperands[1];\n"
            << "  ArrayRef<OpAsmParser::OperandType> " << name << "Operands("
            << name << "RawOperands);";
     }
     body << llvm::formatv(
         "  llvm::SMLoc {0}OperandsLoc = parser.getCurrentLocation();\n"
         "  (void){0}OperandsLoc;\n",
         name);
   } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
-    bool variadic = false;
-    StringRef name = getTypeListName(dir->getOperand(), variadic);
-    if (variadic)
+    ArgumentLengthKind lengthKind;
+    StringRef name = getTypeListName(dir->getOperand(), lengthKind);
+    if (lengthKind != ArgumentLengthKind::Single)
       body << "  SmallVector<Type, 1> " << name << "Types;\n";
     else
       body << llvm::formatv("  Type {0}RawTypes[1];\n", name)
            << llvm::formatv("  ArrayRef<Type> {0}Types({0}RawTypes);\n", name);
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
-    bool ignored = false;
+    ArgumentLengthKind ignored;
     body << "  ArrayRef<Type> " << getTypeListName(dir->getInputs(), ignored)
          << "Types;\n";
     body << "  ArrayRef<Type> " << getTypeListName(dir->getResults(), ignored)
          << "Types;\n";
   }
 }
 
 /// Generate the parser for a single format element.
if (auto *optional = dyn_cast<OptionalElement>(element)) {
     if (Optional<StringRef> typeBuilder = attr->getTypeBuilder()) {
       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)) {
-    bool isVariadic = operand->getVar()->isVariadic();
-    body << formatv(isVariadic ? variadicOperandParserCode : operandParserCode,
-                    operand->getVar()->name);
+    ArgumentLengthKind lengthKind = getArgumentLengthKind(operand->getVar());
+    StringRef name = operand->getVar()->name;
+    if (lengthKind == ArgumentLengthKind::Variadic)
+      body << llvm::formatv(variadicOperandParserCode, name);
+    else if (lengthKind == ArgumentLengthKind::Optional)
+      body << llvm::formatv(optionalOperandParserCode, name);
+    else
+      body << formatv(operandParserCode, name);
   } else if (auto *successor = dyn_cast<SuccessorVariable>(element)) {
     bool isVariadic = successor->getVar()->isVariadic();
     body << formatv(isVariadic ? successorListParserCode : successorParserCode,
                     successor->getVar()->name);
 
     /// Directives.
   } else if (auto *attrDict = dyn_cast<AttrDictDirective>(element)) {
     body << "  if (parser.parseOptionalAttrDict"
          << (attrDict->isWithKeyword() ? "WithKeyword" : "")
          << "(result.attributes))\n"
          << "    return failure();\n";
   } else if (isa<OperandsDirective>(element)) {
     body << "  llvm::SMLoc allOperandLoc = parser.getCurrentLocation();\n"
          << "  SmallVector<OpAsmParser::OperandType, 4> allOperands;\n"
          << "  if (parser.parseOperandList(allOperands))\n"
          << "    return failure();\n";
   } else if (isa<SuccessorsDirective>(element)) {
     body << llvm::formatv(successorListParserCode, "full");
   } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
-    bool isVariadic = false;
-    StringRef listName = getTypeListName(dir->getOperand(), isVariadic);
-    body << formatv(isVariadic ? variadicTypeParserCode : typeParserCode,
-                    listName);
+    ArgumentLengthKind lengthKind;
+    StringRef listName = getTypeListName(dir->getOperand(), lengthKind);
+    if (lengthKind == ArgumentLengthKind::Variadic)
+      body << llvm::formatv(variadicTypeParserCode, listName);
+    else if (lengthKind == ArgumentLengthKind::Optional)
+      body << llvm::formatv(optionalTypeParserCode, listName);
+    else
+      body << formatv(typeParserCode, listName);
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
-    bool ignored = false;
+    ArgumentLengthKind ignored;
     body << formatv(functionalTypeParserCode,
                     getTypeListName(dir->getInputs(), ignored),
                     getTypeListName(dir->getResults(), ignored));
   } else {
     llvm_unreachable("unknown format element");
   }
 }
 

 
 void OperationFormat::genParserVariadicSegmentResolution(Operator &op,
                                                          OpMethodBody &body) {
   if (!allOperands && op.getTrait("OpTrait::AttrSizedOperandSegments")) {
     body << "  result.addAttribute(\"operand_segment_sizes\", "
          << "builder.getI32VectorAttr({";
     auto interleaveFn = [&](const NamedTypeConstraint &operand) {
       // If the operand is variadic emit the parsed size.
-      if (operand.isVariadic())
+      if (operand.isVariableLength())
         body << "static_cast<int32_t>(" << operand.name << "Operands.size())";
       else
         body << "1";
     };
     interleaveComma(op.getOperands(), body, interleaveFn);
     body << "}));\n";
   }
 }
static OpMethodBody &genTypeOperandPrinter(Element *arg, OpMethodBody &body) {
   if (isa<OperandsDirective>(arg))
     return body << "getOperation()->getOperandTypes()";
   if (isa<ResultsDirective>(arg))
     return body << "getOperation()->getResultTypes()";
   auto *operand = dyn_cast<OperandVariable>(arg);
   auto *var = operand ? operand->getVar() : cast<ResultVariable>(arg)->getVar();
   if (var->isVariadic())
     return body << var->name << "().getTypes()";
+  if (var->isOptional())
+    return body << llvm::formatv(
+               "({0}() ? ArrayRef<Type>({0}().getType()) : ArrayRef<Type>())",
+               var->name);
   return body << "ArrayRef<Type>(" << var->name << "().getType())";
 }
 
 /// Generate the code for printing the given element.
 static void genElementPrinter(Element *element, OpMethodBody &body,
                               OperationFormat &fmt, Operator &op,
                               bool &shouldEmitSpace, bool &lastWasPunctuation) {
   if (LiteralElement *literal = dyn_cast<LiteralElement>(element))
     return genLiteralPrinter(literal->getLiteral(), body, shouldEmitSpace,
                              lastWasPunctuation);
 
   // Emit an optional group.
   if (OptionalElement *optional = dyn_cast<OptionalElement>(element)) {
     // Emit the check for the presence of the anchor element.
     Element *anchor = optional->getAnchor();
-    if (AttributeVariable *attrVar = dyn_cast<AttributeVariable>(anchor))
-      body << "  if (getAttr(\"" << attrVar->getVar()->name << "\")) {\n";
-    else
-      body << "  if (!" << cast<OperandVariable>(anchor)->getVar()->name
-           << "().empty()) {\n";
+    if (auto *operand = dyn_cast<OperandVariable>(anchor)) {
+      const NamedTypeConstraint *var = operand->getVar();
+      if (var->isOptional())
+        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";
+    }
 
     // Emit each of the elements.
     for (Element &childElement : optional->getElements())
       genElementPrinter(&childElement, body, fmt, op, shouldEmitSpace,
                         lastWasPunctuation);
     body << "  }\n";
     return;
   }
if (auto *attr = dyn_cast<AttributeVariable>(element)) {
     }
 
     // Elide the attribute type if it is buildable.
     if (attr->getTypeBuilder())
       body << "  p.printAttributeWithoutType(" << var->name << "Attr());\n";
     else
       body << "  p.printAttribute(" << var->name << "Attr());\n";
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
+    if (operand->getVar()->isOptional()) {
+      body << "  if (Value value = " << operand->getVar()->name << "())\n"
+           << "    p << value;\n";
+    } else {
       body << "  p << " << operand->getVar()->name << "();\n";
+    }
   } else if (auto *successor = dyn_cast<SuccessorVariable>(element)) {
     const NamedSuccessor *var = successor->getVar();
     if (var->isVariadic())
       body << "  interleaveComma(" << var->name << "(), p);\n";
     else
       body << "  p << " << var->name << "();\n";
   } else if (isa<OperandsDirective>(element)) {
     body << "  p << getOperation()->getOperands();\n";
if (varResolverIt != variableTyResolver.end()) {
       fmt.operandTypes[i].setVariable(varResolverIt->second.type,
                                       varResolverIt->second.transformer);
       continue;
     }
 
     // Similarly to results, allow a custom builder for resolving the type if
     // we aren't using the 'operands' directive.
     Optional<StringRef> builder = operand.constraint.getBuilderCall();
-    if (!builder || (hasAllOperands && operand.isVariadic())) {
+    if (!builder || (hasAllOperands && operand.isVariableLength())) {
       return emitErrorAndNote(
           loc,
           "type of operand #" + Twine(i) + ", named '" + operand.name +
-              "', is not buildable and a buildable " +
-              "type cannot be inferred",
-          "suggest adding a type constraint "
-          "to the operation or adding a "
+              "', is not buildable and a buildable type cannot be inferred",
+          "suggest adding a type constraint to the operation or adding a "
           "'type($" +
               operand.name + ")' directive to the " + "custom assembly format");
     }
     auto it = buildableTypes.insert({*builder, buildableTypes.size()});
     fmt.operandTypes[i].setBuilderIdx(it.first->second);
   }
   return success();
 }
for (unsigned i = 0, e = op.getNumResults(); i != e; ++i) {
     // Check to see if we can infer this type from another variable.
     auto varResolverIt = variableTyResolver.find(op.getResultName(i));
     if (varResolverIt != variableTyResolver.end()) {
       fmt.resultTypes[i].setVariable(varResolverIt->second.type,
                                      varResolverIt->second.transformer);
       continue;
     }
 
-    // If the result is not variadic, allow for the case where the type has a
-    // builder that we can use.
+    // If the result is not variable length, allow for the case where the type
+    // has a builder that we can use.
     NamedTypeConstraint &result = op.getResult(i);
     Optional<StringRef> builder = result.constraint.getBuilderCall();
-    if (!builder || result.constraint.isVariadic()) {
+    if (!builder || result.isVariableLength()) {
       return emitErrorAndNote(
           loc,
           "type of result #" + Twine(i) + ", named '" + result.name +
-              "', is not buildable and a buildable " +
-              "type cannot be inferred",
-          "suggest adding a type constraint "
-          "to the operation or adding a "
+              "', is not buildable and a buildable type cannot be inferred",
+          "suggest adding a type constraint to the operation or adding a "
           "'type($" +
               result.name + ")' directive to the " + "custom assembly format");
     }
     // Note in the format that this result uses the custom builder.
     auto it = buildableTypes.insert({*builder, buildableTypes.size()});
     fmt.resultTypes[i].setBuilderIdx(it.first->second);
   }
   return success();
return TypeSwitch<Element *, LogicalResult>(childElements.back().get())
         if (isAnchor && !attrEle->getVar()->attr.isOptional())
           return emitError(childLoc, "only optional attributes can be used to "
                                      "anchor an optional group");
         return success();
       })
       // Only optional-like(i.e. variadic) operands can be within an optional
       // group.
       .Case<OperandVariable>([&](OperandVariable *ele) {
-        if (!ele->getVar()->isVariadic())
-          return emitError(childLoc, "only variadic operands can be used within"
-                                     " an optional group");
+        if (!ele->getVar()->isVariableLength())
+          return emitError(childLoc, "only variable length operands can be "
+                                     "used within an optional group");
         seenVariables.insert(ele->getVar());
         return success();
       })
       // Literals and type directives may be used, but they can't anchor the
       // group.
       .Case<LiteralElement, TypeDirective, FunctionalTypeDirective>(
           [&](Element *) {
             if (isAnchor)

mlir/tools/mlir-tblgen/RewriterGen.cpp

if (!name.empty())
     os.indent(indent) << formatv("{0} = castedOp{1};\n", name, depth);
 
   for (int i = 0, e = tree.getNumArgs(); i != e; ++i) {
     auto opArg = op.getArg(i);
 
     // Handle nested DAG construct first
     if (DagNode argTree = tree.getArgAsNestedDag(i)) {
       if (auto *operand = opArg.dyn_cast<NamedTypeConstraint *>()) {
-        if (operand->isVariadic()) {
+        if (operand->isVariableLength()) {
           auto error = formatv("use nested DAG construct to match op {0}'s "
                                "variadic operand #{1} unsupported now",
                                op.getOperationName(), i);
           PrintFatalError(loc, error);
         }
       }
       os.indent(indent) << "{\n";
 
if (!matcher.isOperandMatcher()) {
           loc, formatv("the {1}-th argument of op '{0}' should be an operand",
                        op.getOperationName(), argIndex + 1));
     }
 
     // Only need to verify if the matcher's type is different from the one
     // of op definition.
     Constraint constraint = matcher.getAsConstraint();
     if (operand->constraint != constraint) {
-      if (operand->isVariadic()) {
+      if (operand->isVariableLength()) {
         auto error = formatv(
             "further constrain op {0}'s variadic operand #{1} unsupported now",
             op.getOperationName(), argIndex);
         PrintFatalError(loc, error);
       }
       auto self =
           formatv("(*castedOp{0}.getODSOperands({1}).begin()).getType()", depth,
                   argIndex);

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

static void emitOperandDeserialization(const Operator &op, ArrayRef<SMLoc> loc,
                                        StringRef tabs, StringRef words,
                                        StringRef wordIndex, StringRef operands,
                                        StringRef attributes, raw_ostream &os) {
   // Process operands/attributes
   unsigned operandNum = 0;
   for (unsigned i = 0, e = op.getNumArgs(); i < e; ++i) {
     auto argument = op.getArg(i);
     if (auto valueArg = argument.dyn_cast<NamedTypeConstraint *>()) {
-      if (valueArg->isVariadic()) {
+      if (valueArg->isVariableLength()) {
         if (i != e - 1) {
-          PrintFatalError(loc,
-                          "SPIR-V ops can have Variadic<..> argument only if "
+          PrintFatalError(loc, "SPIR-V ops can have Variadic<..> or "
+                               "Optional<...> arguments only if "
                                "it's the last argument");
         }
         os << tabs
            << formatv("for (; {0} < {1}.size(); ++{0})", wordIndex, words);
       } else {
         os << tabs << formatv("if ({0} < {1}.size())", wordIndex, words);
       }
       os << " {\n";
       os << tabs
          << formatv("  auto arg = getValue({0}[{1}]);\n", words, wordIndex);
       os << tabs << "  if (!arg) {\n";
       os << tabs
          << formatv(
                 "    return emitError(unknownLoc, \"unknown result <id> : \") "
                 "<< {0}[{1}];\n",
                 words, wordIndex);
       os << tabs << "  }\n";
       os << tabs << formatv("  {0}.push_back(arg);\n", operands);
-      if (!valueArg->isVariadic()) {
+      if (!valueArg->isVariableLength()) {
         os << tabs << formatv("  {0}++;\n", wordIndex);
       }
       operandNum++;
       os << tabs << "}\n";
     } else {
       os << tabs << formatv("if ({0} < {1}.size()) {{\n", wordIndex, words);
       auto attr = argument.get<NamedAttribute *>();
       auto newtabs = tabs.str() + "  ";