Add a `qualified` directive to the Op, Attribute, and Type declarative assembly format

[mehdi_amini]

Summary

This patch introduces a new directive that allow to parse/print attributes and types fully
qualified.
This is a follow-up to ee0908703d29 which introduces the eliding of the !dialect.mnemonic by default and allows to force to fully qualify each type/attribute
individually.

[jpienaar]

mlir/docs/Tutorials/DefiningAttributesAndTypes.md

493

Copy pasta?

523

And by nesting here this also means for nested types inside type nested in directive?

[jpienaar]

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

92

shouldBeQualified?

[mehdi_amini]

mlir/docs/Tutorials/DefiningAttributesAndTypes.md

523

It does not mean "recursive" if this is what you're asking for

[mehdi_amini]

Addess Jacques' comments

[rriddle]

LGTM after resolving comments. It's nice to be able to opt out for those that don't want the more implicit behavior.

mlir/docs/OpDefinitions.md

656

mlir/docs/Tutorials/DefiningAttributesAndTypes.md

523–525

?

I also found the wording including nesting a bit confusing.

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

151–154

^ better matches how we format everywhere else, not sure why this file formats this way.

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

80–83

same comment as other file, but I guess this is fine for the sake of conformance with the other tests (we should NFC fix that though)

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

314–316

mlir/test/mlir-tblgen/testdialect-typedefs.mlir

33–35

semi unrelated, but could this just be a declaration?

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

92–95

Can you document these functions?

96–97

684–685

In the failed(var) case, is that going to lead to a double error message?

mlir/tools/mlir-tblgen/OpFormatGen.cpp

48

Is this necessary? I wouldn't expect so, given that there is no element class added.

122–125

Can you add documentation here?

3225–3227

nit: I might have added braces here given that this statement stretches 3 lines.

3229

Not sure why we are qualifying ::mlir:: in this code. I should really go through and clean this up.

[stellaraccident]

Thanks - lg modulo comments.

[bondhugula]

Nice!

mlir/docs/OpDefinitions.md

659

, -> ;

mlir/tools/mlir-tblgen/OpFormatGen.cpp

255

Nit: Flat to indicate ... -> Indicates ....

[mehdi_amini]

Address comments

[mehdi_amini]

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

92–95

Moving the comment from the member variable to the accessors then.

mlir/tools/mlir-tblgen/OpFormatGen.cpp

48

No this is from an early attempt...

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.
 
+*   `qualified` ( type_or_attribute )
+
+    -   Wrap a `type` directive or an attribute parameter.
+    -   Used to force printing the type or attribute prefixed with its dialect
+        and mnemonic. For example the `vector.multi_reduction` operation has a
+        `kind` attribute, by default the declarative assembly will print:
+        `vector.multi_reduction <minf>, ...` but using `qualified($kind)` in the
+        declarative assembly format will print it instead as:
+        `vector.multi_reduction #vector.kind<minf>, ...`.
+
 #### Literals
 
 A literal is either a keyword or punctuation surrounded by \`\`.
 
 The following are the set of valid punctuation:
 
 `:`, `,`, `=`, `<`, `>`, `(`, `)`, `{`, `}`, `[`, `]`, `->`, `?`, `+`, `*`
 

mlir/docs/Tutorials/DefiningAttributesAndTypes.md

 For example, `StringRefParameter` uses `std::string` as its storage type,
 whereas `ArrayRefParameter` uses `SmallVector` as its storage type. The parsers
 for these parameters are expected to return `FailureOr<$cppStorageType>`.
 
 ### Assembly Format Directives
 
 Attribute and type assembly formats have the following directives:
 
-* `params`: capture all parameters of an attribute or type.
-* `struct`: generate a "struct-like" parser and printer for a list of key-value
-  pairs.
+*   `params`: capture all parameters of an attribute or type.
+*   `qualified`: capture all parameters of an attribute or type.
+*   `struct`: generate a "struct-like" parser and printer for a list of
+    key-value pairs.
 
 #### `params` Directive
 
 This directive is used to refer to all parameters of an attribute or type.
 When used as a top-level directive, `params` generates a parser and printer for
 a comma-separated list of the parameters. For example:
 
 ```tablegen

 ```mlir
 !my_dialect.pair<42, 24>
 ```
 
 The `params` directive can also be passed to other directives, such as `struct`,
 as an argument that refers to all parameters in place of explicitly listing all
 parameters as variables.
 
