Apply clang-tidy fixes for misc-unused-parameters to MLIR (NFC)

[mehdi_amini]

Summary

Alternative to D116246 with the option in D116488

[bondhugula]

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

148

Isn't there a readability benefit to having the parameter named here albeit unused? Or:

..., bool /*woudBeCloned*/

Do we need to drop the arg names on interface method implementations also albeit unused? The comment on wouldBeCloned above can also be dropped if we are dropping this.

[aartbik]

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

148

I am also a bit old-fashioned that I like to see a parameter name in the *implementation* of a method (not the declaration per se), but if this is the style going forward, am okay with the change of course.

[jpienaar]

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

148

Agreed, I think dropping biases to folks using IDEs & results in an indirection when reading the code (and indeed then keeping the comment above is even less defensible as those same IDEs would provide it too and contrary to the parameter names, it can't be automatically updated). So not particularly fond of this style change.

[mehdi_amini]

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

148

I also prefer the variable name available than this variant.

I didn't get your point in the parenthesis here Jacques, can you expand?

[rriddle]

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

148

+1 on keeping the variable names. I'm okay with the other patch (given that there aren't that many hits in practice), though I would like clang-tidy to alert on mismatch.

mlir/lib/Analysis/AffineAnalysis.cpp

 }
 
 // Computes distance and direction vectors in 'dependences', by adding
 // variables to 'dependenceDomain' which represent the difference of the IVs,
 // eliminating all other variables, and reading off distance vectors from
 // equality constraints (if possible), and direction vectors from inequalities.
 static void computeDirectionVector(
     const FlatAffineValueConstraints &srcDomain,
-    const FlatAffineValueConstraints &dstDomain, unsigned loopDepth,
+    const FlatAffineValueConstraints &dstDomain,
     FlatAffineValueConstraints *dependenceDomain,
     SmallVector<DependenceComponent, 2> *dependenceComponents) {
   // Find the number of common loops shared by src and dst accesses.
   SmallVector<AffineForOp, 4> commonLoops;
   unsigned numCommonLoops =
       getNumCommonLoops(srcDomain, dstDomain, &commonLoops);
   if (numCommonLoops == 0)
     return;
addOrderingConstraints(srcDomain, dstDomain, loopDepth,
                          dependenceConstraints);
 
   // Return 'NoDependence' if the solution space is empty: no dependence.
   if (dependenceConstraints->isEmpty())
     return DependenceResult::NoDependence;
 
   // Compute dependence direction vector and return true.
   if (dependenceComponents != nullptr)
-    computeDirectionVector(srcDomain, dstDomain, loopDepth,
-                           dependenceConstraints, dependenceComponents);
+    computeDirectionVector(srcDomain, dstDomain, dependenceConstraints,
+                           dependenceComponents);
 
   LLVM_DEBUG(llvm::dbgs() << "Dependence polyhedron:\n");
   LLVM_DEBUG(dependenceConstraints->dump());
   return DependenceResult::HasDependence;
 }
 
 /// Gathers dependence components for dependences between all ops in loop nest
 /// rooted at 'forOp' at loop depths in range [1, maxLoopDepth].

mlir/lib/Analysis/AliasAnalysis.cpp

case Kind::ModRef:
     break;
   }
 }
 
 //===----------------------------------------------------------------------===//
 // AliasAnalysis
 //===----------------------------------------------------------------------===//
 
