[mlir:Parser] Don't use strings for the "ugly" form of Attribute/Type syntax

[rriddle]

Summary

This commit refactors the syntax of "ugly" attribute/type formats to not use
strings for wrapping. This means that moving forward attirbutes and type formats
will always need to be in some recognizable form, i.e. if they use incompatible
characters they will need to manually wrap those in a string, the framework will
no longer do it automatically.

This has the benefit of greatly simplifying how parsing attributes/types work, given
that we currently rely on some extremely complicated nested parser logic which is
quite problematic for a myriad of reasons; unecessary complexity(we create a nested
source manager/lexer/etc.), diagnostic locations can be off/wrong given string escaping,
etc.

[rriddle]

This patch isn't entirely done, still need to update a few things (essentially just documentation). Just getting it out to show the direction.

[Mogball]

mlir/lib/Parser/DialectSymbolParser.cpp

209

I was under the impression from the description that nested parsers would be gone?

[rriddle]

mlir/lib/Parser/DialectSymbolParser.cpp

209

This is not a nested parser in the ways that matter, it is a controlled API layered on top of the base parser. The "nested parser" in the description is referring to the fact that we previously had to instantiate a completely new base parser(i.e. new source manager, new lexer, etc.).

[rriddle]

(updating triggered review, still not done)

[bondhugula]

flang/lib/Optimizer/Dialect/FIRType.cpp

754

Side comment: this declaration can now be moved inside.

mlir/lib/IR/AsmPrinter.cpp

1684

Single quotes.

[rriddle]

flang/lib/Optimizer/Dialect/FIRType.cpp

754

It can't, it's used lower down in the SequenceType::get call. Unless I completely misunderstood what you meant here, which is possible.

[Mogball]

Are ugly attributes and types now no longer allowed to have unbalanced < and > in their format?

[jpienaar]

Overall looks good thanks, could you add to commit some guide for downstream folks needing to update?

mlir/lib/IR/AsmPrinter.cpp

1652

Could this be expanded to say when it's simple enough?

flang/lib/Optimizer/Dialect/FIRType.cpp

