Sample some of the new enabled clang-tidy fixes (WIP)

[mehdi_amini]

Summary

This is a demo for D116185

[rriddle]

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

64

I'm personally not much of a fan of needing to do this.

[rriddle]

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

64

Doesn't really seem to have any benefit and just adds annoyance

[mehdi_amini]

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

64

I wouldn't write it myself, but what if the tool does it for you?
I find it adds to the readability because you immediately know that an operand isn't used anywhere in the function body.

Anyway, that's why I opened this revision, to evaluate the various checks, in this case it is this one: https://clang.llvm.org/extra/clang-tidy/checks/misc-unused-parameters.html

I could also open one revision per check if you'd like: now I scripted it all :)

[rriddle]

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

64

I think if a tool automatically did it (ala clang-format) I'd be +1. The main part I'd be annoyed with is having to write it/interact with it by hand. (though I generally rely on an IDE to tell me uses of a parameter)

[rriddle]

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

64

If it isn't annoying to do, I think one revision per check(or group of related checks) would be good. Would allow much easier discussion for specific checks.

[Mogball]

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

64

Even if it was done automatically, if I suddenly need a function argument, deleting the inline /* */ comments is very annoying. Also, I can't imagine the inferReturnTypes definitions will look great with this, because most of the time only 1 or 2 of the arguments are used (operands and attributes).

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

149

+1

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

51

Yeah I think this looks terrible.

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

35

What's this one?

mlir/include/mlir/Dialect/Async/Transforms.h

 /// Must return an index type.
 using AsyncMinTaskSizeComputationFunction =
     std::function<Value(ImplicitLocOpBuilder, scf::ParallelOp)>;
 
 /// Add a pattern to the given pattern list to lower scf.parallel to async
 /// operations.
 void populateAsyncParallelForPatterns(
     RewritePatternSet &patterns, bool asyncDispatch, int32_t numWorkerThreads,
-    AsyncMinTaskSizeComputationFunction computeMinTaskSize);
+    const AsyncMinTaskSizeComputationFunction &computeMinTaskSize);
 
 } // namespace async
 } // namespace mlir
 
 #endif // MLIR_DIALECT_ASYNC_TRANSFORMS_H_

mlir/include/mlir/Dialect/Quant/UniformSupport.h

 /// (i.e. f32, bf16, etc) or a vector/tensor type based on a supported
 /// elemental type.
 ///
 /// Since conversion often involves introspecting some attributes of the
 /// input type in order to determine how to represent it, this is a two step
 /// process.
 struct ExpressedToQuantizedConverter {
   /// Creates a converter for the given input type.
-  static const ExpressedToQuantizedConverter forInputType(Type inputType);
+  static ExpressedToQuantizedConverter forInputType(Type inputType);
 
   /// Converts the inputType to be based on the given elemental type,
   /// returning the new type (or nullptr and emit an error on failure).
   Type convert(QuantizedType elementalType) const;
 
   /// Whether the conversion is legal.
   explicit operator bool() const { return (bool)expressedType; }
 

mlir/include/mlir/TableGen/GenInfo.h

 /// GenRegistration provides a global initializer that registers a generator
 /// function.
 ///
 /// Usage:
 ///
 ///   // At namespace scope.
 ///   static GenRegistration Print("print", "Print records", [](...){...});
 struct GenRegistration {
-  GenRegistration(StringRef arg, StringRef description, GenFunction function);
+  GenRegistration(StringRef arg, StringRef description,
+                  const GenFunction &function);
 };
 
 } // namespace mlir
 
 #endif // MLIR_TABLEGEN_GENINFO_H_

mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp

 //===- AsyncParallelFor.cpp - Implementation of Async Parallel For --------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements scf.parallel to scf.for + async.execute conversion pass.
 //
 //===----------------------------------------------------------------------===//
 
