[mlir] Declarative Assembly Format - Revert spurious commit of TypeRefDirective

[nicolasvasilache]

The whole mechanism has been generalized by @rriddle and this is now obsolete.

mlir/docs/OpDefinitions.md

*   `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:
 
 `:`, `,`, `=`, `<`, `>`, `(`, `)`, `{`, `}`, `[`, `]`, `->`
 
*   Region Variables
     -   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> &`
 
 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 &`), and secondly 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:
*   Region Variables
     -   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`
 
 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
 of the assembly format can be marked as `optional` based on the presence of this

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

if (succeeded(parser.parseOptionalComma())) {
     if (parser.parseType(optOperandType))
       return failure();
   }
   if (parser.parseArrow() || parser.parseLParen() ||
       parser.parseTypeList(varOperandTypes) || parser.parseRParen())
     return failure();
   return success();
 }
-static ParseResult
-parseCustomDirectiveWithTypeRefs(OpAsmParser &parser, Type operandType,
-                                 Type optOperandType,
-                                 const SmallVectorImpl<Type> &varOperandTypes) {
-  if (parser.parseKeyword("type_refs_capture"))
-    return failure();
-
-  Type operandType2, optOperandType2;
-  SmallVector<Type, 1> varOperandTypes2;
-  if (parseCustomDirectiveResults(parser, operandType2, optOperandType2,
-                                  varOperandTypes2))
-    return failure();
-
-  if (operandType != operandType2 || optOperandType != optOperandType2 ||
-      varOperandTypes != varOperandTypes2)
-    return failure();
-
-  return success();
-}
 static ParseResult parseCustomDirectiveOperandsAndTypes(
     OpAsmParser &parser, OpAsmParser::OperandType &operand,
     Optional<OpAsmParser::OperandType> &optOperand,
     SmallVectorImpl<OpAsmParser::OperandType> &varOperands, Type &operandType,
     Type &optOperandType, SmallVectorImpl<Type> &varOperandTypes) {
   if (parseCustomDirectiveOperands(parser, operand, optOperand, varOperands) ||
       parseCustomDirectiveResults(parser, operandType, optOperandType,
                                   varOperandTypes))

 static void printCustomDirectiveResults(OpAsmPrinter &printer, Type operandType,
                                         Type optOperandType,
                                         TypeRange varOperandTypes) {
   printer << " : " << operandType;
   if (optOperandType)
     printer << ", " << optOperandType;
   printer << " -> (" << varOperandTypes << ")";
 }
-static void printCustomDirectiveWithTypeRefs(OpAsmPrinter &printer,
-                                             Type operandType,
-                                             Type optOperandType,
-                                             TypeRange varOperandTypes) {
-  printer << " type_refs_capture ";
-  printCustomDirectiveResults(printer, operandType, optOperandType,
-                              varOperandTypes);
-}
 static void
 printCustomDirectiveOperandsAndTypes(OpAsmPrinter &printer, Value operand,
                                      Value optOperand, OperandRange varOperands,
                                      Type operandType, Type optOperandType,
                                      TypeRange varOperandTypes) {
   printCustomDirectiveOperands(printer, operand, optOperand, varOperands);
   printCustomDirectiveResults(printer, operandType, optOperandType,
                               varOperandTypes);

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

def FormatCustomDirectiveResults
   let assemblyFormat = [{
     custom<CustomDirectiveResults>(
       type($result), type($optResult), type($varResults)
     )
     attr-dict
   }];
 }
 
-def FormatCustomDirectiveResultsWithTypeRefs
-    : 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)
-    )
-    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

 // CHECK: error: 'type' of 'result' is already bound
 def DirectiveTypeZOperandInvalidH : TestFormat_Op<"type_operand_invalid_h", [{
   type(results) type($result)
 }]>, Results<(outs I64:$result)>;
 // CHECK: error: 'type' of 'result' is already bound
 def DirectiveTypeZOperandInvalidI : TestFormat_Op<"type_operand_invalid_i", [{
   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", [{
+def DirectiveTypeZOperandValid : TestFormat_Op<"type_operand_valid", [{
   type(operands) type(results) attr-dict
 }]>;
 
 //===----------------------------------------------------------------------===//
 // Literals
 //===----------------------------------------------------------------------===//
 
 // Test all of the valid literals.

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

 }
 
 // CHECK: test.format_custom_directive_results : i64, i64 -> (i64)
 test.format_custom_directive_results : i64, i64 -> (i64)
 
 // CHECK: test.format_custom_directive_results : i64 -> (i64)
 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)
