[AsmParser] Adopt emitWrongTokenError more, improving QoI

[lattner]

Summary

This is a full audit of emitError calls, I took the opportunity
to remove extranous parens and fix a couple cases where we'd
generate multiple diagnostics for the same error.

[lattner]

Pair programmed with @bollu

[bzcheeseman]

mlir/lib/Parser/AffineParser.cpp

300

Does this error get emitted in parseElement now?

[lattner]

Thx for the reviews!

mlir/lib/Parser/AffineParser.cpp

300

Yes, i always did, this was generating two diagnostics for the same line.

mlir/lib/Parser/AffineParser.cpp

 
 /// Parse an affine expression inside parentheses.
 ///
 ///   affine-expr ::= `(` affine-expr `)`
 AffineExpr AffineParser::parseParentheticalExpr() {
   if (parseToken(Token::l_paren, "expected '('"))
     return nullptr;
   if (getToken().is(Token::r_paren))
-    return (emitError("no expression inside parentheses"), nullptr);
+    return emitError("no expression inside parentheses"), nullptr;
 
   auto expr = parseAffineExpr();
-  if (!expr)
-    return nullptr;
-  if (parseToken(Token::r_paren, "expected ')'"))
+  if (!expr || parseToken(Token::r_paren, "expected ')'"))
     return nullptr;
 
   return expr;
 }
 
 /// Parse the negation expression.
 ///
 ///   affine-expr ::= `-` affine-expr
 AffineExpr AffineParser::parseNegateExpression(AffineExpr lhs) {
   if (parseToken(Token::minus, "expected '-'"))
     return nullptr;
 
   AffineExpr operand = parseAffineOperandExpr(lhs);
   // Since negation has the highest precedence of all ops (including high
   // precedence ops) but lower than parentheses, we are only going to use
   // parseAffineOperandExpr instead of parseAffineExpr here.
   if (!operand)
     // Extra error message although parseAffineOperandExpr would have
     // complained. Leads to a better diagnostic.
-    return (emitError("missing operand of negation"), nullptr);
+    return emitError("missing operand of negation"), nullptr;
   return (-1) * operand;
 }
 
 /// Parse a bare id that may appear in an affine expression.
 ///
 ///   affine-expr ::= bare-id
 AffineExpr AffineParser::parseBareIdExpr() {
   if (getToken().isNot(Token::bare_identifier))
-    return (emitError("expected bare identifier"), nullptr);
+    return emitWrongTokenError("expected bare identifier"), nullptr;
 
   StringRef sRef = getTokenSpelling();
   for (auto entry : dimsAndSymbols) {
     if (entry.first == sRef) {
       consumeToken(Token::bare_identifier);
       return entry.second;
     }
   }
 
-  return (emitError("use of undeclared identifier"), nullptr);
+  return emitWrongTokenError("use of undeclared identifier"), nullptr;
 }
 
 /// Parse an SSA id which may appear in an affine expression.
 AffineExpr AffineParser::parseSSAIdExpr(bool isSymbol) {
   if (!allowParsingSSAIds)
-    return (emitError("unexpected ssa identifier"), nullptr);
+    return emitWrongTokenError("unexpected ssa identifier"), nullptr;
   if (getToken().isNot(Token::percent_identifier))
-    return (emitError("expected ssa identifier"), nullptr);
+    return emitWrongTokenError("expected ssa identifier"), nullptr;
   auto name = getTokenSpelling();
   // Check if we already parsed this SSA id.
   for (auto entry : dimsAndSymbols) {
     if (entry.first == name) {
       consumeToken(Token::percent_identifier);
       return entry.second;
     }
   }
   // Parse the SSA id and add an AffineDim/SymbolExpr to represent it.
   if (parseElement(isSymbol))
-    return (emitError("failed to parse ssa identifier"), nullptr);
+    return nullptr;
   auto idExpr = isSymbol
                     ? getAffineSymbolExpr(numSymbolOperands++, getContext())
                     : getAffineDimExpr(numDimOperands++, getContext());
   dimsAndSymbols.push_back({name, idExpr});
   return idExpr;
 }
 
 AffineExpr AffineParser::parseSymbolSSAIdExpr() {

 }
 
 /// Parse a positive integral constant appearing in an affine expression.
 ///
 ///   affine-expr ::= integer-literal
 AffineExpr AffineParser::parseIntegerExpr() {
   auto val = getToken().getUInt64IntegerValue();
   if (!val.hasValue() || (int64_t)val.getValue() < 0)
-    return (emitError("constant too large for index"), nullptr);
+    return emitError("constant too large for index"), nullptr;
 
   consumeToken(Token::integer);
   return builder.getAffineConstantExpr((int64_t)val.getValue());
 }
 
 /// Parses an expression that can be a valid operand of an affine expression.
 /// lhs: if non-null, lhs is an affine expression that is the lhs of a binary
 /// operator, the rhs of which is being parsed. This is used to determine
