[mlir] NFC: fix trivial typos fix typos in comments and documents

[jpienaar]

Thanks

mlir/docs/OpDefinitions.md

 ```
 custom-directive ::= `custom` `<` UserDirective `>` `(` Params `)`
 ```
 
 A custom directive has two main parts: The `UserDirective` and the `Params`. A
 custom directive is transformed into a call to a `print*` and a `parse*` method
 when generating the C++ code for the format. The `UserDirective` is an
 identifier used as a suffix to these two calls, i.e., `custom<MyDirective>(...)`
-would result in calls to `parseMyDirective` and `printMyDirective` wihtin the
+would result in calls to `parseMyDirective` and `printMyDirective` within the
 parser and printer respectively. `Params` may be any combination of variables
 (i.e. Attribute, Operand, Successor, etc.) and type directives. The type
 directives must refer to a variable, but that variable need not also be a
 parameter to the custom directive.
 
 The arguments to the `parse<UserDirective>` method is firstly a reference to the
 `OpAsmParser`(`OpAsmParser &`), and secondly a set of output parameters
 corresponding to the parameters specified in the format. The mapping of
let parser = [{
     return get(ctxt, width);
   }];
 ```
 
 ### Type name
 
 The name of the C++ class which gets generated defaults to
 `<classParamName>Type` (e.g. `TestIntegerType` in the above example). This
-can be overridden via the the `cppClassName` field. The field `mnemonic` is
+can be overridden via the `cppClassName` field. The field `mnemonic` is
 to specify the asm name for parsing. It is optional and not specifying it
 will imply that no parser or printer methods are attached to this class.
 
 ### Type documentation
 
 The `summary` and `description` fields exist and are to be used the same way
 as in Operations. Namely, the summary should be a one-liner and `description`
 should be a longer explanation.

 let parameters = (ins
   "ArrayRef<int>":$dims);
 ```
 
 The default storage constructor blindly copies fields by value. It does not
 know anything about the types. In this case, the ArrayRef<int> requires
 allocation with `dims = allocator.copyInto(dims)`.
 
-You can specify the necessary constuctor by specializing the `TypeParameter`
+You can specify the necessary constructor by specializing the `TypeParameter`
 tblgen class:
 
 ```tablegen
 class ArrayRefIntParam :
     TypeParameter<"::llvm::ArrayRef<int>", "Array of ints"> {
   let allocator = [{$_dst = $_allocator.copyInto($_self);}];
 }
 

mlir/include/mlir-c/Diagnostics.h

 
 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/** An opaque reference to a dignostic, always owned by the diagnostics engine
+/** An opaque reference to a diagnostic, always owned by the diagnostics engine
  * (context). Must not be stored outside of the diagnostic handler. */
 struct MlirDiagnostic {
   void *ptr;
 };
 typedef struct MlirDiagnostic MlirDiagnostic;
 
 /** Severity of a diagnostic. */
 enum MlirDiagnosticSeverity {

mlir/include/mlir-c/StandardAttributes.h

 MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, intptr_t length,
                                    const char *symbol, intptr_t numReferences,
                                    MlirAttribute *references);
 
 /** Returns the string reference to the root referenced symbol. The data remains
  * live as long as the context in which the attribute lives. */
 MlirStringRef mlirSymbolRefAttrGetRootReference(MlirAttribute attr);
 
-/** Returns the stirng reference to the leaf referenced symbol. The data remains
+/** Returns the string reference to the leaf referenced symbol. The data remains
  * live as long as the context in which the attribute lives. */
 MlirStringRef mlirSymbolRefAttrGetLeafReference(MlirAttribute attr);
 
 /** Returns the number of references nested in the given symbol reference
  * attribute. */
 intptr_t mlirSymbolRefAttrGetNumNestedReferences(MlirAttribute attr);
 
 /** Returns pos-th reference nested in the given symbol reference attribute. */

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

let description = [{
     "compute1" starts) is a completely legal execution.
 
     Because concurrent execution is not guaranteed, it is illegal to create an
     implicit dependency from "compute1" to "compute0" (e.g. via shared global
     state). All dependencies must be made explicit with async execute arguments
     (`async.token` or `async.value`).
 
    `async.execute` operation takes `async.token` dependencies and `async.value`
-    operands separatly, and starts execution of the attached body region only
+    operands separately, and starts execution of the attached body region only
     when all tokens and values become ready.
 
     Example:
 
     ```mlir
     %dependency = ... : !async.token
     %value = ... : !async.value<f32>
 

mlir/include/mlir/IR/OpBase.td

