[ParseResult] Mark this as LLVM_NODISCARD (like LogicalResult) and fix issues.

[lattner]

Summary

There are a lot of cases where we accidentally ignored the result of some
parsing hook. Mark ParseResult as LLVM_NODISCARD just like ParseResult is.
This exposed some stuff to clean up, so do.

[rriddle]

Nice!

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

3116

It isn't clear why any of these variables needed to move, they looked fine in the place they were before.

mlir/lib/Parser/AffineParser.cpp

521

Why doesn't this have : in the error?

(Thanks for cleaning this up! The original was confusing and hard to follow)

[lattner]

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

3116

I moved them for reasons now irrelevant, will move them back, thanks!

mlir/lib/Parser/AffineParser.cpp

521

Good point. I kept the wrong error message from the original, which was broken as well. I'll fix in a follow-up thx for noticing!

mlir/include/mlir/Support/LogicalResult.h

 /// bool.
 ///
 /// This class should not be used for general error handling cases - we prefer
 /// to keep the logic explicit with the `succeeded`/`failed` predicates.
 /// However, traditional monadic-style parsing logic can sometimes get
 /// swallowed up in boilerplate without this, so we provide this for narrow
 /// cases where it is important.
 ///
-class ParseResult : public LogicalResult {
+class LLVM_NODISCARD ParseResult : public LogicalResult {
 public:
   ParseResult(LogicalResult result = success()) : LogicalResult(result) {}
 
   /// Failure is true in a boolean context.
   explicit operator bool() const { return failed(); }
 };
 
 } // namespace mlir
 
 #endif // MLIR_SUPPORT_LOGICALRESULT_H

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

p.printOptionalAttrDict(
                        AffineParallelOp::getUpperBoundsGroupsAttrName(),
                        AffineParallelOp::getStepsAttrName()});
 }
 
 /// Given a list of lists of parsed operands, populates `uniqueOperands` with
 /// unique operands. Also populates `replacements with affine expressions of
 /// `kind` that can be used to update affine maps previously accepting a
 /// `operands` to accept `uniqueOperands` instead.
-static void deduplicateAndResolveOperands(
+static ParseResult deduplicateAndResolveOperands(
     OpAsmParser &parser,
     ArrayRef<SmallVector<OpAsmParser::UnresolvedOperand>> operands,
     SmallVectorImpl<Value> &uniqueOperands,
     SmallVectorImpl<AffineExpr> &replacements, AffineExprKind kind) {
   assert((kind == AffineExprKind::DimId || kind == AffineExprKind::SymbolId) &&
          "expected operands to be dim or symbol expression");
 
   Type indexType = parser.getBuilder().getIndexType();
   for (const auto &list : operands) {
     SmallVector<Value> valueOperands;
-    parser.resolveOperands(list, indexType, valueOperands);
+    if (parser.resolveOperands(list, indexType, valueOperands))
+      return failure();
     for (Value operand : valueOperands) {
       unsigned pos = std::distance(uniqueOperands.begin(),
                                    llvm::find(uniqueOperands, operand));
       if (pos == uniqueOperands.size())
         uniqueOperands.push_back(operand);
       replacements.push_back(
           kind == AffineExprKind::DimId
               ? getAffineDimExpr(pos, parser.getContext())
               : getAffineSymbolExpr(pos, parser.getContext()));
     }
   }
+  return success();
 }
 
 namespace {
 enum class MinMaxKind { Min, Max };
 } // namespace
 
 /// Parses an affine map that can contain a min/max for groups of its results,
 /// e.g., max(expr-1, expr-2), expr-3, max(expr-4, expr-5, expr-6). Populates
flatExprs[i] = flatExprs[i]
                        .shiftSymbols(numSyms, totalNumSyms);
     totalNumDims += numDims;
     totalNumSyms += numSyms;
   }
 
   // Deduplicate map operands.
   SmallVector<Value> dimOperands, symOperands;
   SmallVector<AffineExpr> dimRplacements, symRepacements;
