[WIP][ADT] Do not use lvalue references with `llvm::enumerate`. NFC.

[kuhar]

Summary

The future API changes will make the dereference return a temporary.

Context: https://reviews.llvm.org/D144503

llvm/lib/ObjectYAML/DWARFYAML.cpp

if (DebugLoclists)
     SecNames.insert("debug_loclists");
   return SecNames;
 }
 
 Expected<DWARFYAML::Data::AbbrevTableInfo>
 DWARFYAML::Data::getAbbrevTableInfoByID(uint64_t ID) const {
   if (AbbrevTableInfoMap.empty()) {
     uint64_t AbbrevTableOffset = 0;
-    for (auto &AbbrevTable : enumerate(DebugAbbrev)) {
+    for (auto &&AbbrevTable : enumerate(DebugAbbrev)) {
       // If the abbrev table's ID isn't specified, we use the index as its ID.
       uint64_t AbbrevTableID =
           AbbrevTable.value().ID.value_or(AbbrevTable.index());
       auto It = AbbrevTableInfoMap.insert(
           {AbbrevTableID, AbbrevTableInfo{/*Index=*/AbbrevTable.index(),
                                           /*Offset=*/AbbrevTableOffset}});
       if (!It.second)
         return createStringError(

llvm/lib/ObjectYAML/MinidumpEmitter.cpp

bool yaml2minidump(MinidumpYAML::Object &Obj, raw_ostream &Out,
                    ErrorHandler /*EH*/) {
   BlobAllocator File;
   File.allocateObject(Obj.Header);
 
   std::vector<Directory> StreamDirectory(Obj.Streams.size());
   Obj.Header.StreamDirectoryRVA = File.allocateArray(ArrayRef(StreamDirectory));
   Obj.Header.NumberOfStreams = StreamDirectory.size();
 
-  for (auto &Stream : enumerate(Obj.Streams))
+  for (auto &&Stream : enumerate(Obj.Streams))
     StreamDirectory[Stream.index()] = layout(File, *Stream.value());
 
   File.writeTo(Out);
   return true;
 }
 
 } // namespace yaml
 } // namespace llvm

llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp

bool clusterSortPtrAccesses(ArrayRef<Value *> VL, Type *ElemTy,
   for (auto &Base : Bases) {
     auto &Vec = Base.second;
     if (Vec.size() > 1) {
       llvm::stable_sort(Vec, [](const std::tuple<Value *, int, unsigned> &X,
                                 const std::tuple<Value *, int, unsigned> &Y) {
         return std::get<1>(X) < std::get<1>(Y);
       });
       int InitialOffset = std::get<1>(Vec[0]);
-      AnyConsecutive |= all_of(enumerate(Vec), [InitialOffset](auto &P) {
+      AnyConsecutive |= all_of(enumerate(Vec), [InitialOffset](auto &&P) {
         return std::get<1>(P.value()) == int(P.index()) + InitialOffset;
       });
     }
   }
 
   // Fill SortedIndices array only if it looks worth-while to sort the ptrs.
   SortedIndices.clear();
   if (!AnyConsecutive)

llvm/tools/llvm-reduce/deltas/ReduceArguments.cpp

for (Value *V : InstToDelete) {
         I->eraseFromParent();
     }
 
     // No arguments to reduce
     if (VMap.empty())
       continue;
 
     std::set<int> ArgIndexesToKeep;
-    for (auto &Arg : enumerate(F->args()))
+    for (auto &&Arg : enumerate(F->args()))
       if (ArgsToKeep.count(&Arg.value()))
         ArgIndexesToKeep.insert(Arg.index());
 
     auto *ClonedFunc = CloneFunction(F, VMap);
     // In order to preserve function order, we move Clone after old Function
     ClonedFunc->removeFromParent();
     Program.getFunctionList().insertAfter(F->getIterator(), ClonedFunc);
 

llvm/unittests/DebugInfo/CodeView/RandomAccessVisitorTest.cpp

TEST_F(RandomAccessVisitorTest, AscendingWithinChunk) {
 
   // [0, 7]
   EXPECT_EQ(8u, Types.size());
   for (uint32_t I = 0; I < 8; ++I)
     EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
 
   // 2, 4, 7
   EXPECT_EQ(3u, TestState->Callbacks.count());
-  for (auto &I : enumerate(IndicesToVisit))
+  for (auto &&I : enumerate(IndicesToVisit))
     EXPECT_TRUE(ValidateVisitedRecord(I.index(), I.value()));
 }
 
 TEST_F(RandomAccessVisitorTest, StopPrematurelyInChunk) {
   // * Don't visit the last item in one chunk, ensuring that visitation stops
   //   at the record you specify, and the chunk is only partially visited.
   //   In the below example, this is tested by visiting 0 and 1 but not 2,
   //   all from the [0,3) chunk.
TEST_F(RandomAccessVisitorTest, InnerChunk) {
 
   // [4, 9)
   EXPECT_EQ(5u, Types.size());
   for (uint32_t I = 4; I < 9; ++I)
     EXPECT_TRUE(ValidateDatabaseRecord(Types, I));
 
   // 5, 7
   EXPECT_EQ(2u, TestState->Callbacks.count());
-  for (auto &I : enumerate(IndicesToVisit))
+  for (auto &&I : enumerate(IndicesToVisit))
     EXPECT_TRUE(ValidateVisitedRecord(I.index(), I.value()));
 }
 
 TEST_F(RandomAccessVisitorTest, CrossChunkName) {
   AppendingTypeTableBuilder Builder(GlobalState->Allocator);
 
   // TypeIndex 0
   ClassRecord Class(TypeRecordKind::Class);

mlir/lib/Analysis/DataFlow/SparseAnalysis.cpp

for (Block::pred_iterator it = block->pred_begin(), e = block->pred_end();
     if (!edgeExecutable->isLive())
       continue;
 
     // Check if we can reason about the data-flow from the predecessor.
     if (auto branch =
             dyn_cast<BranchOpInterface>(predecessor->getTerminator())) {
       SuccessorOperands operands =
           branch.getSuccessorOperands(it.getSuccessorIndex());
-      for (auto &it : llvm::enumerate(argLattices)) {
+      for (auto &&it : llvm::enumerate(argLattices)) {
         if (Value operand = operands[it.index()]) {
           join(it.value(), *getLatticeElementFor(block, operand));
         } else {
           // Conservatively consider internally produced arguments as entry
           // points.
           setAllToEntryStates(it.value());
         }
       }

mlir/lib/Bytecode/Writer/IRNumbering.cpp

for (unsigned i = 1; i < 9; ++i) {
     dialectToOrderFirst = byteSubRange.back()->dialect->number;
 
     // If the data range is now empty, we are done.
     if (iterRange.empty())
       break;
   }
 
   // Assign the entry numbers based on the sort order.
-  for (auto &entry : llvm::enumerate(range))
+  for (auto &&entry : llvm::enumerate(range))
     entry.value()->number = entry.index();
 }
 
 IRNumberingState::IRNumberingState(Operation *op) {
   // Number the root operation.
   number(*op);
 
   // Push all of the regions of the root operation onto the worklist.
for (Operation &op : region->getOps()) {
         numberContext.emplace_back(&region, opFirstValueID);
     }
   }
 
   // Number each of the dialects. For now this is just in the order they were
   // found, given that the number of dialects on average is small enough to fit
   // within a singly byte (128). If we ever have real world use cases that have
   // a huge number of dialects, this could be made more intelligent.
-  for (auto &it : llvm::enumerate(dialects))
+  for (auto &&it : llvm::enumerate(dialects))
     it.value().second->number = it.index();
 
   // Number each of the recorded components within each dialect.
 
   // First sort by ref count so that the most referenced elements are first. We
   // try to bias more heavily used elements to the front. This allows for more
   // frequently referenced things to be encoded using smaller varints.
   auto sortByRefCountFn = [](const auto &lhs, const auto &rhs) {

 
 void IRNumberingState::number(Region &region) {
   if (region.empty())
     return;
   size_t firstValueID = nextValueID;
 
   // Number the blocks within this region.
   size_t blockCount = 0;
-  for (auto &it : llvm::enumerate(region)) {
+  for (auto &&it : llvm::enumerate(region)) {
     blockIDs.try_emplace(&it.value(), it.index());
     number(it.value());
     ++blockCount;
   }
 
   // Remember the number of blocks and values in this region.
   regionBlockValueCounts.try_emplace(&region, blockCount,
                                      nextValueID - firstValueID);

mlir/lib/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.cpp

matchAndRewrite(GpuOp gpuOp, typename GpuOp::Adaptor adaptor,
     Value word3Const = createI32Constant(rewriter, loc, word3);
     resource = rewriter.create<LLVM::InsertElementOp>(
         loc, llvm4xI32, resource, word3Const,
         this->createIndexConstant(rewriter, loc, 3));
     args.push_back(resource);
 
     // Indexing (voffset)
     Value voffset;
-    for (auto &pair : llvm::enumerate(adaptor.getIndices())) {
+    for (auto &&pair : llvm::enumerate(adaptor.getIndices())) {
       size_t i = pair.index();
       Value index = pair.value();
       Value strideOp;
       if (ShapedType::isDynamic(strides[i])) {
         strideOp = rewriter.create<LLVM::MulOp>(
             loc, memrefDescriptor.stride(rewriter, loc, i), byteWidthConst);
       } else {
         strideOp =

mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp

auto wrapperFuncOp = rewriter.create<LLVM::LLVMFuncOp>(
       wrapperFuncType, LLVM::Linkage::External, /*dsoLocal*/ false,
       /*cconv*/ LLVM::CConv::C, attributes);
 
   OpBuilder::InsertionGuard guard(rewriter);
   rewriter.setInsertionPointToStart(wrapperFuncOp.addEntryBlock());
 
   SmallVector<Value, 8> args;
   size_t argOffset = resultStructType ? 1 : 0;
-  for (auto &[index, argType] : llvm::enumerate(type.getInputs())) {
+  for (auto [index, argType] : llvm::enumerate(type.getInputs())) {
     Value arg = wrapperFuncOp.getArgument(index + argOffset);
     if (auto memrefType = argType.dyn_cast<MemRefType>()) {
       Value loaded = rewriter.create<LLVM::LoadOp>(
           loc, typeConverter.convertType(memrefType), arg);
       MemRefDescriptor::unpack(rewriter, loc, loaded, memrefType, args);
       continue;
     }
     if (argType.isa<UnrankedMemRefType>()) {
Value one = builder.create<LLVM::ConstantOp>(
         builder.getIntegerAttr(builder.getIndexType(), 1));
     Value result =
         builder.create<LLVM::AllocaOp>(loc, resultType, resultStructType, one);
     args.push_back(result);
   }
 
   // Iterate over the inputs of the original function and pack values into
   // memref descriptors if the original type is a memref.
-  for (auto &en : llvm::enumerate(type.getInputs())) {
+  for (auto &&en : llvm::enumerate(type.getInputs())) {
     Value arg;
     int numToDrop = 1;
     auto memRefType = en.value().dyn_cast<MemRefType>();
     auto unrankedMemRefType = en.value().dyn_cast<UnrankedMemRefType>();
     if (memRefType || unrankedMemRefType) {
       numToDrop = memRefType
                       ? MemRefDescriptor::getNumUnpackedValues(memRefType)
                       : UnrankedMemRefDescriptor::getNumUnpackedValues();
matchAndRewrite(func::ReturnOp op, OpAdaptor adaptor,
     }
 
     // Otherwise, we need to pack the arguments into an LLVM struct type before
     // returning.
     auto packedType =
         getTypeConverter()->packFunctionResults(op.getOperandTypes());
 
     Value packed = rewriter.create<LLVM::UndefOp>(loc, packedType);
-    for (auto &it : llvm::enumerate(updatedOperands)) {
+    for (auto &&it : llvm::enumerate(updatedOperands)) {
       packed = rewriter.create<LLVM::InsertValueOp>(loc, packed, it.value(),
                                                     it.index());
     }
     rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, TypeRange(), packed,
                                                 op->getAttrs());
     return success();
   }
 };

mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp

 Type LLVMTypeConverter::convertFunctionSignature(
     FunctionType funcTy, bool isVariadic,
     LLVMTypeConverter::SignatureConversion &result) {
   // Select the argument converter depending on the calling convention.
   auto funcArgConverter = options.useBarePtrCallConv
                               ? barePtrFuncArgTypeConverter
                               : structFuncArgTypeConverter;
   // Convert argument types one by one and check for errors.
-  for (auto &en : llvm::enumerate(funcTy.getInputs())) {
+  for (auto &&en : llvm::enumerate(funcTy.getInputs())) {
     Type type = en.value();
     SmallVector<Type, 8> converted;
     if (failed(funcArgConverter(*this, type, converted)))
       return {};
     result.addInputs(en.index(), converted);
   }
 
   // If function does not return anything, create the void result type,

mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp

if (operands.size() == 1 && operands[0].getType().isa<pdl::RangeType>()) {
     }
   }
   /// Results.
   if (types.size() == 1 && types[0].getType().isa<pdl::RangeType>()) {
     getTreePredicates(predList, types.front(), builder, inputs,
                       builder.getType(builder.getAllResults(opPos)));
   } else {
     bool foundVariableLength = false;
-    for (auto &resultIt : llvm::enumerate(types)) {
+    for (auto &&resultIt : llvm::enumerate(types)) {
       bool isVariadic = resultIt.value().getType().isa<pdl::RangeType>();
       foundVariableLength |= isVariadic;
 
       auto *resultPos =
           foundVariableLength
               ? builder.getResultGroup(pos, resultIt.index(), isVariadic)
               : builder.getResult(pos, resultIt.index());
       predList.emplace_back(resultPos, builder.getIsNotNull());

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

 }
 
 void ComputationSliceState::dump() const {
   llvm::errs() << "\tIVs:\n";
   for (Value iv : ivs)
     llvm::errs() << "\t\t" << iv << "\n";
 
   llvm::errs() << "\tLBs:\n";
-  for (auto &en : llvm::enumerate(lbs)) {
+  for (auto &&en : llvm::enumerate(lbs)) {
     llvm::errs() << "\t\t" << en.value() << "\n";
     llvm::errs() << "\t\tOperands:\n";
     for (Value lbOp : lbOperands[en.index()])
       llvm::errs() << "\t\t\t" << lbOp << "\n";
   }
 
   llvm::errs() << "\tUBs:\n";
-  for (auto &en : llvm::enumerate(ubs)) {
+  for (auto &&en : llvm::enumerate(ubs)) {
     llvm::errs() << "\t\t" << en.value() << "\n";
     llvm::errs() << "\t\tOperands:\n";
     for (Value ubOp : ubOperands[en.index()])
       llvm::errs() << "\t\t\t" << ubOp << "\n";
   }
 }
 
 /// Fast check to determine if the computation slice is maximal. Returns true if

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

OpFoldResult LLVM::GEPOp::fold(FoldAdaptor adaptor) {
   if (getBase().getType() == getType() && indices.size() == 1)
     if (auto integer = indices[0].dyn_cast_or_null<IntegerAttr>())
       if (integer.getValue().isZero())
         return getBase();
 
   // Canonicalize any dynamic indices of constant value to constant indices.
   bool changed = false;
   SmallVector<GEPArg> gepArgs;
-  for (auto &iter : llvm::enumerate(indices)) {
+  for (auto &&iter : llvm::enumerate(indices)) {
     auto integer = iter.value().dyn_cast_or_null<IntegerAttr>();
     // Constant indices can only be int32_t, so if integer does not fit we
     // are forced to keep it dynamic, despite being a constant.
     if (!indices.isDynamicIndex(iter.index()) || !integer ||
         !integer.getValue().isSignedIntN(kGEPConstantBitWidth)) {
 
       PointerUnion<IntegerAttr, Value> existing = getIndices()[iter.index()];
       if (Value val = existing.dyn_cast<Value>())

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

for (Operation *op : dynamicSizeProducers.back()) {
       diag.attachNote(transformValue.getLoc()) << "for this handle";
       return diag;
     }
   }
 
   SmallVector<Operation *> tiled;
   SmallVector<SmallVector<Operation *, 4>, 4> loops;
   loops.resize(getLoops().size());
-  for (auto &[i, op] : llvm::enumerate(targets)) {
+  for (auto [i, op] : llvm::enumerate(targets)) {
     auto tilingInterface = dyn_cast<TilingInterface>(op);
     auto dpsInterface = dyn_cast<DestinationStyleOpInterface>(op);
     if (!tilingInterface || !dpsInterface) {
       DiagnosedSilenceableFailure diag =
           emitSilenceableError() << "only ops implementing TilingInterface and "
                                     "DestinationStyleOpInterface are supported";
       diag.attachNote(op->getLoc()) << "target op";
       return diag;
for (Operation *op : dynamicSizeProducers.back()) {
       diag.attachNote(dynamicSizeProducerHandle.getLoc()) << "for this handle";
       return diag;
     }
   }
 
   SmallVector<Operation *> tiled;
   SmallVector<SmallVector<Operation *, 4>, 4> loops;
   loops.resize(getLoops().size());
-  for (auto &en : llvm::enumerate(targets)) {
+  for (auto &&en : llvm::enumerate(targets)) {
     auto tilingInterfaceOp = dyn_cast<TilingInterface>(en.value());
     if (!tilingInterfaceOp) {
       DiagnosedSilenceableFailure diag =
           emitSilenceableError() << "only TilingInterface ops are supported";
       diag.attachNote(en.value()->getLoc()) << "target op";
       return diag;
     }
 

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

void generateCollapsedIndexingRegion(Location loc, Block *block,
   // For each folded dimension list resolve the original induction variable
   // values in terms of the folded dimension induction variable.
   //   i_{folded} = (i_0 * d1 + i1) * d2 + i2.
   // can be inverted to
   //   i2 = i_{folded} % d2
   //   i1 = (i_{folded} / d2) % d1
   //   i0 = i_{folded} / (d1 * d2)
   llvm::DenseMap<unsigned, Value> indexReplacementVals;
-  for (auto &foldedDims :
+  for (auto &&foldedDims :
        enumerate(collapsingInfo.getCollapsedOpToOrigOpMapping())) {
     ReassociationIndicesRef foldedDimsRef(foldedDims.value());
     Value newIndexVal =
         rewriter.create<linalg::IndexOp>(loc, foldedDims.index());
     for (auto dim : llvm::reverse(foldedDimsRef.drop_front())) {
       indexReplacementVals[dim] =
           rewriter.create<arith::RemUIOp>(loc, newIndexVal, loopRange[dim]);
       newIndexVal =

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

FailureOr<SplitReductionResult> mlir::linalg::splitReduction(
   Value constantOp = b.create<arith::ConstantOp>(loc, *identity);
   Value identityTensor =
       b.create<linalg::FillOp>(op->getLoc(), constantOp, emptyOrAllocTensor)
           .getResult(0);
 
   newMaps.push_back(AffineMap::get(oldOutputMap.getNumDims() + 1, 0, outputExpr,
                                    op.getContext()));
   SmallVector<utils::IteratorType> newIteratorTypes;
-  for (auto &it : llvm::enumerate(op.getIteratorTypesArray())) {
+  for (auto &&it : llvm::enumerate(op.getIteratorTypesArray())) {
     if (insertSplitDimension == it.index())
       newIteratorTypes.push_back(utils::IteratorType::parallel);
     newIteratorTypes.push_back(it.value());
   }
   if (insertSplitDimension == op.getIteratorTypesArray().size()) {
     newIteratorTypes.push_back(utils::IteratorType::parallel);
   }
   // Create the new op matching the original op with an extra parallel

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

for (unsigned idx = 0, e = tileSizes.size(); idx < e; ++idx)
     res.push_back(Range{b.getIndexAttr(0), shapeSizes[idx], tileSizes[idx]});
   return std::make_tuple(res, loopIndexToRangeIndex);
 }
 
 void mlir::linalg::transformIndexOps(
     RewriterBase &b, LinalgOp op, SmallVectorImpl<Value> &ivs,
     const LoopIndexToRangeIndexMap &loopIndexToRangeIndex) {
   SmallVector<Value> allIvs(op.getNumLoops(), nullptr);
-  for (auto &en : enumerate(allIvs)) {
+  for (auto &&en : enumerate(allIvs)) {
     auto rangeIndex = loopIndexToRangeIndex.find(en.index());
     if (rangeIndex == loopIndexToRangeIndex.end())
       continue;
     en.value() = ivs[rangeIndex->second];
   }
   offsetIndices(b, op, getAsOpFoldResult(allIvs));
 }
 

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

Operation *tileToPartialReduction(Operation *op, OpBuilder &b, Location loc,
     auto linalgOp = cast<LinalgOp>(op);
     assert(reductionDims.size() == 1 &&
            "only support single reduction right now.");
     int64_t insertSplitDimension = reductionDims[0];
 
     AffineMap oldOutputMap =
         linalgOp.getMatchingIndexingMap(linalgOp.getDpsInitOperand(0));
     SmallVector<AffineExpr> outputExpr;
-    for (auto &[idx, expr] : llvm::enumerate(oldOutputMap.getResults())) {
+    for (auto [idx, expr] : llvm::enumerate(oldOutputMap.getResults())) {
       if (static_cast<int64_t>(idx) == insertSplitDimension) {
         outputExpr.push_back(b.getAffineDimExpr(reductionDims[0]));
       }
       outputExpr.push_back(expr);
     }
     if (insertSplitDimension == oldOutputMap.getNumResults())
       outputExpr.push_back(b.getAffineDimExpr(reductionDims[0]));
 

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

LogicalResult ReinterpretCastOp::verify() {
   if (srcType.getMemorySpace() != resultType.getMemorySpace())
     return emitError("different memory spaces specified for source type ")
            << srcType << " and result memref type " << resultType;
   if (srcType.getElementType() != resultType.getElementType())
     return emitError("different element types specified for source type ")
            << srcType << " and result memref type " << resultType;
 
   // Match sizes in result memref type and in static_sizes attribute.
-  for (auto &en :
+  for (auto &&en :
        llvm::enumerate(llvm::zip(resultType.getShape(), getStaticSizes()))) {
     int64_t resultSize = std::get<0>(en.value());
     int64_t expectedSize = std::get<1>(en.value());
     if (!ShapedType::isDynamic(resultSize) &&
         !ShapedType::isDynamic(expectedSize) && resultSize != expectedSize)
       return emitError("expected result type with size = ")
              << expectedSize << " instead of " << resultSize
              << " in dim = " << en.index();
LogicalResult ReinterpretCastOp::verify() {
   int64_t expectedOffset = getStaticOffsets().front();
   if (!ShapedType::isDynamic(resultOffset) &&
       !ShapedType::isDynamic(expectedOffset) &&
       resultOffset != expectedOffset)
     return emitError("expected result type with offset = ")
            << resultOffset << " instead of " << expectedOffset;
 
   // Match strides in result memref type and in static_strides attribute.
-  for (auto &en :
+  for (auto &&en :
        llvm::enumerate(llvm::zip(resultStrides, getStaticStrides()))) {
     int64_t resultStride = std::get<0>(en.value());
     int64_t expectedStride = std::get<1>(en.value());
     if (!ShapedType::isDynamic(resultStride) &&
         !ShapedType::isDynamic(expectedStride) &&
         resultStride != expectedStride)
       return emitError("expected result type with stride = ")
              << expectedStride << " instead of " << resultStride

mlir/lib/Dialect/SCF/IR/SCF.cpp

for (auto [idx, result, operand] :
                  .attachNote(yield.getLoc())
              << name << " returns " << operand << " here";
     }
     return success();
   };
 
   if (failed(verifyRegion(getDefaultRegion(), "default region")))
     return failure();
-  for (auto &[idx, caseRegion] : llvm::enumerate(getCaseRegions()))
+  for (auto [idx, caseRegion] : llvm::enumerate(getCaseRegions()))
     if (failed(verifyRegion(caseRegion, "case region #" + Twine(idx))))
       return failure();
 
   return success();
 }
 
 unsigned scf::IndexSwitchOp::getNumCases() { return getCases().size(); }
 

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

mlir::scf::tileReductionUsingScf(PatternRewriter &b,
   SmallVector<utils::IteratorType> iterators =
       tilingInterfaceOp.getLoopIteratorTypes();
   int64_t numReductionDims = llvm::count(
       tilingInterfaceOp.getLoopIteratorTypes(), utils::IteratorType::reduction);
   if (numReductionDims != 1)
     return b.notifyMatchFailure(
         op, "only support ops with one reduction dimension.");
   int reductionDim;
-  for (auto &[idx, iteratorType] :
+  for (auto [idx, iteratorType] :
        llvm::enumerate(tilingInterfaceOp.getLoopIteratorTypes())) {
     if (iteratorType == utils::IteratorType::reduction) {
       reductionDim = idx;
       break;
     }
   }
   if (static_cast<size_t>(reductionDim) >= tileSize.size())
     return b.notifyMatchFailure(op, "reduction dimension must be tiled");

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

matchAndRewrite(NewOp op, OpAdaptor adaptor,
     // the sparse tensor reader.
     SmallVector<Value> dynSizes;
     if (dstTp.hasDynamicDimShape()) {
       Value dimSizes = genAlloca(rewriter, loc, dimRank, indexTp);
       createFuncCall(rewriter, loc, "copySparseTensorReaderDimSizes", {},
                      {reader, dimSizes}, EmitCInterface::On)
           .getResult(0);
       ArrayRef<int64_t> dstShape = dstTp.getRankedTensorType().getShape();
-      for (auto &d : llvm::enumerate(dstShape)) {
+      for (auto &&d : llvm::enumerate(dstShape)) {
         if (d.value() == ShapedType::kDynamic) {
           dynSizes.push_back(rewriter.create<memref::LoadOp>(
               loc, dimSizes, constantIndex(rewriter, loc, d.index())));
         }
       }
     }
 
     Value nse = createFuncCall(rewriter, loc, "getSparseTensorReaderNNZ",

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

LogicalResult matchAndRewrite(ReshapeOp op,
     SmallVector<Value> dstDynSizes;
     if (dstTp.hasStaticShape()) {
       for (auto d : dstTp.getShape())
         dstSizes.push_back(constantIndex(rewriter, loc, d));
     } else {
       ArrayRef<int64_t> dstShape = dstTp.getShape();
       genReshapeDstShape(loc, rewriter, dstSizes, srcSizes, dstShape,
                          op.getReassociationIndices());
-      for (auto &d : llvm::enumerate(dstShape)) {
+      for (auto &&d : llvm::enumerate(dstShape)) {
         if (d.value() == ShapedType::kDynamic)
           dstDynSizes.push_back(dstSizes[d.index()]);
       }
     }
 
     // Implement the sparse2sparse reshape as follows:
     //   %tmp = bufferization.alloc_tensor : unordered COO
     //   foreach srcCoords %srcTensor

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

unsigned startPos = reassociation[sourceDimPos]
                           .cast<AffineDimExpr>()
                           .getPosition();
   unsigned endPos = reassociation[sourceDimPos]
                         .getResults()
                         .back()
                         .cast<AffineDimExpr>()
                         .getPosition();
   int64_t linearizedStaticDim = 1;
-  for (auto &d :
+  for (auto &&d :
        llvm::enumerate(dstStaticShape.slice(startPos, endPos - startPos + 1))) {
     if (d.index() + startPos == static_cast<unsigned>(dimIndex))
       continue;
     assert(!ShapedType::isDynamic(d.value()) &&
            "single dimension cannot be expanded into multiple dynamic "
            "dimensions");
     linearizedStaticDim *= d.value();
   }

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

LogicalResult matchAndRewrite(PadOp padOp,
     }
 
     // 6) Combine the offsets of the two tensor::ExtractSliceOps. Find the
     // zero-offset and zero-padding tensor::ExtractSliceOp, tensor::PadOp pair
     // for every dimension, and use the offset the other pair. Fail if no
     // zero-offset and zero-padding tensor::ExtractSliceOp, tensor::PadOp pair
     // exists.
     SmallVector<OpFoldResult> newOffsets(rank, rewriter.getIndexAttr(0));
-    for (auto &en : enumerate(newOffsets)) {
+    for (auto &&en : enumerate(newOffsets)) {
       OpFoldResult innerOffset = innerSliceOp.getMixedOffsets()[en.index()];
       OpFoldResult outerOffset = outerSliceOp.getMixedOffsets()[en.index()];
       if (!innerDims.test(en.index()) &&
           (getConstantIntValue(innerOffset) == static_cast<int64_t>(0))) {
         en.value() = outerOffset;
         continue;
       }
       if (!outerDims.test(en.index()) &&
           (getConstantIntValue(outerOffset) == static_cast<int64_t>(0))) {
         en.value() = innerOffset;
         continue;
       }
       return rewriter.notifyMatchFailure(
           padOp, "cannot find zero-offset and zero-padding pair");
     }
 
     // 7) Combine the sizes of the two tensor::ExtractSliceOps. Take the size
     // of the outer tensor::ExtractSliceOp for the dimensions padded by the
     // outer tensor::PadOp and fail if the size of the inner
     // tensor::ExtractSliceOp does not match the size of the padded dimension.
     // Otherwise, take the size of the inner tensor::ExtractSliceOp.
     SmallVector<OpFoldResult> newSizes = innerSliceOp.getMixedSizes();
-    for (auto &en : enumerate(newSizes)) {
+    for (auto &&en : enumerate(newSizes)) {
       if (!outerDims.test(en.index()))
         continue;
       OpFoldResult sliceSize = innerSliceOp.getMixedSizes()[en.index()];
       int64_t sourceSize = innerSliceOp.getSourceType().getShape()[en.index()];
       assert(!ShapedType::isDynamic(sourceSize) &&
              "expected padded dimension to have a static size");
       if (getConstantIntValue(sliceSize) != sourceSize) {
         return rewriter.notifyMatchFailure(
             padOp, "cannot fold since the inner ExtractSliceOp size does not "
                    "match the size of the outer padding");
       }
       en.value() = outerSliceOp.getMixedSizes()[en.index()];
     }
 
     // Combine the high paddings of the two tensor::PadOps.
     SmallVector<OpFoldResult> newHighPad(rank, rewriter.getIndexAttr(0));
-    for (auto &en : enumerate(newHighPad)) {
+    for (auto &&en : enumerate(newHighPad)) {
       if (innerDims.test(en.index()))
         newHighPad[en.index()] = padOp.getMixedHighPad()[en.index()];
       if (outerDims.test(en.index()))
         newHighPad[en.index()] = outerPadOp.getMixedHighPad()[en.index()];
     }
 
     // Create a new tensor::ExtractSliceOp, tensor::PadOp pair that performs
     // the two paddings in one step.

mlir/lib/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.cpp

bool bufferizesToMemoryRead(Operation *op, OpOperand &opOperand,
 
     // Dest is not read if it is entirely overwritten. E.g.:
     // tensor.insert_slice %a into %t[0][10][1] : ... into tensor<10xf32>
     bool allOffsetsZero =
         llvm::all_of(insertSliceOp.getMixedOffsets(), [](OpFoldResult ofr) {
           return isConstantIntValue(ofr, 0);
         });
     bool sizesMatchDestSizes = llvm::all_of(
-        llvm::enumerate(insertSliceOp.getMixedSizes()), [&](auto &it) {
+        llvm::enumerate(insertSliceOp.getMixedSizes()), [&](auto &&it) {
           return getConstantIntValue(it.value()) ==
                  destType.getDimSize(it.index());
         });
     bool allStridesOne =
         llvm::all_of(insertSliceOp.getMixedStrides(), [](OpFoldResult ofr) {
           return isConstantIntValue(ofr, 1);
         });
     return !(allOffsetsZero && sizesMatchDestSizes && allStridesOne);

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

LogicalResult matchAndRewrite(tosa::TransposeOp op,
     int64_t numElements = inputType.getNumElements();
 
     SmallVector<Attribute, 4> outputValues;
     outputValues.resize(numElements);
 
     // Transpose the input constant. Because we don't know its rank in advance,
     // we need to loop over the range [0, element count) and delinearize the
     // index.
-    auto attrValues = inputValues.getValues<Attribute>();
+    auto attrValuesIt = inputValues.value_begin<Attribute>();
     ArrayRef<int64_t> outputShape = outputType.getShape();
-    for (const auto &it : llvm::enumerate(attrValues)) {
+    for (int64_t totalCount = 0, e = inputValues.size(); totalCount != e;
+         ++totalCount) {
       SmallVector<uint64_t, 6> srcIndices(inputType.getRank(), 0);
-      int totalCount = it.index();
       for (int dim = inputType.getRank() - 1; dim >= 0; --dim) {
         srcIndices[dim] = totalCount % inputShape[dim];
         totalCount /= inputShape[dim];
       }
 
       SmallVector<uint64_t, 6> dstIndices(outputType.getRank(), 0);
       for (int dim = outputType.getRank() - 1; dim >= 0; --dim)
         dstIndices[dim] = srcIndices[permValues[dim]];
 
       uint64_t dstLinearIndex = dstIndices.front();
       for (int dim = 1; dim < outputType.getRank(); ++dim)
         dstLinearIndex = dstLinearIndex * outputShape[dim] + dstIndices[dim];
 
-      outputValues[dstLinearIndex] = it.value();
+      outputValues[dstLinearIndex] = *(attrValuesIt + totalCount);
     }
 
     rewriter.replaceOpWithNewOp<tosa::ConstOp>(
         op, outputType, DenseElementsAttr::get(outputType, outputValues));
     return success();
   }
 };
 
 } // namespace
 
 void mlir::tosa::populateTosaFoldConstantTransposePatterns(
     MLIRContext *ctx, RewritePatternSet &patterns) {
   patterns.add<TosaFoldConstantTranspose>(ctx);
 }

mlir/lib/Dialect/Transform/IR/TransformInterfaces.cpp

void transform::detail::setApplyToOneResults(
   SmallVector<SmallVector<MappedValue>> transposed;
   transposed.resize(transformOp->getNumResults());
   for (const ApplyToEachResultList &partialResults : results) {
     if (llvm::any_of(partialResults,
                      [](MappedValue value) { return value.isNull(); }))
       continue;
     assert(transformOp->getNumResults() == partialResults.size() &&
            "expected as many partial results as op as results");
-    for (auto &[i, value] : llvm::enumerate(partialResults))
+    for (auto [i, value] : llvm::enumerate(partialResults))
       transposed[i].push_back(value);
   }
 
   for (OpResult r : transformOp->getResults()) {
     unsigned position = r.getResultNumber();
     if (r.getType().isa<TransformParamTypeInterface>()) {
       transformResults.setParams(r,
                                  castVector<Attribute>(transposed[position]));

mlir/lib/Dialect/Vector/Transforms/VectorDistribute.cpp

static WarpExecuteOnLane0Op moveRegionToNewWarpOpAndAppendReturns(
   llvm::SmallSetVector<Value, 32> yieldValues(yield.getOperands().begin(),
                                               yield.getOperands().end());
   for (auto newRet : llvm::zip(newYieldedValues, newReturnTypes)) {
     if (yieldValues.insert(std::get<0>(newRet))) {
       types.push_back(std::get<1>(newRet));
       indices.push_back(yieldValues.size() - 1);
     } else {
       // If the value already exit the region don't create a new output.
-      for (auto &yieldOperand : llvm::enumerate(yieldValues.getArrayRef())) {
+      for (auto &&yieldOperand : llvm::enumerate(yieldValues.getArrayRef())) {
         if (yieldOperand.value() == std::get<0>(newRet)) {
           indices.push_back(yieldOperand.index());
           break;
         }
       }
     }
   }
   yieldValues.insert(newYieldedValues.begin(), newYieldedValues.end());

mlir/lib/Dialect/Vector/Transforms/VectorUnroll.cpp

LogicalResult matchAndRewrite(vector::TransposeOp transposeOp,
     // of multiples of the targetShape.
     auto ratioStrides = computeStrides(ratio);
     for (int64_t i = 0; i < sliceCount; i++) {
       SmallVector<int64_t> elementOffsets =
           getVectorOffset(ratioStrides, i, *targetShape);
       SmallVector<int64_t> permutedOffsets(elementOffsets.size());
       SmallVector<int64_t> permutedShape(elementOffsets.size());
       // Compute the source offsets and shape.
-      for (auto &indices : llvm::enumerate(permutation)) {
+      for (auto &&indices : llvm::enumerate(permutation)) {
         permutedOffsets[indices.value()] = elementOffsets[indices.index()];
         permutedShape[indices.value()] = (*targetShape)[indices.index()];
       }
       Value slicedOperand = rewriter.create<vector::ExtractStridedSliceOp>(
           loc, transposeOp.getVector(), permutedOffsets, permutedShape,
           strides);
       Value transposedSlice =
           rewriter.create<vector::TransposeOp>(loc, slicedOperand, permutation);

mlir/lib/Dialect/X86Vector/Transforms/AVXTranspose.cpp

LogicalResult matchAndRewrite(vector::TransposeOp op,
 
     // Check if the source vector type is supported. AVX2 patterns can only be
     // applied to f32 vector types with two dimensions greater than one.
     VectorType srcType = op.getSourceVectorType();
     if (!srcType.getElementType().isF32())
       return rewriter.notifyMatchFailure(op, "Unsupported vector element type");
 
     SmallVector<int64_t> srcGtOneDims;
-    for (auto &en : llvm::enumerate(srcType.getShape()))
+    for (auto &&en : llvm::enumerate(srcType.getShape()))
       if (en.value() > 1)
         srcGtOneDims.push_back(en.index());
 
     if (srcGtOneDims.size() != 2)
       return rewriter.notifyMatchFailure(op, "Unsupported vector type");
 
     SmallVector<int64_t, 4> transp;
     for (auto attr : op.getTransp())

mlir/lib/ExecutionEngine/ExecutionEngine.cpp

for (auto &func : module->getFunctionList()) {
     // Extract the arguments from the type-erased argument list and cast them to
     // the proper types.
     auto *bb = llvm::BasicBlock::Create(ctx);
     bb->insertInto(interfaceFunc);
     builder.SetInsertPoint(bb);
     llvm::Value *argList = interfaceFunc->arg_begin();
     SmallVector<llvm::Value *, 8> args;
     args.reserve(llvm::size(func.args()));
-    for (auto &indexedArg : llvm::enumerate(func.args())) {
+    for (auto &&indexedArg : llvm::enumerate(func.args())) {
       llvm::Value *argIndex = llvm::Constant::getIntegerValue(
           builder.getInt64Ty(), APInt(64, indexedArg.index()));
       llvm::Value *argPtrPtr =
           builder.CreateGEP(builder.getInt8PtrTy(), argList, argIndex);
       llvm::Value *argPtr =
           builder.CreateLoad(builder.getInt8PtrTy(), argPtrPtr);
       llvm::Type *argTy = indexedArg.value().getType();
       argPtr = builder.CreateBitCast(argPtr, argTy->getPointerTo());

mlir/lib/IR/AsmPrinter.cpp

 
 void OperationPrinter::printValueUsers(Value value) {
   if (value.use_empty())
     os << "unused";
 
   // One value might be used as the operand of an operation more than once.
   // Only print the operations results once in that case.
   SmallPtrSet<Operation *, 1> userSet;
-  for (auto &indexedUser : enumerate(value.getUsers())) {
+  for (auto &&indexedUser : enumerate(value.getUsers())) {
     if (userSet.insert(indexedUser.value()).second)
       printUserIDs(indexedUser.value(), indexedUser.index());
   }
 }
 
 void OperationPrinter::printUserIDs(Operation *user, bool prefixComma) {
   if (prefixComma)
     os << ", ";

mlir/lib/Pass/PassStatistics.cpp

#if LLVM_ENABLE_STATS
       if (statistics.empty())
         return;
 
       auto &passEntry = mergedStats[pass->getName()];
       if (passEntry.empty()) {
         for (Pass::Statistic *it : pass->getStatistics())
           passEntry.push_back({it->getName(), it->getDesc(), it->getValue()});
       } else {
-        for (auto &it : llvm::enumerate(pass->getStatistics()))
+        for (auto &&it : llvm::enumerate(pass->getStatistics()))
           passEntry[it.index()].value += it.value()->getValue();
       }
 #endif
       return;
     }
 
     // Otherwise, recursively add each of the children.
     for (auto &mgr : adaptor->getPassManagers())

mlir/lib/TableGen/Operator.cpp

void Operator::populateTypeInferenceInfo(
   };
 
   // This vector represents the type inference graph, with one node for each
   // operation result. The nth element is the node for the nth result.
   SmallVector<ResultTypeInference> inference(getNumResults(), {});
 
   // For all results whose types are buildable, initialize their type inference
   // nodes with an edge to themselves. Mark those nodes are fully-inferred.
-  for (auto &[idx, infer] : llvm::enumerate(inference)) {
+  for (auto &&[idx, infer] : llvm::enumerate(inference)) {
     if (getResult(idx).constraint.getBuilderCall()) {
       infer.sources.emplace_back(InferredResultType::mapResultIndex(idx),
                                  "$_self");
       infer.inferred = true;
     }
   }
 
   // Use `AllTypesMatch` and `TypesMatchWith` operation traits to build the

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

void mlir::LLVM::detail::connectPHINodes(Region &region,
                                          const ModuleTranslation &state) {
   // Skip the first block, it cannot be branched to and its arguments correspond
   // to the arguments of the LLVM function.
   for (Block &bb : llvm::drop_begin(region)) {
     llvm::BasicBlock *llvmBB = state.lookupBlock(&bb);
     auto phis = llvmBB->phis();
     auto numArguments = bb.getNumArguments();
     assert(numArguments == std::distance(phis.begin(), phis.end()));
-    for (auto &numberedPhiNode : llvm::enumerate(phis)) {
+    for (auto &&numberedPhiNode : llvm::enumerate(phis)) {
       auto &phiNode = numberedPhiNode.value();
       unsigned index = numberedPhiNode.index();
       for (auto *pred : bb.getPredecessors()) {
         // Find the LLVM IR block that contains the converted terminator
         // 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.

mlir/lib/Transforms/TopologicalSort.cpp

 using namespace mlir;
 
 namespace {
 struct TopologicalSortPass
     : public impl::TopologicalSortBase<TopologicalSortPass> {
   void runOnOperation() override {
     // Topologically sort the regions of the operation without SSA dominance.
     getOperation()->walk([](RegionKindInterface op) {
-      for (auto &it : llvm::enumerate(op->getRegions())) {
+      for (auto &&it : llvm::enumerate(op->getRegions())) {
         if (op.hasSSADominance(it.index()))
           continue;
         for (Block &block : it.value())
           sortTopologically(&block);
       }
     });
   }
 };
 } // end anonymous namespace
 
 std::unique_ptr<Pass> mlir::createTopologicalSortPass() {
   return std::make_unique<TopologicalSortPass>();
 }

mlir/lib/Transforms/Utils/ControlFlowSinkUtils.cpp

size_t mlir::controlFlowSink(
   return Sinker(shouldMoveIntoRegion, moveIntoRegion, domInfo)
       .sinkRegions(regions);
 }
 
 void mlir::getSinglyExecutedRegionsToSink(RegionBranchOpInterface branch,
                                           SmallVectorImpl<Region *> &regions) {
   // Collect constant operands.
   SmallVector<Attribute> operands(branch->getNumOperands(), Attribute());
-  for (auto &it : llvm::enumerate(branch->getOperands()))
+  for (auto &&it : llvm::enumerate(branch->getOperands()))
     (void)matchPattern(it.value(), m_Constant(&operands[it.index()]));
 
   // Get the invocation bounds.
   SmallVector<InvocationBounds> bounds;
   branch.getRegionInvocationBounds(operands, bounds);
 
   // For a simple control-flow sink, only consider regions that are executed at
   // most once.
   for (auto it : llvm::zip(branch->getRegions(), bounds)) {
     const InvocationBounds &bound = std::get<1>(it);
     if (bound.getUpperBound() && *bound.getUpperBound() <= 1)
       regions.push_back(&std::get<0>(it));
   }
 }

mlir/test/lib/Analysis/DataFlow/TestDenseDataFlowAnalysis.cpp

void runOnOperation() override {
     op->walk([&](Operation *op) {
       auto tag = op->getAttrOfType<StringAttr>("tag");
       if (!tag)
         return;
       os << "test_tag: " << tag.getValue() << ":\n";
       const LastModification *lastMods =
           solver.lookupState<LastModification>(op);
       assert(lastMods && "expected a dense lattice");
-      for (auto &it : llvm::enumerate(op->getOperands())) {
+      for (auto &&it : llvm::enumerate(op->getOperands())) {
         os << " operand #" << it.index() << "\n";
         Value value = getMostUnderlyingValue(it.value(), [&](Value value) {
           return solver.lookupState<UnderlyingValueLattice>(value);
         });
         assert(value && "expected an underlying value");
         if (std::optional<ArrayRef<Operation *>> lastMod =
                 lastMods->getLastModifiers(value)) {
           for (Operation *lastModifier : *lastMod) {

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

 int64_t cst{1} = self.get{0}().getValues<int64_t>()[{2}];
 exprs.push_back(getAffineConstantExpr(cst{1}, context));
 )FMT";
         // Update all symbol bindings mapped to an attribute.
         for (LinalgOperandDef &arg : opConfig.structuredOp->args) {
           if (arg.kind != LinalgOperandDefKind::IndexAttr)
             continue;
           assert(arg.indexAttrMap);
-          for (auto &en :
+          for (auto &&en :
                llvm::enumerate(arg.indexAttrMap->affineMap().getResults())) {
             if (auto symbol = en.value().dyn_cast<AffineSymbolExpr>()) {
               std::string argName = arg.name;
               argName[0] = toupper(argName[0]);
               symbolBindings[symbol.getPosition()] =
                   llvm::formatv(structuredOpAccessAttrFormat, argName,
                                 symbol.getPosition(), en.index());
             }

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

private:
   /// Seen attribute or type parameters.
   BitVector seenParams;
 };
 } // namespace
 
 LogicalResult DefFormatParser::verify(SMLoc loc,
                                       ArrayRef<FormatElement *> elements) {
   // Check that all parameters are referenced in the format.
-  for (auto &it : llvm::enumerate(def.getParameters())) {
+  for (auto &&it : llvm::enumerate(def.getParameters())) {
     if (it.value().isOptional())
       continue;
     if (!seenParams.test(it.index())) {
       if (isa<AttributeSelfTypeParameter>(it.value()))
         continue;
       return emitError(loc, "format is missing reference to parameter: " +
                                 it.value().getName());
     }

mlir/tools/mlir-tblgen/EnumsGen.cpp

os << "  return p << '\"' << valueStr << '\"';\n"
           "} // namespace llvm\n";
     return;
   }
 
   // If there are any cases that can't be used with a keyword, switch on the
   // case value to determine when to print in the string form.
   if (nonKeywordCases.any()) {
     os << "  switch (value) {\n";
-    for (auto &it : llvm::enumerate(cases)) {
+    for (auto &&it : llvm::enumerate(cases)) {
       if (nonKeywordCases.test(it.index()))
         continue;
       StringRef symbol = it.value().getSymbol();
       os << llvm::formatv("  case {0}::{1}:\n", qualName,
                           makeIdentifier(symbol));
     }
     os << "    break;\n"
           "  default:\n"

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

void OpEmitter::genAttrNameGetters() {
   return name.getAttributeNames()[index];
 )";
     method->body() << formatv(getAttrName, attributes.size());
   }
 
   // Generate the <attr>AttrName methods, that expose the attribute names to
   // users.
   const char *attrNameMethodBody = "  return getAttributeNameForIndex({0});";
-  for (auto &attrIt : llvm::enumerate(llvm::make_first_range(attributes))) {
+  for (auto &&attrIt : llvm::enumerate(llvm::make_first_range(attributes))) {
     std::string name = op.getGetterName(attrIt.value());
     std::string methodName = name + "AttrName";
 
     // Generate the non-static variant.
     {
       auto *method = opClass.addInlineMethod("::mlir::StringAttr", methodName);
       ERROR_IF_PRUNED(method, methodName, op);
       method->body() << llvm::formatv(attrNameMethodBody, attrIt.index());
const auto canSkip = [](const NamedSuccessor &successor) {
     return successor.constraint.getPredicate().isNull();
   };
   auto successors = op.getSuccessors();
   if (successors.empty() && llvm::all_of(successors, canSkip))
     return;
 
   body << "  {\n    unsigned index = 0; (void)index;\n";
 
-  for (auto &it : llvm::enumerate(successors)) {
+  for (auto &&it : llvm::enumerate(successors)) {
     const auto &successor = it.value();
     if (canSkip(successor))
       continue;
 
     auto getSuccessor =
         formatv(successor.isVariadic() ? "{0}()" : getSingleSuccessor,
                 successor.name, it.index())
             .str();

mlir/tools/mlir-tblgen/OpFormatGen.cpp

static void genEnumAttrPrinter(const NamedAttribute *var, const Operator &op,
   body << llvm::formatv(enumAttrBeginPrinterCode,
                         (var->attr.isOptional() ? "*" : "") +
                             op.getGetterName(var->name),
                         enumAttr.getSymbolToStringFnName());
 
   // Get a string containing all of the cases that can't be represented with a
   // keyword.
   BitVector nonKeywordCases(cases.size());
-  for (auto &it : llvm::enumerate(cases)) {
+  for (auto &&it : llvm::enumerate(cases)) {
     if (!canFormatStringAsKeyword(it.value().getStr()))
       nonKeywordCases.set(it.index());
   }
 
   // Otherwise if this is a bit enum attribute, don't allow cases that may
   // overlap with other cases. For simplicity sake, only allow cases with a
   // single bit value.
   if (enumAttr.isBitEnum()) {
-    for (auto &it : llvm::enumerate(cases)) {
+    for (auto &&it : llvm::enumerate(cases)) {
       int64_t value = it.value().getValue();
       if (value < 0 || !llvm::isPowerOf2_64(value))
         nonKeywordCases.set(it.index());
     }
   }
 
   // If there are any cases that can't be used with a keyword, switch on the
   // case value to determine when to print in the string form.
   if (nonKeywordCases.any()) {
     body << "    switch (caseValue) {\n";
     StringRef cppNamespace = enumAttr.getCppNamespace();
     StringRef enumName = enumAttr.getEnumClassName();
-    for (auto &it : llvm::enumerate(cases)) {
+    for (auto &&it : llvm::enumerate(cases)) {
       if (nonKeywordCases.test(it.index()))
         continue;
       StringRef symbol = it.value().getSymbol();
       body << llvm::formatv("    case {0}::{1}::{2}:\n", cppNamespace, enumName,
                             llvm::isDigit(symbol.front()) ? ("_" + symbol)
                                                           : symbol);
     }
     body << "      _odsPrinter << caseValueStr;\n"