[mlir][vector] Fix typo, NFC.

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

LogicalResult matchAndRewrite(vector::ReductionOp reductionOp,
     rewriter.replaceOp(reductionOp, accumulator);
     return success();
   }
 
 private:
   const vector::UnrollVectorOptions options;
 };
 
-struct UnrollTranposePattern : public OpRewritePattern<vector::TransposeOp> {
-  UnrollTranposePattern(MLIRContext *context,
+struct UnrollTransposePattern : public OpRewritePattern<vector::TransposeOp> {
+  UnrollTransposePattern(MLIRContext *context,
                          const vector::UnrollVectorOptions &options,
                          PatternBenefit benefit = 1)
       : OpRewritePattern<vector::TransposeOp>(context, benefit),
         options(options) {}
 
-  LogicalResult matchAndRewrite(vector::TransposeOp tranposeOp,
+  LogicalResult matchAndRewrite(vector::TransposeOp transposeOp,
                                 PatternRewriter &rewriter) const override {
-    if (tranposeOp.getResultType().getRank() == 0)
+    if (transposeOp.getResultType().getRank() == 0)
       return failure();
-    auto targetShape = getTargetShape(options, tranposeOp);
+    auto targetShape = getTargetShape(options, transposeOp);
     if (!targetShape)
       return failure();
-    auto originalVectorType = tranposeOp.getResultType();
+    auto originalVectorType = transposeOp.getResultType();
     SmallVector<int64_t> strides(targetShape->size(), 1);
-    Location loc = tranposeOp.getLoc();
+    Location loc = transposeOp.getLoc();
     ArrayRef<int64_t> originalSize = originalVectorType.getShape();
     SmallVector<int64_t> ratio = *computeShapeRatio(originalSize, *targetShape);
     int64_t sliceCount = computeMaxLinearIndex(ratio);
     // Prepare the result vector;
     Value result = rewriter.create<arith::ConstantOp>(
         loc, originalVectorType, rewriter.getZeroAttr(originalVectorType));
     SmallVector<int64_t> permutation;
-    tranposeOp.getTransp(permutation);
+    transposeOp.getTransp(permutation);
 
     // Stride of the ratios, this gives us the offsets of sliceCount in a basis
     // 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)) {
         permutedOffsets[indices.value()] = elementOffsets[indices.index()];
         permutedShape[indices.value()] = (*targetShape)[indices.index()];
       }
       Value slicedOperand = rewriter.create<vector::ExtractStridedSliceOp>(
-          loc, tranposeOp.getVector(), permutedOffsets, permutedShape, strides);
-      Value tranposedSlice =
+          loc, transposeOp.getVector(), permutedOffsets, permutedShape,
+          strides);
+      Value transposedSlice =
           rewriter.create<vector::TransposeOp>(loc, slicedOperand, permutation);
       result = rewriter.create<vector::InsertStridedSliceOp>(
-          loc, tranposedSlice, result, elementOffsets, strides);
+          loc, transposedSlice, result, elementOffsets, strides);
     }
-    rewriter.replaceOp(tranposeOp, result);
+    rewriter.replaceOp(transposeOp, result);
     return success();
   }
 
 private:
   vector::UnrollVectorOptions options;
 };
 
 } // namespace
 
 void mlir::vector::populateVectorUnrollPatterns(
     RewritePatternSet &patterns, const UnrollVectorOptions &options,
     PatternBenefit benefit) {
   patterns.add<UnrollTransferReadPattern, UnrollTransferWritePattern,
                UnrollContractionPattern, UnrollElementwisePattern,
                UnrollReductionPattern, UnrollMultiReductionPattern,
-               UnrollTranposePattern>(patterns.getContext(), options, benefit);
+               UnrollTransposePattern>(patterns.getContext(), options, benefit);
 }