Demo fix for misc-unused-parameters (WIP)

[Mogball]

This one is a no vote from me:

• inline comments /*foo*/ are annoying to edit
• function signatures with a /*bunch*/ /*of*/ /*commented*/ /*out*/ arguments is ugly
• +1 for automatically removing unused function arguments though

[jpienaar]

I find the approach in
https://google.github.io/styleguide/cppguide.html#Function_Declarations_and_Definitions useful: omit what is obvious, make explicit and named what is not (well if nowhere used, not staged, and no planned use, then removing better). I like it being explicit when unused and having local context of names. It does put the load on whomever updates the function (to use variable) or signature (if one adds params) to edit, and that's good IMHO (it can get out of date though, as nothing flags it until actually used). Updating frequency is unknown (but if one clang-rewrite it, it is simple to mechanically do). There are tradeoffs, but documented locally is clearer to me.

[mehdi_amini]

• inline comments /*foo*/ are annoying to edit

Code is written once, read multiple times :)
And how many times would you actually need to edit the comment though? (that is, how often will you introduce a new use of an argument unused until now?).

• +1 for automatically removing unused function arguments though

We would need to patch clang-tidy to add an option to not comment out and only remove, it does not exist right now.

[rriddle]

I'm +1 on removing unused arguments, but the argument name comments still feel a bit annoying to write/interact with. Though it doesn't look like there are too many of them, so maybe not that bad in the long run. Are the comment params something that clang-tidy can flag for mismatch? i.e. if the declaration of the argument is changed, does the comment get flagged for being out-of-date?

[mehdi_amini]

In D116246#3215933, @rriddle wrote:

I'm +1 on removing unused arguments, but the argument name comments still feel a bit annoying to write/interact with.

D116488 for an alternative.

Though it doesn't look like there are too many of them, so maybe not that bad in the long run. Are the comment params something that clang-tidy can flag for mismatch? i.e. if the declaration of the argument is changed, does the comment get flagged for being out-of-date?

Maybe not, but we can likely implement this as well :)

[mehdi_amini]

In D116246#3215981, @mehdi_amini wrote:

In D116246#3215933, @rriddle wrote:

I'm +1 on removing unused arguments, but the argument name comments still feel a bit annoying to write/interact with.

D116488 for an alternative.

D116501 for the application with the new option

[jpienaar]

In D116246#3215933, @rriddle wrote:

I'm +1 on removing unused arguments, but the argument name comments still feel a bit annoying to write/interact with. Though it doesn't look like there are too many of them, so maybe not that bad in the long run. Are the comment params something that clang-tidy can flag for mismatch? i.e. if the declaration of the argument is changed, does the comment get flagged for being out-of-date?

That seems easy to add and mechanical to update if it isn't there. I think the workflow is probably, copy the signature you want to implement, use what you do, run clang-tidy (so you never really have to even write these). Then upon updates we rerun clang-tidy. Now I do run clang-tidy and clang-format often, so no change in my workflow really :-) this inconvenience is easy to address in the tooling.

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

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>();

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())

mlir/lib/Dialect/DLTI/DLTI.cpp

 } // 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/IR/QuantOps.cpp

void QuantizationDialect::initialize() {
   addTypes<AnyQuantizedType, CalibratedQuantizedType, UniformQuantizedType,
            UniformQuantizedPerAxisType>();
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Quant/QuantOps.cpp.inc"
       >();
 }
 
-OpFoldResult StorageCastOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult StorageCastOp::fold(ArrayRef<Attribute> /*operands*/) {
   // Matches x -> [scast -> scast] -> y, replacing the second scast with the
   // value of x if the casts invert each other.
   auto srcScastOp = arg().getDefiningOp<StorageCastOp>();
   if (!srcScastOp || srcScastOp.arg().getType() != getType())
     return OpFoldResult();
   return srcScastOp.arg();
 }
 

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

 }
 
 bool QuantizedType::classof(Type type) {
   return llvm::isa<QuantizationDialect>(type.getDialect());
 }
 
 LogicalResult
 QuantizedType::verify(function_ref<InFlightDiagnostic()> emitError,
-                      unsigned flags, Type storageType, Type expressedType,
+                      unsigned flags, Type storageType, Type /*expressedType*/,
                       int64_t storageTypeMin, int64_t storageTypeMax) {
   // Verify that the storage type is integral.
   // This restriction may be lifted at some point in favor of using bf16
   // or f16 as exact representations on hardware where that is advantageous.
   auto intStorageType = storageType.dyn_cast<IntegerType>();
   if (!intStorageType)
     return emitError() << "storage type must be integral";
   unsigned integralWidth = intStorageType.getWidth();
UniformQuantizedType UniformQuantizedType::getChecked(
     int64_t storageTypeMin, int64_t storageTypeMax) {
   return Base::getChecked(emitError, storageType.getContext(), flags,
                           storageType, expressedType, scale, zeroPoint,
                           storageTypeMin, storageTypeMax);
 }
 
 LogicalResult UniformQuantizedType::verify(
     function_ref<InFlightDiagnostic()> emitError, unsigned flags,
-    Type storageType, Type expressedType, double scale, int64_t zeroPoint,
+    Type storageType, Type expressedType, double scale, int64_t /*zeroPoint*/,
     int64_t storageTypeMin, int64_t storageTypeMax) {
   if (failed(QuantizedType::verify(emitError, flags, storageType, expressedType,
                                    storageTypeMin, storageTypeMax))) {
     return failure();
   }
 
   // Uniform quantization requires fully expressed parameters, including
   // expressed type.
UniformQuantizedPerAxisType UniformQuantizedPerAxisType::getChecked(
   return Base::getChecked(emitError, storageType.getContext(), flags,
                           storageType, expressedType, scales, zeroPoints,
                           quantizedDimension, storageTypeMin, storageTypeMax);
 }
 
 LogicalResult UniformQuantizedPerAxisType::verify(
     function_ref<InFlightDiagnostic()> emitError, unsigned flags,
     Type storageType, Type expressedType, ArrayRef<double> scales,
-    ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
+    ArrayRef<int64_t> zeroPoints, int32_t /*quantizedDimension*/,
     int64_t storageTypeMin, int64_t storageTypeMax) {
   if (failed(QuantizedType::verify(emitError, flags, storageType, expressedType,
                                    storageTypeMin, storageTypeMax))) {
     return failure();
   }
 
   // Uniform quantization requires fully expressed parameters, including
   // expressed type.

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())) {
       SmallVector<Type, 2> decomposedTypes;
       if (failed(typeConverter->convertType(argType.value(), decomposedTypes)))

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);
   }
 
LogicalResult IfOp::inferReturnTypeComponents(
   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.

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);
 
SmallVector<Attribute, 4> reassociationAttr =
       llvm::to_vector<4>(llvm::map_range(
           reassociation, [&](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/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/Linalg/TestLinalgTransforms.cpp

 
 //===----------------------------------------------------------------------===//
 // 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();

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/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/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

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; });
 

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/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())
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/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));

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);