+#### `qualified` Directive
+
+This directive can be used to wrap parameters so that nested types and/or
+attributes are printed fully qualified, that is they include the dialect name
+and mnemonic prefix.
+
+For example:
+
+```tablegen
+def OuterType : TypeDef<My_Dialect, "MyOuterType"> {
+  let parameters = (ins MyPairType:$inner);
+  let mnemonic = "outer";
+  let assemblyFormat = "`<` pair `:` $inner `>`";
+}
+def OuterQualifiedType : TypeDef<My_Dialect, "MyOuterQualifiedType"> {
+  let parameters = (ins MyPairType:$inner);
+  let mnemonic = "outer_qual";
+  let assemblyFormat = "`<` pair `:` qualified($inner) `>`";
+}
+```
+
+In the IR, the types will appear as:
+
+```mlir
+!my_dialect.outer<pair : <42, 24>>
+!my_dialect.outer_qual<pair : !mydialect.pair<42, 24>>
+```
+
 #### `struct` Directive
 
 The `struct` directive accepts a list of variables to capture and will generate
 a parser and printer for a comma-separated list of key-value pairs. The
 variables are printed in the order they are specified in the argument list **but
 can be parsed in any order**. For example:
 
 ```tablegen

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

def CompoundNestedOuter : Test_Attr<"CompoundNestedOuter"> {
   // List of type parameters.
   let parameters = (
     ins
     CompoundNestedInner:$inner
   );
   let assemblyFormat = "`<` `i`  $inner `>`";
 }
 
+def CompoundNestedOuterQual : Test_Attr<"CompoundNestedOuterQual"> {
+  let mnemonic = "cmpnd_nested_outer_qual";
+
+  // List of type parameters.
+  let parameters = (
+    ins
+    CompoundNestedInner:$inner
+  );
+  let assemblyFormat = "`<` `i`  qualified($inner) `>`";
+}
+
 def TestParamOne : AttrParameter<"int64_t", ""> {}
 
 def TestParamTwo : AttrParameter<"std::string", "", "llvm::StringRef"> {
   let printer = "$_printer << '\"' << $_self << '\"'";
 }
 
 def TestParamFour : ArrayRefParameter<"int", ""> {
   let cppStorageType = "llvm::SmallVector<int>";

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

def FormatNestedAttr : TEST_Op<"format_nested_attr"> {
   let assemblyFormat = "$nested attr-dict-with-keyword";
 }
 
 def FormatNestedCompoundAttr : TEST_Op<"format_cpmd_nested_attr"> {
   let arguments = (ins CompoundNestedOuter:$nested);
   let assemblyFormat = "`nested` $nested attr-dict-with-keyword";
 }
 
+def FormatQualifiedCompoundAttr : TEST_Op<"format_qual_cpmd_nested_attr"> {
+  let arguments = (ins CompoundNestedOuter:$nested);
+  let assemblyFormat = "`nested` qualified($nested) attr-dict-with-keyword";
+}
+
 def FormatNestedType : TEST_Op<"format_cpmd_nested_type"> {
   let arguments = (ins CompoundNestedOuterType:$nested);
   let assemblyFormat = "$nested `nested` type($nested) attr-dict-with-keyword";
 }
 
+def FormatQualifiedNestedType : TEST_Op<"format_qual_cpmd_nested_type"> {
+  let arguments = (ins CompoundNestedOuterType:$nested);
+  let assemblyFormat = "$nested `nested` qualified(type($nested)) attr-dict-with-keyword";
+}
+
 //===----------------------------------------------------------------------===//
 // Custom Directives
 
 def FormatCustomDirectiveOperands
     : TEST_Op<"format_custom_directive_operands", [AttrSizedOperandSegments]> {
   let arguments = (ins I64:$operand, Optional<I64>:$optOperand,
                        Variadic<I64>:$varOperands);
   let assemblyFormat = [{

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

def CompoundNestedOuterType : Test_Type<"CompoundNestedOuter"> {
   // List of type parameters.
   let parameters = (
     ins
     CompoundNestedInnerType:$inner
   );
   let assemblyFormat = "`<` `i`  $inner `>`";
 }
 
+def CompoundNestedOuterTypeQual : Test_Type<"CompoundNestedOuterQual"> {
+  let mnemonic = "cmpnd_nested_outer_qual";
+
+  // List of type parameters.
+  let parameters = (
+    ins
+    CompoundNestedInnerType:$inner
+  );
+  let assemblyFormat = "`<` `i`  qualified($inner) `>`";
+}
+
 // An example of how one could implement a standard integer.
 def IntegerType : Test_Type<"TestInteger"> {
   let mnemonic = "int";
   let genVerifyDecl = 1;
   let parameters = (
     ins
     "unsigned":$width,
     // SignednessSemantics is defined below.

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

 {
 }
 
 //-----
 
 // CHECK: test.format_cpmd_nested_attr nested <i <42 <1, !test.smpla, [5, 6]>>>
 test.format_cpmd_nested_attr nested <i <42 <1, !test.smpla, [5, 6]>>>
 
+//-----
+
+// CHECK: test.format_qual_cpmd_nested_attr nested #test.cmpnd_nested_outer<i <42 <1, !test.smpla, [5, 6]>>>
+test.format_qual_cpmd_nested_attr nested #test.cmpnd_nested_outer<i <42 <1, !test.smpla, [5, 6]>>>
+
+//-----
+
+// Check the `qualified` directive in the declarative assembly format.
+// CHECK: @qualifiedCompoundNestedExplicit(%arg0: !test.cmpnd_nested_outer<i <42 <1, !test.smpla, [5, 6]>>>)
+func @qualifiedCompoundNestedExplicit(%arg0: !test.cmpnd_nested_outer<i !test.cmpnd_inner<42 <1, !test.smpla, [5, 6]>>>) -> () {
+// Verify that the type prefix is not elided
+// CHECK: format_qual_cpmd_nested_type %arg0 nested !test.cmpnd_nested_outer<i <42 <1, !test.smpla, [5, 6]>>>
+  test.format_qual_cpmd_nested_type %arg0 nested !test.cmpnd_nested_outer<i <42 <1, !test.smpla, [5, 6]>>>
+  return
+}
+
+//-----
+
 //===----------------------------------------------------------------------===//
 // Format custom directives
 //===----------------------------------------------------------------------===//
 
 // CHECK: test.format_custom_directive_operands %[[I64]], %[[I64]] -> (%[[I64]])
 test.format_custom_directive_operands %i64, %i64 -> (%i64)
 
 // CHECK: test.format_custom_directive_operands %[[I64]] -> (%[[I64]])

mlir/test/mlir-tblgen/testdialect-attrdefs.mlir

 // RUN: mlir-opt %s | mlir-opt -verify-diagnostics | FileCheck %s
 
 // CHECK-LABEL: func private @compoundA()
 // CHECK-SAME: #test.cmpnd_a<1, !test.smpla, [5, 6]>
 func private @compoundA() attributes {foo = #test.cmpnd_a<1, !test.smpla, [5, 6]>}
 
 // CHECK: test.result_has_same_type_as_attr #test<"attr_with_self_type_param i32"> -> i32
 %a = test.result_has_same_type_as_attr #test<"attr_with_self_type_param i32"> -> i32
 
 // CHECK: test.result_has_same_type_as_attr #test<"attr_with_type_builder 10 : i16"> -> i16
 %b = test.result_has_same_type_as_attr #test<"attr_with_type_builder 10 : i16"> -> i16
+
+// CHECK-LABEL: @qualifiedAttr()
+// CHECK-SAME: #test.cmpnd_nested_outer_qual<i #test.cmpnd_nested_inner<42 <1, !test.smpla, [5, 6]>>>
+func private @qualifiedAttr() attributes {foo = #test.cmpnd_nested_outer_qual<i #test.cmpnd_nested_inner<42 <1, !test.smpla, [5, 6]>>>}

mlir/test/mlir-tblgen/testdialect-typedefs.mlir

 // Verify that the type prefix is elided and optional
 // CHECK: format_cpmd_nested_type %arg0 nested <i <42 <1, !test.smpla, [5, 6]>>>
 // CHECK: format_cpmd_nested_type %arg0 nested <i <42 <1, !test.smpla, [5, 6]>>>
   test.format_cpmd_nested_type %arg0 nested !test.cmpnd_nested_outer<i !test.cmpnd_inner<42 <1, !test.smpla, [5, 6]>>>
   test.format_cpmd_nested_type %arg0 nested <i <42 <1, !test.smpla, [5, 6]>>>
   return
 }
 
+// CHECK: @compoundNestedQual(%arg0: !test.cmpnd_nested_outer_qual<i !test.cmpnd_inner<42 <1, !test.smpla, [5, 6]>>>)
+func @compoundNestedQual(%arg0: !test.cmpnd_nested_outer_qual<i !test.cmpnd_inner<42 <1, !test.smpla, [5, 6]>>>) -> () {
+  return
+}
+
 // CHECK: @testInt(%arg0: !test.int<signed, 8>, %arg1: !test.int<unsigned, 2>, %arg2: !test.int<none, 1>)
 func @testInt(%A : !test.int<s, 8>, %B : !test.int<unsigned, 2>, %C : !test.int<n, 1>) {
   return
 }
 
 // CHECK: @structTest(%arg0: !test.struct<{field1,!test.smpla},{field2,!test.int<none, 3>}>)
 func @structTest (%A : !test.struct< {field1, !test.smpla}, {field2, !test.int<none, 3>} > ) {
   return
 }

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

public:
 
   static bool classof(const Element *el) {
     return el->getKind() == Kind::Variable;
   }
 
   /// Get the parameter in the element.
   const AttrOrTypeParameter &getParam() const { return param; }
 
+  bool isQualified() { return qualified; }
+  void setQualified(bool qualified = true) { this->qualified = qualified; }
+
 private:
+  // Flag to indicate if this variable is printed "qualified" (that is it is
+  // prefixed with the `#dialect.mnemonic`).
+  bool qualified = false;
   AttrOrTypeParameter param;
 };
 
 /// Base class for a directive that contains references to multiple variables.
 template <Element::Kind ElementKind>
 class ParamsDirectiveBase : public Element {
 public:
   using Base = ParamsDirectiveBase<ElementKind>;

 /// Default parser for attribute or type parameters.
 static const char *const defaultParameterParser =
     "::mlir::FieldParser<$0>::parse($_parser)";
 
 /// Default printer for attribute or type parameters.
 static const char *const defaultParameterPrinter =
     "$_printer.printStrippedAttrOrType($_self)";
 
+/// Qualified printer for attribute or type parameters: it does not elide
+/// dialect and mnemonic.
+static const char *const qualifiedParameterPrinter = "$_printer << $_self";
+
 /// Print an error when failing to parse an element.
 ///
 /// $0: The parameter C++ class name.
 static const char *const parseErrorStr =
     "$_parser.emitError($_parser.getCurrentLocation(), ";
 
 /// Loop declaration for struct parser.
 ///
private:
   void genStructParser(StructDirective *el, FmtContext &ctx, MethodBody &os);
 
   /// Generate the printer code for a specific format element.
   void genElementPrinter(Element *el, FmtContext &ctx, MethodBody &os);
   /// Generate the printer code for a literal.
   void genLiteralPrinter(StringRef value, FmtContext &ctx, MethodBody &os);
   /// Generate the printer code for a variable.
   void genVariablePrinter(const AttrOrTypeParameter &param, FmtContext &ctx,
-                          MethodBody &os);
+                          MethodBody &os, bool printQualified = false);
   /// Generate the printer code for a `params` directive.
   void genParamsPrinter(ParamsDirective *el, FmtContext &ctx, MethodBody &os);
   /// Generate the printer code for a `struct` directive.
   void genStructPrinter(StructDirective *el, FmtContext &ctx, MethodBody &os);
 
   /// The ODS definition of the attribute or type whose format is being used to
   /// generate a parser and printer.
   const AttrOrTypeDef &def;
