[mlir] NFC: fix trivial typo under test and tools

[rriddle]

Thanks!!

mlir/integration_test/lit.cfg.py

 config.substitutions.append(('%PATH%', config.environment['PATH']))
 config.substitutions.append(('%shlibext', config.llvm_shlib_ext))
 config.substitutions.append(('%mlir_src_root', config.mlir_src_root))
 
 llvm_config.with_system_environment(['HOME', 'INCLUDE', 'LIB', 'TMP', 'TEMP'])
 
 llvm_config.use_default_substitutions()
 
-# excludes: A list of directories to exclude from the integraiton testsuite.
+# excludes: A list of directories to exclude from the integration testsuite.
 config.excludes = ['CMakeLists.txt', 'README.txt', 'LICENSE.txt']
 
 # Tweak the PATH to include the tools dir.
 llvm_config.with_environment('PATH', config.llvm_tools_dir, append_path=True)
 tool_dirs = [config.mlir_tools_dir, config.llvm_tools_dir]
 tools = [
     'mlir-opt',
     'mlir-cpu-runner',

mlir/test/Dialect/Affine/loop-tiling.mlir

affine.for %i1 = 0 to 196608 {
     affine.for %i3 = 0 to 1 {
       %4 = affine.load %arg0[%i1, %i3] : memref<196608x1xf32>
       affine.store %4, %arg1[%i1, %i3] : memref<196608x1xf32>
     }
   }
   // CHECK: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<196608x1xf32>
   return %arg1 : memref<196608x1xf32>
 }