AffineExpr AffineParser::parseAffineExpr() {
   return parseAffineLowPrecOpExpr(nullptr, AffineLowPrecOp::LNoOp);
 }
 
 /// Parse a dim or symbol from the lists appearing before the actual
 /// expressions of the affine map. Update our state to store the
 /// dimensional/symbolic identifier.
 ParseResult AffineParser::parseIdentifierDefinition(AffineExpr idExpr) {
   if (getToken().isNot(Token::bare_identifier))
-    return emitError("expected bare identifier");
+    return emitWrongTokenError("expected bare identifier");
 
   auto name = getTokenSpelling();
   for (auto entry : dimsAndSymbols) {
     if (entry.first == name)
       return emitError("redefinition of identifier '" + name + "'");
   }
   consumeToken(Token::bare_identifier);
 
ParseResult AffineParser::parseAffineMapOrIntegerSetInline(AffineMap &map,
   if (parseDimAndOptionalSymbolIdList(numDims, numSymbols)) {
     return failure();
   }
 
   // This is needed for parsing attributes as we wouldn't know whether we would
   // be parsing an integer set attribute or an affine map attribute.
   bool isArrow = getToken().is(Token::arrow);
   bool isColon = getToken().is(Token::colon);
-  if (!isArrow && !isColon) {
-    return emitError("expected '->' or ':'");
-  }
+  if (!isArrow && !isColon)
+    return emitWrongTokenError("expected '->' or ':'");
+
   if (isArrow) {
     parseToken(Token::arrow, "expected '->' or '['");
     map = parseAffineMapRange(numDims, numSymbols);
     return map ? success() : failure();
   }
   if (parseToken(Token::colon, "expected ':' or '['"))
     return failure();
 
AffineExpr AffineParser::parseAffineConstraint(bool *isEq) {
   if (consumeIf(Token::greater) && consumeIf(Token::equal) &&
       getToken().is(Token::integer)) {
     auto dim = getToken().getUnsignedIntegerValue();
     if (dim.hasValue() && dim.getValue() == 0) {
       consumeToken(Token::integer);
       *isEq = false;
       return expr;
     }
-    return (emitError("expected '0' after '>='"), nullptr);
+    return emitError("expected '0' after '>='"), nullptr;
   }
 
   if (consumeIf(Token::equal) && consumeIf(Token::equal) &&
       getToken().is(Token::integer)) {
     auto dim = getToken().getUnsignedIntegerValue();
     if (dim.hasValue() && dim.getValue() == 0) {
       consumeToken(Token::integer);
       *isEq = true;
       return expr;
     }
-    return (emitError("expected '0' after '=='"), nullptr);
+    return emitError("expected '0' after '=='"), nullptr;
   }
 
-  return (emitError("expected '== 0' or '>= 0' at end of affine constraint"),
-          nullptr);
+  return emitError("expected '== 0' or '>= 0' at end of affine constraint"),
+         nullptr;
 }
 
 /// Parse the constraints that are part of an integer set definition.
 ///  integer-set-inline
 ///                ::= dim-and-symbol-id-lists `:`
 ///                '(' affine-constraint-conjunction? ')'
 ///  affine-constraint-conjunction ::= affine-constraint (`,`
 ///                                       affine-constraint)*

mlir/lib/Parser/AttributeParser.cpp

case Token::integer:
     return parseDecOrHexAttr(type, /*isNegative=*/false);
   case Token::minus: {
     consumeToken(Token::minus);
     if (getToken().is(Token::integer))
       return parseDecOrHexAttr(type, /*isNegative=*/true);
     if (getToken().is(Token::floatliteral))
       return parseFloatAttr(type, /*isNegative=*/true);
 
-    return (emitError("expected constant integer or floating point value"),
+    return (emitWrongTokenError(
+                "expected constant integer or floating point value"),
             nullptr);
   }
 
   // Parse a location attribute.
   case Token::kw_loc: {
     consumeToken(Token::kw_loc);
 
     LocationAttr locAttr;
case Token::kw_unit:
     return builder.getUnitAttr();
 
   default:
     // Parse a type attribute. We parse `Optional` here to allow for providing a
     // better error message.
     Type type;
     OptionalParseResult result = parseOptionalType(type);
     if (!result.hasValue())
-      return emitError("expected attribute value"), Attribute();
+      return emitWrongTokenError("expected attribute value"), Attribute();
     return failed(*result) ? Attribute() : TypeAttr::get(type);
   }
 }
 
 /// Parse an optional attribute with the provided type.
 OptionalParseResult Parser::parseOptionalAttribute(Attribute &attribute,
                                                    Type type) {
   switch (getToken().getKind()) {
auto parseElt = [&]() -> ParseResult {
     // The name of an attribute can either be a bare identifier, or a string.
     Optional<StringAttr> nameId;
     if (getToken().is(Token::string))
       nameId = builder.getStringAttr(getToken().getStringValue());
     else if (getToken().isAny(Token::bare_identifier, Token::inttype) ||
              getToken().isKeyword())
       nameId = builder.getStringAttr(getTokenSpelling());
     else
-      return emitError("expected attribute name");
+      return emitWrongTokenError("expected attribute name");
 
     if (nameId->size() == 0)
       return emitError("expected valid attribute name");
 
     if (!seenKeys.insert(*nameId).second)
       return emitError("duplicate key '")
              << nameId->getValue() << "' in dictionary attribute";
     consumeToken();

mlir/lib/Parser/DialectSymbolParser.cpp

static Symbol parseExtendedSymbol(Parser &p, Token::Kind identifierTok,
   p.consumeToken(identifierTok);
 
   // 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('.')) {
     // Check for an alias for this type.
     auto aliasIt = aliases.find(identifier);
     if (aliasIt == aliases.end())
-      return (p.emitError("undefined symbol alias id '" + identifier + "'"),
+      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.emitError("expected string literal data in dialect symbol"),
+      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"))
       return nullptr;

mlir/lib/Parser/LocationParser.cpp

ParseResult Parser::parseCallSiteLocation(LocationAttr &loc) {
   // Parse the callee location.
   LocationAttr calleeLoc;
   if (parseLocationInstance(calleeLoc))
     return failure();
 
   // Parse the 'at'.
   if (getToken().isNot(Token::bare_identifier) ||
       getToken().getSpelling() != "at")
-    return emitError("expected 'at' in callsite location");
+    return emitWrongTokenError("expected 'at' in callsite location");
   consumeToken(Token::bare_identifier);
 
   // Parse the caller location.
   LocationAttr callerLoc;
   if (parseLocationInstance(callerLoc))
     return failure();
 
   // Parse the ')'.
   if (parseToken(Token::r_paren, "expected ')' in callsite location"))
     return failure();
 
   // Return the callsite location.
   loc = CallSiteLoc::get(calleeLoc, callerLoc);
   return success();
 }
 
 ParseResult Parser::parseFusedLocation(LocationAttr &loc) {
   consumeToken(Token::bare_identifier);
 
   // Try to parse the optional metadata.
   Attribute metadata;
   if (consumeIf(Token::less)) {
     metadata = parseAttribute();
     if (!metadata)
-      return emitError("expected valid attribute metadata");
+      return failure();
+
     // Parse the '>' token.
     if (parseToken(Token::greater,
                    "expected '>' after fused location metadata"))
       return failure();
   }
 
   SmallVector<Location, 4> locations;
   auto parseElt = [&] {
ParseResult Parser::parseNameOrFileLineColLocation(LocationAttr &loc) {
   auto *ctx = getContext();
   auto str = getToken().getStringValue();
   consumeToken(Token::string);
 
   // If the next token is ':' this is a filelinecol location.
   if (consumeIf(Token::colon)) {
     // Parse the line number.
     if (getToken().isNot(Token::integer))
-      return emitError("expected integer line number in FileLineColLoc");
+      return emitWrongTokenError(
+          "expected integer line number in FileLineColLoc");
     auto line = getToken().getUnsignedIntegerValue();
     if (!line.hasValue())
-      return emitError("expected integer line number in FileLineColLoc");
+      return emitWrongTokenError(
+          "expected integer line number in FileLineColLoc");
     consumeToken(Token::integer);
 
     // Parse the ':'.
     if (parseToken(Token::colon, "expected ':' in FileLineColLoc"))
       return failure();
 
     // Parse the column number.
     if (getToken().isNot(Token::integer))
-      return emitError("expected integer column number in FileLineColLoc");
+      return emitWrongTokenError(
+          "expected integer column number in FileLineColLoc");
     auto column = getToken().getUnsignedIntegerValue();
     if (!column.hasValue())
       return emitError("expected integer column number in FileLineColLoc");
     consumeToken(Token::integer);
 
     loc = FileLineColLoc::get(ctx, str, line.getValue(), column.getValue());
     return success();
   }

 
 ParseResult Parser::parseLocationInstance(LocationAttr &loc) {
   // Handle either name or filelinecol locations.
   if (getToken().is(Token::string))
     return parseNameOrFileLineColLocation(loc);
 
   // Bare tokens required for other cases.
   if (!getToken().is(Token::bare_identifier))
-    return emitError("expected location instance");
+    return emitWrongTokenError("expected location instance");
 
   // Check for the 'callsite' signifying a callsite location.
   if (getToken().getSpelling() == "callsite")
     return parseCallSiteLocation(loc);
 
   // If the token is 'fused', then this is a fused location.
   if (getToken().getSpelling() == "fused")
     return parseFusedLocation(loc);
 
   // Check for a 'unknown' for an unknown location.
   if (getToken().getSpelling() == "unknown") {
     consumeToken(Token::bare_identifier);
     loc = UnknownLoc::get(getContext());
     return success();
   }
 
-  return emitError("expected location instance");
+  return emitWrongTokenError("expected location instance");
 }

mlir/lib/Parser/TypeParser.cpp

 /// Parse the offset and strides from a strided layout specification.
 ///
 ///   strided-layout ::= `offset:` dimension `,` `strides: ` stride-list
 ///
 ParseResult Parser::parseStridedLayout(int64_t &offset,
                                        SmallVectorImpl<int64_t> &strides) {
   // Parse offset.
   consumeToken(Token::kw_offset);
-  if (!consumeIf(Token::colon))
-    return emitError("expected colon after `offset` keyword");
+  if (parseToken(Token::colon, "expected colon after `offset` keyword"))
+    return failure();
+
   auto maybeOffset = getToken().getUnsignedIntegerValue();
   bool question = getToken().is(Token::question);
   if (!maybeOffset && !question)
-    return emitError("invalid offset");
+    return emitWrongTokenError("invalid offset");
   offset = maybeOffset ? static_cast<int64_t>(maybeOffset.getValue())
                        : MemRefType::getDynamicStrideOrOffset();
   consumeToken();
 
-  if (!consumeIf(Token::comma))
-    return emitError("expected comma after offset value");
-
   // Parse stride list.
-  if (parseToken(Token::kw_strides,
+  if (parseToken(Token::comma, "expected comma after offset value") ||
+      parseToken(Token::kw_strides,
                  "expected `strides` keyword after offset specification") ||
-
       parseToken(Token::colon, "expected colon after `strides` keyword") ||
       parseStrideList(strides))
     return failure();
   return success();
 }
 
 /// Parse a memref type.
 ///

 ///
 ///   index-type ::= `index`
 ///   float-type ::= `f16` | `bf16` | `f32` | `f64` | `f80` | `f128`
 ///   none-type ::= `none`
 ///
 Type Parser::parseNonFunctionType() {
   switch (getToken().getKind()) {
   default:
-    return (emitError("expected non-function type"), nullptr);
+    return (emitWrongTokenError("expected non-function type"), nullptr);
   case Token::kw_memref:
     return parseMemRefType();
   case Token::kw_tensor:
     return parseTensorType();
   case Token::kw_complex:
     return parseComplexType();
   case Token::kw_tuple:
     return parseTupleType();
while (getToken().is(Token::integer)) {
       int64_t value;
       if (parseIntegerInDimensionList(value))
         return failure();
       dimensions.push_back(value);
       numScalableDims++;
       // Check if we have reached the end of the scalable dimension list
       if (consumeIf(Token::r_square)) {
         // Make sure we have something like 'xbf32'.
-        if (parseXInDimensionList())
-          return failure();
-        return success();
+        return parseXInDimensionList();
       }
       // Make sure we have an 'x'
       if (parseXInDimensionList())
         return failure();
     }
     // If we make it here, we've finished parsing the dimension list
     // without finding ']' closing the set of scalable dimensions
-    return emitError("missing ']' closing set of scalable dimensions");
+    return emitWrongTokenError(
+        "missing ']' closing set of scalable dimensions");
   }
 
   return success();
 }
 
 /// Parse a dimension list of a tensor or memref type.  This populates the
 /// dimension list, using -1 for the `?` dimensions if `allowDynamic` is set and
 /// errors out on `?` otherwise.
 ///
 ///   dimension-list-ranked ::= (dimension `x`)*
 ///   dimension ::= `?` | decimal-literal
 ///
 /// When `allowDynamic` is not set, this is used to parse:
 ///
 ///   static-dimension-list ::= (decimal-literal `x`)*
 ParseResult
 Parser::parseDimensionListRanked(SmallVectorImpl<int64_t> &dimensions,
                                  bool allowDynamic) {
   while (getToken().isAny(Token::integer, Token::question)) {
+    auto loc = getToken().getLoc();
     if (consumeIf(Token::question)) {
       if (!allowDynamic)
-        return emitError("expected static shape");
+        return emitError(loc, "expected static shape");
       dimensions.push_back(-1);
     } else {
       int64_t value;
       if (parseIntegerInDimensionList(value))
         return failure();
       dimensions.push_back(value);
     }
     // Make sure we have an 'x' or something like 'xbf32'.
ParseResult Parser::parseIntegerInDimensionList(int64_t &value) {
   return success();
 }
 
 /// Parse an 'x' token in a dimension list, handling the case where the x is
 /// juxtaposed with an element type, as in "xf32", leaving the "f32" as the next
 /// token.
 ParseResult Parser::parseXInDimensionList() {
   if (getToken().isNot(Token::bare_identifier) || getTokenSpelling()[0] != 'x')
-    return emitError("expected 'x' in dimension list");
+    return emitWrongTokenError("expected 'x' in dimension list");
 
   // If we had a prefix of 'x', lex the next token immediately after the 'x'.
   if (getTokenSpelling().size() != 1)
     state.lex.resetPointer(getTokenSpelling().data() + 1);
 
   // Consume the 'x'.
   consumeToken(Token::bare_identifier);
 

mlir/test/Dialect/SPIRV/IR/glsl-ops.mlir

func.func @exp(%arg0 : f32, %arg1 : f32) -> () {
   // expected-error @+1 {{expected ':'}}
   %2 = spv.GLSL.Exp %arg0, %arg1 : i32
   return
 }
 
 // -----
 
 func.func @exp(%arg0 : i32) -> () {
-  // expected-error @+2 {{expected non-function type}}
+  // expected-error @+1 {{expected non-function type}}
   %2 = spv.GLSL.Exp %arg0 :
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // spv.GLSL.{F|S|U}{Max|Min}

mlir/test/Dialect/SPIRV/IR/logical-ops.mlir

func.func @logicalBinary(%arg0 : i1, %arg1 : i1)
   %0 = spv.LogicalAnd %arg0, %arg1
   return
 }
 
 // -----
 
 func.func @logicalBinary(%arg0 : i1, %arg1 : i1)
 {
-  // expected-error @+2 {{expected non-function type}}
+  // expected-error @+1 {{expected non-function type}}
   %0 = spv.LogicalAnd %arg0, %arg1 :
   return
 }
 
 // -----
 
 func.func @logicalBinary(%arg0 : i1, %arg1 : i1)
 {
func.func @logicalUnary(%arg0 : i1)
   %0 = spv.LogicalNot %arg0
   return
 }
 
 // -----
 
 func.func @logicalUnary(%arg0 : i1)
 {
-  // expected-error @+2 {{expected non-function type}}
+  // expected-error @+1 {{expected non-function type}}
   %0 = spv.LogicalNot %arg0 :
   return
 }
 
 // -----
 
 func.func @logicalUnary(%arg0 : i1)
 {

mlir/test/Dialect/SPIRV/IR/misc-ops.mlir

func.func @undef() -> () {
   // CHECK: %{{.*}} = spv.Undef : vector<4xf32>
   %1 = spv.Undef : vector<4xf32>
   spv.Return
 }
 
 // -----
 
 func.func @undef() -> () {
-  // expected-error @+2{{expected non-function type}}
+  // expected-error @+1{{expected non-function type}}
   %0 = spv.Undef :
   spv.Return
 }
 
 // -----
 
 func.func @undef() -> () {
   // expected-error @+1{{expected ':'}}

mlir/test/Dialect/SPIRV/IR/ocl-ops.mlir

func.func @exp(%arg0 : f32, %arg1 : f32) -> () {
   // expected-error @+1 {{expected ':'}}
   %2 = spv.OCL.exp %arg0, %arg1 : i32
   return
 }
 
 // -----
 
 func.func @exp(%arg0 : i32) -> () {
-  // expected-error @+2 {{expected non-function type}}
+  // expected-error @+1 {{expected non-function type}}
   %2 = spv.OCL.exp %arg0 :
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // spv.OCL.fabs
func.func @fabs(%arg0 : f32, %arg1 : f32) -> () {
   // expected-error @+1 {{expected ':'}}
   %2 = spv.OCL.fabs %arg0, %arg1 : i32
   return
 }
 
 // -----
 
 func.func @fabs(%arg0 : i32) -> () {
-  // expected-error @+2 {{expected non-function type}}
+  // expected-error @+1 {{expected non-function type}}
   %2 = spv.OCL.fabs %arg0 :
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // spv.OCL.s_abs
func.func @sabs(%arg0 : i32, %arg1 : i32) -> () {
   // expected-error @+1 {{expected ':'}}
   %2 = spv.OCL.s_abs %arg0, %arg1 : i32
   return
 }
 
 // -----
 
 func.func @sabs(%arg0 : i32) -> () {
-  // expected-error @+2 {{expected non-function type}}
+  // expected-error @+1 {{expected non-function type}}
   %2 = spv.OCL.s_abs %arg0 :
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // spv.OCL.fma

mlir/test/IR/invalid-locations.mlir

^bb:
   return loc(fused<true [unknown]) // expected-error {{expected '>' after fused location metadata}}
 }
 
 // -----
 
 func.func @location_fused_missing_metadata() {
 ^bb:
   // expected-error@+1 {{expected attribute value}}
-  return loc(fused<) // expected-error {{expected valid attribute metadata}}
+  return loc(fused<) 
 }
 
 // -----
 
 func.func @location_fused_missing_l_square() {
 ^bb:
   return loc(fused<true>unknown]) // expected-error {{expected '[' in fused location}}
 }

mlir/test/IR/invalid.mlir

 !missing_eq_alias type i32 // expected-error {{expected '=' in type alias definition}}
 
 // -----
 
 !missing_kw_type_alias = i32 // expected-error {{expected 'type' in type alias definition}}
 
 // -----
 
-!missing_type_alias = type // expected-error@+1 {{expected non-function type}}
+!missing_type_alias = type // expected-error {{expected non-function type}}
 
 // -----
 
 !redef_alias = type i32
 !redef_alias = type i32 // expected-error {{redefinition of type alias id 'redef_alias'}}
 
 // -----
 
func.func @error_at_end_of_line() {
   %0 = "foo"()  // expected-error {{expected ':' followed by operation type}}
   return
 }
 
 // -----
 
 @foo   // expected-error {{expected operation name in quotes}}
 
+// -----
+
+func.func @func() {
+  %c0 = arith.constant  // expected-error {{expected attribute value}}
+
+  %x = arith.constant 1 : i32
+}