[mlir] Mark LogicalResult as LLVM_NODISCARD

[rriddle]

Summary

This makes ignoring a result explicit by the user, and helps to prevent accidental errors with dropped results. Marking LogicalResult as no discard was always the intention from the beginning, but got lost along the way.

[jpienaar]

Perhaps a high level question: is the intention to just retain the current behavior or to check up on cases where currently not checked?

mlir/lib/Dialect/Affine/Utils/Utils.cpp

223

Why doesnt this return failure if this fails?

[mehdi_amini]

Thanks!

[silvas]

mlir/include/mlir/Support/LogicalResult.h

16–17

Maybe add a blurb here about the fact that it is nodiscard, and how to explicitly discard it if needed (the (void) trick -- not obvious to most folks).

Also maybe document a best practice about only using it in contexts where it makes sense to always check the result?

[rriddle]

In D95841#2535509, @jpienaar wrote:

Perhaps a high level question: is the intention to just retain the current behavior or to check up on cases where currently not checked?

The intention for this revision is to be mostly NFC. I'll look at a few obvious fixes, but a lot of these seem to indicate a general lack of testing which would be better served by proper followups by the owners of the affected components. I plan to file bugs against these owners to look into/resolve the (void)s added for their components in this revision.

mlir/lib/Dialect/Affine/Utils/Utils.cpp

223

An applyPatternsAndFoldGreedily failure just means that it failed to converge when applying patterns. Returning failure in this case (and in most TBH) wouldn't make sense here given that failing to converge on the cleanup doesn't mean that the hoisting failed. I'm honestly considering moving the indication of non-convergence to an optional parameter or something, given the above.

[rriddle]

feedback

mlir/include/mlir/IR/OpDefinition.h

 public:
   ParseResult(LogicalResult result = success()) : LogicalResult(result) {}
 
   // Allow diagnostics emitted during parsing to be converted to failure.
   ParseResult(const InFlightDiagnostic &) : LogicalResult(failure()) {}
   ParseResult(const Diagnostic &) : LogicalResult(failure()) {}
 
   /// Failure is true in a boolean context.