-
 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

enum class Kind {
     AttrDictDirective,
     CustomDirective,
     FunctionalTypeDirective,
     OperandsDirective,
     RegionsDirective,
     ResultsDirective,
     SuccessorsDirective,
     TypeDirective,
-    TypeRefDirective,
 
     /// This element is a literal.
     Literal,
 
     /// This element is an variable value.
     AttributeVariable,
     OperandVariable,
     RegionVariable,

 public:
   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;
 };
-
-/// This class represents the `type_ref` directive.
-class TypeRefDirective
-    : public DirectiveElement<Element::Kind::TypeRefDirective> {
-public:
-  TypeRefDirective(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
+} // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // LiteralElement
 
 namespace {
 /// This class represents an instance of a literal element.
 class LiteralElement : public Element {
 public:
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";
   }
 }
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<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);
     }
   }
 
   body << "    if (parse" << dir->getName() << "(parser";
   for (Element &param : dir->getArguments())
     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);
+      body << llvm::formatv(
+          "    result.attributes.addAttribute(\"{0}\", {0}Attr);", 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 (auto *attr = dyn_cast<AttributeVariable>(&param)) {
       body << operand->getVar()->name << "()";
 
     } else if (auto *region = dyn_cast<RegionVariable>(&param)) {
       body << region->getVar()->name << "()";
 
     } else if (auto *successor = dyn_cast<SuccessorVariable>(&param)) {
       body << successor->getVar()->name << "()";
 
-    } 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())
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 {
     kw_attr_dict_w_keyword,
     kw_custom,
     kw_functional_type,
     kw_operands,
     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::Kind kind =
           .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("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
 //===----------------------------------------------------------------------===//
 
LogicalResult parseOperandsDirective(std::unique_ptr<Element> &element,
                                        llvm::SMLoc loc, bool isTopLevel);
   LogicalResult parseRegionsDirective(std::unique_ptr<Element> &element,
                                       llvm::SMLoc loc, bool isTopLevel);
   LogicalResult parseResultsDirective(std::unique_ptr<Element> &element,
                                       llvm::SMLoc loc, bool isTopLevel);
   LogicalResult parseSuccessorsDirective(std::unique_ptr<Element> &element,
                                          llvm::SMLoc loc, bool isTopLevel);
   LogicalResult parseTypeDirective(std::unique_ptr<Element> &element, Token tok,
-                                   bool isTopLevel, bool isTypeRef = false);
-  LogicalResult parseTypeDirectiveOperand(std::unique_ptr<Element> &element,
-                                          bool isTypeRef = false);
+                                   bool isTopLevel);
+  LogicalResult parseTypeDirectiveOperand(std::unique_ptr<Element> &element);
 
   //===--------------------------------------------------------------------===//
   // Lexer Utilities
   //===--------------------------------------------------------------------===//
 
   /// Advance the current lexer onto the next token.
   void consumeToken() {
     assert(curToken.getKind() != Token::eof &&
LogicalResult FormatParser::parseDirective(std::unique_ptr<Element> &element,
   case Token::kw_operands:
     return parseOperandsDirective(element, dirTok.getLoc(), isTopLevel);
   case Token::kw_regions:
     return parseRegionsDirective(element, dirTok.getLoc(), isTopLevel);
   case Token::kw_results:
     return parseResultsDirective(element, dirTok.getLoc(), isTopLevel);
   case Token::kw_successors:
     return parseSuccessorsDirective(element, dirTok.getLoc(), isTopLevel);
-  case Token::kw_type_ref:
-    return parseTypeDirective(element, dirTok, isTopLevel, /*isTypeRef=*/true);
   case Token::kw_type:
     return parseTypeDirective(element, dirTok, isTopLevel);
 
   default:
     llvm_unreachable("unknown directive token");
   }
 }
 
auto checkTypeOperand = [&](Element *typeEle) {
     auto *opVar = dyn_cast<OperandVariable>(typeEle);
     const NamedTypeConstraint *var = opVar ? opVar->getVar() : nullptr;
     if (!seenVariables.count(var))
       return emitError(curLoc, "type directive can only refer to variables "
                                "within the optional group");
     return ::mlir::success();
   };
   for (auto &ele : elements) {
-    if (auto *typeEle = dyn_cast<TypeRefDirective>(ele.get())) {
-      if (failed(checkTypeOperand(typeEle->getOperand())))
-        return failure();
-    } else if (auto *typeEle = dyn_cast<TypeDirective>(ele.get())) {
+    if (auto *typeEle = dyn_cast<TypeDirective>(ele.get())) {
       if (failed(checkTypeOperand(typeEle->getOperand())))
         return ::mlir::failure();
     } else if (auto *typeEle = dyn_cast<FunctionalTypeDirective>(ele.get())) {
       if (failed(checkTypeOperand(typeEle->getInputs())) ||
           failed(checkTypeOperand(typeEle->getResults())))
         return ::mlir::failure();
     }
   }
return TypeSwitch<Element *, LogicalResult>(childElements.back().get())
       .Case<RegionVariable>([&](RegionVariable *) {
         // TODO: When ODS has proper support for marking "optional" regions, add
         // a check here.
         return ::mlir::success();
       })
       // Literals, custom directives, and type directives may be used,
       // but they can't anchor the group.
       .Case<LiteralElement, CustomDirective, FunctionalTypeDirective,
-            OptionalElement, TypeRefDirective, TypeDirective>([&](Element *) {
+            OptionalElement, TypeDirective>([&](Element *) {
         if (isAnchor)
           return emitError(childLoc, "only variables can be used to anchor "
                                      "an optional group");
         return ::mlir::success();
       })
       .Default([&](Element *) {
         return emitError(childLoc, "only literals, types, and variables can be "
                                    "used within an optional group");
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)))
     return ::mlir::failure();
 
   // Verify that the element can be placed within a custom directive.
-  if (!isa<TypeRefDirective, TypeDirective, AttributeVariable, OperandVariable,
-           RegionVariable, SuccessorVariable>(parameters.back().get())) {
+  if (!isa<TypeDirective, 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,
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) {
+                                 bool isTopLevel) {
   llvm::SMLoc loc = tok.getLoc();
   if (!isTopLevel)
     return emitError(loc, "'type' is only valid as a top-level directive");
 
   std::unique_ptr<Element> operand;
   if (failed(parseToken(Token::l_paren, "expected '(' before argument list")) ||
-      failed(parseTypeDirectiveOperand(operand, isTypeRef)) ||
+      failed(parseTypeDirectiveOperand(operand)) ||
       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) {
+FormatParser::parseTypeDirectiveOperand(std::unique_ptr<Element> &element) {
   llvm::SMLoc loc = curToken.getLoc();
   if (failed(parseElement(element, /*isTopLevel=*/false)))
     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 (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");
     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 (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");
     seenResultTypes.set(resIdx);
   } else if (isa<OperandsDirective>(&*element)) {
-    if (!isTypeRef && (fmt.allOperandTypes || seenOperandTypes.any()))
+    if (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");
     fmt.allOperandTypes = true;
   } else if (isa<ResultsDirective>(&*element)) {
-    if (!isTypeRef && (fmt.allResultTypes || seenResultTypes.any()))
+    if (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");
     fmt.allResultTypes = true;
   } else {
     return emitError(loc, "invalid argument to 'type' directive");
   }
   return ::mlir::success();
 }
 
 //===----------------------------------------------------------------------===//