[mlir][OpFormatGen] Refactor `type_ref` into a more general `ref` directive

[rriddle]

Summary

This allows for referencing nearly every component of an operation from within a custom directive.

It also fixes a bug with the current type_ref implementation, PR48478

[nicolasvasilache]

Thanks! The turnaround was so fast I missed it :)

mlir/docs/OpDefinitions.md

-   Formats the `inputs` and `results` arguments as a
         [function type](LangRef.md#function-type).
     -   The constraints on `inputs` and `results` are the same as the `input` of
         the `type` directive.
 
 *   `operands`
 
     -   Represents all of the operands of an operation.
 
+*   `ref` ( input )
+
+    -   Represents a reference to the a variable or directive, that must have
+        already been resolved, that may be used as a parameter to a `custom`
+        directive.
+    -   Used to pass previously parsed entities to custom directives.
+    -   The input may be any directive or variable, aside from `functional-type`
+        and `custom`.
+
 *   `regions`
 
     -   Represents all of the regions of an operation.
 
 *   `results`
 
     -   Represents all of the results of an operation.
 
 *   `successors`
 
     -   Represents all of the successors of an operation.
 
 *   `type` ( input )
 
     -   Represents the type of the given input.
     -   `input` must be either an operand or result [variable](#variables), the
         `operands` directive, or the `results` directive.
 
-*   `type_ref` ( input )
-
-    -   Represents a reference to the type of the given input that must have
-        already been resolved.
-    -   `input` must be either an operand or result [variable](#variables), the
-        `operands` directive, or the `results` directive.
-    -   Used to pass previously parsed types to custom directives.
-
 #### Literals
 
 A literal is either a keyword or punctuation surrounded by \`\`.
 
 The following are the set of valid punctuation:
 
 `:`, `,`, `=`, `<`, `>`, `(`, `)`, `{`, `}`, `[`, `]`, `->`, `?`, `+`, `*`
 

 
 *   Attribute Variables
     -   Single: `<Attribute-Storage-Type>(e.g. Attribute) &`
     -   Optional: `<Attribute-Storage-Type>(e.g. Attribute) &`
 *   Operand Variables
     -   Single: `OpAsmParser::OperandType &`
     -   Optional: `Optional<OpAsmParser::OperandType> &`
     -   Variadic: `SmallVectorImpl<OpAsmParser::OperandType> &`
+*   Ref Directives
+    -   A reference directive is passed to the parser using the same mapping as
+        the input operand. For example, a single region would be passed as a
+        `Region &`.
 *   Region Variables
     -   Single: `Region &`
     -   Variadic: `SmallVectorImpl<std::unique_ptr<Region>> &`
 *   Successor Variables
     -   Single: `Block *&`
     -   Variadic: `SmallVectorImpl<Block *> &`
 *   Type Directives
     -   Single: `Type &`
     -   Optional: `Type &`
     -   Variadic: `SmallVectorImpl<Type> &`
-*   TypeRef Directives
-    -   Single: `Type`
-    -   Optional: `Type`
-    -   Variadic: `const SmallVectorImpl<Type> &`
 *   `attr-dict` Directive: `NamedAttrList &`
 
 When a variable is optional, the value should only be specified if the variable
 is present. Otherwise, the value should remain `None` or null.
 
 The arguments to the `print<UserDirective>` method is firstly a reference to the
 `OpAsmPrinter`(`OpAsmPrinter &`), second the op (e.g. `FooOp op` which can be
 `Operation *op` alternatively), and finally a set of output parameters
 corresponding to the parameters specified in the format. The mapping of
 declarative parameter to `print` method argument is detailed below:
 
 *   Attribute Variables
     -   Single: `<Attribute-Storage-Type>(e.g. Attribute)`
     -   Optional: `<Attribute-Storage-Type>(e.g. Attribute)`
 *   Operand Variables
     -   Single: `Value`
     -   Optional: `Value`
     -   Variadic: `OperandRange`
+*   Ref Directives
+    -   A reference directive is passed to the printer using the same mapping as
+        the input operand. For example, a single region would be passed as a
+        `Region &`.
 *   Region Variables
     -   Single: `Region &`
     -   Variadic: `MutableArrayRef<Region>`
 *   Successor Variables
     -   Single: `Block *`
     -   Variadic: `SuccessorRange`
 *   Type Directives
     -   Single: `Type`
     -   Optional: `Type`
     -   Variadic: `TypeRange`
-*   TypeRef Directives
-    -   Single: `Type`
-    -   Optional: `Type`
-    -   Variadic: `TypeRange`
 *   `attr-dict` Directive: `DictionaryAttr`
 
 When a variable is optional, the provided value may be null.
 
 #### Optional Groups
 
 In certain situations operations may have "optional" information, e.g.
 attributes or an empty set of variadic operands. In these situations a section

mlir/test/lib/Dialect/Test/TestDialect.cpp

static ParseResult parseCustomDirectiveAttributes(OpAsmParser &parser,
   }
   return success();
 }
 
 static ParseResult parseCustomDirectiveAttrDict(OpAsmParser &parser,
                                                 NamedAttrList &attrs) {
   return parser.parseOptionalAttrDict(attrs);
 }
+static ParseResult parseCustomDirectiveOptionalOperandRef(
+    OpAsmParser &parser, Optional<OpAsmParser::OperandType> &optOperand) {
+  int64_t operandCount = 0;
+  if (parser.parseInteger(operandCount))
+    return failure();
+  bool expectedOptionalOperand = operandCount == 0;
+  return success(expectedOptionalOperand != optOperand.hasValue());
+}
 
 //===----------------------------------------------------------------------===//
 // Printing
 
 static void printCustomDirectiveOperands(OpAsmPrinter &printer, Operation *,
                                          Value operand, Value optOperand,
                                          OperandRange varOperands) {
   printer << operand;
static void printCustomDirectiveAttributes(OpAsmPrinter &printer, Operation *,
   if (optAttribute)
     printer << ", " << optAttribute;
 }
 
 static void printCustomDirectiveAttrDict(OpAsmPrinter &printer, Operation *op,
                                          DictionaryAttr attrs) {
   printer.printOptionalAttrDict(attrs.getValue());
 }
+
+static void printCustomDirectiveOptionalOperandRef(OpAsmPrinter &printer,
+                                                   Operation *op,
+                                                   Value optOperand) {
+  printer << (optOperand ? "1" : "0");
+}
+
 //===----------------------------------------------------------------------===//
 // Test IsolatedRegionOp - parse passthrough region arguments.
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseIsolatedRegionOp(OpAsmParser &parser,
                                          OperationState &result) {
   OpAsmParser::OperandType argInfo;
   Type argType = parser.getBuilder().getIndexType();

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

: TEST_Op<"format_custom_directive_results_with_type_refs",
               [AttrSizedResultSegments]> {
   let results = (outs AnyType:$result, Optional<AnyType>:$optResult,
                       Variadic<AnyType>:$varResults);
   let assemblyFormat = [{
     custom<CustomDirectiveResults>(
       type($result), type($optResult), type($varResults)
     )
     custom<CustomDirectiveWithTypeRefs>(
-      type_ref($result), type_ref($optResult), type_ref($varResults)
+      ref(type($result)), ref(type($optResult)), ref(type($varResults))
     )
     attr-dict
   }];
 }
 
+def FormatCustomDirectiveWithOptionalOperandRef
+    : TEST_Op<"format_custom_directive_with_optional_operand_ref"> {
+  let arguments = (ins Optional<I64>:$optOperand);
+  let assemblyFormat = [{
+    ($optOperand^)? `:`
+    custom<CustomDirectiveOptionalOperandRef>(ref($optOperand))
+    attr-dict
+  }];
+}
+
 def FormatCustomDirectiveSuccessors
     : TEST_Op<"format_custom_directive_successors", [Terminator]> {
   let successors = (successor AnySuccessor:$successor,
                               VariadicSuccessor<AnySuccessor>:$successors);
   let assemblyFormat = [{
     custom<CustomDirectiveSuccessors>(
       $successor, $successors
     )

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

 // RUN: mlir-tblgen -gen-op-decls -asmformat-error-is-fatal=false -I %S/../../include %s -o=%t 2>&1 | FileCheck %s
 
 // This file contains tests for the specification of the declarative op format.
 
 include "mlir/IR/OpBase.td"
 
 def TestDialect : Dialect {
   let name = "test";
 }
-class TestFormat_Op<string name, string fmt, list<OpTrait> traits = []>
-    : Op<TestDialect, name, traits> {
+class TestFormat_Op<string fmt, list<OpTrait> traits = []>
+    : Op<TestDialect, "format_op", traits> {
   let assemblyFormat = fmt;
 }
 
 //===----------------------------------------------------------------------===//
 // Directives
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // attr-dict
 
 // CHECK: error: 'attr-dict' directive not found
-def DirectiveAttrDictInvalidA : TestFormat_Op<"attrdict_invalid_a", [{
+def DirectiveAttrDictInvalidA : TestFormat_Op<[{
 }]>;
 // CHECK: error: 'attr-dict' directive has already been seen
-def DirectiveAttrDictInvalidB : TestFormat_Op<"attrdict_invalid_b", [{
+def DirectiveAttrDictInvalidB : TestFormat_Op<[{
   attr-dict attr-dict
 }]>;
 // CHECK: error: 'attr-dict' directive has already been seen
-def DirectiveAttrDictInvalidC : TestFormat_Op<"attrdict_invalid_c", [{
+def DirectiveAttrDictInvalidC : TestFormat_Op<[{
   attr-dict attr-dict-with-keyword
 }]>;
 // CHECK: error: 'attr-dict' directive can only be used as a top-level directive
-def DirectiveAttrDictInvalidD : TestFormat_Op<"attrdict_invalid_d", [{
+def DirectiveAttrDictInvalidD : TestFormat_Op<[{
   type(attr-dict)
 }]>;
 // CHECK-NOT: error
-def DirectiveAttrDictValidA : TestFormat_Op<"attrdict_valid_a", [{
+def DirectiveAttrDictValidA : TestFormat_Op<[{
   attr-dict
 }]>;
-def DirectiveAttrDictValidB : TestFormat_Op<"attrdict_valid_b", [{
+def DirectiveAttrDictValidB : TestFormat_Op<[{
   attr-dict-with-keyword
 }]>;
 
 //===----------------------------------------------------------------------===//
 // custom
 
 // CHECK: error: expected '<' before custom directive name
-def DirectiveCustomInvalidA : TestFormat_Op<"custom_invalid_a", [{
+def DirectiveCustomInvalidA : TestFormat_Op<[{
   custom(
 }]>;
 // CHECK: error: expected custom directive name identifier
-def DirectiveCustomInvalidB : TestFormat_Op<"custom_invalid_b", [{
+def DirectiveCustomInvalidB : TestFormat_Op<[{
   custom<>
 }]>;
 // CHECK: error: expected '>' after custom directive name
-def DirectiveCustomInvalidC : TestFormat_Op<"custom_invalid_c", [{
+def DirectiveCustomInvalidC : TestFormat_Op<[{
   custom<MyDirective(
 }]>;
 // CHECK: error: expected '(' before custom directive parameters
-def DirectiveCustomInvalidD : TestFormat_Op<"custom_invalid_d", [{
+def DirectiveCustomInvalidD : TestFormat_Op<[{
   custom<MyDirective>)
 }]>;
 // CHECK: error: only variables and types may be used as parameters to a custom directive
-def DirectiveCustomInvalidE : TestFormat_Op<"custom_invalid_e", [{
+def DirectiveCustomInvalidE : TestFormat_Op<[{
   custom<MyDirective>(operands)
 }]>;
 // CHECK: error: expected ')' after custom directive parameters
-def DirectiveCustomInvalidF : TestFormat_Op<"custom_invalid_f", [{
+def DirectiveCustomInvalidF : TestFormat_Op<[{
   custom<MyDirective>($operand<
 }]>, Arguments<(ins I64:$operand)>;
 // CHECK: error: type directives within a custom directive may only refer to variables
-def DirectiveCustomInvalidH : TestFormat_Op<"custom_invalid_h", [{
+def DirectiveCustomInvalidH : TestFormat_Op<[{
   custom<MyDirective>(type(operands))
 }]>;
 
 // CHECK-NOT: error
-def DirectiveCustomValidA : TestFormat_Op<"custom_valid_a", [{
+def DirectiveCustomValidA : TestFormat_Op<[{
   custom<MyDirective>($operand) attr-dict
 }]>, Arguments<(ins Optional<I64>:$operand)>;
-def DirectiveCustomValidB : TestFormat_Op<"custom_valid_b", [{
+def DirectiveCustomValidB : TestFormat_Op<[{
   custom<MyDirective>($operand, type($operand), type($result)) attr-dict
 }]>, Arguments<(ins I64:$operand)>, Results<(outs I64:$result)>;
-def DirectiveCustomValidC : TestFormat_Op<"custom_valid_c", [{
+def DirectiveCustomValidC : TestFormat_Op<[{
   custom<MyDirective>($attr) attr-dict
 }]>, Arguments<(ins I64Attr:$attr)>;
 
 //===----------------------------------------------------------------------===//
 // functional-type
 
 // CHECK: error: 'functional-type' is only valid as a top-level directive
-def DirectiveFunctionalTypeInvalidA : TestFormat_Op<"functype_invalid_a", [{
+def DirectiveFunctionalTypeInvalidA : TestFormat_Op<[{
   functional-type(functional-type)
 }]>;
 // CHECK: error: expected '(' before argument list
-def DirectiveFunctionalTypeInvalidB : TestFormat_Op<"functype_invalid_b", [{
+def DirectiveFunctionalTypeInvalidB : TestFormat_Op<[{
   functional-type
 }]>;
 // CHECK: error: expected directive, literal, variable, or optional group
-def DirectiveFunctionalTypeInvalidC : TestFormat_Op<"functype_invalid_c", [{
+def DirectiveFunctionalTypeInvalidC : TestFormat_Op<[{
   functional-type(
 }]>;
 // CHECK: error: expected ',' after inputs argument
-def DirectiveFunctionalTypeInvalidD : TestFormat_Op<"functype_invalid_d", [{
+def DirectiveFunctionalTypeInvalidD : TestFormat_Op<[{
   functional-type(operands
 }]>;
 // CHECK: error: expected directive, literal, variable, or optional group
-def DirectiveFunctionalTypeInvalidE : TestFormat_Op<"functype_invalid_e", [{
+def DirectiveFunctionalTypeInvalidE : TestFormat_Op<[{
   functional-type(operands,
 }]>;
 // CHECK: error: expected ')' after argument list
-def DirectiveFunctionalTypeInvalidF : TestFormat_Op<"functype_invalid_f", [{
+def DirectiveFunctionalTypeInvalidF : TestFormat_Op<[{
   functional-type(operands, results
 }]>;
 // CHECK-NOT: error
-def DirectiveFunctionalTypeValid : TestFormat_Op<"functype_invalid_a", [{
+def DirectiveFunctionalTypeValid : TestFormat_Op<[{
   functional-type(operands, results) attr-dict
 }]>;
 
 //===----------------------------------------------------------------------===//
 // operands
 
 // CHECK: error: 'operands' directive creates overlap in format
-def DirectiveOperandsInvalidA : TestFormat_Op<"operands_invalid_a", [{
+def DirectiveOperandsInvalidA : TestFormat_Op<[{
   operands operands
 }]>;
 // CHECK: error: 'operands' directive creates overlap in format
-def DirectiveOperandsInvalidB : TestFormat_Op<"operands_invalid_b", [{
+def DirectiveOperandsInvalidB : TestFormat_Op<[{
   $operand operands
 }]>, Arguments<(ins I64:$operand)>;
 // CHECK-NOT: error:
-def DirectiveOperandsValid : TestFormat_Op<"operands_valid", [{
+def DirectiveOperandsValid : TestFormat_Op<[{
   operands attr-dict
 }]>;
 
 //===----------------------------------------------------------------------===//
+// ref
+
+// CHECK: error: 'ref' is only valid within a `custom` directive
+def DirectiveRefInvalidA : TestFormat_Op<[{
+  ref(type($operand))
+}]>, Arguments<(ins I64:$operand)>;
+
+// CHECK: error: 'ref' of 'type($operand)' is not bound by a prior 'type' directive
+def DirectiveRefInvalidB : TestFormat_Op<[{
+  custom<Foo>(ref(type($operand)))
+}]>, Arguments<(ins I64:$operand)>;
+
+// CHECK: error: 'ref' of 'type(operands)' is not bound by a prior 'type' directive
+def DirectiveRefInvalidC : TestFormat_Op<[{
+  custom<Foo>(ref(type(operands)))
+}]>;
+
+// CHECK: error: 'ref' of 'type($result)' is not bound by a prior 'type' directive
+def DirectiveRefInvalidD : TestFormat_Op<[{
+  custom<Foo>(ref(type($result)))
+}]>, Results<(outs I64:$result)>;
+
+// CHECK: error: 'ref' of 'type(results)' is not bound by a prior 'type' directive
+def DirectiveRefInvalidE : TestFormat_Op<[{
+  custom<Foo>(ref(type(results)))
+}]>;
+
+// CHECK: error: 'ref' of 'successors' is not bound by a prior 'successors' directive
+def DirectiveRefInvalidF : TestFormat_Op<[{
+  custom<Foo>(ref(successors))
+}]>;
+
+// CHECK: error: 'ref' of 'regions' is not bound by a prior 'regions' directive
+def DirectiveRefInvalidG : TestFormat_Op<[{
+  custom<Foo>(ref(regions))
+}]>;
+
+// CHECK: error: expected '(' before argument list
+def DirectiveRefInvalidH : TestFormat_Op<[{
+  custom<Foo>(ref)
+}]>;
+
+// CHECK: error: expected ')' after argument list
+def DirectiveRefInvalidI : TestFormat_Op<[{
+  operands custom<Foo>(ref(operands(
+}]>;
+
+// CHECK: error: 'ref' of 'operands' is not bound by a prior 'operands' directive
+def DirectiveRefInvalidJ : TestFormat_Op<[{
+  custom<Foo>(ref(operands))
+}]>;
+
+// CHECK: error: 'ref' of 'attr-dict' is not bound by a prior 'attr-dict' directive
+def DirectiveRefInvalidK : TestFormat_Op<[{
+  custom<Foo>(ref(attr-dict))
+}]>;
+
+// CHECK: error: successor 'successor' must be bound before it is referenced
+def DirectiveRefInvalidL : TestFormat_Op<[{
+  custom<Foo>(ref($successor))
+}]> {
+  let successors = (successor AnySuccessor:$successor);
+}
+
+// CHECK: error: region 'region' must be bound before it is referenced
+def DirectiveRefInvalidM : TestFormat_Op<[{
+  custom<Foo>(ref($region))
+}]> {
+  let regions = (region AnyRegion:$region);
+}
+
+// CHECK: error: attribute 'attr' must be bound before it is referenced
+def DirectiveRefInvalidN : TestFormat_Op<[{
+  custom<Foo>(ref($attr))
+}]>, Arguments<(ins I64Attr:$attr)>;
+
+
+// CHECK: error: operand 'operand' must be bound before it is referenced
+def DirectiveRefInvalidO : TestFormat_Op<[{
+  custom<Foo>(ref($operand))
+}]>, Arguments<(ins I64:$operand)>;
+
+//===----------------------------------------------------------------------===//
 // regions
 
 // CHECK: error: 'regions' directive creates overlap in format
-def DirectiveRegionsInvalidA : TestFormat_Op<"regions_invalid_a", [{
+def DirectiveRegionsInvalidA : TestFormat_Op<[{
   regions regions attr-dict
 }]>;
 // CHECK: error: 'regions' directive creates overlap in format
-def DirectiveRegionsInvalidB : TestFormat_Op<"regions_invalid_b", [{
+def DirectiveRegionsInvalidB : TestFormat_Op<[{
   $region regions attr-dict
 }]> {
   let regions = (region AnyRegion:$region);
 }
 // CHECK: error: 'regions' is only valid as a top-level directive
-def DirectiveRegionsInvalidC : TestFormat_Op<"regions_invalid_c", [{
+def DirectiveRegionsInvalidC : TestFormat_Op<[{
   type(regions)
 }]>;
 // CHECK-NOT: error:
-def DirectiveRegionsValid : TestFormat_Op<"regions_valid", [{
+def DirectiveRegionsValid : TestFormat_Op<[{
   regions attr-dict
 }]>;
 
 //===----------------------------------------------------------------------===//
 // results
 
-// CHECK: error: 'results' directive can not be used as a top-level directive
-def DirectiveResultsInvalidA : TestFormat_Op<"results_invalid_a", [{
+// CHECK: error: 'results' directive can can only be used as a child to a 'type' directive
+def DirectiveResultsInvalidA : TestFormat_Op<[{
   results
 }]>;
 
 //===----------------------------------------------------------------------===//
 // successors
 
 // CHECK: error: 'successors' is only valid as a top-level directive
-def DirectiveSuccessorsInvalidA : TestFormat_Op<"successors_invalid_a", [{
+def DirectiveSuccessorsInvalidA : TestFormat_Op<[{
   type(successors)
 }]>;
 
 //===----------------------------------------------------------------------===//
 // type
 
 // CHECK: error: expected '(' before argument list
-def DirectiveTypeInvalidA : TestFormat_Op<"type_invalid_a", [{
+def DirectiveTypeInvalidA : TestFormat_Op<[{
   type
 }]>;
 // CHECK: error: expected directive, literal, variable, or optional group
-def DirectiveTypeInvalidB : TestFormat_Op<"type_invalid_b", [{
+def DirectiveTypeInvalidB : TestFormat_Op<[{
   type(
 }]>;
 // CHECK: error: expected ')' after argument list
-def DirectiveTypeInvalidC : TestFormat_Op<"type_invalid_c", [{
+def DirectiveTypeInvalidC : TestFormat_Op<[{
   type(operands
 }]>;
 // CHECK-NOT: error:
-def DirectiveTypeValid : TestFormat_Op<"type_valid", [{
+def DirectiveTypeValid : TestFormat_Op<[{
   type(operands) attr-dict
 }]>;
 
 //===----------------------------------------------------------------------===//
 // functional-type/type operands
 
-// CHECK: error: 'type' directive operand expects variable or directive operand
-def DirectiveTypeZOperandInvalidA : TestFormat_Op<"type_operand_invalid_a", [{
+// CHECK: error: literals may only be used in a top-level section of the format
+def DirectiveTypeZOperandInvalidA : TestFormat_Op<[{
   type(`literal`)
 }]>;
 // CHECK: error: 'operands' 'type' is already bound
-def DirectiveTypeZOperandInvalidB : TestFormat_Op<"type_operand_invalid_b", [{
+def DirectiveTypeZOperandInvalidB : TestFormat_Op<[{
   type(operands) type(operands)
 }]>;
 // CHECK: error: 'operands' 'type' is already bound
-def DirectiveTypeZOperandInvalidC : TestFormat_Op<"type_operand_invalid_c", [{
+def DirectiveTypeZOperandInvalidC : TestFormat_Op<[{
   type($operand) type(operands)
 }]>, Arguments<(ins I64:$operand)>;
 // CHECK: error: 'type' of 'operand' is already bound
-def DirectiveTypeZOperandInvalidD : TestFormat_Op<"type_operand_invalid_d", [{
+def DirectiveTypeZOperandInvalidD : TestFormat_Op<[{
   type(operands) type($operand)
 }]>, Arguments<(ins I64:$operand)>;
 // CHECK: error: 'type' of 'operand' is already bound
-def DirectiveTypeZOperandInvalidE : TestFormat_Op<"type_operand_invalid_e", [{
+def DirectiveTypeZOperandInvalidE : TestFormat_Op<[{
   type($operand) type($operand)
 }]>, Arguments<(ins I64:$operand)>;
 // CHECK: error: 'results' 'type' is already bound
-def DirectiveTypeZOperandInvalidF : TestFormat_Op<"type_operand_invalid_f", [{
+def DirectiveTypeZOperandInvalidF : TestFormat_Op<[{
   type(results) type(results)
 }]>;
 // CHECK: error: 'results' 'type' is already bound
-def DirectiveTypeZOperandInvalidG : TestFormat_Op<"type_operand_invalid_g", [{
+def DirectiveTypeZOperandInvalidG : TestFormat_Op<[{
   type($result) type(results)
 }]>, Results<(outs I64:$result)>;
 // CHECK: error: 'type' of 'result' is already bound
-def DirectiveTypeZOperandInvalidH : TestFormat_Op<"type_operand_invalid_h", [{
+def DirectiveTypeZOperandInvalidH : TestFormat_Op<[{
   type(results) type($result)
 }]>, Results<(outs I64:$result)>;
 // CHECK: error: 'type' of 'result' is already bound
-def DirectiveTypeZOperandInvalidI : TestFormat_Op<"type_operand_invalid_i", [{
+def DirectiveTypeZOperandInvalidI : TestFormat_Op<[{
   type($result) type($result)
 }]>, Results<(outs I64:$result)>;
 
 //===----------------------------------------------------------------------===//
-// type_ref
-
-// CHECK: error: 'type_ref' of 'operand' is not bound by a prior 'type' directive
-def DirectiveTypeZZTypeRefOperandInvalidC : TestFormat_Op<"type_ref_operand_invalid_c", [{
-  type_ref($operand) type(operands)
-}]>, Arguments<(ins I64:$operand)>;
-// CHECK: error: 'operands' 'type_ref' is not bound by a prior 'type' directive
-def DirectiveTypeZZTypeRefOperandInvalidD : TestFormat_Op<"type_ref_operand_invalid_d", [{
-  type_ref(operands) type($operand)
-}]>, Arguments<(ins I64:$operand)>;
-// CHECK: error: 'type_ref' of 'operand' is not bound by a prior 'type' directive
-def DirectiveTypeZZTypeRefOperandInvalidE : TestFormat_Op<"type_ref_operand_invalid_e", [{
-  type_ref($operand) type($operand)
-}]>, Arguments<(ins I64:$operand)>;
-// CHECK: error: 'type_ref' of 'result' is not bound by a prior 'type' directive
-def DirectiveTypeZZTypeRefOperandInvalidG : TestFormat_Op<"type_ref_operand_invalid_g", [{
-  type_ref($result) type(results)
-}]>, Results<(outs I64:$result)>;
-// CHECK: error: 'results' 'type_ref' is not bound by a prior 'type' directive
-def DirectiveTypeZZTypeRefOperandInvalidH : TestFormat_Op<"type_ref_operand_invalid_h", [{
-  type_ref(results) type($result)
-}]>, Results<(outs I64:$result)>;
-// CHECK: error: 'type_ref' of 'result' is not bound by a prior 'type' directive
-def DirectiveTypeZZTypeRefOperandInvalidI : TestFormat_Op<"type_ref_operand_invalid_i", [{
-  type_ref($result) type($result)
-}]>, Results<(outs I64:$result)>;
-
-// CHECK-NOT: error
-def DirectiveTypeZZTypeRefOperandB : TestFormat_Op<"type_ref_operand_valid_b", [{
-  type_ref(operands) attr-dict
-}]>;
-// CHECK-NOT: error
-def DirectiveTypeZZTypeRefOperandD : TestFormat_Op<"type_ref_operand_valid_d", [{
-  type(operands) type_ref($operand) attr-dict
-}]>, Arguments<(ins I64:$operand)>;
-// CHECK-NOT: error
-def DirectiveTypeZZTypeRefOperandE : TestFormat_Op<"type_ref_operand_valid_e", [{
-  type($operand) type_ref($operand) attr-dict
-}]>, Arguments<(ins I64:$operand)>;
-// CHECK-NOT: error
-def DirectiveTypeZZTypeRefOperandF : TestFormat_Op<"type_ref_operand_valid_f", [{
-  type(results) type_ref(results) attr-dict
-}]>;
-// CHECK-NOT: error
-def DirectiveTypeZZTypeRefOperandG : TestFormat_Op<"type_ref_operand_valid_g", [{
-  type($result) type_ref(results) attr-dict
-}]>, Results<(outs I64:$result)>;
-// CHECK-NOT: error
-def DirectiveTypeZZTypeRefOperandH : TestFormat_Op<"type_ref_operand_valid_h", [{
-  type(results) type_ref($result) attr-dict
-}]>, Results<(outs I64:$result)>;
-// CHECK-NOT: error
-def DirectiveTypeZZTypeRefOperandI : TestFormat_Op<"type_ref_operand_valid_i", [{
-  type($result) type_ref($result) attr-dict
-}]>, Results<(outs I64:$result)>;
-
-// CHECK-NOT: error:
-def DirectiveTypeZZZOperandValid : TestFormat_Op<"type_operand_valid", [{
-  type(operands) type(results) attr-dict
-}]>;
-
-//===----------------------------------------------------------------------===//
 // Literals
 //===----------------------------------------------------------------------===//
 
 // Test all of the valid literals.
 // CHECK: error: expected valid literal
-def LiteralInvalidA : TestFormat_Op<"literal_invalid_a", [{
+def LiteralInvalidA : TestFormat_Op<[{
   `1`
 }]>;
 // CHECK: error: unexpected end of file in literal
 // CHECK: error: expected directive, literal, variable, or optional group
-def LiteralInvalidB : TestFormat_Op<"literal_invalid_b", [{
+def LiteralInvalidB : TestFormat_Op<[{
   `
 }]>;
 // CHECK-NOT: error
-def LiteralValid : TestFormat_Op<"literal_valid", [{
+def LiteralValid : TestFormat_Op<[{
   `_` `:` `,` `=` `<` `>` `(` `)` `[` `]` `?` `+` `*` ` ` `` `->` `\n` `abc$._`
   attr-dict
 }]>;
 
 //===----------------------------------------------------------------------===//
 // Optional Groups
 //===----------------------------------------------------------------------===//
 
 // CHECK: error: optional groups can only be used as top-level elements
-def OptionalInvalidA : TestFormat_Op<"optional_invalid_a", [{
+def OptionalInvalidA : TestFormat_Op<[{
   type(($attr^)?) attr-dict
 }]>, Arguments<(ins OptionalAttr<I64Attr>:$attr)>;
 // CHECK: error: expected directive, literal, variable, or optional group
-def OptionalInvalidB : TestFormat_Op<"optional_invalid_b", [{
+def OptionalInvalidB : TestFormat_Op<[{
   () attr-dict
 }]>, Arguments<(ins OptionalAttr<I64Attr>:$attr)>;
 // CHECK: error: optional group specified no anchor element
-def OptionalInvalidC : TestFormat_Op<"optional_invalid_c", [{
+def OptionalInvalidC : TestFormat_Op<[{
   ($attr)? attr-dict
 }]>, Arguments<(ins OptionalAttr<I64Attr>:$attr)>;
 // CHECK: error: first parsable element of an operand group must be an attribute, literal, operand, or region
-def OptionalInvalidD : TestFormat_Op<"optional_invalid_d", [{
+def OptionalInvalidD : TestFormat_Op<[{
   (type($operand) $operand^)? attr-dict
 }]>, Arguments<(ins Optional<I64>:$operand)>;
 // CHECK: error: only literals, types, and variables can be used within an optional group
-def OptionalInvalidE : TestFormat_Op<"optional_invalid_e", [{
+def OptionalInvalidE : TestFormat_Op<[{
   (`,` $attr^ type(operands))? attr-dict
 }]>, Arguments<(ins OptionalAttr<I64Attr>:$attr)>;
 // CHECK: error: only one element can be marked as the anchor of an optional group
-def OptionalInvalidF : TestFormat_Op<"optional_invalid_f", [{
+def OptionalInvalidF : TestFormat_Op<[{
   ($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", [{
+def OptionalInvalidG : TestFormat_Op<[{
   ($attr^) attr-dict
 }]>, Arguments<(ins I64Attr:$attr)>;
 // CHECK: error: only variable length operands can be used within an optional group
-def OptionalInvalidH : TestFormat_Op<"optional_invalid_h", [{
+def OptionalInvalidH : TestFormat_Op<[{
   ($arg^) attr-dict
 }]>, Arguments<(ins I64:$arg)>;
 // CHECK: error: only literals, types, and variables can be used within an optional group
-def OptionalInvalidI : TestFormat_Op<"optional_invalid_i", [{
+def OptionalInvalidI : TestFormat_Op<[{
   (functional-type($arg, results)^)? attr-dict
 }]>, Arguments<(ins Variadic<I64>:$arg)>;
 // CHECK: error: only literals, types, and variables can be used within an optional group
-def OptionalInvalidJ : TestFormat_Op<"optional_invalid_j", [{
+def OptionalInvalidJ : TestFormat_Op<[{
   (attr-dict)
 }]>;
 // CHECK: error: expected '?' after optional group
-def OptionalInvalidK : TestFormat_Op<"optional_invalid_k", [{
+def OptionalInvalidK : TestFormat_Op<[{
   ($arg^)
 }]>, Arguments<(ins Variadic<I64>:$arg)>;
 // CHECK: error: only variables and types can be used to anchor an optional group
-def OptionalInvalidL : TestFormat_Op<"optional_invalid_l", [{
+def OptionalInvalidL : TestFormat_Op<[{
   (custom<MyDirective>($arg)^)?
 }]>, Arguments<(ins I64:$arg)>;
 // CHECK: error: only variables and types can be used to anchor an optional group
-def OptionalInvalidM : TestFormat_Op<"optional_invalid_m", [{
+def OptionalInvalidM : TestFormat_Op<[{
   (` `^)?
 }]>, Arguments<(ins)>;
 
 // CHECK-NOT: error
-def OptionalValidA : TestFormat_Op<"optional_valid_a", [{
+def OptionalValidA : TestFormat_Op<[{
   (` ` `` $arg^)?
 }]>;
 
 //===----------------------------------------------------------------------===//
 // Variables
 //===----------------------------------------------------------------------===//
 
 // CHECK: error: expected variable to refer to an argument, region, result, or successor
-def VariableInvalidA : TestFormat_Op<"variable_invalid_a", [{
+def VariableInvalidA : TestFormat_Op<[{
   $unknown_arg attr-dict
 }]>;
 // CHECK: error: attribute 'attr' is already bound
-def VariableInvalidB : TestFormat_Op<"variable_invalid_b", [{
+def VariableInvalidB : TestFormat_Op<[{
   $attr $attr attr-dict
 }]>, Arguments<(ins I64Attr:$attr)>;
 // CHECK: error: operand 'operand' is already bound
-def VariableInvalidC : TestFormat_Op<"variable_invalid_c", [{
+def VariableInvalidC : TestFormat_Op<[{
   $operand $operand attr-dict
 }]>, Arguments<(ins I64:$operand)>;
 // CHECK: error: operand 'operand' is already bound
-def VariableInvalidD : TestFormat_Op<"variable_invalid_d", [{
+def VariableInvalidD : TestFormat_Op<[{
   operands $operand attr-dict
 }]>, Arguments<(ins I64:$operand)>;
-// CHECK: error: results can not be used at the top level
-def VariableInvalidE : TestFormat_Op<"variable_invalid_e", [{
+// CHECK: error: result variables can can only be used as a child to a 'type' directive
+def VariableInvalidE : TestFormat_Op<[{
   $result attr-dict
 }]>, Results<(outs I64:$result)>;
 // CHECK: error: successor 'successor' is already bound
-def VariableInvalidF : TestFormat_Op<"variable_invalid_f", [{
+def VariableInvalidF : TestFormat_Op<[{
   $successor $successor attr-dict
 }]> {
   let successors = (successor AnySuccessor:$successor);
 }
 // CHECK: error: successor 'successor' is already bound
-def VariableInvalidG : TestFormat_Op<"variable_invalid_g", [{
+def VariableInvalidG : TestFormat_Op<[{
   successors $successor attr-dict
 }]> {
   let successors = (successor AnySuccessor:$successor);
 }
 // CHECK: error: format ambiguity caused by `:` literal found after attribute `attr` which does not have a buildable type
-def VariableInvalidH : TestFormat_Op<"variable_invalid_h", [{
+def VariableInvalidH : TestFormat_Op<[{
   $attr `:` attr-dict
 }]>, Arguments<(ins ElementsAttr:$attr)>;
 // CHECK: error: format ambiguity caused by `:` literal found after attribute `attr` which does not have a buildable type
-def VariableInvalidI : TestFormat_Op<"variable_invalid_i", [{
+def VariableInvalidI : TestFormat_Op<[{
   (`foo` $attr^)? `:` attr-dict
 }]>, Arguments<(ins OptionalAttr<ElementsAttr>:$attr)>;
 // CHECK: error: format ambiguity caused by `:` literal found after attribute `attr` which does not have a buildable type
-def VariableInvalidJ : TestFormat_Op<"variable_invalid_j", [{
+def VariableInvalidJ : TestFormat_Op<[{
   $attr ` ` `:` attr-dict
 }]>, Arguments<(ins ElementsAttr:$attr)>;
 // CHECK: error: region 'region' is already bound
-def VariableInvalidK : TestFormat_Op<"variable_invalid_k", [{
+def VariableInvalidK : TestFormat_Op<[{
   $region $region attr-dict
 }]> {
   let regions = (region AnyRegion:$region);
 }
 // CHECK: error: region 'region' is already bound
-def VariableInvalidL : TestFormat_Op<"variable_invalid_l", [{
+def VariableInvalidL : TestFormat_Op<[{
   regions $region attr-dict
 }]> {
   let regions = (region AnyRegion:$region);
 }
 // CHECK: error: regions can only be used at the top level
-def VariableInvalidM : TestFormat_Op<"variable_invalid_m", [{
+def VariableInvalidM : TestFormat_Op<[{
   type($region)
 }]> {
   let regions = (region AnyRegion:$region);
 }
 // CHECK: error: region #0, named 'region', not found
-def VariableInvalidN : TestFormat_Op<"variable_invalid_n", [{
+def VariableInvalidN : TestFormat_Op<[{
   attr-dict
 }]> {
   let regions = (region AnyRegion:$region);
 }
 // CHECK-NOT: error:
-def VariableValidA : TestFormat_Op<"variable_valid_a", [{
+def VariableValidA : TestFormat_Op<[{
   $attr `:` attr-dict
 }]>, Arguments<(ins OptionalAttr<I1Attr>:$attr)>;
-def VariableValidB : TestFormat_Op<"variable_valid_b", [{
+def VariableValidB : TestFormat_Op<[{
   (`foo` $attr^)? `:` attr-dict
 }]>, Arguments<(ins OptionalAttr<I1Attr>:$attr)>;
 
 //===----------------------------------------------------------------------===//
 // Coverage Checks
 //===----------------------------------------------------------------------===//
 
 // 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 ZCoverageInvalidA : TestFormat_Op<"variable_invalid_a", [{
+def ZCoverageInvalidA : TestFormat_Op<[{
   attr-dict
 }]>, Arguments<(ins AnyMemRef:$operand)>, Results<(outs AnyMemRef:$result)>;
 // CHECK: error: operand #0, named 'operand', not found
 // CHECK: note: suggest adding a '$operand' directive to the custom assembly format
-def ZCoverageInvalidB : TestFormat_Op<"variable_invalid_b", [{
+def ZCoverageInvalidB : TestFormat_Op<[{
   type($result) attr-dict
 }]>, Arguments<(ins AnyMemRef:$operand)>, Results<(outs AnyMemRef:$result)>;
 // 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 ZCoverageInvalidC : TestFormat_Op<"variable_invalid_c", [{
+def ZCoverageInvalidC : TestFormat_Op<[{
   $operand type($result) attr-dict
 }]>, Arguments<(ins AnyMemRef:$operand)>, Results<(outs AnyMemRef:$result)>;
 // 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 ZCoverageInvalidD : TestFormat_Op<"variable_invalid_d", [{
+def ZCoverageInvalidD : TestFormat_Op<[{
   operands attr-dict
 }]>, Arguments<(ins Variadic<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 ZCoverageInvalidE : TestFormat_Op<"variable_invalid_e", [{
+def ZCoverageInvalidE : TestFormat_Op<[{
   attr-dict
 }]>, 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", [{
+def ZCoverageInvalidF : TestFormat_Op<[{
    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", [{
+def ZCoverageInvalidG : TestFormat_Op<[{
   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", [{
+def ZCoverageInvalidH : TestFormat_Op<[{
   attr-dict
 }]>, Results<(outs Optional<I64>:$result)>;
 
 // CHECK-NOT: error
-def ZCoverageValidA : TestFormat_Op<"variable_valid_a", [{
+def ZCoverageValidA : TestFormat_Op<[{
   $operand type($operand) type($result) attr-dict
 }]>, Arguments<(ins AnyMemRef:$operand)>, Results<(outs AnyMemRef:$result)>;
-def ZCoverageValidB : TestFormat_Op<"variable_valid_b", [{
+def ZCoverageValidB : TestFormat_Op<[{
   $operand type(operands) type(results) attr-dict
 }]>, Arguments<(ins AnyMemRef:$operand)>, Results<(outs AnyMemRef:$result)>;
-def ZCoverageValidC : TestFormat_Op<"variable_valid_c", [{
+def ZCoverageValidC : TestFormat_Op<[{
   operands functional-type(operands, results) attr-dict
 }]>, Arguments<(ins AnyMemRef:$operand)>, Results<(outs AnyMemRef:$result)>;
 
 // Check that we can infer type equalities from certain traits.
-def ZCoverageValidD : TestFormat_Op<"variable_valid_d", [{
+def ZCoverageValidD : TestFormat_Op<[{
   operands type($result) attr-dict
 }], [SameOperandsAndResultType]>, Arguments<(ins AnyMemRef:$operand)>,
      Results<(outs AnyMemRef:$result)>;
-def ZCoverageValidE : TestFormat_Op<"variable_valid_e", [{
+def ZCoverageValidE : TestFormat_Op<[{
   $operand type($operand) attr-dict
 }], [SameOperandsAndResultType]>, Arguments<(ins AnyMemRef:$operand)>,
      Results<(outs AnyMemRef:$result)>;
-def ZCoverageValidF : TestFormat_Op<"variable_valid_f", [{
+def ZCoverageValidF : TestFormat_Op<[{
   operands type($other) attr-dict
 }], [SameTypeOperands]>, Arguments<(ins AnyMemRef:$operand, AnyMemRef:$other)>;
-def ZCoverageValidG : TestFormat_Op<"variable_valid_g", [{
+def ZCoverageValidG : TestFormat_Op<[{
   operands type($other) attr-dict
 }], [AllTypesMatch<["operand", "other"]>]>,
      Arguments<(ins AnyMemRef:$operand, AnyMemRef:$other)>;
-def ZCoverageValidH : TestFormat_Op<"variable_valid_h", [{
+def ZCoverageValidH : TestFormat_Op<[{
   operands type($result) attr-dict
 }], [AllTypesMatch<["operand", "result"]>]>,
      Arguments<(ins AnyMemRef:$operand)>, Results<(outs AnyMemRef:$result)>;
 

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

 test.format_custom_directive_results : i64 -> (i64)
 
 // CHECK: test.format_custom_directive_results_with_type_refs : i64, i64 -> (i64) type_refs_capture : i64, i64 -> (i64)
 test.format_custom_directive_results_with_type_refs : i64, i64 -> (i64) type_refs_capture : i64, i64 -> (i64)
 
 // CHECK: test.format_custom_directive_results_with_type_refs : i64 -> (i64) type_refs_capture : i64 -> (i64)
 test.format_custom_directive_results_with_type_refs : i64 -> (i64) type_refs_capture : i64 -> (i64)
 
+// CHECK: test.format_custom_directive_with_optional_operand_ref %[[I64]] : 1
+test.format_custom_directive_with_optional_operand_ref %i64 : 1
+
+// CHECK: test.format_custom_directive_with_optional_operand_ref : 0
+test.format_custom_directive_with_optional_operand_ref : 0
+
 func @foo() {
   // CHECK: test.format_custom_directive_successors ^bb1, ^bb2
   test.format_custom_directive_successors ^bb1, ^bb2
 
 ^bb1:
   // CHECK: test.format_custom_directive_successors ^bb2
   test.format_custom_directive_successors ^bb2
 

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 class Element {
 public:
   enum class Kind {
     /// This element is a directive.
     AttrDictDirective,
     CustomDirective,
     FunctionalTypeDirective,
     OperandsDirective,
+    RefDirective,
     RegionsDirective,
     ResultsDirective,
     SuccessorsDirective,
     TypeDirective,
-    TypeRefDirective,
 
     /// This element is a literal.
     Literal,
 
     /// This element is a whitespace.
     Newline,
     Space,
 
public:
   Element *getInputs() const { return inputs.get(); }
   Element *getResults() const { return results.get(); }
 
 private:
   /// The input and result arguments.
   std::unique_ptr<Element> inputs, results;
 };
 
-/// This class represents the `type` directive.
-class TypeDirective : public DirectiveElement<Element::Kind::TypeDirective> {
+/// This class represents the `ref` directive.
+class RefDirective : public DirectiveElement<Element::Kind::RefDirective> {
 public:
-  TypeDirective(std::unique_ptr<Element> arg) : operand(std::move(arg)) {}
+  RefDirective(std::unique_ptr<Element> arg) : operand(std::move(arg)) {}
   Element *getOperand() const { return operand.get(); }
 
 private:
   /// The operand that is used to format the directive.
   std::unique_ptr<Element> operand;
 };
 
-/// This class represents the `type_ref` directive.
-class TypeRefDirective
-    : public DirectiveElement<Element::Kind::TypeRefDirective> {
+/// This class represents the `type` directive.
+class TypeDirective : public DirectiveElement<Element::Kind::TypeDirective> {
 public:
-  TypeRefDirective(std::unique_ptr<Element> arg) : operand(std::move(arg)) {}
+  TypeDirective(std::unique_ptr<Element> arg) : operand(std::move(arg)) {}
   Element *getOperand() const { return operand.get(); }
 
 private:
   /// The operand that is used to format the directive.
   std::unique_ptr<Element> operand;
 };
 } // namespace
 
if (auto *optional = dyn_cast<OptionalElement>(element)) {
     StringRef name = getTypeListName(dir->getOperand(), lengthKind);
     if (lengthKind != ArgumentLengthKind::Single)
       body << "  ::mlir::SmallVector<::mlir::Type, 1> " << name << "Types;\n";
     else
       body << llvm::formatv("  ::mlir::Type {0}RawTypes[1];\n", name)
            << llvm::formatv(
                   "  ::llvm::ArrayRef<::mlir::Type> {0}Types({0}RawTypes);\n",
                   name);
-  } else if (auto *dir = dyn_cast<TypeRefDirective>(element)) {
-    ArgumentLengthKind lengthKind;
-    StringRef name = getTypeListName(dir->getOperand(), lengthKind);
-    // Refer to the previously encountered TypeDirective for name.
-    // Take a `const ::mlir::SmallVector<::mlir::Type, 1> &` in the declaration
-    // to properly track the types that will be parsed and pushed later on.
-    if (lengthKind != ArgumentLengthKind::Single)
-      body << "  const ::mlir::SmallVector<::mlir::Type, 1> &" << name
-           << "TypesRef(" << name << "Types);\n";
-    else
-      body << llvm::formatv(
-          "  ::llvm::ArrayRef<::mlir::Type> {0}RawTypesRef({0}RawTypes);\n",
-          name);
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
     ArgumentLengthKind ignored;
     body << "  ::llvm::ArrayRef<::mlir::Type> "
          << getTypeListName(dir->getInputs(), ignored) << "Types;\n";
     body << "  ::llvm::ArrayRef<::mlir::Type> "
          << getTypeListName(dir->getResults(), ignored) << "Types;\n";
   }
 }
 
 /// Generate the parser for a parameter to a custom directive.
 static void genCustomParameterParser(Element &param, OpMethodBody &body) {
-  body << ", ";
   if (auto *attr = dyn_cast<AttributeVariable>(&param)) {
     body << attr->getVar()->name << "Attr";
   } else if (isa<AttrDictDirective>(&param)) {
     body << "result.attributes";
   } else if (auto *operand = dyn_cast<OperandVariable>(&param)) {
     StringRef name = operand->getVar()->name;
     ArgumentLengthKind lengthKind = getArgumentLengthKind(operand->getVar());
     if (lengthKind == ArgumentLengthKind::Variadic)
static void genCustomParameterParser(Element &param, OpMethodBody &body) {
 
   } else if (auto *successor = dyn_cast<SuccessorVariable>(&param)) {
     StringRef name = successor->getVar()->name;
     if (successor->getVar()->isVariadic())
       body << llvm::formatv("{0}Successors", name);
     else
       body << llvm::formatv("{0}Successor", name);
 
-  } else if (auto *dir = dyn_cast<TypeRefDirective>(&param)) {
-    ArgumentLengthKind lengthKind;
-    StringRef listName = getTypeListName(dir->getOperand(), lengthKind);
-    if (lengthKind == ArgumentLengthKind::Variadic)
-      body << llvm::formatv("{0}TypesRef", listName);
-    else if (lengthKind == ArgumentLengthKind::Optional)
-      body << llvm::formatv("{0}TypeRef", listName);
-    else
-      body << formatv("{0}RawTypesRef[0]", listName);
+  } else if (auto *dir = dyn_cast<RefDirective>(&param)) {
+    genCustomParameterParser(*dir->getOperand(), body);
+
   } else if (auto *dir = dyn_cast<TypeDirective>(&param)) {
     ArgumentLengthKind lengthKind;
     StringRef listName = getTypeListName(dir->getOperand(), lengthKind);
     if (lengthKind == ArgumentLengthKind::Variadic)
       body << llvm::formatv("{0}Types", listName);
     else if (lengthKind == ArgumentLengthKind::Optional)
       body << llvm::formatv("{0}Type", listName);
     else
if (auto *operand = dyn_cast<OperandVariable>(&param)) {
       body << "    " << operand->getVar()->name
            << "OperandsLoc = parser.getCurrentLocation();\n";
       if (operand->getVar()->isOptional()) {
         body << llvm::formatv(
             "    llvm::Optional<::mlir::OpAsmParser::OperandType> "
             "{0}Operand;\n",
             operand->getVar()->name);
       }
-    } else if (auto *dir = dyn_cast<TypeRefDirective>(&param)) {
-      // Reference to an optional which may or may not have been set.
-      // Retrieve from vector if not empty.
-      ArgumentLengthKind lengthKind;
-      StringRef listName = getTypeListName(dir->getOperand(), lengthKind);
-      if (lengthKind == ArgumentLengthKind::Optional)
-        body << llvm::formatv(
-            "    ::mlir::Type {0}TypeRef = {0}TypesRef.empty() "
-            "? Type() : {0}TypesRef[0];\n",
-            listName);
     } else if (auto *dir = dyn_cast<TypeDirective>(&param)) {
       ArgumentLengthKind lengthKind;
       StringRef listName = getTypeListName(dir->getOperand(), lengthKind);
       if (lengthKind == ArgumentLengthKind::Optional)
         body << llvm::formatv("    ::mlir::Type {0}Type;\n", listName);
+    } else if (auto *dir = dyn_cast<RefDirective>(&param)) {
+      Element *input = dir->getOperand();
+      if (auto *operand = dyn_cast<OperandVariable>(input)) {
+        if (!operand->getVar()->isOptional())
+          continue;
+        body << llvm::formatv(
+            "    {0} {1}Operand = {1}Operands.empty() ? {0}() : "
+            "{1}Operands[0];\n",
+            "llvm::Optional<::mlir::OpAsmParser::OperandType>",
+            operand->getVar()->name);
+
+      } else if (auto *type = dyn_cast<TypeDirective>(input)) {
+        ArgumentLengthKind lengthKind;
+        StringRef listName = getTypeListName(type->getOperand(), lengthKind);
+        if (lengthKind == ArgumentLengthKind::Optional) {
+          body << llvm::formatv("    ::mlir::Type {0}Type = {0}Types.empty() ? "
+                                "::mlir::Type() : {0}Types[0];\n",
+                                listName);
+        }
+      }
     }
   }
 
   body << "    if (parse" << dir->getName() << "(parser";
-  for (Element &param : dir->getArguments())
+  for (Element &param : dir->getArguments()) {
+    body << ", ";
     genCustomParameterParser(param, body);
+  }
 
   body << "))\n"
        << "      return ::mlir::failure();\n";
 
   // After parsing, add handling for any of the optional constructs.
   for (Element &param : dir->getArguments()) {
     if (auto *attr = dyn_cast<AttributeVariable>(&param)) {
       const NamedAttribute *var = attr->getVar();
       if (var->attr.isOptional())
         body << llvm::formatv("    if ({0}Attr)\n  ", var->name);
 
       body << llvm::formatv("    result.addAttribute(\"{0}\", {0}Attr);\n",
                             var->name);
     } else if (auto *operand = dyn_cast<OperandVariable>(&param)) {
       const NamedTypeConstraint *var = operand->getVar();
       if (!var->isOptional())
         continue;
       body << llvm::formatv("    if ({0}Operand.hasValue())\n"
                             "      {0}Operands.push_back(*{0}Operand);\n",
                             var->name);
-    } else if (isa<TypeRefDirective>(&param)) {
-      // In the `type_ref` case, do not parse a new Type that needs to be added.
-      // Just do nothing here.
     } else if (auto *dir = dyn_cast<TypeDirective>(&param)) {
       ArgumentLengthKind lengthKind;
       StringRef listName = getTypeListName(dir->getOperand(), lengthKind);
       if (lengthKind == ArgumentLengthKind::Optional) {
         body << llvm::formatv("    if ({0}Type)\n"
                               "      {0}Types.push_back({0}Type);\n",
                               listName);
       }
void OperationFormat::genElementParser(Element *element, OpMethodBody &body,
   } else if (isa<RegionsDirective>(element)) {
     body << llvm::formatv(regionListParserCode, "full");
     if (hasImplicitTermTrait)
       body << llvm::formatv(regionListEnsureTerminatorParserCode, "full");
 
   } else if (isa<SuccessorsDirective>(element)) {
     body << llvm::formatv(successorListParserCode, "full");
 
-  } else if (auto *dir = dyn_cast<TypeRefDirective>(element)) {
-    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<TypeDirective>(element)) {
     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
if (value) {
     body << "  p << ' ';\n";
     lastWasPunctuation = false;
   } else {
     lastWasPunctuation = true;
   }
   shouldEmitSpace = false;
 }
 
-/// Generate the printer for a custom directive.
-static void genCustomDirectivePrinter(CustomDirective *customDir,
+/// Generate the printer for a custom directive parameter.
+static void genCustomDirectiveParameterPrinter(Element *element,
                                                OpMethodBody &body) {
-  body << "  print" << customDir->getName() << "(p, *this";
-  for (Element &param : customDir->getArguments()) {
-    body << ", ";
-    if (auto *attr = dyn_cast<AttributeVariable>(&param)) {
-      body << attr->getVar()->name << "Attr()";
+  if (auto *attr = dyn_cast<AttributeVariable>(element)) {
 
-    } else if (isa<AttrDictDirective>(&param)) {
-      body << "getOperation()->getAttrDictionary()";
+  } else if (isa<AttrDictDirective>(element)) {
 
-    } else if (auto *operand = dyn_cast<OperandVariable>(&param)) {
-      body << operand->getVar()->name << "()";
+  } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
 
-    } else if (auto *region = dyn_cast<RegionVariable>(&param)) {
-      body << region->getVar()->name << "()";
+  } else if (auto *region = dyn_cast<RegionVariable>(element)) {
 
-    } else if (auto *successor = dyn_cast<SuccessorVariable>(&param)) {
-      body << successor->getVar()->name << "()";
+  } else if (auto *successor = dyn_cast<SuccessorVariable>(element)) {
 
-    } else if (auto *dir = dyn_cast<TypeRefDirective>(&param)) {
-      auto *typeOperand = dir->getOperand();
-      auto *operand = dyn_cast<OperandVariable>(typeOperand);
-      auto *var = operand ? operand->getVar()
-                          : cast<ResultVariable>(typeOperand)->getVar();
-      if (var->isVariadic())
-        body << var->name << "().getTypes()";
-      else if (var->isOptional())
-        body << llvm::formatv("({0}() ? {0}().getType() : Type())", var->name);
-      else
-        body << var->name << "().getType()";
-    } else if (auto *dir = dyn_cast<TypeDirective>(&param)) {
-      auto *typeOperand = dir->getOperand();
-      auto *operand = dyn_cast<OperandVariable>(typeOperand);
-      auto *var = operand ? operand->getVar()
-                          : cast<ResultVariable>(typeOperand)->getVar();
-      if (var->isVariadic())
-        body << var->name << "().getTypes()";
-      else if (var->isOptional())
-        body << llvm::formatv("({0}() ? {0}().getType() : Type())", var->name);
-      else
-        body << var->name << "().getType()";
-    } else {
-      llvm_unreachable("unknown custom directive parameter");
-    }
-  }
+  } else if (auto *dir = dyn_cast<RefDirective>(element)) {
+    genCustomDirectiveParameterPrinter(dir->getOperand(), body);
+
+  } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
 
+/// Generate the printer for a custom directive.
+static void genCustomDirectivePrinter(CustomDirective *customDir,
+                                      OpMethodBody &body) {
+  body << "  print" << customDir->getName() << "(p, *this";
+  for (Element &param : customDir->getArguments()) {
+    body << ", ";
+    genCustomDirectiveParameterPrinter(&param, body);
+  }
   body << ");\n";
 }
 
 /// Generate the printer for a region with the given variable name.
 static void genRegionPrinter(const Twine &regionName, OpMethodBody &body,
                              bool hasImplicitTermTrait) {
   if (hasImplicitTermTrait)
     body << llvm::formatv(regionSingleBlockImplicitTerminatorPrinterCode,
void OperationFormat::genElementPrinter(Element *element, OpMethodBody &body,
   } else if (isa<RegionsDirective>(element)) {
     genVariadicRegionPrinter("getOperation()->getRegions()", body,
                              hasImplicitTermTrait);
   } else if (isa<SuccessorsDirective>(element)) {
     body << "  ::llvm::interleaveComma(getOperation()->getSuccessors(), p);\n";
   } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
     body << "  p << ";
     genTypeOperandPrinter(dir->getOperand(), body) << ";\n";
-  } else if (auto *dir = dyn_cast<TypeRefDirective>(element)) {
-    body << "  p << ";
-    genTypeOperandPrinter(dir->getOperand(), body) << ";\n";
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
     body << "  p.printFunctionalType(";
     genTypeOperandPrinter(dir->getInputs(), body) << ", ";
     genTypeOperandPrinter(dir->getResults(), body) << ");\n";
   } else {
     llvm_unreachable("unknown format element");
   }
 }
enum Kind {
 
     // Keywords.
     keyword_start,
     kw_attr_dict,
     kw_attr_dict_w_keyword,
     kw_custom,
     kw_functional_type,
     kw_operands,
+    kw_ref,
     kw_regions,
     kw_results,
     kw_successors,
     kw_type,
-    kw_type_ref,
     keyword_end,
 
     // String valued tokens.
     identifier,
     literal,
     variable,
   };
   Token(Kind kind, StringRef spelling) : kind(kind), spelling(spelling) {}
Token FormatLexer::lexIdentifier(const char *tokStart) {
   StringRef str(tokStart, curPtr - tokStart);
   Token::Kind kind =
       StringSwitch<Token::Kind>(str)
           .Case("attr-dict", Token::kw_attr_dict)
           .Case("attr-dict-with-keyword", Token::kw_attr_dict_w_keyword)
           .Case("custom", Token::kw_custom)
           .Case("functional-type", Token::kw_functional_type)
           .Case("operands", Token::kw_operands)
+          .Case("ref", Token::kw_ref)
           .Case("regions", Token::kw_regions)
           .Case("results", Token::kw_results)
           .Case("successors", Token::kw_successors)
           .Case("type", Token::kw_type)
-          .Case("type_ref", Token::kw_type_ref)
           .Default(Token::identifier);
   return Token(kind, str);
 }
 
 //===----------------------------------------------------------------------===//
 // FormatParser
 //===----------------------------------------------------------------------===//
 
FormatParser(llvm::SourceMgr &mgr, OperationFormat &format, Operator &op)
       : lexer(mgr, op), curToken(lexer.lexToken()), fmt(format), op(op),
         seenOperandTypes(op.getNumOperands()),
         seenResultTypes(op.getNumResults()) {}
 
   /// Parse the operation assembly format.
   LogicalResult parse();
 
 private:
+  /// The current context of the parser when parsing an element.
+  enum ParserContext {
+    /// The element is being parsed in a "top-level" context, i.e. at the top of
+    /// the format or in an optional group.
+    TopLevelContext,
+    /// The element is being parsed as a custom directive child.
+    CustomDirectiveContext,
+    /// The element is being parsed as a type directive child.
+    TypeDirectiveContext,
+    /// The element is being parsed as a reference directive child.
+    RefDirectiveContext
+  };
+
   /// This struct represents a type resolution instance. It includes a specific
   /// type as well as an optional transformer to apply to that type in order to
   /// properly resolve the type of a variable.
   struct TypeResolutionInstance {
     ConstArgument resolver;
     Optional<StringRef> transformer;
   };
 
void handleTypesMatchConstraint(
       llvm::Record def);
 
   /// Returns an argument or attribute with the given name that has been seen
   /// within the format.
   ConstArgument findSeenArg(StringRef name);
 
   /// Parse a specific element.
   LogicalResult parseElement(std::unique_ptr<Element> &element,
-                             bool isTopLevel);
+                             ParserContext context);
   LogicalResult parseVariable(std::unique_ptr<Element> &element,
-                              bool isTopLevel);
+                              ParserContext context);
   LogicalResult parseDirective(std::unique_ptr<Element> &element,
-                               bool isTopLevel);
-  LogicalResult parseLiteral(std::unique_ptr<Element> &element);
+                               ParserContext context);
+  LogicalResult parseLiteral(std::unique_ptr<Element> &element,
+                             ParserContext context);
   LogicalResult parseOptional(std::unique_ptr<Element> &element,
-                              bool isTopLevel);
+                              ParserContext context);
   LogicalResult parseOptionalChildElement(
       std::vector<std::unique_ptr<Element>> &childElements,
       Optional<unsigned> &anchorIdx);
   LogicalResult verifyOptionalChildElement(Element *element,
                                            llvm::SMLoc childLoc, bool isAnchor);
 
   /// Parse the various different directives.
   LogicalResult parseAttrDictDirective(std::unique_ptr<Element> &element,
-                                       llvm::SMLoc loc, bool isTopLevel,
+                                       llvm::SMLoc loc, ParserContext context,
                                        bool withKeyword);
   LogicalResult parseCustomDirective(std::unique_ptr<Element> &element,
-                                     llvm::SMLoc loc, bool isTopLevel);
+                                     llvm::SMLoc loc, ParserContext context);
   LogicalResult parseCustomDirectiveParameter(
       std::vector<std::unique_ptr<Element>> &parameters);
   LogicalResult parseFunctionalTypeDirective(std::unique_ptr<Element> &element,
-                                             Token tok, bool isTopLevel);
+                                             Token tok, ParserContext context);
   LogicalResult parseOperandsDirective(std::unique_ptr<Element> &element,
-                                       llvm::SMLoc loc, bool isTopLevel);
+                                       llvm::SMLoc loc, ParserContext context);
+  LogicalResult parseReferenceDirective(std::unique_ptr<Element> &element,
+                                        llvm::SMLoc loc, ParserContext context);
   LogicalResult parseRegionsDirective(std::unique_ptr<Element> &element,
-                                      llvm::SMLoc loc, bool isTopLevel);
+                                      llvm::SMLoc loc, ParserContext context);
   LogicalResult parseResultsDirective(std::unique_ptr<Element> &element,
-                                      llvm::SMLoc loc, bool isTopLevel);
+                                      llvm::SMLoc loc, ParserContext context);
   LogicalResult parseSuccessorsDirective(std::unique_ptr<Element> &element,
-                                         llvm::SMLoc loc, bool isTopLevel);
+                                         llvm::SMLoc loc,
+                                         ParserContext context);
   LogicalResult parseTypeDirective(std::unique_ptr<Element> &element, Token tok,
-                                   bool isTopLevel, bool isTypeRef = false);
+                                   ParserContext context);
   LogicalResult parseTypeDirectiveOperand(std::unique_ptr<Element> &element,
-                                          bool isTypeRef = false);
+                                          bool isRefChild = false);
 
   //===--------------------------------------------------------------------===//
   // Lexer Utilities
   //===--------------------------------------------------------------------===//
 
   /// Advance the current lexer onto the next token.
   void consumeToken() {
     assert(curToken.getKind() != Token::eof &&

 } // end anonymous namespace
 
 LogicalResult FormatParser::parse() {
   llvm::SMLoc loc = curToken.getLoc();
 
   // Parse each of the format elements into the main format.
   while (curToken.getKind() != Token::eof) {
     std::unique_ptr<Element> element;
-    if (failed(parseElement(element, /*isTopLevel=*/true)))
+    if (failed(parseElement(element, TopLevelContext)))
       return ::mlir::failure();
     fmt.elements.push_back(std::move(element));
   }
 
   // Check that the attribute dictionary is in the format.
   if (!hasAttrDict)
     return emitError(loc, "'attr-dict' directive not found in "
                           "custom assembly format");
ConstArgument FormatParser::findSeenArg(StringRef name) {
   if (const NamedTypeConstraint *arg = findArg(op.getResults(), name))
     return seenResultTypes.test(arg - op.result_begin()) ? arg : nullptr;
   if (const NamedAttribute *attr = findArg(op.getAttributes(), name))
     return seenAttrs.count(attr) ? attr : nullptr;
   return nullptr;
 }
 
 LogicalResult FormatParser::parseElement(std::unique_ptr<Element> &element,
-                                         bool isTopLevel) {
+                                         ParserContext context) {
   // Directives.
   if (curToken.isKeyword())
-    return parseDirective(element, isTopLevel);
+    return parseDirective(element, context);
   // Literals.
   if (curToken.getKind() == Token::literal)
-    return parseLiteral(element);
+    return parseLiteral(element, context);
   // Optionals.
   if (curToken.getKind() == Token::l_paren)
-    return parseOptional(element, isTopLevel);
+    return parseOptional(element, context);
   // Variables.
   if (curToken.getKind() == Token::variable)
-    return parseVariable(element, isTopLevel);
+    return parseVariable(element, context);
   return emitError(curToken.getLoc(),
                    "expected directive, literal, variable, or optional group");
 }
 
 LogicalResult FormatParser::parseVariable(std::unique_ptr<Element> &element,
-                                          bool isTopLevel) {
+                                          ParserContext context) {
   Token varTok = curToken;
   consumeToken();
 
   StringRef name = varTok.getSpelling().drop_front();
   llvm::SMLoc loc = varTok.getLoc();
 
   // Check that the parsed argument is something actually registered on the
   // op.
   /// Attributes
   if (const NamedAttribute *attr = findArg(op.getAttributes(), name)) {
-    if (isTopLevel && !seenAttrs.insert(attr))
+    if (context == TypeDirectiveContext)
+      return emitError(
+          loc, "attributes cannot be used as children to a `type` directive");
+    if (context == RefDirectiveContext) {
+      if (!seenAttrs.count(attr))
+        return emitError(loc, "attribute '" + name +
+                                  "' must be bound before it is referenced");
+    } else if (!seenAttrs.insert(attr)) {
       return emitError(loc, "attribute '" + name + "' is already bound");
+    }
+
     element = std::make_unique<AttributeVariable>(attr);
     return ::mlir::success();
   }
   /// Operands
   if (const NamedTypeConstraint *operand = findArg(op.getOperands(), name)) {
-    if (isTopLevel) {
+    if (context == TopLevelContext || context == CustomDirectiveContext) {
       if (fmt.allOperands || !seenOperands.insert(operand).second)
         return emitError(loc, "operand '" + name + "' is already bound");
+    } else if (context == RefDirectiveContext && !seenOperands.count(operand)) {
+      return emitError(loc, "operand '" + name +
+                                "' must be bound before it is referenced");
     }
     element = std::make_unique<OperandVariable>(operand);
     return ::mlir::success();
   }
   /// Regions
   if (const NamedRegion *region = findArg(op.getRegions(), name)) {
-    if (!isTopLevel)
-      return emitError(loc, "regions can only be used at the top level");
+    if (context == TopLevelContext || context == CustomDirectiveContext) {
       if (hasAllRegions || !seenRegions.insert(region).second)
         return emitError(loc, "region '" + name + "' is already bound");
+    } else if (context == RefDirectiveContext && !seenRegions.count(region)) {
+      return emitError(loc, "region '" + name +
+                                "' must be bound before it is referenced");
+    } else {
+      return emitError(loc, "regions can only be used at the top level");
+    }
     element = std::make_unique<RegionVariable>(region);
     return ::mlir::success();
   }
   /// Results.
   if (const auto *result = findArg(op.getResults(), name)) {
-    if (isTopLevel)
-      return emitError(loc, "results can not be used at the top level");
+    if (context != TypeDirectiveContext)
+      return emitError(loc, "result variables can can only be used as a child "
+                            "to a 'type' directive");
     element = std::make_unique<ResultVariable>(result);
     return ::mlir::success();
   }
   /// Successors.
   if (const auto *successor = findArg(op.getSuccessors(), name)) {
-    if (!isTopLevel)
-      return emitError(loc, "successors can only be used at the top level");
+    if (context == TopLevelContext || context == CustomDirectiveContext) {
       if (hasAllSuccessors || !seenSuccessors.insert(successor).second)
         return emitError(loc, "successor '" + name + "' is already bound");
+    } else if (context == RefDirectiveContext &&
+               !seenSuccessors.count(successor)) {
+      return emitError(loc, "successor '" + name +
+                                "' must be bound before it is referenced");
+    } else {
+      return emitError(loc, "successors can only be used at the top level");
+    }
+
     element = std::make_unique<SuccessorVariable>(successor);
     return ::mlir::success();
   }
   return emitError(loc, "expected variable to refer to an argument, region, "
                         "result, or successor");
 }
 
 LogicalResult FormatParser::parseDirective(std::unique_ptr<Element> &element,
-                                           bool isTopLevel) {
+                                           ParserContext context) {
   Token dirTok = curToken;
   consumeToken();
 
   switch (dirTok.getKind()) {
   case Token::kw_attr_dict:
-    return parseAttrDictDirective(element, dirTok.getLoc(), isTopLevel,
+    return parseAttrDictDirective(element, dirTok.getLoc(), context,
                                   /*withKeyword=*/false);
   case Token::kw_attr_dict_w_keyword:
-    return parseAttrDictDirective(element, dirTok.getLoc(), isTopLevel,
+    return parseAttrDictDirective(element, dirTok.getLoc(), context,
                                   /*withKeyword=*/true);
   case Token::kw_custom:
-    return parseCustomDirective(element, dirTok.getLoc(), isTopLevel);
+    return parseCustomDirective(element, dirTok.getLoc(), context);
   case Token::kw_functional_type:
-    return parseFunctionalTypeDirective(element, dirTok, isTopLevel);
+    return parseFunctionalTypeDirective(element, dirTok, context);
   case Token::kw_operands:
-    return parseOperandsDirective(element, dirTok.getLoc(), isTopLevel);
+    return parseOperandsDirective(element, dirTok.getLoc(), context);
   case Token::kw_regions:
-    return parseRegionsDirective(element, dirTok.getLoc(), isTopLevel);
+    return parseRegionsDirective(element, dirTok.getLoc(), context);
   case Token::kw_results:
-    return parseResultsDirective(element, dirTok.getLoc(), isTopLevel);
+    return parseResultsDirective(element, dirTok.getLoc(), context);
   case Token::kw_successors:
-    return parseSuccessorsDirective(element, dirTok.getLoc(), isTopLevel);
-  case Token::kw_type_ref:
-    return parseTypeDirective(element, dirTok, isTopLevel, /*isTypeRef=*/true);
+    return parseSuccessorsDirective(element, dirTok.getLoc(), context);
+  case Token::kw_ref:
+    return parseReferenceDirective(element, dirTok.getLoc(), context);
   case Token::kw_type:
-    return parseTypeDirective(element, dirTok, isTopLevel);
+    return parseTypeDirective(element, dirTok, context);
 
   default:
     llvm_unreachable("unknown directive token");
   }
 }
 
-LogicalResult FormatParser::parseLiteral(std::unique_ptr<Element> &element) {
+LogicalResult FormatParser::parseLiteral(std::unique_ptr<Element> &element,
+                                         ParserContext context) {
   Token literalTok = curToken;
+  if (context != TopLevelContext) {
+    return emitError(
+        literalTok.getLoc(),
+        "literals may only be used in a top-level section of the format");
+  }
   consumeToken();
 
   StringRef value = literalTok.getSpelling().drop_front().drop_back();
 
   // The parsed literal is a space element (`` or ` `).
   if (value.empty() || (value.size() == 1 && value.front() == ' ')) {
     element = std::make_unique<SpaceElement>(!value.empty());
     return ::mlir::success();
   }
   // The parsed literal is a newline element.
   if (value == "\\n") {
     element = std::make_unique<NewlineElement>();
     return ::mlir::success();
   }
 
   // Check that the parsed literal is valid.
   if (!LiteralElement::isValidLiteral(value))
     return emitError(literalTok.getLoc(), "expected valid literal");
 
   element = std::make_unique<LiteralElement>(value);
   return ::mlir::success();
 }
 
 LogicalResult FormatParser::parseOptional(std::unique_ptr<Element> &element,
-                                          bool isTopLevel) {
+                                          ParserContext context) {
   llvm::SMLoc curLoc = curToken.getLoc();
-  if (!isTopLevel)
+  if (context != TopLevelContext)
     return emitError(curLoc, "optional groups can only be used as top-level "
                              "elements");
   consumeToken();
 
   // Parse the child elements for this optional group.
   std::vector<std::unique_ptr<Element>> elements;
   Optional<unsigned> anchorIdx;
   do {
LogicalResult FormatParser::parseOptional(std::unique_ptr<Element> &element,
   return ::mlir::success();
 }
 
 LogicalResult FormatParser::parseOptionalChildElement(
     std::vector<std::unique_ptr<Element>> &childElements,
     Optional<unsigned> &anchorIdx) {
   llvm::SMLoc childLoc = curToken.getLoc();
   childElements.push_back({});
-  if (failed(parseElement(childElements.back(), /*isTopLevel=*/true)))
+  if (failed(parseElement(childElements.back(), TopLevelContext)))
     return ::mlir::failure();
 
   // Check to see if this element is the anchor of the optional group.
   bool isAnchor = curToken.getKind() == Token::caret;
   if (isAnchor) {
     if (anchorIdx)
       return emitError(childLoc, "only one element can be marked as the anchor "
                                  "of an optional group");
return TypeSwitch<Element *, LogicalResult>(element)
       .Case([&](AttributeVariable *attrEle) {
         if (isAnchor && !attrEle->getVar()->attr.isOptional())
           return emitError(childLoc, "only optional attributes can be used to "
                                      "anchor an optional group");
         return ::mlir::success();
       })
       // Only optional-like(i.e. variadic) operands can be within an optional
       // group.
-      .Case<OperandVariable>([&](OperandVariable *ele) {
+      .Case([&](OperandVariable *ele) {
         if (!ele->getVar()->isVariableLength())
           return emitError(childLoc, "only variable length operands can be "
                                      "used within an optional group");
         return ::mlir::success();
       })
       // Only optional-like(i.e. variadic) results can be within an optional
       // group.
-      .Case<ResultVariable>([&](ResultVariable *ele) {
+      .Case([&](ResultVariable *ele) {
         if (!ele->getVar()->isVariableLength())
           return emitError(childLoc, "only variable length results can be "
                                      "used within an optional group");
         return ::mlir::success();
       })
-      .Case<RegionVariable>([&](RegionVariable *) {
+      .Case([&](RegionVariable *) {
         // TODO: When ODS has proper support for marking "optional" regions, add
         // a check here.
         return ::mlir::success();
       })
-      .Case<TypeDirective>([&](TypeDirective *ele) {
+      .Case([&](TypeDirective *ele) {
         return verifyOptionalChildElement(ele->getOperand(), childLoc,
                                           /*isAnchor=*/false);
       })
-      .Case<FunctionalTypeDirective>([&](FunctionalTypeDirective *ele) {
+      .Case([&](FunctionalTypeDirective *ele) {
         if (failed(verifyOptionalChildElement(ele->getInputs(), childLoc,
                                               /*isAnchor=*/false)))
           return failure();
         return verifyOptionalChildElement(ele->getResults(), childLoc,
                                           /*isAnchor=*/false);
       })
       // Literals, whitespace, and custom directives may be used, but they can't
       // anchor the group.
       .Case<LiteralElement, WhitespaceElement, CustomDirective,
-            FunctionalTypeDirective, OptionalElement, TypeRefDirective>(
-          [&](Element *) {
-            if (isAnchor)
-              return emitError(childLoc, "only variables and types can be used "
-                                         "to anchor an optional group");
-            return ::mlir::success();
-          })
+            FunctionalTypeDirective, OptionalElement>([&](Element *) {
       .Default([&](Element *) {
         return emitError(childLoc, "only literals, types, and variables can be "
                                    "used within an optional group");
       });
 }
 
 LogicalResult
 FormatParser::parseAttrDictDirective(std::unique_ptr<Element> &element,
-                                     llvm::SMLoc loc, bool isTopLevel,
+                                     llvm::SMLoc loc, ParserContext context,
                                      bool withKeyword) {
-  if (!isTopLevel)
+  if (context == TypeDirectiveContext)
     return emitError(loc, "'attr-dict' directive can only be used as a "
                           "top-level directive");
+
+  if (context == RefDirectiveContext) {
+    if (!hasAttrDict)
+      return emitError(loc, "'ref' of 'attr-dict' is not bound by a prior "
+                            "'attr-dict' directive");
+
+    // Otherwise, this is a top-level context.
+  } else {
     if (hasAttrDict)
       return emitError(loc, "'attr-dict' directive has already been seen");
-
     hasAttrDict = true;
+  }
+
   element = std::make_unique<AttrDictDirective>(withKeyword);
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseCustomDirective(std::unique_ptr<Element> &element,
-                                   llvm::SMLoc loc, bool isTopLevel) {
+                                   llvm::SMLoc loc, ParserContext context) {
   llvm::SMLoc curLoc = curToken.getLoc();
+  if (context != TopLevelContext)
+    return emitError(loc, "'custom' is only valid as a top-level directive");
 
   // Parse the custom directive name.
   if (failed(
           parseToken(Token::less, "expected '<' before custom directive name")))
     return ::mlir::failure();
 
   Token nameTok = curToken;
   if (failed(parseToken(Token::identifier,
FormatParser::parseCustomDirective(std::unique_ptr<Element> &element,
 
   if (failed(parseToken(Token::r_paren,
                         "expected ')' after custom directive parameters")))
     return ::mlir::failure();
 
   // After parsing all of the elements, ensure that all type directives refer
   // only to variables.
   for (auto &ele : elements) {
-    if (auto *typeEle = dyn_cast<TypeRefDirective>(ele.get())) {
-      if (!isa<OperandVariable, ResultVariable>(typeEle->getOperand())) {
-        return emitError(curLoc,
-                         "type_ref directives within a custom directive "
-                         "may only refer to variables");
-      }
-    }
     if (auto *typeEle = dyn_cast<TypeDirective>(ele.get())) {
       if (!isa<OperandVariable, ResultVariable>(typeEle->getOperand())) {
         return emitError(curLoc, "type directives within a custom directive "
                                  "may only refer to variables");
       }
     }
   }
 
   element = std::make_unique<CustomDirective>(nameTok.getSpelling(),
                                               std::move(elements));
   return ::mlir::success();
 }
 
 LogicalResult FormatParser::parseCustomDirectiveParameter(
     std::vector<std::unique_ptr<Element>> &parameters) {
   llvm::SMLoc childLoc = curToken.getLoc();
   parameters.push_back({});
-  if (failed(parseElement(parameters.back(), /*isTopLevel=*/true)))
+  if (failed(parseElement(parameters.back(), CustomDirectiveContext)))
     return ::mlir::failure();
 
   // Verify that the element can be placed within a custom directive.
-  if (!isa<TypeRefDirective, TypeDirective, AttrDictDirective,
-           AttributeVariable, OperandVariable, RegionVariable,
-           SuccessorVariable>(parameters.back().get())) {
+  if (!isa<RefDirective, TypeDirective, AttrDictDirective, AttributeVariable,
+           OperandVariable, RegionVariable, SuccessorVariable>(
+          parameters.back().get())) {
     return emitError(childLoc, "only variables and types may be used as "
                                "parameters to a custom directive");
   }
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseFunctionalTypeDirective(std::unique_ptr<Element> &element,
-                                           Token tok, bool isTopLevel) {
+                                           Token tok, ParserContext context) {
   llvm::SMLoc loc = tok.getLoc();
-  if (!isTopLevel)
+  if (context != TopLevelContext)
     return emitError(
         loc, "'functional-type' is only valid as a top-level directive");
 
   // Parse the main operand.
   std::unique_ptr<Element> inputs, results;
   if (failed(parseToken(Token::l_paren, "expected '(' before argument list")) ||
       failed(parseTypeDirectiveOperand(inputs)) ||
       failed(parseToken(Token::comma, "expected ',' after inputs argument")) ||
       failed(parseTypeDirectiveOperand(results)) ||
       failed(parseToken(Token::r_paren, "expected ')' after argument list")))
     return ::mlir::failure();
   element = std::make_unique<FunctionalTypeDirective>(std::move(inputs),
                                                       std::move(results));
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseOperandsDirective(std::unique_ptr<Element> &element,
-                                     llvm::SMLoc loc, bool isTopLevel) {
-  if (isTopLevel) {
+                                     llvm::SMLoc loc, ParserContext context) {
+  if (context == RefDirectiveContext) {
+    if (!fmt.allOperands)
+      return emitError(loc, "'ref' of 'operands' is not bound by a prior "
+                            "'operands' directive");
+
+  } else if (context == TopLevelContext || context == CustomDirectiveContext) {
     if (fmt.allOperands || !seenOperands.empty())
       return emitError(loc, "'operands' directive creates overlap in format");
     fmt.allOperands = true;
   }
   element = std::make_unique<OperandsDirective>();
   return ::mlir::success();
 }
 
 LogicalResult
+FormatParser::parseReferenceDirective(std::unique_ptr<Element> &element,
+                                      llvm::SMLoc loc, ParserContext context) {
+  if (context != CustomDirectiveContext)
+    return emitError(loc, "'ref' is only valid within a `custom` directive");
+
+  std::unique_ptr<Element> operand;
+  if (failed(parseToken(Token::l_paren, "expected '(' before argument list")) ||
+      failed(parseElement(operand, RefDirectiveContext)) ||
+      failed(parseToken(Token::r_paren, "expected ')' after argument list")))
+    return ::mlir::failure();
+
+  element = std::make_unique<RefDirective>(std::move(operand));
+  return ::mlir::success();
+}
+
+LogicalResult
 FormatParser::parseRegionsDirective(std::unique_ptr<Element> &element,
-                                    llvm::SMLoc loc, bool isTopLevel) {
-  if (!isTopLevel)
+                                    llvm::SMLoc loc, ParserContext context) {
+  if (context == TypeDirectiveContext)
     return emitError(loc, "'regions' is only valid as a top-level directive");
+  if (context == RefDirectiveContext) {
+    if (!hasAllRegions)
+      return emitError(loc, "'ref' of 'regions' is not bound by a prior "
+                            "'regions' directive");
+
+    // Otherwise, this is a TopLevel directive.
+  } else {
     if (hasAllRegions || !seenRegions.empty())
       return emitError(loc, "'regions' directive creates overlap in format");
     hasAllRegions = true;
+  }
   element = std::make_unique<RegionsDirective>();
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseResultsDirective(std::unique_ptr<Element> &element,
-                                    llvm::SMLoc loc, bool isTopLevel) {
-  if (isTopLevel)
-    return emitError(loc, "'results' directive can not be used as a "
-                          "top-level directive");
+                                    llvm::SMLoc loc, ParserContext context) {
+  if (context != TypeDirectiveContext)
+    return emitError(loc, "'results' directive can can only be used as a child "
+                          "to a 'type' directive");
   element = std::make_unique<ResultsDirective>();
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseSuccessorsDirective(std::unique_ptr<Element> &element,
-                                       llvm::SMLoc loc, bool isTopLevel) {
-  if (!isTopLevel)
+                                       llvm::SMLoc loc, ParserContext context) {
+  if (context == TypeDirectiveContext)
     return emitError(loc,
                      "'successors' is only valid as a top-level directive");
+  if (context == RefDirectiveContext) {
+    if (!hasAllSuccessors)
+      return emitError(loc, "'ref' of 'successors' is not bound by a prior "
+                            "'successors' directive");
+
+    // Otherwise, this is a TopLevel directive.
+  } else {
     if (hasAllSuccessors || !seenSuccessors.empty())
       return emitError(loc, "'successors' directive creates overlap in format");
     hasAllSuccessors = true;
+  }
   element = std::make_unique<SuccessorsDirective>();
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseTypeDirective(std::unique_ptr<Element> &element, Token tok,
-                                 bool isTopLevel, bool isTypeRef) {
+                                 ParserContext context) {
   llvm::SMLoc loc = tok.getLoc();
-  if (!isTopLevel)
-    return emitError(loc, "'type' is only valid as a top-level directive");
+  if (context == TypeDirectiveContext)
+    return emitError(loc, "'type' cannot be used as a child of another `type`");
 
+  bool isRefChild = context == RefDirectiveContext;
   std::unique_ptr<Element> operand;
   if (failed(parseToken(Token::l_paren, "expected '(' before argument list")) ||
-      failed(parseTypeDirectiveOperand(operand, isTypeRef)) ||
+      failed(parseTypeDirectiveOperand(operand, isRefChild)) ||
       failed(parseToken(Token::r_paren, "expected ')' after argument list")))
     return ::mlir::failure();
-  if (isTypeRef)
-    element = std::make_unique<TypeRefDirective>(std::move(operand));
-  else
-    element = std::make_unique<TypeDirective>(std::move(operand));
+
   return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseTypeDirectiveOperand(std::unique_ptr<Element> &element,
-                                        bool isTypeRef) {
+                                        bool isRefChild) {
   llvm::SMLoc loc = curToken.getLoc();
-  if (failed(parseElement(element, /*isTopLevel=*/false)))
+  if (failed(parseElement(element, TypeDirectiveContext)))
     return ::mlir::failure();
   if (isa<LiteralElement>(element.get()))
     return emitError(
         loc, "'type' directive operand expects variable or directive operand");
 
   if (auto *var = dyn_cast<OperandVariable>(element.get())) {
     unsigned opIdx = var->getVar() - op.operand_begin();
-    if (!isTypeRef && (fmt.allOperandTypes || seenOperandTypes.test(opIdx)))
+    if (!isRefChild && (fmt.allOperandTypes || seenOperandTypes.test(opIdx)))
       return emitError(loc, "'type' of '" + var->getVar()->name +
                                 "' is already bound");
-    if (isTypeRef && !(fmt.allOperandTypes || seenOperandTypes.test(opIdx)))
-      return emitError(loc, "'type_ref' of '" + var->getVar()->name +
-                                "' is not bound by a prior 'type' directive");
+    if (isRefChild && !(fmt.allOperandTypes || seenOperandTypes.test(opIdx)))
+      return emitError(loc, "'ref' of 'type($" + var->getVar()->name +
+                                ")' is not bound by a prior 'type' directive");
     seenOperandTypes.set(opIdx);
   } else if (auto *var = dyn_cast<ResultVariable>(element.get())) {
     unsigned resIdx = var->getVar() - op.result_begin();
-    if (!isTypeRef && (fmt.allResultTypes || seenResultTypes.test(resIdx)))
+    if (!isRefChild && (fmt.allResultTypes || seenResultTypes.test(resIdx)))
       return emitError(loc, "'type' of '" + var->getVar()->name +
                                 "' is already bound");
-    if (isTypeRef && !(fmt.allResultTypes || seenResultTypes.test(resIdx)))
-      return emitError(loc, "'type_ref' of '" + var->getVar()->name +
-                                "' is not bound by a prior 'type' directive");
+    if (isRefChild && !(fmt.allResultTypes || seenResultTypes.test(resIdx)))
+      return emitError(loc, "'ref' of 'type($" + var->getVar()->name +
+                                ")' is not bound by a prior 'type' directive");
     seenResultTypes.set(resIdx);
   } else if (isa<OperandsDirective>(&*element)) {
-    if (!isTypeRef && (fmt.allOperandTypes || seenOperandTypes.any()))
+    if (!isRefChild && (fmt.allOperandTypes || seenOperandTypes.any()))
       return emitError(loc, "'operands' 'type' is already bound");
-    if (isTypeRef && !(fmt.allOperandTypes || seenOperandTypes.all()))
-      return emitError(
-          loc,
-          "'operands' 'type_ref' is not bound by a prior 'type' directive");
+    if (isRefChild && !fmt.allOperandTypes)
+      return emitError(loc, "'ref' of 'type(operands)' is not bound by a prior "
+                            "'type' directive");
     fmt.allOperandTypes = true;
   } else if (isa<ResultsDirective>(&*element)) {
-    if (!isTypeRef && (fmt.allResultTypes || seenResultTypes.any()))
+    if (!isRefChild && (fmt.allResultTypes || seenResultTypes.any()))
       return emitError(loc, "'results' 'type' is already bound");
-    if (isTypeRef && !(fmt.allResultTypes || seenResultTypes.all()))
-      return emitError(
-          loc, "'results' 'type_ref' is not bound by a prior 'type' directive");
+    if (isRefChild && !fmt.allResultTypes)
+      return emitError(loc, "'ref' of 'type(results)' is not bound by a prior "
+                            "'type' directive");
     fmt.allResultTypes = true;
   } else {
     return emitError(loc, "invalid argument to 'type' directive");
   }
   return ::mlir::success();
 }
 
 //===----------------------------------------------------------------------===//