[mlir] NFC: fix trivial typos under include directory

[jurahul]

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

633

should this be func?

[mravishankar]

Thanks!

[jpienaar]

Thanks, LG with Rahul's comments addressed.

[kiszk]

address review comment

[kiszk]

address review comment

mlir/include/mlir-c/IR.h

 /** Opaque type declarations.
  *
  * Types are exposed to C bindings as structs containing opaque pointers. They
  * are not supposed to be inspected from C. This allows the underlying
  * representation to change without affecting the API users. The use of structs
  * instead of typedefs enables some type safety as structs are not implicitly
  * convertible to each other.
  *
- * Instaces of these types may or may not own the underlying object (most often
+ * Instances of these types may or may not own the underlying object (most often
  * only point to an IR fragment without owning it). The ownership semantics is
  * defined by how an instance of the type was obtained.
  */
 /*============================================================================*/
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \

  * a string.
  */
 struct MlirNamedAttribute {
   const char *name;
   MlirAttribute attribute;
 };
 typedef struct MlirNamedAttribute MlirNamedAttribute;
 
-/** A callback for returning string referenes.
+/** A callback for returning string references.
  *
  * This function is called back by the functions that need to return a reference
  * to the portion of the string with the following arguments:
  *   - a pointer to the beginning of a string;
  *   - the length of the string (the pointer may point to a larger buffer, not
  *     necessarily null-terminated);
  *   - a pointer to user data forwarded from the printing call.
  */

 MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos);
 
 /** Returns the number of attributes attached to the operation. */
 intptr_t mlirOperationGetNumAttributes(MlirOperation op);
 
 /** Return `pos`-th attribute of the operation. */
 MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos);
 
-/** Returns an attrbute attached to the operation given its name. */
+/** Returns an attribute attached to the operation given its name. */
 MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
                                               const char *name);
 
 /** Prints an operation by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirOperationPrint(MlirOperation op, MlirStringCallback callback,
                         void *userData);

 int mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2);
 
 /** Prints an attribute by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
                         void *userData);
 
-/** Prints the attrbute to the standard error stream. */
+/** Prints the attribute to the standard error stream. */
 void mlirAttributeDump(MlirAttribute attr);
 
 /** Associates an attribute with the name. Takes ownership of neither. */
 MlirNamedAttribute mlirNamedAttributeGet(const char *name, MlirAttribute attr);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_IR_H

mlir/include/mlir-c/StandardAttributes.h

 
 /** Creates an opaque attribute in the given context associated with the dialect
  * identified by its namespace. The attribute contains opaque byte data of the
  * specified length (data need not be null-terminated). */
 MlirAttribute mlirOpaqueAttrGet(MlirContext ctx, const char *dialectNamespace,
                                 intptr_t dataLength, const char *data,
                                 MlirType type);
 
-/** Returns the namepsace of the dialect with which the given opaque attribute
+/** Returns the namespace of the dialect with which the given opaque attribute
  * is associated. The namespace string is owned by the context. */
 const char *mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr);
 
 /** Returns the raw data as a string reference. The data remains live as long as
  * the context in which the attribute lives. */
 MlirStringRef mlirOpaqueAttrGetData(MlirAttribute attr);
 
 /*============================================================================*/

mlir/include/mlir-c/StandardTypes.h

 
 /*============================================================================*/
 /* Vector type.                                                               */
 /*============================================================================*/
 
 /** Checks whether the given type is a Vector type. */
 int mlirTypeIsAVector(MlirType type);
 
-/** Creates a vector type of the shape identified by its rank and dimensios,
+/** Creates a vector type of the shape identified by its rank and dimensions,
  * with the given element type in the same context as the element type. The type
  * is owned by the context. */
 MlirType mlirVectorTypeGet(intptr_t rank, int64_t *shape, MlirType elementType);
 
 /** Same as "mlirVectorTypeGet" but returns a nullptr wrapping MlirType on
  * illegal arguments, emitting appropriate diagnostics. */
 MlirType mlirVectorTypeGetChecked(intptr_t rank, int64_t *shape,
                                   MlirType elementType, MlirLocation loc);