mlir::Type fir::SequenceType::parse(mlir::AsmParser &parser) {
   SequenceType::Shape shape;
   if (parser.parseOptionalStar()) {
     if (parser.parseDimensionList(shape, /*allowDynamic=*/true))
       return {};
   } else if (parser.parseColon()) {
     return {};
   }
   mlir::Type eleTy;
-  if (parser.parseType(eleTy) || parser.parseGreater())
+  if (parser.parseType(eleTy))
     return {};
   mlir::AffineMapAttr map;
-  if (!parser.parseOptionalComma())
+  if (!parser.parseOptionalComma()) {
     if (parser.parseAttribute(map)) {
       parser.emitError(parser.getNameLoc(), "expecting affine map");
       return {};
     }
+  }
+  if (parser.parseGreater())
+    return {};
   return SequenceType::get(parser.getContext(), shape, eleTy, map);
 }
 
 void fir::SequenceType::print(mlir::AsmPrinter &printer) const {
   auto shape = getShape();
   if (shape.size()) {
     printer << '<';
     for (const auto &b : shape) {

mlir/docs/LangRef.md

 ### Dialect Types
 
 Similarly to operations, dialects may define custom extensions to the type
 system.
 
 ```
 dialect-namespace ::= bare-id
 
-opaque-dialect-item ::= dialect-namespace '<' string-literal '>'
-
-pretty-dialect-item ::= dialect-namespace '.' pretty-dialect-item-lead-ident
-                                              pretty-dialect-item-body?
-
-pretty-dialect-item-lead-ident ::= '[A-Za-z][A-Za-z0-9._]*'
-pretty-dialect-item-body ::= '<' pretty-dialect-item-contents+ '>'
-pretty-dialect-item-contents ::= pretty-dialect-item-body
-                              | '(' pretty-dialect-item-contents+ ')'
-                              | '[' pretty-dialect-item-contents+ ']'
-                              | '{' pretty-dialect-item-contents+ '}'
-                              | '[^\[<({\]>)}\0]+'
-
-dialect-type ::= '!' (opaque-dialect-item | pretty-dialect-item)
+dialect-type ::= '!' (opaque-dialect-type | pretty-dialect-type)
+opaque-dialect-type ::= dialect-namespace dialect-type-body
+pretty-dialect-type ::= dialect-namespace '.' pretty-dialect-type-lead-ident
+                                              dialect-type-body?
+pretty-dialect-type-lead-ident ::= '[A-Za-z][A-Za-z0-9._]*'
+
+dialect-type-body ::= '<' dialect-type-contents+ '>'
+dialect-type-contents ::= dialect-type-body
+                            | '(' dialect-type-contents+ ')'
+                            | '[' dialect-type-contents+ ']'
+                            | '{' dialect-type-contents+ '}'
 ```
 
-Dialect types can be specified in a verbose form, e.g. like this:
+Dialect types are generally specified in an opaque form, where the contents
+of the type are defined within a body wrapped with the dialect namespace
+and `<>`. Consider the following examples:
 
 ```mlir
-// LLVM type that wraps around llvm IR types.
-!llvm<"i32*">
-
-// Tensor flow string type.
-!tf.string
+// A tensorflow string type.
+!tf<string>
 
-// Complex type
-!foo<"something<abcd>">
+// A type with complex components.
+!foo<something<abcd>>
 
-// Even more complex type
-!foo<"something<a%%123^^^>>>">
+// An even more complex type.
+!foo<"a123^^^" + bar>
 ```
 
-Dialect types that are simple enough can use the pretty format, which is a
-lighter weight syntax that is equivalent to the above forms:
+Dialect types that are simple enough may use a prettier format, which unwraps
+part of the syntax into an equivalent, but lighter weight form:
 
 ```mlir
-// Tensor flow string type.
+// A tensorflow string type.
 !tf.string
 
-// Complex type
+// A type with complex components.
 !foo.something<abcd>
 ```
 
-Sufficiently complex dialect types are required to use the verbose form for
-generality. For example, the more complex type shown above wouldn't be valid in
-the lighter syntax: `!foo.something<a%%123^^^>>>` because it contains characters
-that are not allowed in the lighter syntax, as well as unbalanced `<>`
-characters.
-
 See [here](AttributesAndTypes.md) to learn how to define dialect types.
 
 ### Builtin Types
 
 The [builtin dialect](Dialects/Builtin.md) defines a set of types that are
 directly usable by any other dialect in MLIR. These types cover a range from
 primitive integer and floating-point types, function types, and more.
 

 %b = affine.apply affine_map<(d0) -> (d0 + 10)> (%a)
 
 // Using the attribute alias.
 %b = affine.apply #map(%a)
 ```
 
 ### Dialect Attribute Values
 
-Similarly to operations, dialects may define custom attribute values. The
-syntactic structure of these values is identical to custom dialect type values,
-except that dialect attribute values are distinguished with a leading '#', while
-dialect types are distinguished with a leading '!'.
+Similarly to operations, dialects may define custom attribute values.
 
 ```
-dialect-attribute-value ::= '#' opaque-dialect-item
-dialect-attribute-value ::= '#' pretty-dialect-item
+dialect-namespace ::= bare-id
+
+dialect-attribute ::= '#' (opaque-dialect-attribute | pretty-dialect-attribute)
+opaque-dialect-attribute ::= dialect-namespace dialect-attribute-body
+pretty-dialect-attribute ::= dialect-namespace '.' pretty-dialect-attribute-lead-ident
+                                              dialect-attribute-body?
+pretty-dialect-attribute-lead-ident ::= '[A-Za-z][A-Za-z0-9._]*'
+
+dialect-attribute-body ::= '<' dialect-attribute-contents+ '>'
+dialect-attribute-contents ::= dialect-attribute-body
+                            | '(' dialect-attribute-contents+ ')'
+                            | '[' dialect-attribute-contents+ ']'
+                            | '{' dialect-attribute-contents+ '}'
+                            | '[^\[<({\]>)}\0]+'
 ```
 
-Dialect attribute values can be specified in a verbose form, e.g. like this:
+Dialect attributes are generally specified in an opaque form, where the contents
+of the attribute are defined within a body wrapped with the dialect namespace
+and `<>`. Consider the following examples:
 
 ```mlir
-// Complex attribute value.
-#foo<"something<abcd>">
+// A string attribute.
+#foo<string<"">>
 
-// Even more complex attribute value.
-#foo<"something<a%%123^^^>>>">
+// A complex attribute.
+#foo<"a123^^^" + bar>
 ```
 
-Dialect attribute values that are simple enough can use the pretty format, which
-is a lighter weight syntax that is equivalent to the above forms:
+Dialect attributes that are simple enough may use a prettier format, which unwraps
+part of the syntax into an equivalent, but lighter weight form:
 
 ```mlir
-// Complex attribute
-#foo.something<abcd>
+// A string attribute.
+#foo.string<"">
 ```
 
-Sufficiently complex dialect attribute values are required to use the verbose
-form for generality. For example, the more complex type shown above would not be
-valid in the lighter syntax: `#foo.something<a%%123^^^>>>` because it contains
-characters that are not allowed in the lighter syntax, as well as unbalanced
-`<>` characters.
-
 See [here](AttributesAndTypes.md) on how to define dialect attribute values.
 
 ### Builtin Attribute Values
 
 The [builtin dialect](Dialects/Builtin.md) defines a set of attribute values
 that are directly usable by any other dialect in MLIR. These types cover a range
 from primitive integer and floating-point values, attribute dictionaries, dense
 multi-dimensional arrays, and more.

mlir/lib/IR/AsmPrinter.cpp

if (printerFlags.shouldPrintDebugInfoPrettyForm())
     return printLocationInternal(loc, /*pretty=*/true);
 
   os << "loc(";
   if (!allowAlias || !state || failed(state->getAliasState().getAlias(loc, os)))
     printLocationInternal(loc);
   os << ')';
 }
 
 /// Returns true if the given dialect symbol data is simple enough to print in
-/// the pretty form, i.e. without the enclosing "".
+/// the pretty form. This is essentially when the symbol takes the form:
+///   identifier (`<` body `>`)?
 static bool isDialectSymbolSimpleEnoughForPrettyForm(StringRef symName) {
   // The name must start with an identifier.
   if (symName.empty() || !isalpha(symName.front()))
     return false;
 
   // Ignore all the characters that are valid in an identifier in the symbol
   // name.
   symName = symName.drop_while(
       [](char c) { return llvm::isAlnum(c) || c == '.' || c == '_'; });
   if (symName.empty())
     return true;
 
-  // If we got to an unexpected character, then it must be a <>.  Check those
-  // recursively.
-  if (symName.front() != '<' || symName.back() != '>')
-    return false;
-
-  SmallVector<char, 8> nestedPunctuation;
-  do {
-    // If we ran out of characters, then we had a punctuation mismatch.
-    if (symName.empty())
-      return false;
-
-    auto c = symName.front();
-    symName = symName.drop_front();
-
-    switch (c) {
-    // We never allow null characters. This is an EOF indicator for the lexer
-    // which we could handle, but isn't important for any known dialect.
-    case '\0':
-      return false;
-    case '<':
-    case '[':
-    case '(':
-    case '{':
-      nestedPunctuation.push_back(c);
-      continue;
-    case '-':
-      // Treat `->` as a special token.
-      if (!symName.empty() && symName.front() == '>') {
-        symName = symName.drop_front();
-        continue;
-      }
-      break;
-    // Reject types with mismatched brackets.
-    case '>':
-      if (nestedPunctuation.pop_back_val() != '<')
-        return false;
-      break;
-    case ']':
-      if (nestedPunctuation.pop_back_val() != '[')
-        return false;
-      break;
-    case ')':
-      if (nestedPunctuation.pop_back_val() != '(')
-        return false;
-      break;
-    case '}':
-      if (nestedPunctuation.pop_back_val() != '{')
-        return false;
-      break;
-    default:
-      continue;
-    }
-
-    // We're done when the punctuation is fully matched.
-  } while (!nestedPunctuation.empty());
-
-  // If there were extra characters, then we failed.
-  return symName.empty();
+  // If we got to an unexpected character, then it must be a <>. Check that the
+  // rest of the symbol is wrapped within <>.
+  return symName.front() == '<' && symName.back() == '>';
 }
 
 /// Print the given dialect symbol to the stream.
 static void printDialectSymbol(raw_ostream &os, StringRef symPrefix,
                                StringRef dialectName, StringRef symString) {
   os << symPrefix << dialectName;
 
   // If this symbol name is simple enough, print it directly in pretty form,
   // otherwise, we print it as an escaped string.
   if (isDialectSymbolSimpleEnoughForPrettyForm(symString)) {
     os << '.' << symString;
     return;
   }
 
-  os << "<\"";
-  llvm::printEscapedString(symString, os);
-  os << "\">";
+  os << '<' << symString << '>';
 }
 
 /// Returns true if the given string can be represented as a bare identifier.
 static bool isBareIdentifier(StringRef name) {
   // By making this unsigned, the value passed in to isalnum will always be
   // in the range 0-255. This is important when building with MSVC because
   // its implementation will assert. This situation can arise when dealing
   // with UTF-8 multibyte characters.

mlir/lib/Parser/DialectSymbolParser.cpp

public:
   StringRef getFullSymbolSpec() const override { return fullSpec; }
 
 private:
   /// The full symbol specification.
   StringRef fullSpec;
 };
 } // namespace
 
-/// Parse the body of a pretty dialect symbol, which starts and ends with <>'s,
-/// and may be recursive.  Return with the 'prettyName' StringRef encompassing
-/// the entire pretty name.
+/// Parse the body of a dialect symbol, which starts and ends with <>'s, and may
+/// be recursive. Return with the 'body' StringRef encompassing the entire
+/// body.
 ///
 ///   pretty-dialect-sym-body ::= '<' pretty-dialect-sym-contents+ '>'
 ///   pretty-dialect-sym-contents ::= pretty-dialect-sym-body
 ///                                  | '(' pretty-dialect-sym-contents+ ')'
 ///                                  | '[' pretty-dialect-sym-contents+ ']'
 ///                                  | '{' pretty-dialect-sym-contents+ '}'
 ///                                  | '[^[<({>\])}\0]+'
 ///
-ParseResult Parser::parsePrettyDialectSymbolName(StringRef &prettyName) {
-  // Pretty symbol names are a relatively unstructured format that contains a
-  // series of properly nested punctuation, with anything else in the middle.
-  // Scan ahead to find it and consume it if successful, otherwise emit an
-  // error.
-  auto *curPtr = getTokenSpelling().data();
-
-  SmallVector<char, 8> nestedPunctuation;
+ParseResult Parser::parseDialectSymbolBody(StringRef &body) {
+  // Symbol bodies are a relatively unstructured format that contains a series
+  // of properly nested punctuation, with anything else in the middle. Scan
+  // ahead to find it and consume it if successful, otherwise emit an error.
+  const char *curPtr = getTokenSpelling().data();
 
   // Scan over the nested punctuation, bailing out on error and consuming until
-  // we find the end.  We know that we're currently looking at the '<', so we
-  // can go until we find the matching '>' character.
+  // we find the end. We know that we're currently looking at the '<', so we can
+  // go until we find the matching '>' character.
   assert(*curPtr == '<');
+  SmallVector<char, 8> nestedPunctuation;
   do {
     char c = *curPtr++;
     switch (c) {
     case '\0':
       // This also handles the EOF case.
+      if (!nestedPunctuation.empty()) {
+        return emitError() << "unbalanced '" << nestedPunctuation.back()
+                           << "' character in pretty dialect name";
+      }
       return emitError("unexpected nul or EOF in pretty dialect name");
     case '<':
     case '[':
     case '(':
     case '{':
       nestedPunctuation.push_back(c);
       continue;
 
do {
     case ')':
       if (nestedPunctuation.pop_back_val() != '(')
         return emitError("unbalanced ')' character in pretty dialect name");
       break;
     case '}':
       if (nestedPunctuation.pop_back_val() != '{')
         return emitError("unbalanced '}' character in pretty dialect name");
       break;
+    case '"': {
+      // Dispatch to the lexer to lex past strings.
+      resetToken(curPtr - 1);
+      if (state.curToken.isNot(Token::string))
+        return failure();
+      curPtr = state.curToken.getEndLoc().getPointer();
+      break;
+    }
 
     default:
       continue;
     }
   } while (!nestedPunctuation.empty());
 
   // Ok, we succeeded, remember where we stopped, reset the lexer to know it is
   // consuming all this stuff, and return.
-  state.lex.resetPointer(curPtr);
+  resetToken(curPtr);
 
-  unsigned length = curPtr - prettyName.begin();
-  prettyName = StringRef(prettyName.begin(), length);
-  consumeToken();
+  unsigned length = curPtr - body.begin();
+  body = StringRef(body.data(), length);
   return success();
 }
 
 /// Parse an extended dialect symbol.
 template <typename Symbol, typename SymbolAliasMap, typename CreateFn>
 static Symbol parseExtendedSymbol(Parser &p, Token::Kind identifierTok,
                                   SymbolAliasMap &aliases,
                                   CreateFn &&createSymbol) {
   // Parse the dialect namespace.
   StringRef identifier = p.getTokenSpelling().drop_front();
-  auto loc = p.getToken().getLoc();
+  SMLoc loc = p.getToken().getLoc();
   p.consumeToken(identifierTok);
 
+  // Check to see if this is a pretty name.
+  StringRef dialectName;
+  StringRef symbolData;
+  std::tie(dialectName, symbolData) = identifier.split('.');
+  bool isPrettyName = !symbolData.empty();
+
+  // Check to see if the symbol has trailing data, i.e. has an immediately
+  // following '<'.
+  bool hasTrailingData =
+      p.getToken().is(Token::less) &&
+      identifier.bytes_end() == p.getTokenSpelling().bytes_begin();
+
   // If there is no '<' token following this, and if the typename contains no
   // dot, then we are parsing a symbol alias.
-  if (p.getToken().isNot(Token::less) && !identifier.contains('.')) {
+  if (!hasTrailingData && !isPrettyName) {
     // Check for an alias for this type.
     auto aliasIt = aliases.find(identifier);
     if (aliasIt == aliases.end())
       return (p.emitWrongTokenError("undefined symbol alias id '" + identifier +
                                     "'"),
               nullptr);
     return aliasIt->second;
   }
 
-  // Otherwise, we are parsing a dialect-specific symbol.  If the name contains
-  // a dot, then this is the "pretty" form.  If not, it is the verbose form that
-  // looks like <"...">.
-  std::string symbolData;
-  auto dialectName = identifier;
-
-  // Handle the verbose form, where "identifier" is a simple dialect name.
-  if (!identifier.contains('.')) {
-    // Consume the '<'.
-    if (p.parseToken(Token::less, "expected '<' in dialect type"))
-      return nullptr;
-
-    // Parse the symbol specific data.
-    if (p.getToken().isNot(Token::string))
-      return (p.emitWrongTokenError(
-                  "expected string literal data in dialect symbol"),
-              nullptr);
-    symbolData = p.getToken().getStringValue();
-    loc = SMLoc::getFromPointer(p.getToken().getLoc().getPointer() + 1);
-    p.consumeToken(Token::string);
-
-    // Consume the '>'.
-    if (p.parseToken(Token::greater, "expected '>' in dialect symbol"))
+  // If this isn't an alias, we are parsing a dialect-specific symbol. If the
+  // name contains a dot, then this is the "pretty" form. If not, it is the
+  // verbose form that looks like <...>.
+  if (!isPrettyName) {
+    // Point the symbol data to the end of the dialect name to start.
+    symbolData = StringRef(dialectName.end(), 0);
+    if (p.parseDialectSymbolBody(symbolData))
       return nullptr;
+    symbolData = symbolData.drop_front().drop_back();
   } else {
-    // Ok, the dialect name is the part of the identifier before the dot, the
-    // part after the dot is the dialect's symbol, or the start thereof.
-    auto dotHalves = identifier.split('.');
-    dialectName = dotHalves.first;
-    auto prettyName = dotHalves.second;
-    loc = SMLoc::getFromPointer(prettyName.data());
+    loc = SMLoc::getFromPointer(symbolData.data());
 
     // If the dialect's symbol is followed immediately by a <, then lex the body
     // of it into prettyName.
-    if (p.getToken().is(Token::less) &&
-        prettyName.bytes_end() == p.getTokenSpelling().bytes_begin()) {
-      if (p.parsePrettyDialectSymbolName(prettyName))
-        return nullptr;
-    }
+    if (hasTrailingData && p.parseDialectSymbolBody(symbolData))
 
-    symbolData = prettyName.str();
-  }
-
-  // Record the name location of the type remapped to the top level buffer.
-  SMLoc locInTopLevelBuffer = p.remapLocationToTopLevelBuffer(loc);
-  p.getState().symbols.nestedParserLocs.push_back(locInTopLevelBuffer);
-
-  // Call into the provided symbol construction function.
-  Symbol sym = createSymbol(dialectName, symbolData, loc);
-
-  // Pop the last parser location.
-  p.getState().symbols.nestedParserLocs.pop_back();
-  return sym;
-}
-
-/// Parses a symbol, of type 'T', and returns it if parsing was successful. If
-/// parsing failed, nullptr is returned. The number of bytes read from the input
-/// string is returned in 'numRead'.
-template <typename T, typename ParserFn>
-static T parseSymbol(StringRef inputStr, MLIRContext *context,
-                     SymbolState &symbolState, ParserFn &&parserFn,
-                     size_t *numRead = nullptr) {
-  SourceMgr sourceMgr;
-  auto memBuffer = MemoryBuffer::getMemBuffer(
-      inputStr, /*BufferName=*/"<mlir_parser_buffer>",
-      /*RequiresNullTerminator=*/false);
-  sourceMgr.AddNewSourceBuffer(std::move(memBuffer), SMLoc());
-  ParserConfig config(context);
-  ParserState state(sourceMgr, config, symbolState, /*asmState=*/nullptr);
-  Parser parser(state);
-
-  Token startTok = parser.getToken();
-  T symbol = parserFn(parser);
-  if (!symbol)
-    return T();
-
-  // If 'numRead' is valid, then provide the number of bytes that were read.
-  Token endTok = parser.getToken();
-  if (numRead) {
-    *numRead = static_cast<size_t>(endTok.getLoc().getPointer() -
-                                   startTok.getLoc().getPointer());
-
-    // Otherwise, ensure that all of the tokens were parsed.
-  } else if (startTok.getLoc() != endTok.getLoc() && endTok.isNot(Token::eof)) {
-    parser.emitError(endTok.getLoc(), "encountered unexpected token");
-    return T();
-  }
-  return symbol;
+  return createSymbol(dialectName, symbolData, loc);
 }
 
 /// Parse an extended attribute.
 ///
 ///   extended-attribute ::= (dialect-attribute | attribute-alias)
 ///   dialect-attribute  ::= `#` dialect-namespace `<` `"` attr-data `"` `>`
 ///   dialect-attribute  ::= `#` alias-name pretty-dialect-sym-body?
 ///   attribute-alias    ::= `#` alias-name
 ///
 Attribute Parser::parseExtendedAttr(Type type) {
   MLIRContext *ctx = getContext();
   Attribute attr = parseExtendedSymbol<Attribute>(
       *this, Token::hash_identifier, state.symbols.attributeAliasDefinitions,
-      [&](StringRef dialectName, StringRef symbolData,
-          SMLoc loc) -> Attribute {
+      [&](StringRef dialectName, StringRef symbolData, SMLoc loc) -> Attribute {
         // Parse an optional trailing colon type.
         Type attrType = type;
         if (consumeIf(Token::colon) && !(attrType = parseType()))
           return Attribute();
 
         // If we found a registered dialect, then ask it to parse the attribute.
         if (Dialect *dialect =
                 builder.getContext()->getOrLoadDialect(dialectName)) {
-          return parseSymbol<Attribute>(
-              symbolData, ctx, state.symbols, [&](Parser &parser) {
-                CustomDialectAsmParser customParser(symbolData, parser);
-                return dialect->parseAttribute(customParser, attrType);
-              });
+          // Temporarily reset the lexer to let the dialect parse the attribute.
+          const char *curLexerPos = getToken().getLoc().getPointer();
+          resetToken(symbolData.data());
+
+          // Parse the attribute.
+          CustomDialectAsmParser customParser(symbolData, *this);
+          Attribute attr = dialect->parseAttribute(customParser, attrType);
+          resetToken(curLexerPos);
+          return attr;
         }
 
         // Otherwise, form a new opaque attribute.
         return OpaqueAttr::getChecked(
             [&] { return emitError(loc); }, StringAttr::get(ctx, dialectName),
             symbolData, attrType ? attrType : NoneType::get(ctx));
       });
 

 ///
 Type Parser::parseExtendedType() {
   MLIRContext *ctx = getContext();
   return parseExtendedSymbol<Type>(
       *this, Token::exclamation_identifier, state.symbols.typeAliasDefinitions,
       [&](StringRef dialectName, StringRef symbolData, SMLoc loc) -> Type {
         // If we found a registered dialect, then ask it to parse the type.
         if (auto *dialect = ctx->getOrLoadDialect(dialectName)) {
-          return parseSymbol<Type>(
-              symbolData, ctx, state.symbols, [&](Parser &parser) {
-                CustomDialectAsmParser customParser(symbolData, parser);
-                return dialect->parseType(customParser);
-              });
+          // Temporarily reset the lexer to let the dialect parse the type.
+          const char *curLexerPos = getToken().getLoc().getPointer();
+          resetToken(symbolData.data());
+
+          // Parse the type.
+          CustomDialectAsmParser customParser(symbolData, *this);
+          Type type = dialect->parseType(customParser);
+          resetToken(curLexerPos);
+          return type;
         }
 
         // Otherwise, form a new opaque type.
         return OpaqueType::getChecked([&] { return emitError(loc); },
                                       StringAttr::get(ctx, dialectName),
                                       symbolData);
       });
 }
 
 //===----------------------------------------------------------------------===//
 // mlir::parseAttribute/parseType
 //===----------------------------------------------------------------------===//
 
 /// Parses a symbol, of type 'T', and returns it if parsing was successful. If
 /// parsing failed, nullptr is returned. The number of bytes read from the input
 /// string is returned in 'numRead'.
 template <typename T, typename ParserFn>
 static T parseSymbol(StringRef inputStr, MLIRContext *context, size_t &numRead,
                      ParserFn &&parserFn) {
+  SourceMgr sourceMgr;
+  auto memBuffer = MemoryBuffer::getMemBuffer(
+      inputStr, /*BufferName=*/"<mlir_parser_buffer>",
+      /*RequiresNullTerminator=*/false);
+  sourceMgr.AddNewSourceBuffer(std::move(memBuffer), SMLoc());
   SymbolState aliasState;
-  return parseSymbol<T>(
-      inputStr, context, aliasState,
-      [&](Parser &parser) {
-        SourceMgrDiagnosticHandler handler(
-            const_cast<llvm::SourceMgr &>(parser.getSourceMgr()),
-            parser.getContext());
-        return parserFn(parser);
-      },
-      &numRead);
+  ParserConfig config(context);
+  ParserState state(sourceMgr, config, aliasState, /*asmState=*/nullptr);
+  Parser parser(state);
+
+  Token startTok = parser.getToken();
+  T symbol = parserFn(parser);
+  if (!symbol)
+    return T();
+
+  // Provide the number of bytes that were read.
+  Token endTok = parser.getToken();
+  numRead = static_cast<size_t>(endTok.getLoc().getPointer() -
+                                startTok.getLoc().getPointer());
+  return symbol;
 }
 
 Attribute mlir::parseAttribute(StringRef attrStr, MLIRContext *context) {
   size_t numRead = 0;
   return parseAttribute(attrStr, context, numRead);
 }
 Attribute mlir::parseAttribute(StringRef attrStr, Type type) {
   size_t numRead = 0;

mlir/lib/Parser/Parser.h

public:
 
   /// Parse a comma separated list of elements that must have at least one entry
   /// in it.
   ParseResult
   parseCommaSeparatedList(function_ref<ParseResult()> parseElementFn) {
     return parseCommaSeparatedList(Delimiter::None, parseElementFn);
   }
 
-  ParseResult parsePrettyDialectSymbolName(StringRef &prettyName);
+  ParseResult parseDialectSymbolBody(StringRef &body);
 
   // We have two forms of parsing methods - those that return a non-null
   // pointer on success, and those that return a ParseResult to indicate whether
   // they returned a failure.  The second class fills in by-reference arguments
   // as the results of their action.
 
   //===--------------------------------------------------------------------===//
   // Error Handling
   //===--------------------------------------------------------------------===//
 
   /// Emit an error and return failure.
   InFlightDiagnostic emitError(const Twine &message = {});
   InFlightDiagnostic emitError(SMLoc loc, const Twine &message = {});
 
   /// Emit an error about a "wrong token".  If the current token is at the
   /// start of a source line, this will apply heuristics to back up and report
   /// the error at the end of the previous line, which is where the expected
   /// token is supposed to be.
   InFlightDiagnostic emitWrongTokenError(const Twine &message = {});
 
   /// Encode the specified source location information into an attribute for
   /// attachment to the IR.
   Location getEncodedSourceLocation(SMLoc loc) {
-    // If there are no active nested parsers, we can get the encoded source
-    // location directly.
-    if (state.parserDepth == 0)
-      return state.lex.getEncodedSourceLocation(loc);
-    // Otherwise, we need to re-encode it to point to the top level buffer.
-    return state.symbols.topLevelLexer->getEncodedSourceLocation(
-        remapLocationToTopLevelBuffer(loc));
-  }
-
-  /// Remaps the given SMLoc to the top level lexer of the parser. This is used
-  /// to adjust locations of potentially nested parsers to ensure that they can
-  /// be emitted properly as diagnostics.
-  SMLoc remapLocationToTopLevelBuffer(SMLoc loc) {
-    // If there are no active nested parsers, we can return location directly.
-    SymbolState &symbols = state.symbols;
-    if (state.parserDepth == 0)
-      return loc;
-    assert(symbols.topLevelLexer && "expected valid top-level lexer");
-
-    // Otherwise, we need to remap the location to the main parser. This is
-    // simply offseting the location onto the location of the last nested
-    // parser.
-    size_t offset = loc.getPointer() - state.lex.getBufferBegin();
-    auto *rawLoc =
-        symbols.nestedParserLocs[state.parserDepth - 1].getPointer() + offset;
-    return SMLoc::getFromPointer(rawLoc);
   }
 
   //===--------------------------------------------------------------------===//
   // Token Parsing
   //===--------------------------------------------------------------------===//
 
   /// Return the current token the parser is inspecting.
   const Token &getToken() const { return state.curToken; }
public:
   /// Advance the current lexer onto the next token, asserting what the expected
   /// current token is.  This is preferred to the above method because it leads
   /// to more self-documenting code with better checking.
   void consumeToken(Token::Kind kind) {
     assert(state.curToken.is(kind) && "consumed an unexpected token");
     consumeToken();
   }
 
+  /// Reset the parser to the given lexer position.
+  void resetToken(const char *tokPos) {
+    state.lex.resetPointer(tokPos);
+    state.curToken = state.lex.lexToken();
+  }
+
   /// Consume the specified token if present and return success.  On failure,
   /// output a diagnostic and return failure.
   ParseResult parseToken(Token::Kind expectedToken, const Twine &message);
 
   /// Parse an optional integer value from the stream.
   OptionalParseResult parseOptionalInteger(APInt &result);
 
   /// Parse a floating point value from an integer literal token.

mlir/lib/Parser/ParserState.h

struct SymbolState {
   /// A map from type alias identifier to Type.
   llvm::StringMap<Type> typeAliasDefinitions;
 
   /// A map of dialect resource keys to the resolved resource name and handle
   /// to use during parsing.
   DenseMap<const OpAsmDialectInterface *,
            llvm::StringMap<std::pair<std::string, AsmDialectResourceHandle>>>
       dialectResources;
-
-  /// A set of locations into the main parser memory buffer for each of the
-  /// active nested parsers. Given that some nested parsers, i.e. custom dialect
-  /// parsers, operate on a temporary memory buffer, this provides an anchor
-  /// point for emitting diagnostics.
-  SmallVector<SMLoc, 1> nestedParserLocs;
-
-  /// The top-level lexer that contains the original memory buffer provided by
-  /// the user. This is used by nested parsers to get a properly encoded source
-  /// location.
-  Lexer *topLevelLexer = nullptr;
 };
 
 //===----------------------------------------------------------------------===//
 // ParserState
 //===----------------------------------------------------------------------===//
 
 /// This class refers to all of the state maintained globally by the parser,
 /// such as the current lexer position etc.
 struct ParserState {
   ParserState(const llvm::SourceMgr &sourceMgr, const ParserConfig &config,
               SymbolState &symbols, AsmParserState *asmState)
       : config(config), lex(sourceMgr, config.getContext()),
-        curToken(lex.lexToken()), symbols(symbols),
-        parserDepth(symbols.nestedParserLocs.size()), asmState(asmState) {
-    // Set the top level lexer for the symbol state if one doesn't exist.
-    if (!symbols.topLevelLexer)
-      symbols.topLevelLexer = &lex;
-  }
-  ~ParserState() {
-    // Reset the top level lexer if it refers the lexer in our state.
-    if (symbols.topLevelLexer == &lex)
-      symbols.topLevelLexer = nullptr;
-  }
+        curToken(lex.lexToken()), symbols(symbols), asmState(asmState) {}
   ParserState(const ParserState &) = delete;
   void operator=(const ParserState &) = delete;
 
   /// The configuration used to setup the parser.
   const ParserConfig &config;
 
   /// The lexer for the source file we're parsing.
   Lexer lex;
 
   /// This is the next token that hasn't been consumed yet.
   Token curToken;
 
   /// The current state for symbol parsing.
   SymbolState &symbols;
 
-  /// The depth of this parser in the nested parsing stack.
-  size_t parserDepth;
-
   /// An optional pointer to a struct containing high level parser state to be
   /// populated during parsing.
   AsmParserState *asmState;
 
   // Contains the stack of default dialect to use when parsing regions.
   // A new dialect get pushed to the stack before parsing regions nested
   // under an operation implementing `OpAsmOpInterface`, and
   // popped when done. At the top-level we start with "builtin" as the
   // default, so that the top-level `module` operation parses as-is.
   SmallVector<StringRef> defaultDialectStack{"builtin"};
 };
 
 } // namespace detail
 } // namespace mlir
 
 #endif // MLIR_LIB_PARSER_PARSERSTATE_H

mlir/test/Dialect/EmitC/types.mlir

 // RUN: mlir-opt -verify-diagnostics %s | FileCheck %s
 // check parser
 // RUN: mlir-opt -verify-diagnostics %s | mlir-opt -verify-diagnostics | FileCheck %s
 
 // CHECK-LABEL: func @opaque_types() {
 func.func @opaque_types() {
   // CHECK-NEXT: !emitc.opaque<"int">
-  emitc.call "f"() {template_args = [!emitc<"opaque<\"int\">">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc<opaque<"int">>]} : () -> ()
   // CHECK-NEXT: !emitc.opaque<"byte">
-  emitc.call "f"() {template_args = [!emitc<"opaque<\"byte\">">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc<opaque<"byte">>]} : () -> ()
   // CHECK-NEXT: !emitc.opaque<"unsigned">
-  emitc.call "f"() {template_args = [!emitc<"opaque<\"unsigned\">">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc<opaque<"unsigned">>]} : () -> ()
   // CHECK-NEXT: !emitc.opaque<"status_t">
-  emitc.call "f"() {template_args = [!emitc<"opaque<\"status_t\">">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc<opaque<"status_t">>]} : () -> ()
   // CHECK-NEXT: !emitc.opaque<"std::vector<std::string>">
   emitc.call "f"() {template_args = [!emitc.opaque<"std::vector<std::string>">]} : () -> ()
   // CHECK-NEXT: !emitc.opaque<"SmallVector<int*, 4>">
   emitc.call "f"() {template_args = [!emitc.opaque<"SmallVector<int*, 4>">]} : () -> ()
 
   return
 }
 
 // CHECK-LABEL: func @pointer_types() {
 func.func @pointer_types() {
   // CHECK-NEXT: !emitc.ptr<i32>
-  emitc.call "f"() {template_args = [!emitc<"ptr<i32>">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc.ptr<i32>]} : () -> ()
   // CHECK-NEXT: !emitc.ptr<i64>
   emitc.call "f"() {template_args = [!emitc.ptr<i64>]} : () -> ()
   // CHECK-NEXT: !emitc.ptr<f32>
-  emitc.call "f"() {template_args = [!emitc<"ptr<f32>">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc.ptr<f32>]} : () -> ()
   // CHECK-NEXT: !emitc.ptr<f64>
   emitc.call "f"() {template_args = [!emitc.ptr<f64>]} : () -> ()
   // CHECK-NEXT: !emitc.ptr<i32>
   %0 = emitc.call "f"() : () -> (!emitc.ptr<i32>)
   // CHECK-NEXT: (!emitc.ptr<i32>) -> !emitc.ptr<!emitc.ptr<i32>>
   %1 = emitc.call "f"(%0) : (!emitc.ptr<i32>) -> (!emitc.ptr<!emitc.ptr<i32>>)
   // CHECK-NEXT: !emitc.ptr<!emitc.opaque<"int">>
   emitc.call "f"() {template_args = [!emitc.ptr<!emitc.opaque<"int">>]} : () -> ()
 
   return
 }

mlir/test/Dialect/GPU/invalid.mlir

 
 // -----
 
 func.func @reduce_op_and_body(%arg0 : f32) {
   // expected-error@+1 {{expected either an op attribute or a non-empty body}}
   %res = "gpu.all_reduce"(%arg0) ({
   ^bb(%lhs : f32, %rhs : f32):
     "gpu.yield"(%lhs) : (f32) -> ()
-  }) {op = #gpu<"all_reduce_op add">} : (f32) -> (f32)
+  }) {op = #gpu<all_reduce_op add>} : (f32) -> (f32)
   return
 }
 
 // -----
 
 func.func @reduce_invalid_op(%arg0 : f32) {
   // expected-error@+1 {{invalid op kind}}
   %res = gpu.all_reduce foo %arg0 {} : (f32) -> (f32)
func.func @reduce_incorrect_yield(%arg0 : f32) {
   } : (f32) -> (f32)
   return
 }
 
 // -----
 
 func.func @shuffle_mismatching_type(%arg0 : f32, %arg1 : i32, %arg2 : i32) {
   // expected-error@+1 {{op failed to verify that all of {value, result} have same type}}
-  %shfl, %pred = "gpu.shuffle"(%arg0, %arg1, %arg2) { mode = #gpu<"shuffle_mode xor"> } : (f32, i32, i32) -> (i32, i1)
+  %shfl, %pred = "gpu.shuffle"(%arg0, %arg1, %arg2) { mode = #gpu<shuffle_mode xor> } : (f32, i32, i32) -> (i32, i1)
   return
 }
 
 // -----
 
 func.func @shuffle_unsupported_type(%arg0 : index, %arg1 : i32, %arg2 : i32) {
   // expected-error@+1 {{operand #0 must be i32 or f32}}
   %shfl, %pred = gpu.shuffle xor %arg0, %arg1, %arg2 : index

mlir/test/Dialect/OpenACC/ops.mlir

func.func @testparallelop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) -> () {
   }
   acc.parallel no_create(%a: memref<10xf32>) present(%b: memref<10xf32>, %c: memref<10x10xf32>) {
   }
   acc.parallel deviceptr(%a: memref<10xf32>) attach(%b: memref<10xf32>, %c: memref<10x10xf32>) {
   }
   acc.parallel private(%a: memref<10xf32>, %c: memref<10x10xf32>) firstprivate(%b: memref<10xf32>) {
   }
   acc.parallel {
-  } attributes {defaultAttr = #acc<"defaultvalue none">}
+  } attributes {defaultAttr = #acc<defaultvalue none>}
   acc.parallel {
-  } attributes {defaultAttr = #acc<"defaultvalue present">}
+  } attributes {defaultAttr = #acc<defaultvalue present>}
   acc.parallel {
   } attributes {asyncAttr}
   acc.parallel {
   } attributes {waitAttr}
   acc.parallel {
   } attributes {selfAttr}
   return
 }

 // CHECK-NEXT: }
 // CHECK:      acc.parallel no_create([[ARGA]]: memref<10xf32>) present([[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.parallel deviceptr([[ARGA]]: memref<10xf32>) attach([[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.parallel private([[ARGA]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) firstprivate([[ARGB]]: memref<10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.parallel {
-// CHECK-NEXT: } attributes {defaultAttr = #acc<"defaultvalue none">}
+// CHECK-NEXT: } attributes {defaultAttr = #acc<defaultvalue none>}
 // CHECK:      acc.parallel {
-// CHECK-NEXT: } attributes {defaultAttr = #acc<"defaultvalue present">}
+// CHECK-NEXT: } attributes {defaultAttr = #acc<defaultvalue present>}
 // CHECK:      acc.parallel {
 // CHECK-NEXT: } attributes {asyncAttr}
 // CHECK:      acc.parallel {
 // CHECK-NEXT: } attributes {waitAttr}
 // CHECK:      acc.parallel {
 // CHECK-NEXT: } attributes {selfAttr}
 
 // -----
func.func @testdataop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) -> () {
   }
   acc.data deviceptr(%a, %b, %c : memref<10xf32>, memref<10xf32>, memref<10x10xf32>) {
   }
   acc.data attach(%a, %b, %c : memref<10xf32>, memref<10xf32>, memref<10x10xf32>) {
   }
   acc.data copyin(%b: memref<10xf32>) copyout(%c: memref<10x10xf32>) present(%a: memref<10xf32>) {
   }
   acc.data present(%a : memref<10xf32>) {
-  } attributes { defaultAttr = #acc<"defaultvalue none"> }
+  } attributes { defaultAttr = #acc<defaultvalue none> }
   acc.data present(%a : memref<10xf32>) {
-  } attributes { defaultAttr = #acc<"defaultvalue present"> }
+  } attributes { defaultAttr = #acc<defaultvalue present> }
   acc.data {
-  } attributes { defaultAttr = #acc<"defaultvalue none"> }
+  } attributes { defaultAttr = #acc<defaultvalue none> }
   return
 }
 
 // CHECK:      func @testdataop([[ARGA:%.*]]: memref<10xf32>, [[ARGB:%.*]]: memref<10xf32>, [[ARGC:%.*]]: memref<10x10xf32>) {
 // CHECK:      [[IFCOND1:%.*]] = arith.constant true
 // CHECK:      acc.data if([[IFCOND1]]) present([[ARGA]] : memref<10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data present([[ARGA]], [[ARGB]], [[ARGC]] : memref<10xf32>, memref<10xf32>, memref<10x10xf32>) {

 // CHECK-NEXT: }
 // CHECK:      acc.data deviceptr([[ARGA]], [[ARGB]], [[ARGC]] : memref<10xf32>, memref<10xf32>, memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data attach([[ARGA]], [[ARGB]], [[ARGC]] : memref<10xf32>, memref<10xf32>, memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data copyin([[ARGB]] : memref<10xf32>) copyout([[ARGC]] : memref<10x10xf32>) present([[ARGA]] : memref<10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data present([[ARGA]] : memref<10xf32>) {
-// CHECK-NEXT: } attributes {defaultAttr = #acc<"defaultvalue none">}
+// CHECK-NEXT: } attributes {defaultAttr = #acc<defaultvalue none>}
 // CHECK:      acc.data present([[ARGA]] : memref<10xf32>) {
-// CHECK-NEXT: } attributes {defaultAttr = #acc<"defaultvalue present">}
+// CHECK-NEXT: } attributes {defaultAttr = #acc<defaultvalue present>}
 // CHECK:      acc.data {
-// CHECK-NEXT: } attributes {defaultAttr = #acc<"defaultvalue none">}
+// CHECK-NEXT: } attributes {defaultAttr = #acc<defaultvalue none>}
 
 // -----
 
 func.func @testupdateop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) -> () {
   %i64Value = arith.constant 1 : i64
   %i32Value = arith.constant 1 : i32
   %idxValue = arith.constant 1 : index
   %ifCond = arith.constant true

mlir/test/Dialect/OpenMP/ops.mlir

func.func @omp_parallel(%data_var : memref<i32>, %if_cond : i1, %num_threads : i32) -> () {
 
   // test without allocate
   // CHECK: omp.parallel if(%{{.*}}) num_threads(%{{.*}} : i32)
     "omp.parallel"(%if_cond, %num_threads) ({
       omp.terminator
     }) {operand_segment_sizes = dense<[1,1,0,0,0]> : vector<5xi32>} : (i1, i32) -> ()
 
     omp.terminator
-  }) {operand_segment_sizes = dense<[1,1,1,1,0]> : vector<5xi32>, proc_bind_val = #omp<"procbindkind spread">} : (i1, i32, memref<i32>, memref<i32>) -> ()
+  }) {operand_segment_sizes = dense<[1,1,1,1,0]> : vector<5xi32>, proc_bind_val = #omp<procbindkind spread>} : (i1, i32, memref<i32>, memref<i32>) -> ()
 
   // test with multiple parameters for single variadic argument
   // CHECK: omp.parallel allocate(%{{.*}} : memref<i32> -> %{{.*}} : memref<i32>)
   "omp.parallel" (%data_var, %data_var) ({
     omp.terminator
   }) {operand_segment_sizes = dense<[0,0,1,1,0]> : vector<5xi32>} : (memref<i32>, memref<i32>) -> ()
 
   return
func.func @omp_wsloop(%lb : index, %ub : index, %step : index, %data_var : memref<i32>, %linear_var : i32, %chunk_var : i32) -> () {
   }) {operand_segment_sizes = dense<[1,1,1,0,0,0,0]> : vector<7xi32>, ordered_val = 1} :
     (index, index, index) -> ()
 
   // CHECK: omp.wsloop linear(%{{.*}} = %{{.*}} : memref<i32>) schedule(static)
   // CHECK-SAMe: for (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
   "omp.wsloop" (%lb, %ub, %step, %data_var, %linear_var) ({
     ^bb0(%iv: index):
       omp.yield
-  }) {operand_segment_sizes = dense<[1,1,1,1,1,0,0]> : vector<7xi32>, schedule_val = #omp<"schedulekind static">} :
+  }) {operand_segment_sizes = dense<[1,1,1,1,1,0,0]> : vector<7xi32>, schedule_val = #omp<schedulekind static>} :
     (index, index, index, memref<i32>, i32) -> ()
 
   // CHECK: omp.wsloop linear(%{{.*}} = %{{.*}} : memref<i32>, %{{.*}} = %{{.*}} : memref<i32>) schedule(static)
   // CHECK-SAME: for (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
   "omp.wsloop" (%lb, %ub, %step, %data_var, %data_var, %linear_var, %linear_var) ({
     ^bb0(%iv: index):
       omp.yield
-  }) {operand_segment_sizes = dense<[1,1,1,2,2,0,0]> : vector<7xi32>, schedule_val = #omp<"schedulekind static">} :
+  }) {operand_segment_sizes = dense<[1,1,1,2,2,0,0]> : vector<7xi32>, schedule_val = #omp<schedulekind static>} :
     (index, index, index, memref<i32>, memref<i32>, i32, i32) -> ()
 
   // CHECK: omp.wsloop linear(%{{.*}} = %{{.*}} : memref<i32>) schedule(dynamic = %{{.*}}) ordered(2)
   // CHECK-SAME: for (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
   "omp.wsloop" (%lb, %ub, %step, %data_var, %linear_var, %chunk_var) ({
     ^bb0(%iv: index):
       omp.yield
-  }) {operand_segment_sizes = dense<[1,1,1,1,1,0,1]> : vector<7xi32>, schedule_val = #omp<"schedulekind dynamic">, ordered_val = 2} :
+  }) {operand_segment_sizes = dense<[1,1,1,1,1,0,1]> : vector<7xi32>, schedule_val = #omp<schedulekind dynamic>, ordered_val = 2} :
     (index, index, index, memref<i32>, i32, i32) -> ()
 
   // CHECK: omp.wsloop schedule(auto) nowait
   // CHECK-SAME: for (%{{.*}}) : index = (%{{.*}}) to (%{{.*}}) step (%{{.*}})
   "omp.wsloop" (%lb, %ub, %step) ({
     ^bb0(%iv: index):
       omp.yield
-  }) {operand_segment_sizes = dense<[1,1,1,0,0,0,0]> : vector<7xi32>, nowait, schedule_val = #omp<"schedulekind auto">} :
+  }) {operand_segment_sizes = dense<[1,1,1,0,0,0,0]> : vector<7xi32>, nowait, schedule_val = #omp<schedulekind auto>} :
     (index, index, index) -> ()
 
   return
 }
 
 // CHECK-LABEL: omp_wsloop_pretty
 func.func @omp_wsloop_pretty(%lb : index, %ub : index, %step : index, %data_var : memref<i32>, %linear_var : i32, %chunk_var : i32, %chunk_var2 : i16) -> () {
 

mlir/test/Dialect/Quant/parse-any-invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // -----
 // Unrecognized token: missing storage type maximum
 // expected-error@+1 {{expected ':'}}
 !qalias = !quant.any<i8<16>:f32>
 
 // -----
 // Unrecognized token: missing closing angle bracket
-// expected-error@+1 {{expected '>'}}
-!qalias = !quant<"any<i8<-4:3:f32>">
+// expected-error@+1 {{unbalanced '<' character in pretty dialect name}}
+!qalias = !quant<any<i8<-4:3:f32>>
 
 // -----
 // Unrecognized token: missing type colon
 // expected-error@+1 {{expected '>'}}
 !qalias = !quant.any<i8<-4:3>f32>
 
 // -----
 // Unrecognized storage type: illegal prefix

mlir/test/Dialect/Quant/parse-calibrated-invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // -----
 // Unrecognized token: missing calibrated type maximum
 // expected-error@+2 {{calibrated values must be present}}
 // expected-error@+1 {{expected ':'}}
 !qalias = !quant.calibrated<f32<-0.998>>
 
 // -----
 // Unrecognized token: missing closing angle bracket
-// expected-error@+1 {{expected '>'}}
-!qalias = !quant<"calibrated<f32<-0.998:1.232>">
+// expected-error@+1 {{unbalanced '<' character in pretty dialect name}}
+!qalias = !quant.calibrated<f32<-0.998:1.232>
 
 // -----
 // Unrecognized expressed type: integer type
 // expected-error@+2 {{invalid kind of type specified}}
 // expected-error@+1 {{expecting float expressed type}}
 !qalias = !quant.calibrated<i8<-4:3>>
 
 // -----
 // Illegal storage min/max: max - min < 0
 // expected-error@+1 {{illegal min and max: (1.000000e+00:-1.000000e+00)}}
 !qalias = !quant.calibrated<f32<1.0:-1.0>>
 
 // -----
 // Illegal storage min/max: max - min == 0
 // expected-error@+1 {{illegal min and max: (1.000000e+00:1.000000e+00)}}
 !qalias = !quant.calibrated<f32<1.0:1.0>>

mlir/test/Dialect/Quant/parse-uniform-invalid.mlir

 
 // -----
 // Unrecognized token: missing storage type maximum
 // expected-error@+1 {{expected ':'}}
 !qalias = !quant.uniform<i8<16>:f32, 0.99872:127>
 
 // -----
 // Unrecognized token: missing closing angle bracket
-// expected-error@+1 {{expected '>'}}
-!qalias = !quant<"uniform<i8<-4:3:f32, 0.99872:127>">
+// expected-error@+1 {{unbalanced '<' character in pretty dialect name}}
+!qalias = !quant<uniform<i8<-4:3:f32, 0.99872:127>>
 
 // -----
 // Unrecognized token: missing type colon
 // expected-error@+1 {{expected ':'}}
 !qalias = !quant.uniform<i8<-4:3>f32, 0.99872:127>
 
 // -----
 // Unrecognized token: missing comma

mlir/test/IR/enum-attr-invalid.mlir

 // RUN: mlir-opt -verify-diagnostics -split-input-file %s
 
 func.func @test_invalid_enum_case() -> () {
   // expected-error@+2 {{expected test::TestEnum to be one of: first, second, third}}
   // expected-error@+1 {{failed to parse TestEnumAttr}}
-  test.op_with_enum #test<"enum fourth">
+  test.op_with_enum #test<enum fourth>
 }
 
 // -----
 
 func.func @test_invalid_enum_case() -> () {
   // expected-error@+1 {{expected test::TestEnum to be one of: first, second, third}}
   test.op_with_enum fourth
   // expected-error@+1 {{failed to parse TestEnumAttr}}

mlir/test/IR/enum-attr-roundtrip.mlir

 // RUN: mlir-opt %s | mlir-opt -test-patterns | FileCheck %s
 
 // CHECK-LABEL: @test_enum_attr_roundtrip
 func.func @test_enum_attr_roundtrip() -> () {
-  // CHECK: value = #test<"enum first">
-  "test.op"() {value = #test<"enum first">} : () -> ()
-  // CHECK: value = #test<"enum second">
-  "test.op"() {value = #test<"enum second">} : () -> ()
-  // CHECK: value = #test<"enum third">
-  "test.op"() {value = #test<"enum third">} : () -> ()
+  // CHECK: value = #test<enum first>
+  "test.op"() {value = #test<enum first>} : () -> ()
+  // CHECK: value = #test<enum second>
+  "test.op"() {value = #test<enum second>} : () -> ()
+  // CHECK: value = #test<enum third>
+  "test.op"() {value = #test<enum third>} : () -> ()
   return
 }
 
 // CHECK-LABEL: @test_op_with_enum
 func.func @test_op_with_enum() -> () {
   // CHECK: test.op_with_enum third
   test.op_with_enum third
   return

mlir/test/IR/invalid.mlir

 // -----
 
 func.func @dialect_type_empty_namespace(!<"">) -> () { // expected-error {{invalid type identifier}}
   return
 }
 
 // -----
 
-func.func @dialect_type_no_string_type_data(!foo<>) -> () { // expected-error {{expected string literal data in dialect symbol}}
+func.func @dialect_type_missing_greater(!foo<) -> () { // expected-error {{unbalanced ')' character in pretty dialect name}}
   return
-}
-
-// -----
-
-func.func @dialect_type_missing_greater(!foo<"") -> () { // expected-error {{expected '>' in dialect symbol}}
-  return
-}
 
 // -----
 
 func.func @type_alias_unknown(!unknown_alias) -> () { // expected-error {{undefined symbol alias id 'unknown_alias'}}
   return
 }
 
 // -----

mlir/test/IR/parser.mlir

// CHECK: "foof32"() {bar = sparse<> : tensor<1x0x1xf32>} : () -> ()
   "foof32"(){bar = sparse<> : tensor<1x0x1xf32>} : () -> ()
 // CHECK:  "foof64"() {bar = sparse<0, -1.000000e+00> : tensor<1xf64>} : () -> ()
   "foof64"(){bar = sparse<[[0]], [-1.0]> : tensor<1xf64>} : () -> ()
 // CHECK: "foof320"() {bar = sparse<> : tensor<0xf32>} : () -> ()
   "foof320"(){bar = sparse<> : tensor<0xf32>} : () -> ()
 // CHECK: "foof321"() {bar = sparse<> : tensor<f32>} : () -> ()
   "foof321"(){bar = sparse<> : tensor<f32>} : () -> ()
 
-// CHECK: "foostr"() {bar = sparse<0, "foo"> : tensor<1x1x1x!unknown<"">>} : () -> ()
-  "foostr"(){bar = sparse<0, "foo"> : tensor<1x1x1x!unknown<"">>} : () -> ()
-// CHECK: "foostr"() {bar = sparse<{{\[\[}}1, 1, 0], {{\[}}0, 1, 0], {{\[}}0, 0, 1]], {{\[}}"a", "b", "c"]> : tensor<2x2x2x!unknown<"">>} : () -> ()
-  "foostr"(){bar = sparse<[[1, 1, 0], [0, 1, 0], [0, 0, 1]], ["a", "b", "c"]> : tensor<2x2x2x!unknown<"">>} : () -> ()
+// CHECK: "foostr"() {bar = sparse<0, "foo"> : tensor<1x1x1x!unknown<>>} : () -> ()
+  "foostr"(){bar = sparse<0, "foo"> : tensor<1x1x1x!unknown<>>} : () -> ()
+// CHECK: "foostr"() {bar = sparse<{{\[\[}}1, 1, 0], {{\[}}0, 1, 0], {{\[}}0, 0, 1]], {{\[}}"a", "b", "c"]> : tensor<2x2x2x!unknown<>>} : () -> ()
+  "foostr"(){bar = sparse<[[1, 1, 0], [0, 1, 0], [0, 0, 1]], ["a", "b", "c"]> : tensor<2x2x2x!unknown<>>} : () -> ()
   return
 }
 
 // CHECK-LABEL: func @sparsevectorattr
 func.func @sparsevectorattr() -> () {
 ^bb0:
 // NOTE: The {{\[\[}} syntax is because "[[" confuses FileCheck.
 // CHECK: "fooi8"() {bar = sparse<0, -2> : vector<1x1x1xi8>} : () -> ()
// CHECK: "foof16"() {bar = sparse<0, -2.000000e+00> : vector<1x1x1xf16>} : () -> ()
   "foof16"(){bar = sparse<0, -2.0> : vector<1x1x1xf16>} : () -> ()
 // CHECK: "foobf16"() {bar = sparse<{{\[\[}}1, 1, 0], {{\[}}0, 1, 0], {{\[}}0, 0, 1]], {{\[}}2.000000e+00, -1.000000e+00, 5.000000e+00]> : vector<2x2x2xbf16>} : () -> ()
   "foobf16"(){bar = sparse<[[1, 1, 0], [0, 1, 0], [0, 0, 1]], [2.0, -1.0, 5.0]> : vector<2x2x2xbf16>} : () -> ()
 // CHECK:  "foof64"() {bar = sparse<0, -1.000000e+00> : vector<1xf64>} : () -> ()
   "foof64"(){bar = sparse<0, [-1.0]> : vector<1xf64>} : () -> ()
   return
 }
 
-// CHECK-LABEL: func @unknown_dialect_type() -> !bar<""> {
-func.func @unknown_dialect_type() -> !bar<""> {
+// CHECK-LABEL: func @unknown_dialect_type() -> !bar<> {
+func.func @unknown_dialect_type() -> !bar<> {
   // Unregistered dialect 'bar'.
-  // CHECK: "foo"() : () -> !bar<"">
-  %0 = "foo"() : () -> !bar<"">
+  // CHECK: "foo"() : () -> !bar<>
+  %0 = "foo"() : () -> !bar<>
 
   // CHECK: "foo"() : () -> !bar.baz
-  %1 = "foo"() : () -> !bar<"baz">
+  %1 = "foo"() : () -> !bar<baz>
 
-  return %0 : !bar<"">
+  return %0 : !bar<>
 }
 
 // CHECK-LABEL: func @type_alias() -> i32 {
 !i32_type_alias = i32
 func.func @type_alias() -> !i32_type_alias {
 
   // Return a non-aliased i32 type.
   %0 = "foo"() : () -> i32
func.func @pretty_dialect_attribute() {
   "foo.unknown_op"() {foo = #foo.complexattr<abcd<f32>>} : () -> ()
 
   // CHECK: "foo.unknown_op"() {foo = #foo.complexattr<abcd<[f]$$[32]>>} : () -> ()
   "foo.unknown_op"() {foo = #foo.complexattr<abcd<[f]$$[32]>>} : () -> ()
 
   // CHECK: "foo.unknown_op"() {foo = #foo.dialect<!x@#!@#>} : () -> ()
   "foo.unknown_op"() {foo = #foo.dialect<!x@#!@#>} : () -> ()
 
-  // Extraneous extra > character can't use the pretty syntax.
-  // CHECK: "foo.unknown_op"() {foo = #foo<"dialect<!x@#!@#>>">} : () -> ()
-  "foo.unknown_op"() {foo = #foo<"dialect<!x@#!@#>>">} : () -> ()
-
   return
 }
 
 // CHECK-LABEL: func @pretty_dialect_type()
 func.func @pretty_dialect_type() {
 
   // CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo.simpletype
   %0 = "foo.unknown_op"() : () -> !foo.simpletype
 
   // CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo.complextype<abcd>
   %1 = "foo.unknown_op"() : () -> !foo.complextype<abcd>
 
   // CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo.complextype<abcd<f32>>
   %2 = "foo.unknown_op"() : () -> !foo.complextype<abcd<f32>>
 
   // CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo.complextype<abcd<[f]$$[32]>>
   %3 = "foo.unknown_op"() : () -> !foo.complextype<abcd<[f]$$[32]>>
 
   // CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo.dialect<!x@#!@#>
   %4 = "foo.unknown_op"() : () -> !foo.dialect<!x@#!@#>
 
-  // Extraneous extra > character can't use the pretty syntax.
-  // CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo<"dialect<!x@#!@#>>">
-  %5 = "foo.unknown_op"() : () -> !foo<"dialect<!x@#!@#>>">
-
   return
 }
 
 // CHECK-LABEL: func @none_type
 func.func @none_type() {
   // CHECK: "foo.unknown_op"() : () -> none
   %none_val = "foo.unknown_op"() : () -> none
   return

 func.func @"\"_string_symbol_reference\""() {
   // CHECK: ref = @"\22_string_symbol_reference\22"
   "foo.symbol_reference"() {ref = @"\"_string_symbol_reference\""} : () -> ()
   return
 }
 
 // CHECK-LABEL: func private @parse_opaque_attr_escape
 func.func private @parse_opaque_attr_escape() {
-    // CHECK: value = #foo<"\22escaped\\\0A\22">
+    // CHECK: value = #foo<"\"escaped\\\n\"">
     "foo.constant"() {value = #foo<"\"escaped\\\n\"">} : () -> ()
 }
 
 // CHECK-LABEL: func private @string_attr_name
 // CHECK-SAME: {"0 . 0", nested = {"0 . 0"}}
 func.func private @string_attr_name() attributes {"0 . 0", nested = {"0 . 0"}}
 
 // CHECK-LABEL: func private @nested_reference

mlir/test/Target/Cpp/types.mlir

 // RUN: mlir-translate -mlir-to-cpp %s | FileCheck %s
 
 // CHECK-LABEL: void opaque_types() {
 func.func @opaque_types() {
   // CHECK-NEXT: f<int>();
-  emitc.call "f"() {template_args = [!emitc<"opaque<\"int\">">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc<opaque<"int">>]} : () -> ()
   // CHECK-NEXT: f<byte>();
-  emitc.call "f"() {template_args = [!emitc<"opaque<\"byte\">">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc<opaque<"byte">>]} : () -> ()
   // CHECK-NEXT: f<unsigned>();
-  emitc.call "f"() {template_args = [!emitc<"opaque<\"unsigned\">">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc<opaque<"unsigned">>]} : () -> ()
   // CHECK-NEXT: f<status_t>();
-  emitc.call "f"() {template_args = [!emitc<"opaque<\"status_t\">">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc<opaque<"status_t">>]} : () -> ()
   // CHECK-NEXT: f<std::vector<std::string>>();
   emitc.call "f"() {template_args = [!emitc.opaque<"std::vector<std::string>">]} : () -> ()
 
   return
 }
 
 // CHECK-LABEL: void ptr_types() {
 func.func @ptr_types() {
   // CHECK-NEXT: f<int32_t*>();
-  emitc.call "f"() {template_args = [!emitc<"ptr<i32>">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc.ptr<i32>]} : () -> ()
   // CHECK-NEXT: f<int64_t*>();
   emitc.call "f"() {template_args = [!emitc.ptr<i64>]} : () -> ()
   // CHECK-NEXT: f<float*>();
-  emitc.call "f"() {template_args = [!emitc<"ptr<f32>">]} : () -> ()
+  emitc.call "f"() {template_args = [!emitc.ptr<f32>]} : () -> ()
   // CHECK-NEXT: f<double*>();
   emitc.call "f"() {template_args = [!emitc.ptr<f64>]} : () -> ()
   // CHECK-NEXT: int32_t* [[V0:[^ ]*]] = f();
   %0 = emitc.call "f"() : () -> (!emitc.ptr<i32>)
   // CHECK-NEXT: int32_t** [[V1:[^ ]*]] = f([[V0:[^ ]*]]);
   %1 = emitc.call "f"(%0) : (!emitc.ptr<i32>) -> (!emitc.ptr<!emitc.ptr<i32>>)
   // CHECK-NEXT: f<int*>();
   emitc.call "f"() {template_args = [!emitc.ptr<!emitc.opaque<"int">>]} : () -> ()
 
   return
 }

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

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
 // CHECK-LABEL: @test_roundtrip_parameter_parsers
-// CHECK: !test.type_with_format<111, three = #test<"attr_ugly begin 5 : index end">, two = "foo">
+// CHECK: !test.type_with_format<111, three = #test<attr_ugly begin 5 : index end>, two = "foo">
 // CHECK: !test.type_with_format<2147, three = "hi", two = "hi">
-func.func private @test_roundtrip_parameter_parsers(!test.type_with_format<111, three = #test<"attr_ugly begin 5 : index end">, two = "foo">) -> !test.type_with_format<2147, two = "hi", three = "hi">
+func.func private @test_roundtrip_parameter_parsers(!test.type_with_format<111, three = #test<attr_ugly begin 5 : index end>, two = "foo">) -> !test.type_with_format<2147, two = "hi", three = "hi">
 attributes {
   // CHECK: #test.attr_with_format<3 : two = "hello", four = [1, 2, 3] : 42 : i64, [ 10 : i16]
   attr0 = #test.attr_with_format<3 : two = "hello", four = [1, 2, 3] : 42 : i64, [10 : i16]>,
   // CHECK: #test.attr_with_format<5 : two = "a_string", four = [4, 5, 6, 7, 8] : 8 : i8, [ 10 : i16]>,
   attr1 = #test.attr_with_format<5 : two = "a_string", four = [4, 5, 6, 7, 8] : 8 : i8, [10 : i16]>,
-  // CHECK: #test<"attr_ugly begin 5 : index end">
-  attr2 = #test<"attr_ugly begin 5 : index end">,
+  // CHECK: #test<attr_ugly begin 5 : index end>
+  attr2 = #test<attr_ugly begin 5 : index end>,
   // CHECK: #test.attr_params<42, 24>
   attr3 = #test.attr_params<42, 24>,
   // CHECK: #test.attr_with_type<i32, vector<4xi32>>
   attr4 = #test.attr_with_type<i32, vector<4xi32>>,
   // CHECK: #test.attr_self_type_format<5> : i32
   attr5 = #test.attr_self_type_format<5> : i32
 }
 

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

 // RUN: mlir-opt --split-input-file %s --verify-diagnostics
 
 func.func private @test_ugly_attr_cannot_be_pretty() -> () attributes {
-  // expected-error@+1 {{expected 'begin'}}
-  attr = #test.attr_ugly
+  // expected-error@below {{expected 'begin'}}
+  attr = #test.attr_ugly,
 }
 
 // -----
 
 func.func private @test_ugly_attr_no_mnemonic() -> () attributes {
   // expected-error@+1 {{expected valid keyword}}
-  attr = #test<"">
+  attr = #test<>
 }
 
 // -----
 
 func.func private @test_ugly_attr_parser_dispatch() -> () attributes {
   // expected-error@+1 {{expected 'begin'}}
-  attr = #test<"attr_ugly">
+  attr = #test<attr_ugly>
 }
 
 // -----
 
 func.func private @test_ugly_attr_missing_parameter() -> () attributes {
   // expected-error@+2 {{failed to parse TestAttrUgly parameter 'attr'}}
   // expected-error@+1 {{expected attribute value}}
-  attr = #test<"attr_ugly begin">
+  attr = #test<attr_ugly begin>
 }
 
 // -----
 
 func.func private @test_ugly_attr_missing_literal() -> () attributes {
   // expected-error@+1 {{expected 'end'}}
-  attr = #test<"attr_ugly begin \"string_attr\"">
+  attr = #test<attr_ugly begin "string_attr">
 }
 
 // -----
 
 func.func private @test_pretty_attr_expects_less() -> () attributes {
   // expected-error@+1 {{expected '<'}}
-  attr = #test.attr_with_format
+  attr = #test.attr_with_format,
 }
 
 // -----
 
 func.func private @test_pretty_attr_missing_param() -> () attributes {
   // expected-error@+2 {{expected integer value}}
   // expected-error@+1 {{failed to parse TestAttrWithFormat parameter 'one'}}
   attr = #test.attr_with_format<>
 }
 
 // -----
 
 func.func private @test_parse_invalid_param() -> () attributes {
   // Test parameter parser failure is propagated
   // expected-error@+2 {{expected integer value}}
   // expected-error@+1 {{failed to parse TestAttrWithFormat parameter 'one'}}
-  attr = #test.attr_with_format<"hi">
+  attr = #test.attr_with_format<hi>
 }
 
 // -----
 
 func.func private @test_pretty_attr_invalid_syntax() -> () attributes {
   // expected-error@+1 {{expected ':'}}
   attr = #test.attr_with_format<42>
 }
func.func private @test_parse_param_after_struct() -> () attributes {
   // expected-error@+2 {{expected attribute value}}
   // expected-error@+1 {{failed to parse TestAttrWithFormat parameter 'three'}}
   attr = #test.attr_with_format<42 : two = "foo", four = [1, 2, 3] : >
 }
 
 // -----
 
 // expected-error@+1 {{expected '<'}}
-func.func private @test_invalid_type() -> !test.type_with_format
+func.func private @test_invalid_type() -> !test.type_with_format,
 
 // -----
 
 // expected-error@+2 {{expected integer value}}
 // expected-error@+1 {{failed to parse TestTypeWithFormat parameter 'one'}}
 func.func private @test_pretty_type_invalid_param() -> !test.type_with_format<>
 
 // -----

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.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 -> i16
-%b = test.result_has_same_type_as_attr #test<"attr_with_type_builder 10 : i16"> -> i16
+// CHECK: test.result_has_same_type_as_attr #test<attr_with_type_builder 10 : i16> : 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.func private @qualifiedAttr() attributes {foo = #test.cmpnd_nested_outer_qual<i #test.cmpnd_nested_inner<42 <1, !test.smpla, [5, 6]>>>}

mlir/test/python/ir/attributes.py

with Context() as ctx:
     ctx.allow_unregistered_dialects = True
     oattr = OpaqueAttr(Attribute.parse("#pytest_dummy.dummyattr<>"))
     # CHECK: oattr value: pytest_dummy
     print("oattr value:", oattr.dialect_namespace)
     # CHECK: oattr value: dummyattr<>
     print("oattr value:", oattr.data)
 
     # Test factory methods.
-    # CHECK: default_get: #foobar<"123">
+    # CHECK: default_get: #foobar<123>
     print(
         "default_get:",
         OpaqueAttr.get("foobar", bytes("123", "utf-8"), NoneType.get()))
 
 
 # CHECK-LABEL: TEST: testStringAttr
 @run
 def testStringAttr():