-// To make sure SEPRATE-DAGs further below do not match with something above.
+// To make sure SEPARATE-DAGs further below do not match with something above.
 // SEPARATE: return
 
 // -----
 
 func @separate_full_tile_2d(%M : index, %N : index) {
   affine.for %i = 0 to %M {
     affine.for %j = 0 to %N {
       "test.foo"() : () -> ()

mlir/test/Dialect/Affine/simplify-affine-structures.mlir

 }
 
 // -----
 
 // Tests the simplification of a semi-affine expression in various cases.
 // CHECK-DAG: #[[$map0:.*]] = affine_map<()[s0, s1] -> (-(s1 floordiv s0) + 2)>
 // CHECK-DAG: #[[$map1:.*]] = affine_map<()[s0, s1] -> (-(s1 floordiv s0) + 42)>
 
-// Tests the simplification of a semi-affine expression with a modulo operartion on a floordiv and multiplication.
+// Tests the simplification of a semi-affine expression with a modulo operation on a floordiv and multiplication.
 // CHECK-LABEL: func @semiaffine_mod
 func @semiaffine_mod(%arg0: index, %arg1: index) -> index {
   %a = affine.apply affine_map<(d0)[s0] ->((-((d0 floordiv s0) * s0) + s0 * s0) mod s0)> (%arg0)[%arg1]
   // CHECK:       %[[CST:.*]] = constant 0
   return %a : index
 }
 
 // Tests the simplification of a semi-affine expression with a nested floordiv and a floordiv on modulo operation.

mlir/test/Dialect/LLVMIR/invalid.mlir

 
 func @alloca_missing_input_type() {
   // expected-error@+1 {{expected trailing function type with one argument and one result}}
   llvm.alloca %size x !llvm.i32 : () -> (!llvm.ptr<i32>)
 }
 
 // -----
 
-func @alloca_mising_result_type() {
+func @alloca_missing_result_type() {
   // expected-error@+1 {{expected trailing function type with one argument and one result}}
   llvm.alloca %size x !llvm.i32 : (!llvm.i64) -> ()
 }
 
 // -----
 
 func @alloca_non_function_type() {
   // expected-error@+1 {{expected trailing function type with one argument and one result}}

mlir/test/Dialect/Linalg/tensors-to-buffers.mlir

 // RUN: mlir-opt -convert-linalg-on-tensors-to-buffers -buffer-placement -split-input-file %s | FileCheck %s
 
 #map0 = affine_map<(d0) -> (d0)>
 
-// CHECK-LABEL: func @muliple_results_generic_op
-func @muliple_results_generic_op(%arg0: tensor<4xf32>) -> (tensor<4xf32>, tensor<4xf32>) {
+// CHECK-LABEL: func @multiple_results_generic_op
+func @multiple_results_generic_op(%arg0: tensor<4xf32>) -> (tensor<4xf32>, tensor<4xf32>) {
     %0, %1 = linalg.generic {args_in = 1 : i64, args_out = 2 : i64, indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} %arg0 {
     ^bb0(%gen_arg1: f32):
         %tmp1 = exp %gen_arg1 : f32
         linalg.yield %tmp1, %tmp1 : f32, f32
     }: tensor<4xf32> -> (tensor<4xf32>, tensor<4xf32>)
     return %0, %1 : tensor<4xf32>, tensor<4xf32>
 }
 //      CHECK: (%[[NEW_ARG0:.*]]: [[TYPE:.*]], %[[ARG1_RESULT:.*]]: [[TYPE]], %[[ARG2_RESULT:.*]]: [[TYPE]])

mlir/test/IR/pretty-attributes.mlir

 
 // CHECK: dense<[1, 2]> : tensor<2xi32>
 "test.non_elided_dense_attr"() {foo.dense_attr = dense<[1, 2]> : tensor<2xi32>} : () -> ()
 
 // CHECK: opaque<"", "0xDEADBEEF"> : vector<1x1x1xf16>
 "test.sparse_attr"() {foo.sparse_attr = sparse<[[1, 2, 3]],  -2.0> : vector<1x1x1xf16>} : () -> ()
 
 // CHECK: opaque<"", "0xDEADBEEF"> : tensor<100xf32>
-"test.opaue_attr"() {foo.opaque_attr = opaque<"", "0xEBFE"> : tensor<100xf32> } : () -> ()
+"test.opaque_attr"() {foo.opaque_attr = opaque<"", "0xEBFE"> : tensor<100xf32> } : () -> ()

mlir/test/Target/llvmir-types.mlir

 
 // CHECK: declare %empty
 llvm.func @return_s_empty() -> !llvm.struct<"empty", ()>
 // CHECK: declare %opaque
 llvm.func @return_s_opaque() -> !llvm.struct<"opaque", opaque>
 // CHECK: declare %long
 llvm.func @return_s_long() -> !llvm.struct<"long", (i32, struct<(i32, i1)>, float, ptr<func<void ()>>)>
 // CHECK: declare %self-recursive
-llvm.func @return_s_self_recurisve() -> !llvm.struct<"self-recursive", (ptr<struct<"self-recursive">>)>
+llvm.func @return_s_self_recursive() -> !llvm.struct<"self-recursive", (ptr<struct<"self-recursive">>)>
 // CHECK: declare %unpacked
 llvm.func @return_s_unpacked() -> !llvm.struct<"unpacked", (i32)>
 // CHECK: declare %packed
 llvm.func @return_s_packed() -> !llvm.struct<"packed", packed (i32)>
 // CHECK: declare %"name with spaces and !^$@$#"
 llvm.func @return_s_symbols() -> !llvm.struct<"name with spaces and !^$@$#", packed (i32)>
 
 // CHECK: declare %mutually-a

mlir/test/Target/llvmir.mlir

llvm.func @volatile_store_and_load() {
   // CHECK: %{{.*}} = load volatile i32, i32* %{{.*}}
   %1 = llvm.load volatile %0: !llvm.ptr<i32>
   llvm.return
 }
 
 // -----
 
 // Check that nontemporal attribute is exported as metadata node.
-llvm.func @nontemoral_store_and_load() {
+llvm.func @nontemporal_store_and_load() {
   %val = llvm.mlir.constant(5 : i32) : !llvm.i32
   %size = llvm.mlir.constant(1 : i64) : !llvm.i64
   %0 = llvm.alloca %size x !llvm.i32 : (!llvm.i64) -> (!llvm.ptr<i32>)
   // CHECK: !nontemporal ![[NODE:[0-9]+]]
   llvm.store %val, %0 {nontemporal} : !llvm.ptr<i32>
   // CHECK: !nontemporal ![[NODE]]
   %1 = llvm.load %0 {nontemporal} : !llvm.ptr<i32>
   llvm.return

mlir/test/Transforms/buffer-placement.mlir

 
 // CHECK-NEXT: %{{.*}} = alloc()
 //      CHECK: linalg.copy
 // CHECK-NEXT: dealloc
 // CHECK-NEXT: return
 
 // -----
 
-// Test Case: Iserting missing DeallocOp in a single block.
+// Test Case: Inserting missing DeallocOp in a single block.
 
 #map0 = affine_map<(d0) -> (d0)>
 
 // CHECK-LABEL: func @inserting_missing_dealloc_simple
 func @inserting_missing_dealloc_simple(
   %arg0 : memref<2xf32>,
   %arg1: memref<2xf32>) {
   %0 = alloc() : memref<2xf32>

mlir/test/Transforms/test-legalizer.mlir

func @undo_block_arg_replace() {
   // expected-remark@+1 {{op 'std.return' is not legalizable}}
   return
 }
 
 // -----
 
 // The op in this function is rewritten to itself (and thus remains illegal) by
 // a pattern that removes its second block after adding an operation into it.
-// Check that we can undo block removal succesfully.
+// Check that we can undo block removal successfully.
 // CHECK-LABEL: @undo_block_erase
 func @undo_block_erase() {
   // CHECK: test.undo_block_erase
   "test.undo_block_erase"() ({
     // expected-remark@-1 {{not legalizable}}
     // CHECK: "unregistered.return"()[^[[BB:.*]]]
     "unregistered.return"()[^bb1] : () -> ()
     // expected-remark@-1 {{not legalizable}}

mlir/test/Transforms/test-merge-blocks.mlir

func @merge_blocks(%arg0: i32, %arg1 : i32) -> () {
   "test.return"(%0#0, %0#1) : (i32, i32) -> ()
 }
 
 // -----
 
 // The op in this function is rewritten to itself (and thus remains
 // illegal) by a pattern that merges the second block with the first
 // after adding an operation into it.  Check that we can undo block
-// removal succesfully.
+// removal successfully.
 // CHECK-LABEL: @undo_blocks_merge
 func @undo_blocks_merge(%arg0: i32) {
   "test.undo_blocks_merge"() ({
     // expected-remark@-1 {{op 'test.undo_blocks_merge' is not legalizable}}
     // CHECK: "unregistered.return"(%{{.*}})[^[[BB:.*]]]
     "unregistered.return"(%arg0)[^bb1] : (i32) -> ()
     // expected-remark@-1 {{op 'unregistered.return' is not legalizable}}
   // CHECK: ^[[BB]]

mlir/test/lib/Dialect/Test/TestOps.td

 
 // Single variadic arg and multiple variadic results.
 def TableGenBuildOp3 : TEST_Op<"tblgen_build_3", [SameVariadicResultSize]> {
   let arguments = (ins Variadic<AnyType>:$inputs);
   let results = (outs Variadic<AnyType>:$resultA, Variadic<AnyType>:$resultB);
 }
 
 // Single variadic arg, non variadic results, with SameOperandsAndResultType.
-// Tests suppression of ambiguious build methods for operations with
+// Tests suppression of ambiguous build methods for operations with
 // SameOperandsAndResultType trait.
 def TableGenBuildOp4 : TEST_Op<"tblgen_build_4", [SameOperandsAndResultType]> {
   let arguments = (ins Variadic<AnyType>:$inputs);
   let results = (outs AnyType:$result);
 }
 
 // Single variadic arg with SameOperandsAndResultType and InferTypeOpInterface.
-// Tests suppression of ambiguious build methods for operations with
+// Tests suppression of ambiguous build methods for operations with
 // SameOperandsAndResultType and InferTypeOpInterface.
 def TableGenBuildOp5 : TEST_Op<"tblgen_build_5",
       [SameOperandsAndResultType, InferTypeOpInterface]> {
   let arguments = (ins Variadic<AnyType>:$inputs);
   let results = (outs AnyType:$result);
 
   let extraClassDeclaration = [{
     static LogicalResult inferReturnTypes(MLIRContext *, 

mlir/test/lib/Dialect/Test/TestPatterns.cpp

FoldingPattern(MLIRContext *context)
                        /*benefit=*/1, context) {}
 
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const override {
     // Exercice OperationFolder API for a single-result operation that is folded
     // upon construction. The operation being created through the folder has an
     // in-place folder, and it should be still present in the output.
     // Furthermore, the folder should not crash when attempting to recover the
-    // (unchanged) opeation result.
+    // (unchanged) operation result.
     OperationFolder folder(op->getContext());
     Value result = folder.create<TestOpInPlaceFold>(
         rewriter, op->getLoc(), rewriter.getIntegerType(32), op->getOperand(0),
         rewriter.getI32IntegerAttr(0));
     assert(result);
     rewriter.replaceOp(op, result);
     return success();
   }
LogicalResult matchAndRewrite(Operation *op,
     Type i32Type = rewriter.getIntegerType(32);
     rewriter.createBlock(&region, region.end(), {i32Type, i32Type});
     rewriter.create<TerminatorOp>(op->getLoc());
     rewriter.replaceOp(op, {});
     return success();
   }
 };
 
-/// A simple pattern that creates a block containing an invalid operaiton in
+/// A simple pattern that creates a block containing an invalid operation in
 /// order to trigger the block creation undo mechanism.
 struct TestCreateIllegalBlock : public RewritePattern {
   TestCreateIllegalBlock(MLIRContext *ctx)
       : RewritePattern("test.create_illegal_block", /*benefit=*/1, ctx) {}
 
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const final {
     Region &region = *op->getParentRegion();

mlir/test/lib/IR/TestTypes.cpp

 namespace {
 struct TestRecursiveTypesPass
     : public PassWrapper<TestRecursiveTypesPass, FunctionPass> {
   LogicalResult createIRWithTypes();
 
   void runOnFunction() override {
     FuncOp func = getFunction();
 
-    // Just make sure recurisve types are printed and parsed.
+    // Just make sure recursive types are printed and parsed.
     if (func.getName() == "roundtrip")
       return;
 
     // Create a recursive type and print it as a part of a dummy op.
     if (func.getName() == "create") {
       if (failed(createIRWithTypes()))
         signalPassFailure();
       return;

mlir/test/lib/Transforms/TestConvertCallOp.cpp

-//===- TestConvertCallOp.cpp - Test LLVM Convesion of Standard CallOp -----===//
+//===- TestConvertCallOp.cpp - Test LLVM Conversion of Standard CallOp ----===//
 //
 // 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 "TestDialect.h"

mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp

 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "memref-bound-check"
 
 using namespace mlir;
 
 namespace {
 
-/// Checks for out of bound memef access subscripts..
+/// Checks for out of bound memref access subscripts..
 struct TestMemRefBoundCheck
     : public PassWrapper<TestMemRefBoundCheck, FunctionPass> {
   void runOnFunction() override;
 };
 
 } // end anonymous namespace
 
 void TestMemRefBoundCheck::runOnFunction() {

mlir/test/mlir-reduce/dce-test.mlir

 // UNSUPPORTED: -windows-
 // RUN: mlir-reduce %s -test %S/failure-test.sh -pass-test DCE | FileCheck %s
 // This input should be reduced by the pass pipeline so that only
-// the @simple1 function remains as the other fucntions should be
+// the @simple1 function remains as the other functions should be
 // removed by the dead code elimination pass.
 // CHECK-LABEL: func @simple1(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
 
 // CHECK-NOT: func @dead_nested_function
 func @dead_private_function() attributes { sym_visibility = "private" }
 
 // CHECK-NOT: func @dead_nested_function
 func @dead_nested_function() attributes { sym_visibility = "nested" }
 
 func @simple1(%arg0: i1, %arg1: memref<2xf32>, %arg2: memref<2xf32>) {
   "test.crashOp" () : () -> ()
   return
 }

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

OpReducerImpl::OpReducerImpl(
     llvm::function_ref<std::vector<Operation *>(ModuleOp)> getSpecificOps)
     : getSpecificOps(getSpecificOps) {}
 
 /// Return the name of this reducer class.
 StringRef OpReducerImpl::getName() {
   return StringRef("High Level Operation Reduction");
 }
 
-/// Return the initial transformSpace cointaing the transformable indices.
+/// Return the initial transformSpace containing the transformable indices.
 std::vector<bool> OpReducerImpl::initTransformSpace(ModuleOp module) {
   auto ops = getSpecificOps(module);
   int numOps = std::distance(ops.begin(), ops.end());
   return ReductionTreeUtils::createTransformSpace(module, numOps);
 }
 
 /// Generate variants by removing opType operations from the module in the
 /// parent and link the variants as childs in the Reduction Tree Pass.
 void OpReducerImpl::generateVariants(
     ReductionNode *parent, const Tester &test, int numVariants,
     llvm::function_ref<void(ModuleOp, int, int)> transform) {
   ReductionTreeUtils::createVariants(parent, test, numVariants, transform,
                                      true);
 }

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 generaed function call returns an OperandRange);
+//   an operand (the generated function call returns an OperandRange);
 // - reultGet 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,
void OpEmitter::genSeparateArgParamBuilder() {
   for (auto attrType : attrBuilderType) {
     // Case 3b above.
     if (!(op.hasNoVariadicRegions() && op.hasSingleVariadicArg() &&
           op.hasSingleVariadicResult()))
       emit(attrType, TypeParamKind::Separate, /*inferType=*/false);
     if (canInferType(op)) {
       // When inferType = true, the generated build method does not have
       // result types. If the op has a single variadic arg, then this build
-      // method will be ambiguious with the collective inferred build method
+      // method will be ambiguous with the collective inferred build method
       // generated in `genInferredTypeCollectiveParamBuilder`. If we are going
       // to generate that collective inferred method, suppress generating the
-      // ambiguious build method here.
-      bool buildMethodAmbiguious =
+      // ambiguous build method here.
+      bool buildMethodAmbiguous =
           op.hasSingleVariadicArg() &&
           shouldGenerateInferredTypeCollectiveParamBuilder();
-      if (!buildMethodAmbiguious)
+      if (!buildMethodAmbiguous)
         emit(attrType, TypeParamKind::None, /*inferType=*/true);
     }
     // The separate arg + collective param kind method will be:
     // (a) Same as the separate arg + separate param kind method if there is
     //     only one variadic result.
     // (b) Ambiguous with the collective params method under conditions in (3a)
     //     above.
     // In either case, skip generating such build method.
void OpEmitter::genBuilder() {
   genCollectiveParamBuilder();
   // 3. one having a stand-alone parameter for each operand and attribute,
   //    use the first operand or attribute's type as all result types
   //    to facilitate different call patterns.
   if (op.getNumVariableLengthResults() == 0) {
     if (op.getTrait("OpTrait::SameOperandsAndResultType")) {
       // If the operation has a single variadic input, then the build method
       // generated by `genUseOperandAsResultTypeSeparateParamBuilder` will be
-      // ambiguious with the one generated by
+      // ambiguous with the one generated by
       // `genUseOperandAsResultTypeCollectiveParamBuilder` (they both will have
       // a single `ValueRange` argument for operands, and the collective one
-      // will have a `ArrayRef<NamedAttribute>` argument initalized to empty).
-      // Suppress such ambiguious build method.
+      // will have a `ArrayRef<NamedAttribute>` argument initialized to empty).
+      // Suppress such ambiguous build method.
       if (!op.hasSingleVariadicArg())
         genUseOperandAsResultTypeSeparateParamBuilder();
 
       // The build method generated by the inferred type collective param
       // builder and one generated here have the same arguments and hence
-      // generating both will be ambiguious. Enable just one of them.
+      // generating both will be ambiguous. Enable just one of them.
       if (!shouldGenerateInferredTypeCollectiveParamBuilder())
         genUseOperandAsResultTypeCollectiveParamBuilder();
     }
     if (op.getTrait("OpTrait::FirstAttrDerivedResultType"))
       genUseAttrAsResultTypeBuilder();
   }
 }
 

mlir/tools/mlir-tblgen/OpInterfacesGen.cpp

AttrInterfaceGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
     interfaceBaseType = "AttrInterface";
     valueTemplate = "ConcreteAttr";
     StringRef castCode = "(tablegen_opaque_val.cast<ConcreteAttr>())";
     nonStaticMethodFmt.addSubst("_attr", castCode).withSelf(castCode);
     traitMethodFmt.addSubst("_attr",
                             "(*static_cast<const ConcreteAttr *>(this))");
   }
 };
-/// A specialized generator for operaton interfaces.
+/// A specialized generator for operation interfaces.
 struct OpInterfaceGenerator : public InterfaceGenerator {
   OpInterfaceGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
       : InterfaceGenerator(getAllOpInterfaceDefinitions(records), os) {
     valueType = "::mlir::Operation *";
     interfaceBaseType = "OpInterface";
     valueTemplate = "ConcreteOp";
     StringRef castCode = "(llvm::cast<ConcreteOp>(tablegen_opaque_val))";
     nonStaticMethodFmt.withOp(castCode).withSelf(castCode);

mlir/tools/mlir-vulkan-runner/CMakeLists.txt

if (MLIR_VULKAN_RUNNER_ENABLED)
 
   target_include_directories(vulkan-runtime-wrappers
     PUBLIC
     ${Vulkan_INCLUDE_DIR}
   )
 
   # *IMPORTANT*: This library cannot depend on LLVM libraries. Otherwise,
   # it may cause LLVM version conflict when used together with other shared
-  # libraries depending on LLVM. Notably, Mesa, who implemnents Vulkan
+  # libraries depending on LLVM. Notably, Mesa, who implements Vulkan
   # drivers on Linux, depends on the system libLLVM.so.
   target_link_libraries(vulkan-runtime-wrappers
     PUBLIC
     ${Vulkan_LIBRARY}
   )
 
   get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
   get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)

mlir/unittests/Analysis/AffineStructuresTest.cpp

checkSample(true,
               makeFACFromConstraints(2, {{0, 1, 0}, {0, -1, 3}}, {{4, 1, -7}}));
 
   // 4q + r = 7 and r = 0.
   // Solution: q = 1, r = 3.
   checkSample(false, makeFACFromConstraints(2, {}, {{4, 1, -7}, {0, 1, 0}}));
 
   // The next two sets are large sets that should take a long time to sample
   // with a naive branch and bound algorithm but can be sampled efficiently with
-  // the GBR algroithm.
+  // the GBR algorithm.
   //
   // This is a triangle with vertices at (1/3, 0), (2/3, 0) and (10000, 10000).
   checkSample(
       true,
       makeFACFromConstraints(
           2, {{0, 1, 0}, {300000, -299999, -100000}, {-300000, 299998, 200000}},
           {}));
 

mlir/unittests/TableGen/OpBuildGen.cpp

TEST_F(OpBuildGenTest,
   verifyOp(std::move(op), {i32Ty, f32Ty}, {cstI32}, noAttrs);
 
   // Test collective params build method, with attributes.
   op = builder.create<TableGenBuildOp3>(loc, ArrayRef<Type>{i32Ty, f32Ty},
                                         ArrayRef<Value>{cstI32}, attrs);
   verifyOp(std::move(op), {i32Ty, f32Ty}, {cstI32}, attrs);
 }
 
-// The next 2 tests test supression of ambiguious build methods for ops that
+// The next 2 tests test supression of ambiguous build methods for ops that
 // have a single variadic input, and single non-variadic result, and which
 // support the SameOperandsAndResultType trait and and optionally the
 // InferOpTypeInterface interface. For such ops, the ODS framework generates
 // build methods with no result types as they are inferred from the input types.
 TEST_F(OpBuildGenTest, BuildMethodsSameOperandsAndResultTypeSuppression) {
   testSingleVariadicInputInferredType<TableGenBuildOp4>();
 }
 
 TEST_F(
     OpBuildGenTest,
     BuildMethodsSameOperandsAndResultTypeAndInferOpTypeInterfaceSuppression) {
   testSingleVariadicInputInferredType<TableGenBuildOp5>();
 }
 
 } // namespace mlir