-AliasAnalysis::AliasAnalysis(Operation *op) {
+AliasAnalysis::AliasAnalysis(Operation *) {
   addAnalysisImplementation(LocalAliasAnalysis());
 }
 
 AliasResult AliasAnalysis::alias(Value lhs, Value rhs) {
   // Check each of the alias analysis implemenations for an alias result.
   for (const std::unique_ptr<Concept> &aliasImpl : aliasImpls) {
     AliasResult result = aliasImpl->alias(lhs, rhs);
     if (!result.isMay())

mlir/lib/Analysis/NumberOfExecutions.cpp

while (parentOp != perEntryOfThisRegion->getParentOp()) {
 
     assert(parentOp != nullptr);
   }
 
   return numberOfExecutions;
 }
 
 void NumberOfExecutions::printBlockExecutions(
-    raw_ostream &os, Region *perEntryOfThisRegion) const {
+    raw_ostream &, Region *perEntryOfThisRegion) const {
   unsigned blockId = 0;
 
   operation->walk<WalkOrder::PreOrder>([&](Block *block) {
     llvm::errs() << "Block: " << blockId++ << "\n";
     llvm::errs() << "Number of executions: ";
     if (auto n = getNumberOfExecutions(block, perEntryOfThisRegion))
       llvm::errs() << *n << "\n";
     else
       llvm::errs() << "<unknown>\n";
   });
 }
 
 void NumberOfExecutions::printOperationExecutions(
-    raw_ostream &os, Region *perEntryOfThisRegion) const {
+    raw_ostream &, Region *perEntryOfThisRegion) const {
   operation->walk<WalkOrder::PreOrder>([&](Block *block) {
     block->walk([&](Operation *operation) {
       // Skip the operation that was used to build the analysis.
       if (operation == this->operation)
         return;
 
       llvm::errs() << "Operation: " << operation->getName() << "\n";
       llvm::errs() << "Number of executions: ";

mlir/lib/Analysis/Utils.cpp

if (loopsA[i].getOperation() != loopsB[i].getOperation())
       break;
     ++numCommonLoops;
   }
   return numCommonLoops;
 }
 
 static Optional<int64_t> getMemoryFootprintBytes(Block &block,
                                                  Block::iterator start,
-                                                 Block::iterator end,
-                                                 int memorySpace) {
+                                                 Block::iterator end) {
   SmallDenseMap<Value, std::unique_ptr<MemRefRegion>, 4> regions;
 
   // Walk this 'affine.for' operation to gather all memory regions.
   auto result = block.walk(start, end, [&](Operation *opInst) -> WalkResult {
     if (!isa<AffineReadOpInterface, AffineWriteOpInterface>(opInst)) {
       // Neither load nor a store op.
       return WalkResult::advance();
     }
for (const auto &region : regions) {
     totalSizeInBytes += size.getValue();
   }
   return totalSizeInBytes;
 }
 
 Optional<int64_t> mlir::getMemoryFootprintBytes(AffineForOp forOp,
                                                 int memorySpace) {
   auto *forInst = forOp.getOperation();
-  return ::getMemoryFootprintBytes(
-      *forInst->getBlock(), Block::iterator(forInst),
-      std::next(Block::iterator(forInst)), memorySpace);
+  return ::getMemoryFootprintBytes(*forInst->getBlock(),
+                                   Block::iterator(forInst),
+                                   std::next(Block::iterator(forInst)));
 }
 
 /// Returns whether a loop is parallel and contains a reduction loop.
 bool mlir::isLoopParallelAndContainsReduction(AffineForOp forOp) {
   SmallVector<LoopReduction> reductions;
   if (!isLoopParallel(forOp, &reductions))
     return false;
   return !reductions.empty();

mlir/lib/Bindings/Python/IRAffine.cpp

py::class_<PyAffineExpr>(m, "AffineExpr", py::module_local())
            })
       .def("__rsub__",
            [](PyAffineExpr &self, intptr_t other) {
              return PyAffineAddExpr::getLHSConstant(
                  other, PyAffineMulExpr::getLHSConstant(-1, self));
            })
       .def("__eq__", [](PyAffineExpr &self,
                         PyAffineExpr &other) { return self == other; })
-      .def("__eq__",
-           [](PyAffineExpr &self, py::object &other) { return false; })
+      .def("__eq__", [](PyAffineExpr &, py::object &) { return false; })
       .def("__str__",
            [](PyAffineExpr &self) {
              PyPrintAccumulator printAccum;
              mlirAffineExprPrint(self, printAccum.getCallback(),
                                  printAccum.getUserData());
              return printAccum.join();
            })
       .def("__repr__",
void mlir::python::populateIRAffine(py::module &m) {
   // Mapping of PyAffineMap.
   //----------------------------------------------------------------------------
   py::class_<PyAffineMap>(m, "AffineMap", py::module_local())
       .def_property_readonly(MLIR_PYTHON_CAPI_PTR_ATTR,
                              &PyAffineMap::getCapsule)
       .def(MLIR_PYTHON_CAPI_FACTORY_ATTR, &PyAffineMap::createFromCapsule)
       .def("__eq__",
            [](PyAffineMap &self, PyAffineMap &other) { return self == other; })
-      .def("__eq__", [](PyAffineMap &self, py::object &other) { return false; })
+      .def("__eq__", [](PyAffineMap &, py::object &) { return false; })
       .def("__str__",
            [](PyAffineMap &self) {
              PyPrintAccumulator printAccum;
              mlirAffineMapPrint(self, printAccum.getCallback(),
                                 printAccum.getUserData());
              return printAccum.join();
            })
       .def("__repr__",
void mlir::python::populateIRAffine(py::module &m) {
   // Mapping of PyIntegerSet.
   //----------------------------------------------------------------------------
   py::class_<PyIntegerSet>(m, "IntegerSet", py::module_local())
       .def_property_readonly(MLIR_PYTHON_CAPI_PTR_ATTR,
                              &PyIntegerSet::getCapsule)
       .def(MLIR_PYTHON_CAPI_FACTORY_ATTR, &PyIntegerSet::createFromCapsule)
       .def("__eq__", [](PyIntegerSet &self,
                         PyIntegerSet &other) { return self == other; })
-      .def("__eq__", [](PyIntegerSet &self, py::object other) { return false; })
+      .def("__eq__", [](PyIntegerSet &, py::object) { return false; })
       .def("__str__",
            [](PyIntegerSet &self) {
              PyPrintAccumulator printAccum;
              mlirIntegerSetPrint(self, printAccum.getCallback(),
                                  printAccum.getUserData());
              return printAccum.join();
            })
       .def("__repr__",

mlir/lib/Bindings/Python/IRCore.cpp

 }
 
 static MlirStringRef toMlirStringRef(const std::string &s) {
   return mlirStringRefCreate(s.data(), s.size());
 }
 
 /// Wrapper for the global LLVM debugging flag.
 struct PyGlobalDebugFlag {
-  static void set(py::object &o, bool enable) { mlirEnableGlobalDebug(enable); }
+  static void set(py::object &, bool enable) { mlirEnableGlobalDebug(enable); }
 
   static bool get(const py::object &) { return mlirIsGlobalDebugEnabled(); }
 
   static void bind(py::module &m) {
     // Debug flags.
     py::class_<PyGlobalDebugFlag>(m, "_GlobalDebug", py::module_local())
         .def_property_static("flag", &PyGlobalDebugFlag::get,
                              &PyGlobalDebugFlag::set, "LLVM-wide debug flag");

 size_t PyMlirContext::getLiveOperationCount() { return liveOperations.size(); }
 
 size_t PyMlirContext::getLiveModuleCount() { return liveModules.size(); }
 
 pybind11::object PyMlirContext::contextEnter() {
   return PyThreadContextEntry::pushContext(*this);
 }
 
-void PyMlirContext::contextExit(const pybind11::object &excType,
-                                const pybind11::object &excVal,
-                                const pybind11::object &excTb) {
+void PyMlirContext::contextExit(const pybind11::object &,
+                                const pybind11::object &,
+                                const pybind11::object &) {
   PyThreadContextEntry::popContext(*this);
 }
 
 PyMlirContext &DefaultingPyMlirContext::resolve() {
   PyMlirContext *context = PyThreadContextEntry::getDefaultContext();
   if (!context) {
     throw SetPyError(
         PyExc_RuntimeError,
PyLocation PyLocation::createFromCapsule(py::object capsule) {
   return PyLocation(PyMlirContext::forContext(mlirLocationGetContext(rawLoc)),
                     rawLoc);
 }
 
 py::object PyLocation::contextEnter() {
   return PyThreadContextEntry::pushLocation(*this);
 }
 
-void PyLocation::contextExit(const pybind11::object &excType,
-                             const pybind11::object &excVal,
-                             const pybind11::object &excTb) {
+void PyLocation::contextExit(const pybind11::object &, const pybind11::object &,
+                             const pybind11::object &) {
   PyThreadContextEntry::popLocation(*this);
 }
 
 PyLocation &DefaultingPyLocation::resolve() {
   auto *location = PyThreadContextEntry::getDefaultLocation();
   if (!location) {
     throw SetPyError(
         PyExc_RuntimeError,
void PyOperation::checkValid() const {
   if (!valid) {
     throw SetPyError(PyExc_RuntimeError, "the operation has been invalidated");
   }
 }
 
 void PyOperationBase::print(py::object fileObject, bool binary,
                             llvm::Optional<int64_t> largeElementsLimit,
                             bool enableDebugInfo, bool prettyDebugInfo,
-                            bool printGenericOpForm, bool useLocalScope,
+                            bool printGenericOpForm, bool,
                             bool assumeVerified) {
   PyOperation &operation = getOperation();
   operation.checkValid();
   if (fileObject.is_none())
     fileObject = py::module::import("sys").attr("stdout");
 
   if (!assumeVerified && !printGenericOpForm &&
       !mlirOperationVerify(operation)) {
PyOperationRef terminatorOpRef = PyOperation::forOperation(
       block.getParentOperation()->getContext(), terminator);
   return PyInsertionPoint{block, std::move(terminatorOpRef)};
 }
 
 py::object PyInsertionPoint::contextEnter() {
   return PyThreadContextEntry::pushInsertionPoint(*this);
 }
 
-void PyInsertionPoint::contextExit(const pybind11::object &excType,
-                                   const pybind11::object &excVal,
-                                   const pybind11::object &excTb) {
+void PyInsertionPoint::contextExit(const pybind11::object &,
+                                   const pybind11::object &,
+                                   const pybind11::object &) {
   PyThreadContextEntry::popInsertionPoint(*this);
 }
 
 //------------------------------------------------------------------------------
 // PyAttribute.
 //------------------------------------------------------------------------------
 
 bool PyAttribute::operator==(const PyAttribute &other) {
py::class_<PyLocation>(m, "Location", py::module_local())
       .def_property_readonly(MLIR_PYTHON_CAPI_PTR_ATTR, &PyLocation::getCapsule)
       .def(MLIR_PYTHON_CAPI_FACTORY_ATTR, &PyLocation::createFromCapsule)
       .def("__enter__", &PyLocation::contextEnter)
       .def("__exit__", &PyLocation::contextExit)
       .def("__eq__",
            [](PyLocation &self, PyLocation &other) -> bool {
              return mlirLocationEqual(self, other);
            })
-      .def("__eq__", [](PyLocation &self, py::object other) { return false; })
+      .def("__eq__", [](PyLocation &, py::object) { return false; })
       .def_property_readonly_static(
           "current",
           [](py::object & /*class*/) {
             auto *loc = PyThreadContextEntry::getDefaultLocation();
             if (!loc)
               throw SetPyError(PyExc_ValueError, "No current Location");
             return loc;
           },
py::class_<PyLocation>(m, "Location", py::module_local())
                 context->getRef(),
                 mlirLocationFileLineColGet(
                     context->get(), toMlirStringRef(filename), line, col));
           },
           py::arg("filename"), py::arg("line"), py::arg("col"),
           py::arg("context") = py::none(), kContextGetFileLocationDocstring)
       .def_static(
           "fused",
-          [](const std::vector<PyLocation> &pyLocations, llvm::Optional<PyAttribute> metadata,
+          [](const std::vector<PyLocation> &pyLocations,
+             llvm::Optional<PyAttribute> metadata,
              DefaultingPyMlirContext context) {
             if (pyLocations.empty())
               throw py::value_error("No locations provided");
             llvm::SmallVector<MlirLocation, 4> locations;
             locations.reserve(pyLocations.size());
             for (auto &pyLocation : pyLocations)
               locations.push_back(pyLocation.get());
             MlirLocation location = mlirLocationFusedGet(
py::class_<PyOperationBase>(m, "_OperationBase", py::module_local())
       .def_property_readonly(MLIR_PYTHON_CAPI_PTR_ATTR,
                              [](PyOperationBase &self) {
                                return self.getOperation().getCapsule();
                              })
       .def("__eq__",
            [](PyOperationBase &self, PyOperationBase &other) {
              return &self.getOperation() == &other.getOperation();
            })
-      .def("__eq__",
-           [](PyOperationBase &self, py::object other) { return false; })
+      .def("__eq__", [](PyOperationBase &, py::object) { return false; })
       .def("__hash__",
            [](PyOperationBase &self) {
              return static_cast<size_t>(llvm::hash_value(&self.getOperation()));
            })
       .def_property_readonly("attributes",
                              [](PyOperationBase &self) {
                                return PyOpAttributeMap(
                                    self.getOperation().getRef());
py::class_<PyRegion>(m, "Region", py::module_local())
             MlirBlock firstBlock = mlirRegionGetFirstBlock(self.get());
             return PyBlockIterator(self.getParentOperation(), firstBlock);
           },
           "Iterates over blocks in the region.")
       .def("__eq__",
            [](PyRegion &self, PyRegion &other) {
              return self.get().ptr == other.get().ptr;
            })
-      .def("__eq__", [](PyRegion &self, py::object &other) { return false; });
+      .def("__eq__", [](PyRegion &, py::object &) { return false; });
 
   //----------------------------------------------------------------------------
   // Mapping of PyBlock.
   //----------------------------------------------------------------------------
   py::class_<PyBlock>(m, "Block", py::module_local())
       .def_property_readonly(
           "owner",
           [](PyBlock &self) {
py::class_<PyBlock>(m, "Block", py::module_local())
             return PyOperationIterator(self.getParentOperation(),
                                        firstOperation);
           },
           "Iterates over operations in the block.")
       .def("__eq__",
            [](PyBlock &self, PyBlock &other) {
              return self.get().ptr == other.get().ptr;
            })
-      .def("__eq__", [](PyBlock &self, py::object &other) { return false; })
+      .def("__eq__", [](PyBlock &, py::object &) { return false; })
       .def(
           "__str__",
           [](PyBlock &self) {
             self.checkValid();
             PyPrintAccumulator printAccum;
             mlirBlockPrint(self.get(), printAccum.getCallback(),
                            printAccum.getUserData());
             return printAccum.join();
py::class_<PyAttribute>(m, "Attribute", py::module_local())
       .def(
           "get_named",
           [](PyAttribute &self, std::string name) {
             return PyNamedAttribute(self, std::move(name));
           },
           py::keep_alive<0, 1>(), "Binds a name to the attribute")
       .def("__eq__",
            [](PyAttribute &self, PyAttribute &other) { return self == other; })
-      .def("__eq__", [](PyAttribute &self, py::object &other) { return false; })
+      .def("__eq__", [](PyAttribute &, py::object &) { return false; })
       .def("__hash__",
            [](PyAttribute &self) {
              return static_cast<size_t>(llvm::hash_value(self.get().ptr));
            })
       .def(
           "dump", [](PyAttribute &self) { mlirAttributeDump(self); },
           kDumpDocstring)
       .def(
py::class_<PyType>(m, "Type", py::module_local())
             return PyType(context->getRef(), type);
           },
           py::arg("asm"), py::arg("context") = py::none(),
           kContextParseTypeDocstring)
       .def_property_readonly(
           "context", [](PyType &self) { return self.getContext().getObject(); },
           "Context that owns the Type")
       .def("__eq__", [](PyType &self, PyType &other) { return self == other; })
-      .def("__eq__", [](PyType &self, py::object &other) { return false; })
+      .def("__eq__", [](PyType &, py::object &) { return false; })
       .def("__hash__",
            [](PyType &self) {
              return static_cast<size_t>(llvm::hash_value(self.get().ptr));
            })
       .def(
           "dump", [](PyType &self) { mlirTypeDump(self); }, kDumpDocstring)
       .def(
           "__str__",
py::class_<PyValue>(m, "Value", py::module_local())
                    "expected the owner of the value in Python to match that in "
                    "the IR");
             return self.getParentOperation().getObject();
           })
       .def("__eq__",
            [](PyValue &self, PyValue &other) {
              return self.get().ptr == other.get().ptr;
            })
-      .def("__eq__", [](PyValue &self, py::object other) { return false; })
+      .def("__eq__", [](PyValue &, py::object) { return false; })
       .def("__hash__",
            [](PyValue &self) {
              return static_cast<size_t>(llvm::hash_value(self.get().ptr));
            })
       .def(
           "__str__",
           [](PyValue &self) {
             PyPrintAccumulator printAccum;

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

 //===----------------------------------------------------------------------===//
 // Floating point attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAFloat(MlirAttribute attr) {
   return unwrap(attr).isa<FloatAttr>();
 }
 
-MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
-                                     double value) {
+MlirAttribute mlirFloatAttrDoubleGet(MlirContext, MlirType type, double value) {
   return wrap(FloatAttr::get(unwrap(type), value));
 }
 
 MlirAttribute mlirFloatAttrDoubleGetChecked(MlirLocation loc, MlirType type,
                                             double value) {
   return wrap(FloatAttr::getChecked(unwrap(loc), unwrap(type), value));
 }
 

mlir/lib/CAPI/IR/IntegerSet.cpp

 
 MlirIntegerSet mlirIntegerSetEmptyGet(MlirContext context, intptr_t numDims,
                                       intptr_t numSymbols) {
   return wrap(IntegerSet::getEmptySet(static_cast<unsigned>(numDims),
                                       static_cast<unsigned>(numSymbols),
                                       unwrap(context)));
 }
 
-MlirIntegerSet mlirIntegerSetGet(MlirContext context, intptr_t numDims,
+MlirIntegerSet mlirIntegerSetGet(MlirContext, intptr_t numDims,
                                  intptr_t numSymbols, intptr_t numConstraints,
                                  const MlirAffineExpr *constraints,
                                  const bool *eqFlags) {
   SmallVector<AffineExpr> mlirConstraints;
   (void)unwrapList(static_cast<size_t>(numConstraints), constraints,
                    mlirConstraints);
   return wrap(IntegerSet::get(
       static_cast<unsigned>(numDims), static_cast<unsigned>(numSymbols),

mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp

static bool isBoolScalarOrVector(Type type) {
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp with composite type
 //===----------------------------------------------------------------------===//
 
 LogicalResult ConstantCompositeOpPattern::matchAndRewrite(
-    arith::ConstantOp constOp, OpAdaptor adaptor,
+    arith::ConstantOp constOp, OpAdaptor,
     ConversionPatternRewriter &rewriter) const {
   auto srcType = constOp.getType().dyn_cast<ShapedType>();
   if (!srcType || srcType.getNumElements() == 1)
     return failure();
 
   // arith.constant should only have vector or tenor types.
   assert((srcType.isa<VectorType, RankedTensorType>()));
 
LogicalResult ConstantCompositeOpPattern::matchAndRewrite(
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp with scalar type
 //===----------------------------------------------------------------------===//
 
 LogicalResult ConstantScalarOpPattern::matchAndRewrite(
-    arith::ConstantOp constOp, OpAdaptor adaptor,
+    arith::ConstantOp constOp, OpAdaptor,
     ConversionPatternRewriter &rewriter) const {
   Type srcType = constOp.getType();
   if (auto shapedType = srcType.dyn_cast<ShapedType>()) {
     if (shapedType.getNumElements() != 1)
       return failure();
     srcType = shapedType.getElementType();
   }
   if (!srcType.isIntOrIndexOrFloat())

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

 //===----------------------------------------------------------------------===//
 
 namespace {
 class CoroIdOpConversion : public OpConversionPattern<CoroIdOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(CoroIdOp op, OpAdaptor adaptor,
+  matchAndRewrite(CoroIdOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto token = AsyncAPI::tokenType(op->getContext());
     auto i8Ptr = AsyncAPI::opaquePointerType(op->getContext());
     auto loc = op->getLoc();
 
     // Constants for initializing coroutine frame.
     auto constZero = rewriter.create<LLVM::ConstantOp>(
         loc, rewriter.getI32Type(), rewriter.getI32IntegerAttr(0));

 //===----------------------------------------------------------------------===//
 
 namespace {
 class RuntimeCreateOpLowering : public OpConversionPattern<RuntimeCreateOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(RuntimeCreateOp op, OpAdaptor adaptor,
+  matchAndRewrite(RuntimeCreateOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     TypeConverter *converter = getTypeConverter();
     Type resultType = op->getResultTypes()[0];
 
     // Tokens creation maps to a simple function call.
     if (resultType.isa<TokenType>()) {
       rewriter.replaceOpWithNewOp<CallOp>(op, kCreateToken,
                                           converter->convertType(resultType));

mlir/lib/Conversion/BufferizationToMemRef/BufferizationToMemRef.cpp

 /// The CloneOpConversion transforms all bufferization clone operations into
 /// memref alloc and memref copy operations. In the dynamic-shape case, it also
 /// emits additional dim and constant operations to determine the shape. This
 /// conversion does not resolve memory leaks if it is used alone.
 struct CloneOpConversion : public OpConversionPattern<bufferization::CloneOp> {
   using OpConversionPattern<bufferization::CloneOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(bufferization::CloneOp op, OpAdaptor adaptor,
+  matchAndRewrite(bufferization::CloneOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Check for unranked memref types which are currently not supported.
     Type type = op.getType();
     if (type.isa<UnrankedMemRefType>()) {
       return rewriter.notifyMatchFailure(
           op, "UnrankedMemRefType is not supported.");
     }
 

mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp

 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Builders.h"
 #include "llvm/Support/FormatVariadic.h"
 
 using namespace mlir;
 
 LogicalResult
-GPUFuncOpLowering::matchAndRewrite(gpu::GPUFuncOp gpuFuncOp, OpAdaptor adaptor,
+GPUFuncOpLowering::matchAndRewrite(gpu::GPUFuncOp gpuFuncOp, OpAdaptor,
                                    ConversionPatternRewriter &rewriter) const {
   Location loc = gpuFuncOp.getLoc();
 
   SmallVector<LLVM::GlobalOp, 3> workgroupBuffers;
   workgroupBuffers.reserve(gpuFuncOp.getNumWorkgroupAttributions());
   for (const auto &en : llvm::enumerate(gpuFuncOp.getWorkgroupAttributions())) {
     Value attribution = en.value();
 

mlir/lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp

 mlir::createGpuToLLVMConversionPass() {
   return std::make_unique<GpuToLLVMConversionPass>();
 }
 
 void mlir::populateGpuToLLVMConversionPatterns(
     LLVMTypeConverter &converter, OwningRewritePatternList &patterns,
     StringRef gpuBinaryAnnotation) {
   converter.addConversion(
-      [context = &converter.getContext()](gpu::AsyncTokenType type) -> Type {
+      [context = &converter.getContext()](gpu::AsyncTokenType) -> Type {
         return LLVM::LLVMPointerType::get(IntegerType::get(context, 8));
       });
   patterns.add<ConvertAllocOpToGpuRuntimeCallPattern,
                ConvertDeallocOpToGpuRuntimeCallPattern,
                ConvertHostRegisterOpToGpuRuntimeCallPattern,
                ConvertMemcpyOpToGpuRuntimeCallPattern,
                ConvertMemsetOpToGpuRuntimeCallPattern,
                ConvertWaitAsyncOpToGpuRuntimeCallPattern,
                ConvertWaitOpToGpuRuntimeCallPattern,
                ConvertAsyncYieldToGpuRuntimeCallPattern>(converter);
   patterns.add<ConvertLaunchFuncOpToGpuRuntimeCallPattern>(converter,
                                                            gpuBinaryAnnotation);
   patterns.add<EraseGpuModuleOpPattern>(&converter.getContext());
 }

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp

 };
 
 class GPUModuleEndConversion final
     : public OpConversionPattern<gpu::ModuleEndOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(gpu::ModuleEndOp endOp, OpAdaptor adaptor,
+  matchAndRewrite(gpu::ModuleEndOp endOp, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.eraseOp(endOp);
     return success();
   }
 };
 
 /// Pattern to convert a gpu.return into a SPIR-V return.
 // TODO: This can go to DRR when GPU return has operands.
return llvm::StringSwitch<Optional<int32_t>>(dimAttr.getValue())
       .Case("x", 0)
       .Case("y", 1)
       .Case("z", 2)
       .Default(llvm::None);
 }
 
 template <typename SourceOp, spirv::BuiltIn builtin>
 LogicalResult LaunchConfigConversion<SourceOp, builtin>::matchAndRewrite(
-    SourceOp op, typename SourceOp::Adaptor adaptor,
+    SourceOp op, typename SourceOp::Adaptor,
     ConversionPatternRewriter &rewriter) const {
   auto index = getLaunchConfigIndex(op);
   if (!index)
     return failure();
 
   auto *typeConverter = this->template getTypeConverter<SPIRVTypeConverter>();
   auto indexType = typeConverter->getIndexType();
 
   // SPIR-V invocation builtin variables are a vector of type <3xi32>
   auto spirvBuiltin =
       spirv::getBuiltinVariableValue(op, builtin, indexType, rewriter);
   rewriter.replaceOpWithNewOp<spirv::CompositeExtractOp>(
       op, indexType, spirvBuiltin,
       rewriter.getI32ArrayAttr({index.getValue()}));
   return success();
 }
 
 template <typename SourceOp, spirv::BuiltIn builtin>
 LogicalResult
 SingleDimLaunchConfigConversion<SourceOp, builtin>::matchAndRewrite(
-    SourceOp op, typename SourceOp::Adaptor adaptor,
+    SourceOp op, typename SourceOp::Adaptor,
     ConversionPatternRewriter &rewriter) const {
   auto *typeConverter = this->template getTypeConverter<SPIRVTypeConverter>();
   auto indexType = typeConverter->getIndexType();
 
   auto spirvBuiltin =
       spirv::getBuiltinVariableValue(op, builtin, indexType, rewriter);
   rewriter.replaceOp(op, spirvBuiltin);
   return success();
 }
 
 LogicalResult WorkGroupSizeConversion::matchAndRewrite(
-    gpu::BlockDimOp op, OpAdaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+    gpu::BlockDimOp op, OpAdaptor, ConversionPatternRewriter &rewriter) const {
   auto index = getLaunchConfigIndex(op);
   if (!index)
     return failure();
 
   auto workGroupSizeAttr = spirv::lookupLocalWorkGroupSize(op);
   auto val = workGroupSizeAttr.getValues<int32_t>()[index.getValue()];
   auto convertedType =
       getTypeConverter()->convertType(op.getResult().getType());
for (auto argIndex : llvm::seq<unsigned>(0, funcOp.getNumArguments())) {
     if (funcOp.getArgument(argIndex).getType().isIntOrIndexOrFloat())
       sc = spirv::StorageClass::StorageBuffer;
     argABI.push_back(spirv::getInterfaceVarABIAttr(0, argIndex, sc, context));
   }
   return success();
 }
 
 LogicalResult GPUFuncOpConversion::matchAndRewrite(
-    gpu::GPUFuncOp funcOp, OpAdaptor adaptor,
+    gpu::GPUFuncOp funcOp, OpAdaptor,
     ConversionPatternRewriter &rewriter) const {
   if (!gpu::GPUDialect::isKernel(funcOp))
     return failure();
 
   SmallVector<spirv::InterfaceVarABIAttr, 4> argABI;
   if (failed(getDefaultABIAttrs(rewriter.getContext(), funcOp, argABI))) {
     argABI.clear();
     for (auto argIndex : llvm::seq<unsigned>(0, funcOp.getNumArguments())) {
LogicalResult GPUFuncOpConversion::matchAndRewrite(
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ModuleOp with gpu.module.
 //===----------------------------------------------------------------------===//
 
 LogicalResult GPUModuleConversion::matchAndRewrite(
-    gpu::GPUModuleOp moduleOp, OpAdaptor adaptor,
+    gpu::GPUModuleOp moduleOp, OpAdaptor,
     ConversionPatternRewriter &rewriter) const {
   spirv::TargetEnvAttr targetEnv = spirv::lookupTargetEnvOrDefault(moduleOp);
   spirv::AddressingModel addressingModel = spirv::getAddressingModel(targetEnv);
   FailureOr<spirv::MemoryModel> memoryModel = spirv::getMemoryModel(targetEnv);
   if (failed(memoryModel))
     return moduleOp.emitRemark("match failure: could not selected memory model "
                                "based on 'spv.target_env'");
 

mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp

Value UnrankedMemRefDescriptor::strideBasePtr(OpBuilder &builder, Location loc,
   Type indexPtrTy = LLVM::LLVMPointerType::get(typeConverter.getIndexType());
   return builder.create<LLVM::GEPOp>(loc, indexPtrTy, sizeBasePtr,
                                      ValueRange({rank}));
 }
 
 Value UnrankedMemRefDescriptor::stride(OpBuilder &builder, Location loc,
                                        LLVMTypeConverter &typeConverter,
                                        Value strideBasePtr, Value index,
-                                       Value stride) {
+                                       Value) {
   Type indexPtrTy = LLVM::LLVMPointerType::get(typeConverter.getIndexType());
   Value strideStoreGep = builder.create<LLVM::GEPOp>(
       loc, indexPtrTy, strideBasePtr, ValueRange({index}));
   return builder.create<LLVM::LoadOp>(loc, strideStoreGep);
 }
 
 void UnrankedMemRefDescriptor::setStride(OpBuilder &builder, Location loc,
                                          LLVMTypeConverter &typeConverter,
                                          Value strideBasePtr, Value index,
                                          Value stride) {
   Type indexPtrTy = LLVM::LLVMPointerType::get(typeConverter.getIndexType());
   Value strideStoreGep = builder.create<LLVM::GEPOp>(
       loc, indexPtrTy, strideBasePtr, ValueRange({index}));
   builder.create<LLVM::StoreOp>(loc, stride, strideStoreGep);
 }

mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp

 Type LLVMTypeConverter::getIndexType() {
   return IntegerType::get(&getContext(), getIndexTypeBitwidth());
 }
 
 unsigned LLVMTypeConverter::getPointerBitwidth(unsigned addressSpace) {
   return options.dataLayout.getPointerSizeInBits(addressSpace);
 }
 
-Type LLVMTypeConverter::convertIndexType(IndexType type) {
-  return getIndexType();
-}
+Type LLVMTypeConverter::convertIndexType(IndexType) { return getIndexType(); }
 
 Type LLVMTypeConverter::convertIntegerType(IntegerType type) {
   return IntegerType::get(&getContext(), type.getWidth());
 }
 
 Type LLVMTypeConverter::convertFloatType(FloatType type) { return type; }
 
 // Convert a `ComplexType` to an LLVM type. The result is a complex number

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

struct AllocaOpLowering : public AllocLikeOpLLVMLowering {
   }
 };
 
 struct AllocaScopeOpLowering
     : public ConvertOpToLLVMPattern<memref::AllocaScopeOp> {
   using ConvertOpToLLVMPattern<memref::AllocaScopeOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(memref::AllocaScopeOp allocaScopeOp, OpAdaptor adaptor,
+  matchAndRewrite(memref::AllocaScopeOp allocaScopeOp, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     OpBuilder::InsertionGuard guard(rewriter);
     Location loc = allocaScopeOp.getLoc();
 
     // Split the current block before the AllocaScopeOp to create the inlining
     // point.
     auto *currentBlock = rewriter.getInsertionBlock();
     auto *remainingOpsBlock =

 }
 
 /// GlobalMemrefOp is lowered to a LLVM Global Variable.
 struct GlobalMemrefOpLowering
     : public ConvertOpToLLVMPattern<memref::GlobalOp> {
   using ConvertOpToLLVMPattern<memref::GlobalOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
-  matchAndRewrite(memref::GlobalOp global, OpAdaptor adaptor,
+  matchAndRewrite(memref::GlobalOp global, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     MemRefType type = global.type();
     if (!isConvertibleAndHasIdentityMaps(type))
       return failure();
 
     Type arrayTy = convertGlobalMemrefTypeToLLVM(type, *getTypeConverter());
 
     LLVM::Linkage linkage =

 struct GetGlobalMemrefOpLowering : public AllocLikeOpLLVMLowering {
   GetGlobalMemrefOpLowering(LLVMTypeConverter &converter)
       : AllocLikeOpLLVMLowering(memref::GetGlobalOp::getOperationName(),
                                 converter) {}
 
   /// Buffer "allocation" for memref.get_global op is getting the address of
   /// the global variable referenced.
   std::tuple<Value, Value> allocateBuffer(ConversionPatternRewriter &rewriter,
-                                          Location loc, Value sizeBytes,
+                                          Location loc, Value,
                                           Operation *op) const override {
     auto getGlobalOp = cast<memref::GetGlobalOp>(op);
     MemRefType type = getGlobalOp.result().getType().cast<MemRefType>();
     unsigned memSpace = type.getMemorySpaceAsInt();
 
     Type arrayTy = convertGlobalMemrefTypeToLLVM(type, *getTypeConverter());
     auto addressOf = rewriter.create<LLVM::AddressOfOp>(
         loc, LLVM::LLVMPointerType::get(arrayTy, memSpace), getGlobalOp.name());
using ConvertOpToLLVMPattern<
       memref::ReinterpretCastOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(memref::ReinterpretCastOp castOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type srcType = castOp.source().getType();
 
     Value descriptor;
-    if (failed(convertSourceMemRefToDescriptor(rewriter, srcType, castOp,
-                                               adaptor, &descriptor)))
+    if (failed(convertSourceMemRefToDescriptor(rewriter, castOp, adaptor,
+                                               &descriptor)))
       return failure();
     rewriter.replaceOp(castOp, {descriptor});
     return success();
   }
 
 private:
   LogicalResult convertSourceMemRefToDescriptor(
-      ConversionPatternRewriter &rewriter, Type srcType,
-      memref::ReinterpretCastOp castOp,
+      ConversionPatternRewriter &rewriter, memref::ReinterpretCastOp castOp,
       memref::ReinterpretCastOp::Adaptor adaptor, Value *descriptor) const {
     MemRefType targetMemRefType =
         castOp.getResult().getType().cast<MemRefType>();
     auto llvmTargetDescriptorTy = typeConverter->convertType(targetMemRefType)
                                       .dyn_cast_or_null<LLVM::LLVMStructType>();
     if (!llvmTargetDescriptorTy)
       return failure();
 
struct MemRefReshapeOpLowering
   using ConvertOpToLLVMPattern<memref::ReshapeOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(memref::ReshapeOp reshapeOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type srcType = reshapeOp.source().getType();
 
     Value descriptor;
-    if (failed(convertSourceMemRefToDescriptor(rewriter, srcType, reshapeOp,
-                                               adaptor, &descriptor)))
+    if (failed(convertSourceMemRefToDescriptor(rewriter, reshapeOp, adaptor,
+                                               &descriptor)))
       return failure();
     rewriter.replaceOp(reshapeOp, {descriptor});
     return success();
   }
 
 private:
-  LogicalResult
-  convertSourceMemRefToDescriptor(ConversionPatternRewriter &rewriter,
-                                  Type srcType, memref::ReshapeOp reshapeOp,
-                                  memref::ReshapeOp::Adaptor adaptor,
-                                  Value *descriptor) const {
+  LogicalResult convertSourceMemRefToDescriptor(
+      ConversionPatternRewriter &rewriter, memref::ReshapeOp reshapeOp,
+      memref::ReshapeOp::Adaptor adaptor, Value *descriptor) const {
     // Conversion for statically-known shape args is performed via
     // `memref_reinterpret_cast`.
     auto shapeMemRefType = reshapeOp.shape().getType().cast<MemRefType>();
     if (shapeMemRefType.hasStaticShape())
       return failure();
 
     // The shape is a rank-1 tensor with unknown length.
     Location loc = reshapeOp.getLoc();

mlir/lib/Conversion/MemRefToSPIRV/MemRefToSPIRV.cpp

 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // AllocOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-AllocOpPattern::matchAndRewrite(memref::AllocOp operation, OpAdaptor adaptor,
+AllocOpPattern::matchAndRewrite(memref::AllocOp operation, OpAdaptor,
                                 ConversionPatternRewriter &rewriter) const {
   MemRefType allocType = operation.getType();
   if (!isAllocationSupported(allocType))
     return operation.emitError("unhandled allocation type");
 
   // Get the SPIR-V type for the allocation.
   Type spirvType = getTypeConverter()->convertType(allocType);
 
AllocOpPattern::matchAndRewrite(memref::AllocOp operation, OpAdaptor,
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // DeallocOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-DeallocOpPattern::matchAndRewrite(memref::DeallocOp operation,
-                                  OpAdaptor adaptor,
+DeallocOpPattern::matchAndRewrite(memref::DeallocOp operation, OpAdaptor,
                                   ConversionPatternRewriter &rewriter) const {
   MemRefType deallocType = operation.memref().getType().cast<MemRefType>();
   if (!isAllocationSupported(deallocType))
     return operation.emitError("unhandled deallocation type");
   rewriter.eraseOp(operation);
   return success();
 }
 

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

public:
   }
 };
 
 class AddressOfPattern : public SPIRVToLLVMConversion<spirv::AddressOfOp> {
 public:
   using SPIRVToLLVMConversion<spirv::AddressOfOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::AddressOfOp op, OpAdaptor adaptor,
+  matchAndRewrite(spirv::AddressOfOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = typeConverter.convertType(op.pointer().getType());
     if (!dstType)
       return failure();
     rewriter.replaceOpWithNewOp<LLVM::AddressOfOp>(op, dstType, op.variable());
     return success();
   }
 };
 
 class BitFieldInsertPattern
     : public SPIRVToLLVMConversion<spirv::BitFieldInsertOp> {
 public:
   using SPIRVToLLVMConversion<spirv::BitFieldInsertOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::BitFieldInsertOp op, OpAdaptor adaptor,
+  matchAndRewrite(spirv::BitFieldInsertOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
     Location loc = op.getLoc();
 
     // Process `Offset` and `Count`: broadcast and extend/truncate if needed.

 };
 
 class BitFieldSExtractPattern
     : public SPIRVToLLVMConversion<spirv::BitFieldSExtractOp> {
 public:
   using SPIRVToLLVMConversion<spirv::BitFieldSExtractOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::BitFieldSExtractOp op, OpAdaptor adaptor,
+  matchAndRewrite(spirv::BitFieldSExtractOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
     Location loc = op.getLoc();
 
     // Process `Offset` and `Count`: broadcast and extend/truncate if needed.

 };
 
 class BitFieldUExtractPattern
     : public SPIRVToLLVMConversion<spirv::BitFieldUExtractOp> {
 public:
   using SPIRVToLLVMConversion<spirv::BitFieldUExtractOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::BitFieldUExtractOp op, OpAdaptor adaptor,
+  matchAndRewrite(spirv::BitFieldUExtractOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
     Location loc = op.getLoc();
 
     // Process `Offset` and `Count`: broadcast and extend/truncate if needed.

 
 class BranchConditionalConversionPattern
     : public SPIRVToLLVMConversion<spirv::BranchConditionalOp> {
 public:
   using SPIRVToLLVMConversion<
       spirv::BranchConditionalOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::BranchConditionalOp op, OpAdaptor adaptor,
+  matchAndRewrite(spirv::BranchConditionalOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // If branch weights exist, map them to 32-bit integer vector.
     ElementsAttr branchWeights = nullptr;
     if (auto weights = op.branch_weights()) {
       VectorType weightType = VectorType::get(2, rewriter.getI32Type());
       branchWeights =
           DenseElementsAttr::get(weightType, weights.getValue().getValue());
     }

 /// Converts `spv.ExecutionMode` into a global struct constant that holds
 /// execution mode information.
 class ExecutionModePattern
     : public SPIRVToLLVMConversion<spirv::ExecutionModeOp> {
 public:
   using SPIRVToLLVMConversion<spirv::ExecutionModeOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::ExecutionModeOp op, OpAdaptor adaptor,
+  matchAndRewrite(spirv::ExecutionModeOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // First, create the global struct's name that would be associated with
     // this entry point's execution mode. We set it to be:
     //   __spv__{SPIR-V module name}_{function name}_execution_mode_info_{mode}
     ModuleOp module = op->getParentOfType<ModuleOp>();
     IntegerAttr executionModeAttr = op.execution_modeAttr();
     std::string moduleName;
     if (module.getName().hasValue())

 /// This difference is handled by `spv.mlir.addressof` and
 /// `llvm.mlir.addressof`ops that both return a pointer.
 class GlobalVariablePattern
     : public SPIRVToLLVMConversion<spirv::GlobalVariableOp> {
 public:
   using SPIRVToLLVMConversion<spirv::GlobalVariableOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::GlobalVariableOp op, OpAdaptor adaptor,
+  matchAndRewrite(spirv::GlobalVariableOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Currently, there is no support of initialization with a constant value in
     // SPIR-V dialect. Specialization constants are not considered as well.
     if (op.initializer())
       return failure();
 
     auto srcType = op.type().cast<spirv::PointerType>();
     auto dstType = typeConverter.convertType(srcType.getPointeeType());

 
 /// Converts SPIR-V floating-point comparisons to llvm.fcmp "predicate"
 template <typename SPIRVOp, LLVM::FCmpPredicate predicate>
 class FComparePattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
+  matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
 
     rewriter.template replaceOpWithNewOp<LLVM::FCmpOp>(
         operation, dstType, predicate, operation.operand1(),
         operation.operand2());
     return success();
   }
 };
 
 /// Converts SPIR-V integer comparisons to llvm.icmp "predicate"
 template <typename SPIRVOp, LLVM::ICmpPredicate predicate>
 class IComparePattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
+  matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto dstType = this->typeConverter.convertType(operation.getType());
     if (!dstType)
       return failure();
 
     rewriter.template replaceOpWithNewOp<LLVM::ICmpOp>(
         operation, dstType, predicate, operation.operand1(),
         operation.operand2());
     return success();
   }
 };
 
 class InverseSqrtPattern
     : public SPIRVToLLVMConversion<spirv::GLSLInverseSqrtOp> {
 public:
   using SPIRVToLLVMConversion<spirv::GLSLInverseSqrtOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::GLSLInverseSqrtOp op, OpAdaptor adaptor,
+  matchAndRewrite(spirv::GLSLInverseSqrtOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
 
     Location loc = op.getLoc();
     Value one = createFPConstant(loc, srcType, dstType, rewriter, 1.0);

 
 /// Converts `spv.Not` and `spv.LogicalNot` into LLVM dialect.
 template <typename SPIRVOp>
 class NotPattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVOp notOp, typename SPIRVOp::Adaptor adaptor,
+  matchAndRewrite(SPIRVOp notOp, typename SPIRVOp::Adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = notOp.getType();
     auto dstType = this->typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
 
     Location loc = notOp.getLoc();
     IntegerAttr minusOne = minusOneIntegerAttribute(srcType, rewriter);

 
 /// A template pattern that erases the given `SPIRVOp`.
 template <typename SPIRVOp>
 class ErasePattern : public SPIRVToLLVMConversion<SPIRVOp> {
 public:
   using SPIRVToLLVMConversion<SPIRVOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(SPIRVOp op, typename SPIRVOp::Adaptor adaptor,
+  matchAndRewrite(SPIRVOp op, typename SPIRVOp::Adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.eraseOp(op);
     return success();
   }
 };
 
 class ReturnPattern : public SPIRVToLLVMConversion<spirv::ReturnOp> {
 public:
   using SPIRVToLLVMConversion<spirv::ReturnOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::ReturnOp returnOp, OpAdaptor adaptor,
+  matchAndRewrite(spirv::ReturnOp returnOp, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(returnOp, ArrayRef<Type>(),
                                                 ArrayRef<Value>());
     return success();
   }
 };
 
 class ReturnValuePattern : public SPIRVToLLVMConversion<spirv::ReturnValueOp> {

 ///      |   <code after spv.mlir.loop>       |
 ///      +------------------------------------+
 ///
 class LoopPattern : public SPIRVToLLVMConversion<spirv::LoopOp> {
 public:
   using SPIRVToLLVMConversion<spirv::LoopOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::LoopOp loopOp, OpAdaptor adaptor,
+  matchAndRewrite(spirv::LoopOp loopOp, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // There is no support of loop control at the moment.
     if (loopOp.loop_control() != spirv::LoopControl::None)
       return failure();
 
     Location loc = loopOp.getLoc();
 
     // Split the current block after `spv.mlir.loop`. The remaining ops will be

 /// Converts `spv.mlir.selection` with `spv.BranchConditional` in its header
 /// block. All blocks within selection should be reachable for conversion to
 /// succeed.
 class SelectionPattern : public SPIRVToLLVMConversion<spirv::SelectionOp> {
 public:
   using SPIRVToLLVMConversion<spirv::SelectionOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::SelectionOp op, OpAdaptor adaptor,
+  matchAndRewrite(spirv::SelectionOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // There is no support for `Flatten` or `DontFlatten` selection control at
     // the moment. This are just compiler hints and can be performed during the
     // optimization passes.
     if (op.selection_control() != spirv::SelectionControl::None)
       return failure();
 
     // `spv.mlir.selection` should have at least two blocks: one selection
public:
   }
 };
 
 class TanPattern : public SPIRVToLLVMConversion<spirv::GLSLTanOp> {
 public:
   using SPIRVToLLVMConversion<spirv::GLSLTanOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::GLSLTanOp tanOp, OpAdaptor adaptor,
+  matchAndRewrite(spirv::GLSLTanOp tanOp, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = typeConverter.convertType(tanOp.getType());
     if (!dstType)
       return failure();
 
     Location loc = tanOp.getLoc();
     Value sin = rewriter.create<LLVM::SinOp>(loc, dstType, tanOp.operand());
     Value cos = rewriter.create<LLVM::CosOp>(loc, dstType, tanOp.operand());
     rewriter.replaceOpWithNewOp<LLVM::FDivOp>(tanOp, dstType, sin, cos);
     return success();
   }
 };
 
 /// Convert `spv.Tanh` to
 ///
 ///   exp(2x) - 1
 ///   -----------
 ///   exp(2x) + 1
 ///
 class TanhPattern : public SPIRVToLLVMConversion<spirv::GLSLTanhOp> {
 public:
   using SPIRVToLLVMConversion<spirv::GLSLTanhOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::GLSLTanhOp tanhOp, OpAdaptor adaptor,
+  matchAndRewrite(spirv::GLSLTanhOp tanhOp, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = tanhOp.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
 
     Location loc = tanhOp.getLoc();
     Value two = createFPConstant(loc, srcType, dstType, rewriter, 2.0);

 // FuncOp conversion
 //===----------------------------------------------------------------------===//
 
 class FuncConversionPattern : public SPIRVToLLVMConversion<spirv::FuncOp> {
 public:
   using SPIRVToLLVMConversion<spirv::FuncOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::FuncOp funcOp, OpAdaptor adaptor,
+  matchAndRewrite(spirv::FuncOp funcOp, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     // Convert function signature. At the moment LLVMType converter is enough
     // for currently supported types.
     auto funcType = funcOp.getType();
     TypeConverter::SignatureConversion signatureConverter(
         funcType.getNumInputs());
     auto llvmType = typeConverter.convertFunctionSignature(

 // ModuleOp conversion
 //===----------------------------------------------------------------------===//
 
 class ModuleConversionPattern : public SPIRVToLLVMConversion<spirv::ModuleOp> {
 public:
   using SPIRVToLLVMConversion<spirv::ModuleOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::ModuleOp spvModuleOp, OpAdaptor adaptor,
+  matchAndRewrite(spirv::ModuleOp spvModuleOp, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto newModuleOp =
         rewriter.create<ModuleOp>(spvModuleOp.getLoc(), spvModuleOp.getName());
     rewriter.inlineRegionBefore(spvModuleOp.getRegion(), newModuleOp.getBody());
 
     // Remove the terminator block that was automatically added by builder
     rewriter.eraseBlock(&newModuleOp.getBodyRegion().back());

mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp

public:
 
   LogicalResult
   matchAndRewrite(ConstShapeOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult ConstShapeOpConverter::matchAndRewrite(
-    ConstShapeOp op, OpAdaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+    ConstShapeOp op, OpAdaptor, ConversionPatternRewriter &rewriter) const {
 
   // For now, this lowering supports only extent tensors, not `shape.shape`
   // types.
   if (op.getType().isa<ShapeType>())
     return failure();
 
   auto loc = op.getLoc();
   SmallVector<Value, 4> extentOperands;
public:
 
   LogicalResult
   matchAndRewrite(ConstSizeOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult ConstSizeOpConversion::matchAndRewrite(
-    ConstSizeOp op, OpAdaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+    ConstSizeOp op, OpAdaptor, ConversionPatternRewriter &rewriter) const {
   rewriter.replaceOpWithNewOp<arith::ConstantIndexOp>(
       op, op.getValue().getSExtValue());
   return success();
 }
 
 namespace {
 struct IsBroadcastableOpConverter
     : public OpConversionPattern<IsBroadcastableOp> {
for (Value shape : adaptor.getShapes().drop_front(1)) {
     auto same = rewriter.create<IfOp>(
         loc, i1Ty, eqRank,
         [&](OpBuilder &b, Location loc) {
           Value one = b.create<arith::ConstantIndexOp>(loc, 1);
           Value init =
               b.create<arith::ConstantOp>(loc, i1Ty, b.getBoolAttr(true));
           auto loop = b.create<scf::ForOp>(
               loc, zero, firstRank, one, ValueRange{init},
-              [&](OpBuilder &b, Location nestedLoc, Value iv, ValueRange args) {
+              [&](OpBuilder &b, Location, Value iv, ValueRange args) {
                 Value conj = args[0];
                 Value lhsExtent =
                     b.create<tensor::ExtractOp>(loc, firstShape, iv);
                 Value rhsExtent = b.create<tensor::ExtractOp>(loc, shape, iv);
                 Value eqExtent = b.create<arith::CmpIOp>(
                     loc, arith::CmpIPredicate::eq, lhsExtent, rhsExtent);
                 Value conjNext = b.create<arith::AndIOp>(loc, conj, eqExtent);
                 b.create<scf::YieldOp>(loc, ValueRange({conjNext}));

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

elementwiseMatchAndRewriteHelper(Operation *operation,
 
   indexingMaps.append(operation->getNumResults(),
                       rewriter.getMultiDimIdentityMap(rank));
 
   bool didEncounterError = false;
   auto linalgOp = rewriter.create<linalg::GenericOp>(
       loc, opResultTypes, operands, initTensors, indexingMaps,
       getNParallelLoopsAttrs(rank),
-      [&](OpBuilder &nestedBuilder, Location nestedLoc, ValueRange blockArgs) {
+      [&](OpBuilder &nestedBuilder, Location, ValueRange blockArgs) {
         Value opResult = createLinalgBodyCalculationForElementwiseOp(
             operation, blockArgs.take_front(operation->getNumOperands()),
             bodyResultTypes, rewriter);
         if (!opResult) {
           didEncounterError = true;
           return;
         }
         nestedBuilder.create<linalg::YieldOp>(loc, opResult);
for (unsigned int i = 0, rank = inputTy.getRank(); i != rank; ++i) {
     if (axis != i)
       dstExprs.push_back(mlir::getAffineDimExpr(i, rewriter.getContext()));
   }
 
   bool didEncounterError = false;
   auto maps = AffineMap::inferFromExprList({srcExprs, dstExprs});
   auto linalgOp = rewriter.create<linalg::GenericOp>(
       loc, reduceTy, input, filledTensor, maps, iteratorTypes,
-      [&](OpBuilder &nestedBuilder, Location nestedLoc, ValueRange blockArgs) {
+      [&](OpBuilder &nestedBuilder, Location, ValueRange blockArgs) {
         auto result = createLinalgBodyCalculationForReduceOp(
             op, blockArgs, elementTy, rewriter);
         if (result)
           didEncounterError = true;
 
         nestedBuilder.create<linalg::YieldOp>(loc, result);
       });
 
LogicalResult matchAndRewrite(tosa::TransposeOp op,
     SmallVector<AffineMap, 2> affineMaps = {
         AffineMap::get(resultTy.getRank(), /*symbolCount=*/0, inputExprs,
                        rewriter.getContext()),
         rewriter.getMultiDimIdentityMap(resultTy.getRank())};
 
     rewriter.replaceOpWithNewOp<linalg::GenericOp>(
         op, resultTy, op.input1(), ValueRange{initTensor}, affineMaps,
         getNParallelLoopsAttrs(resultTy.getRank()),
-        [&](OpBuilder &nestedBuilder, Location nestedLoc, ValueRange args) {
+        [&](OpBuilder &nestedBuilder, Location, ValueRange args) {
           nestedBuilder.create<linalg::YieldOp>(loc, *args.begin());
         });
     return success();
   }
 };
 
 class RescaleConverter : public OpRewritePattern<tosa::RescaleOp> {
 public:
auto initTensor = rewriter
                               inputTy.getShape(), inputTy.getElementType())
                           .result();
     SmallVector<AffineMap, 2> affineMaps = {
         rewriter.getMultiDimIdentityMap(resultTy.getRank())};
 
     rewriter.replaceOpWithNewOp<linalg::GenericOp>(
         op, resultTy, ArrayRef<Value>({}), ValueRange{initTensor}, affineMaps,
         getNParallelLoopsAttrs(resultTy.getRank()),
-        [&](OpBuilder &nestedBuilder, Location nestedLoc, ValueRange args) {
+        [&](OpBuilder &nestedBuilder, Location nestedLoc, ValueRange) {
           llvm::SmallVector<Value> indices;
           for (unsigned int i = 0; i < inputTy.getRank(); i++) {
             auto index =
                 rewriter.create<linalg::IndexOp>(nestedLoc, i).getResult();
             if (i == axis) {
               auto one = rewriter.create<arith::ConstantIndexOp>(nestedLoc, 1);
               auto sizeMinusOne =
                   rewriter.create<arith::SubIOp>(nestedLoc, axisDimSize, one);

 // This converter translate a tile operation to a reshape, broadcast, reshape.
 // The first reshape minimally expands each tiled dimension to include a
 // proceding size-1 dim. This dim is then broadcasted to the appropriate
 // multiple.
 struct TileConverter : public OpConversionPattern<tosa::TileOp> {
   using OpConversionPattern<tosa::TileOp>::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(tosa::TileOp op, OpAdaptor adaptor,
+  matchAndRewrite(tosa::TileOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = op.getLoc();
     auto input = op.input1();
     auto inputTy = input.getType().cast<ShapedType>();
     auto inputShape = inputTy.getShape();
     auto resultTy = op.getType().cast<ShapedType>();
     auto elementTy = inputTy.getElementType();
     int64_t rank = inputTy.getRank();
matchAndRewrite(tosa::TileOp op, OpAdaptor,
 
     SmallVector<AffineMap, 2> affineMaps = {
         readAffineMap, rewriter.getMultiDimIdentityMap(genericShape.size())};
 
     auto genericOp = rewriter.create<linalg::GenericOp>(
         loc, RankedTensorType::get(genericShape, elementTy), input,
         ValueRange{initTensor}, affineMaps,
         getNParallelLoopsAttrs(genericShape.size()),
-        [&](OpBuilder &nestedBuilder, Location nestedLoc, ValueRange args) {
+        [&](OpBuilder &nestedBuilder, Location, ValueRange args) {
           nestedBuilder.create<linalg::YieldOp>(op.getLoc(), *args.begin());
         });
 
     rewriter.replaceOpWithNewOp<tosa::ReshapeOp>(
         op, resultTy, genericOp.getResult(0),
         rewriter.getI64ArrayAttr(resultTy.getShape()));
     return success();
   }
SmallVector<AffineMap, 2> affineMaps = {
             {rewriter.getAffineDimExpr(0), rewriter.getAffineDimExpr(1)},
             rewriter.getContext()),
         rewriter.getMultiDimIdentityMap(resultTy.getRank())};
 
     auto genericOp = rewriter.create<linalg::GenericOp>(
         loc, ArrayRef<Type>({resultTy}), ValueRange{indices},
         ValueRange{initTensor}, affineMaps,
         getNParallelLoopsAttrs(resultTy.getRank()),
-        [&](OpBuilder &b, Location loc, ValueRange args) {
+        [&](OpBuilder &, Location loc, ValueRange args) {
           auto indexValue = args[0];
           auto index0 = rewriter.create<linalg::IndexOp>(loc, 0);
           Value index1 = rewriter.create<arith::IndexCastOp>(
               loc, rewriter.getIndexType(), indexValue);
           auto index2 = rewriter.create<linalg::IndexOp>(loc, 2);
           Value extract = rewriter.create<tensor::ExtractOp>(
               loc, input, ValueRange{index0, index1, index2});
           rewriter.create<linalg::YieldOp>(loc, extract);

mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamed.cpp

 }
 
 namespace {
 
 class ConvConverter : public OpConversionPattern<tosa::Conv2DOp> {
 public:
   using OpConversionPattern<tosa::Conv2DOp>::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tosa::Conv2DOp op, OpAdaptor adaptor,
+  matchAndRewrite(tosa::Conv2DOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = op->getLoc();
     Value input = op->getOperand(0);
     Value weight = op->getOperand(1);
     Value bias = op->getOperand(2);
 
     ShapedType inputTy = input.getType().cast<ShapedType>();
     ShapedType weightTy = weight.getType().cast<ShapedType>();
public:
   }
 };
 
 class DepthwiseConvConverter
     : public OpConversionPattern<tosa::DepthwiseConv2DOp> {
 public:
   using OpConversionPattern<tosa::DepthwiseConv2DOp>::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tosa::DepthwiseConv2DOp op, OpAdaptor adaptor,
+  matchAndRewrite(tosa::DepthwiseConv2DOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = op->getLoc();
     Value input = op->getOperand(0);
     Value weight = op->getOperand(1);
     Value bias = op->getOperand(2);
 
     ShapedType inputTy = input.getType().cast<ShapedType>();
     ShapedType weightTy = weight.getType().cast<ShapedType>();
public:
   }
 };
 
 class FullyConnectedConverter
     : public OpConversionPattern<tosa::FullyConnectedOp> {
 public:
   using OpConversionPattern<tosa::FullyConnectedOp>::OpConversionPattern;
   LogicalResult
-  matchAndRewrite(tosa::FullyConnectedOp op, OpAdaptor adaptor,
+  matchAndRewrite(tosa::FullyConnectedOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const final {
     Location loc = op.getLoc();
     auto outputTy = op.getType().cast<ShapedType>();
     auto input = op.input();
     auto inputTy = input.getType().cast<ShapedType>();
 
     auto bias = op.bias();
 
LogicalResult matchAndRewrite(tosa::AvgPool2dOp op,
     Value genericInitTensor = rewriter.create<linalg::InitTensorOp>(
         loc, resultTy.getShape(), resultETy);
 
     auto genericOp = rewriter.create<linalg::GenericOp>(
         loc, ArrayRef<Type>({resultTy}), ValueRange{poolingOp},
         ValueRange{genericInitTensor},
         ArrayRef<AffineMap>({affineMap, affineMap}),
         getNParallelLoopsAttrs(resultTy.getRank()),
-        [&](OpBuilder &b, Location loc, ValueRange args) {
+        [&](OpBuilder &, Location loc, ValueRange args) {
           auto zero = rewriter.create<arith::ConstantIndexOp>(loc, 0);
           auto one = rewriter.create<arith::ConstantIndexOp>(loc, 1);
           auto iH = rewriter.create<arith::ConstantIndexOp>(
               loc, poolingOpTy.getDimSize(1) - 1);
           auto iW = rewriter.create<arith::ConstantIndexOp>(
               loc, poolingOpTy.getDimSize(2) - 1);
 
           // Compute the indices from either end.

mlir/lib/Dialect/AMX/Transforms/LegalizeForLLVMExport.cpp

Value castPtr(ConversionPatternRewriter &rewriter, Location loc, Value ptr) {
   auto i8Ptr =
       LLVM::LLVMPointerType::get(IntegerType::get(ptr.getContext(), 8));
   return rewriter.create<LLVM::BitcastOp>(loc, i8Ptr, ptr);
 }
 
 struct TileZeroConversion : public ConvertOpToLLVMPattern<TileZeroOp> {
   using ConvertOpToLLVMPattern<TileZeroOp>::ConvertOpToLLVMPattern;
   LogicalResult
-  matchAndRewrite(TileZeroOp op, OpAdaptor adaptor,
+  matchAndRewrite(TileZeroOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const override {
     VectorType vType = op.getVectorType();
     // Determine m x n tile sizes.
     std::pair<Value, Value> tsz =
         getTileSizes(rewriter, *getTypeConverter(), vType, op.getLoc());
     // Replace operation with intrinsic.
     Type resType = typeConverter->convertType(vType);
     rewriter.replaceOpWithNewOp<amx::x86_amx_tilezero>(op, resType, tsz.first,

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

struct AffineInlinerInterface : public DialectInlinerInterface {
   //===--------------------------------------------------------------------===//
   // Analysis Hooks
   //===--------------------------------------------------------------------===//
 
   /// Returns true if the given region 'src' can be inlined into the region
   /// 'dest' that is attached to an operation registered to the current dialect.
   /// 'wouldBeCloned' is set if the region is cloned into its new location
   /// rather than moved, indicating there may be other users.
-  bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
+  bool isLegalToInline(Region *dest, Region *src, bool,
                        BlockAndValueMapping &valueMapping) const final {
     // We can inline into affine loops and conditionals if this doesn't break
     // affine value categorization rules.
     Operation *destOp = dest->getParentOp();
     if (!isa<AffineParallelOp, AffineForOp, AffineIfOp>(destOp))
       return false;
 
     // Multi-block regions cannot be inlined into affine constructs, all of
for (Operation &op : srcBlock) {
         return false;
     }
 
     return true;
   }
 
   /// Returns true if the given operation 'op', that is registered to this
   /// dialect, can be inlined into the given region, false otherwise.
-  bool isLegalToInline(Operation *op, Region *region, bool wouldBeCloned,
-                       BlockAndValueMapping &valueMapping) const final {
+  bool isLegalToInline(Operation *, Region *region, bool,
+                       BlockAndValueMapping &) const final {
     // Always allow inlining affine operations into a region that is marked as
     // affine scope, or into affine loops and conditionals. There are some edge
     // cases when inlining *into* affine structures, but that is handled in the
     // other 'isLegalToInline' hook above.
     Operation *parentOp = region->getParentOp();
     return parentOp->hasTrait<OpTrait::AffineScope>() ||
            isa<AffineForOp, AffineParallelOp, AffineIfOp>(parentOp);
   }
 
   /// Affine regions should be analyzed recursively.
-  bool shouldAnalyzeRecursively(Operation *op) const final { return true; }
+  bool shouldAnalyzeRecursively(Operation *) const final { return true; }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // AffineDialect
 //===----------------------------------------------------------------------===//
 
 void AffineDialect::initialize() {
static LogicalResult foldMemRefCast(Operation *op, Value ignore = nullptr) {
   return success(folded);
 }
 
 //===----------------------------------------------------------------------===//
 // AffineDmaStartOp
 //===----------------------------------------------------------------------===//
 
 // TODO: Check that map operands are loop IVs or symbols.
-void AffineDmaStartOp::build(OpBuilder &builder, OperationState &result,
+void AffineDmaStartOp::build(OpBuilder &, OperationState &result,
                              Value srcMemRef, AffineMap srcMap,
                              ValueRange srcIndices, Value destMemRef,
                              AffineMap dstMap, ValueRange destIndices,
                              Value tagMemRef, AffineMap tagMap,
                              ValueRange tagIndices, Value numElements,
                              Value stride, Value elementsPerStride) {
   result.addOperands(srcMemRef);
   result.addAttribute(getSrcMapAttrName(), AffineMapAttr::get(srcMap));
for (auto idx : getTagIndices()) {
     if (!idx.getType().isIndex())
       return emitOpError("tag index to dma_start must have 'index' type");
     if (!isValidAffineIndexOperand(idx, scope))
       return emitOpError("tag index must be a dimension or symbol identifier");
   }
   return success();
 }
 
-LogicalResult AffineDmaStartOp::fold(ArrayRef<Attribute> cstOperands,
-                                     SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult AffineDmaStartOp::fold(ArrayRef<Attribute>,
+                                     SmallVectorImpl<OpFoldResult> &) {
   /// dma_start(memrefcast) -> dma_start
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // AffineDmaWaitOp
 //===----------------------------------------------------------------------===//
 
 // TODO: Check that map operands are loop IVs or symbols.
-void AffineDmaWaitOp::build(OpBuilder &builder, OperationState &result,
+void AffineDmaWaitOp::build(OpBuilder &, OperationState &result,
                             Value tagMemRef, AffineMap tagMap,
                             ValueRange tagIndices, Value numElements) {
   result.addOperands(tagMemRef);
   result.addAttribute(getTagMapAttrName(), AffineMapAttr::get(tagMap));
   result.addOperands(tagIndices);
   result.addOperands(numElements);
 }
 
for (auto idx : getTagIndices()) {
     if (!idx.getType().isIndex())
       return emitOpError("index to dma_wait must have 'index' type");
     if (!isValidAffineIndexOperand(idx, scope))
       return emitOpError("index must be a dimension or symbol identifier");
   }
   return success();
 }
 
-LogicalResult AffineDmaWaitOp::fold(ArrayRef<Attribute> cstOperands,
-                                    SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult AffineDmaWaitOp::fold(ArrayRef<Attribute>,
+                                    SmallVectorImpl<OpFoldResult> &) {
   /// dma_wait(memrefcast) -> dma_wait
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // AffineForOp
 //===----------------------------------------------------------------------===//
 

 static bool hasTrivialZeroTripCount(AffineForOp op) {
   if (!op.hasConstantBounds())
     return false;
   int64_t lb = op.getConstantLowerBound();
   int64_t ub = op.getConstantUpperBound();
   return ub - lb <= 0;
 }
 
-LogicalResult AffineForOp::fold(ArrayRef<Attribute> operands,
+LogicalResult AffineForOp::fold(ArrayRef<Attribute>,
                                 SmallVectorImpl<OpFoldResult> &results) {
   bool folded = succeeded(foldLoopBounds(*this));
   folded |= succeeded(canonicalizeLoopBounds(*this));
   if (hasTrivialZeroTripCount(*this)) {
     // The initial values of the loop-carried variables (iter_args) are the
     // results of the op.
     results.assign(getIterOperands().begin(), getIterOperands().end());
     folded = true;
static void buildAffineLoopNestImpl(
   }
 
   // Create the loops iteratively and store the induction variables.
   SmallVector<Value, 4> ivs;
   ivs.reserve(lbs.size());
   for (unsigned i = 0, e = lbs.size(); i < e; ++i) {
     // Callback for creating the loop body, always creates the terminator.
     auto loopBody = [&](OpBuilder &nestedBuilder, Location nestedLoc, Value iv,
-                        ValueRange iterArgs) {
+                        ValueRange) {
       ivs.push_back(iv);
       // In the innermost loop, call the body builder.
       if (i == e - 1 && bodyBuilderFn) {
         OpBuilder::InsertionGuard nestedGuard(nestedBuilder);
         bodyBuilderFn(nestedBuilder, nestedLoc, ivs);
       }
       nestedBuilder.create<AffineYieldOp>(nestedLoc);
     };
void AffineIfOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                              MLIRContext *context) {
   results.add<SimplifyDeadElse, AlwaysTrueOrFalseIf>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // AffineLoadOp
 //===----------------------------------------------------------------------===//
 
-void AffineLoadOp::build(OpBuilder &builder, OperationState &result,
-                         AffineMap map, ValueRange operands) {
+void AffineLoadOp::build(OpBuilder &, OperationState &result, AffineMap map,
+                         ValueRange operands) {
   assert(operands.size() == 1 + map.getNumInputs() && "inconsistent operands");
   result.addOperands(operands);
   if (map)
     result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
   auto memrefType = operands[0].getType().cast<MemRefType>();
   result.types.push_back(memrefType.getElementType());
 }
 
-void AffineLoadOp::build(OpBuilder &builder, OperationState &result,
-                         Value memref, AffineMap map, ValueRange mapOperands) {
+void AffineLoadOp::build(OpBuilder &, OperationState &result, Value memref,
+                         AffineMap map, ValueRange mapOperands) {
   assert(map.getNumInputs() == mapOperands.size() && "inconsistent index info");
   result.addOperands(memref);
   result.addOperands(mapOperands);
   auto memrefType = memref.getType().cast<MemRefType>();
   result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
   result.types.push_back(memrefType.getElementType());
 }
 
LogicalResult verify(AffineLoadOp op) {
   return success();
 }
 
 void AffineLoadOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                MLIRContext *context) {
   results.add<SimplifyAffineOp<AffineLoadOp>>(context);
 }
 
-OpFoldResult AffineLoadOp::fold(ArrayRef<Attribute> cstOperands) {
+OpFoldResult AffineLoadOp::fold(ArrayRef<Attribute>) {
   /// load(memrefcast) -> load
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
   return OpFoldResult();
 }
 
 //===----------------------------------------------------------------------===//
 // AffineStoreOp
 //===----------------------------------------------------------------------===//
 
-void AffineStoreOp::build(OpBuilder &builder, OperationState &result,
+void AffineStoreOp::build(OpBuilder &, OperationState &result,
                           Value valueToStore, Value memref, AffineMap map,
                           ValueRange mapOperands) {
   assert(map.getNumInputs() == mapOperands.size() && "inconsistent index info");
   result.addOperands(valueToStore);
   result.addOperands(memref);
   result.addOperands(mapOperands);
   result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
 }
LogicalResult verify(AffineStoreOp op) {
   return success();
 }
 
 void AffineStoreOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                 MLIRContext *context) {
   results.add<SimplifyAffineOp<AffineStoreOp>>(context);
 }
 
-LogicalResult AffineStoreOp::fold(ArrayRef<Attribute> cstOperands,
-                                  SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult AffineStoreOp::fold(ArrayRef<Attribute>,
+                                  SmallVectorImpl<OpFoldResult> &) {
   /// store(memrefcast) -> store
   return foldMemRefCast(*this, getValueToStore());
 }
 
 //===----------------------------------------------------------------------===//
 // AffineMinMaxOpBase
 //===----------------------------------------------------------------------===//
 

 }
 
 void AffinePrefetchOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                    MLIRContext *context) {
   // prefetch(memrefcast) -> prefetch
   results.add<SimplifyAffineOp<AffinePrefetchOp>>(context);
 }
 
-LogicalResult AffinePrefetchOp::fold(ArrayRef<Attribute> cstOperands,
-                                     SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult AffinePrefetchOp::fold(ArrayRef<Attribute>,
+                                     SmallVectorImpl<OpFoldResult> &) {
   /// prefetch(memrefcast) -> prefetch
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // AffineParallelOp
 //===----------------------------------------------------------------------===//
 
static LogicalResult canonicalizeLoopBounds(AffineParallelOp op) {
   if (lbCanonicalized)
     op.setLowerBounds(lb.getOperands(), lb.getAffineMap());
   if (ubCanonicalized)
     op.setUpperBounds(ub.getOperands(), ub.getAffineMap());
 
   return success();
 }
 
-LogicalResult AffineParallelOp::fold(ArrayRef<Attribute> operands,
-                                     SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult AffineParallelOp::fold(ArrayRef<Attribute>,
+                                     SmallVectorImpl<OpFoldResult> &) {
   return canonicalizeLoopBounds(*this);
 }
 
 /// Prints a lower(upper) bound of an affine parallel loop with max(min)
 /// conditions in it. `mapAttr` is a flat list of affine expressions and `group`
 /// identifies which of the those expressions form max/min groups. `operands`
 /// are the SSA values of dimensions and symbols and `keyword` is either "min"
 /// or "max".
static LogicalResult verify(AffineYieldOp op) {
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // AffineVectorLoadOp
 //===----------------------------------------------------------------------===//
 
-void AffineVectorLoadOp::build(OpBuilder &builder, OperationState &result,
+void AffineVectorLoadOp::build(OpBuilder &, OperationState &result,
                                VectorType resultType, AffineMap map,
                                ValueRange operands) {
   assert(operands.size() == 1 + map.getNumInputs() && "inconsistent operands");
   result.addOperands(operands);
   if (map)
     result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
   result.types.push_back(resultType);
 }
 
-void AffineVectorLoadOp::build(OpBuilder &builder, OperationState &result,
+void AffineVectorLoadOp::build(OpBuilder &, OperationState &result,
                                VectorType resultType, Value memref,
                                AffineMap map, ValueRange mapOperands) {
   assert(map.getNumInputs() == mapOperands.size() && "inconsistent index info");
   result.addOperands(memref);
   result.addOperands(mapOperands);
   result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
   result.types.push_back(resultType);
 }
static LogicalResult verify(AffineVectorLoadOp op) {
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // AffineVectorStoreOp
 //===----------------------------------------------------------------------===//
 
-void AffineVectorStoreOp::build(OpBuilder &builder, OperationState &result,
+void AffineVectorStoreOp::build(OpBuilder &, OperationState &result,
                                 Value valueToStore, Value memref, AffineMap map,
                                 ValueRange mapOperands) {
   assert(map.getNumInputs() == mapOperands.size() && "inconsistent index info");
   result.addOperands(valueToStore);
   result.addOperands(memref);
   result.addOperands(mapOperands);
   result.addAttribute(getMapAttrName(), AffineMapAttr::get(map));
 }

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

 
 // This attempts to find stores which have no impact on the final result.
 // A writing op writeA will be eliminated if there exists an op writeB if
 // 1) writeA and writeB have mathematically equivalent affine access functions.
 // 2) writeB postdominates writeA.
 // 3) There is no potential read between writeA and writeB.
 static void findUnusedStore(AffineWriteOpInterface writeA,
                             SmallVectorImpl<Operation *> &opsToErase,
-                            SmallPtrSetImpl<Value> &memrefsToErase,
                             PostDominanceInfo &postDominanceInfo) {
 
   for (Operation *user : writeA.getMemRef().getUsers()) {
     // Only consider writing operations.
     auto writeB = dyn_cast<AffineWriteOpInterface>(user);
     if (!writeB)
       continue;
 
void mlir::affineScalarReplace(FuncOp f, DominanceInfo &domInfo,
 
   // Erase all load op's whose results were replaced with store fwd'ed ones.
   for (auto *op : opsToErase)
     op->erase();
   opsToErase.clear();
 
   // Walk all store's and perform unused store elimination
   f.walk([&](AffineWriteOpInterface storeOp) {
-    findUnusedStore(storeOp, opsToErase, memrefsToErase, postDomInfo);
+    findUnusedStore(storeOp, opsToErase, postDomInfo);
   });
   // Erase all store op's which don't impact the program
   for (auto *op : opsToErase)
     op->erase();
 
   // Check if the store fwd'ed memrefs are now left with only stores and can
   // thus be completely deleted. Note: the canonicalize pass should be able
   // to do this as well, but we'll do it here since we collected these anyway.

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

if (value.getType() != type)
     return false;
   // Integer values must be signless.
   if (type.isa<IntegerType>() && !type.cast<IntegerType>().isSignless())
     return false;
   // Integer, float, and element attributes are buildable.
   return value.isa<IntegerAttr, FloatAttr, ElementsAttr>();
 }
 
-OpFoldResult arith::ConstantOp::fold(ArrayRef<Attribute> operands) {
-  return getValue();
-}
+OpFoldResult arith::ConstantOp::fold(ArrayRef<Attribute>) { return getValue(); }
 
 void arith::ConstantIntOp::build(OpBuilder &builder, OperationState &result,
                                  int64_t value, unsigned width) {
   auto type = builder.getIntegerType(width);
   arith::ConstantOp::build(builder, result, type,
                            builder.getIntegerAttr(type, value));
 }
 

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) {
       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) {
       // 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) {
     ImplicitLocOpBuilder nb(loc, loopBuilder);
 
     // Call parallel compute function inside the async.execute region.
     auto executeBodyBuilder = [&](OpBuilder &executeBuilder,
-                                  Location executeLoc, ValueRange executeArgs) {
+                                  Location executeLoc, ValueRange) {
       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) {
         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/Bufferization/IR/BufferizationOps.cpp

void CloneOp::getEffects(
   effects.emplace_back(MemoryEffects::Read::get(), input(),
                        SideEffects::DefaultResource::get());
   effects.emplace_back(MemoryEffects::Write::get(), output(),
                        SideEffects::DefaultResource::get());
   effects.emplace_back(MemoryEffects::Allocate::get(), output(),
                        SideEffects::DefaultResource::get());
 }
 
-OpFoldResult CloneOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult CloneOp::fold(ArrayRef<Attribute>) {
   return succeeded(memref::foldMemRefCast(*this)) ? getResult() : Value();
 }
 
 namespace {
 
 /// Merge the clone and its source (by converting the clone to a cast) when
 /// possible.
 struct SimplifyClones : public OpRewritePattern<CloneOp> {

mlir/lib/Dialect/DLTI/DLTI.cpp

 };
 } // namespace
 
 void DLTIDialect::initialize() {
   addAttributes<DataLayoutEntryAttr, DataLayoutSpecAttr>();
   addInterfaces<TargetDataLayoutInterface>();
 }
 
-Attribute DLTIDialect::parseAttribute(DialectAsmParser &parser,
-                                      Type type) const {
+Attribute DLTIDialect::parseAttribute(DialectAsmParser &parser, 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/EmitC/IR/EmitC.cpp

 
 //===----------------------------------------------------------------------===//
 // EmitC Attributes
 //===----------------------------------------------------------------------===//
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCAttributes.cpp.inc"
 
-Attribute emitc::OpaqueAttr::parse(AsmParser &parser, Type type) {
+Attribute emitc::OpaqueAttr::parse(AsmParser &parser, Type) {
   if (parser.parseLess())
     return Attribute();
   std::string value;
   llvm::SMLoc loc = parser.getCurrentLocation();
   if (parser.parseOptionalString(&value)) {
     parser.emitError(loc) << "expected string";
     return Attribute();
   }

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

void rewrite() {
     Value activeWidth =
         create<arith::SubIOp>(workgroupSize, numThreadsWithSmallerSubgroupId);
 
     // Create factory for op which accumulates to values.
     AccumulatorFactory accumFactory = getFactory();
     assert(accumFactory && "failed to create accumulator factory");
 
     // Reduce elements within each subgroup to produce the intermediate results.
-    Value subgroupReduce = createSubgroupReduce(activeWidth, laneId,
-                                                reduceOp.value(), accumFactory);
+    Value subgroupReduce =
+        createSubgroupReduce(activeWidth, reduceOp.value(), accumFactory);
 
     // Add workgroup buffer to parent function for intermediate result.
     Value buffer = createWorkgroupBuffer();
 
     // Write the intermediate results to workgroup memory, using the first lane
     // of each subgroup.
     createPredicatedBlock(isFirstLane, [&] {
       Value subgroupId = getDivideBySubgroupSize(invocationIdx);
void rewrite() {
 
     // Use the first numSubgroups invocations to reduce the intermediate results
     // from workgroup memory. The final result is written to workgroup memory
     // again.
     Value zero = create<arith::ConstantIndexOp>(0);
     createPredicatedBlock(isValidSubgroup, [&] {
       Value index = create<arith::IndexCastOp>(indexType, invocationIdx);
       Value value = create<memref::LoadOp>(valueType, buffer, index);
-      Value result =
-          createSubgroupReduce(numSubgroups, laneId, value, accumFactory);
+      Value result = createSubgroupReduce(numSubgroups, value, accumFactory);
       create<memref::StoreOp>(result, buffer, zero);
     });
 
     // Synchronize workgroup and load result from workgroup memory.
     create<gpu::BarrierOp>();
     Value result = create<memref::LoadOp>(valueType, buffer, zero);
 
     rewriter.replaceOp(reduceOp, result);
createIf(
           return ArrayRef<Value>();
         },
         [&] { return ArrayRef<Value>(); });
   }
 
   /// Creates a reduction across the first activeWidth lanes of a subgroup, or
   /// the entire subgroup if activeWidth is larger than the subgroup width.
   /// The first lane returns the result, all others return values are undefined.
-  Value createSubgroupReduce(Value activeWidth, Value laneId, Value operand,
+  Value createSubgroupReduce(Value activeWidth, Value operand,
                              AccumulatorFactory &accumFactory) {
     Value subgroupSize = create<arith::ConstantIntOp>(kSubgroupSize, int32Type);
     Value isPartialSubgroup = create<arith::CmpIOp>(arith::CmpIPredicate::slt,
                                                     activeWidth, subgroupSize);
     std::array<Type, 2> shuffleType = {valueType, rewriter.getI1Type()};
     auto xorAttr = rewriter.getStringAttr("xor");
 
     createIf(

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

private:
   void addAsyncDependencyAfter(ValueRange asyncTokens, Operation *op) {
     OpBuilder builder(op->getContext());
     auto loc = op->getLoc();
 
     Block::iterator it;
     SmallVector<Value, 1> tokens;
     tokens.reserve(asyncTokens.size());
     TypeSwitch<Operation *>(op)
-        .Case<async::AwaitOp>([&](auto awaitOp) {
+        .Case<async::AwaitOp>([&](auto) {
           // Add async.await ops to wait for the !gpu.async.tokens.
           builder.setInsertionPointAfter(op);
           for (auto asyncToken : asyncTokens)
             tokens.push_back(
                 builder.create<async::AwaitOp>(loc, asyncToken).result());
           // Set `it` after the inserted async.await ops.
           it = builder.getInsertionPoint();
         })

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

if (!blob)
     return signalPassFailure();
 
   // Add the blob as module attribute.
   auto attr =
       StringAttr::get(&getContext(), StringRef(blob->data(), blob->size()));
   getOperation()->setAttr(gpuBinaryAnnotation, attr);
 }
 
-LogicalResult
-gpu::SerializeToBlobPass::optimizeLlvm(llvm::Module &llvmModule,
-                                       llvm::TargetMachine &targetMachine) {
+LogicalResult gpu::SerializeToBlobPass::optimizeLlvm(llvm::Module &,
+                                                     llvm::TargetMachine &) {
   // TODO: If serializeToCubin ends up defining optimizations, factor them
   // into here from SerializeToHsaco
   return success();
 }
 
 void gpu::SerializeToBlobPass::getDependentDialects(
     DialectRegistry &registry) const {
   registerLLVMDialectTranslation(registry);

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

 Type LLVMArrayType::getElementType() const { return getImpl()->elementType; }
 
 unsigned LLVMArrayType::getNumElements() const {
   return getImpl()->numElements;
 }
 
 LogicalResult
 LLVMArrayType::verify(function_ref<InFlightDiagnostic()> emitError,
-                      Type elementType, unsigned numElements) {
+                      Type elementType, unsigned) {
   if (!isValidElementType(elementType))
     return emitError() << "invalid array element type: " << elementType;
   return success();
 }
 
 unsigned LLVMArrayType::getTypeSizeInBits(const DataLayout &dataLayout,
                                           DataLayoutEntryListRef params) const {
   return kBitsInByte * getTypeSize(dataLayout, params);
 }
 
 unsigned LLVMArrayType::getTypeSize(const DataLayout &dataLayout,
-                                    DataLayoutEntryListRef params) const {
+                                    DataLayoutEntryListRef) const {
   return llvm::alignTo(dataLayout.getTypeSize(getElementType()),
                        dataLayout.getTypeABIAlignment(getElementType())) *
          getNumElements();
 }
 
 unsigned LLVMArrayType::getABIAlignment(const DataLayout &dataLayout,
-                                        DataLayoutEntryListRef params) const {
+                                        DataLayoutEntryListRef) const {
   return dataLayout.getTypeABIAlignment(getElementType());
 }
 
-unsigned
-LLVMArrayType::getPreferredAlignment(const DataLayout &dataLayout,
-                                     DataLayoutEntryListRef params) const {
+unsigned LLVMArrayType::getPreferredAlignment(const DataLayout &dataLayout,
+                                              DataLayoutEntryListRef) const {
   return dataLayout.getTypePreferredAlignment(getElementType());
 }
 
 //===----------------------------------------------------------------------===//
 // Function type.
 //===----------------------------------------------------------------------===//
 
 bool LLVMFunctionType::isValidArgumentType(Type type) {
LLVMStructType::verify(function_ref<InFlightDiagnostic()> emitError,
                        ArrayRef<Type> types, bool) {
   for (Type t : types)
     if (!isValidElementType(t))
       return emitError() << "invalid LLVM structure element type: " << t;
 
   return success();
 }
 
-unsigned
-LLVMStructType::getTypeSizeInBits(const DataLayout &dataLayout,
-                                  DataLayoutEntryListRef params) const {
+unsigned LLVMStructType::getTypeSizeInBits(const DataLayout &dataLayout,
+                                           DataLayoutEntryListRef) const {
   unsigned structSize = 0;
   unsigned structAlignment = 1;
   for (Type element : getBody()) {
     unsigned elementAlignment =
         isPacked() ? 1 : dataLayout.getTypeABIAlignment(element);
     // Add padding to the struct size to align it to the abi alignment of the
     // element type before than adding the size of the element
     structSize = llvm::alignTo(structSize, elementAlignment);
unsigned LLVMStructType::getTypeSizeInBits(const DataLayout &dataLayout,
   return structSize * kBitsInByte;
 }
 
 namespace {
 enum class StructDLEntryPos { Abi = 0, Preferred = 1 };
 } // namespace
 
 static Optional<unsigned>
-getStructDataLayoutEntry(DataLayoutEntryListRef params, LLVMStructType type,
-                         StructDLEntryPos pos) {
+getStructDataLayoutEntry(DataLayoutEntryListRef params, StructDLEntryPos pos) {
   const auto *currentEntry =
       llvm::find_if(params, [](DataLayoutEntryInterface entry) {
         return entry.isTypeEntry();
       });
   if (currentEntry == params.end())
     return llvm::None;
 
   auto attr = currentEntry->getValue().cast<DenseIntElementsAttr>();
static unsigned calculateStructAlignment(const DataLayout &dataLayout,
   // requirement of its elements.
   unsigned structAlignment = 1;
   for (Type iter : type.getBody()) {
     structAlignment =
         std::max(dataLayout.getTypeABIAlignment(iter), structAlignment);
   }
 
   // Entries are only allowed to be stricter than the required alignment
-  if (Optional<unsigned> entryResult =
-          getStructDataLayoutEntry(params, type, pos))
+  if (Optional<unsigned> entryResult = getStructDataLayoutEntry(params, pos))
     return std::max(*entryResult / kBitsInByte, structAlignment);
 
   return structAlignment;
 }
 
 unsigned LLVMStructType::getABIAlignment(const DataLayout &dataLayout,
                                          DataLayoutEntryListRef params) const {
   return calculateStructAlignment(dataLayout, params, *this,

mlir/lib/Dialect/Linalg/ComprehensiveBufferize/ArithInterfaceImpl.cpp

LogicalResult bufferize(Operation *op, OpBuilder &b,
 
     GlobalCreator globalCreator(moduleOp);
     auto globalMemref = globalCreator.getGlobalFor(constantOp);
     state.replaceOpWithNewOp<memref::GetGlobalOp>(b, op, globalMemref.type(),
                                                   globalMemref.getName());
     return success();
   }
 
-  bool isWritable(Operation *op, Value value, BufferizationState &state) const {
+  bool isWritable(Operation *, Value value, BufferizationState &) const {
     // Memory locations returned by memref::GetGlobalOp may not be written to.
     assert(value.isa<OpResult>());
     return false;
   }
 };
 
 } // namespace arith_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
 void mlir::linalg::comprehensive_bufferize::arith_ext::
     registerBufferizableOpInterfaceExternalModels(DialectRegistry &registry) {
   registry.addOpInterface<arith::ConstantOp, arith_ext::ConstantOpInterface>();
 }

mlir/lib/Dialect/Linalg/ComprehensiveBufferize/BufferizationInterfaceImpl.cpp

 /// Note: ToMemrefOp / ToTensorOp are temporary ops that are inserted at the
 /// bufferization boundary. When bufferization is complete, there should be no
 /// such ops left over. If `allowUnknownOps`, such ops may be part of the
 /// resulting IR, but such IR may no longer be bufferizable by Comprehensive
 /// Bufferize.
 struct ToMemrefOpInterface
     : public BufferizableOpInterface::ExternalModel<ToMemrefOpInterface,
                                                     bufferization::ToMemrefOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &,
+                              BufferizationState &) const {
     // It is unknown whether the resulting MemRef will be read or not.
     return true;
   }
 
-  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  OpResult getAliasingOpResult(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return OpResult();
   }
 
-  LogicalResult bufferize(Operation *op, OpBuilder &b,
+  LogicalResult bufferize(Operation *op, OpBuilder &,
                           BufferizationState &state) const {
     auto toMemrefOp = cast<bufferization::ToMemrefOp>(op);
 
     // Fold to_memref(to_tensor(x)) to x.
     if (auto toTensorOp =
             toMemrefOp.tensor().getDefiningOp<bufferization::ToTensorOp>()) {
       toMemrefOp.replaceAllUsesWith(toTensorOp.memref());
       toMemrefOp.erase();

 /// ToTensorOp. We have to assume that the loaded tensor may after bufferization
 /// potentially alias with any other bufferized tensor. Since ToTensorOp and
 /// ToMemrefOp have no aliasing OpOperand/OpResult pairs, this cannot be encoded
 /// directly in the analysis. However, declaring ToTensorOp results as not
 /// writable also enforces a buffer copy and has the same effect.
 struct ToTensorOpInterface
     : public BufferizableOpInterface::ExternalModel<ToTensorOpInterface,
                                                     bufferization::ToTensorOp> {
-  LogicalResult bufferize(Operation *op, OpBuilder &b,
-                          BufferizationState &state) const {
+  LogicalResult bufferize(Operation *, OpBuilder &,
+                          BufferizationState &) const {
     return success();
   }
 
-  bool isWritable(Operation *op, Value value, BufferizationState &state) const {
+  bool isWritable(Operation *, Value, BufferizationState &) const {
     // It is unknown whether the MemRef operand is writable or not.
     return false;
   }
 };
 
 } // namespace bufferization_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg

mlir/lib/Dialect/Linalg/ComprehensiveBufferize/ModuleBufferization.cpp

static void annotateReturnOp(OpOperand &returnVal, BlockArgument bbArg) {
     equivBbArgs[returnVal.getOperandNumber()] = bbArg.getArgNumber();
 
     OpBuilder b(op->getContext());
     op->setAttr(kEquivalentArgsAttr, b.getI64ArrayAttr(equivBbArgs));
   }
 
   LogicalResult run(Operation *op, BufferizationState &state,
                     BufferizationAliasInfo &aliasInfo,
-                    SmallVector<Operation *> &newOps) override {
+                    SmallVector<Operation *> &) override {
     ModuleBufferizationState &moduleState = getModuleBufferizationState(state);
 
     // Support only single return-terminated block in the function.
     auto funcOp = cast<FuncOp>(op);
     ReturnOp returnOp = getAssumedUniqueReturnOp(funcOp);
     assert(returnOp && "expected func with single return op");
 
     for (OpOperand &returnVal : returnOp->getOpOperands())

 
 namespace mlir {
 namespace linalg {
 namespace comprehensive_bufferize {
 namespace std_ext {
 
 struct CallOpInterface
     : public BufferizableOpInterface::ExternalModel<CallOpInterface, CallOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &,
+                              BufferizationState &) const {
     // CallOpInterface alone doesn't bufferize to a memory read, one of the uses
     // of the matching bbArg may. It is the responsibility of the caller to
     // inspect bbArgs. In the absence of a BufferizationAliasInfo, we need to be
     // conservative.
     return true;
   }
 
-  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  OpResult getAliasingOpResult(Operation *, OpOperand &,
+                               BufferizationState &) const {
     // CallOpInterface is special, it needs to wait for the callee to be
     // bufferized and needs to inspect the BufferAliasInfo object. It can't
     // make a proper determination by itself and needs to be conservative.
     return OpResult();
   }
 
   /// In a first approximation, all the function arguments of a FuncOp are
   /// marked inplaceable. For now, it is the responsibility of the `callOp`
LogicalResult bufferize(Operation *op, OpBuilder &b,
 
     return success();
   }
 };
 
 struct ReturnOpInterface
     : public BufferizableOpInterface::ExternalModel<ReturnOpInterface,
                                                     ReturnOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &,
+                              BufferizationState &) const {
     return true;
   }
 
-  bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  bool bufferizesToMemoryWrite(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return false;
   }
 
-  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  OpResult getAliasingOpResult(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return OpResult();
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BufferizationState &state) const {
     auto returnOp = cast<ReturnOp>(op);
     assert(isa<FuncOp>(returnOp->getParentOp()) &&
            "only support FuncOp parent for ReturnOp");
 
     for (OpOperand &operand : returnOp->getOpOperands()) {
       auto tensorType = operand.get().getType().dyn_cast<TensorType>();
       if (!tensorType)
         continue;
       Value v = state.lookupBuffer(operand.get());
       Value returnTensor = b.create<bufferization::ToTensorOp>(
           returnOp.getLoc(), v);
       operand.set(returnTensor);
     }
     return success();
   }
 };
 
 struct FuncOpInterface
     : public BufferizableOpInterface::ExternalModel<FuncOpInterface, FuncOp> {
-  LogicalResult bufferize(Operation *op, OpBuilder &b,
+  LogicalResult bufferize(Operation *op, OpBuilder &,
                           BufferizationState &state) const {
     auto funcOp = cast<FuncOp>(op);
 
     // Bufferize function body.
     return comprehensive_bufferize::bufferize(&funcOp.body(), state);
   }
 
   /// Return `true` if the given function argument is writable.
BoolAttr inplaceAttr = funcOp.getArgAttrOfType<BoolAttr>(
         bbArg.getArgNumber(), BufferizableOpInterface::kInplaceableAttrName);
     if (inplaceAttr && inplaceAttr.getValue())
       return true;
 
     // All other function arguments are not writable.
     return false;
   }
 
-  bool isAllocationHoistingBarrier(Operation *op) const { return true; }
+  bool isAllocationHoistingBarrier(Operation *) const { return true; }
 };
 
 } // namespace std_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
 void mlir::linalg::comprehensive_bufferize::std_ext::

mlir/lib/Dialect/Linalg/ComprehensiveBufferize/SCFInterfaceImpl.cpp

 namespace mlir {
 namespace linalg {
 namespace comprehensive_bufferize {
 namespace scf_ext {
 
 struct ExecuteRegionOpInterface
     : public BufferizableOpInterface::ExternalModel<ExecuteRegionOpInterface,
                                                     scf::ExecuteRegionOp> {
-  SmallVector<OpOperand *>
-  getAliasingOpOperand(Operation *op, OpResult opResult,
-                       BufferizationState &state) const {
+  SmallVector<OpOperand *> getAliasingOpOperand(Operation *op,
+                                                OpResult opResult,
+                                                BufferizationState &) const {
     // ExecuteRegionOps do not have tensor OpOperands. The yielded value can be
     // any SSA value that is in scope. To allow for use-def chain traversal
     // through ExecuteRegionOps in the analysis, the corresponding yield value
     // is considered to be aliasing with the result.
     auto executeRegionOp = cast<scf::ExecuteRegionOp>(op);
     size_t resultNum = std::distance(op->getOpResults().begin(),
                                      llvm::find(op->getOpResults(), opResult));
     assert(executeRegionOp.getRegion().getBlocks().size() == 1 &&
            "expected exactly 1 block");
     auto yieldOp = dyn_cast<scf::YieldOp>(
         executeRegionOp.getRegion().front().getTerminator());
     assert(yieldOp && "expected scf.yield terminator in scf.execute_region");
     return {&yieldOp->getOpOperand(resultNum)};
   }
 
-  bool mustBufferizeInPlace(Operation *op, OpResult opResult,
-                            BufferizationState &state) const {
+  bool mustBufferizeInPlace(Operation *, OpResult, BufferizationState &) const {
     // ExecuteRegionOp results always bufferize in-place. Since they have no
     // OpOperands, they are mostly ignored by the analysis once alias sets are
     // set up.
     return true;
   }
 
   // TODO: For better bufferization results, this could return `true` only if
   // there is a memory write in the region.
-  bool isMemoryWrite(Operation *op, OpResult opResult,
-                     BufferizationState &state) const {
+  bool isMemoryWrite(Operation *, OpResult, BufferizationState &) const {
     // Similar to scf.if, results of this op are always considered memory writes
     // in the analysis. This is a useful pattern for all ops that have tensor
     // OpResults but no tensor OpOperands. By default, `isMemoryWrite` is
     // implemented in terms of `bufferizesToMemoryWrite`, which does not work on
     // ops without OpOperands.
     return true;
   }
 
-  LogicalResult bufferize(Operation *op, OpBuilder &b,
+  LogicalResult bufferize(Operation *op, OpBuilder &,
                           BufferizationState &state) const {
     // TODO: Add bufferization support when needed. scf.execute_region should be
     // bufferized similar to scf.if.
     auto executeRegionOp = cast<scf::ExecuteRegionOp>(op);
     bool hasTensorReturnType = any_of(
         op->getResultTypes(), [](Type t) { return t.isa<TensorType>(); });
     if (hasTensorReturnType)
       return op->emitError(
           "scf.execute_region with tensor result not supported");
     return comprehensive_bufferize::bufferize(&executeRegionOp.getRegion(),
                                               state);
   }
 
-  BufferRelation bufferRelation(Operation *op, OpResult opResult,
-                                const BufferizationAliasInfo &aliasInfo,
-                                BufferizationState &state) const {
+  BufferRelation bufferRelation(Operation *, OpResult,
+                                const BufferizationAliasInfo &,
+                                BufferizationState &) const {
     return BufferRelation::Equivalent;
   }
 };
 
 struct IfOpInterface
     : public BufferizableOpInterface::ExternalModel<IfOpInterface, scf::IfOp> {
-  SmallVector<OpOperand *>
-  getAliasingOpOperand(Operation *op, OpResult opResult,
-                       BufferizationState &state) const {
+  SmallVector<OpOperand *> getAliasingOpOperand(Operation *op,
+                                                OpResult opResult,
+                                                BufferizationState &) const {
     // IfOps do not have tensor OpOperands. The yielded value can be any SSA
     // value that is in scope. To allow for use-def chain traversal through
     // IfOps in the analysis, both corresponding yield values from the then/else
     // branches are considered to be aliasing with the result.
     auto ifOp = cast<scf::IfOp>(op);
     size_t resultNum = std::distance(op->getOpResults().begin(),
                                      llvm::find(op->getOpResults(), opResult));
     return {&ifOp.thenYield()->getOpOperand(resultNum),
             &ifOp.elseYield()->getOpOperand(resultNum)};
   }
 
   // TODO: For better bufferization results, this could return `true` only if
   // there is a memory write in one (or both) of the branches. Since this is not
   // allowed at the moment, we should never encounter scf.ifs that yield
   // unmodified tensors. Such scf.yield ops could just fold away.
-  bool isMemoryWrite(Operation *op, OpResult opResult,
-                     BufferizationState &state) const {
+  bool isMemoryWrite(Operation *, OpResult, BufferizationState &) const {
     // IfOp results are always considered memory writes in the analysis. This
     // design decision simplifies the analysis considerably. E.g., consider the
     // following test case:
     //
     // %0 = "some_writing_op" : tensor<?xf32>
     // %r = scf.if %c -> (tensor<?xf32>) {
     //   scf.yield %0
     // } else {
bool isMemoryWrite(Operation *, OpResult, BufferizationState &) const {
     // * read = some_reading_op
     // * lastWrite = %0  (Note: The last write of %r would be a set: {%0, %1}.)
     // * conflictingWrite = %1
     //
     // For more details, check the "scf.IfOp" section of the design document.
     return true;
   }
 
-  bool mustBufferizeInPlace(Operation *op, OpResult opResult,
-                            BufferizationState &state) const {
+  bool mustBufferizeInPlace(Operation *, OpResult, BufferizationState &) const {
     // IfOp results always bufferize in-place. Since they have no OpOperands,
     // they are mostly ignored by the analysis once alias sets are set up.
     return true;
   }
 
-  LogicalResult bufferize(Operation *op, OpBuilder &b,
+  LogicalResult bufferize(Operation *op, OpBuilder &,
                           BufferizationState &state) const {
     auto ifOp = cast<scf::IfOp>(op);
 
     // Use IRRewriter instead of OpBuilder because it has additional helper
     // functions.
     IRRewriter rewriter(op->getContext());
     rewriter.setInsertionPoint(ifOp);
 
struct ForOpInterface
   bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
                               BufferizationState &state) const {
     // scf::ForOp alone doesn't bufferize to a memory read, one of the uses of
     // its matching bbArg may.
     auto forOp = cast<scf::ForOp>(op);
     return state.isValueRead(forOp.getRegionIterArgForOpOperand(opOperand));
   }
 
-  bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  bool bufferizesToMemoryWrite(Operation *, OpOperand &,
+                               BufferizationState &) const {
     // Tensor iter_args of scf::ForOps are always considered as a write. This is
     // to simplify the analysis.
     // TODO: Consider doing sth. like isValueWritten.
     return true;
   }
 
   OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+                               BufferizationState &) const {
     auto forOp = cast<scf::ForOp>(op);
     if (!opOperand.get().getType().isa<RankedTensorType>())
       return OpResult();
     return forOp.getResultForOpOperand(opOperand);
   }
 
   BufferRelation bufferRelation(Operation *op, OpResult opResult,
                                 const BufferizationAliasInfo &aliasInfo,
-                                BufferizationState &state) const {
+                                BufferizationState &) const {
     // ForOp results are equivalent to their corresponding init_args if the
     // corresponding iter_args and yield values are equivalent.
     auto forOp = cast<scf::ForOp>(op);
     OpOperand &forOperand = forOp.getOpOperandForResult(opResult);
     auto bbArg = forOp.getRegionIterArgForOpOperand(forOperand);
     auto yieldOp = cast<scf::YieldOp>(&forOp.getLoopBody().front().back());
     bool equivalentYield = aliasInfo.areEquivalentBufferizedValues(
         bbArg, yieldOp->getOperand(opResult.getResultNumber()));
     return equivalentYield ? BufferRelation::Equivalent : BufferRelation::None;
   }
 
-  bool isWritable(Operation *op, Value value, BufferizationState &state) const {
+  bool isWritable(Operation *, Value, BufferizationState &) const {
     // Interestingly, scf::ForOp's bbArg can **always** be viewed
     // inplace from the perspective of ops nested under:
     //   1. Either the matching iter operand is not bufferized inplace and an
     //      alloc + optional copy makes the bbArg itself inplaceable.
     //   2. Or the matching iter operand is bufferized inplace and bbArg just
     //      bufferizes to that too.
     return true;
   }
auto convert = [&](ValueRange values,
         Value val = it.value();
         result.push_back(indices.contains(idx) ? func(val, idx) : val);
       }
       return result;
     };
 
     // Construct a new scf.for op with memref instead of tensor values.
     SmallVector<Value> initArgs =
-        convert(forOp.getInitArgs(), [&](Value val, int64_t index) {
+        convert(forOp.getInitArgs(), [&](Value, int64_t index) {
           return state.getResultBuffer(forOp->getOpResult(index));
         });
     auto newForOp = rewriter.create<scf::ForOp>(
         forOp.getLoc(), forOp.getLowerBound(), forOp.getUpperBound(),
         forOp.getStep(), initArgs);
     Block *loopBody = &newForOp.getLoopBody().front();
 
     // Set up new iter_args. The loop body uses tensors, so wrap the (memref)
     // iter_args of the new loop in ToTensorOps.
     rewriter.setInsertionPointToStart(loopBody);
     SmallVector<Value> iterArgs =
-        convert(newForOp.getRegionIterArgs(), [&](Value val, int64_t index) {
+        convert(newForOp.getRegionIterArgs(), [&](Value val, int64_t) {
           return rewriter.create<bufferization::ToTensorOp>(val.getLoc(), val);
         });
     iterArgs.insert(iterArgs.begin(), newForOp.getInductionVar());
 
     // Erase terminator if present.
     if (iterArgs.size() == 1)
       rewriter.eraseOp(loopBody->getTerminator());
 
LogicalResult bufferize(Operation *op, OpBuilder & /*b*/,
     return success();
   }
 };
 
 // TODO: Evolve toward matching ReturnLike ops. Check for aliasing values that
 // do not bufferize inplace. (Requires a few more changes for ConstantOp,
 // InitTensorOp, CallOp.)
 LogicalResult mlir::linalg::comprehensive_bufferize::scf_ext::
-    AssertDestinationPassingStyle::run(Operation *op, BufferizationState &state,
+    AssertDestinationPassingStyle::run(Operation *op, BufferizationState &,
                                        BufferizationAliasInfo &aliasInfo,
-                                       SmallVector<Operation *> &newOps) {
+                                       SmallVector<Operation *> &) {
   LogicalResult status = success();
   op->walk([&](scf::YieldOp yieldOp) {
     if (auto forOp = dyn_cast<scf::ForOp>(yieldOp->getParentOp())) {
       for (OpOperand &operand : yieldOp->getOpOperands()) {
         auto tensorType = operand.get().getType().dyn_cast<TensorType>();
         if (!tensorType)
           continue;
 
op->walk([&](scf::YieldOp yieldOp) {
     return WalkResult::advance();
   });
   return status;
 }
 
 struct YieldOpInterface
     : public BufferizableOpInterface::ExternalModel<YieldOpInterface,
                                                     scf::YieldOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &,
+                              BufferizationState &) const {
     return true;
   }
 
-  bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  bool bufferizesToMemoryWrite(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return false;
   }
 
-  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  OpResult getAliasingOpResult(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return OpResult();
   }
 
-  LogicalResult bufferize(Operation *op, OpBuilder &b,
-                          BufferizationState &state) const {
+  LogicalResult bufferize(Operation *op, OpBuilder &,
+                          BufferizationState &) const {
     auto yieldOp = cast<scf::YieldOp>(op);
     if (!isa<scf::ExecuteRegionOp, scf::IfOp, scf::ForOp>(
             yieldOp->getParentOp()))
       return yieldOp->emitError("unsupported scf::YieldOp parent");
     return success();
   }
 };
 

mlir/lib/Dialect/Linalg/ComprehensiveBufferize/TensorInterfaceImpl.cpp

 getTensorBufferizationState(BufferizationState &state) {
   return state.getDialectState<TensorBufferizationState>(
       tensor::TensorDialect::getDialectNamespace());
 }
 
 struct CastOpInterface
     : public BufferizableOpInterface::ExternalModel<CastOpInterface,
                                                     tensor::CastOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &,
+                              BufferizationState &) const {
     return false;
   }
 
-  bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  bool bufferizesToMemoryWrite(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return false;
   }
 
-  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  OpResult getAliasingOpResult(Operation *op, OpOperand &,
+                               BufferizationState &) const {
     return op->getResult(0);
   }
 
-  BufferRelation bufferRelation(Operation *op, OpResult opResult,
-                                const BufferizationAliasInfo &aliasInfo,
-                                BufferizationState &state) const {
+  BufferRelation bufferRelation(Operation *, OpResult,
+                                const BufferizationAliasInfo &,
+                                BufferizationState &) const {
     return BufferRelation::Equivalent;
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BufferizationState &state) const {
     auto castOp = cast<tensor::CastOp>(op);
 
     Value resultBuffer = state.getResultBuffer(castOp->getResult(0));
LogicalResult bufferize(Operation *op, OpBuilder &b,
     state.replaceOpWithNewOp<memref::CastOp>(b, op, memRefType, resultBuffer);
     return success();
   }
 };
 
 struct DimOpInterface
     : public BufferizableOpInterface::ExternalModel<DimOpInterface,
                                                     tensor::DimOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &,
+                              BufferizationState &) const {
     return true;
   }
 
-  bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  bool bufferizesToMemoryWrite(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return false;
   }
 
-  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  OpResult getAliasingOpResult(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return OpResult();
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BufferizationState &state) const {
     auto dimOp = cast<tensor::DimOp>(op);
     if (!dimOp.source().getType().isa<RankedTensorType>())
       return dimOp.emitError("unranked tensor not supported");
     Value v = state.lookupBuffer(dimOp.source());
     state.replaceOpWithNewOp<memref::DimOp>(b, op, v, dimOp.index());
     return success();
   }
 };
 
 struct ExtractSliceOpInterface
     : public BufferizableOpInterface::ExternalModel<ExtractSliceOpInterface,
                                                     tensor::ExtractSliceOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &,
+                              BufferizationState &) const {
     return false;
   }
 
-  bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  bool bufferizesToMemoryWrite(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return false;
   }
 
   OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+                               BufferizationState &) const {
     return &opOperand == &op->getOpOperand(0) /*source*/
                ? op->getResult(0)
                : OpResult();
   }
 
-  BufferRelation bufferRelation(Operation *op, OpResult opResult,
-                                const BufferizationAliasInfo &aliasInfo,
-                                BufferizationState &state) const {
+  BufferRelation bufferRelation(Operation *, OpResult,
+                                const BufferizationAliasInfo &,
+                                BufferizationState &) const {
     return BufferRelation::None;
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BufferizationState &state) const {
     auto extractSliceOp = cast<tensor::ExtractSliceOp>(op);
     Location loc = extractSliceOp.getLoc();
     Value srcMemref = state.lookupBuffer(extractSliceOp.source());
LogicalResult bufferize(Operation *op, OpBuilder &b,
     state.replaceOp(op, subView);
     return success();
   }
 };
 
 struct ExtractOpInterface
     : public BufferizableOpInterface::ExternalModel<ExtractOpInterface,
                                                     tensor::ExtractOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &,
+                              BufferizationState &) const {
     return true;
   }
 
-  bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  bool bufferizesToMemoryWrite(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return false;
   }
 
-  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  OpResult getAliasingOpResult(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return OpResult();
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BufferizationState &state) const {
     auto extractOp = cast<tensor::ExtractOp>(op);
     Value srcMemref = state.lookupBuffer(extractOp.tensor());
     state.replaceOpWithNewOp<memref::LoadOp>(b, op, srcMemref,
                                              extractOp.indices());
     return success();
   }
 };
 
 struct InsertOpInterface
     : public BufferizableOpInterface::ExternalModel<InsertOpInterface,
                                                     tensor::InsertOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &,
+                              BufferizationState &) const {
     return true;
   }
 
-  bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  bool bufferizesToMemoryWrite(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return true;
   }
 
   OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+                               BufferizationState &) const {
     assert(&opOperand == &op->getOpOperand(1) /*dest*/ &&
            "expected dest OpOperand");
     return op->getOpResult(0);
   }
 
-  SmallVector<OpOperand *>
-  getAliasingOpOperand(Operation *op, OpResult opResult,
-                       BufferizationState &state) const {
+  SmallVector<OpOperand *> getAliasingOpOperand(Operation *op, OpResult,
+                                                BufferizationState &) const {
     return {&op->getOpOperand(1) /*dest*/};
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BufferizationState &state) const {
     auto insertOp = cast<tensor::InsertOp>(op);
     Location loc = insertOp.getLoc();
     Value destMemref = state.getResultBuffer(insertOp->getOpResult(0));
     b.create<memref::StoreOp>(loc, insertOp.scalar(), destMemref,
                               insertOp.indices());
     state.replaceOp(op, destMemref);
     return success();
   }
 
-  BufferRelation bufferRelation(Operation *op, OpResult opResult,
-                                const BufferizationAliasInfo &aliasInfo,
-                                BufferizationState &state) const {
+  BufferRelation bufferRelation(Operation *, OpResult,
+                                const BufferizationAliasInfo &,
+                                BufferizationState &) const {
     return BufferRelation::Equivalent;
   }
 };
 
 /// Return true if the (ExtractSliceOp, InsertSliceOp) pair match (i.e.
 /// equivalent operand / result and same offset/sizes/strides specification).
 ///
 /// This is one particular type of relationship between ops on tensors that
static bool hasMatchingExtractSliceOp(const BufferizationAliasInfo &aliasInfo,
 
   return llvm::all_of(state.findValueInReverseUseDefChain(value, condition),
                       condition);
 }
 
 struct InsertSliceOpInterface
     : public BufferizableOpInterface::ExternalModel<InsertSliceOpInterface,
                                                     tensor::InsertSliceOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &,
+                              BufferizationState &) const {
     return true;
   }
 
   bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+                               BufferizationState &) const {
     return &opOperand == &op->getOpOperand(1) /*dest*/;
   }
 
   OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+                               BufferizationState &) const {
     return &opOperand == &op->getOpOperand(1) /*dest*/
                ? op->getResult(0)
                : OpResult();
   }
 
-  BufferRelation bufferRelation(Operation *op, OpResult opResult,
-                                const BufferizationAliasInfo &aliasInfo,
-                                BufferizationState &state) const {
+  BufferRelation bufferRelation(Operation *, OpResult,
+                                const BufferizationAliasInfo &,
+                                BufferizationState &) const {
     return BufferRelation::Equivalent;
   }
 
-  bool isNotConflicting(Operation *op, OpOperand *uRead,
+  bool isNotConflicting(Operation *, OpOperand *uRead,
                         OpOperand *uConflictingWrite, BufferizationState &state,
                         const BufferizationAliasInfo &aliasInfo) const {
     Operation *readingOp = uRead->getOwner();
     Operation *conflictingWritingOp = uConflictingWrite->getOwner();
 
     // Special rules for matching ExtractSliceOp/InsertSliceOp pairs. If
     // uRead is an InsertSliceOp...
     if (auto insertSliceOp = dyn_cast<InsertSliceOp>(readingOp)) {

 } // namespace tensor_ext
 } // namespace comprehensive_bufferize
 } // namespace linalg
 } // namespace mlir
 
 LogicalResult mlir::linalg::comprehensive_bufferize::tensor_ext::
     InplaceInsertSliceOpAnalysis::run(Operation *op, BufferizationState &state,
                                       BufferizationAliasInfo &aliasInfo,
-                                      SmallVector<Operation *> &newOps) {
+                                      SmallVector<Operation *> &) {
   auto &tensorState = getTensorBufferizationState(state);
   op->walk([&](InsertSliceOp insertSliceOp) {
     // A copy of the source buffer is needed if either:
     //   - The producer of `source` is not inplace. This is the case where a
     //     slice is computed out of place into the inplace full tensor.
     //   - The result is not inplace. This is the case where the whole tensor is
     //     cloned and the clone needs to be updated.
     if (isSourceEquivalentToAMatchingInplaceExtractSliceOp(aliasInfo,

mlir/lib/Dialect/Linalg/ComprehensiveBufferize/VectorInterfaceImpl.cpp

 namespace mlir {
 namespace linalg {
 namespace comprehensive_bufferize {
 namespace vector_ext {
 
 struct TransferReadOpInterface
     : public BufferizableOpInterface::ExternalModel<TransferReadOpInterface,
                                                     vector::TransferReadOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &opOperand,
+                              BufferizationState &) const {
     assert(opOperand.get().getType().isa<RankedTensorType>() &&
            "only tensor types expected");
     return true;
   }
 
-  bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  bool bufferizesToMemoryWrite(Operation *, OpOperand &opOperand,
+                               BufferizationState &) const {
     assert(opOperand.get().getType().isa<RankedTensorType>() &&
            "only tensor types expected");
     return false;
   }
 
-  OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  OpResult getAliasingOpResult(Operation *, OpOperand &,
+                               BufferizationState &) const {
     return OpResult();
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BufferizationState &state) const {
     auto readOp = cast<vector::TransferReadOp>(op);
     assert(readOp.getShapedType().isa<TensorType>() &&
            "only tensor types expected");
 
     // TransferReadOp always reads from the bufferized op.source().
     Value buffer = state.lookupBuffer(readOp.source());
     Value read = b.create<vector::TransferReadOp>(
         readOp.getLoc(), readOp.getVectorType(), buffer, readOp.indices(),
         readOp.permutation_map(), readOp.padding(), readOp.mask(),
         readOp.in_boundsAttr());
     state.replaceOp(op, read);
     return success();
   }
 };
 
 struct TransferWriteOpInterface
     : public BufferizableOpInterface::ExternalModel<TransferWriteOpInterface,
                                                     vector::TransferWriteOp> {
-  bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
-                              BufferizationState &state) const {
+  bool bufferizesToMemoryRead(Operation *, OpOperand &opOperand,
+                              BufferizationState &) const {
     assert(opOperand.get().getType().isa<TensorType>() &&
            "only tensor types expected");
     return true;
   }
 
-  bool bufferizesToMemoryWrite(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+  bool bufferizesToMemoryWrite(Operation *, OpOperand &opOperand,
+                               BufferizationState &) const {
     assert(opOperand.get().getType().isa<TensorType>() &&
            "only tensor types expected");
     return true;
   }
 
   OpResult getAliasingOpResult(Operation *op, OpOperand &opOperand,
-                               BufferizationState &state) const {
+                               BufferizationState &) const {
     assert(opOperand.get().getType().isa<TensorType>() &&
            "only tensor types expected");
     return op->getOpResult(0);
   }
 
-  BufferRelation bufferRelation(Operation *op, OpResult opResult,
-                                const BufferizationAliasInfo &aliasInfo,
-                                BufferizationState &state) const {
+  BufferRelation bufferRelation(Operation *, OpResult,
+                                const BufferizationAliasInfo &,
+                                BufferizationState &) const {
     return BufferRelation::Equivalent;
   }
 
   LogicalResult bufferize(Operation *op, OpBuilder &b,
                           BufferizationState &state) const {
     auto writeOp = cast<vector::TransferWriteOp>(op);
     assert(writeOp.getShapedType().isa<TensorType>() &&
            "only tensor types expected");

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

 
 namespace {
 
 struct LinalgInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
 
   // We don't have any special restrictions on what can be inlined into
   // destination regions (e.g. while/conditional bodies). Always allow it.
-  bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
-                       BlockAndValueMapping &valueMapping) const final {
+  bool isLegalToInline(Region *, Region *, bool,
+                       BlockAndValueMapping &) const final {
     return true;
   }
   // Operations in Linalg dialect are always legal to inline.
   bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
   // Handle the given inlined terminator by replacing it with a new operation

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

struct FunctionNonEntryBlockConversion : public ConversionPattern {
   FunctionNonEntryBlockConversion(MLIRContext *ctx, TypeConverter &converter,
                                   DenseSet<BlockArgument> blockArgsToDetensor)
       : ConversionPattern(converter, MatchTraitOpTypeTag(),
                           TypeID::get<OpTrait::FunctionLike>(), /*benefit=*/1,
                           ctx),
         blockArgsToDetensor(std::move(blockArgsToDetensor)) {}
 
   LogicalResult
-  matchAndRewrite(Operation *op, ArrayRef<Value> operands,
+  matchAndRewrite(Operation *op, ArrayRef<Value>,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.startRootUpdate(op);
     Region &region = function_like_impl::getFunctionBody(op);
     SmallVector<TypeConverter::SignatureConversion, 2> conversions;
 
     for (Block &block : llvm::drop_begin(region, 1)) {
       conversions.emplace_back(block.getNumArguments());
       TypeConverter::SignatureConversion &back = conversions.back();
DetensorizeTypeConverter() {
     addConversion([](TensorType tensorType) -> Type {
       if (canBeDetensored(tensorType))
         return tensorType.getElementType();
 
       return tensorType;
     });
 
     // A tensor value is detensoried by extracting its element(s).
-    addTargetMaterialization([](OpBuilder &builder, Type type,
-                                ValueRange inputs, Location loc) -> Value {
+    addTargetMaterialization([](OpBuilder &builder, Type, ValueRange inputs,
+                                Location loc) -> Value {
       return builder.create<tensor::ExtractOp>(loc, inputs[0], ValueRange{});
     });
 
     addSourceMaterialization(sourceMaterializationCallback);
     addArgumentMaterialization(sourceMaterializationCallback);
   }
 };
 

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

for (const auto &en : llvm::enumerate(producerMap.getResults())) {
     fusedLoopsAndRanges[posInProducerLoop] = getRangeFromOperandShape(
         b, consumerOpOperand.getOwner()->getLoc(), shapedOperand, en.index());
   }
   return fuse(b, producerOp, fusedLoopsAndRanges);
 }
 
 // Encode structural fusion safety preconditions.
 // Some of these will be lifted in the future with better analysis.
-static bool isStructurallyFusableProducer(LinalgOp producer, Value consumedView,
+static bool isStructurallyFusableProducer(LinalgOp producer,
                                           LinalgOp consumer) {
   assert(producer.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
   assert(consumer.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
   if (producer.getNumOutputs() != 1) {
     LLVM_DEBUG(llvm::dbgs() << "\nNot structurally fusable (multi-output)");
     return false;
bool mlir::linalg::isProducerLastWriteOfView(const LinalgDependenceGraph &graph,
                                              Value consumedView,
                                              LinalgOp producer) {
   assert(producer.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
   assert(consumer.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
   // Make some simple structural checks that alleviate the need for more
   // complex analyses.
-  if (!isStructurallyFusableProducer(producer, consumedView, consumer)) {
+  if (!isStructurallyFusableProducer(producer, consumer)) {
     LLVM_DEBUG(llvm::dbgs() << "\n***Not static last write due to structure:\t"
                             << *producer.getOperation());
     return false;
   }
   // Check for any interleaved write to consumedView.
   if (!graph.findCoveringWrites(producer, consumer, consumedView).empty()) {
     LLVM_DEBUG(llvm::dbgs() << "\n***Not fusable due to interleaved write:\t"
                             << *producer.getOperation());

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

llvm::TypeSwitch<Operation *>(loopOp)
                         parallelOp.getInductionVars().end());
         })
         .Case([&](scf::ForOp forOp) {
           allIvs.push_back(forOp.getInductionVar());
         })
         .Case([&](AffineForOp affineForOp) {
           allIvs.push_back(affineForOp.getInductionVar());
         })
-        .Default([&](Operation *op) { assert(false && "unexpected op"); });
+        .Default([&](Operation *) { assert(false && "unexpected op"); });
   }
   assert(linalgOp.getNumLoops() == allIvs.size() &&
          "expected the number of loops and induction variables to match");
   // Replace the index operations in the body of the innermost loop op.
   if (!loopOps.empty()) {
     LoopLikeOpInterface loopOp = loopOps.back();
     for (IndexOp indexOp :
          llvm::make_early_inc_range(loopOp.getLoopBody().getOps<IndexOp>()))
auto generateForLoopNestAndCloneBody = [&](OpBuilder &builder, Location loc,
       bvm.map(tiledLoop.getRegionInputArgs(), tiledLoop.inputs());
       bvm.map(tiledLoop.getRegionOutputArgs(), tiledLoop.outputs());
 
       // If not all dimensions of the tiled loop are parallel, an scf.for loop
       // nest is generated.
       if (!seqIVs.empty()) {
         scf::LoopNest nest =
             scf::buildLoopNest(builder, loc, seqLBs, seqUBs, seqSteps,
-                               [&](OpBuilder &builder, Location loc,
-                                   ValueRange ivs) { bvm.map(seqIVs, ivs); });
+                               [&](OpBuilder &, Location, ValueRange ivs) {
+                                 bvm.map(seqIVs, ivs);
+                               });
         builder.setInsertionPointToStart(nest.loops.back().getBody());
       }
       for (auto &op : tiledLoop.getBody()->without_terminator())
         builder.clone(op, bvm);
     };
 
     if (parIVs.empty())
       generateForLoopNestAndCloneBody(rewriter, loc, llvm::None);

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

 
 static llvm::Optional<vector::CombiningKind>
 getKindForOp(Operation *reductionOp) {
   if (!reductionOp)
     return llvm::None;
   return llvm::TypeSwitch<Operation *, llvm::Optional<vector::CombiningKind>>(
              reductionOp)
       .Case<arith::AddIOp, arith::AddFOp>(
-          [&](auto op) { return vector::CombiningKind::ADD; })
-      .Case<arith::AndIOp>([&](auto op) { return vector::CombiningKind::AND; })
-      .Case<arith::MaxSIOp>(
-          [&](auto op) { return vector::CombiningKind::MAXSI; })
-      .Case<arith::MaxFOp>([&](auto op) { return vector::CombiningKind::MAXF; })
-      .Case<arith::MinSIOp>(
-          [&](auto op) { return vector::CombiningKind::MINSI; })
-      .Case<arith::MinFOp>([&](auto op) { return vector::CombiningKind::MINF; })
+          [&](auto) { return vector::CombiningKind::ADD; })
+      .Case<arith::AndIOp>([&](auto) { return vector::CombiningKind::AND; })
+      .Case<arith::MaxSIOp>([&](auto) { return vector::CombiningKind::MAXSI; })
+      .Case<arith::MaxFOp>([&](auto) { return vector::CombiningKind::MAXF; })
+      .Case<arith::MinSIOp>([&](auto) { return vector::CombiningKind::MINSI; })
+      .Case<arith::MinFOp>([&](auto) { return vector::CombiningKind::MINF; })
       .Case<arith::MulIOp, arith::MulFOp>(
-          [&](auto op) { return vector::CombiningKind::MUL; })
-      .Case<arith::OrIOp>([&](auto op) { return vector::CombiningKind::OR; })
-      .Case<arith::XOrIOp>([&](auto op) { return vector::CombiningKind::XOR; })
-      .Default([&](auto op) { return llvm::None; });
+          [&](auto) { return vector::CombiningKind::MUL; })
+      .Case<arith::OrIOp>([&](auto) { return vector::CombiningKind::OR; })
+      .Case<arith::XOrIOp>([&](auto) { return vector::CombiningKind::XOR; })
+      .Default([&](auto) { return llvm::None; });
 }
 
 /// Check whether `outputOperand` is a reduction with a single combiner
 /// operation. Return the combiner operation of the reduction. Return
 /// nullptr otherwise. Multiple reduction operations would impose an
 /// ordering between reduction dimensions and is currently unsupported in
 /// Linalg. This limitation is motivated by the fact that e.g. min(max(X)) !=
 /// max(min(X))
CustomVectorizationHook vectorizeYield =
       [&](Operation *op,
           const BlockAndValueMapping &bvm) -> VectorizationResult {
     return vectorizeLinalgYield(b, op, bvm, linalgOp, newResults);
   };
   hooks.push_back(vectorizeYield);
 
   // 4b. Register CustomVectorizationHook for indexOp.
   CustomVectorizationHook vectorizeIndex =
-      [&](Operation *op,
-          const BlockAndValueMapping &bvm) -> VectorizationResult {
+      [&](Operation *op, const BlockAndValueMapping &) -> VectorizationResult {
     return vectorizeLinalgIndex(b, op, linalgOp);
   };
   hooks.push_back(vectorizeIndex);
 
   // 5. Iteratively call `vectorizeOneOp` to each op in the slice.
   for (Operation &op : block->getOperations()) {
     VectorizationResult result = vectorizeOneOp(b, linalgOp, &op, bvm, hooks);
     if (result.status == VectorizationStatus::Failure) {
FailureOr<Operation *> conv() {
 
     auto linearIndex = [&](int64_t kw, int64_t w) {
       return kw * (wSize / wSizeStep) + w;
     };
 
     // Compute contraction: O{n, w, f} += I{n, sw * w + dw * kw, c} * F{c, f}
     for (int64_t kw = 0; kw < kwSize; ++kw) {
       for (int64_t w = 0; w < wSize; w += wSizeStep) {
-        resVals[w] = conv1dSliceAsContraction(
-            builder, loc, lhsVals[linearIndex(kw, w)], rhsVals[kw], resVals[w]);
+        resVals[w] = conv1dSliceAsContraction(loc, lhsVals[linearIndex(kw, w)],
+                                              rhsVals[kw], resVals[w]);
       }
     }
 
     // Write back res slice: {n, wSizeStep, f} @ [0, w, 0].
     // This does not depend on kw.
     for (int64_t w = 0; w < wSize; w += wSizeStep) {
       res = builder.create<vector::InsertStridedSliceOp>(
           loc, resVals[w], res,
           /*offsets=*/ArrayRef<int64_t>{0, w, 0},
           /*strides=*/ArrayRef<int64_t>{1, 1, 1});
     }
     //===------------------------------------------------------------------===//
     // End vector-only rewrite part
     //===------------------------------------------------------------------===//
 
     // Write back res slice of size {n, w, f} @ [0, 0, 0].
     return builder
         .create<vector::TransferWriteOp>(loc, res, resShaped,
                                          ValueRange{zero, zero, zero})
         .getOperation();
   }
 
   // Create a contraction: lhs{n, w, c} * rhs{c, f} -> res{n, w, f}
-  Value conv1dSliceAsContraction(OpBuilder &b, Location loc, Value lhs,
-                                 Value rhs, Value res) {
+  Value conv1dSliceAsContraction(Location loc, Value lhs, Value rhs,
+                                 Value res) {
     StringRef par = Par().strRef, red = Red().strRef;
     AffineExpr n, w, f, c;
     bindDims(ctx, n, w, f, c);
     return builder.create<vector::ContractionOp>(
         loc, lhs, rhs, res,
         /*indexingMaps=*/MapList{{n, w, c}, {c, f}, {n, w, f}},
         /*iteratorTypes=*/ArrayRef<StringRef>{par, par, par, red});
   }

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

 template <>
 void GenerateLoopNest<scf::ForOp>::doit(
     OpBuilder &b, Location loc, ArrayRef<Range> loopRanges, LinalgOp linalgOp,
     ArrayRef<Attribute> iteratorTypes,
     function_ref<scf::ValueVector(OpBuilder &, Location, ValueRange,
                                   ValueRange)>
         bodyBuilderFn,
     Optional<LinalgLoopDistributionOptions> distributionOptions,
-    ArrayRef<StringRef> distributionTypes) {
+    ArrayRef<StringRef>) {
   SmallVector<Value> iterArgInitValues = linalgOp.getOutputTensorOperands();
   // Create procInfo so it dominates loops, if appropriate.
   SmallVector<ProcInfo, 4> procInfo;
   SmallVector<DistributionMethod, 0> distributionMethod;
   if (distributionOptions.hasValue()) {
     // Collect loop ranges for parallel dimensions.
     SmallVector<Range, 2> parallelLoopRanges;
     for (const auto &iteratorType : enumerate(iteratorTypes))
if (std::get<2>(it) == DistributionMethod::Cyclic)
       mapLoopToProcessorIds(std::get<0>(it), std::get<1>(it).procId,
                             std::get<1>(it).nprocs);
 }
 
 /// Specialization to build affine "for" nest.
 template <>
 void GenerateLoopNest<AffineForOp>::doit(
     OpBuilder &b, Location loc, ArrayRef<Range> loopRanges, LinalgOp linalgOp,
-    ArrayRef<Attribute> iteratorTypes,
+    ArrayRef<Attribute>,
     function_ref<scf::ValueVector(OpBuilder &, Location, ValueRange,
                                   ValueRange)>
         bodyBuilderFn,
     Optional<LinalgLoopDistributionOptions>, ArrayRef<StringRef>) {
   SmallVector<Value> iterArgInitValues = linalgOp.getOutputTensorOperands();
   assert(iterArgInitValues.empty() && "unexpected AffineForOp init values");
   SmallVector<Value, 4> lbs, ubs, steps;
   unpackRanges(loopRanges, lbs, ubs, steps);

 /// Specialization to build an linalg.tiled_loop
 template <>
 void GenerateLoopNest<TiledLoopOp>::doit(
     OpBuilder &b, Location loc, ArrayRef<Range> loopRanges, LinalgOp linalgOp,
     ArrayRef<Attribute> iteratorTypes,
     function_ref<scf::ValueVector(OpBuilder &, Location, ValueRange,
                                   ValueRange)>
         bodyBuilderFn,
-    Optional<LinalgLoopDistributionOptions> distributionOptions,
+    Optional<LinalgLoopDistributionOptions>,
     ArrayRef<StringRef> distributionTypes) {
   SmallVector<ProcInfo, 2> procInfo;
   SmallVector<Value, 4> lbs, ubs, steps;
   unpackRanges(loopRanges, lbs, ubs, steps);
 
   auto wrappedBuilderFn = [&](OpBuilder &nestedBuilder, Location nestedLoc,
                               ValueRange ivs, ValueRange inputs,
                               ValueRange outputs) {
auto tiledLoop =
       b.create<TiledLoopOp>(loc, lbs, ubs, steps, inputOperands, outputOperands,
                             b.getArrayAttr(iteratorTypes), wrappedBuilderFn);
   if (!distributionTypes.empty())
     tiledLoop.setDistributionTypes(b, distributionTypes);
 }
 
 /// Update the `lb`, `ub` and `step` to get per processor `lb`, `ub` and `step`.
 void updateBoundsForCyclicDistribution(OpBuilder &b, Location loc, Value procId,
-                                       Value nprocs, Value &lb, Value &ub,
+                                       Value nprocs, Value &lb, Value &,
                                        Value &step) {
   AffineExpr d0, d1;
   bindDims(b.getContext(), d0, d1);
   AffineExpr s0 = getAffineSymbolExpr(0, b.getContext());
   lb = makeComposedAffineApply(b, loc, d0 + d1 * s0, {lb, procId, step});
   step = makeComposedAffineApply(b, loc, d0 * s0, {nprocs, step});
 }
 

 template <>
 void GenerateLoopNest<scf::ParallelOp>::doit(
     OpBuilder &b, Location loc, ArrayRef<Range> loopRanges, LinalgOp linalgOp,
     ArrayRef<Attribute> iteratorTypes,
     function_ref<scf::ValueVector(OpBuilder &, Location, ValueRange,
                                   ValueRange)>
         bodyBuilderFn,
     Optional<LinalgLoopDistributionOptions> distributionOptions,
-    ArrayRef<StringRef> distributionTypes) {
+    ArrayRef<StringRef>) {
   SmallVector<Value> iterArgInitValues = linalgOp.getOutputTensorOperands();
   assert(iterArgInitValues.empty() && "unexpected ParallelOp init values");
   // This function may be passed more iterator types than ranges.
   assert(iteratorTypes.size() >= loopRanges.size() &&
          "expected iterator type for all ranges");
   iteratorTypes = iteratorTypes.take_front(loopRanges.size());
   SmallVector<Value, 8> lbsStorage, ubsStorage, stepsStorage, ivs;
   unsigned numLoops = iteratorTypes.size();
offsets.push_back(
         isTiled ? ivs[idxIvs++]
                 : b.create<arith::ConstantIndexOp>(loc, 0).getResult());
     LLVM_DEBUG(llvm::dbgs()
                << "computeTileOffsets: " << offsets.back() << "\n");
   }
   return offsets;
 }
 
-SmallVector<Value> computeTileSizes(OpBuilder &b, Location loc, ValueRange ivs,
+SmallVector<Value> computeTileSizes(OpBuilder &b, Location loc, ValueRange,
                                     ValueRange tileSizes,
                                     ArrayRef<Value> sizeBounds) {
   SmallVector<Value> sizes;
   for (unsigned idx = 0, e = tileSizes.size(); idx < e; ++idx) {
     bool isTiled = !isZero(tileSizes[idx]);
     // Before composing, we need to make range a closed interval.
     Value size = isTiled ? tileSizes[idx] : sizeBounds[idx];
     AffineExpr d0 = getAffineDimExpr(0, b.getContext());

mlir/lib/Dialect/MemRef/IR/MemRefDialect.cpp

 
 //===----------------------------------------------------------------------===//
 // MemRefDialect Dialect Interfaces
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct MemRefInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
-  bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
-                       BlockAndValueMapping &valueMapping) const final {
+  bool isLegalToInline(Region *, Region *, bool,
+                       BlockAndValueMapping &) const final {
     return true;
   }
-  bool isLegalToInline(Operation *, Region *, bool wouldBeCloned,
+  bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 };
 } // namespace
 
 void mlir::memref::MemRefDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/MemRef/IR/MemRefOps.cpp.inc"
       >();
   addInterfaces<MemRefInlinerInterface>();
 }

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

 static LogicalResult verify(AllocaScopeOp op) {
   if (failed(RegionBranchOpInterface::verifyTypes(op)))
     return failure();
 
   return success();
 }
 
 void AllocaScopeOp::getSuccessorRegions(
-    Optional<unsigned> index, ArrayRef<Attribute> operands,
+    Optional<unsigned> index, ArrayRef<Attribute>,
     SmallVectorImpl<RegionSuccessor> &regions) {
   if (index.hasValue()) {
     regions.push_back(RegionSuccessor(getResults()));
     return;
   }
 
   regions.push_back(RegionSuccessor(&bodyRegion()));
 }
if (aT && bT) {
     auto aMemSpace = (aT) ? aT.getMemorySpace() : uaT.getMemorySpace();
     auto bMemSpace = (bT) ? bT.getMemorySpace() : ubT.getMemorySpace();
     return aMemSpace == bMemSpace;
   }
 
   return false;
 }
 
-OpFoldResult CastOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult CastOp::fold(ArrayRef<Attribute>) {
   return succeeded(foldMemRefCast(*this)) ? getResult() : Value();
 }
 
 //===----------------------------------------------------------------------===//
 // DeallocOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult DeallocOp::fold(ArrayRef<Attribute> cstOperands,
-                              SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult DeallocOp::fold(ArrayRef<Attribute>,
+                              SmallVectorImpl<OpFoldResult> &) {
   /// dealloc(memrefcast) -> dealloc
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // DimOp
 //===----------------------------------------------------------------------===//
 
void DimOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                         MLIRContext *context) {
   results.add<DimOfMemRefReshape>(context);
 }
 
 // ---------------------------------------------------------------------------
 // DmaStartOp
 // ---------------------------------------------------------------------------
 
-void DmaStartOp::build(OpBuilder &builder, OperationState &result,
-                       Value srcMemRef, ValueRange srcIndices, Value destMemRef,
+void DmaStartOp::build(OpBuilder &, OperationState &result, Value srcMemRef,
+                       ValueRange srcIndices, Value destMemRef,
                        ValueRange destIndices, Value numElements,
                        Value tagMemRef, ValueRange tagIndices, Value stride,
                        Value elementsPerStride) {
   result.addOperands(srcMemRef);
   result.addOperands(srcIndices);
   result.addOperands(destMemRef);
   result.addOperands(destIndices);
   result.addOperands({numElements, tagMemRef});
if (!op.getStride().getType().isIndex() ||
         !op.getNumElementsPerStride().getType().isIndex())
       return op.emitOpError(
           "expected stride and num elements per stride to be of type index");
   }
 
   return success();
 }
 
-LogicalResult DmaStartOp::fold(ArrayRef<Attribute> cstOperands,
-                               SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult DmaStartOp::fold(ArrayRef<Attribute>,
+                               SmallVectorImpl<OpFoldResult> &) {
   /// dma_start(memrefcast) -> dma_start
   return foldMemRefCast(*this);
 }
 
 // ---------------------------------------------------------------------------
 // DmaWaitOp
 // ---------------------------------------------------------------------------
 
-LogicalResult DmaWaitOp::fold(ArrayRef<Attribute> cstOperands,
-                              SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult DmaWaitOp::fold(ArrayRef<Attribute>,
+                              SmallVectorImpl<OpFoldResult> &) {
   /// dma_wait(memrefcast) -> dma_wait
   return foldMemRefCast(*this);
 }
 
 static LogicalResult verify(DmaWaitOp op) {
   // Check that the number of tag indices matches the tagMemRef rank.
   unsigned numTagIndices = op.tagIndices().size();
   unsigned tagMemRefRank = op.getTagMemRefRank();

 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(LoadOp op) {
   if (op.getNumOperands() != 1 + op.getMemRefType().getRank())
     return op.emitOpError("incorrect number of indices for load");
   return success();
 }
 
-OpFoldResult LoadOp::fold(ArrayRef<Attribute> cstOperands) {
+OpFoldResult LoadOp::fold(ArrayRef<Attribute>) {
   /// load(memrefcast) -> load
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
   return OpFoldResult();
 }
 
 //===----------------------------------------------------------------------===//
 // PrefetchOp

 
 static LogicalResult verify(PrefetchOp op) {
   if (op.getNumOperands() != 1 + op.getMemRefType().getRank())
     return op.emitOpError("too few indices");
 
   return success();
 }
 
-LogicalResult PrefetchOp::fold(ArrayRef<Attribute> cstOperands,
-                               SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult PrefetchOp::fold(ArrayRef<Attribute>,
+                               SmallVectorImpl<OpFoldResult> &) {
   // prefetch(memrefcast) -> prefetch
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult RankOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult RankOp::fold(ArrayRef<Attribute>) {
   // Constant fold rank when the rank of the operand is known.
   auto type = getOperand().getType();
   auto shapedType = type.dyn_cast<ShapedType>();
   if (shapedType && shapedType.hasRank())
     return IntegerAttr::get(IndexType::get(getContext()), shapedType.getRank());
   return IntegerAttr();
 }
 

 
 static LogicalResult verify(StoreOp op) {
   if (op.getNumOperands() != 2 + op.getMemRefType().getRank())
     return op.emitOpError("store index operand count not equal to memref rank");
 
   return success();
 }
 
-LogicalResult StoreOp::fold(ArrayRef<Attribute> cstOperands,
-                            SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult StoreOp::fold(ArrayRef<Attribute>,
+                            SmallVectorImpl<OpFoldResult> &) {
   /// store(memrefcast) -> store
   return foldMemRefCast(*this, getValueToStore());
 }
 
 //===----------------------------------------------------------------------===//
 // SubViewOp
 //===----------------------------------------------------------------------===//
 
build(b, result, resultType, source, offsetValues, sizeValues, strideValues,
         attrs);
 }
 
 // Build a SubViewOp with dynamic entries and custom result type. If the type
 // passed is nullptr, it is inferred.
 void SubViewOp::build(OpBuilder &b, OperationState &result,
                       MemRefType resultType, Value source, ValueRange offsets,
                       ValueRange sizes, ValueRange strides,
-                      ArrayRef<NamedAttribute> attrs) {
+                      ArrayRef<NamedAttribute>) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, resultType, source, offsetValues, sizeValues, strideValues);
 }

 void SubViewOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                             MLIRContext *context) {
   results
       .add<OpWithOffsetSizesAndStridesConstantArgumentFolder<
                SubViewOp, SubViewReturnTypeCanonicalizer, SubViewCanonicalizer>,
            SubViewOpMemRefCastFolder, TrivialSubViewOpFolder>(context);
 }
 
-OpFoldResult SubViewOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult SubViewOp::fold(ArrayRef<Attribute>) {
   auto resultShapedType = getResult().getType().cast<ShapedType>();
   auto sourceShapedType = source().getType().cast<ShapedType>();
 
   if (resultShapedType.hasStaticShape() &&
       resultShapedType == sourceShapedType) {
     return getViewSource();
   }
 
if (!op.value().getType().isa<IntegerType>())
              << "' expects an integer type";
     break;
   default:
     break;
   }
   return success();
 }
 
-OpFoldResult AtomicRMWOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult AtomicRMWOp::fold(ArrayRef<Attribute>) {
   /// atomicrmw(memrefcast) -> atomicrmw
   if (succeeded(foldMemRefCast(*this, value())))
     return getResult();
   return OpFoldResult();
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/MemRef/IR/MemRefOps.cpp.inc"

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>) {
   // 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,
                       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(
     function_ref<InFlightDiagnostic()> emitError, unsigned flags,
     Type storageType, Type expressedType, double scale, int64_t zeroPoint,
     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,
+LogicalResult
+UniformQuantizedType::verify(function_ref<InFlightDiagnostic()> emitError,
+                             unsigned flags, Type storageType,
+                             Type expressedType, double scale, int64_t,
                              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.
   if (!expressedType)
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,
-    int64_t storageTypeMin, int64_t storageTypeMax) {
+    ArrayRef<int64_t> zeroPoints, int32_t, 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.
   if (!expressedType)

mlir/lib/Dialect/SCF/SCF.cpp

 // SCFDialect Dialect Interfaces
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct SCFInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
   // We don't have any special restrictions on what can be inlined into
   // destination regions (e.g. while/conditional bodies). Always allow it.
-  bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
-                       BlockAndValueMapping &valueMapping) const final {
+  bool isLegalToInline(Region *, Region *, bool,
+                       BlockAndValueMapping &) const final {
     return true;
   }
   // Operations in scf dialect are always legal to inline since they are
   // pure.
   bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
void ExecuteRegionOp::getCanonicalizationPatterns(RewritePatternSet &results,
   results.add<SingleBlockExecuteInliner, MultiBlockExecuteInliner>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ConditionOp
 //===----------------------------------------------------------------------===//
 
 MutableOperandRange
-ConditionOp::getMutableSuccessorOperands(Optional<unsigned> index) {
+ConditionOp::getMutableSuccessorOperands(Optional<unsigned>) {
   // Pass all operands except the condition to the successor region.
   return getArgsMutable();
 }
 
 //===----------------------------------------------------------------------===//
 // ForOp
 //===----------------------------------------------------------------------===//
 
OperandRange ForOp::getSuccessorEntryOperands(unsigned index) {
   return getInitArgs();
 }
 
 /// Given the region at `index`, or the parent operation if `index` is None,
 /// return the successor regions. These are the regions that may be selected
 /// during the flow of control. `operands` is a set of optional attributes that
 /// correspond to a constant value for each operand, or null if that operand is
 /// not a constant.
-void ForOp::getSuccessorRegions(Optional<unsigned> index,
-                                ArrayRef<Attribute> operands,
+void ForOp::getSuccessorRegions(Optional<unsigned> index, ArrayRef<Attribute>,
                                 SmallVectorImpl<RegionSuccessor> &regions) {
   // If the predecessor is the ForOp, branch into the body using the iterator
   // arguments.
   if (!index.hasValue()) {
     regions.push_back(RegionSuccessor(&getLoopBody(), getRegionIterArgs()));
     return;
   }
 
LoopNest mlir::scf::buildLoopNest(
   SmallVector<Value, 4> ivs;
   loops.reserve(lbs.size());
   ivs.reserve(lbs.size());
   ValueRange currentIterArgs = iterArgs;
   Location currentLoc = loc;
   for (unsigned i = 0, e = lbs.size(); i < e; ++i) {
     auto loop = builder.create<scf::ForOp>(
         currentLoc, lbs[i], ubs[i], steps[i], currentIterArgs,
-        [&](OpBuilder &nestedBuilder, Location nestedLoc, Value iv,
-            ValueRange args) {
+        [&](OpBuilder &, Location nestedLoc, Value iv, ValueRange args) {
           ivs.push_back(iv);
           // It is safe to store ValueRange args because it points to block
           // arguments of a loop operation that we also own.
           currentIterArgs = args;
           currentLoc = nestedLoc;
         });
     // Set the builder to point to the body of the newly created loop. We don't
     // do this in the callback because the builder is reset when the callback

mlir/lib/Dialect/SCF/Transforms/LoopCanonicalization.cpp

value =
         llvm::TypeSwitch<Operation *, Value>(opResult.getOwner())
             .template Case<InsertSliceOp>(
                 [&](InsertSliceOp op) { return op.dest(); })
             .template Case<ForOp>([&](ForOp forOp) {
               return isShapePreserving(forOp, opResult.getResultNumber())
                          ? forOp.getIterOperands()[opResult.getResultNumber()]
                          : Value();
             })
-            .Default([&](auto op) { return Value(); });
+            .Default([&](auto) { return Value(); });
   }
   return false;
 }
 
 namespace {
 /// Fold dim ops of iter_args to dim ops of their respective init args. E.g.:
 ///
 /// ```

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

 
 Type PointerType::getPointeeType() const { return getImpl()->pointeeType; }
 
 StorageClass PointerType::getStorageClass() const {
   return getImpl()->storageClass;
 }
 
 void PointerType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                                Optional<StorageClass> storage) {
+                                Optional<StorageClass>) {
   // Use this pointer type's storage class because this pointer indicates we are
   // using the pointee type in that specific storage class.
   getPointeeType().cast<SPIRVType>().getExtensions(extensions,
                                                    getStorageClass());
 
   if (auto scExts = spirv::getExtensions(getStorageClass()))
     extensions.push_back(*scExts);
 }
 
 void PointerType::getCapabilities(
-    SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    SPIRVType::CapabilityArrayRefVector &capabilities, Optional<StorageClass>) {
   // Use this pointer type's storage class because this pointer indicates we are
   // using the pointee type in that specific storage class.
   getPointeeType().cast<SPIRVType>().getCapabilities(capabilities,
                                                      getStorageClass());
 
   if (auto scCaps = spirv::getCapabilities(getStorageClass()))
     capabilities.push_back(*scCaps);
 }

mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp

 /// Pass to implement the ABI information specified as attributes.
 class LowerABIAttributesPass final
     : public SPIRVLowerABIAttributesBase<LowerABIAttributesPass> {
   void runOnOperation() override;
 };
 } // namespace
 
 LogicalResult ProcessInterfaceVarABI::matchAndRewrite(
-    spirv::FuncOp funcOp, OpAdaptor adaptor,
+    spirv::FuncOp funcOp, OpAdaptor,
     ConversionPatternRewriter &rewriter) const {
   if (!funcOp->getAttrOfType<spirv::EntryPointABIAttr>(
           spirv::getEntryPointABIAttrName())) {
     // TODO: Non-entry point functions are not handled.
     return failure();
   }
   TypeConverter::SignatureConversion signatureConverter(
       funcOp.getType().getNumInputs());

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

public:
 
   LogicalResult
   matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult
-FuncOpConversion::matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor,
+FuncOpConversion::matchAndRewrite(FuncOp funcOp, OpAdaptor,
                                   ConversionPatternRewriter &rewriter) const {
   auto fnType = funcOp.getType();
   if (fnType.getNumResults() > 1)
     return failure();
 
   TypeConverter::SignatureConversion signatureConverter(fnType.getNumInputs());
   for (const auto &argType : enumerate(fnType.getInputs())) {
     auto convertedType = getTypeConverter()->convertType(argType.value());

 
 //===----------------------------------------------------------------------===//
 // Push constant storage
 //===----------------------------------------------------------------------===//
 
 /// Returns the pointer type for the push constant storage containing
 /// `elementCount` 32-bit integer values.
 static spirv::PointerType getPushConstantStorageType(unsigned elementCount,
-                                                     Builder &builder,
                                                      Type indexType) {
   auto arrayType = spirv::ArrayType::get(indexType, elementCount,
                                          /*stride=*/4);
   auto structType = spirv::StructType::get({arrayType}, /*offsetInfo=*/0);
   return spirv::PointerType::get(structType, spirv::StorageClass::PushConstant);
 }
 
 /// Returns the push constant varible containing `elementCount` 32-bit integer

 static spirv::GlobalVariableOp
 getOrInsertPushConstantVariable(Location loc, Block &block,
                                 unsigned elementCount, OpBuilder &b,
                                 Type indexType) {
   if (auto varOp = getPushConstantVariable(block, elementCount))
     return varOp;
 
   auto builder = OpBuilder::atBlockBegin(&block, b.getListener());
-  auto type = getPushConstantStorageType(elementCount, builder, indexType);
+  auto type = getPushConstantStorageType(elementCount, indexType);
   const char *name = "__push_constant_var__";
   return builder.create<spirv::GlobalVariableOp>(loc, type, name,
                                                  /*initializer=*/nullptr);
 }
 
 Value spirv::getPushConstantValue(Operation *op, unsigned elementCount,
                                   unsigned offset, Type integerType,
                                   OpBuilder &builder) {

mlir/lib/Dialect/Shape/IR/Shape.cpp

 
 namespace {
 /// This class defines the interface for inlining shape dialect ops.
 struct ShapeInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
 
   // Returns true if the given region 'src' can be inlined into the region
   // 'dest' that is attached to an operation registered to the current dialect.
-  bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
+  bool isLegalToInline(Region *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 
   // Returns true if the given operation 'op', that is registered to this
   // dialect, can be inlined into the region 'dest' that is attached to an
   // operation registered to the current dialect.
-  bool isLegalToInline(Operation *op, Region *dest, bool wouldBeCloned,
+  bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 };
 } // namespace
 
 void ShapeDialect::initialize() {
   addOperations<

 
 void AssumingOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                              MLIRContext *context) {
   patterns.add<AssumingOpRemoveUnusedResults, AssumingWithTrue>(context);
 }
 
 // See RegionBranchOpInterface in Interfaces/ControlFlowInterfaces.td
 void AssumingOp::getSuccessorRegions(
-    Optional<unsigned> index, ArrayRef<Attribute> operands,
+    Optional<unsigned> index, ArrayRef<Attribute>,
     SmallVectorImpl<RegionSuccessor> &regions) {
   // AssumingOp has unconditional control flow into the region and back to the
   // parent, so return the correct RegionSuccessor purely based on the index
   // being None or 0.
   if (index.hasValue()) {
     regions.push_back(RegionSuccessor(getResults()));
     return;
   }
void AssumingOp::build(
   result.addTypes(assumingTypes);
 }
 
 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult mlir::shape::AddOp::inferReturnTypes(
-    MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *context, Optional<Location>, ValueRange operands,
+    DictionaryAttr, RegionRange, SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<SizeType>() ||
       operands[1].getType().isa<SizeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 

 OpFoldResult ConstShapeOp::fold(ArrayRef<Attribute>) { return getShapeAttr(); }
 
 void ConstShapeOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                MLIRContext *context) {
   patterns.add<TensorCastConstShape>(context);
 }
 
 LogicalResult mlir::shape::ConstShapeOp::inferReturnTypes(
-    MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
+    MLIRContext *context, Optional<Location> location, ValueRange,
+    DictionaryAttr attributes, RegionRange,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   Builder b(context);
   auto shape = attributes.getAs<DenseIntElementsAttr>("shape");
   if (!shape)
     return emitOptionalError(location, "missing shape attribute");
   inferredReturnTypes.assign({RankedTensorType::get(
       {static_cast<int64_t>(shape.size())}, b.getIndexType())});
   return success();
if (quotient.isNegative() && !remainder.isNullValue()) {
     quotient -= 1;
   }
 
   Type indexTy = IndexType::get(getContext());
   return IntegerAttr::get(indexTy, quotient);
 }
 
 LogicalResult mlir::shape::DivOp::inferReturnTypes(
-    MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *context, Optional<Location>, ValueRange operands,
+    DictionaryAttr, RegionRange, SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<SizeType>() ||
       operands[1].getType().isa<SizeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
void GetExtentOp::build(OpBuilder &builder, OperationState &result, Value shape,
   } else {
     Value dim =
         builder.create<arith::ConstantOp>(loc, builder.getIndexType(), dimAttr);
     build(builder, result, builder.getIndexType(), shape, dim);
   }
 }
 
 LogicalResult mlir::shape::GetExtentOp::inferReturnTypes(
-    MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *context, Optional<Location>, ValueRange, DictionaryAttr,
+    RegionRange, SmallVectorImpl<Type> &inferredReturnTypes) {
   inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::GetExtentOp::isCompatibleReturnTypes(TypeRange l,
                                                        TypeRange r) {
   // SizeType is compatible with IndexType.
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
OpFoldResult IsBroadcastableOp::fold(ArrayRef<Attribute> operands) {
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // MeetOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult mlir::shape::MeetOp::inferReturnTypes(
-    MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *, Optional<Location>, ValueRange operands, DictionaryAttr,
+    RegionRange, SmallVectorImpl<Type> &inferredReturnTypes) {
   inferredReturnTypes.assign({operands[0].getType()});
   return success();
 }
 
 bool mlir::shape::MeetOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;
   if (l == r)

 } // namespace
 
 void shape::RankOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                 MLIRContext *context) {
   patterns.add<RankShapeOfCanonicalizationPattern>(context);
 }
 
 LogicalResult mlir::shape::RankOp::inferReturnTypes(
-    MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *context, Optional<Location>, ValueRange operands,
+    DictionaryAttr, RegionRange, SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<ShapeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::RankOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
OpFoldResult NumElementsOp::fold(ArrayRef<Attribute> operands) {
   APInt product(64, 1);
   for (auto value : shape.cast<DenseIntElementsAttr>())
     product *= value;
   Builder builder(getContext());
   return builder.getIndexAttr(product.getLimitedValue());
 }
 
 LogicalResult mlir::shape::NumElementsOp::inferReturnTypes(
-    MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *context, Optional<Location>, ValueRange operands,
+    DictionaryAttr, RegionRange, SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<ShapeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 
 bool mlir::shape::NumElementsOp::isCompatibleReturnTypes(TypeRange l,
                                                          TypeRange r) {
   // SizeType is compatible with IndexType.
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
 }
 
 //===----------------------------------------------------------------------===//
 // MaxOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult MaxOp::fold(llvm::ArrayRef<mlir::Attribute> operands) {
+OpFoldResult MaxOp::fold(llvm::ArrayRef<mlir::Attribute>) {
   // If operands are equal, just propagate one.
   if (getLhs() == getRhs())
     return getLhs();
   return nullptr;
 }
 
 LogicalResult mlir::shape::MaxOp::inferReturnTypes(
-    MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *context, Optional<Location>, ValueRange operands,
+    DictionaryAttr, RegionRange, SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType() == operands[1].getType())
     inferredReturnTypes.assign({operands[0].getType()});
   else
     inferredReturnTypes.assign({SizeType::get(context)});
   return success();
 }
 
 bool mlir::shape::MaxOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   if (l.size() != 1 || r.size() != 1)
     return false;
   if (l.front().isa<ShapeType>() && r.front().isa<ShapeType>())
     return true;
   if (l.front().isa<SizeType>() && r.front().isa<SizeType>())
     return true;
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // MinOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult MinOp::fold(llvm::ArrayRef<mlir::Attribute> operands) {
+OpFoldResult MinOp::fold(llvm::ArrayRef<mlir::Attribute>) {
   // If operands are equal, just propagate one.
   if (getLhs() == getRhs())
     return getLhs();
   return nullptr;
 }
 
 LogicalResult mlir::shape::MinOp::inferReturnTypes(
-    MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *context, Optional<Location>, ValueRange operands,
+    DictionaryAttr, RegionRange, SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType() == operands[1].getType())
     inferredReturnTypes.assign({operands[0].getType()});
   else
     inferredReturnTypes.assign({SizeType::get(context)});
   return success();
 }
 
 bool mlir::shape::MinOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
OpFoldResult MulOp::fold(ArrayRef<Attribute> operands) {
   if (!rhs)
     return nullptr;
   APInt folded = lhs.getValue() * rhs.getValue();
   Type indexTy = IndexType::get(getContext());
   return IntegerAttr::get(indexTy, folded);
 }
 
 LogicalResult mlir::shape::MulOp::inferReturnTypes(
-    MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *context, Optional<Location>, ValueRange operands,
+    DictionaryAttr, RegionRange, SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<SizeType>() ||
       operands[1].getType().isa<SizeType>())
     inferredReturnTypes.assign({SizeType::get(context)});
   else
     inferredReturnTypes.assign({IndexType::get(context)});
   return success();
 }
 

 
 void ShapeOfOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                             MLIRContext *context) {
   patterns.add<ShapeOfCastExtentTensor, ShapeOfWithTensor,
                ExtractFromShapeOfExtentTensor>(context);
 }
 
 LogicalResult mlir::shape::ShapeOfOp::inferReturnTypes(
-    MLIRContext *context, Optional<Location> location, ValueRange operands,
-    DictionaryAttr attributes, RegionRange regions,
-    SmallVectorImpl<Type> &inferredReturnTypes) {
+    MLIRContext *context, Optional<Location>, ValueRange operands,
+    DictionaryAttr, RegionRange, SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType().isa<ValueShapeType>())
     inferredReturnTypes.assign({ShapeType::get(context)});
   else {
     auto shapedTy = operands[0].getType().cast<ShapedType>();
     int64_t rank =
         shapedTy.hasRank() ? shapedTy.getRank() : ShapedType::kDynamicSize;
     Type indexTy = IndexType::get(context);
     Type extentTensorTy = RankedTensorType::get({rank}, indexTy);

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

 using namespace mlir::shape;
 
 namespace {
 class ConvertAssumingOpTypes : public OpConversionPattern<AssumingOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-  matchAndRewrite(AssumingOp op, OpAdaptor adaptor,
+  matchAndRewrite(AssumingOp op, OpAdaptor,
                   ConversionPatternRewriter &rewriter) const final {
     SmallVector<Type, 2> newResultTypes;
     newResultTypes.reserve(op.getNumResults());
     for (auto result : op.getResults()) {
       auto originalType = result.getType();
       Type convertedType = getTypeConverter()->convertType(originalType);
       newResultTypes.push_back(convertedType);
     }

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

static bool acceptBitWidth(unsigned bitWidth) {
   case 32:
   case 64:
     return true;
   default:
     return false;
   }
 }
 
-Attribute SparseTensorEncodingAttr::parse(AsmParser &parser, Type type) {
+Attribute SparseTensorEncodingAttr::parse(AsmParser &parser, Type) {
   if (failed(parser.parseLess()))
     return {};
   // Parse the data as a dictionary.
   DictionaryAttr dict;
   if (failed(parser.parseAttribute(dict)))
     return {};
   if (failed(parser.parseGreater()))
     return {};
if (dimOrdering) {
     if (dimOrdering.getNumResults() != dimLevelType.size())
       return emitError() << "unexpected mismatch in ordering and dimension "
                             "level types size";
   }
   return success();
 }
 
 LogicalResult SparseTensorEncodingAttr::verifyEncoding(
-    ArrayRef<int64_t> shape, Type elementType,
+    ArrayRef<int64_t> shape, Type,
     function_ref<InFlightDiagnostic()> emitError) const {
   // Check structural integrity.
   if (failed(verify(emitError, getDimLevelType(), getDimOrdering(),
                     getPointerBitWidth(), getIndexBitWidth())))
     return failure();
   // Check integrity with tensor type specifics. Dimension ordering is optional,
   // but we always should have dimension level types for the full rank.
   unsigned size = shape.size();
if (auto tp2 = op.dest().getType().dyn_cast<RankedTensorType>()) {
                  << d;
       }
       return success();
     }
   }
   return op.emitError("unexpected type in convert");
 }
 
-OpFoldResult ConvertOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult ConvertOp::fold(ArrayRef<Attribute>) {
   if (getType() == source().getType())
     return source();
   return {};
 }
 
 static LogicalResult verify(ToPointersOp op) {
   if (auto e = getSparseTensorEncoding(op.tensor().getType())) {
     if (failed(isInBounds(op.dim(), op.tensor())))

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp

if (isCOOConstant) {
         lo.push_back(zero);
         hi.push_back(linalg::createOrFoldDimOp(rewriter, loc, src, i));
         st.push_back(one);
       }
     }
     Type eltType = stp.getElementType();
     scf::buildLoopNest(
         rewriter, op.getLoc(), lo, hi, st, {},
-        [&](OpBuilder &builder, Location loc, ValueRange ivs,
-            ValueRange args) -> scf::ValueVector {
+        [&](OpBuilder &, Location loc, ValueRange ivs,
+            ValueRange) -> scf::ValueVector {
           Value val;
           if (isCOOConstant)
             val = genIndexAndValueForSparse(rewriter, loc, indices, values, ind,
                                             ivs, rank);
           else
             val = genIndexAndValueForDense(rewriter, loc, src, ind, ivs);
           genAddEltCall(rewriter, op, eltType, ptr, val, ind, perm);
           return {};

mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp

 }
 
 /// Generates buffer for the output tensor. Note that all sparse kernels
 /// assume that when all elements are written to (viz. x(i) = y(i) * z(i)),
 /// the output buffer is already initialized to all zeroes and only nonzeroes
 /// values are computed and written out. For updates (viz. x(i) += y(i) * z(i)),
 /// only nonzeroes values are used for the updates and no assumption on the
 /// original contents of the output buffer is necessary..
-static Value genOutputBuffer(CodeGen &codegen, PatternRewriter &rewriter,
-                             linalg::GenericOp op, MemRefType denseTp,
-                             ArrayRef<Value> args) {
+static Value genOutputBuffer(PatternRewriter &rewriter, linalg::GenericOp op,
+                             MemRefType denseTp, ArrayRef<Value> args) {
   Location loc = op.getLoc();
   Value tensor = op.getOutputOperand(0)->get();
   // The output tensor simply could materialize from the buffer that will
   // be generated for the tensor present in the outs() clause. This has
   // the major advantage that the sparse kernel only updates the nonzero
   // positions for the output tensor.
   if (isInPlace(tensor))
     return rewriter.create<bufferization::ToMemrefOp>(loc, denseTp, tensor);
for (OpOperand *t : op.getInputAndOutputOperands()) {
     Type elementType = getElementTypeOrSelf(t->get().getType());
     if (!enc) {
       // Non-annotated dense tensors.
       auto denseTp = MemRefType::get(shape, elementType);
       if (tensor < op.getNumInputs())
         codegen.buffers[tensor] =
             rewriter.create<bufferization::ToMemrefOp>(loc, denseTp, t->get());
       else
-        codegen.buffers[tensor] =
-            genOutputBuffer(codegen, rewriter, op, denseTp, args);
+        codegen.buffers[tensor] = genOutputBuffer(rewriter, op, denseTp, args);
     } else if (t == codegen.sparseOut) {
       // True sparse output needs a lexIdx array.
       Value rank = rewriter.create<arith::ConstantIndexOp>(loc, op.getRank(t));
       auto dynShape = {ShapedType::kDynamicSize};
       auto memTp = MemRefType::get(dynShape, rewriter.getIndexType());
       codegen.lexIdx = rewriter.create<memref::AllocaOp>(loc, memTp, rank);
     } else {
       // Annotated sparse tensors.
if (merger.exp(exp).kind == Kind::kTensor) {
     unsigned e0 = merger.exp(exp).children.e0;
     unsigned e1 = merger.exp(exp).children.e1;
     genInvariants(merger, codegen, rewriter, op, e0, ldx, atStart, last);
     genInvariants(merger, codegen, rewriter, op, e1, ldx, atStart, last);
   }
 }
 
 /// Generates an expanded access pattern in innermost dimension.
-static void genExpansion(Merger &merger, CodeGen &codegen,
-                         PatternRewriter &rewriter, linalg::GenericOp op,
-                         unsigned at, bool atStart) {
+static void genExpansion(CodeGen &codegen, PatternRewriter &rewriter,
+                         linalg::GenericOp op, unsigned at, bool atStart) {
   OpOperand *lhs = codegen.sparseOut;
   if (!lhs || codegen.outerParNest != op.getRank(lhs) - 1 ||
       at != codegen.outerParNest)
     return; // not needed at this level
   // Generate start or end of an expanded access pattern.
   Value tensor = lhs->get();
   Location loc = op.getLoc();
   if (atStart) {
static bool isParallelFor(CodeGen &codegen, bool isOuter, bool isReduction,
   }
   llvm_unreachable("unexpected parallelization strategy");
 }
 
 /// Checks unit stride for dense tensors. The iteration graph may have ignored
 /// dense access patterns in order to avoid cycles (sparse access patterns are
 /// always placed innermost), but that means dense access has become strided.
 /// This prevents effective vectorization.
-static bool denseUnitStrides(Merger &merger, linalg::GenericOp op,
-                             unsigned idx) {
+static bool denseUnitStrides(linalg::GenericOp op, unsigned idx) {
   for (OpOperand *t : op.getInputAndOutputOperands()) {
     if (!getSparseTensorEncoding(t->get().getType())) {
       auto map = op.getTiedIndexingMap(t);
       for (unsigned d = 0, rank = map.getNumResults(); d < rank; d++) {
         AffineExpr a = map.getResult(d);
         // Report non-unit stride if innermost index appears at an outer
         // dimension (true non-unit stride) or if the innermost index appears
         // in a compound subscript in the innermost dimension. Even if the
static Operation *genFor(Merger &merger, CodeGen &codegen,
   unsigned fb = indices.find_first();
   unsigned tensor = merger.tensor(fb);
   assert(idx == merger.index(fb));
   auto iteratorTypes = op.iterator_types().getValue();
   bool isReduction = isReductionIterator(iteratorTypes[idx]);
   bool isSparse = merger.isDim(fb, Dim::kSparse);
   bool isVector = !codegen.sparseOut &&
                   isVectorFor(codegen, isInner, isSparse) &&
-                  denseUnitStrides(merger, op, idx);
+                  denseUnitStrides(op, idx);
   bool isParallel =
       !codegen.sparseOut &&
       isParallelFor(codegen, isOuter, isReduction, isSparse, isVector);
 
   // Prepare vector length.
   if (isVector)
     codegen.curVecLength = codegen.options.vectorLength;
 
if (codegen.expValues)
     types.push_back(rewriter.getIndexType());
   scf::IfOp ifOp = rewriter.create<scf::IfOp>(loc, types, cond, /*else=*/true);
   rewriter.setInsertionPointToStart(&ifOp.getThenRegion().front());
   return ifOp;
 }
 
 /// Generates end of true branch of if-statement within a while-loop.
 static void endIf(Merger &merger, CodeGen &codegen, PatternRewriter &rewriter,
-                  linalg::GenericOp op, scf::IfOp ifOp, Operation *loop,
-                  Value redInput, Value cntInput) {
+                  linalg::GenericOp op, scf::IfOp ifOp, Value redInput,
+                  Value cntInput) {
   SmallVector<Value, 4> operands;
   if (codegen.redVal) {
     operands.push_back(codegen.redVal);
     updateReduc(merger, codegen, redInput);
   }
   if (codegen.expValues) {
     operands.push_back(codegen.expCount);
     codegen.expCount = cntInput;
static bool startLoopSeq(Merger &merger, CodeGen &codegen,
                          std::vector<unsigned> &topSort, unsigned exp,
                          unsigned at, unsigned idx, unsigned ldx,
                          unsigned lts) {
   assert(codegen.curVecLength == 1);
   assert(!codegen.loops[idx]);
   // Emit invariants at this loop sequence level.
   genInvariants(merger, codegen, rewriter, op, exp, ldx, /*atStart=*/true);
   // Emit access pattern expansion for sparse tensor output.
-  genExpansion(merger, codegen, rewriter, op, at, /*atStart=*/true);
+  genExpansion(codegen, rewriter, op, at, /*atStart=*/true);
   // Emit further intitialization at this loop sequence level.
   unsigned l0 = merger.set(lts)[0];
   bool needsUniv =
       genInit(merger, codegen, rewriter, op, topSort, at, merger.lat(l0).bits);
   // Maintain the universal index only if it is actually
   // consumed by a subsequent lattice point.
   if (needsUniv) {
     unsigned lsize = merger.set(lts).size();
static void endLoopSeq(Merger &merger, CodeGen &codegen,
   // Bring a pending reduction back from SIMD form when sequence ends.
   if (codegen.redVal)
     if (auto vtp = codegen.redVal.getType().dyn_cast<VectorType>())
       updateReduc(merger, codegen,
                   genVectorReducEnd(codegen, rewriter, op.getLoc(), vtp));
   // Unmark bookkeeping of invariants and loop index.
   genInvariants(merger, codegen, rewriter, op, exp, ldx, /*atStart=*/false);
   // Finalize access pattern expansion for sparse tensor output.
-  genExpansion(merger, codegen, rewriter, op, at, /*atStart=*/false);
+  genExpansion(codegen, rewriter, op, at, /*atStart=*/false);
 }
 
 /// Recursively generates code while computing iteration lattices in order
 /// to manage the complexity of implementing co-iteration over unions
 /// and intersections of sparse iterations spaces.
 static void genStmt(Merger &merger, CodeGen &codegen, PatternRewriter &rewriter,
                     linalg::GenericOp op, std::vector<unsigned> &topSort,
                     unsigned exp, unsigned at) {
for (unsigned j = 0; j < lsize; j++) {
       unsigned lj = merger.set(lts)[j];
       unsigned ej = merger.lat(lj).exp;
       if (li == lj || merger.latGT(li, lj)) {
         // Recurse into body of each branch.
         if (isWhile) {
           scf::IfOp ifOp =
               genIf(merger, codegen, rewriter, op, idx, merger.lat(lj).simple);
           genStmt(merger, codegen, rewriter, op, topSort, ej, at + 1);
-          endIf(merger, codegen, rewriter, op, ifOp, loop, redInput, cntInput);
+          endIf(merger, codegen, rewriter, op, ifOp, redInput, cntInput);
         } else {
           genStmt(merger, codegen, rewriter, op, topSort, ej, at + 1);
         }
       }
     }
 
     // End a loop.
     needsUniv =
         endLoop(merger, codegen, rewriter, op, loop, idx, li, needsUniv);
   }
 
   // End a loop sequence.
   endLoopSeq(merger, codegen, rewriter, op, exp, at, idx, ldx);
 }
 
 /// Converts the result computed by the sparse kernel into the required form.
-static void genResult(Merger &merger, CodeGen &codegen,
-                      PatternRewriter &rewriter, linalg::GenericOp op) {
+static void genResult(CodeGen &codegen, PatternRewriter &rewriter,
+                      linalg::GenericOp op) {
   OpOperand *lhs = op.getOutputOperand(0);
   Type resType = lhs->get().getType();
   Value result;
   if (getSparseTensorEncoding(resType)) {
     // The sparse tensor rematerializes from the original sparse tensor's
     // underlying sparse storage format.
     rewriter.replaceOpWithNewOp<LoadOp>(op, resType, lhs->get(),
                                         codegen.sparseOut == lhs);
if (!isAdmissableTensorExp(merger, op, topSort, exp, &sparseOut,
                                outerParNest))
       return failure();
 
     // Recursively generates code.
     merger.setHasSparseOut(sparseOut != nullptr);
     CodeGen codegen(options, numTensors, numLoops, sparseOut, outerParNest);
     genBuffers(merger, codegen, rewriter, op);
     genStmt(merger, codegen, rewriter, op, topSort, exp, 0);
-    genResult(merger, codegen, rewriter, op);
+    genResult(codegen, rewriter, op);
     return success();
   }
 
 private:
   /// Options to control sparse code generation.
   SparsificationOptions options;
 };
 
 } // namespace
 
 /// Populates the given patterns list with rewriting rules required for
 /// the sparsification of linear algebra operations.
 void mlir::populateSparsificationPatterns(
     RewritePatternSet &patterns, const SparsificationOptions &options) {
   patterns.add<GenericOpSparsifier>(patterns.getContext(), options);
 }

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,
                   ConversionPatternRewriter &rewriter) const final {
     auto functionType = op.getType();
 
     // Convert function arguments using the provided TypeConverter.
     TypeConverter::SignatureConversion conversion(functionType.getNumInputs());
     for (const 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,
                   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

 /// TODO: This should probably just be a general matcher that uses matchConstant
 /// and checks the operation for an index type.
 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) {
+void mlir::canonicalizeSubViewPart(SmallVectorImpl<OpFoldResult> &values,
+                                   llvm::function_ref<bool(int64_t)>) {
   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/Tensor/IR/TensorDialect.cpp

 
 //===----------------------------------------------------------------------===//
 // TensorDialect Dialect Interfaces
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TensorInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
-  bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
-                       BlockAndValueMapping &valueMapping) const final {
+  bool isLegalToInline(Region *, Region *, bool,
+                       BlockAndValueMapping &) const final {
     return true;
   }
-  bool isLegalToInline(Operation *, Region *, bool wouldBeCloned,
+  bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // TensorDialect Methods

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

if (elementsAttr && elementsAttr.isValidIndex(indices))
     return elementsAttr.getValues<Attribute>()[indices];
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // FromElementsOp
 //===----------------------------------------------------------------------===//
 
-void FromElementsOp::build(OpBuilder &builder, OperationState &result,
-                           Type resultType, ValueRange elements) {
+void FromElementsOp::build(OpBuilder &, OperationState &result, Type resultType,
+                           ValueRange elements) {
   result.addOperands(elements);
   result.addTypes(resultType);
 }
 
 void FromElementsOp::build(OpBuilder &builder, OperationState &result,
                            ValueRange elements) {
   assert(!elements.empty() && "expected at least one element");
   Type resultType = RankedTensorType::get(
void GenerateOp::getCanonicalizationPatterns(RewritePatternSet &results,
   results.add<ExtractFromTensorGenerate, ExtractFromTensorCast,
               StaticTensorGenerate>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult RankOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult RankOp::fold(ArrayRef<Attribute>) {
   // Constant fold rank when the rank of the operand is known.
   auto type = getOperand().getType();
   auto shapedType = type.dyn_cast<ShapedType>();
   if (shapedType && shapedType.hasRank())
     return IntegerAttr::get(IndexType::get(getContext()), shapedType.getRank());
   return IntegerAttr();
 }
 

 //===----------------------------------------------------------------------===//
 // ExtractSliceOp
 //===----------------------------------------------------------------------===//
 
 /// An extract_slice op result type can be fully inferred from the source type
 /// and the static representation of offsets, sizes and strides. Special
 /// sentinels encode the dynamic case.
 RankedTensorType ExtractSliceOp::inferResultType(
-    RankedTensorType sourceRankedTensorType, ArrayRef<int64_t> staticOffsets,
-    ArrayRef<int64_t> staticSizes, ArrayRef<int64_t> staticStrides) {
+    RankedTensorType sourceRankedTensorType, ArrayRef<int64_t>,
+    ArrayRef<int64_t> staticSizes, ArrayRef<int64_t>) {
   // An extract_slice op may specify only a leading subset of offset/sizes/
   // strides in which case we complete with offset=0, sizes from memref type and
   // strides=1.
   unsigned rank = sourceRankedTensorType.getRank();
   (void)rank;
   assert(staticSizes.size() == rank &&
          "unexpected staticSizes not equal to rank of source");
   return RankedTensorType::get(staticSizes,
void ExtractSliceOp::build(OpBuilder &b, OperationState &result, Value source,
   build(b, result, RankedTensorType(), source, offsets, sizes, strides, attrs);
 }
 
 /// Build an ExtractSliceOp with dynamic entries and custom result type. If the
 /// type passed is nullptr, it is inferred.
 void ExtractSliceOp::build(OpBuilder &b, OperationState &result,
                            RankedTensorType resultType, Value source,
                            ValueRange offsets, ValueRange sizes,
-                           ValueRange strides, ArrayRef<NamedAttribute> attrs) {
+                           ValueRange strides, ArrayRef<NamedAttribute>) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, resultType, source, offsetValues, sizeValues, strideValues);
 }
build(b, result, dest.getType(), source, dest, dynamicOffsets, dynamicSizes,
         dynamicStrides, b.getI64ArrayAttr(staticOffsets),
         b.getI64ArrayAttr(staticSizes), b.getI64ArrayAttr(staticStrides));
   result.addAttributes(attrs);
 }
 
 // Build a InsertSliceOp with dynamic entries.
 void InsertSliceOp::build(OpBuilder &b, OperationState &result, Value source,
                           Value dest, ValueRange offsets, ValueRange sizes,
-                          ValueRange strides, ArrayRef<NamedAttribute> attrs) {
+                          ValueRange strides, ArrayRef<NamedAttribute>) {
   SmallVector<OpFoldResult> offsetValues = llvm::to_vector<4>(
       llvm::map_range(offsets, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> sizeValues = llvm::to_vector<4>(
       llvm::map_range(sizes, [](Value v) -> OpFoldResult { return v; }));
   SmallVector<OpFoldResult> strideValues = llvm::to_vector<4>(
       llvm::map_range(strides, [](Value v) -> OpFoldResult { return v; }));
   build(b, result, source, dest, offsetValues, sizeValues, strideValues);
 }

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 *, Region *, bool,
+                       BlockAndValueMapping &) 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 *, bool,
+                       BlockAndValueMapping &) 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>) {
   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>) {
   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>) {
   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>) {
   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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
 }
 
 LogicalResult MaxPool2dOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     SmallVectorImpl<ShapedTypeComponents> &inferredReturnShapes) {
   return poolingInferReturnTypes(operands, attributes, inferredReturnShapes);
 }
 
 LogicalResult DepthwiseConv2DOp::inferReturnTypeComponents(
-    MLIRContext *context, ::llvm::Optional<Location> location,
-    ValueShapeRange operands, DictionaryAttr attributes, RegionRange regions,
+    MLIRContext *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange operands,
+    DictionaryAttr attributes, RegionRange,
     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 *, ::llvm::Optional<Location>, ValueShapeRange, DictionaryAttr,
+    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 *, ::llvm::Optional<Location>, ValueShapeRange, DictionaryAttr,
+    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) ||
       parser.parseKeyword("into") || parser.parseType(resultType))
     return failure();
   result.addTypes(resultType);
   return success();
 }
 
 Optional<SmallVector<ReassociationIndices>> mlir::composeReassociationIndices(
     ArrayRef<ReassociationIndices> producerReassociations,
-    ArrayRef<ReassociationIndices> consumerReassociations,
-    MLIRContext *context) {
+    ArrayRef<ReassociationIndices> consumerReassociations, MLIRContext *) {
   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, [&](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 &, 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/lib/Dialect/Vector/VectorOps.cpp

void CombiningKindAttr::print(AsmPrinter &printer) const {
   auto kinds = llvm::make_filter_range(combiningKindsList, [&](auto kind) {
     return bitEnumContains(this->getKind(), kind);
   });
   llvm::interleaveComma(kinds, printer,
                         [&](auto kind) { printer << stringifyEnum(kind); });
   printer << ">";
 }
 
-Attribute CombiningKindAttr::parse(AsmParser &parser, Type type) {
+Attribute CombiningKindAttr::parse(AsmParser &parser, Type) {
   if (failed(parser.parseLess()))
     return {};
 
   StringRef elemName;
   if (failed(parser.parseKeyword(&elemName)))
     return {};
 
   auto kind = symbolizeCombiningKind(elemName);
   if (!kind) {
     parser.emitError(parser.getNameLoc(), "Unknown combining kind: ")
         << elemName;
     return {};
   }
 
   if (failed(parser.parseGreater()))
     return {};
 
   return CombiningKindAttr::get(kind.getValue(), parser.getContext());
 }
 
-Attribute VectorDialect::parseAttribute(DialectAsmParser &parser,
-                                        Type type) const {
+Attribute VectorDialect::parseAttribute(DialectAsmParser &parser, Type) const {
   StringRef attrKind;
   if (parser.parseKeyword(&attrKind))
     return {};
 
   if (attrKind == "kind")
     return CombiningKindAttr::parse(parser, {});
 
   parser.emitError(parser.getNameLoc(), "Unknown attribute type: ") << attrKind;
auto targetType = MultiDimReductionOp::inferDestType(
       op.getSourceVectorType().getElementType());
   // TODO: update to support 0-d vectors when available.
   if (targetType != op.getDestType())
     return op.emitError("invalid output vector type: ")
            << op.getDestType() << " (expected: " << targetType << ")";
   return success();
 }
 
-OpFoldResult MultiDimReductionOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult MultiDimReductionOp::fold(ArrayRef<Attribute>) {
   // Single parallel dim, this is a noop.
   if (getSourceVectorType().getRank() == 1 && !isReducedDim(0))
     return source();
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // ReductionOp
void ContractionOp::getCanonicalizationPatterns(RewritePatternSet &results,
   results.add<CanonicalizeContractAdd<arith::AddIOp>,
               CanonicalizeContractAdd<arith::AddFOp>>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractElementOp
 //===----------------------------------------------------------------------===//
 
-void vector::ExtractElementOp::build(OpBuilder &builder, OperationState &result,
+void vector::ExtractElementOp::build(OpBuilder &, OperationState &result,
                                      Value source) {
   result.addOperands({source});
   result.addTypes(source.getType().cast<VectorType>().getElementType());
 }
 
-void vector::ExtractElementOp::build(OpBuilder &builder, OperationState &result,
+void vector::ExtractElementOp::build(OpBuilder &, OperationState &result,
                                      Value source, Value position) {
   result.addOperands({source, position});
   result.addTypes(source.getType().cast<VectorType>().getElementType());
 }
 
 static LogicalResult verify(vector::ExtractElementOp op) {
   VectorType vectorType = op.getVectorType();
   if (vectorType.getRank() == 0) {
if (op.getSourceVectorType().getDimSize(i) !=
       numId++;
   }
   if (numId != op.ids().size())
     return op.emitOpError("expected number of ids must match the number of "
                           "dimensions distributed");
   return success();
 }
 
-OpFoldResult ExtractMapOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult ExtractMapOp::fold(ArrayRef<Attribute>) {
   auto insert = vector().getDefiningOp<vector::InsertMapOp>();
   if (insert == nullptr || getType() != insert.vector().getType() ||
       ids() != insert.ids())
     return {};
   return insert.vector();
 }
 
 void ExtractMapOp::getMultiplicity(SmallVectorImpl<int64_t> &multiplicity) {
static ParseResult parseShuffleOp(OpAsmParser &parser, OperationState &result) {
   parser.addTypeToList(resType, result.types);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // InsertElementOp
 //===----------------------------------------------------------------------===//
 
-void InsertElementOp::build(OpBuilder &builder, OperationState &result,
-                            Value source, Value dest) {
+void InsertElementOp::build(OpBuilder &, OperationState &result, Value source,
+                            Value dest) {
   result.addOperands({source, dest});
   result.addTypes(dest.getType());
 }
 
-void InsertElementOp::build(OpBuilder &builder, OperationState &result,
-                            Value source, Value dest, Value position) {
+void InsertElementOp::build(OpBuilder &, OperationState &result, Value source,
+                            Value dest, Value position) {
   result.addOperands({source, dest, position});
   result.addTypes(dest.getType());
 }
 
 static LogicalResult verify(InsertElementOp op) {
   auto dstVectorType = op.getDestVectorType();
   if (dstVectorType.getRank() == 0) {
     if (op.position())

 void InsertOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                            MLIRContext *context) {
   results.add<InsertToBroadcast, BroadcastFolder>(context);
 }
 
 // Eliminates insert operations that produce values identical to their source
 // value. This happens when the source and destination vectors have identical
 // sizes.
-OpFoldResult vector::InsertOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult vector::InsertOp::fold(ArrayRef<Attribute>) {
   if (position().empty())
     return source();
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // InsertMapOp
 //===----------------------------------------------------------------------===//
if (failed(
           makeI64ArrayAttr(sourceShapeAsDestShape, op.getContext()), destShape,
           offName, "source vector shape",
           /*halfOpen=*/false, /*min=*/1)))
     return failure();
 
   return success();
 }
 
-OpFoldResult InsertStridedSliceOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult InsertStridedSliceOp::fold(ArrayRef<Attribute>) {
   if (getSourceVectorType() == getDestVectorType())
     return source();
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // OuterProductOp
 //===----------------------------------------------------------------------===//
 
 /// Build an op without mask, use the type of `acc` as the return type.
-void OuterProductOp::build(OpBuilder &builder, OperationState &result,
-                           Value lhs, Value rhs, Value acc) {
+void OuterProductOp::build(OpBuilder &, OperationState &result, Value lhs,
+                           Value rhs, Value acc) {
   result.addOperands({lhs, rhs, acc});
   result.addTypes(acc.getType());
 }
 
 static void print(OpAsmPrinter &p, OuterProductOp op) {
   p << " " << op.lhs() << ", " << op.rhs();
   if (!op.acc().empty()) {
     p << ", " << op.acc();
else {
       // The extracted vector partially overlap the inserted vector, we cannot
       // fold.
       return failure();
     }
   }
   return failure();
 }
 
-OpFoldResult ExtractStridedSliceOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult ExtractStridedSliceOp::fold(ArrayRef<Attribute>) {
   if (getVectorType() == getResult().getType())
     return vector();
   if (succeeded(foldExtractStridedOpFromInsertChain(*this)))
     return getResult();
   return {};
 }
 
 void ExtractStridedSliceOp::getOffsets(SmallVectorImpl<int64_t> &results) {

 /// ```
 ///
 /// `%w0 = vector.transfer_write` op will be removed by DCE if it doesn't have
 /// any other uses.
 class FoldWaw final : public OpRewritePattern<TransferWriteOp> {
 public:
   using OpRewritePattern<TransferWriteOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(TransferWriteOp writeOp,
-                                PatternRewriter &rewriter) const override {
+                                PatternRewriter &) const override {
     if (!writeOp.getShapedType().isa<RankedTensorType>())
       return failure();
     vector::TransferWriteOp writeToModify = writeOp;
 
     auto defWrite = writeOp.source().getDefiningOp<vector::TransferWriteOp>();
     while (defWrite) {
       if (checkSameValueWAW(writeOp, defWrite)) {
         writeToModify.sourceMutable().assign(defWrite.source());
static LogicalResult verify(vector::StoreOp op) {
 
   if (valueVecTy.getElementType() != memElemTy)
     return op.emitOpError("base and valueToStore element type should match");
   if (llvm::size(op.indices()) != memRefTy.getRank())
     return op.emitOpError("requires ") << memRefTy.getRank() << " indices";
   return success();
 }
 
-LogicalResult StoreOp::fold(ArrayRef<Attribute> operands,
-                            SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult StoreOp::fold(ArrayRef<Attribute>,
+                            SmallVectorImpl<OpFoldResult> &) {
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // MaskedLoadOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(MaskedLoadOp op) {

 };
 } // namespace
 
 void MaskedStoreOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                 MLIRContext *context) {
   results.add<MaskedStoreFolder>(context);
 }
 
-LogicalResult MaskedStoreOp::fold(ArrayRef<Attribute> operands,
-                                  SmallVectorImpl<OpFoldResult> &results) {
+LogicalResult MaskedStoreOp::fold(ArrayRef<Attribute>,
+                                  SmallVectorImpl<OpFoldResult> &) {
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // GatherOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(GatherOp op) {
static LogicalResult verify(ShapeCastOp op) {
 
   // Check if source/result are of vector type.
   if (sourceVectorType && resultVectorType)
     return verifyVectorShapeCast(op, sourceVectorType, resultVectorType);
 
   return success();
 }
 
-OpFoldResult ShapeCastOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult ShapeCastOp::fold(ArrayRef<Attribute>) {
   // Nop shape cast.
   if (source().getType() == result().getType())
     return source();
 
   // Canceling shape casts.
   if (auto otherOp = source().getDefiningOp<ShapeCastOp>()) {
     if (result().getType() == otherOp.source().getType())
       return otherOp.source();
SmallVector<int64_t, 8> res(memRefType.getShape().begin(),
                               memRefType.getShape().end());
   if (vectorType)
     res.append(vectorType.getShape().begin(), vectorType.getShape().end());
   return res;
 }
 
 /// Build the canonical memRefType with a single vector.
 /// E.g. memref<4 x 5 x vector<6 x f32>> -> memref<vector<4 x 5 x 6 x f32>>.
-void TypeCastOp::build(OpBuilder &builder, OperationState &result,
-                       Value source) {
+void TypeCastOp::build(OpBuilder &, OperationState &result, Value source) {
   result.addOperands(source);
   MemRefType memRefType = source.getType().cast<MemRefType>();
   VectorType vectorType =
       VectorType::get(extractShape(memRefType),
                       getElementTypeOrSelf(getElementTypeOrSelf(memRefType)));
   result.addTypes(MemRefType::get({}, vectorType, MemRefLayoutAttrInterface(),
                                   memRefType.getMemorySpace()));
 }
void vector::TransposeOp::build(OpBuilder &builder, OperationState &result,
   result.addOperands(vector);
   result.addTypes(VectorType::get(transposedShape, vt.getElementType()));
   result.addAttribute(getTranspAttrName(), builder.getI64ArrayAttr(transp));
 }
 
 // Eliminates transpose operations, which produce values identical to their
 // input values. This happens when the dimensions of the input vector remain in
 // their original order after the transpose operation.
-OpFoldResult vector::TransposeOp::fold(ArrayRef<Attribute> operands) {
+OpFoldResult vector::TransposeOp::fold(ArrayRef<Attribute>) {
   SmallVector<int64_t, 4> transp;
   getTransp(transp);
 
   // Check if the permutation of the dimensions contains sequential values:
   // {0, 1, 2, ...}.
   for (int64_t i = 0, e = transp.size(); i < e; i++) {
     if (transp[i] != i)
       return {};

mlir/lib/ExecutionEngine/ExecutionEngine.cpp

Expected<std::unique_ptr<ExecutionEngine>> ExecutionEngine::create(
   setupTargetTriple(llvmModule.get());
   packFunctionArguments(llvmModule.get());
 
   auto dataLayout = llvmModule->getDataLayout();
 
   // Callback to create the object layer with symbol resolution to current
   // process and dynamically linked libraries.
   auto objectLinkingLayerCreator = [&](ExecutionSession &session,
-                                       const Triple &tt) {
+                                       const Triple &) {
     auto objectLayer = std::make_unique<RTDyldObjectLinkingLayer>(
         session, []() { return std::make_unique<SectionMemoryManager>(); });
 
     // Register JIT event listeners if they are enabled.
     if (engine->gdbListener)
       objectLayer->registerJITEventListener(*engine->gdbListener);
     if (engine->perfListener)
       objectLayer->registerJITEventListener(*engine->perfListener);

mlir/lib/IR/AffineExpr.cpp

void SimpleAffineExprFlattener::visitMulExpr(AffineBinaryOpExpr expr) {
 
   // Get the RHS constant.
   auto rhsConst = rhs[getConstantIndex()];
   for (unsigned i = 0, e = lhs.size(); i < e; i++) {
     lhs[i] *= rhsConst;
   }
 }
 
-void SimpleAffineExprFlattener::visitAddExpr(AffineBinaryOpExpr expr) {
+void SimpleAffineExprFlattener::visitAddExpr(AffineBinaryOpExpr) {
   assert(operandExprStack.size() >= 2);
   const auto &rhs = operandExprStack.back();
   auto &lhs = operandExprStack[operandExprStack.size() - 2];
   assert(lhs.size() == rhs.size());
   // Update the LHS in place.
   for (unsigned i = 0, e = rhs.size(); i < e; i++) {
     lhs[i] += rhs[i];
   }
else
     lhs[getLocalVarStartIndex() + loc] = 1;
 }
 
 // Add a local identifier (needed to flatten a mod, floordiv, ceildiv expr).
 // The local identifier added is always a floordiv of a pure add/mul affine
 // function of other identifiers, coefficients of which are specified in
 // dividend and with respect to a positive constant divisor. localExpr is the
 // simplified tree expression (AffineExpr) corresponding to the quantifier.
-void SimpleAffineExprFlattener::addLocalFloorDivId(ArrayRef<int64_t> dividend,
+void SimpleAffineExprFlattener::addLocalFloorDivId(ArrayRef<int64_t>,
                                                    int64_t divisor,
                                                    AffineExpr localExpr) {
   assert(divisor > 0 && "positive constant divisor expected");
   for (SmallVector<int64_t, 8> &subExpr : operandExprStack)
     subExpr.insert(subExpr.begin() + getLocalVarStartIndex() + numLocals, 0);
   localExprs.push_back(localExpr);
   numLocals++;
   // dividend and divisor are not used here; an override of this method uses it.

mlir/lib/IR/AsmPrinter.cpp

void print(Operation *op) {
     }
 
     // Otherwise print with the generic assembly form.
     printGenericOp(op);
   }
 
 private:
   /// Print the given operation in the generic form.
-  void printGenericOp(Operation *op, bool printOpName = true) override {
+  void printGenericOp(Operation *op, bool = true) override {
     // Consider nested operations for aliases.
     if (op->getNumRegions() != 0) {
       for (Region &region : op->getRegions())
         printRegion(region, /*printEntryBlockArgs=*/true,
                     /*printBlockTerminators=*/true);
     }
 
     // Visit all the types used in the operation.
auto range = llvm::make_range(
         std::prev(block->end(),
                   (!hasTerminator || printBlockTerminator) ? 0 : 1));
     for (Operation &op : range)
       print(&op);
   }
 
   /// Print the given region.
   void printRegion(Region &region, bool printEntryBlockArgs,
-                   bool printBlockTerminators,
-                   bool printEmptyBlock = false) override {
+                   bool printBlockTerminators, bool = false) override {
     if (region.empty())
       return;
 
     auto *entryBlock = &region.front();
     print(entryBlock, printEntryBlockArgs, printBlockTerminators);
     for (Block &b : llvm::drop_begin(region, 1))
       print(&b);
   }
 
-  void printRegionArgument(BlockArgument arg, ArrayRef<NamedAttribute> argAttrs,
-                           bool omitType) override {
+  void printRegionArgument(BlockArgument arg, ArrayRef<NamedAttribute>,
+                           bool) override {
     printType(arg.getType());
     // Visit the argument location.
     if (printerFlags.shouldPrintDebugInfo())
       // TODO: Allow deferring argument locations.
       initializer.visit(arg.getLoc(), /*canBeDeferred=*/false);
   }
 
   /// Consider the given type to be printed for an alias.
void AsmPrinter::Impl::printTrailingLocation(Location loc, bool allowAlias) {
   printLocation(loc, /*allowAlias=*/allowAlias);
 }
 
 void AsmPrinter::Impl::printLocationInternal(LocationAttr loc, bool pretty) {
   TypeSwitch<LocationAttr>(loc)
       .Case<OpaqueLoc>([&](OpaqueLoc loc) {
         printLocationInternal(loc.getFallbackLocation(), pretty);
       })
-      .Case<UnknownLoc>([&](UnknownLoc loc) {
+      .Case<UnknownLoc>([&](UnknownLoc) {
         if (pretty)
           os << "[unknown]";
         else
           os << "unknown";
       })
       .Case<FileLineColLoc>([&](FileLineColLoc loc) {
         if (pretty) {
           os << loc.getFilename().getValue();

 }
 void Block::print(raw_ostream &os, AsmState &state) {
   OperationPrinter(os, /*flags=*/llvm::None, state.getImpl()).print(this);
 }
 
 void Block::dump() { print(llvm::errs()); }
 
 /// Print out the name of the block without printing its body.
-void Block::printAsOperand(raw_ostream &os, bool printType) {
+void Block::printAsOperand(raw_ostream &os, bool) {
   Operation *parentOp = getParentOp();
   if (!parentOp) {
     os << "<<UNLINKED BLOCK>>\n";
     return;
   }
   AsmState state(parentOp);
   printAsOperand(os, state);
 }
 void Block::printAsOperand(raw_ostream &os, AsmState &state) {
   OperationPrinter printer(os, /*flags=*/llvm::None, state.getImpl());
   printer.printBlockName(this);
 }

mlir/lib/IR/BuiltinAttributes.cpp

addAttributes<AffineMapAttr, ArrayAttr, DenseIntOrFPElementsAttr,
                 UnitAttr>();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayAttr
 //===----------------------------------------------------------------------===//
 
 void ArrayAttr::walkImmediateSubElements(
-    function_ref<void(Attribute)> walkAttrsFn,
-    function_ref<void(Type)> walkTypesFn) const {
+    function_ref<void(Attribute)> walkAttrsFn, function_ref<void(Type)>) const {
   for (Attribute attr : getValue())
     walkAttrsFn(attr);
 }
 
 SubElementAttrInterface ArrayAttr::replaceImmediateSubAttribute(
     ArrayRef<std::pair<size_t, Attribute>> replacements) const {
   std::vector<Attribute> vector = getValue().vec();
   for (auto &it : replacements) {

 }
 size_t DictionaryAttr::size() const { return getValue().size(); }
 
 DictionaryAttr DictionaryAttr::getEmptyUnchecked(MLIRContext *context) {
   return Base::get(context, ArrayRef<NamedAttribute>());
 }
 
 void DictionaryAttr::walkImmediateSubElements(
-    function_ref<void(Attribute)> walkAttrsFn,
-    function_ref<void(Type)> walkTypesFn) const {
+    function_ref<void(Attribute)> walkAttrsFn, function_ref<void(Type)>) const {
   for (const NamedAttribute &attr : getValue())
     walkAttrsFn(attr.getValue());
 }
 
 SubElementAttrInterface DictionaryAttr::replaceImmediateSubAttribute(
     ArrayRef<std::pair<size_t, Attribute>> replacements) const {
   std::vector<NamedAttribute> vec = getValue().vec();
   for (auto &it : replacements)
auto *interface =
       dialect->getRegisteredInterface<DialectDecodeAttributesInterface>();
   if (!interface)
     return true;
   return failed(interface->decode(*this, result));
 }
 
 LogicalResult
 OpaqueElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                           StringAttr dialect, StringRef value,
-                           ShapedType type) {
+                           StringAttr dialect, StringRef, ShapedType) {
   if (!Dialect::isValidNamespace(dialect.strref()))
     return emitError() << "invalid dialect namespace '" << dialect << "'";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SparseElementsAttr
 //===----------------------------------------------------------------------===//
SparseElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TypeAttr
 //===----------------------------------------------------------------------===//
 
 void TypeAttr::walkImmediateSubElements(
-    function_ref<void(Attribute)> walkAttrsFn,
-    function_ref<void(Type)> walkTypesFn) const {
+    function_ref<void(Attribute)>, function_ref<void(Type)> walkTypesFn) const {
   walkTypesFn(getValue());
 }

mlir/lib/IR/BuiltinDialect.cpp

static LogicalResult verify(ModuleOp op) {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // UnrealizedConversionCastOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-UnrealizedConversionCastOp::fold(ArrayRef<Attribute> attrOperands,
+UnrealizedConversionCastOp::fold(ArrayRef<Attribute>,
                                  SmallVectorImpl<OpFoldResult> &foldResults) {
   OperandRange operands = inputs();
   ResultRange results = outputs();
 
   if (operands.getType() == results.getType()) {
     foldResults.append(operands.begin(), operands.end());
     return success();
   }
if (!inputOp || inputOp.getResults() != operands ||
       inputOp.getOperandTypes() != results.getTypes())
     return failure();
 
   // If everything matches up, we can fold the passthrough.
   foldResults.append(inputOp->operand_begin(), inputOp->operand_end());
   return success();
 }
 
-bool UnrealizedConversionCastOp::areCastCompatible(TypeRange inputs,
-                                                   TypeRange outputs) {
+bool UnrealizedConversionCastOp::areCastCompatible(TypeRange, TypeRange) {
   // `UnrealizedConversionCastOp` is agnostic of the input/output types.
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/IR/BuiltinOps.cpp.inc"

mlir/lib/IR/BuiltinTypes.cpp

 // Integer Type
 //===----------------------------------------------------------------------===//
 
 // static constexpr must have a definition (until in C++17 and inline variable).
 constexpr unsigned IntegerType::kMaxWidth;
 
 /// Verify the construction of an integer type.
 LogicalResult IntegerType::verify(function_ref<InFlightDiagnostic()> emitError,
-                                  unsigned width,
-                                  SignednessSemantics signedness) {
+                                  unsigned width, SignednessSemantics) {
   if (width > IntegerType::kMaxWidth) {
     return emitError() << "integer bitwidth is limited to "
                        << IntegerType::kMaxWidth << " bits";
   }
   return success();
 }
 
 unsigned IntegerType::getWidth() const { return getImpl()->width; }
if (!resultIndices.empty()) {
     });
     newResultTypes = newResultTypesBuffer;
   }
 
   return get(getContext(), newInputTypes, newResultTypes);
 }
 
 void FunctionType::walkImmediateSubElements(
-    function_ref<void(Attribute)> walkAttrsFn,
-    function_ref<void(Type)> walkTypesFn) const {
+    function_ref<void(Attribute)>, function_ref<void(Type)> walkTypesFn) const {
   for (Type type : llvm::concat<const Type>(getInputs(), getResults()))
     walkTypesFn(type);
 }
 
 //===----------------------------------------------------------------------===//
 // OpaqueType
 //===----------------------------------------------------------------------===//
 

 }
 
 //===----------------------------------------------------------------------===//
 // VectorType
 //===----------------------------------------------------------------------===//
 
 LogicalResult VectorType::verify(function_ref<InFlightDiagnostic()> emitError,
                                  ArrayRef<int64_t> shape, Type elementType,
-                                 unsigned numScalableDims) {
+                                 unsigned) {
   if (!isValidElementType(elementType))
     return emitError()
            << "vector elements must be int/index/float type but got "
            << elementType;
 
   if (any_of(shape, [](int64_t i) { return i <= 0; }))
     return emitError()
            << "vector types must have positive constant sizes but got "
if (auto scaledEt = et.scaleElementBitwidth(scale))
       return VectorType::get(getShape(), scaledEt, getNumScalableDims());
   if (auto et = getElementType().dyn_cast<FloatType>())
     if (auto scaledEt = et.scaleElementBitwidth(scale))
       return VectorType::get(getShape(), scaledEt, getNumScalableDims());
   return VectorType();
 }
 
 void VectorType::walkImmediateSubElements(
-    function_ref<void(Attribute)> walkAttrsFn,
-    function_ref<void(Type)> walkTypesFn) const {
+    function_ref<void(Attribute)>, function_ref<void(Type)> walkTypesFn) const {
   walkTypesFn(getElementType());
 }
 
 //===----------------------------------------------------------------------===//
 // TensorType
 //===----------------------------------------------------------------------===//
 
 // Check if "elementType" can be an element type of a tensor.

 
 LogicalResult
 UnrankedTensorType::verify(function_ref<InFlightDiagnostic()> emitError,
                            Type elementType) {
   return checkTensorElementType(emitError, elementType);
 }
 
 void UnrankedTensorType::walkImmediateSubElements(
-    function_ref<void(Attribute)> walkAttrsFn,
-    function_ref<void(Type)> walkTypesFn) const {
+    function_ref<void(Attribute)>, function_ref<void(Type)> walkTypesFn) const {
   walkTypesFn(getElementType());
 }
 
 //===----------------------------------------------------------------------===//
 // BaseMemRefType
 //===----------------------------------------------------------------------===//
 
 Attribute BaseMemRefType::getMemorySpace() const {
else
       types.push_back(type);
   }
 }
 
 /// Return the number of element types.
 size_t TupleType::size() const { return getImpl()->size(); }
 
 void TupleType::walkImmediateSubElements(
-    function_ref<void(Attribute)> walkAttrsFn,
-    function_ref<void(Type)> walkTypesFn) const {
+    function_ref<void(Attribute)>, function_ref<void(Type)> walkTypesFn) const {
   for (Type type : getTypes())
     walkTypesFn(type);
 }
 
 //===----------------------------------------------------------------------===//
 // Type Utilities
 //===----------------------------------------------------------------------===//
 

mlir/lib/IR/Dialect.cpp

 /// the verification failed, success otherwise. This hook may optionally be
 /// invoked from any operation containing a region.
 LogicalResult Dialect::verifyRegionResultAttribute(Operation *, unsigned,
                                                    unsigned, NamedAttribute) {
   return success();
 }
 
 /// Parse an attribute registered to this dialect.
-Attribute Dialect::parseAttribute(DialectAsmParser &parser, Type type) const {
+Attribute Dialect::parseAttribute(DialectAsmParser &parser, Type) const {
   parser.emitError(parser.getNameLoc())
       << "dialect '" << getNamespace()
       << "' provides no attribute parsing hook";
   return Attribute();
 }
 
 /// Parse a type registered to this dialect.
 Type Dialect::parseType(DialectAsmParser &parser) const {
   // If this dialect allows unknown types, then represent this with OpaqueType.
   if (allowsUnknownTypes()) {
     StringAttr ns = StringAttr::get(getContext(), getNamespace());
     return OpaqueType::get(ns, parser.getFullSymbolSpec());
   }
 
   parser.emitError(parser.getNameLoc())
       << "dialect '" << getNamespace() << "' provides no type parsing hook";
   return Type();
 }
 
-Optional<Dialect::ParseOpHook>
-Dialect::getParseOperationHook(StringRef opName) const {
+Optional<Dialect::ParseOpHook> Dialect::getParseOperationHook(StringRef) const {
   return None;
 }
 
 llvm::unique_function<void(Operation *, OpAsmPrinter &printer)>
 Dialect::getOperationPrinter(Operation *op) const {
   assert(op->getDialect() == this &&
          "Dialect hook invoked on non-dialect owned operation");
   return nullptr;

mlir/lib/IR/FunctionImplementation.cpp

 }
 
 /// Prints the list of function prefixed with the "attributes" keyword. The
 /// attributes with names listed in "elided" as well as those used by the
 /// function-like operation internally are not printed. Nothing is printed
 /// if all attributes are elided. Assumes `op` has the `FunctionLike` trait and
 /// passed the verification.
 void mlir::function_like_impl::printFunctionAttributes(
-    OpAsmPrinter &p, Operation *op, unsigned numInputs, unsigned numResults,
+    OpAsmPrinter &p, Operation *op, unsigned, unsigned,
     ArrayRef<StringRef> elided) {
   // Print out function attributes, if present.
   SmallVector<StringRef, 2> ignoredAttrs = {
       ::mlir::SymbolTable::getSymbolAttrName(), getTypeAttrName(),
       getArgDictAttrName(), getResultDictAttrName()};
   ignoredAttrs.append(elided.begin(), elided.end());
 
   p.printOptionalAttrDictWithKeyword(op->getAttrs(), ignoredAttrs);

mlir/lib/IR/Operation.cpp

if (auto vec = type.dyn_cast<VectorType>())
     return vec.getElementType();
 
   // Look through tensor<vector<...>> to find the underlying element type.
   if (auto tensor = type.dyn_cast<TensorType>())
     return getTensorOrVectorElementType(tensor.getElementType());
   return type;
 }
 
-LogicalResult OpTrait::impl::verifyIsIdempotent(Operation *op) {
+LogicalResult OpTrait::impl::verifyIsIdempotent(Operation *) {
   // FIXME: Add back check for no side effects on operation.
   // Currently adding it would cause the shared library build
   // to fail since there would be a dependency of IR on SideEffectInterfaces
   // which is cyclical.
   return success();
 }
 
-LogicalResult OpTrait::impl::verifyIsInvolution(Operation *op) {
+LogicalResult OpTrait::impl::verifyIsInvolution(Operation *) {
   // FIXME: Add back check for no side effects on operation.
   // Currently adding it would cause the shared library build
   // to fail since there would be a dependency of IR on SideEffectInterfaces
   // which is cyclical.
   return success();
 }
 
 LogicalResult

 
 //===----------------------------------------------------------------------===//
 // BinaryOp implementation
 //===----------------------------------------------------------------------===//
 
 // These functions are out-of-line implementations of the methods in BinaryOp,
 // which avoids them being template instantiated/duplicated.
 
-void impl::buildBinaryOp(OpBuilder &builder, OperationState &result, Value lhs,
+void impl::buildBinaryOp(OpBuilder &, OperationState &result, Value lhs,
                          Value rhs) {
   assert(lhs.getType() == rhs.getType());
   result.addOperands({lhs, rhs});
   result.types.push_back(lhs.getType());
 }
 
 ParseResult impl::parseOneResultSameOperandTypeOp(OpAsmParser &parser,
                                                   OperationState &result) {

 }
 
 //===----------------------------------------------------------------------===//
 // CastOp implementation
 //===----------------------------------------------------------------------===//
 
 /// Attempt to fold the given cast operation.
 LogicalResult
-impl::foldCastInterfaceOp(Operation *op, ArrayRef<Attribute> attrOperands,
+impl::foldCastInterfaceOp(Operation *op, ArrayRef<Attribute>,
                           SmallVectorImpl<OpFoldResult> &foldResults) {
   OperandRange operands = op->getOperands();
   if (operands.empty())
     return failure();
   ResultRange results = op->getResults();
 
   // Check for the case where the input and output types match 1-1.
   if (operands.getTypes() == results.getTypes()) {
else
       diag << "s " << operandTypes;
     return diag << " and result type" << (resultTypes.size() == 1 ? " " : "s ")
                 << resultTypes << " are cast incompatible";
   }
 
   return success();
 }
 
-void impl::buildCastOp(OpBuilder &builder, OperationState &result, Value source,
+void impl::buildCastOp(OpBuilder &, OperationState &result, Value source,
                        Type destType) {
   result.addOperands(source);
   result.addTypes(destType);
 }
 
 ParseResult impl::parseCastOp(OpAsmParser &parser, OperationState &result) {
   OpAsmParser::OperandType srcInfo;
   Type srcType, dstType;

mlir/lib/IR/OperationSupport.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Operation Equivalency
 //===----------------------------------------------------------------------===//
 
 llvm::hash_code OperationEquivalence::computeHash(
     Operation *op, function_ref<llvm::hash_code(Value)> hashOperands,
-    function_ref<llvm::hash_code(Value)> hashResults, Flags flags) {
+    function_ref<llvm::hash_code(Value)> hashResults, Flags) {
   // Hash operations based upon their:
   //   - Operation Name
   //   - Attributes
   //   - Result Types
   llvm::hash_code hash = llvm::hash_combine(
       op->getName(), op->getAttrDictionary(), op->getResultTypes());
 
   //   - Operands

mlir/lib/IR/PatternMatch.cpp

 Pattern::Pattern(StringRef rootName, PatternBenefit benefit,
                  MLIRContext *context, ArrayRef<StringRef> generatedNames)
     : Pattern(OperationName(rootName, context).getAsOpaquePointer(),
               RootKind::OperationName, generatedNames, benefit, context) {}
 
 //===----------------------------------------------------------------------===//
 // MatchAnyOpTypeTag Root Constructors
 
-Pattern::Pattern(MatchAnyOpTypeTag tag, PatternBenefit benefit,
+Pattern::Pattern(MatchAnyOpTypeTag, PatternBenefit benefit,
                  MLIRContext *context, ArrayRef<StringRef> generatedNames)
     : Pattern(nullptr, RootKind::Any, generatedNames, benefit, context) {}
 
 //===----------------------------------------------------------------------===//
 // MatchInterfaceOpTypeTag Root Constructors
 
-Pattern::Pattern(MatchInterfaceOpTypeTag tag, TypeID interfaceID,
+Pattern::Pattern(MatchInterfaceOpTypeTag, TypeID interfaceID,
                  PatternBenefit benefit, MLIRContext *context,
                  ArrayRef<StringRef> generatedNames)
     : Pattern(interfaceID.getAsOpaquePointer(), RootKind::InterfaceID,
               generatedNames, benefit, context) {}
 
 //===----------------------------------------------------------------------===//
 // MatchTraitOpTypeTag Root Constructors
 
-Pattern::Pattern(MatchTraitOpTypeTag tag, TypeID traitID,
-                 PatternBenefit benefit, MLIRContext *context,
-                 ArrayRef<StringRef> generatedNames)
+Pattern::Pattern(MatchTraitOpTypeTag, TypeID traitID, PatternBenefit benefit,
+                 MLIRContext *context, ArrayRef<StringRef> generatedNames)
     : Pattern(traitID.getAsOpaquePointer(), RootKind::TraitID, generatedNames,
               benefit, context) {}
 
 //===----------------------------------------------------------------------===//
 // General Constructors
 
 Pattern::Pattern(const void *rootValue, RootKind rootKind,
                  ArrayRef<StringRef> generatedNames, PatternBenefit benefit,
                  MLIRContext *context)
     : rootValue(rootValue), rootKind(rootKind), benefit(benefit),
       contextAndHasBoundedRecursion(context, false) {
   if (generatedNames.empty())
     return;
   generatedOps.reserve(generatedNames.size());
   std::transform(generatedNames.begin(), generatedNames.end(),
                  std::back_inserter(generatedOps), [context](StringRef name) {
                    return OperationName(name, context);
                  });
 }
 
 //===----------------------------------------------------------------------===//
 // RewritePattern
 //===----------------------------------------------------------------------===//
 
-void RewritePattern::rewrite(Operation *op, PatternRewriter &rewriter) const {
+void RewritePattern::rewrite(Operation *, PatternRewriter &) const {
   llvm_unreachable("need to implement either matchAndRewrite or one of the "
                    "rewrite functions!");
 }
 
-LogicalResult RewritePattern::match(Operation *op) const {
+LogicalResult RewritePattern::match(Operation *) const {
   llvm_unreachable("need to implement either match or matchAndRewrite!");
 }
 
 /// Out-of-line vtable anchor.
 void RewritePattern::anchor() {}
 
 //===----------------------------------------------------------------------===//
 // PDLValue

mlir/lib/IR/SymbolTable.cpp

 // SymbolUserMap
 //===----------------------------------------------------------------------===//
 
 SymbolUserMap::SymbolUserMap(SymbolTableCollection &symbolTable,
                              Operation *symbolTableOp)
     : symbolTable(symbolTable) {
   // Walk each of the symbol tables looking for discardable callgraph nodes.
   SmallVector<Operation *> symbols;
-  auto walkFn = [&](Operation *symbolTableOp, bool allUsesVisible) {
+  auto walkFn = [&](Operation *symbolTableOp, bool) {
     for (Operation &nestedOp : symbolTableOp->getRegion(0).getOps()) {
       auto symbolUses = SymbolTable::getSymbolUses(&nestedOp);
       assert(symbolUses && "expected uses to be valid");
 
       for (const SymbolTable::SymbolUse &use : *symbolUses) {
         symbols.clear();
         (void)symbolTable.lookupSymbolIn(symbolTableOp, use.getSymbolRef(),
                                          symbols);

mlir/lib/Interfaces/ControlFlowInterfaces.cpp

for (Block &block : region) {
       // Found more than one ReturnLike terminator. Make sure the operand types
       // match with the first one.
       if (regionReturnOperands->getTypes() != terminatorOperands->getTypes())
         return op->emitOpError("Region #")
                << regionNo
                << " operands mismatch between return-like terminators";
     }
 
-    auto inputTypesFromRegion =
-        [&](Optional<unsigned> regionNo) -> Optional<TypeRange> {
+    auto inputTypesFromRegion = [&](Optional<unsigned>) -> Optional<TypeRange> {
       // If there is no return-like terminator, the op itself should verify
       // type consistency.
       if (!regionReturnOperands)
         return llvm::None;
 
       // All successors get the same set of operand types.
       return TypeRange(regionReturnOperands->getTypes());
     };

mlir/lib/Interfaces/ViewLikeInterface.cpp

if (val == dynVal)
       p << values[idx++];
     else
       p << val;
   });
   p << ']';
 }
 
 void mlir::printOperandsOrIntegersOffsetsOrStridesList(OpAsmPrinter &p,
-                                                       Operation *op,
+                                                       Operation *,
                                                        OperandRange values,
                                                        ArrayAttr integers) {
   return printOperandsOrIntegersListImpl<ShapedType::kDynamicStrideOrOffset>(
       p, values, integers);
 }
 
-void mlir::printOperandsOrIntegersSizesList(OpAsmPrinter &p, Operation *op,
+void mlir::printOperandsOrIntegersSizesList(OpAsmPrinter &p, Operation *,
                                             OperandRange values,
                                             ArrayAttr integers) {
   return printOperandsOrIntegersListImpl<ShapedType::kDynamicSize>(p, values,
                                                                    integers);
 }
 
 template <int64_t dynVal>
 static ParseResult

mlir/lib/Parser/AttributeParser.cpp

public:
   /// Build a dense attribute instance with the parsed elements and the given
   /// shaped type.
   DenseElementsAttr getAttr(llvm::SMLoc loc, ShapedType type);
 
   ArrayRef<int64_t> getShape() const { return shape; }
 
 private:
   /// Get the parsed elements for an integer attribute.
-  ParseResult getIntAttrElements(llvm::SMLoc loc, Type eltTy,
-                                 std::vector<APInt> &intValues);
+  ParseResult getIntAttrElements(Type eltTy, std::vector<APInt> &intValues);
 
   /// Get the parsed elements for a float attribute.
-  ParseResult getFloatAttrElements(llvm::SMLoc loc, FloatType eltTy,
+  ParseResult getFloatAttrElements(FloatType eltTy,
                                    std::vector<APFloat> &floatValues);
 
   /// Build a Dense String attribute for the given type.
-  DenseElementsAttr getStringAttr(llvm::SMLoc loc, ShapedType type, Type eltTy);
+  DenseElementsAttr getStringAttr(ShapedType type);
 
   /// Build a Dense attribute with hex data for the given type.
   DenseElementsAttr getHexAttr(llvm::SMLoc loc, ShapedType type);
 
   /// Parse a single element, returning failure if it isn't a valid element
   /// literal. For example:
   /// parseElement(1) -> Success, 1
   /// parseElement([1]) -> Failure
DenseElementsAttr TensorLiteralParser::getAttr(llvm::SMLoc loc,
   if (ComplexType complexTy = eltType.dyn_cast<ComplexType>()) {
     eltType = complexTy.getElementType();
     isComplex = true;
   }
 
   // Handle integer and index types.
   if (eltType.isIntOrIndex()) {
     std::vector<APInt> intValues;
-    if (failed(getIntAttrElements(loc, eltType, intValues)))
+    if (failed(getIntAttrElements(eltType, intValues)))
       return nullptr;
     if (isComplex) {
       // If this is a complex, treat the parsed values as complex values.
       auto complexData = llvm::makeArrayRef(
           reinterpret_cast<std::complex<APInt> *>(intValues.data()),
           intValues.size() / 2);
       return DenseElementsAttr::get(type, complexData);
     }
     return DenseElementsAttr::get(type, intValues);
   }
   // Handle floating point types.
   if (FloatType floatTy = eltType.dyn_cast<FloatType>()) {
     std::vector<APFloat> floatValues;
-    if (failed(getFloatAttrElements(loc, floatTy, floatValues)))
+    if (failed(getFloatAttrElements(floatTy, floatValues)))
       return nullptr;
     if (isComplex) {
       // If this is a complex, treat the parsed values as complex values.
       auto complexData = llvm::makeArrayRef(
           reinterpret_cast<std::complex<APFloat> *>(floatValues.data()),
           floatValues.size() / 2);
       return DenseElementsAttr::get(type, complexData);
     }
     return DenseElementsAttr::get(type, floatValues);
   }
 
   // Other types are assumed to be string representations.
-  return getStringAttr(loc, type, type.getElementType());
+  return getStringAttr(type);
 }
 
 /// Build a Dense Integer attribute for the given type.
 ParseResult
-TensorLiteralParser::getIntAttrElements(llvm::SMLoc loc, Type eltTy,
+TensorLiteralParser::getIntAttrElements(Type eltTy,
                                         std::vector<APInt> &intValues) {
   intValues.reserve(storage.size());
   bool isUintType = eltTy.isUnsignedInteger();
   for (const auto &signAndToken : storage) {
     bool isNegative = signAndToken.first;
     const Token &token = signAndToken.second;
     auto tokenLoc = token.getLoc();
 
if (!apInt)
       return p.emitError(tokenLoc, "integer constant out of range for type");
     intValues.push_back(*apInt);
   }
   return success();
 }
 
 /// Build a Dense Float attribute for the given type.
 ParseResult
-TensorLiteralParser::getFloatAttrElements(llvm::SMLoc loc, FloatType eltTy,
+TensorLiteralParser::getFloatAttrElements(FloatType eltTy,
                                           std::vector<APFloat> &floatValues) {
   floatValues.reserve(storage.size());
   for (const auto &signAndToken : storage) {
     bool isNegative = signAndToken.first;
     const Token &token = signAndToken.second;
 
     // Handle hexadecimal float literals.
     if (token.is(Token::integer) && token.getSpelling().startswith("0x")) {
if (!eltTy.isF64()) {
                     &unused);
     }
     floatValues.push_back(apVal);
   }
   return success();
 }
 
 /// Build a Dense String attribute for the given type.
-DenseElementsAttr TensorLiteralParser::getStringAttr(llvm::SMLoc loc,
-                                                     ShapedType type,
-                                                     Type eltTy) {
+DenseElementsAttr TensorLiteralParser::getStringAttr(ShapedType type) {
   if (hexStorage.hasValue()) {
     auto stringValue = hexStorage.getValue().getStringValue();
     return DenseStringElementsAttr::get(type, {stringValue});
   }
 
   std::vector<std::string> stringValues;
   std::vector<StringRef> stringRefValues;
   stringValues.reserve(storage.size());

mlir/lib/Pass/PassCrashRecovery.cpp

if (!isa<OpToOpPassAdaptor>(pass))
       generator.prepareReproducerFor(pass, op);
   }
 
   void runAfterPass(Pass *pass, Operation *op) override {
     if (!isa<OpToOpPassAdaptor>(pass))
       generator.removeLastReproducerFor(pass, op);
   }
 
-  void runAfterPassFailed(Pass *pass, Operation *op) override {
+  void runAfterPassFailed(Pass *, Operation *op) override {
     generator.finalize(op, /*executionResult=*/failure());
   }
 
 private:
   /// The generator used to create crash reproducers.
   PassCrashReproducerGenerator &generator;
 };
 } // namespace

mlir/lib/Pass/PassRegistry.cpp

if ((pm.getNesting() == OpPassManager::Nesting::Explicit) &&
                           pm.getOpName() + "', did you intend to nest?");
     pm.addPass(std::move(pass));
     return result;
   };
 }
 
 /// Utility to print the help string for a specific option.
 static void printOptionHelp(StringRef arg, StringRef desc, size_t indent,
-                            size_t descIndent, bool isTopLevel) {
+                            size_t descIndent) {
   size_t numSpaces = descIndent - indent - 4;
   llvm::outs().indent(indent)
       << "--" << llvm::left_justify(arg, numSpaces) << "-   " << desc << '\n';
 }
 
 //===----------------------------------------------------------------------===//
 // PassRegistry
 //===----------------------------------------------------------------------===//
 
 /// Print the help information for this pass. This includes the argument,
 /// description, and any pass options. `descIndent` is the indent that the
 /// descriptions should be aligned.
 void PassRegistryEntry::printHelpStr(size_t indent, size_t descIndent) const {
-  printOptionHelp(getPassArgument(), getPassDescription(), indent, descIndent,
-                  /*isTopLevel=*/true);
+  printOptionHelp(getPassArgument(), getPassDescription(), indent, descIndent);
   // If this entry has options, print the help for those as well.
   optHandler([=](const PassOptions &options) {
     options.printHelp(indent, descIndent);
   });
 }
 
 /// Return the maximum width required when printing the options of this
 /// entry.
if (opt.hasArgStr()) {
     opt.printHelpStr(opt.HelpStr, globalWidth, opt.ArgStr.size() + 7);
   } else {
     llvm::outs() << "  " << opt.HelpStr << '\n';
   }
 
   // Print the top-level pipeline argument.
   printOptionHelp(passPipelineArg,
                   "A textual description of a pass pipeline to run",
-                  /*indent=*/4, globalWidth, /*isTopLevel=*/!opt.hasArgStr());
+                  /*indent=*/4, globalWidth);
 
   // Functor used to print the ordered entries of a registration map.
   auto printOrderedEntries = [&](StringRef header, auto &map) {
     llvm::SmallVector<PassRegistryEntry *, 32> orderedEntries;
     for (auto &kv : map)
       orderedEntries.push_back(&kv.second);
     llvm::array_pod_sort(
         orderedEntries.begin(), orderedEntries.end(),

mlir/lib/Support/DebugCounter.cpp

 void DebugCounter::addCounter(StringRef actionTag, int64_t countToSkip,
                               int64_t countToStopAfter) {
   assert(!counters.count(actionTag) &&
          "a counter for the given action was already registered");
   counters.try_emplace(actionTag, countToSkip, countToStopAfter);
 }
 
 // Register a counter with the specified name.
-FailureOr<bool> DebugCounter::shouldExecute(StringRef tag,
-                                            StringRef description) {
+FailureOr<bool> DebugCounter::shouldExecute(StringRef tag, StringRef) {
   auto counterIt = counters.find(tag);
   if (counterIt == counters.end())
     return true;
 
   ++counterIt->second.count;
 
   // We only execute while the `countToSkip` is not smaller than `count`, and
   // `countToStopAfter + countToSkip` is larger than `count`. Negative counters

mlir/lib/Support/MlirOptMain.cpp

 using llvm::SMLoc;
 
 /// Perform the actions on the input file indicated by the command line flags
 /// within the specified context.
 ///
 /// This typically parses the main source file, runs zero or more optimization
 /// passes, then prints the output.
 ///
-static LogicalResult performActions(raw_ostream &os, bool verifyDiagnostics,
-                                    bool verifyPasses, SourceMgr &sourceMgr,
-                                    MLIRContext *context,
+static LogicalResult performActions(raw_ostream &os, bool verifyPasses,
+                                    SourceMgr &sourceMgr, MLIRContext *context,
                                     PassPipelineFn passManagerSetupFn) {
   DefaultTimingManager tm;
   applyDefaultTimingManagerCLOptions(tm);
   TimingScope timing = tm.getRootScope();
 
   // Disable multi-threading when parsing the input file. This removes the
   // unnecessary/costly context synchronization when parsing.
   bool wasThreadingEnabled = context->isMultithreadingEnabled();
processBuffer(raw_ostream &os, std::unique_ptr<MemoryBuffer> ownedBuffer,
   if (verifyDiagnostics)
     context.printOpOnDiagnostic(false);
   context.getDebugActionManager().registerActionHandler<DebugCounter>();
 
   // If we are in verify diagnostics mode then we have a lot of work to do,
   // otherwise just perform the actions without worrying about it.
   if (!verifyDiagnostics) {
     SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &context);
-    return performActions(os, verifyDiagnostics, verifyPasses, sourceMgr,
-                          &context, passManagerSetupFn);
+    return performActions(os, verifyPasses, sourceMgr, &context,
+                          passManagerSetupFn);
   }
 
   SourceMgrDiagnosticVerifierHandler sourceMgrHandler(sourceMgr, &context);
 
   // Do any processing requested by command line flags.  We don't care whether
   // these actions succeed or fail, we only care what diagnostics they produce
   // and whether they match our expectations.
-  (void)performActions(os, verifyDiagnostics, verifyPasses, sourceMgr, &context,
+  (void)performActions(os, verifyPasses, sourceMgr, &context,
                        passManagerSetupFn);
 
   // Verify the diagnostic handler to make sure that each of the diagnostics
   // matched.
   return sourceMgrHandler.verify();
 }
 
 LogicalResult mlir::MlirOptMain(raw_ostream &outputStream,

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

auto bodyGenCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP,
     convertOmpOpRegions(region, "omp.par.region", *codeGenIP.getBlock(),
                         continuationBlock, builder, moduleTranslation,
                         bodyGenStatus);
   };
 
   // TODO: Perform appropriate actions according to the data-sharing
   // attribute (shared, private, firstprivate, ...) of variables.
   // Currently defaults to shared.
-  auto privCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP,
-                    llvm::Value &, llvm::Value &vPtr,
+  auto privCB = [&](InsertPointTy, InsertPointTy codeGenIP, llvm::Value &,
+                    llvm::Value &vPtr,
                     llvm::Value *&replacementValue) -> InsertPointTy {
     replacementValue = &vPtr;
 
     return codeGenIP;
   };
 
   // TODO: Perform finalization actions for variables. This has to be
   // called for variables which have destructors/finalizers.

 static LogicalResult
 convertOmpMaster(Operation &opInst, llvm::IRBuilderBase &builder,
                  LLVM::ModuleTranslation &moduleTranslation) {
   using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
   // TODO: support error propagation in OpenMPIRBuilder and use it instead of
   // relying on captured variables.
   LogicalResult bodyGenStatus = success();
 
-  auto bodyGenCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP,
+  auto bodyGenCB = [&](InsertPointTy, InsertPointTy codeGenIP,
                        llvm::BasicBlock &continuationBlock) {
     // MasterOp has only one region associated with it.
     auto &region = cast<omp::MasterOp>(opInst).getRegion();
     convertOmpOpRegions(region, "omp.master.region", *codeGenIP.getBlock(),
                         continuationBlock, builder, moduleTranslation,
                         bodyGenStatus);
   };
 

 convertOmpCritical(Operation &opInst, llvm::IRBuilderBase &builder,
                    LLVM::ModuleTranslation &moduleTranslation) {
   using InsertPointTy = llvm::OpenMPIRBuilder::InsertPointTy;
   auto criticalOp = cast<omp::CriticalOp>(opInst);
   // TODO: support error propagation in OpenMPIRBuilder and use it instead of
   // relying on captured variables.
   LogicalResult bodyGenStatus = success();
 
-  auto bodyGenCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP,
+  auto bodyGenCB = [&](InsertPointTy, InsertPointTy codeGenIP,
                        llvm::BasicBlock &continuationBlock) {
     // CriticalOp has only one region associated with it.
     auto &region = cast<omp::CriticalOp>(opInst).getRegion();
     convertOmpOpRegions(region, "omp.critical.region", *codeGenIP.getBlock(),
                         continuationBlock, builder, moduleTranslation,
                         bodyGenStatus);
   };
 
convertOmpOrderedRegion(Operation &opInst, llvm::IRBuilderBase &builder,
   // TODO: The code generation for ordered simd directive is not supported yet.
   if (orderedRegionOp.simd())
     return failure();
 
   // TODO: support error propagation in OpenMPIRBuilder and use it instead of
   // relying on captured variables.
   LogicalResult bodyGenStatus = success();
 
-  auto bodyGenCB = [&](InsertPointTy allocaIP, InsertPointTy codeGenIP,
+  auto bodyGenCB = [&](InsertPointTy, InsertPointTy codeGenIP,
                        llvm::BasicBlock &continuationBlock) {
     // OrderedOp has only one region associated with it.
     auto &region = cast<omp::OrderedRegionOp>(opInst).getRegion();
     convertOmpOpRegions(region, "omp.ordered.region", *codeGenIP.getBlock(),
                         continuationBlock, builder, moduleTranslation,
                         bodyGenStatus);
   };
 
convertOmpSections(Operation &opInst, llvm::IRBuilderBase &builder,
   SmallVector<StorableBodyGenCallbackTy> sectionCBs;
 
   for (Operation &op : *sectionsOp.region().begin()) {
     auto sectionOp = dyn_cast<omp::SectionOp>(op);
     if (!sectionOp) // omp.terminator
       continue;
 
     Region &region = sectionOp.region();
-    auto sectionCB = [&region, &builder, &moduleTranslation, &bodyGenStatus](
-                         InsertPointTy allocaIP, InsertPointTy codeGenIP,
+    auto sectionCB = [&region, &builder, &moduleTranslation,
+                      &bodyGenStatus](InsertPointTy, InsertPointTy codeGenIP,
                                       llvm::BasicBlock &finiBB) {
       builder.restoreIP(codeGenIP);
       builder.CreateBr(&finiBB);
       convertOmpOpRegions(region, "omp.section.region", *codeGenIP.getBlock(),
                           finiBB, builder, moduleTranslation, bodyGenStatus);
     };
     sectionCBs.push_back(sectionCB);
   }
 
return llvm::TypeSwitch<Operation *, LogicalResult>(op)
       })
       .Case([&](omp::AtomicReadOp) {
         return convertOmpAtomicRead(*op, builder, moduleTranslation);
       })
       .Case([&](omp::SectionsOp) {
         return convertOmpSections(*op, builder, moduleTranslation);
       })
       .Case<omp::YieldOp, omp::TerminatorOp, omp::ReductionDeclareOp,
-            omp::CriticalDeclareOp>([](auto op) {
+            omp::CriticalDeclareOp>([](auto) {
         // `yield` and `terminator` can be just omitted. The block structure
         // was created in the region that handles their parent operation.
         // `reduction.declare` will be used by reductions and is not
         // converted directly, skip it.
         // `critical.declare` is only used to declare names of critical
         // sections which will be used by `critical` ops and hence can be
         // ignored for lowering. The OpenMP IRBuilder will create unique
         // name for critical section names.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

for (Block &block : *current) {
             llvm::map_range(op.getRegions(), [](Region &r) { return &r; }));
       }
     }
   }
 }
 
 /// Get the SSA value passed to the current block from the terminator operation
 /// of its predecessor.
-static Value getPHISourceValue(Block *current, Block *pred,
-                               unsigned numArguments, unsigned index) {
+static Value getPHISourceValue(Block *current, Block *pred, unsigned index) {
   Operation &terminator = *pred->getTerminator();
   if (isa<LLVM::BrOp>(terminator))
     return terminator.getOperand(index);
 
   SuccessorRange successors = terminator.getSuccessors();
   assert(std::adjacent_find(successors.begin(), successors.end()) ==
              successors.end() &&
          "successors with arguments in LLVM branches must be different blocks");
for (auto &numberedPhiNode : llvm::enumerate(phis)) {
         // instruction and use it in the PHI node. Note that this block is not
         // necessarily the same as state.lookupBlock(pred), some operations
         // (in particular, OpenMP operations using OpenMPIRBuilder) may have
         // split the blocks.
         llvm::Instruction *terminator =
             state.lookupBranch(pred->getTerminator());
         assert(terminator && "missing the mapping for a terminator");
         phiNode.addIncoming(
-            state.lookupValue(getPHISourceValue(bb, pred, numArguments, index)),
+            state.lookupValue(getPHISourceValue(bb, pred, index)),
             terminator->getParent());
       }
     }
   }
 }
 
 /// Sort function blocks topologically.
 SetVector<Block *>

mlir/lib/Target/LLVMIR/TypeToLLVM.cpp

llvm::Type *translated =
             .Case([this](LLVM::LLVMMetadataType) {
               return llvm::Type::getMetadataTy(context);
             })
             .Case<LLVM::LLVMArrayType, IntegerType, LLVM::LLVMFunctionType,
                   LLVM::LLVMPointerType, LLVM::LLVMStructType,
                   LLVM::LLVMFixedVectorType, LLVM::LLVMScalableVectorType,
                   VectorType>(
                 [this](auto type) { return this->translate(type); })
-            .Default([](Type t) -> llvm::Type * {
+            .Default([](Type) -> llvm::Type * {
               llvm_unreachable("unknown LLVM dialect type");
             });
 
     // Cache the result of the conversion and return.
     knownTranslations.try_emplace(type, translated);
     return translated;
   }
 

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

std::string spirv::Deserializer::getSpecConstantSymbol(uint32_t id) {
   auto constName = nameMap.lookup(id).str();
   if (constName.empty()) {
     constName = "spirv_spec_const_" + std::to_string(id);
   }
   return constName;
 }
 
 spirv::SpecConstantOp
-spirv::Deserializer::createSpecConstant(Location loc, uint32_t resultID,
+spirv::Deserializer::createSpecConstant(Location, uint32_t resultID,
                                         Attribute defaultValue) {
   auto symName = opBuilder.getStringAttr(getSpecConstantSymbol(resultID));
   auto op = opBuilder.create<spirv::SpecConstantOp>(unknownLoc, symName,
                                                     defaultValue);
   if (decorations.count(resultID)) {
     for (auto attr : decorations[resultID].getAttrs())
       op->setAttr(attr.getName(), attr.getValue());
   }
spirv::Deserializer::processSpecConstantOperation(ArrayRef<uint32_t> operands) {
   if (!emplaceResult.second)
     return emitError(unknownLoc, "value with <id>: ")
            << resultID << " is probably defined before.";
 
   return success();
 }
 
 Value spirv::Deserializer::materializeSpecConstantOperation(
-    uint32_t resultID, spirv::Opcode enclosedOpcode, uint32_t resultTypeID,
+    uint32_t, spirv::Opcode enclosedOpcode, uint32_t resultTypeID,
     ArrayRef<uint32_t> enclosedOpOperands) {
 
   Type resultType = getType(resultTypeID);
 
   // Instructions wrapped by OpSpecConstantOp need an ID for their
   // Deserializer::processOp<op_name>(...) to emit the corresponding SPIR-V
   // dialect wrapped op. For that purpose, a new value map is created and "fake"
   // ID in that map is assigned to the result of the enclosed instruction. Note

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

LogicalResult Serializer::processName(uint32_t resultID, StringRef name) {
   nameOperands.push_back(resultID);
   spirv::encodeStringLiteralInto(nameOperands, name);
   encodeInstructionInto(names, spirv::Opcode::OpName, nameOperands);
   return success();
 }
 
 template <>
 LogicalResult Serializer::processTypeDecoration<spirv::ArrayType>(
-    Location loc, spirv::ArrayType type, uint32_t resultID) {
+    Location, spirv::ArrayType type, uint32_t resultID) {
   if (unsigned stride = type.getArrayStride()) {
     // OpDecorate %arrayTypeSSA ArrayStride strideLiteral
     return emitDecoration(resultID, spirv::Decoration::ArrayStride, {stride});
   }
   return success();
 }
 
 template <>
 LogicalResult Serializer::processTypeDecoration<spirv::RuntimeArrayType>(
-    Location loc, spirv::RuntimeArrayType type, uint32_t resultID) {
+    Location, spirv::RuntimeArrayType type, uint32_t resultID) {
   if (unsigned stride = type.getArrayStride()) {
     // OpDecorate %arrayTypeSSA ArrayStride strideLiteral
     return emitDecoration(resultID, spirv::Decoration::ArrayStride, {stride});
   }
   return success();
 }
 
 LogicalResult Serializer::processMemberDecoration(

mlir/lib/Tools/PDLL/Parser/Parser.cpp

private:
   FailureOr<ast::Expr *> parseTypeConstraintExpr();
 
   /// Try to parse a single reference to a constraint. `typeConstraint` is the
   /// location of a previously parsed type constraint for the entity that will
   /// be constrained by the parsed constraint. `existingConstraints` are any
   /// existing constraints that have already been parsed for the same entity
   /// that will be constrained by this constraint.
   FailureOr<ast::ConstraintRef>
-  parseConstraint(Optional<llvm::SMRange> &typeConstraint,
-                  ArrayRef<ast::ConstraintRef> existingConstraints);
+  parseConstraint(Optional<llvm::SMRange> &typeConstraint);
 
   //===--------------------------------------------------------------------===//
   // Exprs
 
   FailureOr<ast::Expr *> parseExpr();
 
   /// Identifier expressions.
   FailureOr<ast::Expr *> parseAttributeExpr();
createOperationExpr(llvm::SMRange loc, const ast::OpNameDecl *name,
                       MutableArrayRef<ast::Expr *> results);
   LogicalResult
   validateOperationOperands(llvm::SMRange loc, Optional<StringRef> name,
                             MutableArrayRef<ast::Expr *> operands);
   LogicalResult validateOperationResults(llvm::SMRange loc,
                                          Optional<StringRef> name,
                                          MutableArrayRef<ast::Expr *> results);
   LogicalResult
-  validateOperationOperandsOrResults(llvm::SMRange loc,
-                                     Optional<StringRef> name,
-                                     MutableArrayRef<ast::Expr *> values,
+  validateOperationOperandsOrResults(MutableArrayRef<ast::Expr *> values,
                                      ast::Type singleTy, ast::Type rangeTy);
   FailureOr<ast::TupleExpr *> createTupleExpr(llvm::SMRange loc,
                                               ArrayRef<ast::Expr *> elements,
                                               ArrayRef<StringRef> elementNames);
 
   //===--------------------------------------------------------------------===//
   // Stmts
 
Parser::defineVariableDecl(StringRef name, llvm::SMRange nameLoc,
   return defineVariableDecl(name, nameLoc, type, /*initExpr=*/nullptr,
                             constraints);
 }
 
 LogicalResult Parser::parseVariableDeclConstraintList(
     SmallVectorImpl<ast::ConstraintRef> &constraints) {
   Optional<llvm::SMRange> typeConstraint;
   auto parseSingleConstraint = [&] {
-    FailureOr<ast::ConstraintRef> constraint =
-        parseConstraint(typeConstraint, constraints);
+    FailureOr<ast::ConstraintRef> constraint = parseConstraint(typeConstraint);
     if (failed(constraint))
       return failure();
     constraints.push_back(*constraint);
     return success();
   };
 
   // Check to see if this is a single constraint, or a list.
   if (!consumeIf(Token::l_square))
     return parseSingleConstraint();
 
   do {
     if (failed(parseSingleConstraint()))
       return failure();
   } while (consumeIf(Token::comma));
   return parseToken(Token::r_square, "expected `]` after constraint list");
 }
 
 FailureOr<ast::ConstraintRef>
-Parser::parseConstraint(Optional<llvm::SMRange> &typeConstraint,
-                        ArrayRef<ast::ConstraintRef> existingConstraints) {
+Parser::parseConstraint(Optional<llvm::SMRange> &typeConstraint) {
   auto parseTypeConstraint = [&](ast::Expr *&typeExpr) -> LogicalResult {
     if (typeConstraint)
       return emitErrorAndNote(
           curToken.getLoc(),
           "the type of this variable has already been constrained",
           *typeConstraint, "see previous constraint location here");
     FailureOr<ast::Expr *> constraintExpr = parseTypeConstraintExpr();
     if (failed(constraintExpr))
FailureOr<ast::OperationExpr *> Parser::createOperationExpr(
 
   return ast::OperationExpr::create(ctx, loc, name, operands, results,
                                     attributes);
 }
 
 LogicalResult
 Parser::validateOperationOperands(llvm::SMRange loc, Optional<StringRef> name,
                                   MutableArrayRef<ast::Expr *> operands) {
-  return validateOperationOperandsOrResults(loc, name, operands, valueTy,
-                                            valueRangeTy);
+  return validateOperationOperandsOrResults(operands, valueTy, valueRangeTy);
 }
 
 LogicalResult
 Parser::validateOperationResults(llvm::SMRange loc, Optional<StringRef> name,
                                  MutableArrayRef<ast::Expr *> results) {
-  return validateOperationOperandsOrResults(loc, name, results, typeTy,
-                                            typeRangeTy);
+  return validateOperationOperandsOrResults(results, typeTy, typeRangeTy);
 }
 
-LogicalResult Parser::validateOperationOperandsOrResults(
-    llvm::SMRange loc, Optional<StringRef> name,
-    MutableArrayRef<ast::Expr *> values, ast::Type singleTy,
+LogicalResult
+Parser::validateOperationOperandsOrResults(MutableArrayRef<ast::Expr *> values,
+                                           ast::Type singleTy,
                                            ast::Type rangeTy) {
   // All operation types accept a single range parameter.
   if (values.size() == 1) {
     if (failed(convertExpressionTo(values[0], rangeTy)))
       return failure();
     return success();
   }
 
   // Otherwise, accept the value groups as they have been defined and just

mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp

void getLocationsOf(const lsp::URIForFile &uri, const lsp::Position &defPos,
                       std::vector<lsp::Location> &locations);
   void findReferencesOf(const lsp::URIForFile &uri, const lsp::Position &pos,
                         std::vector<lsp::Location> &references);
 
   //===--------------------------------------------------------------------===//
   // Hover
   //===--------------------------------------------------------------------===//
 
-  Optional<lsp::Hover> findHover(const lsp::URIForFile &uri,
-                                 const lsp::Position &hoverPos);
+  Optional<lsp::Hover> findHover(const lsp::Position &hoverPos);
   Optional<lsp::Hover>
   buildHoverForOperation(llvm::SMRange hoverRange,
                          const AsmParserState::OperationDefinition &op);
   lsp::Hover buildHoverForOperationResult(llvm::SMRange hoverRange,
                                           Operation *op, unsigned resultStart,
                                           unsigned resultEnd,
                                           llvm::SMLoc posLoc);
   lsp::Hover buildHoverForBlock(llvm::SMRange hoverRange,
for (const AsmParserState::SMDefinition &arg : block.arguments)
         return appendSMDef(arg);
   }
 }
 
 //===----------------------------------------------------------------------===//
 // MLIRDocument: Hover
 //===----------------------------------------------------------------------===//
 
-Optional<lsp::Hover> MLIRDocument::findHover(const lsp::URIForFile &uri,
-                                             const lsp::Position &hoverPos) {
+Optional<lsp::Hover> MLIRDocument::findHover(const lsp::Position &hoverPos) {
   llvm::SMLoc posLoc = getPosFromLoc(sourceMgr, hoverPos);
   llvm::SMRange hoverRange;
 
   // Check for Hovers on operations and results.
   for (const AsmParserState::OperationDefinition &op : asmState.getOpDefs()) {
     // Check if the position points at this operation.
     if (contains(op.loc, posLoc))
       return buildHoverForOperation(op.loc, op);
void MLIRTextFile::findReferencesOf(const lsp::URIForFile &uri,
   for (lsp::Location &loc : references)
     if (loc.uri == uri)
       chunk.adjustLocForChunkOffset(loc.range);
 }
 
 Optional<lsp::Hover> MLIRTextFile::findHover(const lsp::URIForFile &uri,
                                              lsp::Position hoverPos) {
   MLIRTextFileChunk &chunk = getChunkFor(hoverPos);
-  Optional<lsp::Hover> hoverInfo = chunk.document.findHover(uri, hoverPos);
+  Optional<lsp::Hover> hoverInfo = chunk.document.findHover(hoverPos);
 
   // Adjust any locations within this file for the offset of this chunk.
   if (chunk.lineOffset != 0 && hoverInfo && hoverInfo->range)
     chunk.adjustLocForChunkOffset(*hoverInfo->range);
   return hoverInfo;
 }
 
 void MLIRTextFile::findDocumentSymbols(

mlir/lib/Tools/mlir-lsp-server/lsp/Logging.cpp

 
 void Logger::setLogLevel(Level logLevel) { get().logLevel = logLevel; }
 
 Logger &Logger::get() {
   static Logger logger;
   return logger;
 }
 
-void Logger::log(Level logLevel, const char *fmt,
+void Logger::log(Level logLevel, const char *,
                  const llvm::formatv_object_base &message) {
   Logger &logger = get();
 
   // Ignore messages with log levels below the current setting in the logger.
   if (logLevel < logger.logLevel)
     return;
 
   // An indicator character for each log level.

mlir/lib/Tools/mlir-lsp-server/lsp/Protocol.cpp

bool mlir::lsp::fromJSON(const llvm::json::Value &value,
   return true;
 }
 
 //===----------------------------------------------------------------------===//
 // InitializeParams
 //===----------------------------------------------------------------------===//
 
 bool mlir::lsp::fromJSON(const llvm::json::Value &value, TraceLevel &result,
-                         llvm::json::Path path) {
+                         llvm::json::Path) {
   if (Optional<StringRef> str = value.getAsString()) {
     if (*str == "off") {
       result = TraceLevel::Off;
       return true;
     }
     if (*str == "messages") {
       result = TraceLevel::Messages;
       return true;

mlir/lib/Transforms/BufferOptimizations.cpp

PromoteBuffersToStackPass(unsigned maxAllocSizeInBytes,
     this->maxAllocSizeInBytes = maxAllocSizeInBytes;
     this->bitwidthOfIndexType = bitwidthOfIndexType;
     this->maxRankOfAllocatedMemRef = maxRankOfAllocatedMemRef;
   }
 
   explicit PromoteBuffersToStackPass(std::function<bool(Value)> isSmallAlloc)
       : isSmallAlloc(std::move(isSmallAlloc)) {}
 
-  LogicalResult initialize(MLIRContext *context) override {
+  LogicalResult initialize(MLIRContext *) override {
     if (isSmallAlloc == nullptr) {
       isSmallAlloc = [=](Value alloc) {
         return defaultIsSmallAlloc(alloc, maxAllocSizeInBytes,
                                    bitwidthOfIndexType,
                                    maxRankOfAllocatedMemRef);
       };
     }
     return success();

mlir/lib/Transforms/Inliner.cpp

CGUseList::CGUseList(Operation *op, CallGraph &cg,
   // Compute the uses for each of the callable nodes in the graph.
   for (CallGraphNode *node : cg)
     recomputeUses(node, cg);
 }
 
 void CGUseList::dropCallUses(CallGraphNode *userNode, Operation *callOp,
                              CallGraph &cg) {
   auto &userRefs = nodeUses[userNode].innerUses;
-  auto walkFn = [&](CallGraphNode *node, Operation *user) {
+  auto walkFn = [&](CallGraphNode *node, Operation *) {
     auto parentIt = userRefs.find(node);
     if (parentIt == userRefs.end())
       return;
     --parentIt->second;
     --discardableSymNodeUses[node];
   };
   DenseMap<Attribute, CallGraphNode *> resolvedRefs;
   walkReferencedSymbolNodes(callOp, cg, symbolTable, resolvedRefs, walkFn);

mlir/lib/Transforms/Utils/DialectConversion.cpp

struct ArgConverter {
   /// Fully replace uses of the old arguments with the new.
   void applyRewrites(ConversionValueMapping &mapping);
 
   /// Materialize any necessary conversions for converted arguments that have
   /// live users, using the provided `findLiveUser` to search for a user that
   /// survives the conversion process.
   LogicalResult
   materializeLiveConversions(ConversionValueMapping &mapping,
-                             OpBuilder &builder,
                              function_ref<Operation *(Value)> findLiveUser);
 
   //===--------------------------------------------------------------------===//
   // Conversion
   //===--------------------------------------------------------------------===//
 
   /// Attempt to convert the signature of the given block, if successful a new
   /// block is returned containing the new arguments. Returns `block` if it did
for (unsigned i = 0, e = origBlock->getNumArguments(); i != e; ++i) {
         origArg.replaceAllUsesWith(
             mapping.lookupOrDefault(castValue, origArg.getType()));
       }
     }
   }
 }
 
 LogicalResult ArgConverter::materializeLiveConversions(
-    ConversionValueMapping &mapping, OpBuilder &builder,
+    ConversionValueMapping &mapping,
     function_ref<Operation *(Value)> findLiveUser) {
   for (auto &info : conversionInfo) {
     Block *newBlock = info.first;
     ConvertedBlockInfo &blockInfo = info.second;
     Block *origBlock = blockInfo.origBlock;
 
     // Process the remapping for each of the original arguments.
     for (unsigned i = 0, e = origBlock->getNumArguments(); i != e; ++i) {
case BlockActionKind::TypeConversion: {
       break;
     }
     }
   }
   blockActions.resize(numActionsToKeep);
 }
 
 LogicalResult ConversionPatternRewriterImpl::remapValues(
-    StringRef valueDiagTag, Optional<Location> inputLoc,
-    PatternRewriter &rewriter, ValueRange values,
-    SmallVectorImpl<Value> &remapped) {
+    StringRef valueDiagTag, Optional<Location> inputLoc, PatternRewriter &,
+    ValueRange values, SmallVectorImpl<Value> &remapped) {
   remapped.reserve(llvm::size(values));
 
   SmallVector<Type, 1> legalTypes;
   for (const auto &it : llvm::enumerate(values)) {
     Value operand = it.value();
     Type origType = operand.getType();
 
     // If a converter was provided, get the desired legal types for this

 }
 
 void ConversionPatternRewriterImpl::notifyBlocksBeingMerged(Block *block,
                                                             Block *srcBlock) {
   blockActions.push_back(BlockAction::getMerge(block, srcBlock));
 }
 
 void ConversionPatternRewriterImpl::notifyRegionIsBeingInlinedBefore(
-    Region &region, Region &parent, Region::iterator before) {
+    Region &region, Region &, Region::iterator) {
   if (region.empty())
     return;
   Block *laterBlock = &region.back();
   for (auto &earlierBlock : llvm::drop_begin(llvm::reverse(region), 1)) {
     blockActions.push_back(
         BlockAction::getMove(laterBlock, {&region, &earlierBlock}));
     laterBlock = &earlierBlock;
   }

 //===----------------------------------------------------------------------===//
 
 ConversionPatternRewriter::ConversionPatternRewriter(MLIRContext *ctx)
     : PatternRewriter(ctx),
       impl(new detail::ConversionPatternRewriterImpl(*this)) {}
 ConversionPatternRewriter::~ConversionPatternRewriter() = default;
 
 void ConversionPatternRewriter::replaceOpWithIf(
-    Operation *op, ValueRange newValues, bool *allUsesReplaced,
-    llvm::unique_function<bool(OpOperand &) const> functor) {
+    Operation *, ValueRange, bool *,
+    llvm::unique_function<bool(OpOperand &) const>) {
   // TODO: To support this we will need to rework a bit of how replacements are
   // tracked, given that this isn't guranteed to replace all of the uses of an
   // operation. The main change is that now an operation can be replaced
   // multiple times, in parts. The current "set" based tracking is mainly useful
   // for tracking if a replaced operation should be ignored, i.e. if all of the
   // uses will be replaced.
   llvm_unreachable(
       "replaceOpWithIf is currently not supported by DialectConversion");
LogicalResult legalizeWithPattern(Operation *op,
                                     ConversionPatternRewriter &rewriter);
 
   /// Return true if the given pattern may be applied to the given operation,
   /// false otherwise.
   bool canApplyPattern(Operation *op, const Pattern &pattern,
                        ConversionPatternRewriter &rewriter);
 
   /// Legalize the resultant IR after successfully applying the given pattern.
-  LogicalResult legalizePatternResult(Operation *op, const Pattern &pattern,
+  LogicalResult legalizePatternResult(Operation *op,
                                       ConversionPatternRewriter &rewriter,
                                       RewriterState &curState);
 
   /// Legalizes the actions registered during the execution of a pattern.
   LogicalResult legalizePatternBlockActions(Operation *op,
                                             ConversionPatternRewriter &rewriter,
                                             ConversionPatternRewriterImpl &impl,
                                             RewriterState &state,
auto onFailure = [&](const Pattern &pattern) {
     });
     rewriterImpl.resetState(curState);
     appliedPatterns.erase(&pattern);
   };
 
   // Functor that performs additional legalization when a pattern is
   // successfully applied.
   auto onSuccess = [&](const Pattern &pattern) {
-    auto result = legalizePatternResult(op, pattern, rewriter, curState);
+    auto result = legalizePatternResult(op, rewriter, curState);
     appliedPatterns.erase(&pattern);
     if (failed(result))
       rewriterImpl.resetState(curState);
     return result;
   };
 
   // Try to match and rewrite a pattern on this operation.
   return applicator.matchAndRewrite(op, rewriter, canApply, onFailure,
if (!pattern.hasBoundedRewriteRecursion() &&
     LLVM_DEBUG(
         logFailure(rewriter.getImpl().logger, "pattern was already applied"));
     return false;
   }
   return true;
 }
 
 LogicalResult
-OperationLegalizer::legalizePatternResult(Operation *op, const Pattern &pattern,
+OperationLegalizer::legalizePatternResult(Operation *op,
                                           ConversionPatternRewriter &rewriter,
                                           RewriterState &curState) {
   auto &impl = rewriter.getImpl();
 
 #ifndef NDEBUG
   assert(impl.pendingRootUpdates.empty() && "dangling root updates");
 #endif
 
LogicalResult OperationConverter::legalizeConvertedArgumentTypes(
   // conversion.
   auto findLiveUser = [&](Value val) {
     auto liveUserIt = llvm::find_if_not(val.getUsers(), [&](Operation *user) {
       return rewriterImpl.isOpIgnored(user);
     });
     return liveUserIt == val.user_end() ? nullptr : *liveUserIt;
   };
   return rewriterImpl.argConverter.materializeLiveConversions(
-      rewriterImpl.mapping, rewriter, findLiveUser);
+      rewriterImpl.mapping, findLiveUser);
 }
 
 /// Replace the results of a materialization operation with the given values.
 static void
 replaceMaterialization(ConversionPatternRewriterImpl &rewriterImpl,
                        ResultRange matResults, ValueRange values,
                        DenseMap<Value, SmallVector<Value>> &inverseMapping) {
   matResults.replaceAllUsesWith(values);
for (Value inverseMapVal : inverseMapIt->second)
         rewriterImpl.mapping.erase(inverseMapVal);
   }
 }
 
 /// Compute all of the unresolved materializations that will persist beyond the
 /// conversion process, and require inserting a proper user materialization for.
 static void computeNecessaryMaterializations(
     DenseMap<Operation *, UnresolvedMaterialization *> &materializationOps,
-    ConversionPatternRewriter &rewriter,
     ConversionPatternRewriterImpl &rewriterImpl,
     DenseMap<Value, SmallVector<Value>> &inverseMapping,
     SetVector<UnresolvedMaterialization *> &necessaryMaterializations) {
   auto isLive = [&](Value value) {
     auto findFn = [&](Operation *user) {
       auto matIt = materializationOps.find(user);
       if (matIt != materializationOps.end())
         return !necessaryMaterializations.count(matIt->second);
LogicalResult OperationConverter::legalizeUnresolvedMaterializations(
   if (rewriterImpl.unresolvedMaterializations.empty())
     return success();
   inverseMapping = rewriterImpl.mapping.getInverse();
 
   // As an initial step, compute all of the inserted materializations that we
   // expect to persist beyond the conversion process.
   DenseMap<Operation *, UnresolvedMaterialization *> materializationOps;
   SetVector<UnresolvedMaterialization *> necessaryMaterializations;
-  computeNecessaryMaterializations(materializationOps, rewriter, rewriterImpl,
+  computeNecessaryMaterializations(materializationOps, rewriterImpl,
                                    *inverseMapping, necessaryMaterializations);
 
   // Once computed, legalize any necessary materializations.
   for (auto *mat : necessaryMaterializations) {
     if (failed(legalizeUnresolvedMaterialization(
             *mat, materializationOps, rewriter, rewriterImpl, *inverseMapping)))
       return failure();
   }

 namespace {
 struct FunctionLikeSignatureConversion : public ConversionPattern {
   FunctionLikeSignatureConversion(StringRef functionLikeOpName,
                                   MLIRContext *ctx, TypeConverter &converter)
       : ConversionPattern(converter, functionLikeOpName, /*benefit=*/1, ctx) {}
 
   /// Hook to implement combined matching and rewriting for FunctionLike ops.
   LogicalResult
-  matchAndRewrite(Operation *op, ArrayRef<Value> operands,
+  matchAndRewrite(Operation *op, ArrayRef<Value>,
                   ConversionPatternRewriter &rewriter) const override {
     FunctionType type = function_like_impl::getFunctionType(op);
 
     // Convert the original function types.
     TypeConverter::SignatureConversion result(type.getNumInputs());
     SmallVector<Type, 1> newResults;
     if (failed(typeConverter->convertSignatureArgs(type.getInputs(), result)) ||
         failed(typeConverter->convertTypes(type.getResults(), newResults)) ||

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp

#ifndef NDEBUG
           logger.startLine() << "* Pattern " << pattern.getDebugName() << " : '"
                              << op->getName() << " -> (";
           llvm::interleaveComma(pattern.getGeneratedOps(), logger.getOStream());
           logger.getOStream() << ")' {\n";
           logger.indent();
         });
         return true;
       };
-      auto onFailure = [&](const Pattern &pattern) {
+      auto onFailure = [&](const Pattern &) {
         LLVM_DEBUG(logResult("failure", "pattern failed to match"));
       };
-      auto onSuccess = [&](const Pattern &pattern) {
+      auto onSuccess = [&](const Pattern &) {
         LLVM_DEBUG(logResult("success", "pattern applied successfully"));
         return success();
       };
 
       LogicalResult matchResult =
           matcher.matchAndRewrite(op, *this, canApply, onFailure, onSuccess);
       if (succeeded(matchResult))
         LLVM_DEBUG(logResultWithLine("success", "pattern matched"));
public:
   }
 
   LogicalResult simplifyLocally(Operation *op, int maxIterations, bool &erased);
 
   // These are hooks implemented for PatternRewriter.
 protected:
   /// If an operation is about to be removed, mark it so that we can let clients
   /// know.
-  void notifyOperationRemoved(Operation *op) override {
+  void notifyOperationRemoved(Operation *) override {
     opErasedViaPatternRewrites = true;
   }
 
   // When a root is going to be replaced, its removal will be notified as well.
   // So there is nothing to do here.
   void notifyRootReplaced(Operation *op) override {}
 
 private:

mlir/lib/Transforms/Utils/LoopFusionUtils.cpp

parentBlock->getOperations().splice(Block::iterator(forOp),
                                       forOp.getBody()->getOperations());
   forOp.erase();
   parentForOp.erase();
   return success();
 }
 
 /// Fuses 'srcForOp' into 'dstForOp' with destination loop block insertion point
 /// and source slice loop bounds specified in 'srcSlice'.
-void mlir::fuseLoops(AffineForOp srcForOp, AffineForOp dstForOp,
+void mlir::fuseLoops(AffineForOp srcForOp, AffineForOp,
                      const ComputationSliceState &srcSlice,
                      bool isInnermostSiblingInsertion) {
   // Clone 'srcForOp' into 'dstForOp' at 'srcSlice->insertPoint'.
   OpBuilder b(srcSlice.insertPoint->getBlock(), srcSlice.insertPoint);
   BlockAndValueMapping mapper;
   b.clone(*srcForOp, mapper);
 
   // Update 'sliceLoopNest' upper and lower bounds from computed 'srcSlice'.

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,
                   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) {
       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 &) {
   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, 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 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) {
   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) {
   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,
+                               int64_t one, std::string, IntegerAttr,
                                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) {
   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)>) 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) {
+OpFoldResult
+TestInvolutionTraitFailingOperationFolderOp::fold(ArrayRef<Attribute>) {
   // This failure should cause the trait fold to run instead.
   return {};
 }
 
-OpFoldResult TestInvolutionTraitSuccesfulOperationFolderOp::fold(
-    ArrayRef<Attribute> operands) {
+OpFoldResult
+TestInvolutionTraitSuccesfulOperationFolderOp::fold(ArrayRef<Attribute>) {
   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

void CompoundAType::print(AsmPrinter &printer) const {
   printer << "]>";
 }
 
 //===----------------------------------------------------------------------===//
 // TestIntegerType
 //===----------------------------------------------------------------------===//
 
 // Example type validity checker.
-LogicalResult
-TestIntegerType::verify(function_ref<InFlightDiagnostic()> emitError,
+LogicalResult TestIntegerType::verify(function_ref<InFlightDiagnostic()>,
                                       unsigned width,
-                        TestIntegerType::SignednessSemantics ss) {
+                                      TestIntegerType::SignednessSemantics) {
   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 &,
                                           DataLayoutEntryListRef params) const {
   return extractKind(params, "size");
 }
 
 unsigned
-TestTypeWithLayoutType::getABIAlignment(const DataLayout &dataLayout,
+TestTypeWithLayoutType::getABIAlignment(const DataLayout &,
                                         DataLayoutEntryListRef params) const {
   return extractKind(params, "alignment");
 }
 
 unsigned TestTypeWithLayoutType::getPreferredAlignment(
-    const DataLayout &dataLayout, DataLayoutEntryListRef params) const {
+    const 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) 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,
+                                                  PatternRewriter &) {
   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) {
+customMultiEntityVariadicConstraint(ArrayRef<PDLValue> values, ArrayAttr,
+                                    PatternRewriter &) {
   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,
                          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,
+static void customVariadicResultCreate(ArrayRef<PDLValue> args, ArrayAttr,
+                                       PatternRewriter &,
                                        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>, ArrayAttr,
                              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 &) {
   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 loopDepth,
+                                         unsigned, unsigned, 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
       // fusion pass should check the data dependence graph and run memref

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) {
             body << formatv(typeParserCode, "::mlir::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) {
     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/unittests/Dialect/Quant/QuantizationUtilsTest.cpp

 namespace {
 
 // Test UniformQuantizedValueConverter converts all APFloat to a magic number 5.
 class TestUniformQuantizedValueConverter
     : public UniformQuantizedValueConverter {
 public:
   TestUniformQuantizedValueConverter(UniformQuantizedType type)
       : UniformQuantizedValueConverter(type), qtype(type) {}
-  APInt quantizeFloatToInt(APFloat expressedValue) const override {
+  APInt quantizeFloatToInt(APFloat) const override {
     return APInt(qtype.getStorageType().cast<IntegerType>().getWidth(), 5L);
   }
 
 private:
   UniformQuantizedType qtype;
 };
 
 Attribute getTestFloatAttr(double value, MLIRContext *ctx) {

mlir/unittests/Interfaces/ControlFlowInterfacesTest.cpp

 struct SequentialRegionsOp
     : public Op<SequentialRegionsOp, RegionBranchOpInterface::Trait> {
   using Op::Op;
   static ArrayRef<StringRef> getAttributeNames() { return {}; }
 
   static StringRef getOperationName() { return "cftest.sequential_regions_op"; }
 
   // Region 0 has Region 1 as a successor.
-  void getSuccessorRegions(Optional<unsigned> index,
-                           ArrayRef<Attribute> operands,
+  void getSuccessorRegions(Optional<unsigned> index, ArrayRef<Attribute>,
                            SmallVectorImpl<RegionSuccessor> &regions) {
     assert(index.hasValue() && "expected index");
     if (*index == 0) {
       Operation *thisOp = this->getOperation();
       regions.push_back(RegionSuccessor(&thisOp->getRegion(1)));
     }
   }
 };