-  explicit operator bool() const { return failed(*this); }
+  explicit operator bool() const { return failed(); }
 };
 /// This class implements `Optional` functionality for ParseResult. We don't
 /// directly use Optional here, because it provides an implicit conversion
 /// to 'bool' which we want to avoid. This class is used to implement tri-state
 /// 'parseOptional' functions that may have a failure mode when parsing that
 /// shouldn't be attributed to "not present".
 class OptionalParseResult {
 public:

mlir/include/mlir/IR/SymbolTable.h

public:
   static bool symbolKnownUseEmpty(StringRef symbol, Region *from);
   static bool symbolKnownUseEmpty(Operation *symbol, Region *from);
 
   /// Attempt to replace all uses of the given symbol 'oldSymbol' with the
   /// provided symbol 'newSymbol' that are nested within the given operation
   /// 'from'. This does not traverse into any nested symbol tables. If there are
   /// any unknown operations that may potentially be symbol tables, no uses are
   /// replaced and failure is returned.
-  LLVM_NODISCARD static LogicalResult replaceAllSymbolUses(StringRef oldSymbol,
-                                                           StringRef newSymbol,
-                                                           Operation *from);
-  LLVM_NODISCARD static LogicalResult
-  replaceAllSymbolUses(Operation *oldSymbol, StringRef newSymbolName,
+  static LogicalResult replaceAllSymbolUses(StringRef oldSymbol,
+  static LogicalResult replaceAllSymbolUses(Operation *oldSymbol,
+                                            StringRef newSymbolName,
                                             Operation *from);
-  LLVM_NODISCARD static LogicalResult
-  replaceAllSymbolUses(StringRef oldSymbol, StringRef newSymbol, Region *from);
-  LLVM_NODISCARD static LogicalResult
-  replaceAllSymbolUses(Operation *oldSymbol, StringRef newSymbolName,
+  static LogicalResult replaceAllSymbolUses(StringRef oldSymbol,
+                                            StringRef newSymbol, Region *from);
+  static LogicalResult replaceAllSymbolUses(Operation *oldSymbol,
+                                            StringRef newSymbolName,
                                             Region *from);
 
 private:
   Operation *symbolTableOp;
 
   /// This is a mapping from a name to the symbol with that name.
   llvm::StringMap<Operation *> symbolTable;
 
   /// This is used when name conflicts are detected.

mlir/include/mlir/Pass/PassManager.h

PassManager(MLIRContext *ctx, Nesting nesting = Nesting::Explicit,
               StringRef operationName = "module");
   PassManager(MLIRContext *ctx, StringRef operationName)
       : PassManager(ctx, Nesting::Explicit, operationName) {}
   ~PassManager();
 
   /// Run the passes within this manager on the provided operation. The
   /// specified operation must have the same name as the one provided the pass
   /// manager on construction.
-  LLVM_NODISCARD
   LogicalResult run(Operation *op);
 
   /// Return an instance of the context.
   MLIRContext *getContext() const { return context; }
 
   /// Enable support for the pass manager to generate a reproducer on the event
   /// of a crash or a pass failure. `outputFile` is a .mlir filename used to
   /// write the generated reproducer. If `genLocalReproducer` is true, the pass

mlir/include/mlir/Support/LogicalResult.h

 //===- LogicalResult.h - Utilities for handling success/failure -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_SUPPORT_LOGICAL_RESULT_H
 #define MLIR_SUPPORT_LOGICAL_RESULT_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/Optional.h"
 
 namespace mlir {
 
-/// Values that can be used to signal success/failure. This should be used in
-/// conjunction with the utility functions below.
-struct LogicalResult {
-  enum ResultEnum { Success, Failure } value;
-  LogicalResult(ResultEnum v) : value(v) {}
+/// This class represents an efficient way to signal success or failure. It
+/// should be preferred over the use of `bool` when appropriate, as it avoids
+/// all of the ambiguity that arises in interpreting a boolean result. This
+/// class is marked as NODISCARD to ensure that the result is processed. Users
+/// may explicitly discard a result by using `(void)`, e.g.
+/// `(void)functionThatReturnsALogicalResult();`. Given the intended nature of
+/// this class, it generally shouldn't be used as the result of functions that
+/// very frequently have the result ignored. This class is intended to be used
+/// in conjunction with the utility functions below.
+struct LLVM_NODISCARD LogicalResult {
+public:
+  /// If isSuccess is true a `success` result is generated, otherwise a
+  /// 'failure' result is generated.
+  static LogicalResult success(bool isSuccess = true) {
+    return LogicalResult(isSuccess);
+  }
+
+  /// If isFailure is true a `failure` result is generated, otherwise a
+  /// 'success' result is generated.
+  static LogicalResult failure(bool isFailure = true) {
+    return success(!isFailure);
+  }
+
+  /// Returns true if the provided LogicalResult corresponds to a success value.
+  bool succeeded() const { return isSuccess; }
+
+  /// Returns true if the provided LogicalResult corresponds to a failure value.
+  bool failed() const { return !succeeded(); }
+
+private:
+  LogicalResult(bool isSuccess) : isSuccess(isSuccess) {}
+
+  /// Boolean indicating if this is a success result, if false this is a
+  /// failure result.
+  bool isSuccess;
 };
 
 /// Utility function to generate a LogicalResult. If isSuccess is true a
 /// `success` result is generated, otherwise a 'failure' result is generated.
 inline LogicalResult success(bool isSuccess = true) {
-  return LogicalResult{isSuccess ? LogicalResult::Success
-                                 : LogicalResult::Failure};
+  return LogicalResult::success(isSuccess);
 }
 
 /// Utility function to generate a LogicalResult. If isFailure is true a
 /// `failure` result is generated, otherwise a 'success' result is generated.
 inline LogicalResult failure(bool isFailure = true) {
-  return LogicalResult{isFailure ? LogicalResult::Failure
-                                 : LogicalResult::Success};
+  return LogicalResult::failure(isFailure);
 }
 
 /// Utility function that returns true if the provided LogicalResult corresponds
 /// to a success value.
-inline bool succeeded(LogicalResult result) {
-  return result.value == LogicalResult::Success;
-}
+inline bool succeeded(LogicalResult result) { return result.succeeded(); }
 
 /// Utility function that returns true if the provided LogicalResult corresponds
 /// to a failure value.
-inline bool failed(LogicalResult result) {
-  return result.value == LogicalResult::Failure;
-}
+inline bool failed(LogicalResult result) { return result.failed(); }
 
 /// This class provides support for representing a failure result, or a valid
 /// value of type `T`. This allows for integrating with LogicalResult, while
 /// also providing a value on the success path.
 template <typename T> class LLVM_NODISCARD FailureOr : public Optional<T> {
 public:
   /// Allow constructing from a LogicalResult. The result *must* be a failure.
   /// Success results should use a proper instance of type `T`.

mlir/include/mlir/Transforms/DialectConversion.h

 /// Apply a partial conversion on the given operations and all nested
 /// operations. This method converts as many operations to the target as
 /// possible, ignoring operations that failed to legalize. This method only
 /// returns failure if there ops explicitly marked as illegal. If an
 /// `unconvertedOps` set is provided, all operations that are found not to be
 /// legalizable to the given `target` are placed within that set. (Note that if
 /// there is an op explicitly marked as illegal, the conversion terminates and
 /// the `unconvertedOps` set will not necessarily be complete.)
-LLVM_NODISCARD LogicalResult
+LogicalResult
 applyPartialConversion(ArrayRef<Operation *> ops, ConversionTarget &target,
                        const FrozenRewritePatternList &patterns,
                        DenseSet<Operation *> *unconvertedOps = nullptr);
-LLVM_NODISCARD LogicalResult
+LogicalResult
 applyPartialConversion(Operation *op, ConversionTarget &target,
                        const FrozenRewritePatternList &patterns,
                        DenseSet<Operation *> *unconvertedOps = nullptr);
 
 /// Apply a complete conversion on the given operations, and all nested
 /// operations. This method returns failure if the conversion of any operation
 /// fails, or if there are unreachable blocks in any of the regions nested
 /// within 'ops'.
-LLVM_NODISCARD LogicalResult
-applyFullConversion(ArrayRef<Operation *> ops, ConversionTarget &target,
+LogicalResult applyFullConversion(ArrayRef<Operation *> ops,
+                                  ConversionTarget &target,
                                   const FrozenRewritePatternList &patterns);
-LLVM_NODISCARD LogicalResult
-applyFullConversion(Operation *op, ConversionTarget &target,
+LogicalResult applyFullConversion(Operation *op, ConversionTarget &target,
                                   const FrozenRewritePatternList &patterns);
 
 /// Apply an analysis conversion on the given operations, and all nested
 /// operations. This method analyzes which operations would be successfully
 /// converted to the target if a conversion was applied. All operations that
 /// were found to be legalizable to the given 'target' are placed within the
 /// provided 'convertedOps' set; note that no actual rewrites are applied to the
 /// operations on success and only pre-existing operations are added to the set.
 /// This method only returns failure if there are unreachable blocks in any of
 /// the regions nested within 'ops'.
-LLVM_NODISCARD LogicalResult
-applyAnalysisConversion(ArrayRef<Operation *> ops, ConversionTarget &target,
+LogicalResult applyAnalysisConversion(ArrayRef<Operation *> ops,
+                                      ConversionTarget &target,
                                       const FrozenRewritePatternList &patterns,
                                       DenseSet<Operation *> &convertedOps);
-LLVM_NODISCARD LogicalResult
-applyAnalysisConversion(Operation *op, ConversionTarget &target,
+LogicalResult applyAnalysisConversion(Operation *op, ConversionTarget &target,
                                       const FrozenRewritePatternList &patterns,
                                       DenseSet<Operation *> &convertedOps);
 } // end namespace mlir
 
 #endif // MLIR_TRANSFORMS_DIALECTCONVERSION_H_

mlir/include/mlir/Transforms/LoopUtils.h

 /// their body into the containing Block.
 void promoteSingleIterationLoops(FuncOp f);
 
 /// Skew the operations in an affine.for's body with the specified
 /// operation-wise shifts. The shifts are with respect to the original execution
 /// order, and are multiplied by the loop 'step' before being applied. If
 /// `unrollPrologueEpilogue` is set, fully unroll the prologue and epilogue
 /// loops when possible.
-LLVM_NODISCARD
 LogicalResult affineForOpBodySkew(AffineForOp forOp, ArrayRef<uint64_t> shifts,
                                   bool unrollPrologueEpilogue = false);
 
 /// Identify valid and profitable bands of loops to tile. This is currently just
 /// a temporary placeholder to test the mechanics of tiled code generation.
 /// Returns all maximal outermost perfect loop nests to tile.
 void getTileableBands(FuncOp f,
                       std::vector<SmallVector<AffineForOp, 6>> *bands);
 
 /// Tiles the specified band of perfectly nested loops creating tile-space loops
 /// and intra-tile loops. A band is a contiguous set of loops.
-LLVM_NODISCARD
 LogicalResult
 tilePerfectlyNested(MutableArrayRef<AffineForOp> input,
                     ArrayRef<unsigned> tileSizes,
                     SmallVectorImpl<AffineForOp> *tiledNest = nullptr);
 
 /// Tiles the specified band of perfectly nested loops creating tile-space
 /// loops and intra-tile loops, using SSA values as tiling parameters. A band
 /// is a contiguous set of loops.
-LLVM_NODISCARD
 LogicalResult tilePerfectlyNestedParametric(
     MutableArrayRef<AffineForOp> input, ArrayRef<Value> tileSizes,
     SmallVectorImpl<AffineForOp> *tiledNest = nullptr);
 
 /// Performs loop interchange on 'forOpA' and 'forOpB'. Requires that 'forOpA'
 /// and 'forOpB' are part of a perfectly nested sequence of loops.
 void interchangeLoops(AffineForOp forOpA, AffineForOp forOpB);
 

mlir/lib/Analysis/Presburger/Simplex.cpp

LogicalResult Simplex::restoreRow(Unknown &u) {
 
   while (tableau(u.pos, 1) < 0) {
     Optional<Pivot> maybePivot = findPivot(u.pos, Direction::Up);
     if (!maybePivot)
       break;
 
     pivot(*maybePivot);
     if (u.orientation == Orientation::Column)
-      return LogicalResult::Success; // the unknown is unbounded above.
+      return success(); // the unknown is unbounded above.
   }
   return success(tableau(u.pos, 1) >= 0);
 }
 
 /// Find a row that can be used to pivot the column in the specified direction.
 /// This returns an empty optional if and only if the column is unbounded in the
 /// specified direction (ignoring skipRow, if skipRow is set).
 ///
if (!pivotRow)
       return {};
     pivot(*pivotRow, column);
   }
 
   unsigned row = u.pos;
   Optional<Fraction> optimum = computeRowOptimum(direction, row);
   if (u.restricted && direction == Direction::Down &&
       (!optimum || *optimum < Fraction(0, 1)))
-    restoreRow(u);
+    (void)restoreRow(u);
   return optimum;
 }
 
 bool Simplex::isBoundedAlongConstraint(unsigned constraintIndex) {
   assert(!empty && "It is not meaningful to ask whether a direction is bounded "
                    "in an empty set.");
   // The constraint's perpendicular is already bounded below, since it is a
   // constraint. If it is also bounded above, we can return true.
if (u.orientation == Orientation::Column) {
       pivot(*pivotRow, column);
     }
 
     unsigned row = u.pos;
     Optional<Fraction> minimum = computeRowOptimum(Direction::Down, row);
     if (!minimum || *minimum < Fraction(0, 1)) {
       // Constraint is unbounded below or can attain negative sample values and
       // hence is not redundant.
-      restoreRow(u);
+      (void)restoreRow(u);
       continue;
     }
 
     markRowRedundant(u);
   }
 }
 
 bool Simplex::isUnbounded() {

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

static Value getIdentityValue(AtomicRMWKind op, OpBuilder &builder,
   case AtomicRMWKind::addi:
     return builder.create<ConstantOp>(loc, builder.getI32IntegerAttr(0));
   case AtomicRMWKind::mulf:
     return builder.create<ConstantOp>(loc, builder.getF32FloatAttr(1));
   case AtomicRMWKind::muli:
     return builder.create<ConstantOp>(loc, builder.getI32IntegerAttr(1));
   // TODO: Add remaining reduction operations.
   default:
-    emitOptionalError(loc, "Reduction operation type not supported");
+    (void)emitOptionalError(loc, "Reduction operation type not supported");
+    break;
   }
   return nullptr;
 }
 
 /// Return the value obtained by applying the reduction operation kind
 /// associated with a binary AtomicRMWKind op to `lhs` and `rhs`.
 static Value getReductionOp(AtomicRMWKind op, OpBuilder &builder, Location loc,
                             Value lhs, Value rhs) {
   switch (op) {
   case AtomicRMWKind::addf:
     return builder.create<AddFOp>(loc, lhs, rhs);
   case AtomicRMWKind::addi:
     return builder.create<AddIOp>(loc, lhs, rhs);
   case AtomicRMWKind::mulf:
     return builder.create<MulFOp>(loc, lhs, rhs);
   case AtomicRMWKind::muli:
     return builder.create<MulIOp>(loc, lhs, rhs);
   // TODO: Add remaining reduction operations.
   default:
-    emitOptionalError(loc, "Reduction operation type not supported");
+    (void)emitOptionalError(loc, "Reduction operation type not supported");
+    break;
   }
   return nullptr;
 }
 
 /// Convert an `affine.parallel` (loop nest) operation into a `scf.parallel`
 /// operation.
 class AffineParallelLowering : public OpRewritePattern<AffineParallelOp> {
 public:

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

void runOnOperation() override {
     });
 
     OwningRewritePatternList patterns, llvmPatterns;
 
     // Apply in-dialect lowering first. In-dialect lowering will replace ops
     // which need to be lowered further, which is not supported by a single
     // conversion pass.
     populateGpuRewritePatterns(m.getContext(), patterns);
-    applyPatternsAndFoldGreedily(m, std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(m, std::move(patterns));
 
     populateStdToLLVMConversionPatterns(converter, llvmPatterns);
     populateGpuToNVVMConversionPatterns(converter, llvmPatterns);
     LLVMConversionTarget target(getContext());
     configureGpuToNVVMConversionLegality(target);
     if (failed(applyPartialConversion(m, target, std::move(llvmPatterns))))
       signalPassFailure();
   }

mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp

LowerToLLVMOptions options = {/*useBarePtrCallConv =*/false,
                                   /*emitCWrappers =*/true,
                                   /*indexBitwidth =*/indexBitwidth,
                                   /*useAlignedAlloc =*/false};
     LLVMTypeConverter converter(m.getContext(), options);
 
     OwningRewritePatternList patterns, llvmPatterns;
 
     populateGpuRewritePatterns(m.getContext(), patterns);
-    applyPatternsAndFoldGreedily(m, std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(m, std::move(patterns));
 
     populateVectorToLLVMConversionPatterns(converter, llvmPatterns);
     populateVectorToROCDLConversionPatterns(converter, llvmPatterns);
     populateStdToLLVMConversionPatterns(converter, llvmPatterns);
     populateGpuToROCDLConversionPatterns(converter, llvmPatterns);
     LLVMConversionTarget target(getContext());
     configureGpuToROCDLConversionLegality(target);
     if (failed(applyPartialConversion(m, target, std::move(llvmPatterns))))

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp

lowerAsEntryFunction(gpu::GPUFuncOp funcOp, TypeConverter &typeConverter,
 
   rewriter.inlineRegionBefore(funcOp.getBody(), newFuncOp.getBody(),
                               newFuncOp.end());
   if (failed(rewriter.convertRegionTypes(&newFuncOp.getBody(), typeConverter,
                                          &signatureConverter)))
     return nullptr;
   rewriter.eraseOp(funcOp);
 
-  spirv::setABIAttrs(newFuncOp, entryPointInfo, argABIInfo);
+  if (failed(spirv::setABIAttrs(newFuncOp, entryPointInfo, argABIInfo)))
+    return nullptr;
   return newFuncOp;
 }
 
 /// Populates `argABI` with spv.interface_var_abi attributes for lowering
 /// gpu.func to spv.func if no arguments have the attributes set
 /// already. Returns failure if any argument has the ABI attribute set already.
 static LogicalResult
 getDefaultABIAttrs(MLIRContext *context, gpu::GPUFuncOp funcOp,

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

void runOnOperation() override {
     ConversionTarget target(*context);
     target.addLegalDialect<LLVM::LLVMDialect>();
     if (failed(applyPartialConversion(module, target, std::move(patterns))))
       signalPassFailure();
 
     // Finally, modify the kernel function in SPIR-V modules to avoid symbolic
     // conflicts.
     for (auto spvModule : module.getOps<spirv::ModuleOp>())
-      encodeKernelName(spvModule);
+      (void)encodeKernelName(spvModule);
   }
 };
 } // namespace
 
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
 mlir::createLowerHostCodeToLLVMPass() {
   return std::make_unique<LowerHostCodeToLLVM>();
 }

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

 public:
   using SPIRVToLLVMConversion<SPIRVop>::SPIRVToLLVMConversion;
 
   LogicalResult
   matchAndRewrite(SPIRVop op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
 
     if (!op.memory_access().hasValue()) {
-      replaceWithLoadOrStore(op, rewriter, this->typeConverter, /*alignment=*/0,
-                             /*isVolatile=*/false, /*isNonTemporal=*/false);
-      return success();
+      return replaceWithLoadOrStore(
+          op, rewriter, this->typeConverter, /*alignment=*/0,
     }
     auto memoryAccess = op.memory_access().getValue();
     switch (memoryAccess) {
     case spirv::MemoryAccess::Aligned:
     case spirv::MemoryAccess::None:
     case spirv::MemoryAccess::Nontemporal:
     case spirv::MemoryAccess::Volatile: {
       unsigned alignment =
           memoryAccess == spirv::MemoryAccess::Aligned ? *op.alignment() : 0;
       bool isNonTemporal = memoryAccess == spirv::MemoryAccess::Nontemporal;
       bool isVolatile = memoryAccess == spirv::MemoryAccess::Volatile;
-      replaceWithLoadOrStore(op, rewriter, this->typeConverter, alignment,
-                             isVolatile, isNonTemporal);
-      return success();
+      return replaceWithLoadOrStore(op, rewriter, this->typeConverter,
+                                    alignment, isVolatile, isNonTemporal);
     }
     default:
       // There is no support of other memory access attributes.
       return failure();
     }
   }
 };
 

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

if (getTypeConverter()->getOptions().useBarePtrCallConv) {
           // Unranked memref is not supported in the bare pointer calling
           // convention.
           return failure();
         }
         updatedOperands.push_back(newOperand);
       }
     } else {
       updatedOperands = llvm::to_vector<4>(operands);
-      copyUnrankedDescriptors(rewriter, loc, *getTypeConverter(),
-                              op.getOperands().getTypes(), updatedOperands,
+      (void)copyUnrankedDescriptors(rewriter, loc, *getTypeConverter(),
+                                    op.getOperands().getTypes(),
+                                    updatedOperands,
                                     /*toDynamic=*/true);
     }
 
     // If ReturnOp has 0 or 1 operand, create it and return immediately.
     if (numArguments == 0) {
       rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, TypeRange(), ValueRange(),
                                                   op.getAttrs());
       return success();
     }

mlir/lib/Conversion/StandardToSPIRV/LegalizeStandardForSPIRV.cpp

struct SPIRVLegalization final
   void runOnOperation() override;
 };
 } // namespace
 
 void SPIRVLegalization::runOnOperation() {
   OwningRewritePatternList patterns;
   auto *context = &getContext();
   populateStdLegalizationPatternsForSPIRVLowering(context, patterns);
-  applyPatternsAndFoldGreedily(getOperation()->getRegions(),
+  (void)applyPatternsAndFoldGreedily(getOperation()->getRegions(),
                                      std::move(patterns));
 }
 
 std::unique_ptr<Pass> mlir::createLegalizeStdOpsForSPIRVLoweringPass() {
   return std::make_unique<SPIRVLegalization>();
 }

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

createLinalgBodyCalculationForElementwiseOp(Operation *op, ValueRange args,
   // tosa::CeilOp
   if (isa<tosa::CeilOp>(op) && elementTy.isa<FloatType>())
     return rewriter.create<mlir::CeilFOp>(loc, resultTypes, args);
 
   // tosa::FloorOp
   if (isa<tosa::FloorOp>(op) && elementTy.isa<FloatType>())
     return rewriter.create<mlir::FloorFOp>(loc, resultTypes, args);
 
-  rewriter.notifyMatchFailure(
+  (void)rewriter.notifyMatchFailure(
       op, "unhandled op for linalg body calculation for elementwise op");
   return nullptr;
 }
 
 static LogicalResult
 elementwiseMatchAndRewriteHelper(Operation *operation,
                                  PatternRewriter &rewriter) {
   auto loc = operation->getLoc();

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVMPass.cpp

 void LowerVectorToLLVMPass::runOnOperation() {
   // Perform progressive lowering of operations on slices and
   // all contraction operations. Also applies folding and DCE.
   {
     OwningRewritePatternList patterns;
     populateVectorToVectorCanonicalizationPatterns(patterns, &getContext());
     populateVectorSlicesLoweringPatterns(patterns, &getContext());
     populateVectorContractLoweringPatterns(patterns, &getContext());
-    applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 
   // Convert to the LLVM IR dialect.
   LLVMTypeConverter converter(&getContext());
   OwningRewritePatternList patterns;
   populateVectorToLLVMMatrixConversionPatterns(converter, patterns);
   populateVectorToLLVMConversionPatterns(
       converter, patterns, reassociateFPReductions, enableIndexOptimizations);

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

ConvertVectorToSCFPass(const VectorTransferToSCFOptions &options) {
     this->fullUnroll = options.unroll;
   }
 
   void runOnFunction() override {
     OwningRewritePatternList patterns;
     auto *context = getFunction().getContext();
     populateVectorToSCFConversionPatterns(
         patterns, context, VectorTransferToSCFOptions().setUnroll(fullUnroll));
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 } // namespace
 
 std::unique_ptr<Pass>
 mlir::createConvertVectorToSCFPass(const VectorTransferToSCFOptions &options) {
   return std::make_unique<ConvertVectorToSCFPass>(options);
 }

mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp

if ((forOp = dyn_cast<AffineForOp>(&*it)) && copyNests.count(forOp) == 0) {
       // the footprint can't be calculated, we assume for now it fits. Recurse
       // inside if footprint for 'forOp' exceeds capacity, or when
       // skipNonUnitStrideLoops is set and the step size is not one.
       bool recurseInner = skipNonUnitStrideLoops ? forOp.getStep() != 1
                                                  : exceedsCapacity(forOp);
       if (recurseInner) {
         // We'll recurse and do the copies at an inner level for 'forInst'.
         // Recurse onto the body of this loop.
-        runOnBlock(forOp.getBody(), copyNests);
+        (void)runOnBlock(forOp.getBody(), copyNests);
       } else {
         // We have enough capacity, i.e., copies will be computed for the
         // portion of the block until 'it', and for 'it', which is 'forOp'. Note
         // that for the latter, the copies are placed just before this loop (for
         // incoming copies) and right after (for outgoing ones).
 
         // Inner loop copies have their own scope - we don't thus update
         // consumed capacity. The footprint check above guarantees this inner
void AffineDataCopyGeneration::runOnFunction() {
   // Nests that are copy-in's or copy-out's; the root AffineForOps of those
   // nests are stored herein.
   DenseSet<Operation *> copyNests;
 
   // Clear recorded copy nests.
   copyNests.clear();
 
   for (auto &block : f)
-    runOnBlock(&block, copyNests);
+    (void)runOnBlock(&block, copyNests);
 
   // Promote any single iteration loops in the copy nests and collect
   // load/stores to simplify.
   SmallVector<Operation *, 4> copyOps;
   for (Operation *nest : copyNests)
     // With a post order walk, the erasure of loops does not affect
     // continuation of the walk or the collection of load/store ops.
     nest->walk([&](Operation *op) {
       if (auto forOp = dyn_cast<AffineForOp>(op))
-        promoteIfSingleIteration(forOp);
+        (void)promoteIfSingleIteration(forOp);
       else if (isa<AffineLoadOp, AffineStoreOp>(op))
         copyOps.push_back(op);
     });
 
   // Promoting single iteration loops could lead to simplification of
   // contained load's/store's, and the latter could anyway also be
   // canonicalized.
   OwningRewritePatternList patterns;
   AffineLoadOp::getCanonicalizationPatterns(patterns, &getContext());
   AffineStoreOp::getCanonicalizationPatterns(patterns, &getContext());
   FrozenRewritePatternList frozenPatterns(std::move(patterns));
   for (Operation *op : copyOps)
-    applyOpPatternsAndFold(op, frozenPatterns);
+    (void)applyOpPatternsAndFold(op, frozenPatterns);
 }

mlir/lib/Dialect/Affine/Transforms/LoopTiling.cpp

for (auto &band : bands) {
     SmallVector<AffineForOp, 6> tiledNest;
     if (failed(tilePerfectlyNested(band, tileSizes, &tiledNest)))
       return signalPassFailure();
 
     // Separate full and partial tiles.
     if (separate) {
       auto intraTileLoops =
           MutableArrayRef<AffineForOp>(tiledNest).drop_front(band.size());
-      separateFullTiles(intraTileLoops);
+      (void)separateFullTiles(intraTileLoops);
     }
   }
 }
 
 constexpr unsigned LoopTiling::kDefaultTileSize;

mlir/lib/Dialect/Affine/Transforms/LoopUnroll.cpp

if (unrollFull && unrollFullThreshold.hasValue()) {
     // so that loops are gathered from innermost to outermost (or else unrolling
     // an outer one may delete gathered inner ones).
     getFunction().walk([&](AffineForOp forOp) {
       Optional<uint64_t> tripCount = getConstantTripCount(forOp);
       if (tripCount.hasValue() && tripCount.getValue() <= unrollFullThreshold)
         loops.push_back(forOp);
     });
     for (auto forOp : loops)
-      loopUnrollFull(forOp);
+      (void)loopUnrollFull(forOp);
     return;
   }
 
   // If the call back is provided, we will recurse until no loops are found.
   FuncOp func = getFunction();
   SmallVector<AffineForOp, 4> loops;
   for (unsigned i = 0; i < numRepetitions || getUnrollFactor; i++) {
     loops.clear();

mlir/lib/Dialect/Affine/Transforms/LoopUnrollAndJam.cpp

 }
 
 void LoopUnrollAndJam::runOnFunction() {
   // Currently, just the outermost loop from the first loop nest is
   // unroll-and-jammed by this pass. However, runOnAffineForOp can be called on
   // any for operation.
   auto &entryBlock = getFunction().front();
   if (auto forOp = dyn_cast<AffineForOp>(entryBlock.front()))
-    loopUnrollJamByFactor(forOp, unrollJamFactor);
+    (void)loopUnrollJamByFactor(forOp, unrollJamFactor);
 }

mlir/lib/Dialect/Affine/Transforms/SimplifyAffineStructures.cpp

for (auto attr : op->getAttrs()) {
         simplifyAndUpdateAttribute(op, attr.first, mapAttr);
       else if (auto setAttr = attr.second.dyn_cast<IntegerSetAttr>())
         simplifyAndUpdateAttribute(op, attr.first, setAttr);
     }
 
     // The simplification of the attribute will likely simplify the op. Try to
     // fold / apply canonicalization patterns when we have affine dialect ops.
     if (isa<AffineForOp, AffineIfOp, AffineApplyOp>(op))
-      applyOpPatternsAndFold(op, frozenPatterns);
+      (void)applyOpPatternsAndFold(op, frozenPatterns);
   });
 }

mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp

if (load.getAffineMap() !=
         b.getMultiDimIdentityMap(load.getMemRefType().getRank())) {
       computeMemoryOpIndices(opInst, load.getAffineMap(), mapOperands, indices);
     } else {
       indices.append(mapOperands.begin(), mapOperands.end());
     }
     auto permutationMap =
         makePermutationMap(opInst, indices, state->strategy->loopToVectorDim);
     if (!permutationMap)
-      return LogicalResult::Failure;
+      return failure();
     LLVM_DEBUG(dbgs() << "\n[early-vect]+++++ permutationMap: ");
     LLVM_DEBUG(permutationMap.print(dbgs()));
     auto transfer = b.create<vector::TransferReadOp>(
         opInst->getLoc(), vectorType, memoryOp.getMemRef(), indices,
         permutationMap);
     state->registerReplacement(opInst, transfer.getOperation());
   } else {
     state->registerTerminal(opInst);
for (auto m : matches) {
       if (failed(analyzeProfitability(m.getMatchedChildren(), 1, patternDepth,
                                       &strategy))) {
         continue;
       }
       vectorizeLoopIfProfitable(m.getMatchedOperation(), 0, patternDepth,
                                 &strategy);
       // TODO: if pattern does not apply, report it; alter the
       // cost/benefit.
-      vectorizeRootMatch(m, strategy);
+      (void)vectorizeRootMatch(m, strategy);
       // TODO: some diagnostics if failure to vectorize occurs.
     }
   }
   LLVM_DEBUG(dbgs() << "\n");
 }
 
 std::unique_ptr<OperationPass<FuncOp>>
 createSuperVectorizePass(ArrayRef<int64_t> virtualVectorSize) {

mlir/lib/Dialect/Affine/Utils/Utils.cpp

LogicalResult mlir::hoistAffineIfOp(AffineIfOp ifOp, bool *folded) {
   // hoisting check to be correct (operands should be composed), and to be more
   // effective (no unused operands). Since the pattern rewriter's folding is
   // entangled with application of patterns, we may fold/end up erasing the op,
   // in which case we return with `folded` being set.
   OwningRewritePatternList patterns;
   AffineIfOp::getCanonicalizationPatterns(patterns, ifOp.getContext());
   bool erased;
   FrozenRewritePatternList frozenPatterns(std::move(patterns));
-  applyOpPatternsAndFold(ifOp, frozenPatterns, &erased);
+  (void)applyOpPatternsAndFold(ifOp, frozenPatterns, &erased);
   if (erased) {
     if (folded)
       *folded = true;
     return failure();
   }
   if (folded)
     *folded = false;
 
LogicalResult mlir::hoistAffineIfOp(AffineIfOp ifOp, bool *folded) {
 
   AffineIfOp hoistedIfOp = ::hoistAffineIfOp(ifOp, hoistOverOp);
   // Nothing to hoist over.
   if (hoistedIfOp == ifOp)
     return failure();
 
   // Canonicalize to remove dead else blocks (happens whenever an 'if' moves up
   // a sequence of affine.fors that are all perfectly nested).
-  applyPatternsAndFoldGreedily(
+  (void)applyPatternsAndFoldGreedily(
       hoistedIfOp->getParentWithTrait<OpTrait::IsIsolatedFromAbove>(),
       frozenPatterns);
 
   return success();
 }
 
 // Return the min expr after replacing the given dim.
 AffineExpr mlir::substWithMin(AffineExpr e, AffineExpr dim, AffineExpr min,

mlir/lib/Dialect/GPU/Transforms/ParallelLoopMapper.cpp

static void mapParallelOp(ParallelOp parallelOp,
   Builder b(ctx);
   SmallVector<ParallelLoopDimMapping, 4> attrs;
   attrs.reserve(parallelOp.getNumLoops());
   for (int i = 0, e = parallelOp.getNumLoops(); i < e; ++i) {
     attrs.push_back(getParallelLoopDimMappingAttr(
         getHardwareIdForMapping(mappingLevel, i), b.getDimIdentityMap(),
         b.getDimIdentityMap()));
   }
-  setMappingAttr(parallelOp, attrs);
+  (void)setMappingAttr(parallelOp, attrs);
   ++mappingLevel;
   // Parallel loop operations are immediately nested, so do not use
   // walk but just iterate over the operations.
   for (Operation &op : *parallelOp.getBody()) {
     if (ParallelOp nested = dyn_cast<ParallelOp>(op))
       mapParallelOp(nested, mappingLevel);
   }
 }
 
 void mlir::greedilyMapParallelSCFToGPU(Region &region) {
   region.walk([](ParallelOp parallelOp) { mapParallelOp(parallelOp); });
 }

mlir/lib/Dialect/Linalg/Transforms/CodegenStrategy.cpp

if (enableLICM) {
           llvm_unreachable("unexpected LICM failure");
       });
     }
     promoteSingleIterationLoops(cast<FuncOp>(op));
     hoistViewAllocOps(cast<FuncOp>(op));
     hoistRedundantVectorTransfers(cast<FuncOp>(op));
     return success();
   };
-  linalg::applyStagedPatterns(func, stage1Patterns, std::move(stage2Patterns),
-                              stage3Transforms);
+  (void)linalg::applyStagedPatterns(
+      func, stage1Patterns, std::move(stage2Patterns), stage3Transforms);
 
   //===--------------------------------------------------------------------===//
   // Post staged patterns transforms
   //===--------------------------------------------------------------------===//
 
   // Programmatic splitting of slow/fast path vector transfers.
   OwningRewritePatternList patterns;
   patterns.insert<vector::VectorTransferFullPartialRewriter>(
       context, vectorTransformsOptions);
-  applyPatternsAndFoldGreedily(func, std::move(patterns));
+  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
 
   // Programmatic controlled lowering of vector.contract only.
   OwningRewritePatternList vectorContractLoweringPatterns;
   vectorContractLoweringPatterns
       .insert<ContractionOpToOuterProductOpLowering,
               ContractionOpToMatmulOpLowering, ContractionOpLowering>(
           vectorTransformsOptions, context);
-  applyPatternsAndFoldGreedily(func, std::move(vectorContractLoweringPatterns));
+  (void)applyPatternsAndFoldGreedily(func,
+                                     std::move(vectorContractLoweringPatterns));
 
   // Programmatic controlled lowering of vector.transfer only.
   OwningRewritePatternList vectorToLoopsPatterns;
   populateVectorToSCFConversionPatterns(vectorToLoopsPatterns, context,
                                         vectorToSCFOptions);
-  applyPatternsAndFoldGreedily(func, std::move(vectorToLoopsPatterns));
+  (void)applyPatternsAndFoldGreedily(func, std::move(vectorToLoopsPatterns));
 
   // Ensure we drop the marker in the end.
   func.walk([](LinalgOp op) {
     op.removeAttr(LinalgTransforms::kLinalgTransformMarker);
   });
 }

mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp

LogicalResult matchAndRewrite(GenericOpTy op,
     for (auto attr : llvm::enumerate(iteratorTypes)) {
       if (!unitDims.count(attr.index()))
         newIteratorTypes.push_back(attr.value());
     }
 
     rewriter.startRootUpdate(op);
     op.indexing_mapsAttr(newIndexingMapAttr);
     op.iterator_typesAttr(ArrayAttr::get(newIteratorTypes, context));
-    replaceBlockArgForUnitDimLoops(op, unitDims, rewriter);
+    (void)replaceBlockArgForUnitDimLoops(op, unitDims, rewriter);
     rewriter.finalizeRootUpdate(op);
     return success();
   }
 };
 
 struct UnitExtentReplacementInfo {
   RankedTensorType type;
   AffineMap indexMap;
void runOnFunction() override {
     OwningRewritePatternList patterns;
     FuncOp funcOp = getFunction();
     MLIRContext *context = funcOp.getContext();
     if (foldOneTripLoopsOnly)
       patterns.insert<FoldUnitDimLoops<GenericOp>,
                       FoldUnitDimLoops<IndexedGenericOp>>(context);
     else
       populateLinalgFoldUnitExtentDimsPatterns(context, patterns);
-    applyPatternsAndFoldGreedily(funcOp.getBody(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(funcOp.getBody(), std::move(patterns));
   }
 };
 } // namespace
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createLinalgFoldUnitExtentDimsPass() {
   return std::make_unique<LinalgFoldUnitExtentDimsPass>();
 }

mlir/lib/Dialect/Linalg/Transforms/FusionOnTensors.cpp

 
 /// Pass that fuses generic ops on tensors. Used only for testing.
 struct FusionOfTensorOpsPass
     : public LinalgFusionOfTensorOpsBase<FusionOfTensorOpsPass> {
   void runOnOperation() override {
     OwningRewritePatternList patterns;
     Operation *op = getOperation();
     populateLinalgTensorOpsFusionPatterns(op->getContext(), patterns);
-    applyPatternsAndFoldGreedily(op->getRegions(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(op->getRegions(), std::move(patterns));
   }
 };
 
 /// Pass to test folding of reshape op with generic/indexed_generic ops by
 /// linearization.
 struct FoldReshapeOpsByLinearizationPass
     : public LinalgFoldReshapeOpsByLinearizationBase<
           FoldReshapeOpsByLinearizationPass> {
   void runOnOperation() override {
     OwningRewritePatternList patterns;
     Operation *op = getOperation();
     populateFoldReshapeOpsByLinearizationPatterns(op->getContext(), patterns);
-    applyPatternsAndFoldGreedily(op->getRegions(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(op->getRegions(), std::move(patterns));
   }
 };
 
 } // namespace
 
 void mlir::populateFoldReshapeOpsByLinearizationPatterns(
     MLIRContext *context, OwningRewritePatternList &patterns) {
   patterns.insert<FoldProducerReshapeOpByLinearization<GenericOp, false>,

mlir/lib/Dialect/Linalg/Transforms/Generalization.cpp

 
 } // namespace
 
 void LinalgGeneralizationPass::runOnFunction() {
   FuncOp func = getFunction();
   OwningRewritePatternList patterns;
   linalg::populateLinalgConvGeneralizationPatterns(&getContext(), patterns);
   linalg::populateLinalgNamedOpsGeneralizationPatterns(&getContext(), patterns);
-  applyPatternsAndFoldGreedily(func.getBody(), std::move(patterns));
+  (void)applyPatternsAndFoldGreedily(func.getBody(), std::move(patterns));
 }
 
 linalg::GenericOp GeneralizeConvOp::createGenericOp(linalg::ConvOp convOp,
                                                     OpBuilder &builder) const {
   SmallVector<AffineMap, 4> indexingMaps = convOp.getIndexingMaps();
   auto iterators =
       llvm::to_vector<4>(convOp.iterator_types().getAsValueRange<StringAttr>());
   return builder.create<linalg::GenericOp>(

mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp

func.walk([&changed](Operation *op) {
             return isa<ViewLikeOpInterface, DeallocOp>(operand.getOwner());
           })) {
         LLVM_DEBUG(DBGS() << "Found non view-like or dealloc use: bail\n");
         return;
       }
 
       // Move AllocOp before the loop.
       if (isa<AllocOp, AllocaOp>(op))
-        loop.moveOutOfLoop({op});
+        (void)loop.moveOutOfLoop({op});
       else // Move DeallocOp outside of the loop.
         op->moveAfter(loop);
       changed = true;
     });
   }
 }
 
 /// Look for a transfer_read, in the given tensor uses, accessing the same

mlir/lib/Dialect/Linalg/Transforms/Loops.cpp

static void lowerLinalgToLoopsImpl(FuncOp funcOp,
                                    ArrayRef<unsigned> interchangeVector) {
   MLIRContext *context = funcOp.getContext();
   OwningRewritePatternList patterns;
   patterns.insert<LinalgRewritePattern<LoopType>>(interchangeVector);
   DimOp::getCanonicalizationPatterns(patterns, context);
   AffineApplyOp::getCanonicalizationPatterns(patterns, context);
   patterns.insert<FoldAffineOp>(context);
   // Just apply the patterns greedily.
-  applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
+  (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
 }
 
 namespace {
 /// Local folding pattern for AffineApplyOp that we can apply greedily.
 /// This replaces AffineApplyOp by the proper value in cases where the
 /// associated map is trivial.
 /// A trivial map here is defined as a map with a single result and either:
 ///   1. Zero operand + returns a single AffineConstantExpr

mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp

promoteSubViews(OpBuilder &b, LinalgOp op,
   for (auto viewAndPartialLocalView : writebackViews) {
     if (failed(options.copyOutFn(b, viewAndPartialLocalView.second,
                                  viewAndPartialLocalView.first)))
       return {};
   }
 
   // 4. Dealloc all local buffers.
   for (const auto &pi : *promotedBuffersAndViews)
-    options.deallocationFn(b, pi.second.fullLocalView);
+    (void)options.deallocationFn(b, pi.second.fullLocalView);
   return op;
 }
 
 LogicalResult
 mlir::linalg::promoteSubviewsPrecondition(Operation *op,
                                           LinalgPromotionOptions options) {
   LinalgOp linOp = dyn_cast<LinalgOp>(op);
   // Transformation applies to buffers only.

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

 static void applyTilingToLoopPatterns(LinalgTilingLoopType loopType,
                                       FuncOp funcOp,
                                       ArrayRef<int64_t> tileSizes) {
   auto options =
       LinalgTilingOptions().setTileSizes(tileSizes).setLoopType(loopType);
   MLIRContext *ctx = funcOp.getContext();
   OwningRewritePatternList patterns;
   insertTilingPatterns(patterns, options, ctx);
-  applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
-  applyPatternsAndFoldGreedily(funcOp,
-                               getLinalgTilingCanonicalizationPatterns(ctx));
+  (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
+  (void)applyPatternsAndFoldGreedily(
+      funcOp, getLinalgTilingCanonicalizationPatterns(ctx));
   // Drop the marker.
   funcOp.walk([](LinalgOp op) {
     op.removeAttr(LinalgTransforms::kLinalgTransformMarker);
   });
 }
 
 namespace {
 struct LinalgTilingPass : public LinalgTilingBase<LinalgTilingPass> {

mlir/lib/Dialect/Quant/Transforms/ConvertConst.cpp

QuantizedConstRewrite::matchAndRewrite(QuantizeCastOp qbarrier,
   return success();
 }
 
 void ConvertConstPass::runOnFunction() {
   OwningRewritePatternList patterns;
   auto func = getFunction();
   auto *context = &getContext();
   patterns.insert<QuantizedConstRewrite>(context);
-  applyPatternsAndFoldGreedily(func, std::move(patterns));
+  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
 }
 
 std::unique_ptr<OperationPass<FuncOp>> mlir::quant::createConvertConstPass() {
   return std::make_unique<ConvertConstPass>();
 }

mlir/lib/Dialect/Quant/Transforms/ConvertSimQuant.cpp

 
 void ConvertSimulatedQuantPass::runOnFunction() {
   bool hadFailure = false;
   OwningRewritePatternList patterns;
   auto func = getFunction();
   auto ctx = func.getContext();
   patterns.insert<ConstFakeQuantRewrite, ConstFakeQuantPerAxisRewrite>(
       ctx, &hadFailure);
-  applyPatternsAndFoldGreedily(func, std::move(patterns));
+  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
   if (hadFailure)
     signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::quant::createConvertSimulatedQuantPass() {
   return std::make_unique<ConvertSimulatedQuantPass>();
 }

mlir/lib/Dialect/Shape/Transforms/RemoveShapeConstraints.cpp

class RemoveShapeConstraintsPass
     : public RemoveShapeConstraintsBase<RemoveShapeConstraintsPass> {
 
   void runOnFunction() override {
     MLIRContext &ctx = getContext();
 
     OwningRewritePatternList patterns;
     populateRemoveShapeConstraintsPatterns(patterns, &ctx);
 
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 } // namespace
 
 void mlir::populateRemoveShapeConstraintsPatterns(
     OwningRewritePatternList &patterns, MLIRContext *ctx) {
   patterns.insert<RemoveCstrBroadcastableOp, RemoveCstrEqOp>(ctx);
 }
 
 std::unique_ptr<FunctionPass> mlir::createRemoveShapeConstraintsPass() {
   return std::make_unique<RemoveShapeConstraintsPass>();
 }

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

static SubViewVerificationResult isRankReducedType(Type originalType,
 
   // Strided layout logic is relevant for MemRefType only.
   MemRefType original = originalType.cast<MemRefType>();
   MemRefType candidateReduced = candidateReducedType.cast<MemRefType>();
   MLIRContext *c = original.getContext();
   int64_t originalOffset, candidateReducedOffset;
   SmallVector<int64_t, 4> originalStrides, candidateReducedStrides, keepStrides;
   SmallVector<bool, 4> keepMask = optionalMask.getValue();
-  getStridesAndOffset(original, originalStrides, originalOffset);
-  getStridesAndOffset(candidateReduced, candidateReducedStrides,
+  (void)getStridesAndOffset(original, originalStrides, originalOffset);
+  (void)getStridesAndOffset(candidateReduced, candidateReducedStrides,
                             candidateReducedOffset);
 
   // Filter strides based on the mask and check that they are the same
   // as candidateReduced ones.
   unsigned candidateReducedIdx = 0;
   for (unsigned originalIdx = 0; originalIdx < originalRank; ++originalIdx) {
     if (keepMask[originalIdx]) {
       if (originalStrides[originalIdx] !=
           candidateReducedStrides[candidateReducedIdx++])

mlir/lib/Dialect/StandardOps/Transforms/DecomposeCallGraphTypes.cpp

struct DecomposeCallGraphTypesForFuncArgs
   matchAndRewrite(FuncOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const final {
     auto functionType = op.getType();
 
     // Convert function arguments using the provided TypeConverter.
     TypeConverter::SignatureConversion conversion(functionType.getNumInputs());
     for (auto argType : llvm::enumerate(functionType.getInputs())) {
       SmallVector<Type, 2> decomposedTypes;
-      getTypeConverter()->convertType(argType.value(), decomposedTypes);
+      if (failed(typeConverter->convertType(argType.value(), decomposedTypes)))
+        return failure();
       if (!decomposedTypes.empty())
         conversion.addInputs(argType.index(), decomposedTypes);
     }
 
     // If the SignatureConversion doesn't apply, bail out.
     if (failed(rewriter.convertRegionTypes(&op.getBody(), *getTypeConverter(),
                                            &conversion)))
       return failure();
 
     // Update the signature of the function.
     SmallVector<Type, 2> newResultTypes;
-    getTypeConverter()->convertTypes(functionType.getResults(), newResultTypes);
+    if (failed(typeConverter->convertTypes(functionType.getResults(),
+                                           newResultTypes)))
+      return failure();
     rewriter.updateRootInPlace(op, [&] {
       op.setType(rewriter.getFunctionType(conversion.getConvertedTypes(),
                                           newResultTypes));
     });
     return success();
   }
 };
 } // namespace
matchAndRewrite(CallOp op, ArrayRef<Value> operands,
     // the new call op's results that correspond to the old call op's results.
     //
     // expandedResultIndices[i] = "list of new result indices that old result i
     // expanded to".
     SmallVector<Type, 2> newResultTypes;
     SmallVector<SmallVector<unsigned, 2>, 4> expandedResultIndices;
     for (Type resultType : op.getResultTypes()) {
       unsigned oldSize = newResultTypes.size();
-      getTypeConverter()->convertType(resultType, newResultTypes);
+      if (failed(typeConverter->convertType(resultType, newResultTypes)))
+        return failure();
       auto &resultMapping = expandedResultIndices.emplace_back();
       for (unsigned i = oldSize, e = newResultTypes.size(); i < e; i++)
         resultMapping.push_back(i);
     }
 
     CallOp newCallOp = rewriter.create<CallOp>(op.getLoc(), op.getCallee(),
                                                newResultTypes, newOperands);
 

mlir/lib/Dialect/Tosa/Transforms/TosaMakeBroadcastable.cpp

void runOnFunction() override {
     patterns.insert<ConvertTosaOp<tosa::MaximumOp>>(ctx);
     patterns.insert<ConvertTosaOp<tosa::MinimumOp>>(ctx);
     patterns.insert<ConvertTosaOp<tosa::EqualOp>>(ctx);
     patterns.insert<ConvertTosaOp<tosa::GreaterOp>>(ctx);
     patterns.insert<ConvertTosaOp<tosa::GreaterEqualOp>>(ctx);
     patterns.insert<ConvertTosaOp<tosa::LogicalLeftShiftOp>>(ctx);
     patterns.insert<ConvertTosaOp<tosa::ArithmeticRightShiftOp>>(ctx);
     patterns.insert<ConvertTosaOp<tosa::LogicalRightShiftOp>>(ctx);
-    applyPatternsAndFoldGreedily(func, std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
   }
 };
 } // end anonymous namespace
 
 std::unique_ptr<Pass> mlir::tosa::createTosaMakeBroadcastablePass() {
   return std::make_unique<TosaMakeBroadcastable>();
 }

mlir/lib/IR/AsmPrinter.cpp

void AliasInitializer::visit(Type type) {
   }
 }
 
 template <typename T>
 LogicalResult AliasInitializer::generateAlias(
     T symbol, llvm::MapVector<StringRef, std::vector<T>> &aliasToSymbol) {
   SmallString<16> tempBuffer;
   for (const auto &interface : interfaces) {
-    interface.getAlias(symbol, aliasOS);
-    StringRef name = aliasOS.str();
-    if (name.empty())
+    if (failed(interface.getAlias(symbol, aliasOS)))
       continue;
+    StringRef name = aliasOS.str();
+    assert(!name.empty() && "expected valid alias name");
     name = sanitizeIdentifier(name, tempBuffer, /*allowedPunctChars=*/"$_-",
                               /*allowTrailingDigit=*/false);
     name = name.copy(aliasAllocator);
 
     aliasToSymbol[name].push_back(symbol);
     aliasBuffer.clear();
     return success();
   }

mlir/lib/IR/BuiltinTypes.cpp

 /// pass in an instance of UnknownLoc.
 MemRefType MemRefType::getImpl(ArrayRef<int64_t> shape, Type elementType,
                                ArrayRef<AffineMap> affineMapComposition,
                                unsigned memorySpace,
                                Optional<Location> location) {
   auto *context = elementType.getContext();
 
   if (!BaseMemRefType::isValidElementType(elementType))
-    return emitOptionalError(location, "invalid memref element type"),
+    return (void)emitOptionalError(location, "invalid memref element type"),
            MemRefType();
 
   for (int64_t s : shape) {
     // Negative sizes are not allowed except for `-1` that means dynamic size.
     if (s < -1)
-      return emitOptionalError(location, "invalid memref size"), MemRefType();
+      return (void)emitOptionalError(location, "invalid memref size"),
+             MemRefType();
   }
 
   // Check that the structure of the composition is valid, i.e. that each
   // subsequent affine map has as many inputs as the previous map has results.
   // Take the dimensionality of the MemRef for the first map.
   auto dim = shape.size();
   unsigned i = 0;
   for (const auto &affineMap : affineMapComposition) {

mlir/lib/Pass/Pass.cpp

 }
 
 void RecoveryReproducerContext::crashHandler(void *) {
   // Walk the current stack of contexts and generate a reproducer for each one.
   // We can't know for certain which one was the cause, so we need to generate
   // a reproducer for all of them.
   std::string ignored;
   for (RecoveryReproducerContext *context : *reproducerSet)
-    context->generate(ignored);
+    (void)context->generate(ignored);
 }
 
 void RecoveryReproducerContext::registerSignalHandler() {
   // Ensure that the handler is only registered once.
   static bool registered =
       (llvm::sys::AddSignalHandler(crashHandler, nullptr), false);
   (void)registered;
 }

mlir/lib/Support/MlirOptMain.cpp

return performActions(os, verifyDiagnostics, verifyPasses, sourceMgr,
                           &context, passPipeline);
   }
 
   SourceMgrDiagnosticVerifierHandler sourceMgrHandler(sourceMgr, &context);
 
   // Do any processing requested by command line flags.  We don't care whether
   // these actions succeed or fail, we only care what diagnostics they produce
   // and whether they match our expectations.
-  performActions(os, verifyDiagnostics, verifyPasses, sourceMgr, &context,
+  (void)performActions(os, verifyDiagnostics, verifyPasses, sourceMgr, &context,
                        passPipeline);
 
   // Verify the diagnostic handler to make sure that each of the diagnostics
   // matched.
   return sourceMgrHandler.verify();
 }
 
 LogicalResult mlir::MlirOptMain(raw_ostream &outputStream,
                                 std::unique_ptr<MemoryBuffer> buffer,

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

if (!ii->getType()->isVoidTy())
       tys.push_back(processType(inst->getType()));
 
     SmallVector<Value, 4> ops;
     ops.reserve(inst->getNumOperands() + 1);
     for (auto &op : ii->arg_operands())
       ops.push_back(processValue(op.get()));
 
     SmallVector<Value, 4> normalArgs, unwindArgs;
-    processBranchArgs(ii, ii->getNormalDest(), normalArgs);
-    processBranchArgs(ii, ii->getUnwindDest(), unwindArgs);
+    (void)processBranchArgs(ii, ii->getNormalDest(), normalArgs);
+    (void)processBranchArgs(ii, ii->getUnwindDest(), unwindArgs);
 
     Operation *op;
     if (llvm::Function *callee = ii->getCalledFunction()) {
       op = b.create<InvokeOp>(loc, tys, b.getSymbolRefAttr(callee->getName()),
                               ops, blocks[ii->getNormalDest()], normalArgs,
                               blocks[ii->getUnwindDest()], unwindArgs);
     } else {
       ops.insert(ops.begin(), processValue(ii->getCalledOperand()));

mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp

LogicalResult spirv::Deserializer::processOpWithoutGrammarAttr(
   if (hasResult)
     opState.addTypes(resultTypes);
   opState.addAttributes(attributes);
   Operation *op = opBuilder.createOperation(opState);
   if (hasResult)
     valueMap[valueID] = op->getResult(0);
 
   if (op->hasTrait<OpTrait::IsTerminator>())
-    clearDebugLine();
+    (void)clearDebugLine();
 
   return success();
 }
 
 LogicalResult spirv::Deserializer::processUndef(ArrayRef<uint32_t> operands) {
   if (operands.size() != 2) {
     return emitError(unknownLoc, "OpUndef instruction must have two operands");
   }

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

LogicalResult spirv::Deserializer::processBranch(ArrayRef<uint32_t> operands) {
 
   auto *target = getOrCreateBlock(operands[0]);
   auto loc = createFileLineColLoc(opBuilder);
   // The preceding instruction for the OpBranch instruction could be an
   // OpLoopMerge or an OpSelectionMerge instruction, in this case they will have
   // the same OpLine information.
   opBuilder.create<spirv::BranchOp>(loc, target);
 
-  clearDebugLine();
+  (void)clearDebugLine();
   return success();
 }
 
 LogicalResult
 spirv::Deserializer::processBranchConditional(ArrayRef<uint32_t> operands) {
   if (!curBlock) {
     return emitError(unknownLoc,
                      "OpBranchConditional must appear inside a block");
spirv::Deserializer::processBranchConditional(ArrayRef<uint32_t> operands) {
   // an OpSelectionMerge instruction, in this case they will have the same
   // OpLine information.
   auto loc = createFileLineColLoc(opBuilder);
   opBuilder.create<spirv::BranchConditionalOp>(
       loc, condition, trueBlock,
       /*trueArguments=*/ArrayRef<Value>(), falseBlock,
       /*falseArguments=*/ArrayRef<Value>(), weights);
 
-  clearDebugLine();
+  (void)clearDebugLine();
   return success();
 }
 
 LogicalResult spirv::Deserializer::processLabel(ArrayRef<uint32_t> operands) {
   if (!curFunction) {
     return emitError(unknownLoc, "OpLabel must appear inside a function");
   }
 

mlir/lib/Target/SPIRV/Serialization/Serialization.cpp

if (!funcID) {
     funcID = getNextID();
     funcIDMap[fnName] = funcID;
   }
   return funcID;
 }
 
 void Serializer::processCapability() {
   for (auto cap : module.vce_triple()->getCapabilities())
-    encodeInstructionInto(capabilities, spirv::Opcode::OpCapability,
+    (void)encodeInstructionInto(capabilities, spirv::Opcode::OpCapability,
                                 {static_cast<uint32_t>(cap)});
 }
 
 void Serializer::processDebugInfo() {
   if (!emitDebugInfo)
     return;
   auto fileLoc = module.getLoc().dyn_cast<FileLineColLoc>();
   auto fileName = fileLoc ? fileLoc.getFilename() : "<unknown>";
   fileID = getNextID();
   SmallVector<uint32_t, 16> operands;
   operands.push_back(fileID);
-  spirv::encodeStringLiteralInto(operands, fileName);
-  encodeInstructionInto(debug, spirv::Opcode::OpString, operands);
+  (void)spirv::encodeStringLiteralInto(operands, fileName);
+  (void)encodeInstructionInto(debug, spirv::Opcode::OpString, operands);
   // TODO: Encode more debug instructions.
 }
 
 void Serializer::processExtension() {
   llvm::SmallVector<uint32_t, 16> extName;
   for (spirv::Extension ext : module.vce_triple()->getExtensions()) {
     extName.clear();
-    spirv::encodeStringLiteralInto(extName, spirv::stringifyExtension(ext));
-    encodeInstructionInto(extensions, spirv::Opcode::OpExtension, extName);
+    (void)spirv::encodeStringLiteralInto(extName,
+                                         spirv::stringifyExtension(ext));
+    (void)encodeInstructionInto(extensions, spirv::Opcode::OpExtension,
+                                extName);
   }
 }
 
 void Serializer::processMemoryModel() {
   uint32_t mm = module->getAttrOfType<IntegerAttr>("memory_model").getInt();
   uint32_t am = module->getAttrOfType<IntegerAttr>("addressing_model").getInt();
 
-  encodeInstructionInto(memoryModel, spirv::Opcode::OpMemoryModel, {am, mm});
+  (void)encodeInstructionInto(memoryModel, spirv::Opcode::OpMemoryModel,
+                              {am, mm});
 }
 
 LogicalResult Serializer::processConstantOp(spirv::ConstantOp op) {
   if (auto resultID = prepareConstant(op.getLoc(), op.getType(), op.value())) {
     valueIDMap[op.getResult()] = resultID;
     return success();
   }
   return failure();
 }
 
 LogicalResult Serializer::processSpecConstantOp(spirv::SpecConstantOp op) {
   if (auto resultID = prepareConstantScalar(op.getLoc(), op.default_value(),
                                             /*isSpec=*/true)) {
     // Emit the OpDecorate instruction for SpecId.
     if (auto specID = op->getAttrOfType<IntegerAttr>("spec_id")) {
       auto val = static_cast<uint32_t>(specID.getInt());
-      emitDecoration(resultID, spirv::Decoration::SpecId, {val});
+      (void)emitDecoration(resultID, spirv::Decoration::SpecId, {val});
     }
 
     specConstIDMap[op.sym_name()] = resultID;
     return processName(resultID, op.sym_name());
   }
   return failure();
 }
 
for (auto index : llvm::seq<uint32_t>(0, constituents.size())) {
     if (!constituentID) {
       return op.emitError("unknown result <id> for specialization constant ")
              << constituentName;
     }
 
     operands.push_back(constituentID);
   }
 
-  encodeInstructionInto(typesGlobalValues,
+  (void)encodeInstructionInto(typesGlobalValues,
                               spirv::Opcode::OpSpecConstantComposite, operands);
   specConstIDMap[op.sym_name()] = resultID;
 
   return processName(resultID, op.sym_name());
 }
 
 LogicalResult
 Serializer::processSpecConstantOperationOp(spirv::SpecConstantOperationOp op) {
   uint32_t typeID = 0;
Serializer::processSpecConstantOperationOp(spirv::SpecConstantOperationOp op) {
 
   // Append operands to the enclosed op to the list of operands.
   for (Value operand : enclosedOp.getOperands()) {
     uint32_t id = getValueID(operand);
     assert(id && "use before def!");
     operands.push_back(id);
   }
 
-  encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpSpecConstantOp,
-                        operands);
+  (void)encodeInstructionInto(typesGlobalValues,
+                              spirv::Opcode::OpSpecConstantOp, operands);
   valueIDMap[op.getResult()] = resultID;
 
   return success();
 }
 
 LogicalResult Serializer::processUndefOp(spirv::UndefOp op) {
   auto undefType = op.getType();
   auto &id = undefValIDMap[undefType];

 } // namespace
 
 LogicalResult Serializer::processFuncOp(spirv::FuncOp op) {
   LLVM_DEBUG(llvm::dbgs() << "-- start function '" << op.getName() << "' --\n");
   assert(functionHeader.empty() && functionBody.empty());
 
   uint32_t fnTypeID = 0;
   // Generate type of the function.
-  processType(op.getLoc(), op.getType(), fnTypeID);
+  (void)processType(op.getLoc(), op.getType(), fnTypeID);
 
   // Add the function definition.
   SmallVector<uint32_t, 4> operands;
   uint32_t resTypeID = 0;
   auto resultTypes = op.getType().getResults();
   if (resultTypes.size() > 1) {
     return op.emitError("cannot serialize function with multiple return types");
   }
   if (failed(processType(op.getLoc(),
                          (resultTypes.empty() ? getVoidType() : resultTypes[0]),
                          resTypeID))) {
     return failure();
   }
   operands.push_back(resTypeID);
   auto funcID = getOrCreateFunctionID(op.getName());
   operands.push_back(funcID);
   operands.push_back(static_cast<uint32_t>(op.function_control()));
   operands.push_back(fnTypeID);
-  encodeInstructionInto(functionHeader, spirv::Opcode::OpFunction, operands);
+  (void)encodeInstructionInto(functionHeader, spirv::Opcode::OpFunction,
+                              operands);
 
   // Add function name.
   if (failed(processName(funcID, op.getName()))) {
     return failure();
   }
 
   // Declare the parameters.
   for (auto arg : op.getArguments()) {
     uint32_t argTypeID = 0;
     if (failed(processType(op.getLoc(), arg.getType(), argTypeID))) {
       return failure();
     }
     auto argValueID = getNextID();
     valueIDMap[arg] = argValueID;
-    encodeInstructionInto(functionHeader, spirv::Opcode::OpFunctionParameter,
+    (void)encodeInstructionInto(functionHeader,
+                                spirv::Opcode::OpFunctionParameter,
                                 {argTypeID, argValueID});
   }
 
   // Process the body.
   if (op.isExternal()) {
     return op.emitError("external function is unhandled");
   }
 
   // Some instructions (e.g., OpVariable) in a function must be in the first
   // block in the function. These instructions will be put in functionHeader.
   // Thus, we put the label in functionHeader first, and omit it from the first
   // block.
-  encodeInstructionInto(functionHeader, spirv::Opcode::OpLabel,
+  (void)encodeInstructionInto(functionHeader, spirv::Opcode::OpLabel,
                               {getOrCreateBlockID(&op.front())});
-  processBlock(&op.front(), /*omitLabel=*/true);
+  (void)processBlock(&op.front(), /*omitLabel=*/true);
   if (failed(visitInPrettyBlockOrder(
           &op.front(), [&](Block *block) { return processBlock(block); },
           /*skipHeader=*/true))) {
     return failure();
   }
 
   // There might be OpPhi instructions who have value references needing to fix.
   for (auto deferredValue : deferredPhiValues) {
LogicalResult Serializer::processVariableOp(spirv::VariableOp op) {
   elidedAttrs.push_back(spirv::attributeName<spirv::StorageClass>());
   for (auto arg : op.getODSOperands(0)) {
     auto argID = getValueID(arg);
     if (!argID) {
       return emitError(op.getLoc(), "operand 0 has a use before def");
     }
     operands.push_back(argID);
   }
-  emitDebugLine(functionHeader, op.getLoc());
-  encodeInstructionInto(functionHeader, spirv::Opcode::OpVariable, operands);
+  (void)emitDebugLine(functionHeader, op.getLoc());
+  (void)encodeInstructionInto(functionHeader, spirv::Opcode::OpVariable,
+                              operands);
   for (auto attr : op->getAttrs()) {
     if (llvm::any_of(elidedAttrs,
                      [&](StringRef elided) { return attr.first == elided; })) {
       continue;
     }
     if (failed(processDecoration(op.getLoc(), resultID, attr))) {
       return failure();
     }
if (auto initializer = varOp.initializer()) {
     if (!initializerID) {
       return emitError(varOp.getLoc(),
                        "invalid usage of undefined variable as initializer");
     }
     operands.push_back(initializerID);
     elidedAttrs.push_back("initializer");
   }
 
-  emitDebugLine(typesGlobalValues, varOp.getLoc());
+  (void)emitDebugLine(typesGlobalValues, varOp.getLoc());
   if (failed(encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpVariable,
                                    operands))) {
     elidedAttrs.push_back("initializer");
     return failure();
   }
 
   // Encode decorations.
   for (auto attr : varOp->getAttrs()) {
if (pointeeStruct && pointeeStruct.isIdentified() &&
       //
       // 1. Prepare an OpTypeForwardPointer with resultID and the ptr storage
       // class as operands.
       SmallVector<uint32_t, 2> forwardPtrOperands;
       forwardPtrOperands.push_back(resultID);
       forwardPtrOperands.push_back(
           static_cast<uint32_t>(ptrType.getStorageClass()));
 
-      encodeInstructionInto(typesGlobalValues,
+      (void)encodeInstructionInto(typesGlobalValues,
                                   spirv::Opcode::OpTypeForwardPointer,
                                   forwardPtrOperands);
 
       // 2. Find the pointee (enclosing) struct.
       auto structType = spirv::StructType::getIdentified(
           module.getContext(), pointeeStruct.getIdentifier());
 
       if (!structType)
         return failure();
 
if (auto runtimeArrayType = type.dyn_cast<spirv::RuntimeArrayType>()) {
     }
     typeEnum = spirv::Opcode::OpTypeRuntimeArray;
     operands.push_back(elementTypeID);
     return processTypeDecoration(loc, runtimeArrayType, resultID);
   }
 
   if (auto structType = type.dyn_cast<spirv::StructType>()) {
     if (structType.isIdentified()) {
-      processName(resultID, structType.getIdentifier());
+      (void)processName(resultID, structType.getIdentifier());
       serializationCtx.insert(structType.getIdentifier());
     }
 
     bool hasOffset = structType.hasOffset();
     for (auto elementIndex :
          llvm::seq<uint32_t>(0, structType.getNumElements())) {
       uint32_t elementTypeID = 0;
       if (failed(processTypeImpl(loc, structType.getElementType(elementIndex),
uint32_t Serializer::prepareArrayConstant(Location loc, Type constType,
   for (Attribute elementAttr : attr) {
     if (auto elementID = prepareConstant(loc, elementType, elementAttr)) {
       operands.push_back(elementID);
     } else {
       return 0;
     }
   }
   spirv::Opcode opcode = spirv::Opcode::OpConstantComposite;
-  encodeInstructionInto(typesGlobalValues, opcode, operands);
+  (void)encodeInstructionInto(typesGlobalValues, opcode, operands);
 
   return resultID;
 }
 
 // TODO: Turn the below function into iterative function, instead of
 // recursive function.
 uint32_t
 Serializer::prepareDenseElementsConstant(Location loc, Type constType,
for (int i = 0; i < shapedType.getDimSize(dim); ++i) {
     if (auto elementID = prepareDenseElementsConstant(
             loc, elementType, valueAttr, dim + 1, index)) {
       operands.push_back(elementID);
     } else {
       return 0;
     }
   }
   spirv::Opcode opcode = spirv::Opcode::OpConstantComposite;
-  encodeInstructionInto(typesGlobalValues, opcode, operands);
+  (void)encodeInstructionInto(typesGlobalValues, opcode, operands);
 
   return resultID;
 }
 
 uint32_t Serializer::prepareConstantScalar(Location loc, Attribute valueAttr,
                                            bool isSpec) {
   if (auto floatAttr = valueAttr.dyn_cast<FloatAttr>()) {
     return prepareConstantFp(loc, floatAttr, isSpec);
uint32_t Serializer::prepareConstantBool(Location loc, BoolAttr boolAttr,
   }
 
   auto resultID = getNextID();
   auto opcode = boolAttr.getValue()
                     ? (isSpec ? spirv::Opcode::OpSpecConstantTrue
                               : spirv::Opcode::OpConstantTrue)
                     : (isSpec ? spirv::Opcode::OpSpecConstantFalse
                               : spirv::Opcode::OpConstantFalse);
-  encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID});
+  (void)encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID});
 
   if (!isSpec) {
     constIDMap[boolAttr] = resultID;
   }
   return resultID;
 }
 
 uint32_t Serializer::prepareConstantInt(Location loc, IntegerAttr intAttr,
uint32_t Serializer::prepareConstantInt(Location loc, IntegerAttr intAttr,
   // type with Signedness of 0, or sign extended when Signedness is 1."
   if (bitwidth == 32 || bitwidth == 16) {
     uint32_t word = 0;
     if (isSigned) {
       word = static_cast<int32_t>(value.getSExtValue());
     } else {
       word = static_cast<uint32_t>(value.getZExtValue());
     }
-    encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID, word});
+    (void)encodeInstructionInto(typesGlobalValues, opcode,
+                                {typeID, resultID, word});
   }
   // According to SPIR-V spec: "When the type's bit width is larger than one
   // word, the literal’s low-order words appear first."
   else if (bitwidth == 64) {
     struct DoubleWord {
       uint32_t word1;
       uint32_t word2;
     } words;
     if (isSigned) {
       words = llvm::bit_cast<DoubleWord>(value.getSExtValue());
     } else {
       words = llvm::bit_cast<DoubleWord>(value.getZExtValue());
     }
-    encodeInstructionInto(typesGlobalValues, opcode,
+    (void)encodeInstructionInto(typesGlobalValues, opcode,
                                 {typeID, resultID, words.word1, words.word2});
   } else {
     std::string valueStr;
     llvm::raw_string_ostream rss(valueStr);
     value.print(rss, /*isSigned=*/false);
 
     emitError(loc, "cannot serialize ")
         << bitwidth << "-bit integer literal: " << rss.str();
     return 0;
uint32_t Serializer::prepareConstantFp(Location loc, FloatAttr floatAttr,
   APFloat value = floatAttr.getValue();
   APInt intValue = value.bitcastToAPInt();
 
   auto opcode =
       isSpec ? spirv::Opcode::OpSpecConstant : spirv::Opcode::OpConstant;
 
   if (&value.getSemantics() == &APFloat::IEEEsingle()) {
     uint32_t word = llvm::bit_cast<uint32_t>(value.convertToFloat());
-    encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID, word});
+    (void)encodeInstructionInto(typesGlobalValues, opcode,
+                                {typeID, resultID, word});
   } else if (&value.getSemantics() == &APFloat::IEEEdouble()) {
     struct DoubleWord {
       uint32_t word1;
       uint32_t word2;
     } words = llvm::bit_cast<DoubleWord>(value.convertToDouble());
-    encodeInstructionInto(typesGlobalValues, opcode,
+    (void)encodeInstructionInto(typesGlobalValues, opcode,
                                 {typeID, resultID, words.word1, words.word2});
   } else if (&value.getSemantics() == &APFloat::IEEEhalf()) {
     uint32_t word =
         static_cast<uint32_t>(value.bitcastToAPInt().getZExtValue());
-    encodeInstructionInto(typesGlobalValues, opcode, {typeID, resultID, word});
+    (void)encodeInstructionInto(typesGlobalValues, opcode,
+                                {typeID, resultID, word});
   } else {
     std::string valueStr;
     llvm::raw_string_ostream rss(valueStr);
     value.print(rss);
 
     emitError(loc, "cannot serialize ")
         << floatAttr.getType() << "-typed float literal: " << rss.str();
     return 0;
Serializer::processBlock(Block *block, bool omitLabel,
   LLVM_DEBUG(block->print(llvm::dbgs()));
   LLVM_DEBUG(llvm::dbgs() << '\n');
   if (!omitLabel) {
     uint32_t blockID = getOrCreateBlockID(block);
     LLVM_DEBUG(llvm::dbgs()
                << "[block] " << block << " (id = " << blockID << ")\n");
 
     // Emit OpLabel for this block.
-    encodeInstructionInto(functionBody, spirv::Opcode::OpLabel, {blockID});
+    (void)encodeInstructionInto(functionBody, spirv::Opcode::OpLabel,
+                                {blockID});
   }
 
   // Emit OpPhi instructions for block arguments, if any.
   if (failed(emitPhiForBlockArguments(block)))
     return failure();
 
   // Process each op in this block except the terminator.
   for (auto &op : llvm::make_range(block->begin(), std::prev(block->end()))) {
for (auto predIndex : llvm::seq<unsigned>(0, predecessors.size())) {
       } else {
         LLVM_DEBUG(llvm::dbgs() << "(id = " << valueId << ")\n");
       }
       phiArgs.push_back(valueId);
       // ... and a parent block <id>.
       phiArgs.push_back(predBlockId);
     }
 
-    encodeInstructionInto(functionBody, spirv::Opcode::OpPhi, phiArgs);
+    (void)encodeInstructionInto(functionBody, spirv::Opcode::OpPhi, phiArgs);
     valueIDMap[arg] = phiID;
   }
 
   return success();
 }
 
 LogicalResult Serializer::processSelectionOp(spirv::SelectionOp selectionOp) {
   // Assign <id>s to all blocks so that branches inside the SelectionOp can
   // resolve properly.
   auto &body = selectionOp.body();
   for (Block &block : body)
     getOrCreateBlockID(&block);
 
   auto *headerBlock = selectionOp.getHeaderBlock();
   auto *mergeBlock = selectionOp.getMergeBlock();
   auto mergeID = getBlockID(mergeBlock);
   auto loc = selectionOp.getLoc();
 
   // Emit the selection header block, which dominates all other blocks, first.
   // We need to emit an OpSelectionMerge instruction before the selection header
   // block's terminator.
   auto emitSelectionMerge = [&]() {
-    emitDebugLine(functionBody, loc);
+    (void)emitDebugLine(functionBody, loc);
     lastProcessedWasMergeInst = true;
-    encodeInstructionInto(
+    (void)encodeInstructionInto(
         functionBody, spirv::Opcode::OpSelectionMerge,
         {mergeID, static_cast<uint32_t>(selectionOp.selection_control())});
   };
   // For structured selection, we cannot have blocks in the selection construct
   // branching to the selection header block. Entering the selection (and
   // reaching the selection header) must be from the block containing the
   // spv.selection op. If there are ops ahead of the spv.selection op in the
   // block, we can "merge" them into the selection header. So here we don't need
LogicalResult Serializer::processLoopOp(spirv::LoopOp loopOp) {
   auto mergeID = getBlockID(mergeBlock);
   auto loc = loopOp.getLoc();
 
   // This LoopOp is in some MLIR block with preceding and following ops. In the
   // binary format, it should reside in separate SPIR-V blocks from its
   // preceding and following ops. So we need to emit unconditional branches to
   // jump to this LoopOp's SPIR-V blocks and jumping back to the normal flow
   // afterwards.
-  encodeInstructionInto(functionBody, spirv::Opcode::OpBranch, {headerID});
+  (void)encodeInstructionInto(functionBody, spirv::Opcode::OpBranch,
+                              {headerID});
 
   // LoopOp's entry block is just there for satisfying MLIR's structural
   // requirements so we omit it and start serialization from the loop header
   // block.
 
   // Emit the loop header block, which dominates all other blocks, first. We
   // need to emit an OpLoopMerge instruction before the loop header block's
   // terminator.
   auto emitLoopMerge = [&]() {
-    emitDebugLine(functionBody, loc);
+    (void)emitDebugLine(functionBody, loc);
     lastProcessedWasMergeInst = true;
-    encodeInstructionInto(
+    (void)encodeInstructionInto(
         functionBody, spirv::Opcode::OpLoopMerge,
         {mergeID, continueID, static_cast<uint32_t>(loopOp.loop_control())});
   };
   if (failed(processBlock(headerBlock, /*omitLabel=*/false, emitLoopMerge)))
     return failure();
 
   // Process all blocks with a depth-first visitor starting from the header
   // block. The loop header block, loop continue block, and loop merge block are
LogicalResult Serializer::processBranchConditionalOp(
   auto falseLabelID = getOrCreateBlockID(condBranchOp.getFalseBlock());
   SmallVector<uint32_t, 5> arguments{conditionID, trueLabelID, falseLabelID};
 
   if (auto weights = condBranchOp.branch_weights()) {
     for (auto val : weights->getValue())
       arguments.push_back(val.cast<IntegerAttr>().getInt());
   }
 
-  emitDebugLine(functionBody, condBranchOp.getLoc());
+  (void)emitDebugLine(functionBody, condBranchOp.getLoc());
   return encodeInstructionInto(functionBody, spirv::Opcode::OpBranchConditional,
                                arguments);
 }
 
 LogicalResult Serializer::processBranchOp(spirv::BranchOp branchOp) {
-  emitDebugLine(functionBody, branchOp.getLoc());
+  (void)emitDebugLine(functionBody, branchOp.getLoc());
   return encodeInstructionInto(functionBody, spirv::Opcode::OpBranch,
                                {getOrCreateBlockID(branchOp.getTarget())});
 }
 
 //===----------------------------------------------------------------------===//
 // Operation
 //===----------------------------------------------------------------------===//
 
if (op->getNumResults() != 0) {
     resultID = getNextID();
     operands.push_back(resultID);
     valueIDMap[op->getResult(0)] = resultID;
   };
 
   for (Value operand : op->getOperands())
     operands.push_back(getValueID(operand));
 
-  emitDebugLine(functionBody, loc);
+  (void)emitDebugLine(functionBody, loc);
 
   if (extInstSet.empty()) {
-    encodeInstructionInto(functionBody, static_cast<spirv::Opcode>(opcode),
-                          operands);
+    (void)encodeInstructionInto(functionBody,
+                                static_cast<spirv::Opcode>(opcode), operands);
   } else {
-    encodeExtensionInstruction(op, extInstSet, opcode, operands);
+    (void)encodeExtensionInstruction(op, extInstSet, opcode, operands);
   }
 
   if (op->getNumResults() != 0) {
     for (auto attr : op->getAttrs()) {
       if (failed(processDecoration(loc, resultID, attr)))
         return failure();
     }
   }
Serializer::processOp<spirv::EntryPointOp>(spirv::EntryPointOp op) {
   if (!funcID) {
     return op.emitError("missing <id> for function ")
            << op.fn()
            << "; function needs to be defined before spv.EntryPoint is "
               "serialized";
   }
   operands.push_back(funcID);
   // Add the name of the function.
-  spirv::encodeStringLiteralInto(operands, op.fn());
+  (void)spirv::encodeStringLiteralInto(operands, op.fn());
 
   // Add the interface values.
   if (auto interface = op.interface()) {
     for (auto var : interface.getValue()) {
       auto id = getVariableID(var.cast<FlatSymbolRefAttr>().getValue());
       if (!id) {
         return op.emitError("referencing undefined global variable."
                             "spv.EntryPoint is at the end of spv.module. All "
Serializer::processOp<spirv::CopyMemoryOp>(spirv::CopyMemoryOp op) {
   elidedAttrs.push_back("source_memory_access");
 
   if (auto attr = op->getAttr("source_alignment")) {
     operands.push_back(static_cast<uint32_t>(
         attr.cast<IntegerAttr>().getValue().getZExtValue()));
   }
 
   elidedAttrs.push_back("source_alignment");
-  emitDebugLine(functionBody, op.getLoc());
-  encodeInstructionInto(functionBody, spirv::Opcode::OpCopyMemory, operands);
+  (void)emitDebugLine(functionBody, op.getLoc());
+  (void)encodeInstructionInto(functionBody, spirv::Opcode::OpCopyMemory,
+                              operands);
 
   return success();
 }
 
 // Pull in auto-generated Serializer::dispatchToAutogenSerialization() and
 // various Serializer::processOp<...>() specializations.
 #define GET_SERIALIZATION_FNS
 #include "mlir/Dialect/SPIRV/IR/SPIRVSerialization.inc"
LogicalResult Serializer::emitDebugLine(SmallVectorImpl<uint32_t> &binary,
 
   if (lastProcessedWasMergeInst) {
     lastProcessedWasMergeInst = false;
     return success();
   }
 
   auto fileLoc = loc.dyn_cast<FileLineColLoc>();
   if (fileLoc)
-    encodeInstructionInto(binary, spirv::Opcode::OpLine,
-                          {fileID, fileLoc.getLine(), fileLoc.getColumn()});
+    (void)encodeInstructionInto(
+        binary, spirv::Opcode::OpLine,
   return success();
 }
 
 namespace mlir {
 LogicalResult spirv::serialize(spirv::ModuleOp module,
                                SmallVectorImpl<uint32_t> &binary,
                                bool emitDebugInfo) {
   if (!module.vce_triple().hasValue())

mlir/lib/Transforms/Canonicalizer.cpp

struct Canonicalizer : public CanonicalizerBase<Canonicalizer> {
   /// execution.
   void initialize(MLIRContext *context) override {
     OwningRewritePatternList owningPatterns;
     for (auto *op : context->getRegisteredOperations())
       op->getCanonicalizationPatterns(owningPatterns, context);
     patterns = std::move(owningPatterns);
   }
   void runOnOperation() override {
-    applyPatternsAndFoldGreedily(getOperation()->getRegions(), patterns);
+    (void)applyPatternsAndFoldGreedily(getOperation()->getRegions(), patterns);
   }
 
   FrozenRewritePatternList patterns;
 };
 } // end anonymous namespace
 
 /// Create a Canonicalizer pass.
 std::unique_ptr<Pass> mlir::createCanonicalizerPass() {
   return std::make_unique<Canonicalizer>();
 }

mlir/lib/Transforms/Inliner.cpp

 LogicalResult InlinerPass::initializeOptions(StringRef options) {
   if (failed(Pass::initializeOptions(options)))
     return failure();
 
   // Initialize the default pipeline builder to use the option string.
   if (!defaultPipelineStr.empty()) {
     std::string defaultPipelineCopy = defaultPipelineStr;
     defaultPipeline = [=](OpPassManager &pm) {
-      parsePassPipeline(defaultPipelineCopy, pm);
+      (void)parsePassPipeline(defaultPipelineCopy, pm);
     };
   } else if (defaultPipelineStr.getNumOccurrences()) {
     defaultPipeline = nullptr;
   }
 
   // Initialize the op specific pass pipelines.
   llvm::StringMap<OpPassManager> pipelines;
   for (StringRef pipeline : opPipelineStrs) {

mlir/lib/Transforms/NormalizeMemRefs.cpp

 void NormalizeMemRefs::normalizeFuncOpMemRefs(FuncOp funcOp,
                                               ModuleOp moduleOp) {
   // Turn memrefs' non-identity layouts maps into ones with identity. Collect
   // alloc ops first and then process since normalizeMemRef replaces/erases ops
   // during memref rewriting.
   SmallVector<AllocOp, 4> allocOps;
   funcOp.walk([&](AllocOp op) { allocOps.push_back(op); });
   for (AllocOp allocOp : allocOps)
-    normalizeMemRef(allocOp);
+    (void)normalizeMemRef(allocOp);
 
   // We use this OpBuilder to create new memref layout later.
   OpBuilder b(funcOp);
 
   FunctionType functionType = funcOp.getType();
   SmallVector<Type, 8> inputTypes;
   // Walk over each argument of a function to perform memref normalization (if
   for (unsigned argIndex :

mlir/lib/Transforms/SCCP.cpp

void SCCPSolver::rewrite(MLIRContext *context,
 
   addToWorklist(initialRegions);
   while (!worklist.empty()) {
     Block *block = worklist.pop_back_val();
 
     // Replace any block arguments with constants.
     builder.setInsertionPointToStart(block);
     for (BlockArgument arg : block->getArguments())
-      replaceWithConstant(builder, folder, arg);
+      (void)replaceWithConstant(builder, folder, arg);
 
     for (Operation &op : llvm::make_early_inc_range(*block)) {
       builder.setInsertionPoint(&op);
 
       // Replace any result with constants.
       bool replacedAll = op.getNumResults() != 0;
       for (Value res : op.getResults())
         replacedAll &= succeeded(replaceWithConstant(builder, folder, res));

mlir/lib/Transforms/Utils/LoopFusionUtils.cpp

if (AffineMap ubMap = srcSlice.ubs[i]) {
       auto ubOperands = srcSlice.ubOperands[i];
       canonicalizeMapAndOperands(&ubMap, &ubOperands);
       forOp.setUpperBound(ubOperands, ubMap);
     }
   }
 
   // Promote any single iteration slice loops.
   for (AffineForOp forOp : sliceLoops)
-    promoteIfSingleIteration(forOp);
+    (void)promoteIfSingleIteration(forOp);
 }
 
 /// Collect loop nest statistics (eg. loop trip count and operation count)
 /// in 'stats' for loop nest rooted at 'forOp'. Returns true on success,
 /// returns false otherwise.
 bool mlir::getLoopNestStats(AffineForOp forOpRoot, LoopNestStats *stats) {
   auto walkResult = forOpRoot.walk([&](AffineForOp forOp) {
     auto *childForOp = forOp.getOperation();

mlir/lib/Transforms/Utils/LoopUtils.cpp

 }
 
 /// Promotes all single iteration 'for' ops in `f`, i.e., moves
 /// their body into the containing Block.
 void mlir::promoteSingleIterationLoops(FuncOp f) {
   // Gathers all innermost loops through a post order pruned walk.
   f.walk([](Operation *op) {
     if (auto forOp = dyn_cast<AffineForOp>(op))
-      promoteIfSingleIteration(forOp);
+      (void)promoteIfSingleIteration(forOp);
     else if (auto forOp = dyn_cast<scf::ForOp>(op))
-      promoteIfSingleIteration(forOp);
+      (void)promoteIfSingleIteration(forOp);
   });
 }
 
 /// Generates an affine.for op with the specified lower and upper bounds
 /// while generating the right IV remappings to realize shifts for operations in
 /// its body. The operations that go into the loop body are specified in
 /// opGroupQueue starting from the specified offset, and in that order. The
 /// first element of the pair specifies the shift applied to that group of
if (!opGroupQueue.empty()) {
         lbShift = d * step;
       }
 
       if (res) {
         // Simplify/canonicalize the affine.for.
         OwningRewritePatternList patterns;
         AffineForOp::getCanonicalizationPatterns(patterns, res.getContext());
         bool erased;
-        applyOpPatternsAndFold(res, std::move(patterns), &erased);
+        (void)applyOpPatternsAndFold(res, std::move(patterns), &erased);
 
         if (!erased && !prologue)
           prologue = res;
         if (!erased)
           epilogue = res;
       }
     } else {
       // Start of first interval.
for (unsigned i = 0, e = opGroupQueue.size(); i < e; ++i) {
     if (!prologue)
       prologue = epilogue;
   }
 
   // Erase the original for op.
   forOp.erase();
 
   if (unrollPrologueEpilogue && prologue)
-    loopUnrollFull(prologue);
+    (void)loopUnrollFull(prologue);
   if (unrollPrologueEpilogue && !epilogue && epilogue != prologue)
-    loopUnrollFull(epilogue);
+    (void)loopUnrollFull(epilogue);
 
   return success();
 }
 
 /// Checks the legality of tiling of a hyper-rectangular loop nest by simply
 /// checking if there is a 'negative' dependence in the memrefs present in
 /// the loop nest. If yes then tiling is invalid.
 static bool

 }
 
 /// Checks whether a loop nest is hyper-rectangular or not.
 LogicalResult checkIfHyperRectangular(MutableArrayRef<AffineForOp> input,
                                       AffineForOp rootAffineForOp,
                                       unsigned width) {
   FlatAffineConstraints cst;
   SmallVector<Operation *, 8> ops(input.begin(), input.end());
-  getIndexSet(ops, &cst);
+  (void)getIndexSet(ops, &cst);
   if (!cst.isHyperRectangular(0, width)) {
     rootAffineForOp.emitError("tiled code generation unimplemented for the "
                               "non-hyperrectangular case");
     return failure();
   }
   return success();
 }
 
if (getLargestDivisorOfTripCount(forOp) % unrollFactor != 0) {
     AffineMap cleanupMap;
     SmallVector<Value, 4> cleanupOperands;
     getCleanupLoopLowerBound(forOp, unrollFactor, cleanupMap, cleanupOperands);
     assert(cleanupMap &&
            "cleanup loop lower bound map for single result lower bound maps "
            "can always be determined");
     cleanupForOp.setLowerBound(cleanupOperands, cleanupMap);
     // Promote the loop body up if this has turned into a single iteration loop.
-    promoteIfSingleIteration(cleanupForOp);
+    (void)promoteIfSingleIteration(cleanupForOp);
 
     // Adjust upper bound of the original loop; this is the same as the lower
     // bound of the cleanup loop.
     forOp.setUpperBound(cleanupOperands, cleanupMap);
   }
 
   // Scale the step of loop being unrolled by unroll factor.
   int64_t step = forOp.getStep();
   forOp.setStep(step * unrollFactor);
   generateUnrolledLoop(forOp.getBody(), forOp.getInductionVar(), unrollFactor,
                        [&](unsigned i, Value iv, OpBuilder b) {
                          // iv' = iv + i * step
                          auto d0 = b.getAffineDimExpr(0);
                          auto bumpMap = AffineMap::get(1, 0, d0 + i * step);
                          return b.create<AffineApplyOp>(forOp.getLoc(), bumpMap,
                                                         iv);
                        },
                        /*iterArgs=*/{}, /*yieldedValues=*/{});
 
   // Promote the loop body up if this has turned into a single iteration loop.
-  promoteIfSingleIteration(forOp);
+  (void)promoteIfSingleIteration(forOp);
   return success();
 }
 
 /// Unrolls 'forOp' by 'unrollFactor', returns success if the loop is unrolled.
 LogicalResult mlir::loopUnrollByFactor(scf::ForOp forOp,
                                        uint64_t unrollFactor) {
   assert(unrollFactor > 0 && "expected positive unroll factor");
   if (unrollFactor == 1)
if (generateEpilogueLoop) {
     auto results = forOp.getResults();
     auto epilogueResults = epilogueForOp.getResults();
     auto epilogueIterOperands = epilogueForOp.getIterOperands();
 
     for (auto e : llvm::zip(results, epilogueResults, epilogueIterOperands)) {
       std::get<0>(e).replaceAllUsesWith(std::get<1>(e));
       epilogueForOp->replaceUsesOfWith(std::get<2>(e), std::get<0>(e));
     }
-    promoteIfSingleIteration(epilogueForOp);
+    (void)promoteIfSingleIteration(epilogueForOp);
   }
 
   // Create unrolled loop.
   forOp.setUpperBound(upperBoundUnrolled);
   forOp.setStep(stepUnrolled);
 
   auto iterArgs = ValueRange(forOp.getRegionIterArgs());
   auto yieldedValues = forOp.getBody()->getTerminator()->getOperands();
 
   generateUnrolledLoop(
       forOp.getBody(), forOp.getInductionVar(), unrollFactor,
       [&](unsigned i, Value iv, OpBuilder b) {
         // iv' = iv + step * i;
         auto stride =
             b.create<MulIOp>(loc, step, b.create<ConstantIndexOp>(loc, i));
         return b.create<AddIOp>(loc, iv, stride);
       },
       iterArgs, yieldedValues);
   // Promote the loop body up if this has turned into a single iteration loop.
-  promoteIfSingleIteration(forOp);
+  (void)promoteIfSingleIteration(forOp);
   return success();
 }
 
 LogicalResult mlir::loopUnrollJamUpToFactor(AffineForOp forOp,
                                             uint64_t unrollJamFactor) {
   Optional<uint64_t> mayBeConstantTripCount = getConstantTripCount(forOp);
   if (mayBeConstantTripCount.hasValue() &&
       mayBeConstantTripCount.getValue() < unrollJamFactor)
if (getLargestDivisorOfTripCount(forOp) % unrollJamFactor != 0) {
     // as the original loop's upper bound.
     AffineMap cleanupMap;
     SmallVector<Value, 4> cleanupOperands;
     getCleanupLoopLowerBound(forOp, unrollJamFactor, cleanupMap,
                              cleanupOperands);
     cleanupAffineForOp.setLowerBound(cleanupOperands, cleanupMap);
 
     // Promote the cleanup loop if it has turned into a single iteration loop.
-    promoteIfSingleIteration(cleanupAffineForOp);
+    (void)promoteIfSingleIteration(cleanupAffineForOp);
 
     // Adjust the upper bound of the original loop - it will be the same as the
     // cleanup loop's lower bound. Its lower bound remains unchanged.
     forOp.setUpperBound(cleanupOperands, cleanupMap);
   }
 
   // Scale the step of loop being unroll-jammed by the unroll-jam factor.
   int64_t step = forOp.getStep();
for (auto &subBlock : subBlocks) {
       }
       // Clone the sub-block being unroll-jammed.
       for (auto it = subBlock.first; it != std::next(subBlock.second); ++it)
         builder.clone(*it, operandMap);
     }
   }
 
   // Promote the loop body up if this has turned into a single iteration loop.
-  promoteIfSingleIteration(forOp);
+  (void)promoteIfSingleIteration(forOp);
   return success();
 }
 
 /// Performs loop interchange on 'forOpA' and 'forOpB', where 'forOpB' is
 /// nested within 'forOpA' as the only non-terminator operation in its block.
 void mlir::interchangeLoops(AffineForOp forOpA, AffineForOp forOpB) {
   assert(&*forOpA.getBody()->begin() == forOpB.getOperation());
   auto &forOpABody = forOpA.getBody()->getOperations();
TileLoops mlir::extractFixedOuterLoops(scf::ForOp rootForOp,
 
   // Call parametric tiling with the given sizes.
   auto intraTile = tile(forOps, tileSizes, forOps.back());
   TileLoops tileLoops = std::make_pair(forOps, intraTile);
 
   // TODO: for now we just ignore the result of band isolation.
   // In the future, mapping decisions may be impacted by the ability to
   // isolate perfectly nested bands.
-  tryIsolateBands(tileLoops);
+  (void)tryIsolateBands(tileLoops);
 
   return tileLoops;
 }
 
 /// Return the new lower bound, upper bound, and step in that order. Insert any
 /// additional bounds calculations before the given builder and any additional
 /// conversion back to the original loop induction value inside the given Block.
 static LoopParams normalizeLoop(OpBuilder &boundsBuilder,
static LogicalResult generateCopy(
 
   // Record the begin since it may be invalidated by memref replacement.
   Block::iterator prevOfBegin;
   bool isBeginAtStartOfBlock = (begin == block->begin());
   if (!isBeginAtStartOfBlock)
     prevOfBegin = std::prev(begin);
 
   // *Only* those uses within the range [begin, end) of 'block' are replaced.
-  replaceAllMemRefUsesWith(memref, fastMemRef,
+  (void)replaceAllMemRefUsesWith(memref, fastMemRef,
                                  /*extraIndices=*/{}, indexRemap,
                                  /*extraOperands=*/regionSymbols,
                                  /*symbolOperands=*/{},
                                  /*domInstFilter=*/&*begin,
                                  /*postDomInstFilter=*/&*postDomFilter);
 
   *nBegin = isBeginAtStartOfBlock ? block->begin() : std::next(prevOfBegin);
 
   return success();
 }
 
 /// Construct the memref region to just include the entire memref. Returns false
 /// dynamic shaped memref's for now. `numParamLoopIVs` is the number of
static AffineIfOp createSeparationCondition(MutableArrayRef<AffineForOp> loops,
 
   auto *context = loops[0].getContext();
 
   FlatAffineConstraints cst;
   SmallVector<Operation *, 8> ops;
   ops.reserve(loops.size());
   for (AffineForOp forOp : loops)
     ops.push_back(forOp);
-  getIndexSet(ops, &cst);
+  (void)getIndexSet(ops, &cst);
 
   // Remove constraints that are independent of these loop IVs.
   cst.removeIndependentConstraints(/*pos=*/0, /*num=*/loops.size());
 
   // Construct the constraint set representing the guard for full tiles. The
   // lower bound (and upper bound) corresponding to the full tile should be
   // larger (and resp. smaller) than any other lower (or upper bound).
   SmallVector<int64_t, 8> fullTileLb, fullTileUb;
createFullTiles(MutableArrayRef<AffineForOp> inputNest,
   for (auto loop : inputNest) {
     // TODO: straightforward to generalize to a non-unit stride.
     if (loop.getStep() != 1) {
       LLVM_DEBUG(llvm::dbgs()
                  << "[tile separation] non-unit stride not implemented\n");
       return failure();
     }
     SmallVector<Operation *, 1> loopOp{loop.getOperation()};
-    getIndexSet(loopOp, &cst);
+    (void)getIndexSet(loopOp, &cst);
     // We will mark everything other than this loop IV as symbol for getting a
     // pair of <lb, ub> with a constant difference.
     cst.setDimSymbolSeparation(cst.getNumDimAndSymbolIds() - 1);
     unsigned lbPos, ubPos;
     if (!cst.getConstantBoundOnDimSize(/*pos=*/0, /*lb=*/nullptr,
                                        /*lbDivisor=*/nullptr, /*ub=*/nullptr,
                                        &lbPos, &ubPos) ||
         lbPos == ubPos) {

mlir/lib/Translation/Translation.cpp

if (!verifyDiagnostics) {
       SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &context);
       return (*translationRequested)(sourceMgr, os, &context);
     }
 
     // In the diagnostic verification flow, we ignore whether the translation
     // failed (in most cases, it is expected to fail). Instead, we check if the
     // diagnostics were produced as expected.
     SourceMgrDiagnosticVerifierHandler sourceMgrHandler(sourceMgr, &context);
-    (*translationRequested)(sourceMgr, os, &context);
+    (void)(*translationRequested)(sourceMgr, os, &context);
     return sourceMgrHandler.verify();
   };
 
   if (splitInputFile) {
     if (failed(splitAndProcessBuffer(std::move(input), processBuffer,
                                      output->os())))
       return failure();
   } else if (failed(processBuffer(std::move(input), output->os()))) {
     return failure();
   }
 
   output->keep();
   return success();
 }

mlir/test/lib/Dialect/Affine/TestAffineDataCopy.cpp

AffineCopyOptions copyOptions = {/*generateDma=*/false,
                                    /*tagMemorySpace=*/0,
                                    /*fastMemCapacityBytes=*/32 * 1024 * 1024UL};
   DenseSet<Operation *> copyNests;
   if (clMemRefFilter) {
     affineDataCopyGenerate(loopNest, copyOptions, load.getMemRef(), copyNests);
   } else if (clTestGenerateCopyForMemRegion) {
     CopyGenerateResult result;
     MemRefRegion region(loopNest.getLoc());
-    region.compute(load, /*loopDepth=*/0);
-    generateCopyForMemRegion(region, loopNest, copyOptions, result);
+    (void)region.compute(load, /*loopDepth=*/0);
+    (void)generateCopyForMemRegion(region, loopNest, copyOptions, result);
   }
 
   // Promote any single iteration loops in the copy nests and simplify
   // load/stores.
   SmallVector<Operation *, 4> copyOps;
   for (auto nest : copyNests)
     // With a post order walk, the erasure of loops does not affect
     // continuation of the walk or the collection of load/store ops.
     nest->walk([&](Operation *op) {
       if (auto forOp = dyn_cast<AffineForOp>(op))
-        promoteIfSingleIteration(forOp);
+        (void)promoteIfSingleIteration(forOp);
       else if (auto loadOp = dyn_cast<AffineLoadOp>(op))
         copyOps.push_back(loadOp);
       else if (auto storeOp = dyn_cast<AffineStoreOp>(op))
         copyOps.push_back(storeOp);
     });
 
   // Promoting single iteration loops could lead to simplification of
   // generated load's/store's, and the latter could anyway also be
   // canonicalized.
   OwningRewritePatternList patterns;
   for (auto op : copyOps) {
     patterns.clear();
     if (isa<AffineLoadOp>(op)) {
       AffineLoadOp::getCanonicalizationPatterns(patterns, &getContext());
     } else {
       assert(isa<AffineStoreOp>(op) && "expected affine store op");
       AffineStoreOp::getCanonicalizationPatterns(patterns, &getContext());
     }
-    applyOpPatternsAndFold(op, std::move(patterns));
+    (void)applyOpPatternsAndFold(op, std::move(patterns));
   }
 }
 
 namespace mlir {
 void registerTestAffineDataCopyPass() {
   PassRegistration<TestAffineDataCopy>(
       PASS_NAME, "Tests affine data copy utility functions.");
 }
 } // namespace mlir

mlir/test/lib/Dialect/Affine/TestVectorizationUtils.cpp

void VectorizerTestPass::testVecAffineLoopNest() {
 
   // We vectorize the outermost loop found with VF=4.
   AffineForOp outermostLoop = loops[0][0];
   VectorizationStrategy strategy;
   strategy.vectorSizes.push_back(4 /*vectorization factor*/);
   strategy.loopToVectorDim[outermostLoop] = 0;
   std::vector<SmallVector<AffineForOp, 2>> loopsToVectorize;
   loopsToVectorize.push_back({outermostLoop});
-  vectorizeAffineLoopNest(loopsToVectorize, strategy);
+  (void)vectorizeAffineLoopNest(loopsToVectorize, strategy);
 }
 
 void VectorizerTestPass::runOnFunction() {
   // Only support single block functions at this point.
   FuncOp f = getFunction();
   if (!llvm::hasSingleElement(f))
     return;
 

mlir/test/lib/Dialect/SPIRV/TestGLSLCanonicalization.cpp

public:
   TestGLSLCanonicalizationPass(const TestGLSLCanonicalizationPass &) {}
   void runOnOperation() override;
 };
 } // namespace
 
 void TestGLSLCanonicalizationPass::runOnOperation() {
   OwningRewritePatternList patterns;
   spirv::populateSPIRVGLSLCanonicalizationPatterns(patterns, &getContext());
-  applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
+  (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
 void registerTestSpirvGLSLCanonicalizationPass() {
   PassRegistration<TestGLSLCanonicalizationPass> registration(
       "test-spirv-glsl-canonicalization",
       "Tests SPIR-V canonicalization patterns for GLSL extension.");
 }
 } // namespace mlir

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

 struct TestPatternDriver : public PassWrapper<TestPatternDriver, FunctionPass> {
   void runOnFunction() override {
     mlir::OwningRewritePatternList patterns;
     populateWithGenerated(&getContext(), patterns);
 
     // Verify named pattern is generated with expected name.
     patterns.insert<FoldingPattern, TestNamedPatternRule>(&getContext());
 
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // ReturnType Driver.
 //===----------------------------------------------------------------------===//
 

 
 struct TestSelectiveReplacementPatternDriver
     : public PassWrapper<TestSelectiveReplacementPatternDriver,
                          OperationPass<>> {
   void runOnOperation() override {
     mlir::OwningRewritePatternList patterns;
     MLIRContext *context = &getContext();
     patterns.insert<TestSelectiveOpReplacementPattern>(context);
-    applyPatternsAndFoldGreedily(getOperation()->getRegions(),
+    (void)applyPatternsAndFoldGreedily(getOperation()->getRegions(),
                                        std::move(patterns));
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // PassRegistration
 //===----------------------------------------------------------------------===//
 

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

OpFoldResult TestInvolutionTraitSuccesfulOperationFolderOp::fold(
   auto argumentOp = getOperand();
   // The success case should cause the trait fold to be supressed.
   return argumentOp.getDefiningOp() ? argumentOp : OpFoldResult{};
 }
 
 namespace {
 struct TestTraitFolder : public PassWrapper<TestTraitFolder, FunctionPass> {
   void runOnFunction() override {
-    applyPatternsAndFoldGreedily(getFunction(), OwningRewritePatternList());
+    (void)applyPatternsAndFoldGreedily(getFunction(),
+                                       OwningRewritePatternList());
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
 void registerTestTraitsPass() {
   PassRegistration<TestTraitFolder>("test-trait-folder", "Run trait folding");
 }
 } // namespace mlir

mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp

 
 void TosaTestQuantUtilAPI::runOnFunction() {
   OwningRewritePatternList patterns;
   auto *ctx = &getContext();
   auto func = getFunction();
 
   patterns.insert<ConvertTosaNegateOp>(ctx);
   patterns.insert<ConvertTosaConv2DOp>(ctx);
-  applyPatternsAndFoldGreedily(func, std::move(patterns));
+  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
 }
 
 } // anonymous namespace
 
 namespace mlir {
 void registerTosaTestQuantUtilAPIPass() {
   PassRegistration<TosaTestQuantUtilAPI>(
       PASS_NAME, "TOSA Test: Exercise the APIs in QuantUtils.cpp.");
 }
 } // namespace mlir

mlir/test/lib/IR/TestSlicing.cpp

void SliceAnalysisTestPass::runOnOperation() {
   for (auto funcOp : funcOps) {
     // TODO: For now this is just looking for Linalg ops. It can be generalized
     // to look for other ops using flags.
     funcOp.walk([&](Operation *op) {
       if (!isa<linalg::LinalgOp>(op))
         return WalkResult::advance();
       std::string append =
           std::string("__backward_slice__") + std::to_string(opNum);
-      createBackwardSliceFunction(op, append);
+      (void)createBackwardSliceFunction(op, append);
       opNum++;
       return WalkResult::advance();
     });
   }
 }
 
 namespace mlir {
 void registerSliceAnalysisTestPass() {
   PassRegistration<SliceAnalysisTestPass> pass(
       "slice-analysis-test", "Test Slice analysis functionality.");
 }
 } // namespace mlir

mlir/test/lib/Transforms/TestConvVectorization.cpp

auto stage3Transforms = [](Operation *op) {
     op->walk([](FuncOp func) {
       promoteSingleIterationLoops(func);
       linalg::hoistViewAllocOps(func);
       linalg::hoistRedundantVectorTransfers(func);
     });
     return success();
   };
 
-  linalg::applyStagedPatterns(module, frozenStage1Patterns,
-                              std::move(stage2Patterns), stage3Transforms);
+  (void)linalg::applyStagedPatterns(module, frozenStage1Patterns,
+                                    std::move(stage2Patterns),
+                                    stage3Transforms);
 
   //===--------------------------------------------------------------------===//
   // Post staged patterns transforms
   //===--------------------------------------------------------------------===//
 
   VectorTransformsOptions vectorTransformsOptions{
       VectorContractLowering::Dot, VectorTransposeLowering::EltWise};
 
   OwningRewritePatternList vectorTransferPatterns;
   // Pattern is not applied because rank-reducing vector transfer is not yet
   // supported as can be seen in splitFullAndPartialTransferPrecondition,
   // VectorTransforms.cpp
   vectorTransferPatterns.insert<VectorTransferFullPartialRewriter>(
       context, vectorTransformsOptions);
-  applyPatternsAndFoldGreedily(module, std::move(vectorTransferPatterns));
+  (void)applyPatternsAndFoldGreedily(module, std::move(vectorTransferPatterns));
 
   // Programmatic controlled lowering of linalg.copy and linalg.fill.
   PassManager pm(context);
   pm.addNestedPass<FuncOp>(createConvertLinalgToLoopsPass());
   if (failed(pm.run(module)))
     llvm_unreachable("Unexpected failure in linalg to loops pass.");
 
   // Programmatic controlled lowering of vector.contract only.
   OwningRewritePatternList vectorContractLoweringPatterns;
   populateVectorContractLoweringPatterns(vectorContractLoweringPatterns,
                                          context, vectorTransformsOptions);
-  applyPatternsAndFoldGreedily(module,
+  (void)applyPatternsAndFoldGreedily(module,
                                      std::move(vectorContractLoweringPatterns));
 
   // Programmatic controlled lowering of vector.transfer only.
   OwningRewritePatternList vectorToLoopsPatterns;
   populateVectorToSCFConversionPatterns(vectorToLoopsPatterns, context,
                                         VectorTransferToSCFOptions());
-  applyPatternsAndFoldGreedily(module, std::move(vectorToLoopsPatterns));
+  (void)applyPatternsAndFoldGreedily(module, std::move(vectorToLoopsPatterns));
 
   // Ensure we drop the marker in the end.
   module.walk([](linalg::LinalgOp op) {
     op.removeAttr(linalg::LinalgTransforms::kLinalgTransformMarker);
   });
 }
 
 namespace mlir {
 namespace test {
 void registerTestConvVectorization() {
   PassRegistration<TestConvVectorization> testTransformPatternsPass(
       "test-conv-vectorization", "Test vectorization of convolutions");
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestDynamicPipeline.cpp

 namespace {
 
 class TestDynamicPipelinePass
     : public PassWrapper<TestDynamicPipelinePass, OperationPass<>> {
 public:
   void getDependentDialects(DialectRegistry &registry) const override {
     OpPassManager pm(ModuleOp::getOperationName(),
                      OpPassManager::Nesting::Implicit);
-    parsePassPipeline(pipeline, pm, llvm::errs());
+    (void)parsePassPipeline(pipeline, pm, llvm::errs());
     pm.getDependentDialects(registry);
   }
 
   TestDynamicPipelinePass(){};
   TestDynamicPipelinePass(const TestDynamicPipelinePass &) {}
 
   void runOnOperation() override {
     Operation *currentOp = getOperation();
void runOnOperation() override {
     auto opName = symbolOp.getName();
     if (!opNames.empty() && !llvm::is_contained(opNames, opName)) {
       llvm::errs() << "dynamic-pipeline skip op name: " << opName << "\n";
       return;
     }
     if (!pm) {
       pm = std::make_unique<OpPassManager>(currentOp->getName().getIdentifier(),
                                            OpPassManager::Nesting::Implicit);
-      parsePassPipeline(pipeline, *pm, llvm::errs());
+      (void)parsePassPipeline(pipeline, *pm, llvm::errs());
     }
 
     // Check that running on the parent operation always immediately fails.
     if (runOnParent) {
       if (currentOp->getParentOp())
         if (!failed(runPipeline(*pm, currentOp->getParentOp())))
           signalPassFailure();
       return;

mlir/test/lib/Transforms/TestExpandTanh.cpp

struct TestExpandTanhPass
     : public PassWrapper<TestExpandTanhPass, FunctionPass> {
   void runOnFunction() override;
 };
 } // end anonymous namespace
 
 void TestExpandTanhPass::runOnFunction() {
   OwningRewritePatternList patterns;
   populateExpandTanhPattern(patterns, &getContext());
-  applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
+  (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
 namespace test {
 void registerTestExpandTanhPass() {
   PassRegistration<TestExpandTanhPass> pass("test-expand-tanh",
                                             "Test expanding tanh");
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestGpuRewrite.cpp

 struct TestGpuRewritePass
     : public PassWrapper<TestGpuRewritePass, OperationPass<ModuleOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<StandardOpsDialect>();
   }
   void runOnOperation() override {
     OwningRewritePatternList patterns;
     populateGpuRewritePatterns(&getContext(), patterns);
-    applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
 };
 } // namespace
 
 namespace mlir {
 void registerTestAllReduceLoweringPass() {
   PassRegistration<TestGpuRewritePass> pass(
       "test-gpu-rewrite",
       "Applies all rewrite patterns within the GPU dialect.");
 }
 } // namespace mlir

mlir/test/lib/Transforms/TestLinalgFusionTransforms.cpp

struct TestLinalgFusionTransforms
   void runOnFunction() override {
     MLIRContext *context = &this->getContext();
     FuncOp funcOp = this->getFunction();
     OwningRewritePatternList fusionPatterns;
     Aliases alias;
     LinalgDependenceGraph dependenceGraph =
         LinalgDependenceGraph::buildDependenceGraph(alias, funcOp);
     fillFusionPatterns<LoopType>(context, dependenceGraph, fusionPatterns);
-    applyPatternsAndFoldGreedily(funcOp, std::move(fusionPatterns));
+    (void)applyPatternsAndFoldGreedily(funcOp, std::move(fusionPatterns));
   }
 };
 } // namespace
 
 static LogicalResult fuseLinalgOpsGreedily(FuncOp f) {
   OpBuilder b(f);
   DenseSet<Operation *> eraseSet;
 
struct TestLinalgGreedyFusion
     : public PassWrapper<TestLinalgGreedyFusion, FunctionPass> {
   void runOnFunction() override {
     MLIRContext *context = &getContext();
     OwningRewritePatternList patterns =
         linalg::getLinalgTilingCanonicalizationPatterns(context);
     patterns.insert<AffineMinSCFCanonicalizationPattern>(context);
     FrozenRewritePatternList frozenPatterns(std::move(patterns));
     while (succeeded(fuseLinalgOpsGreedily(getFunction()))) {
-      applyPatternsAndFoldGreedily(getFunction(), frozenPatterns);
+      (void)applyPatternsAndFoldGreedily(getFunction(), frozenPatterns);
       PassManager pm(context);
       pm.addPass(createLoopInvariantCodeMotionPass());
       pm.addPass(createCanonicalizerPass());
       pm.addPass(createCSEPass());
       LogicalResult res = pm.run(getFunction()->getParentOfType<ModuleOp>());
       if (failed(res))
         this->signalPassFailure();
     }

mlir/test/lib/Transforms/TestLinalgTransforms.cpp

patterns.insert<LinalgPromotionPattern<FillOp>>(
       LinalgPromotionOptions()
           .setOperandsToPromote({0})
           .setUseFullTileBuffers({true})
           .setAlignment(32),
       LinalgTransformationFilter(
           Identifier::get("_promote_views_aligned_", ctx),
           Identifier::get("_views_aligned_promoted_", ctx)));
 
-  applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
+  (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
 
   // Drop the marker.
   funcOp.walk([](LinalgOp op) {
     op.removeAttr(LinalgTransforms::kLinalgTransformMarker);
   });
 }
 
 static void fillL1TilingAndMatmulToVectorPatterns(
static void fillPromotionCallBackPatterns(MLIRContext *ctx,
   patterns.insert<LinalgPromotionPattern<MatmulOp>>(
       ctx,
       LinalgPromotionOptions()
           .setOperandsToPromote({0, 2})
           .setUseFullTileBuffers({false, false})
           .setAllocationDeallocationFns(allocCallBackFn, deallocCallBackFn)
           .setCopyInOutFns(
               [](OpBuilder &b, Value src, Value dst) -> LogicalResult {
-                copyCallBackFn(b, src, dst, false);
-                return success();
+                return copyCallBackFn(b, src, dst, false);
               },
               [](OpBuilder &b, Value src, Value dst) -> LogicalResult {
-                copyCallBackFn(b, src, dst, true);
-                return success();
+                return copyCallBackFn(b, src, dst, true);
               }),
       LinalgTransformationFilter(Identifier::get("PROMOTE", ctx)));
 }
 
 template <typename IdOp, typename NProcsOp>
 static SmallVector<ProcInfo, 2>
 getGpuProcIds(OpBuilder &b, Location loc, ArrayRef<Range> parallelLoopRanges) {
   Type indexType = b.getIndexType();
stage1Patterns.emplace_back(std::make_unique<LinalgTilingPattern<MatmulOp>>(
                                    Identifier::get("L2", ctx))));
     fillL1TilingAndMatmulToVectorPatterns(funcOp, Identifier::get("L2", ctx),
                                           stage1Patterns);
   }
   SmallVector<FrozenRewritePatternList, 4> frozenStage1Patterns;
   llvm::move(stage1Patterns, std::back_inserter(frozenStage1Patterns));
   FrozenRewritePatternList stage2Patterns =
       getLinalgTilingCanonicalizationPatterns(ctx);
-  applyStagedPatterns(funcOp, frozenStage1Patterns, std::move(stage2Patterns));
+  (void)applyStagedPatterns(funcOp, frozenStage1Patterns,
+                            std::move(stage2Patterns));
 }
 
 static void applyVectorTransferForwardingPatterns(FuncOp funcOp) {
   OwningRewritePatternList forwardPattern;
   forwardPattern.insert<LinalgCopyVTRForwardingPattern>(funcOp.getContext());
   forwardPattern.insert<LinalgCopyVTWForwardingPattern>(funcOp.getContext());
-  applyPatternsAndFoldGreedily(funcOp, std::move(forwardPattern));
+  (void)applyPatternsAndFoldGreedily(funcOp, std::move(forwardPattern));
 }
 
 static void applyLinalgToVectorPatterns(FuncOp funcOp) {
   OwningRewritePatternList patterns;
   patterns.insert<LinalgVectorizationPattern>(
       LinalgTransformationFilter()
           .addOpFilter<ContractionOpInterface, FillOp, CopyOp, GenericOp>());
-  applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
+  (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
 }
 
 static void applyAffineMinSCFCanonicalizationPatterns(FuncOp funcOp) {
   OwningRewritePatternList foldPattern;
   foldPattern.insert<AffineMinSCFCanonicalizationPattern>(funcOp.getContext());
   FrozenRewritePatternList frozenPatterns(std::move(foldPattern));
 
   // Explicitly walk and apply the pattern locally to avoid more general folding
   // on the rest of the IR.
   funcOp.walk([&frozenPatterns](AffineMinOp minOp) {
-    applyOpPatternsAndFold(minOp, frozenPatterns);
+    (void)applyOpPatternsAndFold(minOp, frozenPatterns);
   });
 }
 
 // For now, just assume it is the zero of type.
 // In the future, it should be the zero of type + op.
 static Value getNeutralOfLinalgOp(OpBuilder &b, Operation *op) {
   auto t = op->getResult(0).getType().cast<ShapedType>().getElementType();
   return b.create<ConstantOp>(op->getLoc(), t, b.getZeroAttr(t));
 }
 
 static void applyTileAndPadPattern(FuncOp funcOp) {
   MLIRContext *context = funcOp.getContext();
   OwningRewritePatternList tilingPattern;
   auto linalgTilingOptions =
       linalg::LinalgTilingOptions()
           .setTileSizes({2, 3, 4})
           .setPaddingValueComputationFunction(getNeutralOfLinalgOp);
   tilingPattern.insert<linalg::LinalgTilingPattern<linalg::MatmulOp>>(
       context, linalgTilingOptions,
       linalg::LinalgTransformationFilter(
           Identifier::get("tile-and-pad", context)));
-  applyPatternsAndFoldGreedily(funcOp, std::move(tilingPattern));
+  (void)applyPatternsAndFoldGreedily(funcOp, std::move(tilingPattern));
 }
 
 /// Apply transformations specified as patterns.
 void TestLinalgTransforms::runOnFunction() {
   auto lambda = [&](void *) {
     getFunction().walk([](LinalgOp op) {
       op.removeAttr(LinalgTransforms::kLinalgTransformMarker);
     });
   };
   std::unique_ptr<void, decltype(lambda)> cleanupGuard{(void *)1, lambda};
 
   if (testPromotionOptions) {
     OwningRewritePatternList patterns;
     fillPromotionCallBackPatterns(&getContext(), patterns);
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
     return;
   }
   if (testTileAndDistributionOptions) {
     OwningRewritePatternList patterns;
     fillTileAndDistributePatterns(&getContext(), patterns);
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
     return;
   }
   if (testPatterns)
     return applyPatterns(getFunction());
   if (testMatmulToVectorPatterns1dTiling || testMatmulToVectorPatterns2dTiling)
     return applyMatmulToVectorPatterns(getFunction(),
                                        testMatmulToVectorPatterns1dTiling,
                                        testMatmulToVectorPatterns2dTiling);
   if (testVectorTransferForwardingPatterns)
     return applyVectorTransferForwardingPatterns(getFunction());
   if (testGenericToVectorPattern)
     return applyLinalgToVectorPatterns(getFunction());
   if (testAffineMinSCFCanonicalizationPatterns)
     return applyAffineMinSCFCanonicalizationPatterns(getFunction());
   if (testTileAndPadPattern)
     return applyTileAndPadPattern(getFunction());
   if (testHoistPadding2Levels) {
     getFunction().walk([](linalg::PadTensorOp padTensorOp) {
-      linalg::hoistPaddingOnTensors(padTensorOp, 2);
+      (void)linalg::hoistPaddingOnTensors(padTensorOp, 2);
     });
   }
 }
 
 namespace mlir {
 namespace test {
 void registerTestLinalgTransforms() {
   PassRegistration<TestLinalgTransforms> testTransformPatternsPass(
       "test-linalg-transform-patterns",
       "Test Linalg transformation patterns by applying them greedily.");
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLoopUnrolling.cpp

public:
 
   void runOnFunction() override {
     FuncOp func = getFunction();
     SmallVector<scf::ForOp, 4> loops;
     func.walk([&](scf::ForOp forOp) {
       if (getNestingDepth(forOp) == loopDepth)
         loops.push_back(forOp);
     });
-    for (auto loop : loops) {
-      loopUnrollByFactor(loop, unrollFactor);
-    }
+    for (auto loop : loops)
+      (void)loopUnrollByFactor(loop, unrollFactor);
   }
   Option<uint64_t> unrollFactor{*this, "unroll-factor",
                                 llvm::cl::desc("Loop unroll factor."),
                                 llvm::cl::init(1)};
   Option<bool> unrollUpToFactor{*this, "unroll-up-to-factor",
                                 llvm::cl::desc("Loop unroll up to factor."),
                                 llvm::cl::init(false)};
   Option<unsigned> loopDepth{*this, "loop-depth", llvm::cl::desc("Loop depth."),

mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp

 };
 
 } // end anonymous namespace
 
 void TestMemRefBoundCheck::runOnFunction() {
   getFunction().walk([](Operation *opInst) {
     TypeSwitch<Operation *>(opInst)
         .Case<AffineReadOpInterface, AffineWriteOpInterface>(
-            [](auto op) { boundCheckLoadOrStoreOp(op); });
+            [](auto op) { (void)boundCheckLoadOrStoreOp(op); });
 
     // TODO: do this for DMA ops as well.
   });
 }
 
 namespace mlir {
 namespace test {
 void registerMemRefBoundCheck() {
   PassRegistration<TestMemRefBoundCheck>(
       "test-memref-bound-check", "Check memref access bounds in a Function");
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestSCFUtils.cpp

void runOnFunction() override {
     func.walk([&](Operation *fakeRead) {
       if (fakeRead->getName().getStringRef() != "fake_read")
         return;
       auto *fakeCompute = fakeRead->getResult(0).use_begin()->getOwner();
       auto *fakeWrite = fakeCompute->getResult(0).use_begin()->getOwner();
       auto loop = fakeRead->getParentOfType<scf::ForOp>();
 
       OpBuilder b(loop);
-      loop.moveOutOfLoop({fakeRead});
+      (void)loop.moveOutOfLoop({fakeRead});
       fakeWrite->moveAfter(loop);
       auto newLoop = cloneWithNewYields(b, loop, fakeRead->getResult(0),
                                         fakeCompute->getResult(0));
       fakeCompute->getResult(0).replaceAllUsesWith(
           newLoop.getResults().take_back()[0]);
       toErase.push_back(loop);
     });
     for (auto loop : llvm::reverse(toErase))

mlir/test/lib/Transforms/TestSparsification.cpp

void runOnFunction() override {
     OwningRewritePatternList patterns;
     // Translate strategy flags to strategy options.
     linalg::SparsificationOptions options(parallelOption(), vectorOption(),
                                           vectorLength, typeOption(ptrType),
                                           typeOption(indType));
     // Apply rewriting.
     linalg::populateSparsificationPatterns(ctx, patterns, options);
     vector::populateVectorToVectorCanonicalizationPatterns(patterns, ctx);
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
 
 void registerTestSparsification() {
   PassRegistration<TestSparsification> sparsificationPass(
       "test-sparsification",
       "Test automatic generation of sparse tensor code");
 }
 
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestVectorTransforms.cpp

void runOnFunction() override {
     if (unroll) {
       patterns.insert<UnrollVectorPattern>(
           ctx,
           UnrollVectorOptions().setNativeShapeFn(getShape).setFilterConstraint(
               filter));
     }
     populateVectorToVectorCanonicalizationPatterns(patterns, ctx);
     populateVectorToVectorTransformationPatterns(patterns, ctx);
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 
 private:
   // Return the target shape based on op type.
   static Optional<SmallVector<int64_t, 4>> getShape(Operation *op) {
     if (isa<AddFOp, SelectOp, CmpFOp>(op))
       return SmallVector<int64_t, 4>(2, 2);
     if (isa<vector::ContractionOp>(op))
       return SmallVector<int64_t, 4>(3, 2);
     return llvm::None;
   }
 
   static LogicalResult filter(Operation *op) {
     return success(isa<AddFOp, SelectOp, CmpFOp, ContractionOp>(op));
   }
 };
 
 struct TestVectorSlicesConversion
     : public PassWrapper<TestVectorSlicesConversion, FunctionPass> {
   void runOnFunction() override {
     OwningRewritePatternList patterns;
     populateVectorSlicesLoweringPatterns(patterns, &getContext());
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorContractionConversion
     : public PassWrapper<TestVectorContractionConversion, FunctionPass> {
   TestVectorContractionConversion() = default;
   TestVectorContractionConversion(const TestVectorContractionConversion &pass) {
   }
void runOnFunction() override {
     OwningRewritePatternList patterns;
 
     // Test on one pattern in isolation.
     if (lowerToOuterProduct) {
       VectorContractLowering lowering = VectorContractLowering::OuterProduct;
       VectorTransformsOptions options{lowering};
       patterns.insert<ContractionOpToOuterProductOpLowering>(options,
                                                              &getContext());
-      applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+      (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
       return;
     }
 
     // Test on one pattern in isolation.
     if (lowerToFilterOuterProduct) {
       VectorContractLowering lowering = VectorContractLowering::OuterProduct;
       VectorTransformsOptions options{lowering};
       patterns.insert<ContractionOpToOuterProductOpLowering>(
           options, &getContext(), [](vector::ContractionOp op) {
             // Only lowers vector.contract where the lhs as a type vector<MxNx?>
             // where M is not 4.
             if (op.getRhsType().getShape()[0] == 4)
               return failure();
             return success();
           });
-      applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+      (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
       return;
     }
 
     // Test on all contract lowering patterns.
     VectorContractLowering contractLowering = VectorContractLowering::Dot;
     if (lowerToFlatMatrix)
       contractLowering = VectorContractLowering::Matmul;
     VectorTransposeLowering transposeLowering =
         VectorTransposeLowering::EltWise;
     if (lowerToFlatTranspose)
       transposeLowering = VectorTransposeLowering::Flat;
     VectorTransformsOptions options{contractLowering, transposeLowering};
     populateVectorContractLoweringPatterns(patterns, &getContext(), options);
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorUnrollingPatterns
     : public PassWrapper<TestVectorUnrollingPatterns, FunctionPass> {
   TestVectorUnrollingPatterns() = default;
   TestVectorUnrollingPatterns(const TestVectorUnrollingPatterns &pass) {}
   void runOnFunction() override {
if (unrollBasedOnType) {
           ctx, UnrollVectorOptions()
                    .setNativeShape(ArrayRef<int64_t>{2, 2, 2})
                    .setFilterConstraint([](Operation *op) {
                      return success(isa<ContractionOp>(op));
                    }));
     }
     populateVectorToVectorCanonicalizationPatterns(patterns, ctx);
     populateVectorToVectorTransformationPatterns(patterns, ctx);
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 
   Option<bool> unrollBasedOnType{
       *this, "unroll-based-on-type",
       llvm::cl::desc("Set the unroll factor based on type of the operation"),
       llvm::cl::init(false)};
 };
 
func.walk([&](AddFOp op) {
           SmallPtrSet<Operation *, 1> extractOp({ops->extract, ops->insert});
           op.getResult().replaceAllUsesExcept(ops->insert.getResult(),
                                               extractOp);
         }
       }
     });
     patterns.insert<PointwiseExtractPattern>(ctx);
     populateVectorToVectorTransformationPatterns(patterns, ctx);
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorToLoopPatterns
     : public PassWrapper<TestVectorToLoopPatterns, FunctionPass> {
   TestVectorToLoopPatterns() = default;
   TestVectorToLoopPatterns(const TestVectorToLoopPatterns &pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
func.walk([&](AddFOp op) {
       if (ops.hasValue()) {
         SmallPtrSet<Operation *, 1> extractOp({ops->extract, ops->insert});
         op.getResult().replaceAllUsesExcept(ops->insert.getResult(), extractOp);
       }
       return mlir::WalkResult::interrupt();
     });
     patterns.insert<PointwiseExtractPattern>(ctx);
     populateVectorToVectorTransformationPatterns(patterns, ctx);
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferUnrollingPatterns
     : public PassWrapper<TestVectorTransferUnrollingPatterns, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect>();
   }
   void runOnFunction() override {
     MLIRContext *ctx = &getContext();
     OwningRewritePatternList patterns;
     patterns.insert<UnrollVectorPattern>(
         ctx,
         UnrollVectorOptions()
             .setNativeShape(ArrayRef<int64_t>{2, 2})
             .setFilterConstraint([](Operation *op) {
               return success(
                   isa<vector::TransferReadOp, vector::TransferWriteOp>(op));
             }));
     populateVectorToVectorCanonicalizationPatterns(patterns, ctx);
     populateVectorToVectorTransformationPatterns(patterns, ctx);
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferFullPartialSplitPatterns
     : public PassWrapper<TestVectorTransferFullPartialSplitPatterns,
                          FunctionPass> {
   TestVectorTransferFullPartialSplitPatterns() = default;
   TestVectorTransferFullPartialSplitPatterns(
void runOnFunction() override {
     MLIRContext *ctx = &getContext();
     OwningRewritePatternList patterns;
     VectorTransformsOptions options;
     if (useLinalgOps)
       options.setVectorTransferSplit(VectorTransferSplit::LinalgCopy);
     else
       options.setVectorTransferSplit(VectorTransferSplit::VectorTransfer);
     patterns.insert<VectorTransferFullPartialRewriter>(ctx, options);
-    applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
+    (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 struct TestVectorTransferOpt
     : public PassWrapper<TestVectorTransferOpt, FunctionPass> {
   void runOnFunction() override { transferOpflowOpt(getFunction()); }
 };
 

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-gen.cpp

 /// opLoc is the location of the op token to be used to report errors
 /// for non-conforming expressions.
 AffineExpr AffineParser::getAffineBinaryOpExpr(AffineHighPrecOp op,
                                                AffineExpr lhs, AffineExpr rhs,
                                                SMLoc opLoc) {
   switch (op) {
   case Mul:
     if (!lhs.isSymbolicOrConstant() && !rhs.isSymbolicOrConstant()) {
-      parser.emitError(opLoc,
-                       "non-affine expression: at least one of the multiply "
-                       "operands has to be either a constant or symbolic");
+      (void)parser.emitError(
+          opLoc, "non-affine expression: at least one of the multiply "
       return nullptr;
     }
     return lhs * rhs;
   case FloorDiv:
     if (!rhs.isSymbolicOrConstant()) {
-      parser.emitError(opLoc,
+      (void)parser.emitError(opLoc,
                              "non-affine expression: right operand of floordiv "
                              "has to be either a constant or symbolic");
       return nullptr;
     }
     return lhs.floorDiv(rhs);
   case CeilDiv:
     if (!rhs.isSymbolicOrConstant()) {
-      parser.emitError(opLoc, "non-affine expression: right operand of ceildiv "
-                              "has to be either a constant or symbolic");
+      (void)parser.emitError(opLoc,
+                             "non-affine expression: right operand of ceildiv "
       return nullptr;
     }
     return lhs.ceilDiv(rhs);
   case Mod:
     if (!rhs.isSymbolicOrConstant()) {
-      parser.emitError(opLoc, "non-affine expression: right operand of mod "
-                              "has to be either a constant or symbolic");
+      (void)parser.emitError(opLoc,
+                             "non-affine expression: right operand of mod "
       return nullptr;
     }
     return lhs % rhs;
   case HNoOp:
     llvm_unreachable("can't create affine expression for null high prec op");
     return nullptr;
   }
   llvm_unreachable("Unknown AffineHighPrecOp");

 
 /// Parse an affine expression inside parentheses.
 ///
 ///   affine-expr ::= `(` affine-expr `)`
 AffineExpr AffineParser::parseParentheticalExpr() {
   if (failed(parser.parseToken(Token::Kind::l_paren, "expected '('")))
     return nullptr;
   if (parser.curToken.is(Token::Kind::r_paren))
-    return (parser.emitError("no expression inside parentheses"), nullptr);
+    return ((void)parser.emitError("no expression inside parentheses"),
+            nullptr);
 
   auto expr = parseAffineExpr();
   if (!expr)
     return nullptr;
   if (failed(parser.parseToken(Token::Kind::r_paren, "expected ')'")))
     return nullptr;
 
   return expr;
 }
 
 /// Parse the negation expression.
 ///
 ///   affine-expr ::= `-` affine-expr
 AffineExpr AffineParser::parseNegateExpression(AffineExpr lhs) {
   if (failed(parser.parseToken(Token::Kind::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 (parser.emitError("missing operand of negation"), nullptr);
+    return ((void)parser.emitError("missing operand of negation"), nullptr);
   return (-1) * operand;
 }
 
 AffineExpr AffineParser::parseAttrUseOrBareIdExpr() {
   if (llvm::Optional<AffineExpr> attrUse = attrUseCallback())
     return attrUse.getValue();
   return parseBareIdExpr();
 }
 
 /// Parse a bare id that may appear in an affine expression.
 ///
 ///   affine-expr ::= bare-id
 AffineExpr AffineParser::parseBareIdExpr() {
   if (parser.curToken.isNot(Token::Kind::id))
-    return (parser.emitError("expected id"), nullptr);
+    return ((void)parser.emitError("expected id"), nullptr);
 
   StringRef sRef = parser.curToken.getSpelling();
   for (auto &list : {dims, symbols}) {
     for (auto entry : list) {
       if (entry.first == sRef) {
         parser.consumeToken(Token::Kind::id);
         return entry.second;
       }
     }
   }
 
   // Not found, check fallback path.
   AffineExpr expr = bareIdFallback(sRef);
   if (expr) {
     parser.consumeToken(Token::Kind::id);
     return expr;
   }
 
-  return (parser.emitError("use of undeclared id"), nullptr);
+  return ((void)parser.emitError("use of undeclared id"), nullptr);
 }
 
 /// Parse a positive integral constant appearing in an affine expression.
 ///
 ///   affine-expr ::= integer-literal
 AffineExpr AffineParser::parseIntegerExpr() {
   auto val = parser.curToken.getUInt64IntegerValue();
   if (!val.hasValue() || (int64_t)val.getValue() < 0)
-    return (parser.emitError("constant too large for index"), nullptr);
+    return ((void)parser.emitError("constant too large for index"), nullptr);
 
   parser.consumeToken(Token::Kind::integer);
   return getAffineConstantExpr((int64_t)val.getValue(), parser.context);
 }
 
 /// 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::parseAffineOperandExpr(AffineExpr lhs) {
   case Token::Kind::minus:
     return parseNegateExpression(lhs);
   case Token::Kind::kw_ceildiv:
   case Token::Kind::kw_floordiv:
   case Token::Kind::kw_mod:
   case Token::Kind::plus:
   case Token::Kind::star:
     if (lhs)
-      parser.emitError("missing right operand of binary operator");
+      (void)parser.emitError("missing right operand of binary operator");
     else
-      parser.emitError("missing left operand of binary operator");
+      (void)parser.emitError("missing left operand of binary operator");
     return nullptr;
   default:
     if (lhs)
-      parser.emitError("missing right operand of binary operator");
+      (void)parser.emitError("missing right operand of binary operator");
     else
-      parser.emitError("expected affine expression");
+      (void)parser.emitError("expected affine expression");
     return nullptr;
   }
 }
 
 /// Parse affine expressions that are bare-id's, integer constants,
 /// parenthetical affine expressions, and affine op expressions that are a
 /// composition of those.
 ///

 /// one of the operands for `*` has to be either constant/symbolic; the second
 /// operand for floordiv, ceildiv, and mod has to be a positive integer.
 AffineExpr AffineParser::parseAffineExpr() {
   return parseAffineLowPrecOpExpr(nullptr, AffineLowPrecOp::LNoOp);
 }
 
 SmallVector<AffineExpr, 4> AffineParser::parseAffineExprs(Token::Kind lDelim,
                                                           Token::Kind rDelim) {
-  parser.parseToken(lDelim, "expected lDelim at start of affine expr list");
+  if (failed(parser.parseToken(lDelim,
+                               "expected lDelim at start of affine expr list")))
+    return {};
 
   SmallVector<AffineExpr, 4> exprs;
   auto parseElt = [&]() -> LogicalResult {
     auto elt = parseAffineExpr();
     exprs.push_back(elt);
     return elt ? success() : failure();
   };
 
LogicalResult TCParser::parseAttrDef() {
 
   // Parse the attribute's type. We don't expect the type to be arbitrary
   // complex, so just use this ad-hoc handling here.
 
   // Parse potential dimension list
   SmallVector<uint64_t, 4> vectorDims;
   while (parser.curToken.is(Token::Kind::integer)) {
     uint64_t value;
-    parser.parseInteger(value);
+    if (failed(parser.parseInteger(value)))
+      return failure();
     vectorDims.push_back(value);
 
     StringRef spelling = parser.curToken.getSpelling();
     if (spelling[0] != 'x')
       return parser.emitError(parser.curToken.getLoc(),
                               "expected 'x' in dimension list");
 
     // If we had a prefix of 'x', lex the next token immediately after the 'x'.
if (failed(parser.parseCommaSeparatedListUntil(Token::Kind::equal, parseUse,
                                                  /*allowEmptyList=*/true)))
     return failure();
 
   // 2. Parse RHS of `=`, this becomes the expressions from which we emit
   // computations.
   unsigned idx = 0;
   auto parseExpr = [&]() -> LogicalResult {
     std::unique_ptr<Expression> expr;
-    if (idx >= definitions.size()) {
-      parser.emitError("Fewer LHS definitions than RHS expressions");
-      return failure();
-    }
+    if (idx >= definitions.size())
+      return parser.emitError("Fewer LHS definitions than RHS expressions");
     if (failed(parseExpression(definitions[idx++], expr, state)))
       return failure();
     state.expressions.push_back(std::move(expr));
     return success();
   };
   if (failed(parser.parseCommaSeparatedListUntil(
           Token::Kind::semicolon, parseExpr, /*allowEmptyList=*/true)))
     return failure();
-  if (idx != definitions.size()) {
-    parser.emitError("Fewer RHS expressions than LHS definitions");
-    return failure();
-  }
+  if (idx != definitions.size())
+    return parser.emitError("Fewer RHS expressions than LHS definitions");
 
   // 3. Postprocess.
   // 3.a. Normalize all maps to the proper state.dims and symbols counts.
   SmallVector<TensorUse, 4> allUses;
   allUses.reserve(registeredTensors.size());
   for (auto &def : definitions)
     allUses.push_back(def);
   for (auto &pExpr : state.expressions)
     visitPostorder(*pExpr, [&](const Expression &e) {
       if (auto *use = dyn_cast<TensorUse>(&e))
         allUses.push_back(*use);
     });
   for (auto &use : allUses)
     use.indexingMap =
         AffineMap::get(state.dims.size(), symbols.size(),
                        use.indexingMap.getResults(), parser.context);
 
   // 3.b. Traverse definitions
   llvm::DenseSet<StringRef> seenDefs;
   for (auto &def : definitions) {
-    if (seenDefs.count(def.tensorId) > 0) {
-      parser.emitError("Unexpected multi-write to a single tensor");
-      return failure();
-    }
+    if (seenDefs.count(def.tensorId) > 0)
+      return parser.emitError("Unexpected multi-write to a single tensor");
     seenDefs.insert(def.tensorId);
     auto tensorIter = registeredTensors.find(def.tensorId);
     assert(tensorIter != registeredTensors.end() && "unregistered tensor");
     auto &tensor = tensorIter->getValue();
     tensor.indexingMap = def.indexingMap;
     state.orderedTensorArgs[def] = tensor.index;
   }
 
   bool failed = false;
   for (auto &pExpr : state.expressions)
     visitPostorder(*pExpr, [&](const Expression &e) {
       auto *pUse = dyn_cast<TensorUse>(&e);
       if (failed || !pUse)
         return;
       auto &use = *pUse;
       LLVM_DEBUG(llvm::dbgs()
                  << "\nuse: " << use.tensorId << " map: " << use.indexingMap);
       auto tensorIter = registeredTensors.find(use.tensorId);
       assert(tensorIter != registeredTensors.end() && "unregistered tensor");
       auto &tensor = tensorIter->getValue();
       if (tensor.indexingMap && state.orderedTensorArgs.count(use) == 0) {
         LLVM_DEBUG(llvm::dbgs() << "\nexisting: " << tensor.indexingMap);
-        parser.emitError(
+        (void)parser.emitError(
             "Unexpected multi-read of a tensor with different accesses");
         failed = true;
         return;
       }
       seenDefs.insert(use.tensorId);
       tensor.indexingMap = use.indexingMap;
       state.orderedTensorArgs[use] = tensor.index;
     });
LogicalResult TCParser::parseAndEmitODSDef(llvm::raw_ostream &os) {
 
   SmallVector<ComprehensionParsingState, 4> perComprehensionStates;
   while (parser.curToken.isNot(Token::Kind::r_brace)) {
     perComprehensionStates.push_back(ComprehensionParsingState());
     if (failed(parseOneComprehension(cppOpName, tcName,
                                      perComprehensionStates.back())))
       return failure();
   };
-  parser.parseToken(Token::Kind::r_brace, "expected '}'");
+  if (failed(parser.parseToken(Token::Kind::r_brace, "expected '}'")))
+    return failure();
 
   // Print.
   auto nComprehensions = perComprehensionStates.size();
-  if (nComprehensions != 1) {
-    parser.emitError("only 1 comprehension supported for now, got: " +
+  if (nComprehensions != 1)
+    return parser.emitError("only 1 comprehension supported for now, got: " +
                             llvm::Twine(nComprehensions));
-    return failure();
-  }
   if (genODSDecl) {
     auto &state = perComprehensionStates.back();
     printODS(os, cppOpName, tcName, interfaces, state);
     os << "\n";
   }
   if (genODSImpl) {
     auto &state = perComprehensionStates.back();
     std::string extraMethods;
for (const auto &attr : registeredAttrs) {
 
     llvm::StringRef elementType = attr.second.elementType;
     std::string odsType = llvm::StringSwitch<std::string>(elementType)
                               .Case("f32", "F32")
                               .Case("i32", "I32")
                               .Case("i64", "I64")
                               .Default("");
     if (odsType.empty()) {
-      parser.emitError("unimplemented support for attribute element type: " +
-                       elementType);
+      (void)parser.emitError(
+          "unimplemented support for attribute element type: " + elementType);
       return;
     }
 
     const auto &dims = attr.second.vectorDims;
     if (!dims.empty()) {
       SmallVector<std::string, 4> dimStrs;
       for (uint64_t dim : dims)
         dimStrs.push_back(std::to_string(dim));
void TCParser::printReferenceIndexingMaps(llvm::raw_ostream &os,
 
   // Create the affine constant expressions to replace symbols for attributes.
   for (auto attrUse : llvm::enumerate(attrUses)) {
     StringRef attrName = attrUse.value().attrName;
     auto it = registeredAttrs.find(attrName.str());
     assert(it != registeredAttrs.end() && "uses should point to valid attr!");
     std::string getValueFn = it->second.getValueFn(attrUse.value().indices);
     if (getValueFn.empty()) {
-      parser.emitError("unimplemented getValueFn for attribute: " + attrName);
+      (void)parser.emitError("unimplemented getValueFn for attribute: " +
+                             attrName);
       return;
     }
     std::string cstVal = llvm::formatv("{0}().{1}", attrName, getValueFn);
     const char *cstFmt =
         "\n\tauto cst{0} = getAffineConstantExpr({1}, context);";
     mapsStringStream << llvm::formatv(cstFmt, attrUse.index(), cstVal);
 
     unsigned position =
int main(int argc, char **argv) {
   // resorting to non-portable shell manipulations.
   if (testEmitIncludeTdHeader)
     output->os() << "include \"mlir/Dialect/Linalg/IR/LinalgStructuredOps.td\"";
 
   MLIRContext context;
   llvm::SourceMgr mgr;
   mgr.AddNewSourceBuffer(std::move(file), llvm::SMLoc());
   Parser parser(mgr, &context);
-  parseAndEmitAllTensorComprehensions(output->os(), parser);
+  (void)parseAndEmitAllTensorComprehensions(output->os(), parser);
   output->keep();
 
   return 0;
 }

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

emitResultSerialization(op, record->getLoc(), "  ", opVar, operands,
                             resultID, os);
   }
 
   // Process arguments.
   emitArgumentSerialization(op, record->getLoc(), "  ", opVar, operands,
                             elidedAttrs, os);
 
   if (record->isSubClassOf("SPV_ExtInstOp")) {
-    os << formatv("  encodeExtensionInstruction({0}, \"{1}\", {2}, {3});\n",
-                  opVar, record->getValueAsString("extendedInstSetName"),
-                  record->getValueAsInt("extendedInstOpcode"), operands);
+    os << formatv(
+        "  (void)encodeExtensionInstruction({0}, \"{1}\", {2}, {3});\n", opVar,
+        record->getValueAsString("extendedInstSetName"),
   } else {
     // Emit debug info.
-    os << formatv("  emitDebugLine(functionBody, {0}.getLoc());\n", opVar);
-    os << formatv("  encodeInstructionInto("
+    os << formatv("  (void)emitDebugLine(functionBody, {0}.getLoc());\n",
+                  opVar);
+    os << formatv("  (void)encodeInstructionInto("
                   "functionBody, spirv::Opcode::{1}, {2});\n",
                   op.getQualCppClassName(),
                   record->getValueAsString("spirvOpName"), operands);
   }
 
   // Process decorations.
   emitDecorationSerialization(op, "  ", opVar, elidedAttrs, resultID, os);
 
if (op.getNumResults() == 1) {
     os << formatv("  valueMap[{0}] = {1}.getResult();\n\n", valueID, opVar);
   }
 
   // According to SPIR-V spec:
   // This location information applies to the instructions physically following
   // this instruction, up to the first occurrence of any of the following: the
   // next end of block.
   os << formatv("  if ({0}.hasTrait<OpTrait::IsTerminator>())\n", opVar);
-  os << formatv("    clearDebugLine();\n");
+  os << formatv("    (void)clearDebugLine();\n");
   os << "  return success();\n";
   os << "}\n\n";
 }
 
 /// Generates the prologue for the function that dispatches the deserialization
 /// based on the `opcode`.
 static void initDispatchDeserializationFn(StringRef opcode, StringRef words,
                                           raw_ostream &os) {

mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp

LogicalResult VulkanRuntime::submitCommandBuffersToQueue() {
   submitInfo.pSignalSemaphores = nullptr;
   RETURN_ON_VULKAN_ERROR(vkQueueSubmit(queue, 1, &submitInfo, 0),
                          "vkQueueSubmit");
   return success();
 }
 
 LogicalResult VulkanRuntime::updateHostMemoryBuffers() {
   // First copy back the data to the staging buffer.
-  copyResource(/*deviceToHost=*/true);
+  (void)copyResource(/*deviceToHost=*/true);
 
   // For each descriptor set.
   for (auto &resourceDataMapPair : resourceData) {
     auto &resourceDataMap = resourceDataMapPair.second;
     auto &deviceMemoryBuffers =
         deviceMemoryBufferMap[resourceDataMapPair.first];
     // For each device memory buffer in the set.
     for (auto &deviceMemoryBuffer : deviceMemoryBuffers) {

mlir/unittests/Dialect/SPIRV/DeserializationTest.cpp

TEST_F(DeserializationTest, OpMemberNameSuccess) {
   SmallVector<uint32_t, 5> typeDecl;
   std::swap(typeDecl, binary);
 
   auto int32Type = addIntType(32);
   auto structType = addStructType({int32Type, int32Type});
   std::swap(typeDecl, binary);
 
   SmallVector<uint32_t, 5> operands1 = {structType, 0};
-  spirv::encodeStringLiteralInto(operands1, "i1");
+  (void)spirv::encodeStringLiteralInto(operands1, "i1");
   addInstruction(spirv::Opcode::OpMemberName, operands1);
 
   SmallVector<uint32_t, 5> operands2 = {structType, 1};
-  spirv::encodeStringLiteralInto(operands2, "i2");
+  (void)spirv::encodeStringLiteralInto(operands2, "i2");
   addInstruction(spirv::Opcode::OpMemberName, operands2);
 
   binary.append(typeDecl.begin(), typeDecl.end());
   EXPECT_TRUE(deserialize());
 }
 
 TEST_F(DeserializationTest, OpMemberNameMissingOperands) {
   addHeader();
TEST_F(DeserializationTest, OpMemberNameExcessOperands) {
   SmallVector<uint32_t, 5> typeDecl;
   std::swap(typeDecl, binary);
 
   auto int32Type = addIntType(32);
   auto structType = addStructType({int32Type});
   std::swap(typeDecl, binary);
 
   SmallVector<uint32_t, 5> operands = {structType, 0};
-  spirv::encodeStringLiteralInto(operands, "int32");
+  (void)spirv::encodeStringLiteralInto(operands, "int32");
   operands.push_back(42);
   addInstruction(spirv::Opcode::OpMemberName, operands);
 
   binary.append(typeDecl.begin(), typeDecl.end());
   ASSERT_FALSE(deserialize());
   expectDiagnostic("unexpected trailing words in OpMemberName instruction");
 }