-  deduplicateAndResolveOperands(parser, flatDimOperands, dimOperands,
-                                dimRplacements, AffineExprKind::DimId);
+  if (deduplicateAndResolveOperands(parser, flatDimOperands, dimOperands,
+                                    dimRplacements, AffineExprKind::DimId) ||
       deduplicateAndResolveOperands(parser, flatSymOperands, symOperands,
-                                symRepacements, AffineExprKind::SymbolId);
+                                    symRepacements, AffineExprKind::SymbolId))
+    return failure();
 
   result.operands.append(dimOperands.begin(), dimOperands.end());
   result.operands.append(symOperands.begin(), symOperands.end());
 
   Builder &builder = parser.getBuilder();
   auto flatMap = AffineMap::get(totalNumDims, totalNumSyms, flatExprs,
                                 parser.getContext());
   flatMap = flatMap.replaceDimsAndSymbols(

mlir/lib/Dialect/Async/IR/Async.cpp

ParseResult ExecuteOp::parse(OpAsmParser &parser, OperationState &result) {
   // Add derived `operand_segment_sizes` attribute based on parsed operands.
   auto operandSegmentSizes = DenseIntElementsAttr::get(
       VectorType::get({2}, parser.getBuilder().getI32Type()),
       {numDependencies, numOperands});
   result.addAttribute(kOperandSegmentSizesAttr, operandSegmentSizes);
 
   // Parse the types of results returned from the async execute op.
   SmallVector<Type, 4> resultTypes;
-  if (parser.parseOptionalArrowTypeList(resultTypes))
-    return failure();
-
+  NamedAttrList attrs;
+  if (parser.parseOptionalArrowTypeList(resultTypes) ||
       // Async execute first result is always a completion token.
-  parser.addTypeToList(tokenTy, result.types);
-  parser.addTypesToList(resultTypes, result.types);
-
+      parser.addTypeToList(tokenTy, result.types) ||
+      parser.addTypesToList(resultTypes, result.types) ||
       // Parse operation attributes.
-  NamedAttrList attrs;
-  if (parser.parseOptionalAttrDictWithKeyword(attrs))
+      parser.parseOptionalAttrDictWithKeyword(attrs))
     return failure();
+
   result.addAttributes(attrs);
 
   // Parse asynchronous region.
   Region *body = result.addRegion();
   return parser.parseRegion(*body, /*arguments=*/unwrappedArgs);
 }
 
 LogicalResult ExecuteOp::verifyRegions() {

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

void GEPOp::build(OpBuilder &builder, OperationState &result, Type resultType,
   result.addOperands(remainingIndices);
 }
 
 static ParseResult
 parseGEPIndices(OpAsmParser &parser,
                 SmallVectorImpl<OpAsmParser::UnresolvedOperand> &indices,
                 DenseIntElementsAttr &structIndices) {
   SmallVector<int32_t> constantIndices;
-  parser.parseCommaSeparatedList([&]() -> ParseResult {
+
+  auto idxParser = [&]() -> ParseResult {
     int32_t constantIndex;
     OptionalParseResult parsedInteger =
         parser.parseOptionalInteger(constantIndex);
     if (parsedInteger.hasValue()) {
       if (failed(parsedInteger.getValue()))
         return failure();
       constantIndices.push_back(constantIndex);
       return success();
     }
 
     constantIndices.push_back(LLVM::GEPOp::kDynamicIndex);
     return parser.parseOperand(indices.emplace_back());
-  });
+  };
+  if (parser.parseCommaSeparatedList(idxParser))
+    return failure();
 
   structIndices = parser.getBuilder().getI32TensorAttr(constantIndices);
   return success();
 }
 
 static void printGEPIndices(OpAsmPrinter &printer, LLVM::GEPOp gepOp,
                             OperandRange indices,
                             DenseIntElementsAttr structIndices) {

mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp

for (const auto &iter : llvm::enumerate(operandTypes)) {
     if (failed(parser.resolveOperands(frag.regs, frag.regTypes,
                                       parser.getNameLoc(), result.operands)))
       return failure();
     frag.elemtype =
         inferOperandMMAType(frag.regTypes[0], /*isAccum=*/iter.index() < 2);
   }
 
   Type resultType;
-  parser.parseArrow();
-  parser.parseType(resultType);
+  if (parser.parseArrow() || parser.parseType(resultType))
+    return failure();
   frags[3].elemtype = inferOperandMMAType(resultType, /*isAccum=*/true);
 
   std::array<StringRef, 2> names{"multiplicandAPtxType",
                                  "multiplicandBPtxType"};
   for (unsigned idx = 0; idx < names.size(); idx++) {
     const auto &frag = frags[idx];
     Optional<NamedAttribute> attr = namedAttributes.getNamed(names[idx]);
     if (!frag.elemtype.hasValue() && !attr.hasValue()) {

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

 static ParseResult
 parseCommonStructuredOpParts(OpAsmParser &parser, OperationState &result,
                              SmallVectorImpl<Type> &inputTypes,
                              SmallVectorImpl<Type> &outputTypes) {
   SMLoc inputsOperandsLoc, outputsOperandsLoc;
   SmallVector<OpAsmParser::UnresolvedOperand, 4> inputsOperands,
       outputsOperands;
 
-  parser.parseOptionalAttrDict(result.attributes);
+  if (parser.parseOptionalAttrDict(result.attributes))
+    return failure();
 
   if (succeeded(parser.parseOptionalKeyword("ins"))) {
     if (parser.parseLParen())
       return failure();
 
     inputsOperandsLoc = parser.getCurrentLocation();
     if (parser.parseOperandList(inputsOperands) ||
         parser.parseColonTypeList(inputTypes) || parser.parseRParen())

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

return applyTilingToAll(getOperation(), getTarget(), tileSizes,
                                                                     rewriter);
                           });
 }
 
 ParseResult transform::TileOp::parse(OpAsmParser &parser,
                                      OperationState &result) {
   StringRef sizesAttrName = TileOp::getSizesAttrName(result.name).getValue();
   OpAsmParser::UnresolvedOperand targetOperand;
-  SMLoc opLoc;
-  parser.getCurrentLocation(&opLoc);
-  if (parser.parseOperand(targetOperand))
-    return parser.emitError(opLoc, "expected 'target' operand");
-  if (parser.parseOptionalAttrDict(result.attributes))
+  SMLoc opLoc = parser.getCurrentLocation();
+  if (parser.parseOperand(targetOperand) ||
+      parser.parseOptionalAttrDict(result.attributes))
     return failure();
   Attribute sizesAttr = result.attributes.get(sizesAttrName);
   if (!sizesAttr)
     return parser.emitError(opLoc)
            << "expected '" << sizesAttrName << "' attribute";
   auto sizesArrayAttr = sizesAttr.dyn_cast<ArrayAttr>();
   if (!sizesArrayAttr)
     return parser.emitError(opLoc)

mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp

 }
 
 /// Parse optional operand with its type prefixed with prefixKeyword `=`.
 /// Example:
 ///   num=%gangNum: i32
 static OptionalParseResult parserOptionalOperandAndTypeWithPrefix(
     OpAsmParser &parser, OperationState &result, StringRef prefixKeyword) {
   if (succeeded(parser.parseOptionalKeyword(prefixKeyword))) {
-    parser.parseEqual();
-    return parseOperandAndType(parser, result);
+    if (parser.parseEqual() || parseOperandAndType(parser, result))
+      return failure();
+    return success();
   }
   return llvm::None;
 }
 
 static bool isComputeOperation(Operation *op) {
   return isa<acc::ParallelOp>(op) || isa<acc::LoopOp>(op);
 }
 
if (succeeded(parser.parseOptionalKeyword(LoopOp::getGangKeyword())))
     executionMapping |= OpenACCExecMapping::GANG;
 
   // optional gang operand
   if (succeeded(parser.parseOptionalLParen())) {
     gangNum = parserOptionalOperandAndTypeWithPrefix(
         parser, result, LoopOp::getGangNumKeyword());
     if (gangNum.hasValue() && failed(*gangNum))
       return failure();
-    parser.parseOptionalComma();
+    // FIXME: Comma should require subsequent operands.
+    (void)parser.parseOptionalComma();
     gangStatic = parserOptionalOperandAndTypeWithPrefix(
         parser, result, LoopOp::getGangStaticKeyword());
     if (gangStatic.hasValue() && failed(*gangStatic))
       return failure();
-    parser.parseOptionalComma();
+    // FIXME: Why allow optional last commas?
+    (void)parser.parseOptionalComma();
     if (failed(parser.parseRParen()))
       return failure();
   }
 
   // worker?
   if (succeeded(parser.parseOptionalKeyword(LoopOp::getWorkerKeyword())))
     executionMapping |= OpenACCExecMapping::WORKER;
 

mlir/lib/Dialect/Quant/IR/TypeParser.cpp

static IntegerType parseStorageType(DialectAsmParser &parser, bool &isSigned) {
   auto typeLoc = parser.getCurrentLocation();
   IntegerType type;
 
   // Parse storage type (alpha_ident, integer_literal).
   StringRef identifier;
   unsigned storageTypeWidth = 0;
   OptionalParseResult result = parser.parseOptionalType(type);
   if (result.hasValue()) {
-    if (!succeeded(*result)) {
-      parser.parseType(type);
+    if (!succeeded(*result))
       return nullptr;
-    }
     isSigned = !type.isUnsigned();
     storageTypeWidth = type.getWidth();
   } else if (succeeded(parser.parseKeyword(&identifier))) {
     // Otherwise, this must be an unsigned integer (`u` integer-literal).
     if (!identifier.consume_front("u")) {
       parser.emitError(typeLoc, "illegal storage type prefix");
       return nullptr;
     }

mlir/lib/Dialect/SCF/SCF.cpp

ParseResult ParallelOp::parse(OpAsmParser &parser, OperationState &result) {
   result.addAttribute(
       ParallelOp::getOperandSegmentSizeAttr(),
       builder.getI32VectorAttr({static_cast<int32_t>(lower.size()),
                                 static_cast<int32_t>(upper.size()),
                                 static_cast<int32_t>(steps.size()),
                                 static_cast<int32_t>(initVals.size())}));
 
   // Parse attributes.
-  if (parser.parseOptionalAttrDict(result.attributes))
+  if (parser.parseOptionalAttrDict(result.attributes) ||
+      parser.resolveOperands(initVals, result.types, parser.getNameLoc(),
+                             result.operands))
     return failure();
 
-  if (!initVals.empty())
-    parser.resolveOperands(initVals, result.types, parser.getNameLoc(),
-                           result.operands);
   // Add a terminator if none was parsed.
   ForOp::ensureTerminator(*body, builder, result.location);
-
   return success();
 }
 
 void ParallelOp::print(OpAsmPrinter &p) {
   p << " (" << getBody()->getArguments() << ") = (" << getLowerBound()
     << ") to (" << getUpperBound() << ") step (" << getStep() << ")";
   if (!getInitVals().empty())
     p << " init (" << getInitVals() << ")";

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

if (vceTriple)
     state.addAttribute(getVCETripleAttrName(), *vceTriple);
   if (name)
     state.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                        builder.getStringAttr(*name));
 }
 
 ParseResult spirv::ModuleOp::parse(OpAsmParser &parser, OperationState &state) {
   Region *body = state.addRegion();
+  StringAttr nameAttr;
+  spirv::AddressingModel addrModel;
+  spirv::MemoryModel memoryModel;
 
   // If the name is present, parse it.
-  StringAttr nameAttr;
-  parser.parseOptionalSymbolName(
+  (void)parser.parseOptionalSymbolName(
       nameAttr, mlir::SymbolTable::getSymbolAttrName(), state.attributes);
 
   // Parse attributes
-  spirv::AddressingModel addrModel;
-  spirv::MemoryModel memoryModel;
   if (::parseEnumKeywordAttr(addrModel, parser, state) ||
       ::parseEnumKeywordAttr(memoryModel, parser, state))
     return failure();
 
   if (succeeded(parser.parseOptionalKeyword("requires"))) {
     spirv::VerCapExtAttr vceTriple;
     if (parser.parseAttribute(vceTriple,
                               spirv::ModuleOp::getVCETripleAttrName(),
                               state.attributes))
       return failure();
   }
 
-  if (parser.parseOptionalAttrDictWithKeyword(state.attributes))
-    return failure();
-
-  if (parser.parseRegion(*body, /*arguments=*/{}, /*argTypes=*/{}))
+  if (parser.parseOptionalAttrDictWithKeyword(state.attributes) ||
+      parser.parseRegion(*body, /*arguments=*/{}, /*argTypes=*/{}))
     return failure();
 
   // Make sure we have at least one block.
   if (body->empty())
     body->push_back(new Block());
 
   return success();
 }

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

ParseResult TransferReadOp::parse(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::UnresolvedOperand maskInfo;
   // Parsing with support for paddingValue.
   if (parser.parseOperand(sourceInfo) ||
       parser.parseOperandList(indexInfo, OpAsmParser::Delimiter::Square) ||
       parser.parseComma() || parser.parseOperand(paddingInfo))
     return failure();
   ParseResult hasMask = parser.parseOptionalComma();
   if (hasMask.succeeded()) {
-    parser.parseOperand(maskInfo);
+    if (parser.parseOperand(maskInfo))
+      return failure();
   }
   if (parser.parseOptionalAttrDict(result.attributes) ||
       parser.getCurrentLocation(&typesLoc) || parser.parseColonTypeList(types))
     return failure();
   if (types.size() != 2)
     return parser.emitError(typesLoc, "requires two types");
   auto indexType = builder.getIndexType();
   auto shapedType = types[0].dyn_cast<ShapedType>();

mlir/lib/IR/FunctionImplementation.cpp

ParseResult mlir::function_interface_impl::parseFunctionOp(
     OpAsmParser &parser, OperationState &result, bool allowVariadic,
     FuncTypeBuilder funcTypeBuilder) {
   SmallVector<OpAsmParser::Argument> entryArgs;
   SmallVector<DictionaryAttr> resultAttrs;
   SmallVector<Type> resultTypes;
   auto &builder = parser.getBuilder();
 
   // Parse visibility.
-  impl::parseOptionalVisibilityKeyword(parser, result.attributes);
+  (void)impl::parseOptionalVisibilityKeyword(parser, result.attributes);
 
   // Parse the name as a symbol.
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
                              result.attributes))
     return failure();
 
   // Parse the function signature.

mlir/lib/Parser/AffineParser.cpp

 /// bodies.
 class AffineParser : public Parser {
 public:
   AffineParser(ParserState &state, bool allowParsingSSAIds = false,
                function_ref<ParseResult(bool)> parseElement = nullptr)
       : Parser(state), allowParsingSSAIds(allowParsingSSAIds),
         parseElement(parseElement) {}
 
-  AffineMap parseAffineMapRange(unsigned numDims, unsigned numSymbols);
+  ParseResult parseAffineMapRange(unsigned numDims, unsigned numSymbols,
+                                  AffineMap &result);
   ParseResult parseAffineMapOrIntegerSetInline(AffineMap &map, IntegerSet &set);
-  IntegerSet parseIntegerSetConstraints(unsigned numDims, unsigned numSymbols);
+  ParseResult parseIntegerSetConstraints(unsigned numDims, unsigned numSymbols,
+                                         IntegerSet &result);
   ParseResult parseAffineMapOfSSAIds(AffineMap &map,
                                      OpAsmParser::Delimiter delimiter);
   ParseResult parseAffineExprOfSSAIds(AffineExpr &expr);
   void getDimsAndSymbolSSAIds(SmallVectorImpl<StringRef> &dimAndSymbolSSAIds,
                               unsigned &numDims);
 
 private:
   // Binary affine op parsing.

 }
 
 /// Parses an ambiguous affine map or integer set definition inline.
 ParseResult AffineParser::parseAffineMapOrIntegerSetInline(AffineMap &map,
                                                            IntegerSet &set) {
   unsigned numDims = 0, numSymbols = 0;
 
   // List of dimensional and optional symbol identifiers.
-  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 emitWrongTokenError("expected '->' or ':'");
-
-  if (isArrow) {
-    parseToken(Token::arrow, "expected '->' or '['");
-    map = parseAffineMapRange(numDims, numSymbols);
-    return map ? success() : failure();
-  }
-  if (parseToken(Token::colon, "expected ':' or '['"))
+  if (parseDimAndOptionalSymbolIdList(numDims, numSymbols))
     return failure();
 
-  if ((set = parseIntegerSetConstraints(numDims, numSymbols)))
-    return success();
+  if (consumeIf(Token::arrow))
+    return parseAffineMapRange(numDims, numSymbols, map);
 
+  if (parseToken(Token::colon, "expected '->' or '['"))
     return failure();
+  return parseIntegerSetConstraints(numDims, numSymbols, set);
 }
 
 /// Parse an AffineMap where the dim and symbol identifiers are SSA ids.
 ParseResult
 AffineParser::parseAffineMapOfSSAIds(AffineMap &map,
                                      OpAsmParser::Delimiter delimiter) {
 
   SmallVector<AffineExpr, 4> exprs;

 }
 
 /// Parse the range and sizes affine map definition inline.
 ///
 ///  affine-map ::= dim-and-symbol-id-lists `->` multi-dim-affine-expr
 ///
 ///  multi-dim-affine-expr ::= `(` `)`
 ///  multi-dim-affine-expr ::= `(` affine-expr (`,` affine-expr)* `)`
-AffineMap AffineParser::parseAffineMapRange(unsigned numDims,
-                                            unsigned numSymbols) {
+ParseResult AffineParser::parseAffineMapRange(unsigned numDims,
+                                              unsigned numSymbols,
+                                              AffineMap &result) {
   SmallVector<AffineExpr, 4> exprs;
   auto parseElt = [&]() -> ParseResult {
     auto elt = parseAffineExpr();
     ParseResult res = elt ? success() : failure();
     exprs.push_back(elt);
     return res;
   };
 
   // Parse a multi-dimensional affine expression (a comma-separated list of
   // 1-d affine expressions). Grammar:
   // multi-dim-affine-expr ::= `(` `)`
   //                         | `(` affine-expr (`,` affine-expr)* `)`
   if (parseCommaSeparatedList(Delimiter::Paren, parseElt,
                               " in affine map range"))
-    return AffineMap();
+    return failure();
 
   // Parsed a valid affine map.
-  return AffineMap::get(numDims, numSymbols, exprs, getContext());
+  result = AffineMap::get(numDims, numSymbols, exprs, getContext());
+  return success();
 }
 
 /// Parse an affine constraint.
 ///  affine-constraint ::= affine-expr `>=` `0`
 ///                      | affine-expr `==` `0`
 ///
 /// isEq is set to true if the parsed constraint is an equality, false if it
 /// is an inequality (greater than or equal).

 
 /// 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)*
 ///
-IntegerSet AffineParser::parseIntegerSetConstraints(unsigned numDims,
-                                                    unsigned numSymbols) {
+ParseResult AffineParser::parseIntegerSetConstraints(unsigned numDims,
+                                                     unsigned numSymbols,
+                                                     IntegerSet &result) {
   SmallVector<AffineExpr, 4> constraints;
   SmallVector<bool, 4> isEqs;
   auto parseElt = [&]() -> ParseResult {
     bool isEq;
     auto elt = parseAffineConstraint(&isEq);
     ParseResult res = elt ? success() : failure();
     if (elt) {
       constraints.push_back(elt);
       isEqs.push_back(isEq);
     }
     return res;
   };
 
   // Parse a list of affine constraints (comma-separated).
   if (parseCommaSeparatedList(Delimiter::Paren, parseElt,
                               " in integer set constraint list"))
-    return IntegerSet();
+    return failure();
 
   // If no constraints were parsed, then treat this as a degenerate 'true' case.
   if (constraints.empty()) {
     /* 0 == 0 */
     auto zero = getAffineConstantExpr(0, getContext());
-    return IntegerSet::get(numDims, numSymbols, zero, true);
+    result = IntegerSet::get(numDims, numSymbols, zero, true);
+    return success();
   }
 
   // Parsed a valid integer set.
-  return IntegerSet::get(numDims, numSymbols, constraints, isEqs);
+  result = IntegerSet::get(numDims, numSymbols, constraints, isEqs);
+  return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Parser
 //===----------------------------------------------------------------------===//
 
 /// Parse an ambiguous reference to either and affine map or an integer set.
 ParseResult Parser::parseAffineMapOrIntegerSetReference(AffineMap &map,

mlir/test/Dialect/SCF/invalid.mlir

func.func @parallel_more_results_than_reduces(
 
   return
 }
 
 // -----
 
 func.func @parallel_more_results_than_initial_values(
     %arg0 : index, %arg1: index, %arg2: index) {
-  // expected-error@+1 {{expects number of results: 1 to be the same as number of initial values: 0}}
+  // expected-error@+1 {{'scf.parallel' 0 operands present, but expected 1}}
   %res = scf.parallel (%i0) = (%arg0) to (%arg1) step (%arg2) -> f32 {
     scf.reduce(%arg0) : index {
       ^bb0(%lhs: index, %rhs: index):
         scf.reduce.return %lhs : index
     }
   }
 }
 

mlir/test/IR/invalid.mlir

 func.func @invalid_tensor_literal() {
   // expected-error @+1 {{sparse index #0 is not contained within the value shape, with index=[1, 1], and type='tensor<1x1xi16>'}}
   "fooi16"(){bar = sparse<1, 10> : tensor<1x1xi16>} : () -> ()
 
 // -----
 
 func.func @invalid_affine_structure() {
   %c0 = arith.constant 0 : index
-  %idx = affine.apply affine_map<(d0, d1)> (%c0, %c0) // expected-error {{expected '->' or ':'}}
+  %idx = affine.apply affine_map<(d0, d1)> (%c0, %c0) // expected-error {{expected '->' or '['}}
   return
 }
 
 // -----
 
 func.func @missing_for_max(%arg0: index, %arg1: index, %arg2: memref<100xf32>) {
   // expected-error @+1 {{lower loop bound affine map with multiple results requires 'max' prefix}}
   affine.for %i0 = affine_map<()[s]->(0,s-1)>()[%arg0] to %arg1 {

mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp

Attribute parseAttribute(DialectAsmParser &parser, Type type) const override {
     bool ok =
         succeeded(parser.parseKeyword("spec")) && succeeded(parser.parseLess());
     (void)ok;
     assert(ok);
     if (succeeded(parser.parseOptionalGreater()))
       return CustomDataLayoutSpec::get(parser.getContext(), {});
 
     SmallVector<DataLayoutEntryInterface> entries;
-    parser.parseCommaSeparatedList([&]() {
+    ok = succeeded(parser.parseCommaSeparatedList([&]() {
       entries.emplace_back();
       ok = succeeded(parser.parseAttribute(entries.back()));
       assert(ok);
       return success();
-    });
+    }));
+    assert(ok);
     ok = succeeded(parser.parseGreater());
     assert(ok);
     return CustomDataLayoutSpec::get(parser.getContext(), entries);
   }
 
   void printType(Type type, DialectAsmPrinter &printer) const override {
     if (type.isa<SingleQueryType>())
       printer << "single_query";