TypedAttrBase<
       attrValType, "IntegerAttr",
       And<[CPred<"$_self.isa<::mlir::IntegerAttr>()">,
            CPred<"$_self.cast<::mlir::IntegerAttr>().getType()."
                  "isSignlessInteger(" # attrValType.bitwidth # ")">]>,
       descr> {
   let returnType = [{ ::llvm::APInt }];
 }
 // Base class for signless integer attributes of fixed width that have a
-// correpsonding C++ type.
+// corresponding C++ type.
 class TypedSignlessIntegerAttrBase<I attrValType, string retType, string descr>
     : SignlessIntegerAttrBase<attrValType, descr> {
   let returnType = retType;
   let convertFromStorage = "$_self.getValue().getZExtValue()";
 }
 
 def I1Attr  : TypedSignlessIntegerAttrBase<
     I1,  "bool",     "1-bit signless integer attribute">;
TypedAttrBase<
       attrValType, "IntegerAttr",
       And<[CPred<"$_self.isa<::mlir::IntegerAttr>()">,
            CPred<"$_self.cast<::mlir::IntegerAttr>().getType()."
                  "isSignedInteger(" # attrValType.bitwidth # ")">]>,
       descr> {
   let returnType = [{ ::llvm::APInt }];
 }
 // Base class for signed integer attributes of fixed width that have a
-// correpsonding C++ type.
+// corresponding C++ type.
 class TypedSignedIntegerAttrBase<SI attrValType, string retType, string descr>
     : SignedIntegerAttrBase<attrValType, descr> {
   let returnType = retType;
   let convertFromStorage = "$_self.getValue().getSExtValue()";
 }
 
 def SI1Attr  : TypedSignedIntegerAttrBase<
     SI1,  "bool",    "1-bit signed integer attribute">;
TypedAttrBase<
       attrValType, "IntegerAttr",
       And<[CPred<"$_self.isa<::mlir::IntegerAttr>()">,
            CPred<"$_self.cast<::mlir::IntegerAttr>().getType()."
                  "isUnsignedInteger(" # attrValType.bitwidth # ")">]>,
       descr> {
   let returnType = [{ ::llvm::APInt }];
 }
 // Base class for unsigned integer attributes of fixed width that have a
-// correpsonding C++ type.
+// corresponding C++ type.
 class TypedUnsignedIntegerAttrBase<UI attrValType, string retType, string descr>
     : UnsignedIntegerAttrBase<attrValType, descr> {
   let returnType = retType;
   let convertFromStorage = "$_self.getValue().getZExtValue()";
 }
 
 def UI1Attr  : TypedUnsignedIntegerAttrBase<
     UI1,  "bool",     "1-bit unsigned integer attribute">;

mlir/include/mlir/Reducer/Passes/OpReducer.h

 //===- OpReducer.h - MLIR Reduce Operation Reducer ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the OpReducer class. It defines a variant generator method
 // with the purpose of producing different variants by eliminating a
-// parametarizable type of operations from the  parent module.
+// parameterizable type of operations from the  parent module.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_REDUCER_PASSES_OPREDUCER_H
 #define MLIR_REDUCER_PASSES_OPREDUCER_H
 
 #include "mlir/IR/Region.h"
 #include "mlir/Reducer/ReductionNode.h"

mlir/include/mlir/Support/IndentedOstream.h

public:
   };
 
   /// Returns DelimitedScope.
   DelimitedScope scope(StringRef open = "", StringRef close = "") {
     return DelimitedScope(*this, open, close);
   }
 
   /// Re-indents by removing the leading whitespace from the first non-empty
-  /// line from every line of the the string, skipping over empty lines at the
+  /// line from every line of the string, skipping over empty lines at the
   /// start.
   raw_indented_ostream &reindent(StringRef str);
 
   /// Increases the indent and returning this raw_indented_ostream.
   raw_indented_ostream &indent() {
     currentIndent += indentSize;
     return *this;
   }

mlir/integration_test/Dialect/Vector/CPU/test-create-mask-v4i1.mlir

 // RUN: mlir-opt %s -convert-scf-to-std -convert-vector-to-llvm -convert-std-to-llvm | \
 // RUN: mlir-cpu-runner -e entry -entry-point-result=void  \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
 // NOTE: This is similar to test-create-mask.mlir, but with a different length,
-//       because the v4i1 vector specifially exposed bugs in the LLVM backend.
+//       because the v4i1 vector specifically exposed bugs in the LLVM backend.
 
 func @entry() {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
   %c3 = constant 3 : index
   %c5 = constant 5 : index
 

mlir/lib/Analysis/Presburger/Simplex.cpp

 
 /// Mark this tableau empty and push an entry to the undo stack.
 void Simplex::markEmpty() {
   undoLog.push_back(UndoLogEntry::UnmarkEmpty);
   empty = true;
 }
 
 /// Add an inequality to the tableau. If coeffs is c_0, c_1, ... c_n, where n
-/// is the curent number of variables, then the corresponding inequality is
+/// is the current number of variables, then the corresponding inequality is
 /// c_n + c_0*x_0 + c_1*x_1 + ... + c_{n-1}*x_{n-1} >= 0.
 ///
 /// We add the inequality and mark it as restricted. We then try to make its
 /// sample value non-negative. If this is not possible, the tableau has become
 /// empty and we mark it as such.
 void Simplex::addInequality(ArrayRef<int64_t> coeffs) {
   unsigned conIndex = addRow(coeffs);
   Unknown &u = con[conIndex];
   u.restricted = true;
   LogicalResult result = restoreRow(u);
   if (failed(result))
     markEmpty();
 }
 
 /// Add an equality to the tableau. If coeffs is c_0, c_1, ... c_n, where n
-/// is the curent number of variables, then the corresponding equality is
+/// is the current number of variables, then the corresponding equality is
 /// c_n + c_0*x_0 + c_1*x_1 + ... + c_{n-1}*x_{n-1} == 0.
 ///
 /// We simply add two opposing inequalities, which force the expression to
 /// be zero.
 void Simplex::addEquality(ArrayRef<int64_t> coeffs) {
   addInequality(coeffs);
   SmallVector<int64_t, 8> negatedCoeffs;
   for (int64_t coeff : coeffs)
     negatedCoeffs.emplace_back(-coeff);
   addInequality(negatedCoeffs);
 }
 
 unsigned Simplex::numVariables() const { return var.size(); }
 unsigned Simplex::numConstraints() const { return con.size(); }
 
-/// Return a snapshot of the curent state. This is just the current size of the
+/// Return a snapshot of the current state. This is just the current size of the
 /// undo log.
 unsigned Simplex::getSnapshot() const { return undoLog.size(); }
 
 void Simplex::undo(UndoLogEntry entry) {
   if (entry == UndoLogEntry::RemoveLastConstraint) {
     Unknown &constraint = con.back();
     if (constraint.orientation == Orientation::Column) {
       unsigned column = constraint.pos;

mlir/lib/Bindings/Python/IRModules.cpp

public:
   }
 
 private:
   PyOperationRef operation;
   MlirBlock next;
 };
 
 /// Blocks are exposed by the C-API as a forward-only linked list. In Python,
-/// we present them as a more full-featured list-like container but optimzie
+/// we present them as a more full-featured list-like container but optimize
 /// it for forward iteration. Blocks are always owned by a region.
 class PyBlockList {
 public:
   PyBlockList(PyOperationRef operation, MlirRegion region)
       : operation(std::move(operation)), region(region) {}
 
   PyBlockIterator dunderIter() {
     operation->checkValid();

 
 private:
   PyOperationRef parentOperation;
   MlirOperation next;
 };
 
 /// Operations are exposed by the C-API as a forward-only linked list. In
 /// Python, we present them as a more full-featured list-like container but
-/// optimzie it for forward iteration. Iterable operations are always owned
+/// optimize it for forward iteration. Iterable operations are always owned
 /// by a block.
 class PyOperationList {
 public:
   PyOperationList(PyOperationRef parentOperation, MlirBlock block)
       : parentOperation(std::move(parentOperation)), block(block) {}
 
   PyOperationIterator dunderIter() {
     parentOperation->checkValid();

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.cpp

 public:
   using SPIRVOpLowering<SourceOp>::SPIRVOpLowering;
 
   LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
-/// Pattern lowering subgoup size/id to loading SPIR-V invocation
+/// Pattern lowering subgroup size/id to loading SPIR-V invocation
 /// builtin variables.
 template <typename SourceOp, spirv::BuiltIn builtin>
 class SingleDimLaunchConfigConversion : public SPIRVOpLowering<SourceOp> {
 public:
   using SPIRVOpLowering<SourceOp>::SPIRVOpLowering;
 
   LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

return rewriter.create<LLVM::ConstantOp>(
         SplatElementsAttr::get(vecType,
                                rewriter.getFloatAttr(floatType, value)));
   }
   auto floatType = srcType.cast<FloatType>();
   return rewriter.create<LLVM::ConstantOp>(
       loc, dstType, rewriter.getFloatAttr(floatType, value));
 }
 
-/// Utility function for bitfiled ops:
+/// Utility function for bitfield ops:
 ///   - `BitFieldInsert`
 ///   - `BitFieldSExtract`
 ///   - `BitFieldUExtract`
 /// Truncates or extends the value. If the bitwidth of the value is the same as
 /// `dstType` bitwidth, the value remains unchanged.
 static Value optionallyTruncateOrExtend(Location loc, Value value, Type dstType,
                                         PatternRewriter &rewriter) {
   auto srcType = value.getType();
static Value optionallyBroadcast(Location loc, Value value, Type srcType,
                                  ConversionPatternRewriter &rewriter) {
   if (auto vectorType = srcType.dyn_cast<VectorType>()) {
     unsigned numElements = vectorType.getNumElements();
     return broadcast(loc, value, numElements, typeConverter, rewriter);
   }
   return value;
 }
 
-/// Utility function for bitfiled ops: `BitFieldInsert`, `BitFieldSExtract` and
+/// Utility function for bitfield ops: `BitFieldInsert`, `BitFieldSExtract` and
 /// `BitFieldUExtract`.
 /// Broadcast `Offset` and `Count` to match the type of `Base`. If `Base` is of
 /// a vector type, construct a vector that has:
 ///  - same number of elements as `Base`
 ///  - each element has the type that is the same as the type of `Offset` or
 ///    `Count`
 ///  - each element has the same value as `Offset` or `Count`
 /// Then cast `Offset` and `Count` if their bit width is different
public:
   matchAndRewrite(spirv::LoopOp loopOp, ArrayRef<Value> operands,
                   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.loop`. The remaing ops will be used in
-    // `endBlock`.
+    // Split the current block after `spv.loop`. The remaining ops will be used
+    // in `endBlock`.
     Block *currentBlock = rewriter.getBlock();
     auto position = Block::iterator(loopOp);
     Block *endBlock = rewriter.splitBlock(currentBlock, position);
 
     // Remove entry block and create a branch in the current block going to the
     // header block.
     Block *entryBlock = loopOp.getEntryBlock();
     assert(entryBlock->getOperations().size() == 1);
matchAndRewrite(spirv::SelectionOp op, ArrayRef<Value> operands,
     // redundant and it is erased.
     if (op.body().getBlocks().size() <= 2) {
       rewriter.eraseOp(op);
       return success();
     }
 
     Location loc = op.getLoc();
 
-    // Split the current block after `spv.selection`. The remaing ops will be
+    // Split the current block after `spv.selection`. The remaining ops will be
     // used in `continueBlock`.
     auto *currentBlock = rewriter.getInsertionBlock();
     rewriter.setInsertionPointAfter(op);
     auto position = rewriter.getInsertionPoint();
     auto *continueBlock = rewriter.splitBlock(currentBlock, position);
 
     // Extract conditional branch information from the header block. By SPIR-V
     // dialect spec, it should contain `spv.BranchConditional` or `spv.Switch`
patterns.insert<
 
       // Control Flow ops
       BranchConversionPattern, BranchConditionalConversionPattern,
       FunctionCallPattern, LoopPattern, SelectionPattern,
       ErasePattern<spirv::MergeOp>,
 
       // Entry points and execution mode
       // Module generated from SPIR-V could have other "internal" functions, so
-      // having entry point and execution mode metadat can be useful. For now,
+      // having entry point and execution mode metadata can be useful. For now,
       // simply remove them.
       // TODO: Support EntryPoint/ExecutionMode properly.
       ErasePattern<spirv::EntryPointOp>, ErasePattern<spirv::ExecutionModeOp>,
 
       // GLSL extended instruction set ops
       DirectConversionPattern<spirv::GLSLCeilOp, LLVM::FCeilOp>,
       DirectConversionPattern<spirv::GLSLCosOp, LLVM::CosOp>,
       DirectConversionPattern<spirv::GLSLExpOp, LLVM::ExpOp>,

mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp

rewriter.replaceOpWithNewOp<DynamicTensorFromElementsOp>(
         // invalid.
         auto ifOp = b.create<IfOp>(
             loc, TypeRange{indexTy}, isUnchallengedDimension,
             [&](OpBuilder &b, Location loc) {
               b.create<scf::YieldOp>(loc, greaterRankOperandExtent);
             },
             [&](OpBuilder &b, Location loc) {
               // The broadcasting logic is:
-              // - if one extent (here we arbitrariliy choose the extent from
+              // - if one extent (here we arbitrarily choose the extent from
               // the greater-rank operand) is equal to 1, then take the extent
               // from the other operand
               // - otherwise, take the extent as-is.
               // Note that this logic remains correct in the presence of
               // dimensions of zero extent.
               Value lesserRankOperandDimension =
                   b.create<SubIOp>(loc, indexTy, outputDimension, rankDiff);
               Value lesserRankOperandExtent = b.create<ExtractElementOp>(

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 
 // Function types are converted to LLVM Function types by recursively converting
 // argument and result types.  If MLIR Function has zero results, the LLVM
 // Function has one VoidType result.  If MLIR Function has more than one result,
 // they are into an LLVM StructType in their order of appearance.
 LLVM::LLVMType LLVMTypeConverter::convertFunctionSignature(
     FunctionType funcTy, bool isVariadic,
     LLVMTypeConverter::SignatureConversion &result) {
-  // Select the argument converter depending on the calling convetion.
+  // 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())) {
     Type type = en.value();
     SmallVector<Type, 8> converted;
     if (failed(funcArgConverter(*this, type, converted)))

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp

 public:
   using SPIRVOpLowering<CmpFOp>::SPIRVOpLowering;
 
   LogicalResult
   matchAndRewrite(CmpFOp cmpFOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
-/// Converts integer compare operation on i1 type opearnds to SPIR-V ops.
+/// Converts integer compare operation on i1 type operands to SPIR-V ops.
 class BoolCmpIOpPattern final : public SPIRVOpLowering<CmpIOp> {
 public:
   using SPIRVOpLowering<CmpIOp>::SPIRVOpLowering;
 
   LogicalResult
   matchAndRewrite(CmpIOp cmpIOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;
 };

mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp

matchAndRewrite(Operation *op, ArrayRef<Value> operands,
     // MUBUF instruction operate only on addresspace 0(unified) or 1(global)
     // In case of 3(LDS): fall back to vector->llvm pass
     // In case of 5(VGPR): wrong
     if ((memRefType.getMemorySpace() != 0) &&
         (memRefType.getMemorySpace() != 1))
       return failure();
 
     // Note that the dataPtr starts at the offset address specified by
-    // indices, so no need to calculat offset size in bytes again in
+    // indices, so no need to calculate offset size in bytes again in
     // the MUBUF instruction.
     Value dataPtr = getDataPtr(loc, memRefType, adaptor.memref(),
                                adaptor.indices(), rewriter);
 
     // 1. Create and fill a <4 x i32> dwordConfig with:
     //    1st two elements holding the address of dataPtr.
     //    3rd element: -1.
     //    4th element: 0x27000.

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

extractBeneficiaryOps(Operation *op,
                       llvm::SmallPtrSetImpl<Value> &availableValues) {
   if (beneficiaryOps.count(op))
     return true;
 
   if (!isSinkingBeneficiary(op))
     return false;
 
   for (Value operand : op->getOperands()) {
-    // It is already visisble in the kernel, keep going.
+    // It is already visible in the kernel, keep going.
     if (availableValues.count(operand))
       continue;
     // Else check whether it can be made available via sinking or already is a
     // dependency.
     Operation *definingOp = operand.getDefiningOp();
     if ((!definingOp ||
          !extractBeneficiaryOps(definingOp, existingDependencies,
                                 beneficiaryOps, availableValues)) &&

mlir/lib/Dialect/LLVMIR/IR/TypeDetail.h

public:
     /// Constructs a key for a literal struct.
     Key(ArrayRef<LLVMType> types, bool packed)
         : types(types), identified(false), packed(packed), opaque(false) {}
 
     /// Checks a specific property of the struct.
     bool isIdentified() const { return identified; }
     bool isPacked() const {
       assert(!isIdentified() &&
-             "'packed' bit is not part of the key for identified stucts");
+             "'packed' bit is not part of the key for identified structs");
       return packed;
     }
     bool isOpaque() const {
       assert(isIdentified() &&
              "'opaque' bit is meaningless on literal structs");
       return opaque;
     }
 
public:
   bool isInitialized() const {
     return llvm::Bitfield::get<MutableFlagInitialized>(
         identifiedBodySizeAndFlags);
   }
 
   /// Constructs the storage from the given key. This sets up the uniquing key
   /// components and optionally the mutable component if they construction key
   /// has the relevant information. In the latter case, the struct is considered
-  /// as initalized and can no longer be mutated.
+  /// as initialized and can no longer be mutated.
   LLVMStructTypeStorage(const KeyTy &key) {
     if (!key.isIdentified()) {
       ArrayRef<LLVMType> types = key.getTypeList();
       keyPtr = static_cast<const void *>(types.data());
       setKeySize(types.size());
       llvm::Bitfield::set<KeyFlagPacked>(keySizeAndFlags, key.isPacked());
       return;
     }

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

getSymbolLessAffineMaps(ArrayRef<ReassociationExprs> reassociation) {
   }
   return maps;
 }
 
 static SmallVector<SmallVector<AffineExpr, 2>, 2>
 convertReassociationIndicesToMaps(
     OpBuilder &b, ArrayRef<ReassociationIndices> reassociationIndices) {
   SmallVector<SmallVector<AffineExpr, 2>, 2> reassociationMaps;
-  for (const auto &indicies : reassociationIndices) {
+  for (const auto &indices : reassociationIndices) {
     SmallVector<AffineExpr, 2> reassociationMap;
-    reassociationMap.reserve(indicies.size());
-    for (int64_t index : indicies)
+    reassociationMap.reserve(indices.size());
+    for (int64_t index : indices)
       reassociationMap.push_back(b.getAffineDimExpr(index));
     reassociationMaps.push_back(std::move(reassociationMap));
   }
   return reassociationMaps;
 }
 
 void mlir::linalg::ReshapeOp::build(OpBuilder &b, OperationState &result,
                                     Value src,

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

for (auto en : llvm::enumerate(ios)) {
     }
     clonedViews.push_back(
         b.create<SubViewOp>(loc, view, offsets, sizes, strides));
   }
   auto operands = op.getAssumedNonShapedOperands();
   clonedViews.append(operands.begin(), operands.end());
 
   Operation *clonedOp = op.clone(b, loc, /*resultTypes*/ {}, clonedViews);
-  // When the producer is an IndexedGenercOp, we have to transform its block
+  // When the producer is an IndexedGenericOp, we have to transform its block
   // IV arguments according to the tiling of the consumer, i.e. offset them by
   // the values computed in `loopRanges`.
   if (auto indexedGenericOp = dyn_cast<IndexedGenericOp>(clonedOp)) {
     auto &block = indexedGenericOp.region().front();
 
     OpBuilder::InsertionGuard g(b);
     b.setInsertionPointToStart(&block);
     for (unsigned i = 0, e = indexedGenericOp.getNumLoops(); i < e; ++i) {

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

if (consumerArg.index() == consumerIdx + numConsumerIndices) {
           mapper.map(producerArg.value(),
                      fusedBlock->addArgument(producerArg.value().getType()));
         }
       }
       continue;
     }
 
     // If consumer is an indexed_generic op, map the indices to the block
-    // arguments directly. Otherwise, add the same type of arugment and map to
+    // arguments directly. Otherwise, add the same type of argument and map to
     // it.
     if (consumerArg.index() < numConsumerIndices) {
       mapper.map(consumerArg.value(),
                  fusedBlock->getArgument(consumerArg.index()));
     } else {
       mapper.map(consumerArg.value(),
                  fusedBlock->addArgument(consumerArg.value().getType()));
     }

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

func.walk([&changed](Operation *op) {
         loop.moveOutOfLoop({op});
       else // Move DeallocOp outside of the loop.
         op->moveAfter(loop);
       changed = true;
     });
   }
 }
 
-/// Return true if we can prove that the transfer operations access dijoint
+/// Return true if we can prove that the transfer operations access disjoint
 /// memory.
 static bool isDisjoint(VectorTransferOpInterface transferA,
                        VectorTransferOpInterface transferB) {
   if (transferA.memref() != transferB.memref())
     return false;
   // For simplicity only look at transfer of same type.
   if (transferA.getVectorType() != transferB.getVectorType())
     return false;

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

struct LinalgOpInstancePromotionOptions {
 
   /// Callback functions for allocation and deallocation of promoted buffers, as
   /// well as to copy the data into and out of these buffers.
   AllocBufferCallbackFn allocationFn;
   DeallocBufferCallbackFn deallocationFn;
   CopyCallbackFn copyInFn;
   CopyCallbackFn copyOutFn;
 
-  /// Allow the use of dynamicaly-sized buffers.
+  /// Allow the use of dynamically-sized buffers.
   bool dynamicBuffers;
   /// Alignment of promoted buffer.
   Optional<unsigned> alignment;
 };
 
 struct PromotionInfo {
   Value fullLocalView;
   Value partialLocalView;

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

if (failed(parseOptionalArrayStride(dialect, parser, stride)))
     return Type();
 
   if (parser.parseGreater())
     return Type();
   return ArrayType::get(elementType, count, stride);
 }
 
 // cooperative-matrix-type ::= `!spv.coopmatrix` `<` element-type ',' scope ','
-//                                                   rows ',' coloumns>`
+//                                                   rows ',' columns>`
 static Type parseCooperativeMatrixType(SPIRVDialect const &dialect,
                                        DialectAsmParser &parser) {
   if (parser.parseLess())
     return Type();
 
   SmallVector<int64_t, 2> dims;
   llvm::SMLoc countLoc = parser.getCurrentLocation();
   if (parser.parseDimensionList(dims, /*allowDynamic=*/false))
static auto removeIdentifierAndFail =
         return Type();
       };
 
   if (parser.parseLess())
     return Type();
 
   StringRef identifier;
 
-  // Check if this is an idenitifed struct type.
+  // Check if this is an identified struct type.
   if (succeeded(parser.parseOptionalKeyword(&identifier))) {
     // Check if this is a possible recursive reference.
     if (succeeded(parser.parseOptionalGreater())) {
       if (structContext.count(identifier) == 0) {
         parser.emitError(
             parser.getNameLoc(),
             "recursive struct reference not nested in struct definition");
 

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

if (parser.parseComma() ||
                               state.attributes)) {
       return failure();
     }
   }
   return parser.parseRSquare();
 }
 
 // TODO Make sure to merge this and the previous function into one template
-// parameterized by memroy access attribute name and alignment. Doing so now
+// parameterized by memory access attribute name and alignment. Doing so now
 // results in VS2017 in producing an internal error (at the call site) that's
-// not detailed enough to understand what is happenning.
+// not detailed enough to understand what is happening.
 static ParseResult parseSourceMemoryAccessAttributes(OpAsmParser &parser,
                                                      OperationState &state) {
   // Parse an optional list of attributes staring with '['
   if (parser.parseOptionalLSquare()) {
     // Nothing to do
     return success();
   }
 
if (spirv::bitEnumContains(*memAccess, spirv::MemoryAccess::Aligned)) {
       }
     }
     printer << "]";
   }
   elidedAttrs.push_back(spirv::attributeName<spirv::StorageClass>());
 }
 
 // TODO Make sure to merge this and the previous function into one template
-// parameterized by memroy access attribute name and alignment. Doing so now
+// parameterized by memory access attribute name and alignment. Doing so now
 // results in VS2017 in producing an internal error (at the call site) that's
-// not detailed enough to understand what is happenning.
+// not detailed enough to understand what is happening.
 template <typename MemoryOpTy>
 static void printSourceMemoryAccessAttribute(
     MemoryOpTy memoryOp, OpAsmPrinter &printer,
     SmallVectorImpl<StringRef> &elidedAttrs,
     Optional<spirv::MemoryAccess> memoryAccessAtrrValue = None,
     Optional<uint32_t> alignmentAttrValue = None) {
 
   printer << ", ";
if (op->getAttr(kAlignmentAttrName)) {
           "invalid alignment specification with non-aligned memory access "
           "specification");
     }
   }
   return success();
 }
 
 // TODO Make sure to merge this and the previous function into one template
-// parameterized by memroy access attribute name and alignment. Doing so now
+// parameterized by memory access attribute name and alignment. Doing so now
 // results in VS2017 in producing an internal error (at the call site) that's
-// not detailed enough to understand what is happenning.
+// not detailed enough to understand what is happening.
 template <typename MemoryOpTy>
 static LogicalResult verifySourceMemoryAccessAttribute(MemoryOpTy memoryOp) {
   // ODS checks for attributes values. Just need to verify that if the
   // memory-access attribute is Aligned, then the alignment attribute must be
   // present.
   auto *op = memoryOp.getOperation();
   auto memAccessAttr = op->getAttr(kSourceMemoryAccessAttrName);
   if (!memAccessAttr) {

mlir/lib/Dialect/SPIRV/SPIRVTypes.cpp

struct spirv::detail::StructTypeStorage : public TypeStorage {
   /// of the key.
   ///
   /// A literal struct type is unqiued only by the second part (fields 1, 2, and
   /// 3) of the key. The identifier field (field 0) must be empty.
   using KeyTy =
       std::tuple<StringRef, ArrayRef<Type>, ArrayRef<StructType::OffsetInfo>,
                  ArrayRef<StructType::MemberDecorationInfo>>;
 
-  /// For idetified structs, return true if the given key contains the same
+  /// For identified structs, return true if the given key contains the same
   /// identifier.
   ///
   /// For literal structs, return true if the given key contains a matching list
   /// of member types + offset info + decoration info.
   bool operator==(const KeyTy &key) const {
     if (isIdentified()) {
       // Identified types are uniqued by their identifier.
       return getIdentifier() == std::get<0>(key);

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

if (auto ptrType = type.dyn_cast<spirv::PointerType>()) {
     }
   }
   return false;
 }
 
 LogicalResult Serializer::processType(Location loc, Type type,
                                       uint32_t &typeID) {
   // Maintains a set of names for nested identified struct types. This is used
-  // to properly seialize resursive references.
+  // to properly serialize resursive references.
   llvm::SetVector<StringRef> serializationCtx;
   return processTypeImpl(loc, type, typeID, serializationCtx);
 }
 
 LogicalResult
 Serializer::processTypeImpl(Location loc, Type type, uint32_t &typeID,
                             llvm::SetVector<StringRef> &serializationCtx) {
   typeID = getTypeID(type);
if (pointeeStruct && pointeeStruct.isIdentified() &&
       forwardPtrOperands.push_back(resultID);
       forwardPtrOperands.push_back(
           static_cast<uint32_t>(ptrType.getStorageClass()));
 
       encodeInstructionInto(typesGlobalValues,
                             spirv::Opcode::OpTypeForwardPointer,
                             forwardPtrOperands);
 
-      // 2. Find the the pointee (enclosing) struct.
+      // 2. Find the pointee (enclosing) struct.
       auto structType = spirv::StructType::getIdentified(
           module.getContext(), pointeeStruct.getIdentifier());
 
       if (!structType)
         return failure();
 
       // 3. Mark the OpTypePointer that is supposed to be emitted by this call
       // as deferred.

mlir/lib/Dialect/Vector/VectorOps.cpp

static Value foldExtractFromShapeCast(ExtractOp extractOp) {
   SmallVector<int64_t, 4> strides;
   int64_t stride = 1;
   for (int64_t i = 0, e = extractedPos.size(); i < e; i++) {
     strides.push_back(stride);
     stride *= getDimReverse(extractOp.getVectorType(), i + destinationRank);
   }
 
   int64_t position = linearize(extractedPos, strides);
-  // Then extract the strides assoociated to the shapeCast op vector source and
+  // Then extract the strides associated to the shapeCast op vector source and
   // delinearize the position using those strides.
   SmallVector<int64_t, 4> newStrides;
   int64_t numDimension =
       shapeCastOp.getSourceVectorType().getRank() - destinationRank;
   stride = 1;
   for (int64_t i = 0; i < numDimension; i++) {
     newStrides.push_back(stride);
     stride *=

mlir/lib/Dialect/Vector/VectorTransforms.cpp

 
 /// Given two MemRefTypes `aT` and `bT`, return a MemRefType to which both can
 /// be cast. If the MemRefTypes don't have the same rank or are not strided,
 /// return null; otherwise:
 ///   1. if `aT` and `bT` are cast-compatible, return `aT`.
 ///   2. else return a new MemRefType obtained by iterating over the shape and
 ///   strides and:
 ///     a. keeping the ones that are static and equal across `aT` and `bT`.
-///     b. using a dynamic shape and/or stride for the dimeniosns that don't
+///     b. using a dynamic shape and/or stride for the dimensions that don't
 ///        agree.
 static MemRefType getCastCompatibleMemRefType(MemRefType aT, MemRefType bT) {
   if (MemRefCastOp::areCastCompatible(aT, bT))
     return aT;
   if (aT.getRank() != bT.getRank())
     return MemRefType();
   int64_t aOffset, bOffset;
   SmallVector<int64_t, 4> aStrides, bStrides;

mlir/lib/IR/MLIRContext.cpp

#endif
   /// The MLIRContext owns the objects.
   DenseMap<StringRef, std::unique_ptr<Dialect>> loadedDialects;
   DialectRegistry dialectsRegistry;
 
   /// This is a mapping from operation name to AbstractOperation for registered
   /// operations.
   llvm::StringMap<AbstractOperation> registeredOperations;
 
-  /// Identifers are uniqued by string value and use the internal string set for
-  /// storage.
+  /// Identifiers are uniqued by string value and use the internal string set
+  /// for storage.
   llvm::StringSet<llvm::BumpPtrAllocator &> identifiers;
   /// A thread local cache of identifiers to reduce lock contention.
   ThreadLocalCache<llvm::StringMap<llvm::StringMapEntry<llvm::NoneType> *>>
       localIdentifierCache;
 
   /// An allocator used for AbstractAttribute and AbstractType objects.
   llvm::BumpPtrAllocator abstractDialectSymbolAllocator;
 

mlir/lib/IR/PatternMatch.cpp

 // block should not have existing predecessors or successors.
 void PatternRewriter::mergeBlockBefore(Block *source, Operation *op,
                                        ValueRange argValues) {
   assert(source->hasNoPredecessors() &&
          "expected 'source' to have no predecessors");
   assert(source->hasNoSuccessors() &&
          "expected 'source' to have no successors");
 
-  // Split the block containing 'op' into two, one containg all operations
+  // Split the block containing 'op' into two, one containing all operations
   // before 'op' (prologue) and another (epilogue) containing 'op' and all
   // operations after it.
   Block *prologue = op->getBlock();
   Block *epilogue = splitBlock(prologue, op->getIterator());
 
   // Merge the source block at the end of the prologue.
   mergeBlocks(source, prologue, argValues);
 

mlir/lib/Interfaces/ControlFlowInterfaces.cpp

LogicalResult detail::verifyTypesAlongControlFlowEdges(Operation *op) {
   // RegionBranchOpInterface should not be implemented by Ops that do not have
   // attached regions.
   assert(op->getNumRegions() != 0);
 
   // Verify types along control flow edges originating from each region.
   for (unsigned regionNo : llvm::seq(0U, op->getNumRegions())) {
     Region &region = op->getRegion(regionNo);
 
-    // Since the interface cannnot distinguish between different ReturnLike
+    // Since the interface cannot distinguish between different ReturnLike
     // ops within the region branching to different successors, all ReturnLike
     // ops in this region should have the same operand types. We will then use
     // one of them as the representative for type matching.
 
     Operation *regionReturn = nullptr;
     for (Block &block : region) {
       Operation *terminator = block.getTerminator();
       if (!terminator->hasTrait<OpTrait::ReturnLike>())

mlir/lib/Interfaces/VectorInterfaces.cpp

 //===- VectorInterfaces.cpp - Unrollable vector operations -*- C++ -*-===//
 //
 // 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/Interfaces/VectorInterfaces.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // VectorUnroll Interfaces
 //===----------------------------------------------------------------------===//
 
-/// Include the definitions of the VectorUntoll interfaces.
+/// Include the definitions of the VectorUnroll interfaces.
 #include "mlir/Interfaces/VectorInterfaces.cpp.inc"

mlir/lib/Reducer/Tester.cpp

 //===- Tester.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the Tester class used in the MLIR Reduce tool.
 //
 // A Tester object is passed as an argument to the reduction passes and it is
-// used to run the interestigness testing script on the different generated
+// used to run the interestingness testing script on the different generated
 // reduced variants of the test case.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Reducer/Tester.h"
 
 using namespace mlir;
 

mlir/lib/TableGen/CMakeLists.txt

 # This library is unusual, since mlir-tblgen depends on it, which is
 # built with DISABLE_LLVM_LINK_LLVM_DYLIB, this must also be built
 # with that option.  Otherwise builds with LLVM_BUILD_LLVM_DYLIB and
 # LLVM_LINK_LLVM_DYLIB fail.  (Note that even if this has no llvm
 # component dependencies, LLVM_LINK_LLVM_DYLIB tends to introduce a
 # dependence on libLLVM.so)  However, it must also be linkable against
 # libMLIR.so in some contexts (see unittests/Tablegen, for instance, which
-# has a dependance on MLIRIR, which must depend on libLLVM.so).  This works
+# has a dependence on MLIRIR, which must depend on libLLVM.so).  This works
 # in this special case because this library is static.
 
 llvm_add_library(MLIRTableGen STATIC
   Argument.cpp
   Attribute.cpp
   Constraint.cpp
   Dialect.cpp
   Format.cpp

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

return llvm::TypeSwitch<Operation *, LogicalResult>(&opInst)
         ompBuilder->CreateTaskwait(builder.saveIP());
         return success();
       })
       .Case([&](omp::TaskyieldOp) {
         ompBuilder->CreateTaskyield(builder.saveIP());
         return success();
       })
       .Case([&](omp::FlushOp) {
-        // No support in Openmp runtime funciton (__kmpc_flush) to accept
+        // No support in Openmp runtime function (__kmpc_flush) to accept
         // the argument list.
         // OpenMP standard states the following:
         //  "An implementation may implement a flush with a list by ignoring
         //   the list, and treating it the same as a flush without a list."
         //
         // The argument list is discarded so that, flush with a list is treated
         // same as a flush without a list.
         ompBuilder->CreateFlush(builder.saveIP());

mlir/lib/Transforms/Bufferize.cpp

public:
   void addMapping(Value value) { toValuesMapping.push_back({order++, value}); }
 
   /// Add the index of unavailble result value to the mapping.
   void addMapping(unsigned index) {
     toIndicesMapping.push_back({order++, index});
   }
 
   /// This method returns the mapping values list. The unknown result values
-  /// that only their indicies are available are replaced with their values.
+  /// that only their indices are available are replaced with their values.
   void getMappingValues(ValueRange valuesToReplaceIndices,
                         SmallVectorImpl<Value> &values) {
     // Append available values to the list.
     SmallVector<std::pair<unsigned, Value>, 2> res(toValuesMapping.begin(),
                                                    toValuesMapping.end());
     // Replace the indices with the actual values.
     for (const std::pair<unsigned, unsigned> &entry : toIndicesMapping) {
       assert(entry.second < valuesToReplaceIndices.size() &&

mlir/lib/Transforms/DialectConversion.cpp

void ArgConverter::insertConversion(Block *newBlock,
   // Move the original block to the mapped region and emplace the conversion.
   mappedRegion->getBlocks().splice(mappedRegion->end(), region->getBlocks(),
                                    info.origBlock->getIterator());
   convertedBlocks.insert(info.origBlock);
   conversionInfo.insert({newBlock, std::move(info)});
 }
 
 //===----------------------------------------------------------------------===//
-// Rewriter and Transation State
+// Rewriter and Translation State
 //===----------------------------------------------------------------------===//
 namespace {
 /// This class contains a snapshot of the current conversion rewriter state.
 /// This is useful when saving and undoing a set of rewrites.
 struct RewriterState {
   RewriterState(unsigned numCreatedOps, unsigned numReplacements,
                 unsigned numArgReplacements, unsigned numBlockActions,
                 unsigned numIgnoredOperations, unsigned numRootUpdates)

mlir/lib/Transforms/SCCP.cpp

 //===- SCCP.cpp - Sparse Conditional Constant Propagation -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This transformation pass performs a sparse conditional constant propagation
 // in MLIR. It identifies values known to be constant, propagates that
 // information throughout the IR, and replaces them. This is done with an
-// optimisitic dataflow analysis that assumes that all values are constant until
+// optimistic dataflow analysis that assumes that all values are constant until
 // proven otherwise.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
 namespace {
 /// This class represents a single lattice value. A lattive value corresponds to
-/// the various different states that a value in the SCCP dataflow anaylsis can
+/// the various different states that a value in the SCCP dataflow analysis can
 /// take. See 'Kind' below for more details on the different states a value can
 /// take.
 class LatticeValue {
   enum Kind {
     /// A value with a yet to be determined value. This state may be changed to
     /// anything.
     Unknown,
 

mlir/lib/Transforms/Utils/LoopUtils.cpp

 }
 
 /// Set lower and upper bounds of inter-tile loops for parametric tiling.
 //  TODO: Handle non-constant lower bounds.
 static void setInterTileBoundsParametric(OpBuilder &b, AffineForOp origLoop,
                                          AffineForOp newLoop, Value tileSize) {
   OperandRange newLbOperands = origLoop.getLowerBoundOperands();
 
-  // The lower bounds for inter-tile loops are same as the correspondig lower
+  // The lower bounds for inter-tile loops are same as the corresponding lower
   // bounds of original loops.
   newLoop.setLowerBound(newLbOperands, origLoop.getLowerBoundMap());
 
   // The new upper bound map for inter-tile loops, assuming constant lower
-  // bounds, are now originalLowerBound + ceildiv((orignalUpperBound -
-  // originalLowerBound), tiling paramter); where tiling parameter is the
+  // bounds, are now originalLowerBound + ceildiv((originalUpperBound -
+  // originalLowerBound), tiling parameter); where tiling parameter is the
   // respective tile size for that loop. For e.g. if the original ubmap was
   // ()->(1024), the new map will be
   // ()[s0]->(ceildiv((1024 -lb) % s0)), where s0 is the tiling parameter.
   // Therefore a new symbol operand is inserted in the map and the result
   // expression is overwritten.
 
   assert(origLoop.hasConstantLowerBound() &&
          "expected input loops to have constant lower bound.");
boundExprs.push_back(
         origLowerBoundExpr +
         (origUpperBoundExpr - origLowerBoundExpr).ceilDiv(tileParameter));
   } else {
     // If upper bound for the original loop is not constant then two cases
     // are possible, although there handeling is the same, 1.) The result of
     // ubmap has only one result expression. For e.g.
     //    affine.for %i = 5 to %ub
     //
-    // A symbol operand is added which represents the tiling paramater. The
+    // A symbol operand is added which represents the tiling parameter. The
     // new loop bounds here will be like ()[s0, s1] -> ((s0 - 5) ceildiv s1 + 5)
     // where 's0' is the original upper bound and 's1' is the tiling
     // parameter. 2.) When ubMap has more than one result expression. For e.g.
     //    #map0 = affine_map<()[s0, s1] -> (s0, s1)
     //    affine.for %i = 5 to min #map0()[%s0, %s1]
     //
     // A symbol operand is added which represents the tiling parameter. The
     // new loop bounds will be like ()[s0, s1, s2] -> ((s0 - 5) ceildiv s2 + 5,

mlir/test/CAPI/ir.c

if (!mlirAffineExprIsFunctionOfDim(affineDimExpr, 5) ||
       mlirAffineExprIsFunctionOfDim(affineConstantExpr, 5) ||
       !mlirAffineExprIsFunctionOfDim(affineAddExpr, 5) ||
       !mlirAffineExprIsFunctionOfDim(affineMulExpr, 5) ||
       !mlirAffineExprIsFunctionOfDim(affineModExpr, 5) ||
       !mlirAffineExprIsFunctionOfDim(affineFloorDivExpr, 5) ||
       !mlirAffineExprIsFunctionOfDim(affineCeilDivExpr, 5))
     return 8;
 
-  // Tests 'IsA' methods of affine binary operaion expression.
+  // Tests 'IsA' methods of affine binary operation expression.
   if (!mlirAffineExprIsAAdd(affineAddExpr))
     return 9;
 
   if (!mlirAffineExprIsAMul(affineMulExpr))
     return 10;
 
   if (!mlirAffineExprIsAMod(affineModExpr))
     return 11;

mlir/test/Transforms/buffer-placement-preparation-allowed-memref-results.mlir

 }
 // CHECK: (%[[CALLER_ARG:.*]]: memref<5xf32>) -> memref<5xf32>
 // CHECK: %[[X:.*]]:2 = call @callee(%[[CALLER_ARG]])
 // CHECK: %[[Y:.*]]:2 = call @callee(%[[X]]#0)
 // CHECK: return %[[Y]]#0
 
 // -----
 
-// Test case: Testing BufferAssginmnetCallOpConverter to see if it matches with the
+// Test case: Testing BufferAssignmentCallOpConverter to see if it matches with the
 // signature of the new signature of the callee function when there are tuple typed
-// args and results. BufferAssginmentTypeConverter is set to flatten tuple typed
+// args and results. BufferAssignmentTypeConverter is set to flatten tuple typed
 // arguments. The tuple typed values should be decomposed and composed using
 // get_tuple_element and make_tuple operations of test dialect. Tensor types are
 // converted to Memref. Memref typed function results remain as function results.
 
 // CHECK-LABEL: func @callee
 func @callee(%arg0: tuple<tensor<2xf32>,i1, tensor<5xf32>>) -> (tuple<tensor<2xf32>,i1, tensor<5xf32>>){
   return %arg0 : tuple<tensor<2xf32>,i1, tensor<5xf32>>
 }

 // CHECK-NEXT: %[[RETURN_TUPLE:.*]] = "test.make_tuple"(%[[CALLEE_RESULTS]]#0, %[[CALLEE_RESULTS]]#1, %[[CALLEE_RESULTS]]#2)
 // CHECK-NEXT: %[[FIRST_ELEM:.*]] = "test.get_tuple_element"(%[[RETURN_TUPLE]]) {index = 0 : i32}
 // CHECK-NEXT: %[[SECOND_ELEM:.*]] = "test.get_tuple_element"(%[[RETURN_TUPLE]]) {index = 1 : i32}
 // CHECK-NEXT: %[[THIRD_ELEM:.*]]  = "test.get_tuple_element"(%[[RETURN_TUPLE]]) {index = 2 : i32}
 // CHECK-NEXT: return %[[FIRST_ELEM]], %[[SECOND_ELEM]], %[[THIRD_ELEM]]
 
 // -----
 
-// Test case: Testing BufferAssginmnetFuncOpConverter and
-// BufferAssginmentReturnOpConverter to see if the return operation matches with
+// Test case: Testing BufferAssignmentFuncOpConverter and
+// BufferAssignmentReturnOpConverter to see if the return operation matches with
 // the new function signature when there are tuple typed args and results.
-// BufferAssginmentTypeConverter is set to flatten tuple typed arguments. The tuple
+// BufferAssignmentTypeConverter is set to flatten tuple typed arguments. The tuple
 // typed values should be decomposed and composed using get_tuple_element and
 // make_tuple operations of test dialect. Tensor types are converted to Memref.
 // Memref typed function results remain as function results.
 
 // CHECK-LABEL: func @decompose_tuple_typed_function_args_and_results
 func @decompose_tuple_typed_function_args_and_results(%arg0: tuple<i1,f32>, %arg1: tensor<10xf32>, %arg2: tuple<i1, tensor<5xf32>>) -> (tuple<i1, tensor<5xf32>>, tensor<10xf32>, tuple<i1,f32>){
   return %arg2, %arg1, %arg0 : tuple<i1, tensor<5xf32>>, tensor<10xf32>, tuple<i1,f32>
 }

mlir/test/Transforms/buffer-placement-preparation.mlir

 // CHECK-LABEL: func @func_with_unranked_arg
 func @func_with_unranked_arg(%arg0: tensor<*xf32>) {
   return
 }
 // CHECK-SAME: ([[ARG:%.*]]: memref<*xf32>)
 
 // -----
 
-// Test case: Testing BufferAssginmnetCallOpConverter to see if it matches with the
+// Test case: Testing BufferAssignmentCallOpConverter to see if it matches with the
 // signature of the new signature of the callee function when there are tuple typed
-// args and results. BufferAssginmentTypeConverter is set to flatten tuple typed
+// args and results. BufferAssignmentTypeConverter is set to flatten tuple typed
 // arguments. The tuple typed values should be decomposed and composed using
 // get_tuple_element and make_tuple operations of test dialect. Tensor types are
 // converted to Memref. Memref typed function results are appended to the function
 // arguments list.
 
 // CHECK-LABEL: func @callee
 func @callee(%arg0: tuple<tensor<2xf32>,i1, tensor<5xf32>>) -> (tuple<tensor<2xf32>,i1, tensor<5xf32>>){
   return %arg0 : tuple<tensor<2xf32>,i1, tensor<5xf32>>

 // CHECK-NEXT: %[[SECOND_ELEM:.*]] = "test.get_tuple_element"(%[[TUPLE]]) {index = 1 : i32}
 // CHECK-NEXT: %[[THIRD_ELEM:.*]]  = "test.get_tuple_element"(%[[TUPLE]]) {index = 2 : i32}
 // CHECK-NEXT: linalg.copy(%[[FIRST_ELEM]], %[[RESULT0]])
 // CHECK-NEXT: linalg.copy(%[[THIRD_ELEM]], %[[RESULT1]])
 // CHECK-NEXT: return %[[SECOND_ELEM]]
 
 // -----
 
-// Test case: Testing BufferAssginmnetFuncOpConverter and
-// BufferAssginmentReturnOpConverter to see if the return operation matches with
+// Test case: Testing BufferAssignmentFuncOpConverter and
+// BufferAssignmentReturnOpConverter to see if the return operation matches with
 // the new function signature when there are tuple typed args and results.
-// BufferAssginmentTypeConverter is set to flatten tuple typed arguments. The tuple
+// BufferAssignmentTypeConverter is set to flatten tuple typed arguments. The tuple
 // typed values should be decomposed and composed using get_tuple_element and
 // make_tuple operations of test dialect. Tensor types are converted to Memref.
 // Memref typed function results are appended to the function arguments list.
 
 // CHECK-LABEL: func @decompose_tuple_typed_function_args_and_results
 func @decompose_tuple_typed_function_args_and_results(%arg0: tuple<i1,f32>, %arg1: tensor<10xf32>, %arg2: tuple<i1, tensor<5xf32>>) -> (tuple<i1, tensor<5xf32>>, tensor<10xf32>, tuple<i1,f32>){
   return %arg2, %arg1, %arg0 : tuple<i1, tensor<5xf32>>, tensor<10xf32>, tuple<i1,f32>
 }

mlir/test/Transforms/normalize-memrefs-ops.mlir

func @test_norm(%arg0 : memref<1x16x14x14xf32, #map0>) -> () {
     dealloc %0 :  memref<1x16x14x14xf32, #map0>
 
     // CHECK: %[[v0:[a-z0-9]*]] = alloc() : memref<1x16x1x1x32x64xf32>
     // CHECK: "test.op_norm"(%[[ARG0]], %[[v0]]) : (memref<1x16x1x1x32x64xf32>, memref<1x16x1x1x32x64xf32>) -> ()
     // CHECK: dealloc %[[v0]] : memref<1x16x1x1x32x64xf32>
     return
 }
 
-// Same test with op_nonnorm, with maps in the argmentets and the operations in the function.
+// Same test with op_nonnorm, with maps in the arguments and the operations in the function.
 
 // CHECK-LABEL: test_nonnorm
 // CHECK-SAME: (%[[ARG0:[a-z0-9]*]]: memref<1x16x14x14xf32, #map0>)
 func @test_nonnorm(%arg0 : memref<1x16x14x14xf32, #map0>) -> () {
     %0 = alloc() : memref<1x16x14x14xf32, #map0>
     "test.op_nonnorm"(%arg0, %0) : (memref<1x16x14x14xf32, #map0>, memref<1x16x14x14xf32, #map0>) -> ()
     dealloc %0 :  memref<1x16x14x14xf32, #map0>
 

mlir/test/mlir-tblgen/typedefs.td

 }
 
 def E_IntegerType : TestType<"Integer"> {
     let mnemonic = "int";
     let genVerifyInvariantsDecl = 1;
     let parameters = (
         ins
         "SignednessSemantics":$signedness,
-        TypeParameter<"unsigned", "Bitwdith of integer">:$width
+        TypeParameter<"unsigned", "Bitwidth of integer">:$width
     );
 
 // DECL-LABEL: IntegerType: public ::mlir::Type
 
     let extraClassDeclaration = [{
   /// Signedness semantics.
   enum SignednessSemantics {
     Signless, /// No signedness semantics

mlir/tools/mlir-reduce/Passes/OpReducer.cpp

 //===- OpReducer.cpp - Operation Reducer ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the OpReducer class. It defines a variant generator method
 // with the purpose of producing different variants by eliminating a
-// parametarizable type of operations from the  parent module.
+// parameterizable type of operations from the  parent module.
 //
 //===----------------------------------------------------------------------===//
 #include "mlir/Reducer/Passes/OpReducer.h"
 
 using namespace mlir;
 
 OpReducerImpl::OpReducerImpl(
     llvm::function_ref<std::vector<Operation *>(ModuleOp)> getSpecificOps)

mlir/tools/mlir-reduce/ReductionNode.cpp

if (parent != nullptr)
     parent->linkVariant(this);
 }
 
 /// Calculates and updates the size and interesting values of the module.
 void ReductionNode::measureAndTest(const Tester &test) {
   SmallString<128> filepath;
   int fd;
 
-  // Print module to temprary file.
+  // Print module to temporary file.
   std::error_code ec =
       llvm::sys::fs::createTemporaryFile("mlir-reduce", "mlir", fd, filepath);
 
   if (ec)
     llvm::report_fatal_error("Error making unique filename: " + ec.message());
 
   llvm::ToolOutputFile out(filepath, fd);
   module.print(out.os());

mlir/tools/mlir-reduce/ReductionTreeUtils.cpp

 void ReductionTreeUtils::updateGoldenModule(ModuleOp &golden,
                                             ModuleOp reduced) {
   golden.getBody()->clear();
 
   golden.getBody()->getOperations().splice(golden.getBody()->begin(),
                                            reduced.getBody()->getOperations());
 }
 
-/// Update the the smallest node traversed so far in the reduction tree and
+/// Update the smallest node traversed so far in the reduction tree and
 /// print the debugging information for the currNode being traversed.
 void ReductionTreeUtils::updateSmallestNode(ReductionNode *currNode,
                                             ReductionNode *&smallestNode,
                                             std::vector<int> path) {
   LLVM_DEBUG(llvm::dbgs() << "\nTree Path: root");
   #ifndef NDEBUG
   for (int nodeIndex : path)
     LLVM_DEBUG(llvm::dbgs() << " -> " << nodeIndex);
if (transformableCount == end && inside) {
       break;
     }
   }
 
   return ranges;
 }
 
 /// Create the specified number of variants by applying the transform method
-/// to different ranges of indices in the parent module. The isDeletion bolean
+/// to different ranges of indices in the parent module. The isDeletion boolean
 /// specifies if the transformation is the deletion of indices.
 void ReductionTreeUtils::createVariants(
     ReductionNode *parent, const Tester &test, int numVariants,
     llvm::function_ref<void(ModuleOp, int, int)> transform, bool isDeletion) {
   std::vector<bool> newTSpace;
   ModuleOp module = parent->getModule();
 
   std::vector<bool> parentTSpace = parent->getTransformSpace();

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 } // end anonymous namespace
 
 // Populate the format context `ctx` with substitutions of attributes, operands
 // and results.
 // - attrGet corresponds to the name of the function to call to get value of
 //   attribute (the generated function call returns an Attribute);
 // - operandGet corresponds to the name of the function with which to retrieve
 //   an operand (the generated function call returns an OperandRange);
-// - reultGet corresponds to the name of the function to get an result (the
+// - resultGet corresponds to the name of the function to get an result (the
 //   generated function call returns a ValueRange);
 static void populateSubstitutions(const Operator &op, const char *attrGet,
                                   const char *operandGet, const char *resultGet,
                                   FmtContext &ctx) {
   // Populate substitutions for attributes and named operands.
   for (const auto &namedAttr : op.getAttributes())
     ctx.addSubst(namedAttr.name,
                  formatv("{0}(\"{1}\")", attrGet, namedAttr.name));
// Generate method to materialize derived attributes as a DictionaryAttr.
       if (!nonMaterializable.empty()) {
         std::string attrs;
         llvm::raw_string_ostream os(attrs);
         interleaveComma(nonMaterializable, os,
                         [&](const NamedAttribute &attr) { os << attr.name; });
         PrintWarning(
             op.getLoc(),
             formatv(
-                "op has non-materialzable derived attributes '{0}', skipping",
+                "op has non-materializable derived attributes '{0}', skipping",
                 os.str()));
         body << formatv("  emitOpError(\"op has non-materializable derived "
                         "attributes '{0}'\");\n",
                         attrs);
         body << "  return nullptr;";
         return;
       }
 
case TypeParamKind::Collective: {
              << "u && \"mismatched number of results\");\n";
       body << "  " << builderOpState << ".addTypes(resultTypes);\n";
     }
       return;
     }
     llvm_unreachable("unhandled TypeParamKind");
   };
 
-  // Some of the build methods generated here may be amiguous, but TableGen's
+  // Some of the build methods generated here may be ambiguous, but TableGen's
   // ambiguous function detection will elide those ones.
   for (auto attrType : attrBuilderType) {
     emit(attrType, TypeParamKind::Separate, /*inferType=*/false);
     if (canInferType(op))
       emit(attrType, TypeParamKind::None, /*inferType=*/true);
     emit(attrType, TypeParamKind::Collective, /*inferType=*/false);
   }
 }