mlir/include/mlir/Analysis/Presburger/Simplex.h

 /// configuration, i.e. we try to make the new constraint's sample value
 /// non-negative without making that of any other constraints negative. (See
 /// findPivot and findPivotRow for details.) If this is not possible, then the
 /// set of constraints is mutually contradictory and the tableau is marked
 /// _empty_, which means the set of constraints has no solution.
 ///
 /// The Simplex class supports redundancy checking via detectRedundant and
 /// isMarkedRedundant. A redundant constraint is one which is never violated as
-/// long as the other constrants are not violated, i.e., removing a redundant
+/// long as the other constraints are not violated, i.e., removing a redundant
 /// constraint does not change the set of solutions to the constraints. As a
 /// heuristic, constraints that have been marked redundant can be ignored for
 /// most operations. Therefore, these constraints are kept in rows 0 to
 /// nRedundant - 1, where nRedundant is a member variable that tracks the number
 /// of constraints that have been marked redundant.
 ///
 /// This Simplex class also supports taking snapshots of the current state
-/// and rolling back to prior snapshots. This works by maintaing an undo log
+/// and rolling back to prior snapshots. This works by maintaining an undo log
 /// of operations. Snapshots are just pointers to a particular location in the
 /// log, and rolling back to a snapshot is done by reverting each log entry's
 /// operation from the end until we reach the snapshot's location.
 ///
 /// Finding an integer sample is done with the Generalized Basis Reduction
 /// algorithm. See the documentation for findIntegerSample and reduceBasis.
 class Simplex {
 public:

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

let description = [{
     Note: Calling AffineParallelOp::build will create the required region and
     block, and insert the required terminator if it is trivial (i.e. no values
     are yielded).  Parsing will also create the required region, block, and
     terminator, even when they are missing from the textual representation.
 
     Example (3x3 valid convolution):
 
     ```mlir
-    fuction @conv_2d(%D : memref<100x100xf32>, %K : memref<3x3xf32>) -> (memref<98x98xf32>) {
+    function @conv_2d(%D : memref<100x100xf32>, %K : memref<3x3xf32>) -> (memref<98x98xf32>) {
       %O = alloc memref<98x98xf32>
       affine.parallel (%x, %y) = (0, 0) to (98, 98) {
         %0 = affine.parallel (%kx, %ky) = (0, 0) to (2, 2) reduce ("addf") {
           %1 = affine.load %D[%x + %kx, %y + %ky] : memref<100x100xf32>
           %2 = affine.load %K[%kx, %ky] : memref<3x3xf32>
           %3 = mulf %1, %2 : f32
           affine.yield %3 : f32
         }

mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h

 
 //===----------------------------------------------------------------------===//
 // LLVMType.
 //===----------------------------------------------------------------------===//
 
 /// Base class for LLVM dialect types.
 ///
 /// The LLVM dialect in MLIR fully reflects the LLVM IR type system, prodiving a
-/// sperate MLIR type for each LLVM IR type. All types are represted as separate
-/// subclasses and are compatible with the isa/cast infrastructure. For
+/// separate MLIR type for each LLVM IR type. All types are represented as
+/// separate subclasses and are compatible with the isa/cast infrastructure. For
 /// convenience, the base class provides most of the APIs available on
 /// llvm::Type in addition to MLIR-compatible APIs.
 ///
 /// The LLVM dialect type system is closed: parametric types can only refer to
 /// other LLVM dialect types. This is consistent with LLVM IR and enables a more
 /// concise pretty-printing format.
 ///
 /// Similarly to other MLIR types, LLVM dialect types are owned by the MLIR

 /// body, one is not allowed to set another body (however, one can set exactly
 /// the same body).
 ///
 /// Note that the packedness of the struct takes place in uniquing of literal
 /// structs, but does not in uniquing of identified structs.
 class LLVMStructType : public Type::TypeBase<LLVMStructType, LLVMType,
                                              detail::LLVMStructTypeStorage> {
 public:
-  /// Inherit base construtors.
+  /// Inherit base constructors.
   using Base::Base;
 
   /// Checks if the given type can be contained in a structure type.
   static bool isValidElementType(LLVMType type);
 
   /// Gets or creates an identified struct with the given name in the provided
   /// context. Note that unlike llvm::StructType::create, this function will
   /// _NOT_ rename a struct in case a struct with the same name already exists

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

struct LinalgPromotionOptions {
   }
   /// If true all operands unspecified by `useFullTileBuffers` will use the full
   /// view, otherwise the partial view.
   bool useFullTileBuffersDefault = false;
   LinalgPromotionOptions &setUseFullTileBuffersByDefault(bool use) {
     useFullTileBuffersDefault = use;
     return *this;
   }
-  /// Allow the use of dynamicaly-sized buffers.
+  /// Allow the use of dynamically-sized buffers.
   bool dynamicBuffers = false;
   LinalgPromotionOptions &setDynamicBuffers(unsigned dynamic) {
     dynamicBuffers = dynamic;
     return *this;
   }
   /// Alignment of promoted buffer. If `None` do not specify alignment.
   Optional<unsigned> alignment = None;
   LinalgPromotionOptions &setAlignment(unsigned align) {

 
 /// Emits a loop nest of `scf.parallel` with the proper body for `op`.
 LogicalResult linalgOpToParallelLoops(OpBuilder &builder, Operation *op);
 
 /// Emits a loop nest of `affine.for` with the proper body for `op`.
 LogicalResult linalgOpToAffineLoops(OpBuilder &builder, Operation *op);
 
 //===----------------------------------------------------------------------===//
-// Preconditions that ensure the corresponding transformation suceeds and can be
-// applied as a rewrite pattern.
+// Preconditions that ensure the corresponding transformation succeeds and can
+// be applied as a rewrite pattern.
 //===----------------------------------------------------------------------===//
 /// Emits a `generic` or `indexed_generic` operation with the `indexing_maps`
 /// and `iterator_types` permutated according to `permutation`.
 LogicalResult
 interchangeGenericLinalgOpPrecondition(Operation *op,
                                        ArrayRef<unsigned> interchangeVector);
 
 /// Promote std.subviews feeding linalg operations.

mlir/include/mlir/Dialect/Linalg/Utils/Utils.h

enum class DistributionMethod {
   ///
   /// scf.parallel (%iv) = (%lb) to (%ub) step (%step)
   ///
   /// to
   ///
   /// scf.parallel(%iv)= (%lb + %procId * %step) to (%ub) step (%step * %nprocs)
   Cyclic = 0,
 
-  /// Cyclic distribtuion where the number of processors can be assumed to be
+  /// Cyclic distribution where the number of processors can be assumed to be
   /// more than or equal to the number of iterations of the distributed loop. In
   /// such cases, a simple in-bounds check is enough (instead of materializing a
   /// loop). Distributes the following loop
   ///
   /// scf.parallel (%iv) = (%lb) to (%ub) step (%step)
   ///
   /// to
   ///
   /// %iv = %lb + %procId * %step
   /// %cond = cmpi "slt", %iv, %ub
   /// scf.if %cond {
   ///   ...
   /// }
   CyclicNumProcsGeNumIters = 1,
 
-  /// Cyclic distribtuion where the number of processors can be assumed to be
+  /// Cyclic distribution where the number of processors can be assumed to be
   ///  equal to the number of iterations of the distributed loop. In such cases,
   ///  no bounds check is needed. Distributes the following loop
   ///
   /// scf.parallel (%iv) = (%lb) to (%ub) step (%step)
   ///
   /// to
   ///
   /// %iv = %lb + %procId * %step

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

def OpenACC_DefaultAttr : StrEnumAttr<"DefaultAttr",
   let cppNamespace = "::mlir::acc";
 }
 
 def OpenACC_ParallelOp : OpenACC_Op<"parallel",
     [AttrSizedOperandSegments]> {
   let summary = "parallel construct";
   let description = [{
     The "acc.parallel" operation represents a parallel construct block. It has
-    one region to be executued in parallel on the current device.
+    one region to be executed in parallel on the current device.
 
     Example:
 
     ```mlir
     acc.parallel num_gangs(%c10) num_workers(%c10)
         private(%c : memref<10xf32>) {
       // parallel region
     }

mlir/include/mlir/Dialect/PDL/IR/PDLOps.td

let description = [{
     constructed instance of that operation. The results of a `pdl.operation` are
     a handle to the operation itself, and a handle to each of the operation
     result values.
 
     When used within a matching context, the name of the operation may be
     omitted.
 
     When used within a rewriting context, i.e. when defined within a
-    `pdl.rewrite`, all of the result types must be "inferrable". This means that
+    `pdl.rewrite`, all of the result types must be "inferable". This means that
     the type must be attributable to either a constant type value or the result
     type of another entity, such as an attribute, the result of a
     `createNative`, or the result type of another operation. If the result type
     value does not meet any of these criteria, the operation must provide the
     `InferTypeOpInterface` to ensure that the result types can be inferred.
 
     Example:
 

mlir/include/mlir/Dialect/SPIRV/SPIRVAttributes.h

 /// variable: descriptor set, binding, storage class.
 class InterfaceVarABIAttr
     : public Attribute::AttrBase<InterfaceVarABIAttr, Attribute,
                                  detail::InterfaceVarABIAttributeStorage> {
 public:
   using Base::Base;
 
   /// Gets a InterfaceVarABIAttr.
-  static InterfaceVarABIAttr get(uint32_t descirptorSet, uint32_t binding,
+  static InterfaceVarABIAttr get(uint32_t descriptorSet, uint32_t binding,
                                  Optional<StorageClass> storageClass,
                                  MLIRContext *context);
   static InterfaceVarABIAttr get(IntegerAttr descriptorSet, IntegerAttr binding,
                                  IntegerAttr storageClass);
 
   /// Returns the attribute kind's name (without the 'spv.' prefix).
   static StringRef getKindName();
 

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

 def Shape_WithOp : Shape_Op<"with_shape", [NoSideEffect]> {
   let summary = "Returns ValueShape with given shape";
   let description = [{
     Returns ValueShape with the shape updated to match the shape operand. That
     is a new ValueShape tuple is created with value equal to `operand`'s
     value and shape equal to `shape`. If the ValueShape and given `shape` are
     non-conformant, then the returned ValueShape will represent an error of
     this mismatch. Similarly if either inputs are in an error state, then an
-    error is popagated.
+    error is propagated.
 
     Usage:
       %0 = shape.with_shape %1, %2 : tensor<...>, !shape.shape
 
     This is used, for example, where one combines shape function calculations
     and/or call one shape function from another. E.g.,
 
     ```mlir

mlir/include/mlir/Dialect/Vector/VectorOps.td

let description = [{
     memref<3x2x6x4x3xf32>, vector<1x1x4x3xf32>).
 
     The slice is further defined by a full-rank index within the MemRef,
     supplied as the operands `2 .. 1 + rank(memref)`.
 
     The permutation_map [attribute](../LangRef.md#attributes) is an
     [affine-map](Affine.md#affine-maps) which specifies the transposition on the
     slice to match the vector shape. The permutation map may be implicit and
-    ommitted from parsing and printing if it is the canonical minor identity map
+    omitted from parsing and printing if it is the canonical minor identity map
     (i.e. if it does not permute or broadcast any dimension).
 
     The size of the slice is specified by the size of the vector, given as the
     return type.
 
     An `ssa-value` of the same elemental type as the MemRef is provided as the
     last operand to specify padding in the case of out-of-bounds accesses.
 
let description = [{
     vector<1x1x4x3xf32>).
 
     The slice is further defined by a full-rank index within the MemRef,
     supplied as the operands `3 .. 2 + rank(memref)`.
 
     The permutation_map [attribute](../LangRef.md#attributes) is an
     [affine-map](Affine.md#affine-maps) which specifies the transposition on the
     slice to match the vector shape. The permutation map may be implicit and
-    ommitted from parsing and printing if it is the canonical minor identity map
+    omitted from parsing and printing if it is the canonical minor identity map
     (i.e. if it does not permute or broadcast any dimension).
 
     The size of the slice is specified by the size of the vector.
 
     An optional boolean array attribute is provided to specify which dimensions
     of the transfer need masking. When a dimension is specified as not requiring
     masking, the `vector.transfer_write` may be lowered to simple stores. The
     absence of this `mask` attribute signifies that all dimensions of the

mlir/include/mlir/IR/OpDefinition.h

static LogicalResult verifyTrait(Operation *op) {
                << TerminatorOpType::getOperationName() << '\'';
       }
 
       return success();
     }
 
     /// Ensure that the given region has the terminator required by this trait.
     /// If OpBuilder is provided, use it to build the terminator and notify the
-    /// OpBuilder litsteners accoridngly. If only a Builder is provided, locally
+    /// OpBuilder litsteners accordingly. If only a Builder is provided, locally
     /// construct an OpBuilder with no listeners; this should only be used if no
     /// OpBuilder is available at the call site, e.g., in the parser.
     static void ensureTerminator(Region &region, Builder &builder,
                                  Location loc) {
       ::mlir::impl::ensureRegionTerminator(region, builder, loc,
                                            buildTerminator);
     }
     static void ensureTerminator(Region &region, OpBuilder &builder,

mlir/include/mlir/IR/StorageUniquerSupport.h

public:
   /// Utility declarations for the concrete attribute class.
   using Base = StorageUserBase<ConcreteT, BaseT, StorageT, UniquerT, Traits...>;
   using ImplType = StorageT;
 
   /// Return a unique identifier for the concrete type.
   static TypeID getTypeID() { return TypeID::get<ConcreteT>(); }
 
   /// Provide an implementation of 'classof' that compares the type id of the
-  /// provided value with that of the concerete type.
+  /// provided value with that of the concrete type.
   template <typename T> static bool classof(T val) {
     static_assert(std::is_convertible<ConcreteT, T>::value,
                   "casting from a non-convertible type");
     return val.getTypeID() == getTypeID();
   }
 
   /// Returns an interface map for the interfaces registered to this storage
   /// user. This should not be used directly.

mlir/include/mlir/Interfaces/SideEffectInterfaces.td

 #define MLIR_INTERFACES_SIDEEFFECTS
 
 include "mlir/IR/OpBase.td"
 
 //===----------------------------------------------------------------------===//
 // Resource Bindings
 //===----------------------------------------------------------------------===//
 
-// A generic resource that can be attachted to a general base side effect.
+// A generic resource that can be attached to a general base side effect.
 class Resource<string resourceName> {
   /// The resource that the associated effect is being applied to.
   string name = resourceName;
 }
 
 // An intrinsic resource that lives in the ::mlir::SideEffects namespace.
 class IntrinsicResource<string resourceName> :
   Resource<!strconcat("::mlir::SideEffects::", resourceName)> {

mlir/include/mlir/Pass/AnalysisManager.h

Optional<std::reference_wrapper<AnalysisT>> getCachedAnalysis() const {
     return impl->analyses.getCachedAnalysis<AnalysisT>();
   }
 
   /// Query for an analysis of a child operation, constructing it if necessary.
   template <typename AnalysisT> AnalysisT &getChildAnalysis(Operation *op) {
     return nest(op).template getAnalysis<AnalysisT>();
   }
 
-  /// Query for an analysis of a child operation of a specifc derived operation
+  /// Query for an analysis of a child operation of a specific derived operation
   /// type, constructing it if necessary.
   template <typename AnalysisT, typename OpT>
   AnalysisT &getChildAnalysis(OpT child) {
     return nest(child).template getAnalysis<AnalysisT, OpT>();
   }
 
   /// Query for a cached analysis of a child operation, or return null.
   template <typename AnalysisT>

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

for (Operation *o : opsToRemove) {
       o->dropAllUses();
       o->erase();
     }
   }
 
   /// Return the name of this reducer class.
   StringRef getName() { return impl->getName(); }
 
-  /// Return the initial transformSpace cointaing the transformable indices.
+  /// Return the initial transformSpace containing the transformable indices.
   std::vector<bool> initTransformSpace(ModuleOp module) {
     return impl->initTransformSpace(module);
   }
 
   /// Generate variants by removing OpType operations from the module in the
   /// parent and link the variants as childs in the Reduction Tree Pass.
   void generateVariants(ReductionNode *parent, const Tester &test,
                         int numVariants) {

mlir/include/mlir/Reducer/ReductionNode.h

 
 #include "mlir/Reducer/Tester.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 namespace mlir {
 
 /// This class defines the ReductionNode which is used to wrap the module of
 /// a generated variant and keep track of the necessary metadata for the
-/// reduction pass. The nodes are linked together in a reduction tree stucture
+/// reduction pass. The nodes are linked together in a reduction tree structure
 /// which defines the relationship between all the different generated variants.
 class ReductionNode {
 public:
   ReductionNode(ModuleOp module, ReductionNode *parent);
 
   ReductionNode(ModuleOp module, ReductionNode *parent,
                 std::vector<bool> transformSpace);
 
private:
   // This is true if the module has been evaluated and it exhibits the
   // interesting behavior.
   bool interesting;
 
   // This indicates the number of characters in the printed module if the module
   // has been evaluated.
   int size;
 
-  // This indicates if the module has been evalueated (measured and tested).
+  // This indicates if the module has been evaluated (measured and tested).
   bool evaluated;
 
   // Indicates the indices in the node that have been transformed in previous
   // levels of the reduction tree.
   std::vector<bool> transformSpace;
 
   // This points to the child variants that were created using this node as a
   // starting point.
   std::vector<std::unique_ptr<ReductionNode>> variants;
 };
 
 } // end namespace mlir
 
 #endif

mlir/include/mlir/Reducer/ReductionTreeUtils.h

 
 // Defines the utilities for the implementation of custom reduction
 // passes using the ReductionTreePass framework.
 namespace ReductionTreeUtils {
 
 /// Update the golden module's content with that of the reduced module.
 void updateGoldenModule(ModuleOp &golden, ModuleOp reduced);
 
-/// 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 updateSmallestNode(ReductionNode *currNode, ReductionNode *&smallestNode,
                         std::vector<int> path);
 
 /// Create a transform space index vector based on the specified number of
 /// indices.
 std::vector<bool> createTransformSpace(ModuleOp module, int numIndices);
 
 /// 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 createVariants(ReductionNode *parent, const Tester &test, int numVariants,
                     llvm::function_ref<void(ModuleOp, int, int)> transform,
                     bool isDeletion);
 
 } // namespace ReductionTreeUtils
 
 } // end namespace mlir
 
 #endif

mlir/include/mlir/Reducer/Tester.h

 //===- Tester.h -------------------------------------------------*- 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 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.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_REDUCER_TESTER_H
 #define MLIR_REDUCER_TESTER_H
 
 #include <vector>

mlir/include/mlir/Support/InterfaceSupport.h

 namespace mlir {
 namespace detail {
 //===----------------------------------------------------------------------===//
 // Interface
 //===----------------------------------------------------------------------===//
 
 /// This class represents an abstract interface. An interface is a simplified
 /// mechanism for attaching concept based polymorphism to a class hierarchy. An
-/// interace is comprised of two components:
+/// interface is comprised of two components:
 /// * The derived interface class: This is what users interact with, and invoke
 ///   methods on.
 /// * An interface `Trait` class: This is the class that is attached to the
 ///   object implementing the interface. It is the mechanism with which models
 ///   are specialized.
 ///
 /// Derived interfaces types must provide the following template types:
 /// * ConcreteType: The CRTP derived type.