void AttrOrTypeFormat::genElementPrinter(Element *el, FmtContext &ctx,
                                          MethodBody &os) {
   if (auto *literal = dyn_cast<LiteralElement>(el))
     return genLiteralPrinter(literal->getSpelling(), ctx, os);
   if (auto *params = dyn_cast<ParamsDirective>(el))
     return genParamsPrinter(params, ctx, os);
   if (auto *strct = dyn_cast<StructDirective>(el))
     return genStructPrinter(strct, ctx, os);
   if (auto *var = dyn_cast<VariableElement>(el))
-    return genVariablePrinter(var->getParam(), ctx, os);
+    return genVariablePrinter(var->getParam(), ctx, os, var->isQualified());
 
   llvm_unreachable("unknown format element");
 }
 
 void AttrOrTypeFormat::genLiteralPrinter(StringRef value, FmtContext &ctx,
                                          MethodBody &os) {
   /// Don't insert a space before certain punctuation.
   bool needSpace =
       shouldEmitSpace && shouldEmitSpaceBefore(value, lastWasPunctuation);
   os << tgfmt("  $_printer$0 << \"$1\";\n", &ctx, needSpace ? " << ' '" : "",
               value);
 
   /// Update the flags.
   shouldEmitSpace =
       value.size() != 1 || !StringRef("<({[").contains(value.front());
   lastWasPunctuation = !(value.front() == '_' || isalpha(value.front()));
 }
 
 void AttrOrTypeFormat::genVariablePrinter(const AttrOrTypeParameter &param,
-                                          FmtContext &ctx, MethodBody &os) {
+                                          FmtContext &ctx, MethodBody &os,
+                                          bool printQualified) {
   /// Insert a space before the next parameter, if necessary.
   if (shouldEmitSpace || !lastWasPunctuation)
     os << tgfmt("  $_printer << ' ';\n", &ctx);
   shouldEmitSpace = true;
   lastWasPunctuation = false;
 
   ctx.withSelf(getParameterAccessorName(param.getName()) + "()");
   os << "  ";
-  if (auto printer = param.getPrinter())
+  if (printQualified)
+    os << tgfmt(qualifiedParameterPrinter, &ctx) << ";\n";
+  else if (auto printer = param.getPrinter())
     os << tgfmt(*printer, &ctx) << ";\n";
   else
     os << tgfmt(defaultParameterPrinter, &ctx) << ";\n";
 }
 
 void AttrOrTypeFormat::genParamsPrinter(ParamsDirective *el, FmtContext &ctx,
                                         MethodBody &os) {
   llvm::interleave(
private:
   /// Parse a literal element.
   FailureOr<std::unique_ptr<Element>> parseLiteral(ParserContext ctx);
   /// Parse a variable element.
   FailureOr<std::unique_ptr<Element>> parseVariable(ParserContext ctx);
   /// Parse a directive.
   FailureOr<std::unique_ptr<Element>> parseDirective(ParserContext ctx);
   /// Parse a `params` directive.
   FailureOr<std::unique_ptr<Element>> parseParamsDirective();
+  /// Parse a `qualified` directive.
+  FailureOr<std::unique_ptr<Element>>
+  parseQualifiedDirective(ParserContext ctx);
   /// Parse a `struct` directive.
   FailureOr<std::unique_ptr<Element>> parseStructDirective();
 
   /// The current format lexer.
   FormatLexer lexer;
   /// The current token in the stream.
   FormatToken curToken;
   /// Attribute or type tablegen def.
FormatParser::parseVariable(ParserContext ctx) {
   consumeToken();
   return {std::make_unique<VariableElement>(*it)};
 }
 
 FailureOr<std::unique_ptr<Element>>
 FormatParser::parseDirective(ParserContext ctx) {
 
   switch (curToken.getKind()) {
+  case FormatToken::kw_qualified:
+    return parseQualifiedDirective(ctx);
   case FormatToken::kw_params:
     return parseParamsDirective();
   case FormatToken::kw_struct:
     if (ctx != TopLevelContext) {
       return emitError(
           "`struct` may only be used in the top-level section of the format");
     }
     return parseStructDirective();
   default:
     return emitError("unknown directive in format: " + curToken.getSpelling());
   }
 }
 
+FailureOr<std::unique_ptr<Element>>
+FormatParser::parseQualifiedDirective(ParserContext ctx) {
+  consumeToken();
+  if (failed(parseToken(FormatToken::l_paren,
+                        "expected '(' before argument list")))
+    return failure();
+  FailureOr<std::unique_ptr<Element>> var = parseElement(ctx);
+  if (failed(var) || !isa<VariableElement>(*var))
+    return emitError("`qualified` argument list expected a variable");
+  cast<VariableElement>(var->get())->setQualified();
+  if (failed(
+          parseToken(FormatToken::r_paren, "expected ')' after argument list")))
+    return failure();
+  return var;
+}
+
 FailureOr<std::unique_ptr<Element>> FormatParser::parseParamsDirective() {
   consumeToken();
   /// Collect all of the attribute's or type's parameters.
   SmallVector<std::unique_ptr<Element>> vars;
   /// Ensure that none of the parameters have already been captured.
   for (const auto &it : llvm::enumerate(def.getParameters())) {
     if (seenParams.test(it.index())) {
       return emitError("`params` captures duplicate parameter: " +

mlir/tools/mlir-tblgen/FormatGen.h

enum Kind {
     // Keywords.
     keyword_start,
     kw_attr_dict,
     kw_attr_dict_w_keyword,
     kw_custom,
     kw_functional_type,
     kw_operands,
     kw_params,
+    kw_qualified,
     kw_ref,
     kw_regions,
     kw_results,
     kw_struct,
     kw_successors,
     kw_type,
     keyword_end,
 

mlir/tools/mlir-tblgen/FormatGen.cpp

auto kind =
           .Case("operands", FormatToken::kw_operands)
           .Case("params", FormatToken::kw_params)
           .Case("ref", FormatToken::kw_ref)
           .Case("regions", FormatToken::kw_regions)
           .Case("results", FormatToken::kw_results)
           .Case("struct", FormatToken::kw_struct)
           .Case("successors", FormatToken::kw_successors)
           .Case("type", FormatToken::kw_type)
+          .Case("qualified", FormatToken::kw_qualified)
           .Default(FormatToken::identifier);
   return FormatToken(kind, str);
 }
 
 //===----------------------------------------------------------------------===//
 // Utility Functions
 //===----------------------------------------------------------------------===//
 

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 class Element {
 public:
   enum class Kind {
     /// This element is a directive.
     AttrDictDirective,
     CustomDirective,
     FunctionalTypeDirective,
     OperandsDirective,
+    QualifiedDirective,
     RefDirective,
     RegionsDirective,
     ResultsDirective,
     SuccessorsDirective,
     TypeDirective,
 
     /// This element is a literal.
     Literal,
Optional<StringRef> getTypeBuilder() const {
     Optional<Type> attrType = var->attr.getValueType();
     return attrType ? attrType->getBuilderCall() : llvm::None;
   }
 
   /// Return if this attribute refers to a UnitAttr.
   bool isUnitAttr() const {
     return var->attr.getBaseAttr().getAttrDefName() == "UnitAttr";
   }
+
+  bool isQualified() { return qualified; }
+  void setQualified(bool qualified = true) { this->qualified = qualified; }
+
+private:
+  // Flag to indicate if this attribute is printed "qualified" (that is it is
+  // prefixed with the `#dialect.mnemonic`).
+  bool qualified = false;
 };
 
 /// This class represents a variable that refers to an operand argument.
 using OperandVariable =
     VariableElement<NamedTypeConstraint, Element::Kind::OperandVariable>;
 
 /// This class represents a variable that refers to a region.
 using RegionVariable =
private:
   std::unique_ptr<Element> operand;
 };
 
 /// This class represents the `type` directive.
 class TypeDirective : public DirectiveElement<Element::Kind::TypeDirective> {
 public:
   TypeDirective(std::unique_ptr<Element> arg) : operand(std::move(arg)) {}
   Element *getOperand() const { return operand.get(); }
+  bool isQualified() { return qualified; }
+  void setQualified(bool qualified = true) { this->qualified = qualified; }
 
 private:
   /// The operand that is used to format the directive.
   std::unique_ptr<Element> operand;
+
+  // Flag to indicate if this type is printed "qualified" (that is it is
+  // prefixed with the `!dialect.mnemonic`).
+  bool qualified = false;
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // LiteralElement
 
 namespace {
 /// This class represents an instance of a literal element.

 const char *const typeParserCode = R"(
   {
     {0} type;
     if (parser.parseCustomTypeWithFallback(type))
       return ::mlir::failure();
     {1}RawTypes[0] = type;
   }
 )";
+const char *const qualifiedTypeParserCode = R"(
+  if (parser.parseType({1}RawTypes[0]))
+    return ::mlir::failure();
+)";
 
 /// The code snippet used to generate a parser call for a functional type.
 ///
 /// {0}: The name for the input type list.
 /// {1}: The name for the result type list.
 const char *const functionalTypeParserCode = R"(
   ::mlir::FunctionType {0}__{1}_functionType;
   if (parser.parseType({0}__{1}_functionType))
if (Optional<StringRef> typeBuilder = attr->getTypeBuilder()) {
       llvm::raw_string_ostream os(attrTypeStr);
       os << tgfmt(*typeBuilder, &attrTypeCtx);
     } else {
       attrTypeStr = "::mlir::Type{}";
     }
     if (var->attr.isOptional()) {
       body << formatv(optionalAttrParserCode, var->name, attrTypeStr);
     } else {
-      if (var->attr.getStorageType() == "::mlir::Attribute")
+      if (attr->isQualified() ||
+          var->attr.getStorageType() == "::mlir::Attribute")
         body << formatv(genericAttrParserCode, var->name, attrTypeStr);
       else
         body << formatv(attrParserCode, var->name, attrTypeStr);
     }
 
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
     ArgumentLengthKind lengthKind = getArgumentLengthKind(operand->getVar());
     StringRef name = operand->getVar()->name;
if (auto *optional = dyn_cast<OptionalElement>(element)) {
     StringRef listName = getTypeListName(dir->getOperand(), lengthKind);
     if (lengthKind == ArgumentLengthKind::VariadicOfVariadic) {
       body << llvm::formatv(variadicOfVariadicTypeParserCode, listName);
     } else if (lengthKind == ArgumentLengthKind::Variadic) {
       body << llvm::formatv(variadicTypeParserCode, listName);
     } else if (lengthKind == ArgumentLengthKind::Optional) {
       body << llvm::formatv(optionalTypeParserCode, listName);
     } else {
+      const char *parserCode =
+          dir->isQualified() ? qualifiedTypeParserCode : typeParserCode;
       TypeSwitch<Element *>(dir->getOperand())
           .Case<OperandVariable, ResultVariable>([&](auto operand) {
-            body << formatv(typeParserCode,
+            body << formatv(parserCode,
                             operand->getVar()->constraint.getCPPClassName(),
                             listName);
           })
           .Default([&](auto operand) {
-            body << formatv(typeParserCode, "::mlir::Type", listName);
+            body << formatv(parserCode, "::mlir::Type", listName);
           });
     }
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
     ArgumentLengthKind ignored;
     body << formatv(functionalTypeParserCode,
                     getTypeListName(dir->getInputs(), ignored),
                     getTypeListName(dir->getResults(), ignored));
   } else {
if (auto *attr = dyn_cast<AttributeVariable>(element)) {
 
     // Elide the attribute type if it is buildable.
     if (attr->getTypeBuilder())
       body << "  _odsPrinter.printAttributeWithoutType("
            << op.getGetterName(var->name) << "Attr());\n";
     else if (var->attr.isOptional())
       body << "_odsPrinter.printAttribute(" << op.getGetterName(var->name)
            << "Attr());\n";
-    else if (var->attr.getStorageType() == "::mlir::Attribute")
+    else if (attr->isQualified() ||
+             var->attr.getStorageType() == "::mlir::Attribute")
       body << "  _odsPrinter.printAttribute(" << op.getGetterName(var->name)
            << "Attr());\n";
     else
       body << "_odsPrinter.printStrippedAttrOrType("
            << op.getGetterName(var->name) << "Attr());\n";
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
     if (operand->getVar()->isVariadicOfVariadic()) {
       body << "  ::llvm::interleaveComma("
const NamedTypeConstraint *var = nullptr;
       if (auto *operand = dyn_cast<OperandVariable>(dir->getOperand()))
         var = operand->getVar();
       else if (auto *operand = dyn_cast<ResultVariable>(dir->getOperand()))
         var = operand->getVar();
     }
     if (var && !var->isVariadicOfVariadic() && !var->isVariadic() &&
         !var->isOptional()) {
       std::string cppClass = var->constraint.getCPPClassName();
+      if (dir->isQualified()) {
+        body << "   _odsPrinter << " << op.getGetterName(var->name)
+             << "().getType();\n";
+        return;
+      }
       body << "  {\n"
            << "    auto type = " << op.getGetterName(var->name)
            << "().getType();\n"
            << "    if (auto validType = type.dyn_cast<" << cppClass << ">())\n"
            << "      _odsPrinter.printStrippedAttrOrType(validType);\n"
            << "   else\n"
            << "     _odsPrinter << type;\n"
            << "  }\n";
LogicalResult parseCustomDirective(std::unique_ptr<Element> &element,
                                      llvm::SMLoc loc, ParserContext context);
   LogicalResult parseCustomDirectiveParameter(
       std::vector<std::unique_ptr<Element>> &parameters);
   LogicalResult parseFunctionalTypeDirective(std::unique_ptr<Element> &element,
                                              FormatToken tok,
                                              ParserContext context);
   LogicalResult parseOperandsDirective(std::unique_ptr<Element> &element,
                                        llvm::SMLoc loc, ParserContext context);
+  LogicalResult parseQualifiedDirective(std::unique_ptr<Element> &element,
+                                        FormatToken tok, ParserContext context);
   LogicalResult parseReferenceDirective(std::unique_ptr<Element> &element,
                                         llvm::SMLoc loc, ParserContext context);
   LogicalResult parseRegionsDirective(std::unique_ptr<Element> &element,
                                       llvm::SMLoc loc, ParserContext context);
   LogicalResult parseResultsDirective(std::unique_ptr<Element> &element,
                                       llvm::SMLoc loc, ParserContext context);
   LogicalResult parseSuccessorsDirective(std::unique_ptr<Element> &element,
                                          llvm::SMLoc loc,
case FormatToken::kw_attr_dict_w_keyword:
     return parseAttrDictDirective(element, dirTok.getLoc(), context,
                                   /*withKeyword=*/true);
   case FormatToken::kw_custom:
     return parseCustomDirective(element, dirTok.getLoc(), context);
   case FormatToken::kw_functional_type:
     return parseFunctionalTypeDirective(element, dirTok, context);
   case FormatToken::kw_operands:
     return parseOperandsDirective(element, dirTok.getLoc(), context);
+  case FormatToken::kw_qualified:
+    return parseQualifiedDirective(element, dirTok, context);
   case FormatToken::kw_regions:
     return parseRegionsDirective(element, dirTok.getLoc(), context);
   case FormatToken::kw_results:
     return parseResultsDirective(element, dirTok.getLoc(), context);
   case FormatToken::kw_successors:
     return parseSuccessorsDirective(element, dirTok.getLoc(), context);
   case FormatToken::kw_ref:
     return parseReferenceDirective(element, dirTok.getLoc(), context);
if (failed(parseToken(FormatToken::l_paren,
           parseToken(FormatToken::r_paren, "expected ')' after argument list")))
     return ::mlir::failure();
 
   element = std::make_unique<TypeDirective>(std::move(operand));
   return ::mlir::success();
 }
 
 LogicalResult
+FormatParser::parseQualifiedDirective(std::unique_ptr<Element> &element,
+                                      FormatToken tok, ParserContext context) {
+  if (failed(parseToken(FormatToken::l_paren,
+                        "expected '(' before argument list")) ||
+      failed(parseElement(element, context)) ||
+      failed(
+          parseToken(FormatToken::r_paren, "expected ')' after argument list")))
+    return ::mlir::failure();
+  if (auto *attr = dyn_cast<AttributeVariable>(element.get()))
+    attr->setQualified();
+  else if (auto *type = dyn_cast<TypeDirective>(element.get()))
+    type->setQualified();
+  else
+    return emitError(
+        tok.getLoc(),
+        "'qualified' directive expects an attribute or a `type` directive");
+
+  return ::mlir::success();
+}
+
+LogicalResult
 FormatParser::parseTypeDirectiveOperand(std::unique_ptr<Element> &element,
                                         bool isRefChild) {
   llvm::SMLoc loc = curToken.getLoc();
   if (failed(parseElement(element, TypeDirectiveContext)))
     return ::mlir::failure();
   if (isa<LiteralElement>(element.get()))
     return emitError(
         loc, "'type' directive operand expects variable or directive operand");