+#include <utility>
+
 #include "PassDetail.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Async/IR/Async.h"
 #include "mlir/Dialect/Async/Passes.h"
 #include "mlir/Dialect/Async/Transforms.h"
 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/BlockAndValueMapping.h"

 
 struct AsyncParallelForRewrite : public OpRewritePattern<scf::ParallelOp> {
 public:
   AsyncParallelForRewrite(
       MLIRContext *ctx, bool asyncDispatch, int32_t numWorkerThreads,
       AsyncMinTaskSizeComputationFunction computeMinTaskSize)
       : OpRewritePattern(ctx), asyncDispatch(asyncDispatch),
         numWorkerThreads(numWorkerThreads),
-        computeMinTaskSize(computeMinTaskSize) {}
+        computeMinTaskSize(std::move(computeMinTaskSize)) {}
 
   LogicalResult matchAndRewrite(scf::ParallelOp op,
                                 PatternRewriter &rewriter) const override;
 
 private:
   bool asyncDispatch;
   int32_t numWorkerThreads;
   AsyncMinTaskSizeComputationFunction computeMinTaskSize;
getParallelComputeFunctionType(scf::ParallelOp op, PatternRewriter &rewriter) {
 
   // Convert captures to vector for later convenience.
   SmallVector<Value> capturesVector(captures.begin(), captures.end());
   return {rewriter.getFunctionType(inputs, TypeRange()), capturesVector};
 }
 
 // Create a parallel compute fuction from the parallel operation.
 static ParallelComputeFunction createParallelComputeFunction(
-    scf::ParallelOp op, ParallelComputeFunctionBounds bounds,
+    scf::ParallelOp op, const ParallelComputeFunctionBounds &bounds,
     unsigned numBlockAlignedInnerLoops, PatternRewriter &rewriter) {
   OpBuilder::InsertionGuard guard(rewriter);
   ImplicitLocOpBuilder b(op.getLoc(), rewriter);
 
   ModuleOp module = op->getParentOfType<ModuleOp>();
 
   ParallelComputeFunctionType computeFuncType =
       getParallelComputeFunctionType(op, rewriter);
static ParallelComputeFunction createParallelComputeFunction(
   // nest are in the first/last iteration.
   SmallVector<Value> isBlockFirstCoord(op.getNumLoops());
   SmallVector<Value> isBlockLastCoord(op.getNumLoops());
 
   // Builds inner loop nest inside async.execute operation that does all the
   // work concurrently.
   LoopNestBuilder workLoopBuilder = [&](size_t loopIdx) -> LoopBodyBuilder {
     return [&, loopIdx](OpBuilder &nestedBuilder, Location loc, Value iv,
-                        ValueRange args) {
+                        ValueRange /*args*/) {
       ImplicitLocOpBuilder nb(loc, nestedBuilder);
 
       // Compute induction variable for `loopIdx`.
       computeBlockInductionVars[loopIdx] = nb.create<arith::AddIOp>(
           lowerBounds[loopIdx], nb.create<arith::MulIOp>(iv, steps[loopIdx]));
 
       // Check if we are inside first or last iteration of the loop.
       isBlockFirstCoord[loopIdx] = nb.create<arith::CmpIOp>(
// for the seconds half of the original range and go to the next iteration.
     Value start = after->getArgument(0);
     Value end = after->getArgument(1);
     Value distance = b.create<arith::SubIOp>(end, start);
     Value halfDistance = b.create<arith::DivSIOp>(distance, c2);
     Value midIndex = b.create<arith::AddIOp>(start, halfDistance);
 
     // Call parallel compute function inside the async.execute region.
     auto executeBodyBuilder = [&](OpBuilder &executeBuilder,
-                                  Location executeLoc, ValueRange executeArgs) {
+                                  Location executeLoc,
+                                  ValueRange /*executeArgs*/) {
       // Update the original `blockStart` and `blockEnd` with new range.
       SmallVector<Value> operands{block->getArguments().begin(),
                                   block->getArguments().end()};
       operands[1] = midIndex;
       operands[2] = end;
 
       executeBuilder.create<CallOp>(executeLoc, func.sym_name(),
                                     func.getCallableResults(), operands);
computeFuncOperands.append(op.getUpperBound().begin(),
                                op.getUpperBound().end());
     computeFuncOperands.append(op.getStep().begin(), op.getStep().end());
     computeFuncOperands.append(parallelComputeFunction.captures);
     return computeFuncOperands;
   };
 
   // Induction variable is the index of the block: [0, blockCount).
   LoopBodyBuilder loopBuilder = [&](OpBuilder &loopBuilder, Location loc,
-                                    Value iv, ValueRange args) {
+                                    Value iv, ValueRange /*args*/) {
     ImplicitLocOpBuilder nb(loc, loopBuilder);
 
     // Call parallel compute function inside the async.execute region.
     auto executeBodyBuilder = [&](OpBuilder &executeBuilder,
-                                  Location executeLoc, ValueRange executeArgs) {
+                                  Location executeLoc,
+                                  ValueRange /*executeArgs*/) {
       executeBuilder.create<CallOp>(executeLoc, compute.sym_name(),
                                     compute.getCallableResults(),
                                     computeFuncOperands(iv));
       executeBuilder.create<async::YieldOp>(executeLoc, ValueRange());
     };
 
     // Create async.execute operation to launch parallel computate function.
     auto execute = nb.create<ExecuteOp>(TypeRange(), ValueRange(), ValueRange(),

 }
 
 void AsyncParallelForPass::runOnOperation() {
   MLIRContext *ctx = &getContext();
 
   RewritePatternSet patterns(ctx);
   populateAsyncParallelForPatterns(
       patterns, asyncDispatch, numWorkerThreads,
-      [&](ImplicitLocOpBuilder builder, scf::ParallelOp op) {
+      [&](ImplicitLocOpBuilder builder, scf::ParallelOp /*op*/) {
         return builder.create<arith::ConstantIndexOp>(minTaskSize);
       });
   if (failed(applyPatternsAndFoldGreedily(getOperation(), std::move(patterns))))
     signalPassFailure();
 }
 
 std::unique_ptr<Pass> mlir::createAsyncParallelForPass() {
   return std::make_unique<AsyncParallelForPass>();
 }
 
 std::unique_ptr<Pass> mlir::createAsyncParallelForPass(bool asyncDispatch,
                                                        int32_t numWorkerThreads,
                                                        int32_t minTaskSize) {
   return std::make_unique<AsyncParallelForPass>(asyncDispatch, numWorkerThreads,
                                                 minTaskSize);
 }
 
 void mlir::async::populateAsyncParallelForPatterns(
     RewritePatternSet &patterns, bool asyncDispatch, int32_t numWorkerThreads,
-    AsyncMinTaskSizeComputationFunction computeMinTaskSize) {
+    const AsyncMinTaskSizeComputationFunction &computeMinTaskSize) {
   MLIRContext *ctx = patterns.getContext();
   patterns.add<AsyncParallelForRewrite>(ctx, asyncDispatch, numWorkerThreads,
                                         computeMinTaskSize);
 }

mlir/lib/Dialect/Async/Transforms/AsyncRuntimeRefCounting.cpp

 
 #define DEBUG_TYPE "async-runtime-ref-counting"
 
 //===----------------------------------------------------------------------===//
 // Utility functions shared by reference counting passes.
 //===----------------------------------------------------------------------===//
 
 // Drop the reference count immediately if the value has no uses.
-static LogicalResult dropRefIfNoUses(Value value, unsigned count = 1) {
+static LogicalResult dropRefIfNoUses(Value value) {
   if (!value.getUses().empty())
     return failure();
 
   OpBuilder b(value.getContext());
 
   // Set insertion point after the operation producing a value, or at the
   // beginning of the block if the value defined by the block argument.
   if (Operation *op = value.getDefiningOp())
for (Block *successor : successors) {
       builder.create<RuntimeDropRefOp>(value.getLoc(), value,
                                        builder.getI64IntegerAttr(1));
 
       // No need to update the terminator operation.
       if (successor == refCountingBlock)
         continue;
 
       // Update terminator `successor` block to `refCountingBlock`.
-      for (auto pair : llvm::enumerate(terminator->getSuccessors()))
+      for (const auto &pair : llvm::enumerate(terminator->getSuccessors()))
         if (pair.value() == successor)
           terminator->setSuccessor(refCountingBlock, pair.index());
     }
   }
 
   return success();
 }
 

mlir/lib/Dialect/DLTI/DLTI.cpp

combineOneSpec(DataLayoutSpecInterface spec,
 
   DenseMap<TypeID, DataLayoutEntryList> newEntriesForType;
   DenseMap<StringAttr, DataLayoutEntryInterface> newEntriesForID;
   spec.bucketEntriesByType(newEntriesForType, newEntriesForID);
 
   // Try overwriting the old entries with the new ones.
   for (const auto &kvp : newEntriesForType) {
     if (!entriesForType.count(kvp.first)) {
-      entriesForType[kvp.first] = std::move(kvp.second);
+      entriesForType[kvp.first] = kvp.second;
       continue;
     }
 
     Type typeSample = kvp.second.front().getKey().get<Type>();
     assert(&typeSample.getDialect() !=
                typeSample.getContext()->getLoadedDialect<BuiltinDialect>() &&
            "unexpected data layout entry for built-in type");
 

 } // namespace
 
 void DLTIDialect::initialize() {
   addAttributes<DataLayoutEntryAttr, DataLayoutSpecAttr>();
   addInterfaces<TargetDataLayoutInterface>();
 }
 
 Attribute DLTIDialect::parseAttribute(DialectAsmParser &parser,
-                                      Type type) const {
+                                      Type /*type*/) const {
   StringRef attrKind;
   if (parser.parseKeyword(&attrKind))
     return {};
 
   if (attrKind == DataLayoutEntryAttr::kAttrKeyword)
     return DataLayoutEntryAttr::parse(parser);
   if (attrKind == DataLayoutSpecAttr::kAttrKeyword)
     return DataLayoutSpecAttr::parse(parser);

mlir/lib/Dialect/Quant/Utils/UniformSupport.cpp

 
 using namespace mlir;
 using namespace mlir::quant;
 
 static bool isQuantizablePrimitiveType(Type inputType) {
   return inputType.isa<FloatType>();
 }
 
-const ExpressedToQuantizedConverter
+ExpressedToQuantizedConverter
 ExpressedToQuantizedConverter::forInputType(Type inputType) {
   if (inputType.isa<TensorType, VectorType>()) {
     Type elementType = inputType.cast<ShapedType>().getElementType();
     if (!isQuantizablePrimitiveType(elementType))
       return ExpressedToQuantizedConverter{inputType, nullptr};
     return ExpressedToQuantizedConverter{inputType, elementType};
   }
   // Supported primitive type (which just is the expressed type).

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

static ParseResult parseSwitchOpCases(
   }
   return success();
 }
 
 static void printSwitchOpCases(
     OpAsmPrinter &p, SwitchOp op, Type flagType, Block *defaultDestination,
     OperandRange defaultOperands, TypeRange defaultOperandTypes,
     DenseIntElementsAttr caseValues, SuccessorRange caseDestinations,
-    OperandRangeRange caseOperands, TypeRangeRange caseOperandTypes) {
+    OperandRangeRange caseOperands, const TypeRangeRange &caseOperandTypes) {
   p << "  default: ";
   p.printSuccessorAndUseList(defaultDestination, defaultOperands);
 
   if (!caseValues)
     return;
 
   for (const auto &it : llvm::enumerate(caseValues.getValues<APInt>())) {
     p << ',';

 /// Helper for folding a switch with a constant value.
 /// switch %c_42 : i32, [
 ///   default: ^bb1 ,
 ///   42: ^bb2,
 ///   43: ^bb3
 /// ]
 /// -> br ^bb2
 static void foldSwitch(SwitchOp op, PatternRewriter &rewriter,
-                       APInt caseValue) {
+                       const APInt &caseValue) {
   auto caseValues = op.getCaseValues();
   for (const auto &it : llvm::enumerate(caseValues->getValues<APInt>())) {
     if (it.value() == caseValue) {
       rewriter.replaceOpWithNewOp<BranchOp>(
           op, op.getCaseDestinations()[it.index()],
           op.getCaseOperands(it.index()));
       return;
     }

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

 /// Expand function arguments according to the provided TypeConverter and
 /// ValueDecomposer.
 struct DecomposeCallGraphTypesForFuncArgs
     : public DecomposeCallGraphTypesOpConversionPattern<FuncOp> {
   using DecomposeCallGraphTypesOpConversionPattern::
       DecomposeCallGraphTypesOpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(FuncOp op, OpAdaptor adaptor,
+  matchAndRewrite(FuncOp op, OpAdaptor /*adaptor*/,
                   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())) {
+    for (const auto &argType : llvm::enumerate(functionType.getInputs())) {
       SmallVector<Type, 2> 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.

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

bool mlir::isLegalForReturnOpTypeConversionPattern(Operation *op,
   // If this is a `return` and the user pass wants to convert/transform across
   // function boundaries, then `converter` is invoked to check whether the the
   // `return` op is legal.
   if (dyn_cast<ReturnOp>(op) && !returnOpAlwaysLegal)
     return converter.isLegal(op);
 
   // ReturnLike operations have to be legalized with their parent. For
   // return this is handled, for other ops they remain as is.
-  if (op->hasTrait<OpTrait::ReturnLike>())
-    return true;
-
-  return false;
+  return op->hasTrait<OpTrait::ReturnLike>();
 }
 
 bool mlir::isNotBranchOpInterfaceOrReturnLikeOp(Operation *op) {
   // If it is not a terminator, ignore it.
   if (!op->mightHaveTrait<OpTrait::IsTerminator>())
     return true;
 
   // If it is not the last operation in the block, also ignore it. We do

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

 public:
   BufferizeTensorConstantOp(GlobalCreator &globals,
                             TypeConverter &typeConverter, MLIRContext *context)
       : OpConversionPattern<arith::ConstantOp>(typeConverter, context,
                                                /*benefit=*/1),
         globals(globals) {}
 
   LogicalResult
-  matchAndRewrite(arith::ConstantOp op, OpAdaptor adaptor,
+  matchAndRewrite(arith::ConstantOp op, OpAdaptor /*adaptor*/,
                   ConversionPatternRewriter &rewriter) const override {
     auto type = op.getType().dyn_cast<RankedTensorType>();
     if (!type)
       return failure();
 
     auto globalMemref = globals.getGlobalFor(op);
     rewriter.replaceOpWithNewOp<memref::GetGlobalOp>(op, globalMemref.type(),
                                                      globalMemref.getName());

mlir/lib/Dialect/StandardOps/Utils/Utils.cpp

 detail::op_matcher<arith::ConstantIndexOp> mlir::matchConstantIndex() {
   return detail::op_matcher<arith::ConstantIndexOp>();
 }
 
 /// Detects the `values` produced by a ConstantIndexOp and places the new
 /// constant in place of the corresponding sentinel value.
 void mlir::canonicalizeSubViewPart(
     SmallVectorImpl<OpFoldResult> &values,
-    llvm::function_ref<bool(int64_t)> isDynamic) {
+    llvm::function_ref<bool(int64_t)> /*isDynamic*/) {
   for (OpFoldResult &ofr : values) {
     if (ofr.is<Attribute>())
       continue;
     // Newly static, move from Value to constant.
     if (auto cstOp =
             ofr.dyn_cast<Value>().getDefiningOp<arith::ConstantIndexOp>())
       ofr = OpBuilder(cstOp).getIndexAttr(cstOp.value());
   }

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

 struct TosaInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
 
   //===--------------------------------------------------------------------===//
   // Analysis Hooks.
   //===--------------------------------------------------------------------===//
 
   /// All operations can be inlined by default.
-  bool isLegalToInline(Operation *op, Region *region, bool wouldBeCloned,
-                       BlockAndValueMapping &map) const final {
+  bool isLegalToInline(Operation * /*op*/, Region * /*region*/,
+                       bool /*wouldBeCloned*/,
+                       BlockAndValueMapping & /*map*/) const final {
     return true;
   }
 
   /// All regions with If and While parent operators can be inlined.
-  bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
-                       BlockAndValueMapping &map) const final {
+  bool isLegalToInline(Region *dest, Region * /*src*/, bool /*wouldBeCloned*/,
+                       BlockAndValueMapping & /*map*/) const final {
     return (isa<tosa::IfOp>(dest->getParentOp()) ||
             isa<tosa::WhileOp>(dest->getParentOp()));
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // TOSA control flow support.
void MaxPool2dOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                               MLIRContext *context) {
   results.insert<MaxPool2dIsNoOp>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // Operator Folders.
 //===----------------------------------------------------------------------===//
 
-OpFoldResult CastOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult CastOp::fold(ArrayRef<Attribute> /*operands*/) {
   if (input().getType() == getType())
     return input();
   return {};
 }
 
 OpFoldResult ConstOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.empty() && "constant has no operands");
   return valueAttr();
OpFoldResult OP::fold(ArrayRef<Attribute> operands) {                        \
     return {};                                                                 \
   }
 
 ReduceFolder(ReduceAllOp) ReduceFolder(ReduceAnyOp) ReduceFolder(ReduceMaxOp)
     ReduceFolder(ReduceMinOp) ReduceFolder(ReduceProdOp)
         ReduceFolder(ReduceSumOp)
 #undef ReduceFolder
 
-            OpFoldResult ReshapeOp::fold(ArrayRef<Attribute> operands) {
+            OpFoldResult ReshapeOp::fold(ArrayRef<Attribute> /*operands*/) {
   auto inputTy = input1().getType().dyn_cast<RankedTensorType>();
   auto outputTy = getType().dyn_cast<RankedTensorType>();
 
   if (!inputTy || !outputTy || inputTy != outputTy)
     return {};
   return input1();
 }
 
 OpFoldResult PadOp::fold(ArrayRef<Attribute> operands) {
   // If the pad is all zeros we can fold this operation away.
   if (operands[1]) {
     auto densePad = operands[1].cast<DenseElementsAttr>();
     if (densePad.isSplat() && densePad.getSplatValue<APInt>().isZero()) {
       return input1();
     }
   }
 
   return {};
 }
 
-OpFoldResult SliceOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult SliceOp::fold(ArrayRef<Attribute> /*operands*/) {
   auto inputTy = input().getType().dyn_cast<RankedTensorType>();
   auto outputTy = getType().dyn_cast<RankedTensorType>();
 
   if (!inputTy || !outputTy || inputTy != outputTy)
     return {};
   if (inputTy.hasStaticShape())
     return input();
 
   return {};
 }
 
-OpFoldResult TileOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult TileOp::fold(ArrayRef<Attribute> /*operands*/) {
   bool allOnes = true;
   for (Attribute val : multiples().getValue()) {
     allOnes = allOnes && val.cast<IntegerAttr>().getValue().getSExtValue() == 1;
   }
 
   if (allOnes && input1().getType() == getType())
     return input1();
   return {};

 
 static void getF64Values(ArrayAttr arrayAttr, SmallVector<double> &values) {
   for (auto it : arrayAttr) {
     values.push_back(it.cast<FloatAttr>().getValueAsDouble());
   }
 }
 
 LogicalResult tosa::ArgMaxOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   IntegerAttr axis = attributes.get("axis").cast<IntegerAttr>();
   int32_t axisVal = axis.getValue().getSExtValue();
 
   if (!inputShape.hasRank()) {
     inferredReturnShapes.push_back(ShapedTypeComponents());
     return success();
   }
 
   SmallVector<int64_t> outShape;
   outShape.reserve(inputShape.getRank() - 1);
   for (int i = 0, s = inputShape.getRank(); i < s; i++) {
     if (i == axisVal)
       continue;
     outShape.push_back(inputShape.getDimSize(i));
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
 LogicalResult tosa::ConcatOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   // Infer all dimension sizes by reducing based on inputs.
   int32_t axis =
       attributes.get("axis").cast<IntegerAttr>().getValue().getSExtValue();
   llvm::SmallVector<int64_t> outputShape;
   bool hasRankedInput = false;
   for (auto operand : operands) {
     ShapeAdaptor operandShape = operands.getShape(operand);
LogicalResult tosa::ConcatOp::inferReturnTypeComponents(
 
   outputShape[axis] = concatDimSize;
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::FullyConnectedOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr /*attributes*/,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   ShapeAdaptor weightShape = operands.getShape(1);
   ShapeAdaptor biasShape = operands.getShape(2);
 
   // All shapes are dynamic.
   SmallVector<int64_t> outShape;
   outShape.resize(2, ShapedType::kDynamicSize);
outShape[1] = outShape[1] == ShapedType::kDynamicSize
                       : outShape[1];
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
 LogicalResult tosa::MatMulOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr /*attributes*/,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor lhsShape = operands.getShape(0);
   ShapeAdaptor rhsShape = operands.getShape(1);
 
   // All shapes are dynamic.
   SmallVector<int64_t> outShape;
   outShape.resize(3, ShapedType::kDynamicSize);
 
if (rhsShape.hasRank()) {
     outShape[2] = rhsShape.getDimSize(2);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outShape));
   return success();
 }
 
 LogicalResult tosa::PadOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr /*attributes*/,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   ShapeAdaptor paddingShape = operands.getShape(1);
   SmallVector<int64_t> outputShape;
 
   // If both inputs have unknown shape, we cannot determine the shape of the
   // output.
   if (!inputShape.hasRank() && !paddingShape.hasRank()) {
outputShape.push_back(inputShape.getDimSize(i) + paddingValues[i * 2] +
                           paddingValues[i * 2 + 1]);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::SliceOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ArrayAttr sizes = SliceOpAdaptor(operands, attributes).size();
   SmallVector<int64_t> outputShape;
   outputShape.reserve(sizes.size());
   for (auto val : sizes) {
     outputShape.push_back(val.cast<IntegerAttr>().getValue().getSExtValue());
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::TableOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr /*attributes*/,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
 
   if (!inputShape.hasRank()) {
     inferredReturnShapes.push_back(ShapedTypeComponents());
     return success();
   }
 
   inferredReturnShapes.resize(1);
   inputShape.getDims(inferredReturnShapes[0]);
   return success();
 }
 
 LogicalResult tosa::TileOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   TileOpAdaptor adaptor(operands, attributes);
   ArrayAttr multiples = adaptor.multiples();
   ShapeAdaptor inputShape = operands.getShape(0);
   SmallVector<int64_t> outputShape;
   if (!inputShape.hasRank()) {
     outputShape.resize(multiples.size(), ShapedType::kDynamicSize);
     inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
for (int i = 0, s = inputShape.getRank(); i < s; i++) {
     outputShape.push_back(dim);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::ReshapeOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ReshapeOpAdaptor adaptor(operands, attributes);
   ShapeAdaptor inputShape = operands.getShape(0);
 
   ArrayAttr newShape = adaptor.new_shape();
   llvm::SmallVector<int64_t> newShapeValue;
   getI64Values(newShape, newShapeValue);
 
if (val == ShapedType::kDynamicSize)
       val = numElements / staticMul;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(newShapeValue));
   return success();
 }
 
 LogicalResult tosa::TransposeOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr /*attributes*/,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ShapeAdaptor inputShape = operands.getShape(0);
   ShapeAdaptor permsShape = operands.getShape(1);
 
   // If input rank and permutation length is unknown, the output rank is
   // unknown.
   if (!inputShape.hasRank() || !permsShape.hasRank() ||
       permsShape.isDynamicDim(0)) {
if (ShapeAdaptor permShape = operands.getValueAsShape(1)) {
     }
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::GatherOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr /*attributes*/,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape;
   outputShape.resize(3, ShapedType::kDynamicSize);
 
   ShapeAdaptor valuesShape = operands.getShape(0);
   if (valuesShape.hasRank()) {
     outputShape[0] = valuesShape.getDimSize(0);
     outputShape[2] = valuesShape.getDimSize(2);
   }
 
   ShapeAdaptor indicesShape = operands.getShape(1);
   if (indicesShape.hasRank()) {
     if (outputShape[0] == ShapedType::kDynamicSize)
       outputShape[0] = indicesShape.getDimSize(0);
     if (outputShape[1] == ShapedType::kDynamicSize)
       outputShape[1] = indicesShape.getDimSize(1);
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::ResizeOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   ResizeOpAdaptor adaptor(operands, attributes);
   llvm::SmallVector<int64_t, 4> outputShape;
   outputShape.resize(4, ShapedType::kDynamicSize);
 
   int32_t inHeight = ShapedType::kDynamicSize;
   int32_t inWidth = ShapedType::kDynamicSize;
 
if (outputShape[2] == ShapedType::kDynamicSize && inWidth >= 0 && !fpMode) {
     outputShape[2] = size + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult tosa::ScatterOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr /*attributes*/,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape;
   outputShape.resize(3, ShapedType::kDynamicSize);
 
   ShapeAdaptor valuesInShape = operands.getShape(0);
   if (valuesInShape.hasRank()) {
     outputShape[0] = valuesInShape.getDimSize(0);
     outputShape[1] = valuesInShape.getDimSize(1);
if (width != -1) {
     outputShape[2] = padded / stride[1] + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult Conv2DOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape(4, ShapedType::kDynamicSize);
   Conv2DOp::Adaptor adaptor(operands.getValues(), attributes);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t weightWidth = ShapedType::kDynamicSize;
   int32_t weightHeight = ShapedType::kDynamicSize;
if (!ShapedType::isDynamic(inputWidth) &&
     outputShape[2] = (unstridedResult - 1) / stride[1] + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult Conv3DOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape(5, ShapedType::kDynamicSize);
   Conv2DOp::Adaptor adaptor(operands.getValues(), attributes);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t inputDepth = ShapedType::kDynamicSize;
 
if (!ShapedType::isDynamic(inputDepth) &&
     outputShape[3] = (unstridedResult - 1) / stride[2] + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult AvgPool2dOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
 }
 
 LogicalResult MaxPool2dOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
 }
 
 LogicalResult DepthwiseConv2DOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<int64_t> outputShape(4, ShapedType::kDynamicSize);
   DepthwiseConv2DOp::Adaptor adaptor(operands.getValues(), attributes);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t inputChannels = ShapedType::kDynamicSize;
 
if (!ShapedType::isDynamic(inputWidth) &&
     outputShape[2] = (unstridedResult - 1) / stride[1] + 1;
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult TransposeConv2DOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange operands, DictionaryAttr attributes,
+    RegionRange /*regions*/,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   TransposeConv2DOp::Adaptor adaptor(operands.getValues(), attributes);
   llvm::SmallVector<int64_t> outputShape;
   getI64Values(adaptor.out_shape(), outputShape);
 
   int32_t inputWidth = ShapedType::kDynamicSize;
   int32_t inputHeight = ShapedType::kDynamicSize;
   int32_t weightWidth = ShapedType::kDynamicSize;
if (!ShapedType::isDynamic(inputWidth) &&
     outputShape[2] = outputShape[2] == -1 ? calculateSize : outputShape[2];
   }
 
   inferredReturnShapes.push_back(ShapedTypeComponents(outputShape));
   return success();
 }
 
 LogicalResult IfOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange /*operands*/, DictionaryAttr /*attributes*/,
+    RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<tosa::YieldOp> yieldOps;
   for (Region *region : regions) {
     for (auto &block : *region)
       if (auto returnOp = dyn_cast<tosa::YieldOp>(block.getTerminator()))
         yieldOps.push_back(returnOp);
   }
 
   if (yieldOps.empty())
     return failure();
 
   // Get the initial type information for the yield op.
   llvm::SmallVector<ValueKnowledge> resultKnowledge;
   resultKnowledge.reserve(yieldOps.front().getNumOperands());
   for (auto operand : yieldOps.front().getOperands()) {
     resultKnowledge.push_back(
         ValueKnowledge::getKnowledgeFromType(operand.getType()));
   }
 
   for (auto yieldOp : yieldOps) {
     if (resultKnowledge.size() != yieldOp.getNumOperands())
       return failure();
 
-    for (auto it : llvm::enumerate(yieldOp.getOperands())) {
+    for (const auto &it : llvm::enumerate(yieldOp.getOperands())) {
       int32_t index = it.index();
       auto meet = ValueKnowledge::meet(
           resultKnowledge[index],
           ValueKnowledge::getKnowledgeFromType(it.value().getType()));
       if (!meet)
         continue;
       resultKnowledge[index] = meet;
     }
   }
 
   for (const ValueKnowledge &result : resultKnowledge) {
     inferredReturnShapes.push_back(result.getShapedTypeComponents());
   }
 
   return success();
 }
 
 LogicalResult WhileOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext * /*context*/, ::llvm::Optional<Location> /*location*/,
+    ValueShapeRange /*operands*/, DictionaryAttr /*attributes*/,
+    RegionRange regions,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   llvm::SmallVector<tosa::YieldOp> yieldOps;
   for (auto &block : *regions[1])
     if (auto returnOp = dyn_cast<tosa::YieldOp>(block.getTerminator()))
       yieldOps.push_back(returnOp);
 
   // TOSA's while must have a tosa.yield as its terminator. If not found this
   // tosa.while is invalid.
   if (yieldOps.empty())
     return failure();
 
   // Get the initial type information from the operand types.
   llvm::SmallVector<ValueKnowledge> resultKnowledge;
   resultKnowledge.reserve(yieldOps.front().getNumOperands());
   for (auto operand : yieldOps.front().getOperands()) {
     resultKnowledge.push_back(
         ValueKnowledge::getKnowledgeFromType(operand.getType()));
   }
 
   for (auto yieldOp : yieldOps) {
     if (resultKnowledge.size() != yieldOp.getNumOperands())
       return failure();
 
-    for (auto it : llvm::enumerate(yieldOp.getOperands())) {
+    for (const auto &it : llvm::enumerate(yieldOp.getOperands())) {
       int32_t index = it.index();
       if (auto meet = ValueKnowledge::meet(
               resultKnowledge[index],
               ValueKnowledge::getKnowledgeFromType(it.value().getType()))) {
         resultKnowledge[index] = meet;
       };
     }
   }

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

while (hasNewTypes) {
 
     // Using the new tosa.yield operand types, infer the new subtypes.
     llvm::SmallVector<ValueKnowledge> yieldTypeInfo;
     for (auto ty : argTypes) {
       yieldTypeInfo.push_back(ValueKnowledge::getKnowledgeFromType(ty));
     }
 
     for (auto yieldOp : yieldOps) {
-      for (auto it : llvm::enumerate(yieldOp.getOperands())) {
+      for (const auto &it : llvm::enumerate(yieldOp.getOperands())) {
         auto newKnowledge =
             ValueKnowledge::getKnowledgeFromType(it.value().getType());
         yieldTypeInfo[it.index()] =
             ValueKnowledge::meet(yieldTypeInfo[it.index()], newKnowledge);
       }
     }
 
     // This should never happen.

mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp

if (parser.parseColon() || parser.parseType(srcType) ||
     return failure();
   result.addTypes(resultType);
   return success();
 }
 
 Optional<SmallVector<ReassociationIndices>> mlir::composeReassociationIndices(
     ArrayRef<ReassociationIndices> producerReassociations,
     ArrayRef<ReassociationIndices> consumerReassociations,
-    MLIRContext *context) {
+    MLIRContext * /*context*/) {
   SmallVector<ReassociationIndices> composedIndices;
   // Make the producer the larger sized vector. If they are of same size, the
   // resulting reshape is not a supported reshape op.
   if (producerReassociations.size() == consumerReassociations.size())
     return llvm::None;
   if (producerReassociations.size() < consumerReassociations.size())
     std::swap(producerReassociations, consumerReassociations);
 
unsigned getMaxPosOfType(ArrayRef<ReassociationExprs> exprArrays) {
   }
   return pos;
 }
 
 ArrayAttr mlir::getReassociationIndicesAttribute(
     OpBuilder &b, ArrayRef<ReassociationIndices> reassociation) {
   SmallVector<Attribute, 4> reassociationAttr =
       llvm::to_vector<4>(llvm::map_range(
-          reassociation, [&](ReassociationIndices indices) -> Attribute {
+          reassociation, [&](const ReassociationIndices &indices) -> Attribute {
             return b.getI64ArrayAttr(indices).cast<Attribute>();
           }));
   return b.getArrayAttr(reassociationAttr);
 }
 
 SmallVector<ReassociationIndices, 2> mlir::convertReassociationMapsToIndices(
-    OpBuilder &b, ArrayRef<ReassociationExprs> reassociationExprs) {
+    OpBuilder & /*b*/, ArrayRef<ReassociationExprs> reassociationExprs) {
   SmallVector<ReassociationIndices, 2> reassociationIndices;
   for (const auto &exprs : reassociationExprs) {
     ReassociationIndices indices;
     indices.reserve(exprs.size());
     for (const auto &expr : exprs)
       indices.push_back(expr.cast<AffineDimExpr>().getPosition());
     reassociationIndices.push_back(indices);
   }
mlir::getSymbolLessAffineMaps(ArrayRef<ReassociationExprs> reassociation) {
   return maps;
 }
 bool mlir::isReassociationValid(ArrayRef<AffineMap> reassociation,
                                 int *invalidIndex) {
   if (reassociation.empty())
     return true;
   unsigned nDims = reassociation[0].getNumDims();
   unsigned nextExpectedDim = 0;
-  for (auto it : llvm::enumerate(reassociation)) {
+  for (const auto &it : llvm::enumerate(reassociation)) {
     auto m = it.value();
     if (m.getNumDims() != nDims || m.getNumSymbols() != 0) {
       if (invalidIndex)
         *invalidIndex = it.index();
       return false;
     }
     for (auto e : m.getResults()) {
       auto d = e.dyn_cast<AffineDimExpr>();

mlir/test/lib/Conversion/StandardToLLVM/TestConvertCallOp.cpp

 
 class TestTypeProducerOpConverter
     : public ConvertOpToLLVMPattern<test::TestTypeProducerOp> {
 public:
   using ConvertOpToLLVMPattern<
       test::TestTypeProducerOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(test::TestTypeProducerOp op, OpAdaptor adaptor,
+  matchAndRewrite(test::TestTypeProducerOp op, OpAdaptor /*adaptor*/,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::NullOp>(op, getVoidPtrType());
     return success();
   }
 };
 
 class TestConvertCallOp
     : public PassWrapper<TestConvertCallOp, OperationPass<ModuleOp>> {
 public:
   void getDependentDialects(DialectRegistry &registry) const final {
     registry.insert<LLVM::LLVMDialect>();
   }
   StringRef getArgument() const final { return "test-convert-call-op"; }
   StringRef getDescription() const final {
     return "Tests conversion of `std.call` to `llvm.call` in "
            "presence of custom types";
   }
 
   void runOnOperation() override {
     ModuleOp m = getOperation();
 
     // Populate type conversions.
     LLVMTypeConverter typeConverter(m.getContext());
-    typeConverter.addConversion([&](test::TestType type) {
+    typeConverter.addConversion([&](test::TestType /*type*/) {
       return LLVM::LLVMPointerType::get(IntegerType::get(m.getContext(), 8));
     });
     typeConverter.addConversion([&](test::SimpleAType type) {
       return IntegerType::get(type.getContext(), 42);
     });
 
     // Populate patterns.
     RewritePatternSet patterns(m.getContext());

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

 
 struct TestAffineDataCopy
     : public PassWrapper<TestAffineDataCopy, FunctionPass> {
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests affine data copy utility functions.";
   }
   TestAffineDataCopy() = default;
-  TestAffineDataCopy(const TestAffineDataCopy &pass){};
+  TestAffineDataCopy(const TestAffineDataCopy &pass) : PassWrapper(pass){};
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
   void runOnFunction() override;
 
 private:
   Option<bool> clMemRefFilter{
       *this, "memref-filter",
       llvm::cl::desc(
           "Enable memref filter testing in affine data copy optimization"),
       llvm::cl::init(false)};
   Option<bool> clTestGenerateCopyForMemRegion{
       *this, "for-memref-region",
       llvm::cl::desc("Test copy generation for a single memref region"),
       llvm::cl::init(false)};
 };
 
 } // namespace
 
 void TestAffineDataCopy::runOnFunction() {
   // Gather all AffineForOps by loop depth.
   std::vector<SmallVector<AffineForOp, 2>> depthToLoops;
   gatherLoops(getFunction(), depthToLoops);
-  assert(depthToLoops.size() && "Loop nest not found");
+  assert(!depthToLoops.empty() && "Loop nest not found");
 
   // Only support tests with a single loop nest and a single innermost loop
   // for now.
   unsigned innermostLoopIdx = depthToLoops.size() - 1;
   if (depthToLoops[0].size() != 1 || depthToLoops[innermostLoopIdx].size() != 1)
     return;
 
   auto loopNest = depthToLoops[0][0];

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

 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestAffineLoopUnswitching
     : public PassWrapper<TestAffineLoopUnswitching, FunctionPass> {
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests affine loop unswitching / if/else hoisting";
   }
   TestAffineLoopUnswitching() = default;
-  TestAffineLoopUnswitching(const TestAffineLoopUnswitching &pass) {}
+  TestAffineLoopUnswitching(const TestAffineLoopUnswitching &pass) = default;
 
   void runOnFunction() override;
 
   /// The maximum number of iterations to run this for.
   constexpr static unsigned kMaxIterations = 5;
 };
 
 } // namespace

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

 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestLoopPermutation
     : public PassWrapper<TestLoopPermutation, FunctionPass> {
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests affine loop permutation utility";
   }
   TestLoopPermutation() = default;
-  TestLoopPermutation(const TestLoopPermutation &pass){};
+  TestLoopPermutation(const TestLoopPermutation &pass) : PassWrapper(pass){};
 
   void runOnFunction() override;
 
 private:
   /// Permutation specifying loop i is mapped to permList[i] in
   /// transformed nest (with i going from outermost to innermost).
   ListOption<unsigned> permList{*this, "permutation-map",
                                 llvm::cl::desc("Specify the loop permutation"),

mlir/test/lib/Dialect/Linalg/TestComprehensiveBufferize.cpp

struct TestComprehensiveFunctionBufferize
   }
 
   StringRef getDescription() const final {
     return "Test Comprehensive Bufferize of FuncOps (body only).";
   }
 
   TestComprehensiveFunctionBufferize() = default;
   TestComprehensiveFunctionBufferize(
-      const TestComprehensiveFunctionBufferize &pass) {}
+      const TestComprehensiveFunctionBufferize &pass)
+      : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<bufferization::BufferizationDialect, linalg::LinalgDialect,
                     memref::MemRefDialect, tensor::TensorDialect,
                     vector::VectorDialect, scf::SCFDialect,
                     arith::ArithmeticDialect, AffineDialect>();
     affine_ext::registerBufferizableOpInterfaceExternalModels(registry);
     arith_ext::registerBufferizableOpInterfaceExternalModels(registry);

mlir/test/lib/Dialect/Linalg/TestLinalgCodegenStrategy.cpp

 //===- TestLinalgCodegenStrategy.cpp - Test Linalg codegen strategy -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements logic for testing the Linalg codegen strategy.
 //
 //===----------------------------------------------------------------------===//
 
+#include <utility>
+
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/Transforms/CodegenStrategy.h"
 #include "mlir/Dialect/Linalg/Utils/Utils.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 
 #include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct TestLinalgCodegenStrategy
     : public PassWrapper<TestLinalgCodegenStrategy, FunctionPass> {
   StringRef getArgument() const final { return "test-linalg-codegen-strategy"; }
   StringRef getDescription() const final {
     return "Test Linalg Codegen Strategy.";
   }
   TestLinalgCodegenStrategy() = default;
-  TestLinalgCodegenStrategy(const TestLinalgCodegenStrategy &pass) {}
+  TestLinalgCodegenStrategy(const TestLinalgCodegenStrategy &pass)
+      : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     // clang-format off
     registry.insert<AffineDialect,
                     gpu::GPUDialect,
                     linalg::LinalgDialect,
                     memref::MemRefDialect,
                     scf::SCFDialect,
void TestLinalgCodegenStrategy::runStrategy(
     LinalgTilingOptions tilingOptions,
     LinalgTilingOptions registerTilingOptions,
     LinalgPaddingOptions paddingOptions,
     vector::VectorContractLowering vectorContractLowering,
     vector::VectorTransferSplit vectorTransferSplit) {
   CodegenStrategy strategy;
   strategy
       .tileAndFuseIf(fuse && !tileSizes.empty(), anchorOpName,
-                     tilingAndFusionOptions)
-      .tileIf(!fuse && !tileSizes.empty(), anchorOpName, tilingOptions)
+                     std::move(tilingAndFusionOptions))
+      .tileIf(!fuse && !tileSizes.empty(), anchorOpName,
+              std::move(tilingOptions))
       .promoteIf(!fuse && promote, anchorOpName,
                  LinalgPromotionOptions()
                      .setAlignment(16)
                      .setUseFullTileBuffersByDefault(promoteFullTile))
       .tileIf(!fuse && !registerTileSizes.empty(), anchorOpName,
-              registerTilingOptions)
+              std::move(registerTilingOptions))
       .promoteIf(!fuse && registerPromote, anchorOpName,
                  LinalgPromotionOptions()
                      .setAlignment(16)
                      .setUseFullTileBuffersByDefault(registerPromoteFullTile))
-      .padIf(pad, "", paddingOptions)
+      .padIf(pad, "", std::move(paddingOptions))
       .decomposeIf(decompose)
       .generalizeIf(generalize, "")
       .interchangeIf(!iteratorInterchange.empty(), iteratorInterchange)
       .vectorizeIf(vectorize, "", nullptr, vectorizePadding)
       .vectorLowering(
           LinalgVectorLoweringOptions()
               .setVectorTransformsOptions(
                   vector::VectorTransformsOptions()

mlir/test/lib/Dialect/Linalg/TestLinalgDistribution.cpp

 }
 
 namespace {
 struct TestLinalgDistribution
     : public PassWrapper<TestLinalgDistribution, FunctionPass> {
   StringRef getArgument() const final { return "test-linalg-distribution"; }
   StringRef getDescription() const final { return "Test Linalg distribution."; }
   TestLinalgDistribution() = default;
-  TestLinalgDistribution(const TestLinalgDistribution &pass) {}
+  TestLinalgDistribution(const TestLinalgDistribution &pass) = default;
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, gpu::GPUDialect>();
   }
 
   void runOnFunction() override;
 };
 } // namespace
 

mlir/test/lib/Dialect/Linalg/TestLinalgFusionTransforms.cpp

 struct TestLinalgTileAndFuseSequencePass
     : public PassWrapper<TestLinalgTileAndFuseSequencePass, FunctionPass> {
   StringRef getArgument() const final { return "test-linalg-tile-and-fuse"; }
   StringRef getDescription() const final {
     return "Test Linalg tiling and fusion of a sequence of Linalg operations.";
   }
   TestLinalgTileAndFuseSequencePass() = default;
   TestLinalgTileAndFuseSequencePass(
-      const TestLinalgTileAndFuseSequencePass &pass){};
+      const TestLinalgTileAndFuseSequencePass &pass)
+      : PassWrapper(pass){};
 
   ListOption<int64_t> tileSizes{
       *this, "tile-sizes", llvm::cl::desc("Tile sizes to use for ops"),
       llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated};
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     scf::SCFDialect>();

mlir/test/lib/Dialect/Linalg/TestLinalgHoisting.cpp

 
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct TestLinalgHoisting
     : public PassWrapper<TestLinalgHoisting, FunctionPass> {
   TestLinalgHoisting() = default;
-  TestLinalgHoisting(const TestLinalgHoisting &pass) {}
+  TestLinalgHoisting(const TestLinalgHoisting &pass) : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect>();
   }
   StringRef getArgument() const final { return "test-linalg-hoisting"; }
   StringRef getDescription() const final {
     return "Test Linalg hoisting functions.";
   }
 

mlir/test/lib/Dialect/Linalg/TestLinalgTransforms.cpp

 
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct TestLinalgTransforms
     : public PassWrapper<TestLinalgTransforms, FunctionPass> {
   TestLinalgTransforms() = default;
-  TestLinalgTransforms(const TestLinalgTransforms &pass) {}
+  TestLinalgTransforms(const TestLinalgTransforms &pass) : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     // clang-format off
     registry.insert<AffineDialect,
                     memref::MemRefDialect,
                     scf::SCFDialect,
                     StandardOpsDialect,
                     vector::VectorDialect,

 
 //===----------------------------------------------------------------------===//
 // Test promotion callbacks
 //===----------------------------------------------------------------------===//
 
 // Allocation call back
 static Optional<Value> allocCallBackFn(OpBuilder &b, memref::SubViewOp subView,
                                        ArrayRef<Value> boundingSubViewSize,
-                                       DataLayout &layout) {
+                                       DataLayout & /*layout*/) {
   SmallVector<int64_t, 4> shape(boundingSubViewSize.size(), -1);
   return b
       .create<memref::AllocOp>(
           subView.getLoc(),
           MemRefType::get(shape, subView.getType().getElementType(),
                           /*affineMapComposition =*/{}, 3),
           boundingSubViewSize)
       .getResult();
vector::populateVectorTransferPermutationMapLoweringPatterns(
         canonicalizationPatterns);
     vector::populateVectorReductionToContractPatterns(canonicalizationPatterns);
     stage1Patterns.push_back(std::move(canonicalizationPatterns));
   }
   SmallVector<FrozenRewritePatternSet, 4> frozenStage1Patterns;
   llvm::move(stage1Patterns, std::back_inserter(frozenStage1Patterns));
   FrozenRewritePatternSet stage2Patterns =
       getLinalgTilingCanonicalizationPatterns(ctx);
-  (void)applyStagedPatterns(funcOp, frozenStage1Patterns,
-                            std::move(stage2Patterns));
+  (void)applyStagedPatterns(funcOp, frozenStage1Patterns, stage2Patterns);
 }
 
 static void applyVectorTransferForwardingPatterns(FuncOp funcOp) {
   RewritePatternSet forwardPattern(funcOp.getContext());
   forwardPattern.add<LinalgCopyVTRForwardingPattern>(funcOp.getContext());
   forwardPattern.add<LinalgCopyVTWForwardingPattern>(funcOp.getContext());
   (void)applyPatternsAndFoldGreedily(funcOp, std::move(forwardPattern));
 }

 }
 
 static void applyExtractSliceOfPadTensorSwapPattern(FuncOp funcOp) {
   RewritePatternSet patterns(funcOp.getContext());
   patterns.add<ExtractSliceOfPadTensorSwapPattern>(funcOp.getContext());
   (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
 }
 
-static void applyTilePattern(FuncOp funcOp, std::string loopType,
+static void applyTilePattern(FuncOp funcOp, const std::string &loopType,
                              ArrayRef<int64_t> tileSizes,
                              ArrayRef<int64_t> peeledLoops,
                              bool scalarizeDynamicDims) {
   MLIRContext *context = funcOp.getContext();
   RewritePatternSet tilingPattern(context);
   LinalgTilingLoopType type =
       llvm::StringSwitch<LinalgTilingLoopType>(loopType)
           .Case("for", LinalgTilingLoopType::Loops)

mlir/test/lib/Dialect/Math/TestPolynomialApproximation.cpp

 
 using namespace mlir;
 
 namespace {
 struct TestMathPolynomialApproximationPass
     : public PassWrapper<TestMathPolynomialApproximationPass, FunctionPass> {
   TestMathPolynomialApproximationPass() = default;
   TestMathPolynomialApproximationPass(
-      const TestMathPolynomialApproximationPass &pass) {}
+      const TestMathPolynomialApproximationPass &pass)
+      : PassWrapper(pass) {}
 
   void runOnFunction() override;
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<arith::ArithmeticDialect, math::MathDialect,
                     vector::VectorDialect>();
     if (enableAvx2)
       registry.insert<x86vector::X86VectorDialect>();
   }

mlir/test/lib/Dialect/StandardOps/TestDecomposeCallGraphTypes.cpp

decomposer.addDecomposeValueConversion([](OpBuilder &builder, Location loc,
         Value res = builder.create<test::GetTupleElementOp>(
             loc, resultType.getType(i), value, builder.getI32IntegerAttr(i));
         values.push_back(res);
       }
       return success();
     });
 
     typeConverter.addArgumentMaterialization(
-        [](OpBuilder &builder, TupleType resultType, ValueRange inputs,
+        [](OpBuilder &builder, TupleType /*resultType*/, ValueRange inputs,
            Location loc) -> Optional<Value> {
           if (inputs.size() == 1)
             return llvm::None;
           TupleType tuple = builder.getTupleType(inputs.getTypes());
           Value value = builder.create<test::MakeTupleOp>(loc, tuple, inputs);
           return value;
         });
 

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

 
 using namespace mlir;
 using namespace test;
 
 //===----------------------------------------------------------------------===//
 // AttrWithSelfTypeParamAttr
 //===----------------------------------------------------------------------===//
 
-Attribute AttrWithSelfTypeParamAttr::parse(AsmParser &parser, Type type) {
+Attribute AttrWithSelfTypeParamAttr::parse(AsmParser &parser, Type /*type*/) {
   Type selfType;
   if (parser.parseType(selfType))
     return Attribute();
   return get(parser.getContext(), selfType);
 }
 
 void AttrWithSelfTypeParamAttr::print(AsmPrinter &printer) const {
   printer << " " << getType();
 }
 
 //===----------------------------------------------------------------------===//
 // AttrWithTypeBuilderAttr
 //===----------------------------------------------------------------------===//
 
-Attribute AttrWithTypeBuilderAttr::parse(AsmParser &parser, Type type) {
+Attribute AttrWithTypeBuilderAttr::parse(AsmParser &parser, Type /*type*/) {
   IntegerAttr element;
   if (parser.parseAttribute(element))
     return Attribute();
   return get(parser.getContext(), element);
 }
 
 void AttrWithTypeBuilderAttr::print(AsmPrinter &printer) const {
   printer << " " << getAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // CompoundAAttr
 //===----------------------------------------------------------------------===//
 
-Attribute CompoundAAttr::parse(AsmParser &parser, Type type) {
+Attribute CompoundAAttr::parse(AsmParser &parser, Type /*type*/) {
   int widthOfSomething;
   Type oneType;
   SmallVector<int, 4> arrayOfInts;
   if (parser.parseLess() || parser.parseInteger(widthOfSomething) ||
       parser.parseComma() || parser.parseType(oneType) || parser.parseComma() ||
       parser.parseLSquare())
     return Attribute();
 
TestI64ElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
   if (type.getRank() != 1 || !type.getElementType().isSignlessInteger(64))
     return emitError() << "expected single rank 64-bit shape type, but got: "
                        << type;
   return success();
 }
 
 LogicalResult
 TestAttrWithFormatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                               int64_t one, std::string two, IntegerAttr three,
-                               ArrayRef<int> four) {
+                               int64_t one, std::string /*two*/,
+                               IntegerAttr /*three*/, ArrayRef<int> four) {
   if (four.size() != static_cast<unsigned>(one))
     return emitError() << "expected 'one' to equal 'four.size()'";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Utility Functions for Generated Attributes
 //===----------------------------------------------------------------------===//
static void printIntArray(AsmPrinter &printer, ArrayRef<int> ints) {
   printer << ']';
 }
 
 //===----------------------------------------------------------------------===//
 // TestSubElementsAccessAttr
 //===----------------------------------------------------------------------===//
 
 Attribute TestSubElementsAccessAttr::parse(::mlir::AsmParser &parser,
-                                           ::mlir::Type type) {
+                                           ::mlir::Type /*type*/) {
   Attribute first, second, third;
   if (parser.parseLess() || parser.parseAttribute(first) ||
       parser.parseComma() || parser.parseAttribute(second) ||
       parser.parseComma() || parser.parseAttribute(third) ||
       parser.parseGreater()) {
     return {};
   }
   return get(parser.getContext(), first, second, third);
 }
 
 void TestSubElementsAccessAttr::print(::mlir::AsmPrinter &printer) const {
   printer << "<" << getFirst() << ", " << getSecond() << ", " << getThird()
           << ">";
 }
 
 void TestSubElementsAccessAttr::walkImmediateSubElements(
     llvm::function_ref<void(mlir::Attribute)> walkAttrsFn,
-    llvm::function_ref<void(mlir::Type)> walkTypesFn) const {
+    llvm::function_ref<void(mlir::Type)> /*walkTypesFn*/) const {
   walkAttrsFn(getFirst());
   walkAttrsFn(getSecond());
   walkAttrsFn(getThird());
 }
 
 SubElementAttrInterface TestSubElementsAccessAttr::replaceImmediateSubAttribute(
     ArrayRef<std::pair<size_t, Attribute>> replacements) const {
   Attribute first = getFirst();

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

static void reifyReturnShape(Operation *op) {
   OpBuilder b(op);
 
   // Use permutations of 2 args as operands.
   auto shapedOp = cast<OpWithShapedTypeInferTypeInterfaceOp>(op);
   SmallVector<Value, 2> shapes;
   if (failed(shapedOp.reifyReturnTypeShapes(b, op->getOperands(), shapes)) ||
       !llvm::hasSingleElement(shapes))
     return;
-  for (auto it : llvm::enumerate(shapes)) {
+  for (const auto &it : llvm::enumerate(shapes)) {
     op->emitRemark() << "value " << it.index() << ": "
                      << it.value().getDefiningOp();
   }
 }
 
 struct TestReturnTypeDriver
     : public PassWrapper<TestReturnTypeDriver, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {

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

 using namespace mlir;
 using namespace test;
 
 //===----------------------------------------------------------------------===//
 // Trait Folder.
 //===----------------------------------------------------------------------===//
 
 OpFoldResult TestInvolutionTraitFailingOperationFolderOp::fold(
-    ArrayRef<Attribute> operands) {
+    ArrayRef<Attribute> /*operands*/) {
   // This failure should cause the trait fold to run instead.
   return {};
 }
 
 OpFoldResult TestInvolutionTraitSuccesfulOperationFolderOp::fold(
-    ArrayRef<Attribute> operands) {
+    ArrayRef<Attribute> /*operands*/) {
   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> {
   StringRef getArgument() const final { return "test-trait-folder"; }

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

 }
 
 //===----------------------------------------------------------------------===//
 // TestIntegerType
 //===----------------------------------------------------------------------===//
 
 // Example type validity checker.
 LogicalResult
-TestIntegerType::verify(function_ref<InFlightDiagnostic()> emitError,
+TestIntegerType::verify(function_ref<InFlightDiagnostic()> /*emitError*/,
                         unsigned width,
-                        TestIntegerType::SignednessSemantics ss) {
+                        TestIntegerType::SignednessSemantics /*ss*/) {
   if (width > 8)
     return failure();
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TestType
 //===----------------------------------------------------------------------===//
Type TestTypeWithLayoutType::parse(AsmParser &parser) {
   return TestTypeWithLayoutType::get(parser.getContext(), val);
 }
 
 void TestTypeWithLayoutType::print(AsmPrinter &printer) const {
   printer << "<" << getKey() << ">";
 }
 
 unsigned
-TestTypeWithLayoutType::getTypeSizeInBits(const DataLayout &dataLayout,
+TestTypeWithLayoutType::getTypeSizeInBits(const DataLayout & /*dataLayout*/,
                                           DataLayoutEntryListRef params) const {
   return extractKind(params, "size");
 }
 
 unsigned
-TestTypeWithLayoutType::getABIAlignment(const DataLayout &dataLayout,
+TestTypeWithLayoutType::getABIAlignment(const DataLayout & /*dataLayout*/,
                                         DataLayoutEntryListRef params) const {
   return extractKind(params, "alignment");
 }
 
 unsigned TestTypeWithLayoutType::getPreferredAlignment(
-    const DataLayout &dataLayout, DataLayoutEntryListRef params) const {
+    const DataLayout & /*dataLayout*/, DataLayoutEntryListRef params) const {
   return extractKind(params, "preferred");
 }
 
 bool TestTypeWithLayoutType::areCompatible(
     DataLayoutEntryListRef oldLayout, DataLayoutEntryListRef newLayout) const {
   unsigned old = extractKind(oldLayout, "alignment");
   return old == 1 || extractKind(newLayout, "alignment") <= old;
 }
 
 LogicalResult
 TestTypeWithLayoutType::verifyEntries(DataLayoutEntryListRef params,
-                                      Location loc) const {
+                                      Location /*loc*/) const {
   for (DataLayoutEntryInterface entry : params) {
     // This is for testing purposes only, so assert well-formedness.
     assert(entry.isTypeEntry() && "unexpected identifier entry");
     assert(entry.getKey().get<Type>().isa<TestTypeWithLayoutType>() &&
            "wrong type passed in");
     auto array = entry.getValue().dyn_cast<ArrayAttr>();
     assert(array && array.getValue().size() == 2 &&
            "expected array of two elements");

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

if (outputElementType.isSigned() ||
     return failure();
 
   double typeRangeMin = double(outputElementType.getStorageTypeMin() -
                                outputElementType.getZeroPoint()) *
                         outputElementType.getScale();
   double typeRangeMax = double(outputElementType.getStorageTypeMax() -
                                outputElementType.getZeroPoint()) *
                         outputElementType.getScale();
-  bool narrowRange = outputElementType.getStorageTypeMin() == 1 ? true : false;
+  bool narrowRange = outputElementType.getStorageTypeMin() == 1;
 
   auto dstQConstType = RankedTensorType::get(
       outputType.getShape(),
       buildQTypeFromMinMax(rewriter, outputElementType.getExpressedType(),
                            rewriter.getF64FloatAttr(typeRangeMin),
                            rewriter.getF64FloatAttr(typeRangeMax),
                            rewriter.getI32IntegerAttr(
                                outputElementType.getStorageTypeIntegralWidth()),

mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp

 using namespace mlir::linalg;
 using namespace mlir::vector;
 
 namespace {
 
 struct TestVectorToVectorLowering
     : public PassWrapper<TestVectorToVectorLowering, FunctionPass> {
   TestVectorToVectorLowering() = default;
-  TestVectorToVectorLowering(const TestVectorToVectorLowering &pass) {}
+  TestVectorToVectorLowering(const TestVectorToVectorLowering &pass)
+      : PassWrapper(pass) {}
   StringRef getArgument() const final {
     return "test-vector-to-vector-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns between ops in the vector dialect";
   }
 
   void getDependentDialects(DialectRegistry &registry) const override {
struct TestVectorContractionLowering
   StringRef getArgument() const final {
     return "test-vector-contraction-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns that lower contract ops in the vector "
            "dialect";
   }
   TestVectorContractionLowering() = default;
-  TestVectorContractionLowering(const TestVectorContractionLowering &pass) {}
+  TestVectorContractionLowering(const TestVectorContractionLowering &pass)
+      : PassWrapper(pass) {}
 
   Option<bool> lowerToFlatMatrix{
       *this, "vector-lower-matrix-intrinsics",
       llvm::cl::desc("Lower vector.contract to llvm.intr.matrix.multiply"),
       llvm::cl::init(false)};
   Option<bool> lowerToOuterProduct{
       *this, "vector-outerproduct",
       llvm::cl::desc("Lower vector.contract to vector.outerproduct"),
struct TestVectorTransposeLowering
   StringRef getArgument() const final {
     return "test-vector-transpose-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns that lower contract ops in the vector "
            "dialect";
   }
   TestVectorTransposeLowering() = default;
-  TestVectorTransposeLowering(const TestVectorTransposeLowering &pass) {}
+  TestVectorTransposeLowering(const TestVectorTransposeLowering &pass)
+      : PassWrapper(pass) {}
 
   Option<bool> lowerToEltwise{
       *this, "eltwise",
       llvm::cl::desc("Lower 2-D vector.transpose to eltwise insert/extract"),
       llvm::cl::init(false)};
   Option<bool> lowerToFlatTranspose{
       *this, "flat",
       llvm::cl::desc("Lower 2-D vector.transpose to vector.flat_transpose"),
struct TestVectorUnrollingPatterns
   StringRef getArgument() const final {
     return "test-vector-unrolling-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to unroll contract ops in the vector "
            "dialect";
   }
   TestVectorUnrollingPatterns() = default;
-  TestVectorUnrollingPatterns(const TestVectorUnrollingPatterns &pass) {}
+  TestVectorUnrollingPatterns(const TestVectorUnrollingPatterns &pass)
+      : PassWrapper(pass) {}
   void runOnFunction() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     populateVectorUnrollPatterns(
         patterns, UnrollVectorOptions()
                       .setNativeShape(ArrayRef<int64_t>{2, 2})
                       .setFilterConstraint([](Operation *op) {
                         return success(isa<arith::AddFOp, vector::FMAOp>(op));
struct TestVectorDistributePatterns
   StringRef getArgument() const final {
     return "test-vector-distribute-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to distribute vector ops in the vector "
            "dialect";
   }
   TestVectorDistributePatterns() = default;
-  TestVectorDistributePatterns(const TestVectorDistributePatterns &pass) {}
+  TestVectorDistributePatterns(const TestVectorDistributePatterns &pass)
+      : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<VectorDialect>();
     registry.insert<AffineDialect>();
   }
   ListOption<int32_t> multiplicity{
       *this, "distribution-multiplicity", llvm::cl::MiscFlags::CommaSeparated,
       llvm::cl::desc("Set the multiplicity used for distributing vector")};
 

 
 struct TestVectorToLoopPatterns
     : public PassWrapper<TestVectorToLoopPatterns, FunctionPass> {
   StringRef getArgument() const final { return "test-vector-to-forloop"; }
   StringRef getDescription() const final {
     return "Test lowering patterns to break up a vector op into a for loop";
   }
   TestVectorToLoopPatterns() = default;
-  TestVectorToLoopPatterns(const TestVectorToLoopPatterns &pass) {}
+  TestVectorToLoopPatterns(const TestVectorToLoopPatterns &pass)
+      : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<VectorDialect>();
     registry.insert<AffineDialect>();
   }
   Option<int32_t> multiplicity{
       *this, "distribution-multiplicity",
       llvm::cl::desc("Set the multiplicity used for distributing vector"),
       llvm::cl::init(32)};
   void runOnFunction() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     FuncOp func = getFunction();
     func.walk([&](arith::AddFOp op) {
       // Check that the operation type can be broken down into a loop.
       VectorType type = op.getType().dyn_cast<VectorType>();
       if (!type || type.getRank() != 1 ||
           type.getNumElements() % multiplicity != 0)
         return mlir::WalkResult::advance();
       auto filterAlloc = [](Operation *op) {
-        if (isa<arith::ConstantOp, memref::AllocOp, CallOp>(op))
-          return false;
-        return true;
+        return !isa<arith::ConstantOp, memref::AllocOp, CallOp>(op);
       };
       auto dependentOps = getSlice(op, filterAlloc);
       // Create a loop and move instructions from the Op slice into the loop.
       OpBuilder builder(op);
       auto zero = builder.create<arith::ConstantIndexOp>(op.getLoc(), 0);
       auto one = builder.create<arith::ConstantIndexOp>(op.getLoc(), 1);
       auto numIter =
           builder.create<arith::ConstantIndexOp>(op.getLoc(), multiplicity);
StringRef getArgument() const final {
     return "test-vector-transfer-full-partial-split";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to split "
            "transfer ops via scf.if + linalg ops";
   }
   TestVectorTransferFullPartialSplitPatterns() = default;
   TestVectorTransferFullPartialSplitPatterns(
-      const TestVectorTransferFullPartialSplitPatterns &pass) {}
+      const TestVectorTransferFullPartialSplitPatterns &pass)
+      : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     scf::SCFDialect>();
   }
 
   Option<bool> useLinalgOps{
       *this, "use-linalg-copy",
struct TestVectorTransferLoweringPatterns
   }
 };
 
 struct TestVectorMultiReductionLoweringPatterns
     : public PassWrapper<TestVectorMultiReductionLoweringPatterns,
                          FunctionPass> {
   TestVectorMultiReductionLoweringPatterns() = default;
   TestVectorMultiReductionLoweringPatterns(
-      const TestVectorMultiReductionLoweringPatterns &pass) {}
+      const TestVectorMultiReductionLoweringPatterns &pass)
+      : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
   StringRef getArgument() const final {
     return "test-vector-multi-reduction-lowering-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to lower vector.multi_reduction to other "
struct TestVectorMultiReductionLoweringPatterns
   }
 };
 
 struct TestVectorTransferCollapseInnerMostContiguousDims
     : public PassWrapper<TestVectorTransferCollapseInnerMostContiguousDims,
                          FunctionPass> {
   TestVectorTransferCollapseInnerMostContiguousDims() = default;
   TestVectorTransferCollapseInnerMostContiguousDims(
-      const TestVectorTransferCollapseInnerMostContiguousDims &pass) {}
+      const TestVectorTransferCollapseInnerMostContiguousDims &pass) = default;
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect, AffineDialect>();
   }
 
   StringRef getArgument() const final {
     return "test-vector-transfer-collapse-inner-most-dims";
   }

mlir/test/lib/IR/TestPrintDefUse.cpp

getOperation()->walk([](Operation *op) {
           auto blockArg = operand.cast<BlockArgument>();
           llvm::outs() << "  - Operand produced by Block argument, number "
                        << blockArg.getArgNumber() << "\n";
         }
       }
 
       // Print information about the user of each of the result.
       llvm::outs() << "Has " << op->getNumResults() << " results:\n";
-      for (auto indexedResult : llvm::enumerate(op->getResults())) {
+      for (const auto &indexedResult : llvm::enumerate(op->getResults())) {
         Value result = indexedResult.value();
         llvm::outs() << "  - Result " << indexedResult.index();
         if (result.use_empty()) {
           llvm::outs() << " has no uses\n";
           continue;
         }
         if (result.hasOneUse()) {
           llvm::outs() << " has a single use: ";

mlir/test/lib/IR/TestSlicing.cpp

static LogicalResult createBackwardSliceFunction(Operation *op,
   FuncOp parentFuncOp = op->getParentOfType<FuncOp>();
   OpBuilder builder(parentFuncOp);
   Location loc = op->getLoc();
   std::string clonedFuncOpName = parentFuncOp.getName().str() + suffix.str();
   FuncOp clonedFuncOp =
       builder.create<FuncOp>(loc, clonedFuncOpName, parentFuncOp.getType());
   BlockAndValueMapping mapper;
   builder.setInsertionPointToEnd(clonedFuncOp.addEntryBlock());
-  for (auto arg : enumerate(parentFuncOp.getArguments()))
+  for (const auto &arg : enumerate(parentFuncOp.getArguments()))
     mapper.map(arg.value(), clonedFuncOp.getArgument(arg.index()));
   SetVector<Operation *> slice;
   getBackwardSlice(op, &slice);
   for (Operation *slicedOp : slice)
     builder.clone(*slicedOp, mapper);
   builder.create<ReturnOp>(loc);
   return success();
 }

mlir/test/lib/Rewrite/TestPDLByteCode.cpp

 //===- TestPDLByteCode.cpp - Test rewriter bytecode functionality ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 /// Custom constraint invoked from PDL.
-static LogicalResult customSingleEntityConstraint(PDLValue value,
-                                                  ArrayAttr constantParams,
-                                                  PatternRewriter &rewriter) {
+static LogicalResult
+customSingleEntityConstraint(PDLValue value, ArrayAttr /*constantParams*/,
+                             PatternRewriter & /*rewriter*/) {
   Operation *rootOp = value.cast<Operation *>();
   return success(rootOp->getName().getStringRef() == "test.op");
 }
 static LogicalResult customMultiEntityConstraint(ArrayRef<PDLValue> values,
                                                  ArrayAttr constantParams,
                                                  PatternRewriter &rewriter) {
   return customSingleEntityConstraint(values[1], constantParams, rewriter);
 }
 static LogicalResult
 customMultiEntityVariadicConstraint(ArrayRef<PDLValue> values,
-                                    ArrayAttr constantParams,
-                                    PatternRewriter &rewriter) {
+                                    ArrayAttr /*constantParams*/,
+                                    PatternRewriter & /*rewriter*/) {
   if (llvm::any_of(values, [](const PDLValue &value) { return !value; }))
     return failure();
   ValueRange operandValues = values[0].cast<ValueRange>();
   TypeRange typeValues = values[1].cast<TypeRange>();
   if (operandValues.size() != 2 || typeValues.size() != 2)
     return failure();
   return success();
 }
 
 // Custom creator invoked from PDL.
-static void customCreate(ArrayRef<PDLValue> args, ArrayAttr constantParams,
+static void customCreate(ArrayRef<PDLValue> args, ArrayAttr /*constantParams*/,
                          PatternRewriter &rewriter, PDLResultList &results) {
   results.push_back(rewriter.createOperation(
       OperationState(args[0].cast<Operation *>()->getLoc(), "test.success")));
 }
 static void customVariadicResultCreate(ArrayRef<PDLValue> args,
-                                       ArrayAttr constantParams,
-                                       PatternRewriter &rewriter,
+                                       ArrayAttr /*constantParams*/,
+                                       PatternRewriter & /*rewriter*/,
                                        PDLResultList &results) {
   Operation *root = args[0].cast<Operation *>();
   results.push_back(root->getOperands());
   results.push_back(root->getOperands().getTypes());
 }
-static void customCreateType(ArrayRef<PDLValue> args, ArrayAttr constantParams,
+static void customCreateType(ArrayRef<PDLValue> /*args*/,
+                             ArrayAttr /*constantParams*/,
                              PatternRewriter &rewriter,
                              PDLResultList &results) {
   results.push_back(rewriter.getF32Type());
 }
 
 /// Custom rewriter invoked from PDL.
 static void customRewriter(ArrayRef<PDLValue> args, ArrayAttr constantParams,
-                           PatternRewriter &rewriter, PDLResultList &results) {
+                           PatternRewriter &rewriter,
+                           PDLResultList & /*results*/) {
   Operation *root = args[0].cast<Operation *>();
   OperationState successOpState(root->getLoc(), "test.success");
   successOpState.addOperands(args[1].cast<Value>());
   successOpState.addAttribute("constantParams", constantParams);
   rewriter.createOperation(successOpState);
   rewriter.eraseOp(root);
 }
 

mlir/test/lib/Transforms/TestLoopFusion.cpp

static bool testSliceComputation(AffineForOp forOpA, AffineForOp forOpB,
   }
   return false;
 }
 
 // Attempts to fuse 'forOpA' into 'forOpB' at loop depths in range
 // ['loopDepth' + 1, 'maxLoopDepth'].
 // Returns true if loops were successfully fused, false otherwise.
 static bool testLoopFusionTransformation(AffineForOp forOpA, AffineForOp forOpB,
-                                         unsigned i, unsigned j,
+                                         unsigned /*i*/, unsigned /*j*/,
                                          unsigned loopDepth,
                                          unsigned maxLoopDepth) {
   for (unsigned d = loopDepth + 1; d <= maxLoopDepth; ++d) {
     mlir::ComputationSliceState sliceUnion;
     FusionResult result = mlir::canFuseLoops(forOpA, forOpB, d, &sliceUnion);
     if (result.value == FusionResult::Success) {
       mlir::fuseLoops(forOpA, forOpB, sliceUnion);
       // Note: 'forOpA' is removed to simplify test output. A proper loop
if (clTestLoopFusionTransformation) {
     // Run loop fusion until a fixed point is reached.
     do {
       depthToLoops.clear();
       // Gather all AffineForOps by loop depth.
       gatherLoops(getFunction(), depthToLoops);
 
       // Try to fuse all combinations of src/dst loop nests in 'depthToLoops'.
     } while (iterateLoops(depthToLoops, testLoopFusionTransformation,
-                          /*return_on_change=*/true));
+                          /*returnOnChange=*/true));
     return;
   }
 
   // Gather all AffineForOps by loop depth.
   gatherLoops(getFunction(), depthToLoops);
 
   // Run tests on all combinations of src/dst loop nests in 'depthToLoops'.
   if (clTestDependenceCheck)

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

static std::string interleaveToString(Container &container,
   llvm::raw_string_ostream ss(result);
   llvm::interleave(container, ss, separator);
   ss.flush();
   return result;
 }
 
 static Optional<int>
 findTensorDefArgIndex(StringRef name, SmallVectorImpl<LinalgOperandDef> &args) {
-  for (auto it : llvm::enumerate(args)) {
+  for (const auto &it : llvm::enumerate(args)) {
     if (it.value().name == name)
       return it.index();
   }
   return None;
 }
 
 // Try to map the TypeVar to a predefined or an argument type.
 static Optional<std::string>
 findTypeValue(StringRef typeVar, SmallVectorImpl<LinalgOperandDef> &args) {
   // Handle all predefined types.
   if (typeVar == "I32")
     return std::string("helper.getIntegerType(32)");
   if (typeVar == "I64")
     return std::string("helper.getIntegerType(64)");
   if (typeVar == "F32")
     return std::string("helper.getFloat32Type()");
   if (typeVar == "F64")
     return std::string("helper.getFloat64Type()");
 
   // Search all argument types.
-  for (auto it : llvm::enumerate(args)) {
+  for (const auto &it : llvm::enumerate(args)) {
     if (it.value().typeVar == typeVar)
       return llvm::formatv("block.getArgument({0}).getType()", it.index())
           .str();
   }
 
   return None;
 }
 

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

Method *construct = storageCls->addMethod<Method::Inline>(
       strfmt("{0} *", def.getStorageClassName()), "construct",
       def.hasStorageCustomConstructor() ? Method::StaticDeclaration
                                         : Method::Static,
       MethodParameter(strfmt("::mlir::{0}StorageAllocator &", valueType),
                       "allocator"),
       MethodParameter("const KeyTy &", "tblgenKey"));
   if (!def.hasStorageCustomConstructor()) {
     auto &body = construct->body().indent();
-    for (auto it : llvm::enumerate(params)) {
+    for (const auto &it : llvm::enumerate(params)) {
       body << formatv("auto {0} = std::get<{1}>(tblgenKey);\n",
                       it.value().getName(), it.index());
     }
     // Use the parameters' custom allocator code, if provided.
     FmtContext ctx = FmtContext().addSubst("_allocator", "allocator");
     for (auto &param : params) {
       if (Optional<StringRef> allocCode = param.getAllocator()) {
         ctx.withSelf(param.getName()).addSubst("_dst", param.getName());

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

void consumeToken() {
     curToken = lexer.lexToken();
   }
 
   /// Parse any element.
   FailureOr<std::unique_ptr<Element>> parseElement(ParserContext ctx);
   /// Parse a literal element.
   FailureOr<std::unique_ptr<Element>> parseLiteral(ParserContext ctx);
   /// Parse a variable element.
-  FailureOr<std::unique_ptr<Element>> parseVariable(ParserContext ctx);
+  FailureOr<std::unique_ptr<Element>> parseVariable();
   /// Parse a directive.
   FailureOr<std::unique_ptr<Element>> parseDirective(ParserContext ctx);
   /// Parse a `params` directive.
   FailureOr<std::unique_ptr<Element>> parseParamsDirective();
   /// Parse a `struct` directive.
   FailureOr<std::unique_ptr<Element>> parseStructDirective();
 
   /// The current format lexer.
FailureOr<AttrOrTypeFormat> FormatParser::parse() {
   return AttrOrTypeFormat(def, std::move(elements));
 }
 
 FailureOr<std::unique_ptr<Element>>
 FormatParser::parseElement(ParserContext ctx) {
   if (curToken.getKind() == FormatToken::literal)
     return parseLiteral(ctx);
   if (curToken.getKind() == FormatToken::variable)
-    return parseVariable(ctx);
+    return parseVariable();
   if (curToken.isKeyword())
     return parseDirective(ctx);
 
   return emitError("expected literal, directive, or variable");
 }
 
 FailureOr<std::unique_ptr<Element>>
 FormatParser::parseLiteral(ParserContext ctx) {
if (!isValidLiteral(value, [&](Twine diag) {
                         "': " + diag);
       }))
     return failure();
 
   consumeToken();
   return {std::make_unique<LiteralElement>(value)};
 }
 
-FailureOr<std::unique_ptr<Element>>
-FormatParser::parseVariable(ParserContext ctx) {
+FailureOr<std::unique_ptr<Element>> FormatParser::parseVariable() {
   /// Get the parameter name without the preceding "$".
   auto name = curToken.getSpelling().drop_front();
 
   /// Lookup the parameter.
   ArrayRef<AttrOrTypeParameter> params = def.getParameters();
   auto *it = llvm::find_if(
       params, [&](auto &param) { return param.getName() == name; });
 
FormatParser::parseDirective(ParserContext ctx) {
   }
 }
 
 FailureOr<std::unique_ptr<Element>> FormatParser::parseParamsDirective() {
   consumeToken();
   /// Collect all of the attribute's or type's parameters.
   SmallVector<std::unique_ptr<Element>> vars;
   /// Ensure that none of the parameters have already been captured.
-  for (auto it : llvm::enumerate(def.getParameters())) {
+  for (const auto &it : llvm::enumerate(def.getParameters())) {
     if (seenParams.test(it.index())) {
       return emitError("`params` captures duplicate parameter: " +
                        it.value().getName());
     }
     seenParams.set(it.index());
     vars.push_back(std::make_unique<VariableElement>(it.value()));
   }
   return {std::make_unique<ParamsDirective>(std::move(vars))};

mlir/tools/mlir-tblgen/DialectGen.cpp

 /// The code block for the op interface fallback hook.
 static const char *const operationInterfaceFallbackDecl = R"(
     /// Provides a hook for op interface.
     void *getRegisteredInterfaceForOp(mlir::TypeID interfaceID,
                                       mlir::OperationName opName) override;
 )";
 
 /// Generate the declaration for the given dialect class.
-static void emitDialectDecl(Dialect &dialect,
-                            iterator_range<DialectFilterIterator> dialectAttrs,
-                            iterator_range<DialectFilterIterator> dialectTypes,
-                            raw_ostream &os) {
+static void
+emitDialectDecl(Dialect &dialect,
+                const iterator_range<DialectFilterIterator> &dialectAttrs,
+                const iterator_range<DialectFilterIterator> &dialectTypes,
   /// Build the list of dependent dialects
   std::string dependentDialectRegistrations;
   {
     llvm::raw_string_ostream dialectsOs(dependentDialectRegistrations);
     for (StringRef dependentDialect : dialect.getDependentDialects())
       dialectsOs << llvm::formatv(dialectRegistrationTemplate,
                                   dependentDialect);
   }

mlir/tools/mlir-tblgen/DirectiveCommonGen.cpp

 // ODS. The emitDecls function below currently generates these enumerations. The
 // name of the enumeration is specified in the enumClauseValue field of
 // Clause record in OMP.td. This name can be used to specify the type of the
 // OpenMP operation's operand. The allowedClauseValues field provides the list
 // of ClauseValues which are part of the enumeration.
 static bool emitDecls(const RecordKeeper &recordKeeper, raw_ostream &os) {
   const auto &directiveLanguages =
       recordKeeper.getAllDerivedDefinitions("DirectiveLanguage");
-  assert(directiveLanguages.size() != 0 && "DirectiveLanguage missing.");
+  assert(!directiveLanguages.empty() && "DirectiveLanguage missing.");
 
   const auto &clauses = recordKeeper.getAllDerivedDefinitions("Clause");
 
   for (const auto &r : clauses) {
     Clause c{r};
     const auto &clauseVals = c.getClauseVals();
-    if (clauseVals.size() <= 0)
+    if (clauseVals.empty())
       continue;
 
     const auto enumName = c.getEnumName();
-    assert(enumName.size() != 0 && "enumClauseValue field not set.");
+    assert(!enumName.empty() && "enumClauseValue field not set.");
 
     std::vector<std::string> cvDefs;
     for (const auto &cv : clauseVals) {
       ClauseVal cval{cv};
       if (!cval.isUserVisible())
         continue;
 
       const auto name = cval.getFormattedName();

mlir/tools/mlir-tblgen/EnumsGen.cpp

 static std::string makeIdentifier(StringRef str) {
   if (!str.empty() && isDigit(static_cast<unsigned char>(str.front()))) {
     std::string newStr = std::string("_") + str.str();
     return newStr;
   }
   return str.str();
 }
 
-static void emitEnumClass(const Record &enumDef, StringRef enumName,
-                          StringRef underlyingType, StringRef description,
+static void emitEnumClass(StringRef enumName, StringRef underlyingType,
+                          StringRef description,
                           const std::vector<EnumAttrCase> &enumerants,
                           raw_ostream &os) {
   os << "// " << description << "\n";
   os << "enum class " << enumName;
 
   if (!underlyingType.empty())
     os << " : " << underlyingType;
   os << " {\n";
static void emitEnumDecl(const Record &enumDef, raw_ostream &os) {
 
   llvm::SmallVector<StringRef, 2> namespaces;
   llvm::SplitString(cppNamespace, namespaces, "::");
 
   for (auto ns : namespaces)
     os << "namespace " << ns << " {\n";
 
   // Emit the enum class definition
-  emitEnumClass(enumDef, enumName, underlyingType, description, enumerants, os);
+  emitEnumClass(enumName, underlyingType, description, enumerants, os);
 
   // Emit conversion function declarations
   if (llvm::all_of(enumerants, [](EnumAttrCase enumerant) {
         return enumerant.getValue() >= 0;
       })) {
     os << formatv(
         "::llvm::Optional<{0}> {1}({2});\n", enumName, underlyingToSymFnName,
         underlyingType.empty() ? std::string("unsigned") : underlyingType);

mlir/tools/mlir-tblgen/LLVMIRIntrinsicGen.cpp

 }
 
 /// Return the indices of the definitions in a list of definitions that
 /// represent overloadable types
 static IndicesTy getOverloadableTypeIdxs(const llvm::Record &record,
                                          const char *listName) {
   auto results = record.getValueAsListOfDefs(listName);
   IndicesTy overloadedOps(results.size());
-  for (auto r : llvm::enumerate(results)) {
+  for (const auto &r : llvm::enumerate(results)) {
     llvm::MVT::SimpleValueType vt = getValueType(r.value());
     switch (vt) {
     case llvm::MVT::iAny:
     case llvm::MVT::fAny:
     case llvm::MVT::Any:
     case llvm::MVT::iPTRAny:
     case llvm::MVT::vAny:
       overloadedOps.set(r.index());

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 // instead of
 // "{0}" marker in the pattern.  Note that the pattern should work for any kind
 // of ops, in particular for one-operand ops that may not have the
 // `getOperand(unsigned)` method.
 static void generateNamedOperandGetters(const Operator &op, Class &opClass,
                                         bool isAdaptor, StringRef sizeAttrInit,
                                         StringRef rangeType,
                                         StringRef rangeBeginCall,
-                                        StringRef rangeSizeCall,
-                                        StringRef getOperandCallPattern) {
+                                        StringRef rangeSizeCall) {
   const int numOperands = op.getNumOperands();
   const int numVariadicOperands = op.getNumVariableLengthOperands();
   const int numNormalOperands = numOperands - numVariadicOperands;
 
   const auto *sameVariadicSize =
       op.getTrait("::mlir::OpTrait::SameVariadicOperandSize");
   const auto *attrSizedOperands =
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
void OpEmitter::genNamedOperandGetters() {
   }
 
   generateNamedOperandGetters(
       op, opClass,
       /*isAdaptor=*/false,
       /*sizeAttrInit=*/attrSizeInitCode,
       /*rangeType=*/"::mlir::Operation::operand_range",
       /*rangeBeginCall=*/"getOperation()->operand_begin()",
-      /*rangeSizeCall=*/"getOperation()->getNumOperands()",
-      /*getOperandCallPattern=*/"getOperation()->getOperand({0})");
+      /*rangeSizeCall=*/"getOperation()->getNumOperands()");
 }
 
 void OpEmitter::genNamedOperandSetters() {
   auto *attrSizedOperands =
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
   for (int i = 0, e = op.getNumOperands(); i != e; ++i) {
     const auto &operand = op.getOperand(i);
     if (operand.name.empty())
)";
   };
   if (values.empty() || llvm::all_of(values, canSkip))
     return;
 
   FmtContext fctx;
 
   body << "  {\n    unsigned index = 0; (void)index;\n";
 
-  for (auto staticValue : llvm::enumerate(values)) {
+  for (const auto &staticValue : llvm::enumerate(values)) {
     const NamedTypeConstraint &value = staticValue.value();
 
     bool hasPredicate = value.hasPredicate();
     bool isOptional = value.isOptional();
     bool isVariadicOfVariadic = value.isVariadicOfVariadic();
     if (!hasPredicate && !isOptional && !isVariadicOfVariadic)
       continue;
     body << formatv("    auto valueGroup{2} = getODS{0}{1}s({2});\n",
)";
   const auto canSkip = [](const NamedRegion &region) {
     return region.constraint.getPredicate().isNull();
   };
   auto regions = op.getRegions();
   if (regions.empty() && llvm::all_of(regions, canSkip))
     return;
 
   body << "  {\n    unsigned index = 0; (void)index;\n";
-  for (auto it : llvm::enumerate(regions)) {
+  for (const auto &it : llvm::enumerate(regions)) {
     const auto &region = it.value();
     if (canSkip(region))
       continue;
 
     auto getRegion = region.isVariadic()
                          ? formatv("{0}()", op.getGetterName(region.name)).str()
                          : formatv(getSingleRegion, it.index()).str();
     auto constraintFn =
const auto *attrSizedOperands =
     m->body() << "  return odsOperands;";
   }
   std::string attr = "operand_segment_sizes";
   std::string sizeAttrInit = formatv(adapterSegmentSizeAttrInitCode, attr);
   generateNamedOperandGetters(op, adaptor,
                               /*isAdaptor=*/true, sizeAttrInit,
                               /*rangeType=*/"::mlir::ValueRange",
                               /*rangeBeginCall=*/"odsOperands.begin()",
-                              /*rangeSizeCall=*/"odsOperands.size()",
-                              /*getOperandCallPattern=*/"odsOperands[{0}]");
+                              /*rangeSizeCall=*/"odsOperands.size()");
 
   FmtContext fctx;
   fctx.withBuilder("::mlir::Builder(odsAttrs.getContext())");
 
   auto emitAttr = [&](StringRef name, StringRef emitName, Attribute attr) {
     auto *method = adaptor.addMethod(attr.getStorageType(), emitName);
     ERROR_IF_PRUNED(method, "Adaptor::" + emitName, op);
     auto &body = method->body();

mlir/tools/mlir-tblgen/OpDocGen.cpp

do {
     split = split.second.split('\n');
     StringRef formatChunk = split.first.trim();
     if (!formatChunk.empty())
       os.indent(indent) << formatChunk << "\n";
   } while (!split.second.empty());
   os << "```\n\n";
 }
 
-static void emitOpTraitsDoc(Operator op, raw_ostream &os) {
+static void emitOpTraitsDoc(const Operator &op, raw_ostream &os) {
   // TODO: We should link to the trait/documentation of it. That also means we
   // should add descriptions to traits that can be queried.
   // Collect using set to sort effects, interfaces & traits.
   std::set<std::string> effects, interfaces, traits;
   for (auto &trait : op.getTraits()) {
     if (isa<PredTrait>(&trait))
       continue;
 
static void emitAttrOrTypeDefAssemblyFormat(const AttrOrTypeDef &def,
   if (parameters.empty()) {
     os << "\nSyntax: `!" << def.getDialect().getName() << "."
        << def.getMnemonic() << "`\n";
     return;
   }
 
   os << "\nSyntax:\n\n```\n!" << def.getDialect().getName() << "."
      << def.getMnemonic() << "<\n";
-  for (auto it : llvm::enumerate(parameters)) {
+  for (const auto &it : llvm::enumerate(parameters)) {
     const AttrOrTypeParameter &param = it.value();
     os << "  " << param.getSyntax();
     if (it.index() < (parameters.size() - 1))
       os << ",";
     os << "   # " << param.getName() << "\n";
   }
   os << ">\n```\n";
 }

mlir/tools/mlir-tblgen/OpFormatGen.cpp

if (lengthKind == ArgumentLengthKind::VariadicOfVariadic) {
       body << llvm::formatv(optionalTypeParserCode, listName);
     } else {
       TypeSwitch<Element *>(dir->getOperand())
           .Case<OperandVariable, ResultVariable>([&](auto operand) {
             body << formatv(typeParserCode,
                             operand->getVar()->constraint.getCPPClassName(),
                             listName);
           })
-          .Default([&](auto operand) {
+          .Default([&](auto /*operand*/) {
             body << formatv(typeParserCode, "Type", listName);
           });
     }
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
     ArgumentLengthKind ignored;
     body << formatv(functionalTypeParserCode,
                     getTypeListName(dir->getInputs(), ignored),
                     getTypeListName(dir->getResults(), ignored));
private:
   /// same type as all of the operands.
   void handleSameTypesConstraint(
       llvm::StringMap<TypeResolutionInstance> &variableTyResolver,
       bool includeResults);
   /// Check for inferable type resolution based on another operand, result, or
   /// attribute.
   void handleTypesMatchConstraint(
       llvm::StringMap<TypeResolutionInstance> &variableTyResolver,
-      llvm::Record def);
+      const llvm::Record &def);
 
   /// Returns an argument or attribute with the given name that has been seen
   /// within the format.
   ConstArgument findSeenArg(StringRef name);
 
   /// Parse a specific element.
   LogicalResult parseElement(std::unique_ptr<Element> &element,
                              ParserContext context);
if (includeResults) {
     for (unsigned i = 0, e = op.getNumResults(); i != e; ++i)
       if (!seenResultTypes.test(i) && !op.getResultName(i).empty())
         variableTyResolver[op.getResultName(i)] = {resolver, llvm::None};
   }
 }
 
 void FormatParser::handleTypesMatchConstraint(
     llvm::StringMap<TypeResolutionInstance> &variableTyResolver,
-    llvm::Record def) {
+    const llvm::Record &def) {
   StringRef lhsName = def.getValueAsString("lhs");
   StringRef rhsName = def.getValueAsString("rhs");
   StringRef transformer = def.getValueAsString("transformer");
   if (ConstArgument arg = findSeenArg(lhsName))
     variableTyResolver[rhsName] = {arg, transformer};
 }
 
 ConstArgument FormatParser::findSeenArg(StringRef name) {

mlir/tools/mlir-tblgen/OpInterfacesGen.cpp

struct TypeInterfaceGenerator : public InterfaceGenerator {
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // GEN: Interface definitions
 //===----------------------------------------------------------------------===//
 
-static void emitInterfaceDef(Interface interface, StringRef valueType,
+static void emitInterfaceDef(const Interface &interface, StringRef valueType,
                              raw_ostream &os) {
   StringRef interfaceName = interface.getName();
   StringRef cppNamespace = interface.getCppNamespace();
   cppNamespace.consume_front("::");
 
   // Insert the method definitions.
   bool isOpInterface = isa<OpInterface>(interface);
   for (auto &method : interface.getMethods()) {

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

static void emitRegionAttributes(const Operator &op, raw_ostream &os) {
   // Note that the base OpView class defines this as (0, True).
   unsigned minRegionCount = op.getNumRegions() - op.getNumVariadicRegions();
   os << llvm::formatv(opClassRegionSpecTemplate, minRegionCount,
                       op.hasNoVariadicRegions() ? "True" : "False");
 }
 
 /// Emits named accessors to regions.
 static void emitRegionAccessors(const Operator &op, raw_ostream &os) {
-  for (auto en : llvm::enumerate(op.getRegions())) {
+  for (const auto &en : llvm::enumerate(op.getRegions())) {
     const NamedRegion &region = en.value();
     if (region.name.empty())
       continue;
 
     assert((!region.isVariadic() || en.index() == op.getNumRegions() - 1) &&
            "expected only the last region to be variadic");
     os << llvm::formatv(regionAccessorTemplate, sanitizeName(region.name),
                         std::to_string(en.index()) +

mlir/tools/mlir-tblgen/RewriterGen.cpp

 using llvm::RecordKeeper;
 
 #define DEBUG_TYPE "mlir-tblgen-rewritergen"
 
 namespace llvm {
 template <>
 struct format_provider<mlir::tblgen::Pattern::IdentifierLine> {
   static void format(const mlir::tblgen::Pattern::IdentifierLine &v,
-                     raw_ostream &os, StringRef style) {
+                     raw_ostream &os, StringRef /*style*/) {
     os << v.first << ":" << v.second;
   }
 };
 } // namespace llvm
 
 //===----------------------------------------------------------------------===//
 // PatternEmitter
 //===----------------------------------------------------------------------===//
private:
   // Emits C++ statements for matching the operands which can be matched in
   // either order.
   void emitEitherOperandMatch(DagNode tree, DagNode eitherArgTree,
                               StringRef opName, int argIndex, int &operandIndex,
                               int depth);
 
   // Emits C++ statements for matching the `argIndex`-th argument of the given
   // DAG `tree` as an attribute.
-  void emitAttributeMatch(DagNode tree, StringRef opName, int argIndex,
-                          int depth);
+  void emitAttributeMatch(DagNode tree, StringRef opName, int argIndex);
 
   // Emits C++ for checking a match with a corresponding match failure
   // diagnostic.
   void emitMatchCheck(StringRef opName, const FmtObjectBase &matchFmt,
                       const llvm::formatv_object_base &failureFmt);
 
   // Emits C++ for checking a match with a corresponding match failure
   // diagnostics.
private:
 
   // Emits a local variable for each value and attribute to be used for creating
   // an op.
   void createSeparateLocalVarsForOpArgs(DagNode node,
                                         ChildNodeIndexNameMap &childNodeNames);
 
   // Emits the concrete arguments used to call an op's builder.
   void supplyValuesForOpArgs(DagNode node,
-                             const ChildNodeIndexNameMap &childNodeNames,
-                             int depth);
+                             const ChildNodeIndexNameMap &childNodeNames);
 
   // Emits the local variables for holding all values as a whole and all named
   // attributes as a whole to be used for creating an op.
   void createAggregateLocalVarsForOpArgs(
-      DagNode node, const ChildNodeIndexNameMap &childNodeNames, int depth);
+      DagNode node, const ChildNodeIndexNameMap &childNodeNames);
 
   // Returns the C++ expression to construct a constant attribute of the given
   // `value` for the given attribute kind `attr`.
   std::string handleConstantAttr(Attribute attr, const Twine &value);
 
   // Returns the C++ expression to build an argument from the given DAG `leaf`.
   // `patArgName` is used to bound the argument to the source pattern.
   std::string handleOpArgument(DagLeaf leaf, StringRef patArgName);
public:
   // Collect the `Record`s, i.e., the DRR, so that we can get the information of
   // the duplicated DAGs.
   void addPattern(Record *record);
 
   // Emit all static functions of DAG Matcher.
   void populateStaticMatchers(raw_ostream &os);
 
   // Emit all static functions for Constraints.
-  void populateStaticConstraintFunctions(raw_ostream &os);
+  void populateStaticConstraintFunctions();
 
 private:
   static constexpr unsigned kStaticMatcherThreshold = 1;
 
   // Consider two patterns as down below,
   //   DagNode_Root_A    DagNode_Root_B
   //       \                 \
   //     DagNode_C         DagNode_C
if (opArg.is<NamedTypeConstraint *>()) {
       auto operandName =
           formatv("{0}.getODSOperands({1})", castedName, nextOperand);
       emitOperandMatch(tree, castedName, operandName.str(),
                        /*operandMatcher=*/tree.getArgAsLeaf(i),
                        /*argName=*/tree.getArgName(i),
                        /*argIndex=*/i);
       ++nextOperand;
     } else if (opArg.is<NamedAttribute *>()) {
-      emitAttributeMatch(tree, opName, i, depth);
+      emitAttributeMatch(tree, opName, i);
     } else {
       PrintFatalError(loc, "unhandled case when matching op");
     }
   }
   LLVM_DEBUG(llvm::dbgs() << "done emitting match for op '"
                           << op.getOperationName() << "' at depth " << depth
                           << '\n');
 }
os << formatv("if(failed({0}(eitherOperand0, eitherOperand1)) && "
                 "eitherOperand0)))\n",
                 lambda);
   os.indent() << "return failure();\n";
 
   os.unindent().unindent() << "}\n";
 }
 
 void PatternEmitter::emitAttributeMatch(DagNode tree, StringRef opName,
-                                        int argIndex, int depth) {
+                                        int argIndex) {
   Operator &op = tree.getDialectOp(opMap);
   auto *namedAttr = op.getArg(argIndex).get<NamedAttribute *>();
   const auto &attr = namedAttr->attr;
 
   os << "{\n";
   os.indent() << formatv("auto tblgen_attr = {0}->getAttrOfType<{1}>(\"{2}\");"
                          "(void)tblgen_attr;\n",
                          opName, attr.getStorageType(), namedAttr->name);
bool useFirstAttr =
       resultOp.getTrait("::mlir::OpTrait::FirstAttrDerivedResultType");
 
   if (!tail.returnType && (isSameOperandsAndResultType || useFirstAttr)) {
     // We know how to deduce the result type for ops with these traits and we've
     // generated builders taking aggregate parameters. Use those builders to
     // create the ops.
 
     // First prepare local variables for op arguments used in builder call.
-    createAggregateLocalVarsForOpArgs(tree, childNodeNames, depth);
+    createAggregateLocalVarsForOpArgs(tree, childNodeNames);
 
     // Then create the op.
     os.scope("", "\n}\n").os << formatv(
         "{0} = rewriter.create<{1}>({2}, tblgen_values, tblgen_attrs);",
         valuePackName, resultOp.getQualCppClassName(), locToUse);
     return resultValue;
   }
 
   bool usePartialResults = valuePackName != resultValue;
 
   if (!tail.returnType && (usePartialResults || depth > 0 || resultIndex < 0)) {
     // For these cases (broadcastable ops, op results used both as auxiliary
     // values and replacement values, ops in nested patterns, auxiliary ops), we
     // still need to supply the result types when building the op. But because
     // we don't generate a builder automatically with ODS for them, it's the
     // developer's responsibility to make sure such a builder (with result type
     // deduction ability) exists. We go through the separate-parameter builder
     // here given that it's easier for developers to write compared to
     // aggregate-parameter builders.
     createSeparateLocalVarsForOpArgs(tree, childNodeNames);
 
     os.scope().os << formatv("{0} = rewriter.create<{1}>({2}", valuePackName,
                              resultOp.getQualCppClassName(), locToUse);
-    supplyValuesForOpArgs(tree, childNodeNames, depth);
+    supplyValuesForOpArgs(tree, childNodeNames);
     os << "\n  );\n}\n";
     return resultValue;
   }
 
   // If we are provided explicit return types, use them to build the op.
   // However, if depth == 0 and resultIndex >= 0, it means we are replacing
   // the values generated from the source pattern root op. Then we must use the
   // source pattern's value types to determine the value type of the generated
   // op here.
   if (depth == 0 && resultIndex >= 0 && tail.returnType)
     PrintFatalError(loc, "Cannot specify explicit return types in an op whose "
                          "return values replace the source pattern's root op");
 
   // First prepare local variables for op arguments used in builder call.
-  createAggregateLocalVarsForOpArgs(tree, childNodeNames, depth);
+  createAggregateLocalVarsForOpArgs(tree, childNodeNames);
 
   // Then prepare the result types. We need to specify the types for all
   // results.
   os.indent() << formatv("::mlir::SmallVector<::mlir::Type, 4> tblgen_types; "
                          "(void)tblgen_types;\n");
   int numResults = resultOp.getNumResults();
   if (tail.returnType) {
     auto numRetTys = tail.returnType.getNumArgs();
for (int argIndex = 0, e = resultOp.getNumArgs(); argIndex < e; ++argIndex) {
     }
 
     // Update to use the newly created local variable for building the op later.
     childNodeNames[argIndex] = varName;
   }
 }
 
 void PatternEmitter::supplyValuesForOpArgs(
-    DagNode node, const ChildNodeIndexNameMap &childNodeNames, int depth) {
+    DagNode node, const ChildNodeIndexNameMap &childNodeNames) {
   Operator &resultOp = node.getDialectOp(opMap);
   for (int argIndex = 0, numOpArgs = resultOp.getNumArgs();
        argIndex != numOpArgs; ++argIndex) {
     // Start each argument on its own line.
     os << ",\n    ";
 
     Argument opArg = resultOp.getArg(argIndex);
     // Handle the case of operand first.
if (auto subTree = node.getArgAsNestedDag(argIndex)) {
         os << "/*" << opArgName << "=*/";
       }
       os << handleOpArgument(leaf, patArgName);
     }
   }
 }
 
 void PatternEmitter::createAggregateLocalVarsForOpArgs(
-    DagNode node, const ChildNodeIndexNameMap &childNodeNames, int depth) {
+    DagNode node, const ChildNodeIndexNameMap &childNodeNames) {
   Operator &resultOp = node.getDialectOp(opMap);
 
   auto scope = os.scope();
   os << formatv("::mlir::SmallVector<::mlir::Value, 4> "
                 "tblgen_values; (void)tblgen_values;\n");
   os << formatv("::mlir::SmallVector<::mlir::NamedAttribute, 4> "
                 "tblgen_attrs; (void)tblgen_attrs;\n");
 
std::string funcName =
         formatv("static_dag_matcher_{0}", staticMatcherCounter++);
     assert(matcherNames.find(node) == matcherNames.end());
     PatternEmitter(dagInfo.second, &opMap, os, *this)
         .emitStaticMatcher(node, funcName);
     matcherNames[node] = funcName;
   }
 }
 
-void StaticMatcherHelper::populateStaticConstraintFunctions(raw_ostream &os) {
+void StaticMatcherHelper::populateStaticConstraintFunctions() {
   staticVerifierEmitter.emitPatternConstraints(constraints);
 }
 
 void StaticMatcherHelper::addPattern(Record *record) {
   Pattern pat(record, &opMap);
 
   // While generating the function body of the DAG matcher, it may depends on
   // other DAG matchers. To ensure the dependent matchers are ready, we compute
static void emitRewriters(const RecordKeeper &recordKeeper, raw_ostream &os) {
   // We put the map here because it can be shared among multiple patterns.
   RecordOperatorMap recordOpMap;
 
   // Exam all the patterns and generate static matcher for the duplicated
   // DagNode.
   StaticMatcherHelper staticMatcher(os, recordKeeper, recordOpMap);
   for (Record *p : patterns)
     staticMatcher.addPattern(p);
-  staticMatcher.populateStaticConstraintFunctions(os);
+  staticMatcher.populateStaticConstraintFunctions();
   staticMatcher.populateStaticMatchers(os);
 
   std::vector<std::string> rewriterNames;
   rewriterNames.reserve(patterns.size());
 
   std::string baseRewriterName = "GeneratedConvert";
   int rewriterIndex = 0;
 

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

os << tabs
               opVar, resultID);
     os << tabs << "    return failure();\n";
     os << tabs << "  }\n";
     os << tabs << "}\n";
   }
 }
 
 /// Generates code to serialize an SPV_Op `op` into `os`.
-static void emitSerializationFunction(const Record *attrClass,
-                                      const Record *record, const Operator &op,
+static void emitSerializationFunction(const Record *record, const Operator &op,
                                       raw_ostream &os) {
   // If the record has 'autogenSerialization' set to 0, nothing to do
   if (!record->getValueAsBit("autogenSerialization"))
     return;
 
   StringRef opVar("op"), operands("operands"), elidedAttrs("elidedAttrs"),
       resultID("resultID");
 
os << tabs
        << formatv("  auto attrs = decorations[{0}].getAttrs();\n", valueID);
     os << tabs
        << formatv("  {0}.append(attrs.begin(), attrs.end());\n", attributes);
     os << tabs << "}\n";
   }
 }
 
 /// Generates code to deserialize an SPV_Op `op` into `os`.
-static void emitDeserializationFunction(const Record *attrClass,
-                                        const Record *record,
+static void emitDeserializationFunction(const Record *record,
                                         const Operator &op, raw_ostream &os) {
   // If the record has 'autogenSerialization' set to 0, nothing to do
   if (!record->getValueAsBit("autogenSerialization"))
     return;
 
   StringRef resultTypes("resultTypes"), valueID("valueID"), words("words"),
       wordIndex("wordIndex"), opVar("op"), operands("operands"),
       attributes("attributes");
static bool emitSerializationFns(const RecordKeeper &recordKeeper,
   StringRef opcode("opcode"), words("words");
 
   // Handle the SPIR-V ops.
   initDispatchSerializationFn(opVar, dSerFn);
   initDispatchDeserializationFn(opcode, words, dDesFn);
   auto defs = recordKeeper.getAllDerivedDefinitions("SPV_Op");
   for (const auto *def : defs) {
     Operator op(def);
-    emitSerializationFunction(attrClass, def, op, serFn);
-    emitDeserializationFunction(attrClass, def, op, deserFn);
+    emitSerializationFunction(def, op, serFn);
+    emitDeserializationFunction(def, op, deserFn);
     if (def->getValueAsBit("hasOpcode") || def->isSubClassOf("SPV_ExtInstOp")) {
       emitSerializationDispatch(op, "  ", opVar, dSerFn);
     }
     if (def->getValueAsBit("hasOpcode")) {
       emitDeserializationDispatch(op, def, "  ", words, dDesFn);
     }
   }
   finalizeDispatchSerializationFn(opVar, dSerFn);

mlir/tools/mlir-tblgen/StructsGen.cpp

 using llvm::raw_ostream;
 using llvm::Record;
 using llvm::RecordKeeper;
 using llvm::StringRef;
 using mlir::tblgen::FmtContext;
 using mlir::tblgen::StructAttr;
 
 static void
-emitStructClass(const Record &structDef, StringRef structName,
+emitStructClass(StringRef structName,
                 llvm::ArrayRef<mlir::tblgen::StructFieldAttr> fields,
                 StringRef description, raw_ostream &os) {
   const char *structInfo = R"(
 // {0}
 class {1} : public ::mlir::DictionaryAttr)";
   const char *structInfoEnd = R"( {
 public:
   using ::mlir::DictionaryAttr::DictionaryAttr;
static void emitStructDecl(const Record &structDef, raw_ostream &os) {
   // Wrap in the appropriate namespace.
   llvm::SmallVector<StringRef, 2> namespaces;
   llvm::SplitString(cppNamespace, namespaces, "::");
 
   for (auto ns : namespaces)
     os << "namespace " << ns << " {\n";
 
   // Emit the struct class definition
-  emitStructClass(structDef, structName, fields, description, os);
+  emitStructClass(structName, fields, description, os);
 
   // Close the declared namespace.
   for (auto ns : namespaces)
     os << "} // namespace " << ns << "\n";
 }
 
 static bool emitStructDecls(const RecordKeeper &recordKeeper, raw_ostream &os) {
   llvm::emitSourceFileHeader("Struct Utility Declarations", os);

mlir/tools/mlir-tblgen/mlir-tblgen.cpp

 #include "llvm/TableGen/TableGenBackend.h"
 
 using namespace llvm;
 using namespace mlir;
 
 static llvm::ManagedStatic<std::vector<GenInfo>> generatorRegistry;
 
 mlir::GenRegistration::GenRegistration(StringRef arg, StringRef description,
-                                       GenFunction function) {
+                                       const GenFunction &function) {
   generatorRegistry->emplace_back(arg, description, function);
 }
 
 GenNameParser::GenNameParser(llvm::cl::Option &opt)
     : llvm::cl::parser<const GenInfo *>(opt) {
   for (const auto &kv : *generatorRegistry) {
     addLiteralOption(kv.getGenArgument(), &kv, kv.getGenDescription());
   }