diff --git a/clang-tools-extra/clang-tidy/llvmlibc/RestrictSystemLibcHeadersCheck.cpp b/clang-tools-extra/clang-tidy/llvmlibc/RestrictSystemLibcHeadersCheck.cpp index b656917071a6c..4e09b735b1580 100644 --- a/clang-tools-extra/clang-tidy/llvmlibc/RestrictSystemLibcHeadersCheck.cpp +++ b/clang-tools-extra/clang-tidy/llvmlibc/RestrictSystemLibcHeadersCheck.cpp @@ -25,9 +25,9 @@ class RestrictedIncludesPPCallbacks public: explicit RestrictedIncludesPPCallbacks( RestrictSystemLibcHeadersCheck &Check, const SourceManager &SM, - const SmallString<128> CompilerIncudeDir) + const SmallString<128> CompilerIncludeDir) : portability::RestrictedIncludesPPCallbacks(Check, SM), - CompilerIncudeDir(CompilerIncudeDir) {} + CompilerIncludeDir(CompilerIncludeDir) {} void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName, bool IsAngled, @@ -38,7 +38,7 @@ class RestrictedIncludesPPCallbacks SrcMgr::CharacteristicKind FileType) override; private: - const SmallString<128> CompilerIncudeDir; + const SmallString<128> CompilerIncludeDir; }; } // namespace @@ -49,7 +49,7 @@ void RestrictedIncludesPPCallbacks::InclusionDirective( StringRef SearchPath, StringRef RelativePath, const Module *SuggestedModule, bool ModuleImported, SrcMgr::CharacteristicKind FileType) { // Compiler provided headers are allowed (e.g stddef.h). - if (SrcMgr::isSystem(FileType) && SearchPath == CompilerIncudeDir) + if (SrcMgr::isSystem(FileType) && SearchPath == CompilerIncludeDir) return; portability::RestrictedIncludesPPCallbacks::InclusionDirective( HashLoc, IncludeTok, FileName, IsAngled, FilenameRange, File, SearchPath, @@ -58,11 +58,11 @@ void RestrictedIncludesPPCallbacks::InclusionDirective( void RestrictSystemLibcHeadersCheck::registerPPCallbacks( const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { - SmallString<128> CompilerIncudeDir = + SmallString<128> CompilerIncludeDir = StringRef(PP->getHeaderSearchInfo().getHeaderSearchOpts().ResourceDir); - llvm::sys::path::append(CompilerIncudeDir, "include"); + llvm::sys::path::append(CompilerIncludeDir, "include"); PP->addPPCallbacks(std::make_unique( - *this, SM, CompilerIncudeDir)); + *this, SM, CompilerIncludeDir)); } } // namespace clang::tidy::llvm_libc diff --git a/mlir/docs/Dialects/Linalg/_index.md b/mlir/docs/Dialects/Linalg/_index.md index fbd1a451dc094..dc4375dc0d799 100644 --- a/mlir/docs/Dialects/Linalg/_index.md +++ b/mlir/docs/Dialects/Linalg/_index.md @@ -478,7 +478,7 @@ The key implication is that this conversion to deep predication needs to be undone once we are done with Linalg transformations. After iterators and induction variables are materialized (i.e. after lowering out of `linalg.generic` occurred), the overall performance will be greatly influenced -by the quality of canonicalizations, foldings and *Loop Independent Code Motion* +by the quality of canonicalization, foldings and *Loop Independent Code Motion* (LICM). In the grander scheme, the reliance on late LICM was deemed a necessary risk. diff --git a/mlir/docs/PDLL.md b/mlir/docs/PDLL.md index f5651156a860c..b4fb0723a4cac 100644 --- a/mlir/docs/PDLL.md +++ b/mlir/docs/PDLL.md @@ -699,7 +699,7 @@ Pattern { } ``` -Below are the set of contexts in which result type inferrence is supported: +Below are the set of contexts in which result type inference is supported: ##### Inferred Results of Replacement Operation diff --git a/mlir/include/mlir/Analysis/Presburger/PWMAFunction.h b/mlir/include/mlir/Analysis/Presburger/PWMAFunction.h index fcc39bf0e0537..640ce509fa4df 100644 --- a/mlir/include/mlir/Analysis/Presburger/PWMAFunction.h +++ b/mlir/include/mlir/Analysis/Presburger/PWMAFunction.h @@ -119,7 +119,7 @@ class MultiAffineFunction { /// The space of this function. The domain variables are considered as the /// input variables of the function. The range variables are considered as /// the outputs. The symbols parametrize the function and locals are used to - /// represent divisions. Each local variable has a corressponding division + /// represent divisions. Each local variable has a corresponding division /// representation stored in `divs`. PresburgerSpace space; diff --git a/mlir/include/mlir/AsmParser/AsmParser.h b/mlir/include/mlir/AsmParser/AsmParser.h index 3c1bff1fbc7f1..33daf7ca26f49 100644 --- a/mlir/include/mlir/AsmParser/AsmParser.h +++ b/mlir/include/mlir/AsmParser/AsmParser.h @@ -47,7 +47,7 @@ parseAsmSourceFile(const llvm::SourceMgr &sourceMgr, Block *block, /// not, an error diagnostic is emitted to the context and a null value is /// returned. /// If `numRead` is provided, it is set to the number of consumed characters on -/// succesful parse. Otherwise, parsing fails if the entire string is not +/// successful parse. Otherwise, parsing fails if the entire string is not /// consumed. /// Some internal copying can be skipped if the source string is known to be /// null terminated. @@ -58,7 +58,7 @@ Attribute parseAttribute(llvm::StringRef attrStr, MLIRContext *context, /// This parses a single MLIR type to an MLIR context if it was valid. If not, /// an error diagnostic is emitted to the context. /// If `numRead` is provided, it is set to the number of consumed characters on -/// succesful parse. Otherwise, parsing fails if the entire string is not +/// successful parse. Otherwise, parsing fails if the entire string is not /// consumed. /// Some internal copying can be skipped if the source string is known to be /// null terminated. diff --git a/mlir/include/mlir/Bytecode/BytecodeImplementation.h b/mlir/include/mlir/Bytecode/BytecodeImplementation.h index 0ddc531073e23..7379e5d4c8095 100644 --- a/mlir/include/mlir/Bytecode/BytecodeImplementation.h +++ b/mlir/include/mlir/Bytecode/BytecodeImplementation.h @@ -438,7 +438,7 @@ class BytecodeDialectInterface /// Read a type belonging to this dialect from the given reader. This method /// should return null in the case of failure. Optionally, the dialect version - /// can be accessed thorugh the reader. + /// can be accessed through the reader. virtual Type readType(DialectBytecodeReader &reader) const { reader.emitError() << "dialect " << getDialect()->getNamespace() << " does not support reading types from bytecode"; diff --git a/mlir/include/mlir/Bytecode/BytecodeReader.h b/mlir/include/mlir/Bytecode/BytecodeReader.h index 19f74a0750cc9..e68fcc0c3bd18 100644 --- a/mlir/include/mlir/Bytecode/BytecodeReader.h +++ b/mlir/include/mlir/Bytecode/BytecodeReader.h @@ -57,7 +57,7 @@ class BytecodeReader { /// The lazyOps call back is invoked for every ops that can be lazy-loaded. /// This let the client decide if the op should be materialized immediately or /// delayed. - /// !! Using this materialize withing an IR walk() can be confusing: make sure + /// !! Using this materialize within an IR walk() can be confusing: make sure /// to use a PreOrder traversal !! LogicalResult materialize( Operation *op, llvm::function_ref lazyOpsCallback = diff --git a/mlir/include/mlir/Conversion/VectorToGPU/VectorToGPU.h b/mlir/include/mlir/Conversion/VectorToGPU/VectorToGPU.h index 10467e61ad083..9521a79e65c0f 100644 --- a/mlir/include/mlir/Conversion/VectorToGPU/VectorToGPU.h +++ b/mlir/include/mlir/Conversion/VectorToGPU/VectorToGPU.h @@ -31,7 +31,7 @@ void populatePrepareVectorToMMAPatterns(RewritePatternSet &patterns, /// The rest of the vector operations are left untouched. LogicalResult convertVectorToMMAOps(RewriterBase &rewriter, Operation *rootOp); -/// Convert vector ops ops nested under `rootOp` to vector and GPU operaitons +/// Convert vector ops ops nested under `rootOp` to vector and GPU operations /// compatible with the `nvvm.mma.sync` lowering path. This will convert a slice /// of operations that can be legally lowered on this path while the rest of /// the vector operations are left untouched. diff --git a/mlir/include/mlir/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h b/mlir/include/mlir/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h index e62b9c0bc0de5..75ba52b78c0a0 100644 --- a/mlir/include/mlir/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h +++ b/mlir/include/mlir/Debug/BreakpointManagers/FileLineColLocBreakpointManager.h @@ -21,7 +21,7 @@ namespace mlir { namespace tracing { -/// This breakpoing intends to match a FileLineColLocation, that is a tuple of +/// This breakpoint intends to match a FileLineColLocation, that is a tuple of /// file name, line number, and column number. Using -1 for the column and the /// line number will match any column and line number respectively. class FileLineColLocBreakpoint diff --git a/mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVWebGPUTransforms.h b/mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVWebGPUTransforms.h index d0fc85ccc9de4..2bb642b088bd4 100644 --- a/mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVWebGPUTransforms.h +++ b/mlir/include/mlir/Dialect/SPIRV/Transforms/SPIRVWebGPUTransforms.h @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// // -// Defines SPIR-V transforms used when targetting WebGPU. +// Defines SPIR-V transforms used when targeting WebGPU. // //===----------------------------------------------------------------------===// diff --git a/mlir/include/mlir/IR/AttrTypeBase.td b/mlir/include/mlir/IR/AttrTypeBase.td index d176b36068f7a..46278b526f722 100644 --- a/mlir/include/mlir/IR/AttrTypeBase.td +++ b/mlir/include/mlir/IR/AttrTypeBase.td @@ -164,7 +164,7 @@ class AttrOrTypeDef defTraits, // Name of storage class to generate or use. string storageClass = name # valueType # "Storage"; - // Namespace (withing dialect c++ namespace) in which the storage class + // Namespace (within dialect c++ namespace) in which the storage class // resides. string storageNamespace = "detail"; diff --git a/mlir/include/mlir/IR/OpImplementation.h b/mlir/include/mlir/IR/OpImplementation.h index e2472eea8a371..7d8ec11182694 100644 --- a/mlir/include/mlir/IR/OpImplementation.h +++ b/mlir/include/mlir/IR/OpImplementation.h @@ -796,7 +796,7 @@ class AsmParser { /// least one element will be parsed. /// /// contextMessage is an optional message appended to "expected '('" sorts of - /// diagnostics when parsing the delimeters. + /// diagnostics when parsing the delimiters. virtual ParseResult parseCommaSeparatedList(Delimiter delimiter, function_ref parseElementFn, diff --git a/mlir/include/mlir/IR/Threading.h b/mlir/include/mlir/IR/Threading.h index 3ceab6b3e883a..0f88f0863d82d 100644 --- a/mlir/include/mlir/IR/Threading.h +++ b/mlir/include/mlir/IR/Threading.h @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// // -// This file defines various utilies for multithreaded processing within MLIR. +// This file defines various utilities for multithreaded processing within MLIR. // These utilities automatically handle many of the necessary threading // conditions, such as properly ordering diagnostics, observing if threading is // disabled, etc. These utilities should be used over other threading utilities diff --git a/mlir/include/mlir/Interfaces/Utils/InferIntRangeCommon.h b/mlir/include/mlir/Interfaces/Utils/InferIntRangeCommon.h index 3988a8826498a..ece40efcbaf75 100644 --- a/mlir/include/mlir/Interfaces/Utils/InferIntRangeCommon.h +++ b/mlir/include/mlir/Interfaces/Utils/InferIntRangeCommon.h @@ -27,7 +27,7 @@ namespace intrange { using InferRangeFn = std::function)>; -/// Function that performs inferrence on an array of `IntegerValueRange`. +/// Function that performs inference on an array of `IntegerValueRange`. using InferIntegerValueRangeFn = std::function)>; diff --git a/mlir/include/mlir/TableGen/Class.h b/mlir/include/mlir/TableGen/Class.h index f750a34a3b2ba..612974ccb043d 100644 --- a/mlir/include/mlir/TableGen/Class.h +++ b/mlir/include/mlir/TableGen/Class.h @@ -143,7 +143,7 @@ class MethodSignature { /// Determine whether a method with this signature makes a method with /// `other` signature redundant. This occurs if the signatures have the same - /// name and this signature's parameteres subsume the other's. + /// name and this signature's parameters subsume the other's. /// /// A method that makes another method redundant with a different return type /// can replace the other, the assumption being that the subsuming method @@ -325,7 +325,7 @@ class Method : public ClassDeclarationBase { }; /// Create a method with a return type, a name, method properties, and a some - /// parameters. The parameteres may be passed as a list or as a variadic pack. + /// parameters. The parameters may be passed as a list or as a variadic pack. template Method(RetTypeT &&retType, NameT &&name, Properties properties, Args &&...args) diff --git a/mlir/include/mlir/TableGen/Constraint.h b/mlir/include/mlir/TableGen/Constraint.h index 8877daaa77514..77a8b71753dab 100644 --- a/mlir/include/mlir/TableGen/Constraint.h +++ b/mlir/include/mlir/TableGen/Constraint.h @@ -58,12 +58,12 @@ class Constraint { // not provided, returns an empty string. StringRef getDescription() const; - /// Returns the name of the TablGen def of this constraint. In some cases + /// Returns the name of the TableGen def of this constraint. In some cases /// where the current def is anonymous, the name of the base def is used (e.g. /// `std::optional<>`/`Variadic<>` type constraints). StringRef getDefName() const; - /// Returns a unique name for the TablGen def of this constraint. This is + /// Returns a unique name for the TableGen def of this constraint. This is /// generally just the name of the def, but in some cases where the current /// def is anonymous, the name of the base def is attached (to provide more /// context on the def). diff --git a/mlir/include/mlir/Tools/PDLL/AST/Nodes.h b/mlir/include/mlir/Tools/PDLL/AST/Nodes.h index aed2562e4d30d..45ca499965c90 100644 --- a/mlir/include/mlir/Tools/PDLL/AST/Nodes.h +++ b/mlir/include/mlir/Tools/PDLL/AST/Nodes.h @@ -107,7 +107,7 @@ class DeclScope { /// nodes. class Node { public: - /// This CRTP class provides several utilies when defining new AST nodes. + /// This CRTP class provides several utilities when defining new AST nodes. template class NodeBase : public BaseT { public: @@ -1312,7 +1312,7 @@ class Module final : public Node::NodeBase, }; //===----------------------------------------------------------------------===// -// Defered Method Definitions +// Deferred Method Definitions //===----------------------------------------------------------------------===// inline bool Decl::classof(const Node *node) { diff --git a/mlir/include/mlir/Tools/PDLL/AST/Types.h b/mlir/include/mlir/Tools/PDLL/AST/Types.h index 89c8e193ddc32..da34527dea57b 100644 --- a/mlir/include/mlir/Tools/PDLL/AST/Types.h +++ b/mlir/include/mlir/Tools/PDLL/AST/Types.h @@ -146,7 +146,7 @@ class AttributeType : public Type::TypeBase { //===----------------------------------------------------------------------===// /// This class represents a PDLL type that corresponds to a constraint. This -/// type has no MLIR C++ API correspondance. +/// type has no MLIR C++ API correspondence. class ConstraintType : public Type::TypeBase { public: using Base::Base; @@ -231,7 +231,7 @@ class ValueRangeType : public RangeType { //===----------------------------------------------------------------------===// /// This class represents a PDLL type that corresponds to a rewrite reference. -/// This type has no MLIR C++ API correspondance. +/// This type has no MLIR C++ API correspondence. class RewriteType : public Type::TypeBase { public: using Base::Base; diff --git a/mlir/include/mlir/Tools/PDLL/ODS/Context.h b/mlir/include/mlir/Tools/PDLL/ODS/Context.h index 8a57bb791e639..e0ec324bb6d4e 100644 --- a/mlir/include/mlir/Tools/PDLL/ODS/Context.h +++ b/mlir/include/mlir/Tools/PDLL/ODS/Context.h @@ -63,7 +63,7 @@ class Context { /// operation already existed). std::pair insertOperation(StringRef name, StringRef summary, StringRef desc, - StringRef nativeClassName, bool supportsResultTypeInferrence, + StringRef nativeClassName, bool supportsResultTypeInference, SMLoc loc); /// Lookup an operation registered with the given name, or null if no diff --git a/mlir/include/mlir/Tools/PDLL/ODS/Dialect.h b/mlir/include/mlir/Tools/PDLL/ODS/Dialect.h index c5c60977dd2f1..84b25c2fe023c 100644 --- a/mlir/include/mlir/Tools/PDLL/ODS/Dialect.h +++ b/mlir/include/mlir/Tools/PDLL/ODS/Dialect.h @@ -35,7 +35,7 @@ class Dialect { /// operation already existed). std::pair insertOperation(StringRef name, StringRef summary, StringRef desc, - StringRef nativeClassName, bool supportsResultTypeInferrence, + StringRef nativeClassName, bool supportsResultTypeInference, SMLoc loc); /// Lookup an operation registered with the given name, or null if no diff --git a/mlir/include/mlir/Tools/PDLL/ODS/Operation.h b/mlir/include/mlir/Tools/PDLL/ODS/Operation.h index e49db88ef9c93..0408c3b9444b8 100644 --- a/mlir/include/mlir/Tools/PDLL/ODS/Operation.h +++ b/mlir/include/mlir/Tools/PDLL/ODS/Operation.h @@ -167,12 +167,12 @@ class Operation { /// Returns the results of this operation. ArrayRef getResults() const { return results; } - /// Return if the operation is known to support result type inferrence. - bool hasResultTypeInferrence() const { return supportsTypeInferrence; } + /// Return if the operation is known to support result type inference. + bool hasResultTypeInference() const { return supportsTypeInference; } private: Operation(StringRef name, StringRef summary, StringRef desc, - StringRef nativeClassName, bool supportsTypeInferrence, SMLoc loc); + StringRef nativeClassName, bool supportsTypeInference, SMLoc loc); /// The name of the operation. std::string name; @@ -184,8 +184,8 @@ class Operation { /// The native class name of the operation, used when generating native code. std::string nativeClassName; - /// Flag indicating if the operation is known to support type inferrence. - bool supportsTypeInferrence; + /// Flag indicating if the operation is known to support type inference. + bool supportsTypeInference; /// The source location of this operation. SMRange location; diff --git a/mlir/include/mlir/Tools/ParseUtilities.h b/mlir/include/mlir/Tools/ParseUtilities.h index f366f6826c9a1..18582bc6381ca 100644 --- a/mlir/include/mlir/Tools/ParseUtilities.h +++ b/mlir/include/mlir/Tools/ParseUtilities.h @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// // -// This file containts common utilities for implementing the file-parsing +// This file contains common utilities for implementing the file-parsing // behaviour for MLIR tools. // //===----------------------------------------------------------------------===// diff --git a/mlir/include/mlir/Tools/lsp-server-support/Protocol.h b/mlir/include/mlir/Tools/lsp-server-support/Protocol.h index 5d2eb01a523a7..a69c91c1d63da 100644 --- a/mlir/include/mlir/Tools/lsp-server-support/Protocol.h +++ b/mlir/include/mlir/Tools/lsp-server-support/Protocol.h @@ -957,7 +957,7 @@ struct ParameterInformation { /// The label of this parameter. Ignored when labelOffsets is set. std::string labelString; - /// Inclusive start and exclusive end offsets withing the containing signature + /// Inclusive start and exclusive end offsets within the containing signature /// label. std::optional> labelOffsets; diff --git a/mlir/include/mlir/Transforms/DialectConversion.h b/mlir/include/mlir/Transforms/DialectConversion.h index 65e279e046e88..8b1272ea98861 100644 --- a/mlir/include/mlir/Transforms/DialectConversion.h +++ b/mlir/include/mlir/Transforms/DialectConversion.h @@ -218,14 +218,15 @@ class TypeConverter { /// /// The conversion functions take a non-null Type or subclass of Type and a /// non-null Attribute (or subclass of Attribute), and returns a - /// `AttributeConversionResult`. This result can either contan an `Attribute`, - /// which may be `nullptr`, representing the conversion's success, - /// `AttributeConversionResult::na()` (the default empty value), indicating - /// that the conversion function did not apply and that further conversion - /// functions should be checked, or `AttributeConversionResult::abort()` - /// indicating that the conversion process should be aborted. + /// `AttributeConversionResult`. This result can either contain an + /// `Attribute`, which may be `nullptr`, representing the conversion's + /// success, `AttributeConversionResult::na()` (the default empty value), + /// indicating that the conversion function did not apply and that further + /// conversion functions should be checked, or + /// `AttributeConversionResult::abort()` indicating that the conversion + /// process should be aborted. /// - /// Registered conversion functions are callled in the reverse of the order in + /// Registered conversion functions are called in the reverse of the order in /// which they were registered. template < typename FnT, @@ -673,7 +674,7 @@ class ConversionPatternRewriter final : public PatternRewriter { /// If no block argument types are changing, the original block will be /// left in place and returned. /// - /// A signature converison must be provided. (Type converters can construct + /// A signature conversion must be provided. (Type converters can construct /// a signature conversion with `convertBlockSignature`.) /// /// Optionally, a type converter can be provided to build materializations. diff --git a/mlir/include/mlir/Transforms/Inliner.h b/mlir/include/mlir/Transforms/Inliner.h index ec77319d6ac88..812c5e46030ec 100644 --- a/mlir/include/mlir/Transforms/Inliner.h +++ b/mlir/include/mlir/Transforms/Inliner.h @@ -65,7 +65,7 @@ class InlinerConfig { /// This is an implementation of the inliner /// that operates bottom up over the Strongly Connected Components(SCCs) /// of the CallGraph. This enables a more incremental propagation -/// of inlining decisions from the leafs to the roots of the callgraph. +/// of inlining decisions from the leaves to the roots of the callgraph. class Inliner { public: /// This struct represents a resolved call to a given callgraph node. Given diff --git a/mlir/include/mlir/Transforms/OneToNTypeConversion.h b/mlir/include/mlir/Transforms/OneToNTypeConversion.h index 4c689ba219e88..39706c25d936b 100644 --- a/mlir/include/mlir/Transforms/OneToNTypeConversion.h +++ b/mlir/include/mlir/Transforms/OneToNTypeConversion.h @@ -15,7 +15,7 @@ // unrealized casts by user-provided materializations. For this to work, the // main function requires a special `TypeConverter`, a special // `PatternRewriter`, and special RewritePattern`s, which extend their -// respective base classes for 1:N type converions. +// respective base classes for 1:N type conversions. // // Note that this is much more simple-minded than the "real" dialect conversion, // which checks for legality before applying patterns and does probably many @@ -179,7 +179,7 @@ class OneToNPatternRewriter : public PatternRewriter { }; /// Base class for patterns with 1:N type conversions. Derived classes have to -/// overwrite the `matchAndRewrite` overlaod that provides additional +/// overwrite the `matchAndRewrite` overload that provides additional /// information for 1:N type conversions. class OneToNConversionPattern : public RewritePatternWithConverter { public: diff --git a/mlir/include/mlir/Transforms/Passes.td b/mlir/include/mlir/Transforms/Passes.td index 000d9f697618e..929d4d1a810c0 100644 --- a/mlir/include/mlir/Transforms/Passes.td +++ b/mlir/include/mlir/Transforms/Passes.td @@ -106,7 +106,7 @@ def RemoveDeadValues : Pass<"remove-dead-values"> { (A) Removes function arguments that are not live, (B) Removes function return values that are not live across all callers of the function, - (C) Removes unneccesary operands, results, region arguments, and region + (C) Removes unnecessary operands, results, region arguments, and region terminator operands of region branch ops, and, (D) Removes simple and region branch ops that have all non-live results and don't affect memory in any way, @@ -412,7 +412,7 @@ def SROA : Pass<"sroa"> { let summary = "Scalar Replacement of Aggregates"; let description = [{ Scalar Replacement of Aggregates. Replaces allocations of aggregates into - independant allocations of its elements. + independent allocations of its elements. Allocators must implement `DestructurableAllocationOpInterface` to provide the list of memory slots for which destructuring should be attempted. diff --git a/mlir/include/mlir/Transforms/RegionUtils.h b/mlir/include/mlir/Transforms/RegionUtils.h index 5c57dd5b7532a..f09272b5596d7 100644 --- a/mlir/include/mlir/Transforms/RegionUtils.h +++ b/mlir/include/mlir/Transforms/RegionUtils.h @@ -60,7 +60,7 @@ void getUsedValuesDefinedAbove(MutableArrayRef regions, /// - `cloneOperationIntoRegion` is a callback that allows caller to specify /// if the operation defining an `OpOperand` needs to be cloned into the /// region. Then the operands of this operation become part of the captured -/// values set (unless the operations that define the operands themeselves +/// values set (unless the operations that define the operands themselves /// are to be cloned). The cloned operations are added to the entry block /// of the region. /// Return the set of captured values for the operation. diff --git a/mlir/lib/Analysis/Presburger/PWMAFunction.cpp b/mlir/lib/Analysis/Presburger/PWMAFunction.cpp index beb9f3e82e22d..59207ce130989 100644 --- a/mlir/lib/Analysis/Presburger/PWMAFunction.cpp +++ b/mlir/lib/Analysis/Presburger/PWMAFunction.cpp @@ -416,7 +416,7 @@ static void addDivisionConstraints(IntegerRelation &rel, } IntegerRelation MultiAffineFunction::getAsRelation() const { - // Create a relation corressponding to the input space plus the divisions + // Create a relation corresponding to the input space plus the divisions // used in outputs. IntegerRelation result(PresburgerSpace::getRelationSpace( space.getNumDomainVars(), 0, space.getNumSymbolVars(), diff --git a/mlir/lib/Bindings/Python/IRModule.h b/mlir/lib/Bindings/Python/IRModule.h index 172898cfda0c5..3cf65e00b2eeb 100644 --- a/mlir/lib/Bindings/Python/IRModule.h +++ b/mlir/lib/Bindings/Python/IRModule.h @@ -228,7 +228,7 @@ class PyMlirContext { void clearOperationsInside(PyOperationBase &op); void clearOperationsInside(MlirOperation op); - /// Clears the operaiton _and_ all operations inside using + /// Clears the operation _and_ all operations inside using /// `clearOperation(MlirOperation)`. void clearOperationAndInside(PyOperationBase &op); diff --git a/mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp b/mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp index e6c01f063e8b8..df23b46e0203b 100644 --- a/mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp +++ b/mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp @@ -1057,10 +1057,10 @@ class CmpFOpNanNonePattern final : public OpConversionPattern { Value replace; if (bitEnumContainsAll(op.getFastmath(), arith::FastMathFlags::nnan)) { if (op.getPredicate() == arith::CmpFPredicate::ORD) { - // Ordered comparsion checks if neither operand is NaN. + // Ordered comparison checks if neither operand is NaN. replace = spirv::ConstantOp::getOne(op.getType(), loc, rewriter); } else { - // Unordered comparsion checks if either operand is NaN. + // Unordered comparison checks if either operand is NaN. replace = spirv::ConstantOp::getZero(op.getType(), loc, rewriter); } } else { diff --git a/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp b/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp index b00cd0dee3ae8..d8d038365b1f1 100644 --- a/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp +++ b/mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp @@ -887,7 +887,7 @@ void PatternLowering::generateOperationResultTypeRewriter( Block *rewriterBlock = op->getBlock(); // Try to handle resolution for each of the result types individually. This is - // preferred over type inferrence because it will allow for us to use existing + // preferred over type inference because it will allow for us to use existing // types directly, as opposed to trying to rebuild the type list. OperandRange resultTypeValues = op.getTypeValues(); auto tryResolveResultTypes = [&] { diff --git a/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp b/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp index 8fffdbf664c3f..dee9e384f2253 100644 --- a/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp +++ b/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp @@ -29,7 +29,7 @@ using namespace mlir::bufferization; // BufferPlacementAllocs //===----------------------------------------------------------------------===// -/// Get the start operation to place the given alloc value withing the +/// Get the start operation to place the given alloc value within the // specified placement block. Operation *BufferPlacementAllocs::getStartOperation(Value allocValue, Block *placementBlock, diff --git a/mlir/lib/Dialect/GPU/Transforms/AllReduceLowering.cpp b/mlir/lib/Dialect/GPU/Transforms/AllReduceLowering.cpp index a75598afe8c72..aa162d512f0ed 100644 --- a/mlir/lib/Dialect/GPU/Transforms/AllReduceLowering.cpp +++ b/mlir/lib/Dialect/GPU/Transforms/AllReduceLowering.cpp @@ -81,7 +81,7 @@ struct GpuAllReduceRewriter { Value invocationIdx = create(int32Type, tmp3, tidX); Value workgroupSize = create(int32Type, tmp4, dimZ); - // Compute lane id (invocation id withing the subgroup). + // Compute lane id (invocation id within the subgroup). Value subgroupMask = create(kSubgroupSize - 1, int32Type); Value laneId = create(invocationIdx, subgroupMask); diff --git a/mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp b/mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp index 90ee0fb3bf0b6..c9beab9c501aa 100644 --- a/mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp +++ b/mlir/lib/Dialect/Linalg/Transforms/DropUnitDims.cpp @@ -330,7 +330,7 @@ static Value collapseValue( /// Compute the modified metadata for an operands of operation /// whose unit dims are being dropped. Return the new indexing map /// to use, the shape of the operand in the replacement op -/// and the `reassocation` to use to go from original operand shape +/// and the `reassociation` to use to go from original operand shape /// to modified operand shape. struct UnitExtentReplacementInfo { AffineMap indexMap; diff --git a/mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp b/mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp index c818675993c2c..59a8ac737a3f4 100644 --- a/mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp +++ b/mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp @@ -584,7 +584,7 @@ class ExpansionInfo { public: // Computes the mapping from original dimensions of the op to the dimensions // of the expanded op given the `indexingMap` of the fused operand/result of - // the generic op, the `reassocationMaps` of the reshape op and the shape of + // the generic op, the `reassociationMaps` of the reshape op and the shape of // the expanded op. LogicalResult compute(LinalgOp linalgOp, OpOperand *fusableOpOperand, ArrayRef reassociationMaps, diff --git a/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp b/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp index 9c021d3613f1c..98c83cce00cf6 100644 --- a/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp +++ b/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp @@ -2107,7 +2107,7 @@ LogicalResult ExpandShapeOp::reifyResultShapes( /// result and operand. Layout maps are verified separately. /// /// If `allowMultipleDynamicDimsPerGroup`, multiple dynamic dimensions are -/// allowed in a reassocation group. +/// allowed in a reassociation group. static LogicalResult verifyCollapsedShape(Operation *op, ArrayRef collapsedShape, ArrayRef expandedShape, diff --git a/mlir/lib/Dialect/MemRef/Transforms/EmulateWideInt.cpp b/mlir/lib/Dialect/MemRef/Transforms/EmulateWideInt.cpp index 57f0141c95dc5..a51181930f9a3 100644 --- a/mlir/lib/Dialect/MemRef/Transforms/EmulateWideInt.cpp +++ b/mlir/lib/Dialect/MemRef/Transforms/EmulateWideInt.cpp @@ -121,7 +121,7 @@ struct EmulateWideIntPass final [&typeConverter](Operation *op) { return typeConverter.isLegal(op); }); RewritePatternSet patterns(ctx); - // Add common pattenrs to support contants, functions, etc. + // Add common patterns to support contants, functions, etc. arith::populateArithWideIntEmulationPatterns(typeConverter, patterns); memref::populateMemRefWideIntEmulationPatterns(typeConverter, patterns); diff --git a/mlir/lib/Dialect/SPIRV/Transforms/SPIRVWebGPUTransforms.cpp b/mlir/lib/Dialect/SPIRV/Transforms/SPIRVWebGPUTransforms.cpp index d75c8552c9ad0..dcc9fa83103d6 100644 --- a/mlir/lib/Dialect/SPIRV/Transforms/SPIRVWebGPUTransforms.cpp +++ b/mlir/lib/Dialect/SPIRV/Transforms/SPIRVWebGPUTransforms.cpp @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// // -// This file implements SPIR-V transforms used when targetting WebGPU. +// This file implements SPIR-V transforms used when targeting WebGPU. // //===----------------------------------------------------------------------===// diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/Utils/LoopEmitter.h b/mlir/lib/Dialect/SparseTensor/Transforms/Utils/LoopEmitter.h index 3e61b5f27fcc2..2415f6f228028 100644 --- a/mlir/lib/Dialect/SparseTensor/Transforms/Utils/LoopEmitter.h +++ b/mlir/lib/Dialect/SparseTensor/Transforms/Utils/LoopEmitter.h @@ -367,7 +367,7 @@ class LoopEmitter { void initSubSectIterator(OpBuilder &builder, Location loc); - /// Get the reduced number of contraints on tensor[tid][lvl]. + /// Get the reduced number of constraints on tensor[tid][lvl]. unsigned redDepOnLevel(TensorId tid, Level lvl) const { return levelReducedDep[tid][lvl]; }; diff --git a/mlir/lib/Dialect/Tensor/IR/TensorInferTypeOpInterfaceImpl.cpp b/mlir/lib/Dialect/Tensor/IR/TensorInferTypeOpInterfaceImpl.cpp index 7ff435a033985..df6e3e391368d 100644 --- a/mlir/lib/Dialect/Tensor/IR/TensorInferTypeOpInterfaceImpl.cpp +++ b/mlir/lib/Dialect/Tensor/IR/TensorInferTypeOpInterfaceImpl.cpp @@ -18,7 +18,7 @@ using namespace mlir::tensor; /// Compute a map that for a given dimension of the expanded type gives the /// dimension in the collapsed type it maps to. Essentially its the inverse of -/// the `reassocation` maps. +/// the `reassociation` maps. static llvm::DenseMap getExpandedDimToCollapsedDimMap(ArrayRef reassociation) { llvm::DenseMap expandedDimToCollapsedDim; @@ -134,14 +134,14 @@ static SmallVector getExpandedOutputShapeFromInputShape( static SmallVector getReshapeOutputShapeFromInputShape(OpBuilder &builder, Location loc, Value src, ArrayRef dstStaticShape, - ArrayRef reassocation) { + ArrayRef reassociation) { return dstStaticShape.size() > static_cast( llvm::cast(src.getType()).getRank()) ? getExpandedOutputShapeFromInputShape( - builder, loc, src, dstStaticShape, reassocation) + builder, loc, src, dstStaticShape, reassociation) : getCollapsedOutputShapeFromInputShape( - builder, loc, src, dstStaticShape, reassocation); + builder, loc, src, dstStaticShape, reassociation); } template diff --git a/mlir/lib/Tools/PDLL/ODS/Context.cpp b/mlir/lib/Tools/PDLL/ODS/Context.cpp index 61a9df92c8047..3ec2df076908f 100644 --- a/mlir/lib/Tools/PDLL/ODS/Context.cpp +++ b/mlir/lib/Tools/PDLL/ODS/Context.cpp @@ -63,11 +63,11 @@ const Dialect *Context::lookupDialect(StringRef name) const { std::pair Context::insertOperation(StringRef name, StringRef summary, StringRef desc, StringRef nativeClassName, - bool supportsResultTypeInferrence, SMLoc loc) { + bool supportsResultTypeInference, SMLoc loc) { std::pair dialectAndName = name.split('.'); return insertDialect(dialectAndName.first) .insertOperation(name, summary, desc, nativeClassName, - supportsResultTypeInferrence, loc); + supportsResultTypeInference, loc); } const Operation *Context::lookupOperation(StringRef name) const { diff --git a/mlir/lib/Tools/PDLL/ODS/Dialect.cpp b/mlir/lib/Tools/PDLL/ODS/Dialect.cpp index b4654a6ad5b2e..6046a4950027d 100644 --- a/mlir/lib/Tools/PDLL/ODS/Dialect.cpp +++ b/mlir/lib/Tools/PDLL/ODS/Dialect.cpp @@ -24,13 +24,13 @@ Dialect::~Dialect() = default; std::pair Dialect::insertOperation(StringRef name, StringRef summary, StringRef desc, StringRef nativeClassName, - bool supportsResultTypeInferrence, llvm::SMLoc loc) { + bool supportsResultTypeInference, llvm::SMLoc loc) { std::unique_ptr &operation = operations[name]; if (operation) return std::make_pair(&*operation, /*wasInserted*/ false); operation.reset(new Operation(name, summary, desc, nativeClassName, - supportsResultTypeInferrence, loc)); + supportsResultTypeInference, loc)); return std::make_pair(&*operation, /*wasInserted*/ true); } diff --git a/mlir/lib/Tools/PDLL/ODS/Operation.cpp b/mlir/lib/Tools/PDLL/ODS/Operation.cpp index 7e708be1ae4d1..adcfbec2e3d17 100644 --- a/mlir/lib/Tools/PDLL/ODS/Operation.cpp +++ b/mlir/lib/Tools/PDLL/ODS/Operation.cpp @@ -18,9 +18,9 @@ using namespace mlir::pdll::ods; //===----------------------------------------------------------------------===// Operation::Operation(StringRef name, StringRef summary, StringRef desc, - StringRef nativeClassName, bool supportsTypeInferrence, + StringRef nativeClassName, bool supportsTypeInference, llvm::SMLoc loc) : name(name.str()), summary(summary.str()), description(desc.str()), nativeClassName(nativeClassName.str()), - supportsTypeInferrence(supportsTypeInferrence), + supportsTypeInference(supportsTypeInference), location(loc, llvm::SMLoc::getFromPointer(loc.getPointer() + 1)) {} diff --git a/mlir/lib/Tools/PDLL/Parser/Parser.cpp b/mlir/lib/Tools/PDLL/Parser/Parser.cpp index 2f842df48826d..7d5496804928a 100644 --- a/mlir/lib/Tools/PDLL/Parser/Parser.cpp +++ b/mlir/lib/Tools/PDLL/Parser/Parser.cpp @@ -433,8 +433,8 @@ class Parser { std::optional name, const ods::Operation *odsOp, SmallVectorImpl &results); - void checkOperationResultTypeInferrence(SMRange loc, StringRef name, - const ods::Operation *odsOp); + void checkOperationResultTypeInference(SMRange loc, StringRef name, + const ods::Operation *odsOp); LogicalResult validateOperationOperandsOrResults( StringRef groupName, SMRange loc, std::optional odsOpLoc, std::optional name, SmallVectorImpl &values, @@ -890,14 +890,14 @@ void Parser::processTdIncludeRecords(const llvm::RecordKeeper &tdRecords, for (const llvm::Record *def : tdRecords.getAllDerivedDefinitions("Op")) { tblgen::Operator op(def); - // Check to see if this operation is known to support type inferrence. - bool supportsResultTypeInferrence = + // Check to see if this operation is known to support type inference. + bool supportsResultTypeInference = op.getTrait("::mlir::InferTypeOpInterface::Trait"); auto [odsOp, inserted] = odsContext.insertOperation( op.getOperationName(), processDoc(op.getSummary()), processAndFormatDoc(op.getDescription()), op.getQualCppClassName(), - supportsResultTypeInferrence, op.getLoc().front()); + supportsResultTypeInference, op.getLoc().front()); // Ignore operations that have already been added. if (!inserted) @@ -2112,7 +2112,7 @@ Parser::parseOperationExpr(OpResultTypeContext inputResultTypeContext) { return failure(); // If result types are provided, initially assume that the operation does - // not rely on type inferrence. We don't assert that it isn't, because we + // not rely on type inference. We don't assert that it isn't, because we // may be inferring the value of some type/type range variables, but given // that these variables may be defined in calls we can't always discern when // this is the case. @@ -2415,7 +2415,7 @@ FailureOr Parser::parseReplaceStmt() { return failure(); } else { // Handle replacement with an operation uniquely, as the replacement - // operation supports type inferrence from the root operation. + // operation supports type inference from the root operation. FailureOr replExpr; if (curToken.is(Token::kw_op)) replExpr = parseOperationExpr(OpResultTypeContext::Replacement); @@ -2853,19 +2853,19 @@ FailureOr Parser::createOperationExpr( assert( (resultTypeContext == OpResultTypeContext::Explicit || results.empty()) && - "unexpected inferrence when results were explicitly specified"); + "unexpected inference when results were explicitly specified"); - // If we aren't relying on type inferrence, or explicit results were provided, + // If we aren't relying on type inference, or explicit results were provided, // validate them. if (resultTypeContext == OpResultTypeContext::Explicit) { if (failed(validateOperationResults(loc, opNameRef, odsOp, results))) return failure(); - // Validate the use of interface based type inferrence for this operation. + // Validate the use of interface based type inference for this operation. } else if (resultTypeContext == OpResultTypeContext::Interface) { assert(opNameRef && "expected valid operation name when inferring operation results"); - checkOperationResultTypeInferrence(loc, *opNameRef, odsOp); + checkOperationResultTypeInference(loc, *opNameRef, odsOp); } return ast::OperationExpr::create(ctx, loc, odsOp, name, operands, results, @@ -2891,14 +2891,14 @@ Parser::validateOperationResults(SMRange loc, std::optional name, results, odsOp ? odsOp->getResults() : std::nullopt, typeTy, typeRangeTy); } -void Parser::checkOperationResultTypeInferrence(SMRange loc, StringRef opName, - const ods::Operation *odsOp) { - // If the operation might not have inferrence support, emit a warning to the +void Parser::checkOperationResultTypeInference(SMRange loc, StringRef opName, + const ods::Operation *odsOp) { + // If the operation might not have inference support, emit a warning to the // user. We don't emit an error because the interface might be added to the // operation at runtime. It's rare, but it could still happen. We emit a // warning here instead. - // Handle inferrence warnings for unknown operations. + // Handle inference warnings for unknown operations. if (!odsOp) { ctx.getDiagEngine().emitWarning( loc, llvm::formatv( @@ -2910,15 +2910,15 @@ void Parser::checkOperationResultTypeInferrence(SMRange loc, StringRef opName, return; } - // Handle inferrence warnings for known operations that expected at least one + // Handle inference warnings for known operations that expected at least one // result, but don't have inference support. An elided results list can mean // "zero-results", and we don't want to warn when that is the expected // behavior. - bool requiresInferrence = + bool requiresInference = llvm::any_of(odsOp->getResults(), [](const ods::OperandOrResult &result) { return !result.isVariableLength(); }); - if (requiresInferrence && !odsOp->hasResultTypeInferrence()) { + if (requiresInference && !odsOp->hasResultTypeInference()) { ast::InFlightDiagnostic diag = ctx.getDiagEngine().emitWarning( loc, llvm::formatv("operation result types are marked to be inferred, but " diff --git a/mlir/lib/Transforms/InlinerPass.cpp b/mlir/lib/Transforms/InlinerPass.cpp index 04b2f9e419187..c1b050dbd44b2 100644 --- a/mlir/lib/Transforms/InlinerPass.cpp +++ b/mlir/lib/Transforms/InlinerPass.cpp @@ -8,7 +8,7 @@ // // This file implements a basic inlining algorithm that operates bottom up over // the Strongly Connect Components(SCCs) of the CallGraph. This enables a more -// incremental propagation of inlining decisions from the leafs to the roots of +// incremental propagation of inlining decisions from the leaves to the roots of // the callgraph. // //===----------------------------------------------------------------------===// diff --git a/mlir/lib/Transforms/RemoveDeadValues.cpp b/mlir/lib/Transforms/RemoveDeadValues.cpp index 055256903a152..cee528e9bfb62 100644 --- a/mlir/lib/Transforms/RemoveDeadValues.cpp +++ b/mlir/lib/Transforms/RemoveDeadValues.cpp @@ -16,7 +16,7 @@ // (A) Removes function arguments that are not live, // (B) Removes function return values that are not live across all callers of // the function, -// (C) Removes unneccesary operands, results, region arguments, and region +// (C) Removes unnecessary operands, results, region arguments, and region // terminator operands of region branch ops, and, // (D) Removes simple and region branch ops that have all non-live results and // don't affect memory in any way, @@ -282,7 +282,7 @@ static void cleanFuncOp(FunctionOpInterface funcOp, Operation *module, /// (2') Erasing it /// if it has no memory effects and none of its results are live, AND /// (1) Erasing its unnecessary operands (operands that are forwarded to -/// unneccesary results and arguments), +/// unnecessary results and arguments), /// (2) Cleaning each of its regions, /// (3) Dropping the uses of its unnecessary results (results that are /// forwarded from unnecessary operands and terminator operands), AND @@ -290,10 +290,10 @@ static void cleanFuncOp(FunctionOpInterface funcOp, Operation *module, /// otherwise. /// Note that here, cleaning a region means: /// (2.a) Dropping the uses of its unnecessary arguments (arguments that are -/// forwarded from unneccesary operands and terminator operands), +/// forwarded from unnecessary operands and terminator operands), /// (2.b) Erasing these arguments, AND /// (2.c) Erasing its unnecessary terminator operands (terminator operands -/// that are forwarded to unneccesary results and arguments). +/// that are forwarded to unnecessary results and arguments). /// It is important to note that values in this op flow from operands and /// terminator operands (successor operands) to arguments and results (successor /// inputs). diff --git a/mlir/lib/Transforms/Utils/Inliner.cpp b/mlir/lib/Transforms/Utils/Inliner.cpp index 8acfc96d2b611..e7636a591f563 100644 --- a/mlir/lib/Transforms/Utils/Inliner.cpp +++ b/mlir/lib/Transforms/Utils/Inliner.cpp @@ -9,7 +9,7 @@ // This file implements Inliner that uses a basic inlining // algorithm that operates bottom up over the Strongly Connect Components(SCCs) // of the CallGraph. This enables a more incremental propagation of inlining -// decisions from the leafs to the roots of the callgraph. +// decisions from the leaves to the roots of the callgraph. // //===----------------------------------------------------------------------===// diff --git a/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize.mlir b/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize.mlir index 05a032b1ece06..826362c54d220 100644 --- a/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize.mlir +++ b/mlir/test/Dialect/Linalg/transform-op-peel-and-vectorize.mlir @@ -3,7 +3,7 @@ // Demonstrates what happens when peeling the middle loop (2nd parallel // dimension) followed by vectorization in the presence of _scalable_ vectors // (these are introduced through scalable tiling). The main goal is to verify -// that canonicalizations fold away the masks in the main loop. +// that canonicalization fold away the masks in the main loop. func.func @matmul(%A: tensor<1024x512xf32>, %B: tensor<512x2000xf32>, diff --git a/mlir/test/Dialect/MemRef/expand-strided-metadata.mlir b/mlir/test/Dialect/MemRef/expand-strided-metadata.mlir index 8aac802ba10ae..eb58f7861890c 100644 --- a/mlir/test/Dialect/MemRef/expand-strided-metadata.mlir +++ b/mlir/test/Dialect/MemRef/expand-strided-metadata.mlir @@ -972,7 +972,7 @@ func.func @simplify_collapse(%arg : memref) // Size 0 = origSize0 * origSize1 // = 3 * 1 // = 3 -// Stride 0 = min(origStride_i, for all i in reassocation group and dim_i != 1) +// Stride 0 = min(origStride_i, for all i in reassociation group and dim_i != 1) // = min(origStride0) // = min(2) // = 2 diff --git a/mlir/test/Dialect/PDLInterp/ops.mlir b/mlir/test/Dialect/PDLInterp/ops.mlir index ef9cefe813a5b..00dd586943d54 100644 --- a/mlir/test/Dialect/PDLInterp/ops.mlir +++ b/mlir/test/Dialect/PDLInterp/ops.mlir @@ -7,7 +7,7 @@ // ----- // Unused operation to force loading the `arithmetic` dialect for the -// test of type inferrence. +// test of type inference. arith.constant true func.func @operations(%attribute: !pdl.attribute, diff --git a/mlir/test/Rewrite/pdl-bytecode.mlir b/mlir/test/Rewrite/pdl-bytecode.mlir index f8e4f2e83b296..9f20b962094f9 100644 --- a/mlir/test/Rewrite/pdl-bytecode.mlir +++ b/mlir/test/Rewrite/pdl-bytecode.mlir @@ -638,7 +638,7 @@ module @ir attributes { test.check_types_1 } { //===----------------------------------------------------------------------===// // Unused operation to force loading the `arithmetic` dialect for the -// test of type inferrence. +// test of type inference. arith.constant 10 // Test support for inferring the types of an operation. diff --git a/mlir/test/lib/Dialect/Test/TestOps.td b/mlir/test/lib/Dialect/Test/TestOps.td index 9e19966414d1d..2527424b81d1b 100644 --- a/mlir/test/lib/Dialect/Test/TestOps.td +++ b/mlir/test/lib/Dialect/Test/TestOps.td @@ -1344,7 +1344,7 @@ def TestInvolutionTraitFailingOperationFolderOp } def TestInvolutionTraitSuccesfulOperationFolderOp - : TEST_Op<"op_involution_trait_succesful_operation_fold", + : TEST_Op<"op_involution_trait_successful_operation_fold", [SameOperandsAndResultType, NoMemoryEffect, Involution]> { let arguments = (ins I32:$op1); let results = (outs I32); diff --git a/mlir/test/mlir-tblgen/trait.mlir b/mlir/test/mlir-tblgen/trait.mlir index 97279c374f7e3..a3a8d4c9e2020 100644 --- a/mlir/test/mlir-tblgen/trait.mlir +++ b/mlir/test/mlir-tblgen/trait.mlir @@ -53,9 +53,9 @@ func.func @testFailingOperationFolder(%arg0: i32) -> i32 { // CHECK-LABEL: func @testInhibitInvolution // CHECK-SAME: ([[ARG0:%.+]]: i32) func.func @testInhibitInvolution(%arg0: i32) -> i32 { - // CHECK: [[OP:%.+]] = "test.op_involution_trait_succesful_operation_fold"([[ARG0]]) - %0 = "test.op_involution_trait_succesful_operation_fold"(%arg0) : (i32) -> i32 - %1 = "test.op_involution_trait_succesful_operation_fold"(%0) : (i32) -> i32 + // CHECK: [[OP:%.+]] = "test.op_involution_trait_successful_operation_fold"([[ARG0]]) + %0 = "test.op_involution_trait_successful_operation_fold"(%arg0) : (i32) -> i32 + %1 = "test.op_involution_trait_successful_operation_fold"(%0) : (i32) -> i32 // CHECK: return [[OP]] return %1: i32 } diff --git a/mlir/tools/mlir-tblgen/RewriterGen.cpp b/mlir/tools/mlir-tblgen/RewriterGen.cpp index 598eb8ea12fcc..cccaab8c8200f 100644 --- a/mlir/tools/mlir-tblgen/RewriterGen.cpp +++ b/mlir/tools/mlir-tblgen/RewriterGen.cpp @@ -845,7 +845,7 @@ void PatternEmitter::emitVariadicOperandMatch(DagNode tree, emitMatchCheck( opName, /*matchStr=*/argName, formatv("\"There's no operation that defines variadic operand " - "{0} (variadic sub-opearnd #{1}) of {2}\"", + "{0} (variadic sub-operand #{1}) of {2}\"", operandIndex, i, opName)); emitMatch(argTree, argName, depth + 1); os << formatv("tblgen_ops.push_back({0});\n", argName); diff --git a/mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp b/mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp index 2dd539ef83481..819d96d7a8f4e 100644 --- a/mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp +++ b/mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp @@ -48,7 +48,7 @@ struct VulkanRunnerOptions { llvm::cl::OptionCategory category{"mlir-vulkan-runner options"}; llvm::cl::opt spirvWebGPUPrepare{ "vulkan-runner-spirv-webgpu-prepare", - llvm::cl::desc("Run MLIR transforms used when targetting WebGPU"), + llvm::cl::desc("Run MLIR transforms used when targeting WebGPU"), llvm::cl::cat(category)}; }; } // namespace @@ -97,7 +97,7 @@ int main(int argc, char **argv) { llvm::InitializeNativeTargetAsmPrinter(); // Initialize runner-specific CLI options. These will be parsed and - // initialzied in `JitRunnerMain`. + // initialized in `JitRunnerMain`. VulkanRunnerOptions options; auto runPassesWithOptions = [&options](Operation *op, JitRunnerOptions &) { return runMLIRPasses(op, options); diff --git a/mlir/unittests/Analysis/Presburger/IntegerPolyhedronTest.cpp b/mlir/unittests/Analysis/Presburger/IntegerPolyhedronTest.cpp index f64bb240b4ee4..381c53240afec 100644 --- a/mlir/unittests/Analysis/Presburger/IntegerPolyhedronTest.cpp +++ b/mlir/unittests/Analysis/Presburger/IntegerPolyhedronTest.cpp @@ -317,7 +317,7 @@ TEST(IntegerPolyhedronTest, FindSampleTest) { checkPermutationsSample( true /* not empty */, 5, { - // Tetrahedron contraints: + // Tetrahedron constraints: {0, 1, 0, 0, 0, 0}, // y >= 0 {0, -1, 1, 0, 0, 0}, // z >= y // -300000x + 299998y + 100000 + z <= 0. @@ -338,7 +338,7 @@ TEST(IntegerPolyhedronTest, FindSampleTest) { checkPermutationsSample( false /* empty */, 5, { - // Tetrahedron contraints: + // Tetrahedron constraints: {0, 1, 0, 0, 0, 0}, // y >= 0 {0, -1, 1, 0, 0, 0}, // z >= y // -300000x + 299998y + 100000 + z <= 0. @@ -360,7 +360,7 @@ TEST(IntegerPolyhedronTest, FindSampleTest) { checkPermutationsSample( false /* empty */, 5, { - // Tetrahedron contraints: + // Tetrahedron constraints: {0, 1, 0, 0, 0, 0, 0}, // y >= 0 {0, -1, 1, 0, 0, 0, 0}, // z >= y // -300000x + 299998y + 100000 + z <= 0. @@ -386,7 +386,7 @@ TEST(IntegerPolyhedronTest, FindSampleTest) { // Since the tetrahedron is empty, the Cartesian product is too. checkPermutationsSample(false /* empty */, 5, { - // Tetrahedron contraints: + // Tetrahedron constraints: {0, 1, 0, 0, 0, 0}, {0, -300, 299, 0, 0, 0}, {300 * 299, -89400, -299, 0, 0, -100 * 299}, @@ -404,7 +404,7 @@ TEST(IntegerPolyhedronTest, FindSampleTest) { // {(p, q) : 1/3 <= p <= 2/3}. checkPermutationsSample(false /* empty */, 5, { - // Tetrahedron contraints: + // Tetrahedron constraints: {0, 1, 0, 0, 0, 0}, {0, -300, 299, 0, 0, 0}, {300 * 299, -89400, -299, 0, 0, -100 * 299}, @@ -622,7 +622,7 @@ TEST(IntegerPolyhedronTest, addConstantLowerBound) { /// Check if the expected division representation of local variables matches the /// computed representation. The expected division representation is given as -/// a vector of expressions set in `expectedDividends` and the corressponding +/// a vector of expressions set in `expectedDividends` and the corresponding /// denominator in `expectedDenominators`. The `denominators` and `dividends` /// obtained through `getLocalRepr` function is verified against the /// `expectedDenominators` and `expectedDividends` respectively. diff --git a/mlir/unittests/Debug/FileLineColLocBreakpointManagerTest.cpp b/mlir/unittests/Debug/FileLineColLocBreakpointManagerTest.cpp index 5b48e80749c8b..bca2567ea71b8 100644 --- a/mlir/unittests/Debug/FileLineColLocBreakpointManagerTest.cpp +++ b/mlir/unittests/Debug/FileLineColLocBreakpointManagerTest.cpp @@ -110,7 +110,7 @@ TEST(FileLineColLocBreakpointManager, OperationMatch) { }; checkMatchIdxs({1}); - // Check that disabling the breakpoing brings us back to the original + // Check that disabling the breakpoint brings us back to the original // behavior. breakpoint->disable(); checkNoMatch(); diff --git a/mlir/unittests/Dialect/OpenACC/OpenACCOpsTest.cpp b/mlir/unittests/Dialect/OpenACC/OpenACCOpsTest.cpp index 452f39d8cae9f..7f8b28d495954 100644 --- a/mlir/unittests/Dialect/OpenACC/OpenACCOpsTest.cpp +++ b/mlir/unittests/Dialect/OpenACC/OpenACCOpsTest.cpp @@ -1,4 +1,4 @@ -//===- OpenACCOpsTest.cpp - OpenACC ops extra functiosn Tests -------------===// +//===- OpenACCOpsTest.cpp - OpenACC ops extra functions Tests -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. diff --git a/mlir/unittests/Dialect/SparseTensor/MergerTest.cpp b/mlir/unittests/Dialect/SparseTensor/MergerTest.cpp index abc6c70766943..5347e1c0e50ea 100644 --- a/mlir/unittests/Dialect/SparseTensor/MergerTest.cpp +++ b/mlir/unittests/Dialect/SparseTensor/MergerTest.cpp @@ -791,7 +791,7 @@ TEST_P(MergerTest3T1L, vector_cmp) { loopsToBits({{l0, t1}})); } -/// Vector element-wise comparsion (disjunction) of 2 vectors, i.e.; +/// Vector element-wise comparison (disjunction) of 2 vectors, i.e.; /// a(i) = b(i) cmp c(i) /// which should form the 3 lattice points /// { diff --git a/mlir/unittests/IR/AttrTypeReplacerTest.cpp b/mlir/unittests/IR/AttrTypeReplacerTest.cpp index c7b42eb267c7a..6f696f84d9726 100644 --- a/mlir/unittests/IR/AttrTypeReplacerTest.cpp +++ b/mlir/unittests/IR/AttrTypeReplacerTest.cpp @@ -141,13 +141,13 @@ TEST_F(CyclicAttrTypeReplacerChainRecursionPruningTest, testPruneSpecific1) { } //===----------------------------------------------------------------------===// -// CyclicAttrTypeReplacerTest: BranchingRecusion +// CyclicAttrTypeReplacerTest: BranchingRecursion //===----------------------------------------------------------------------===// -class CyclicAttrTypeReplacerBranchingRecusionPruningTest +class CyclicAttrTypeReplacerBranchingRecursionPruningTest : public ::testing::Test { public: - CyclicAttrTypeReplacerBranchingRecusionPruningTest() : b(&ctx) { + CyclicAttrTypeReplacerBranchingRecursionPruningTest() : b(&ctx) { // IntegerType // ==> FunctionType< // IntegerType< width = (N+1) % 3> => @@ -181,7 +181,8 @@ class CyclicAttrTypeReplacerBranchingRecusionPruningTest int invokeCount = 0; }; -TEST_F(CyclicAttrTypeReplacerBranchingRecusionPruningTest, testPruneAnywhere0) { +TEST_F(CyclicAttrTypeReplacerBranchingRecursionPruningTest, + testPruneAnywhere0) { setBaseCase(std::nullopt); // No recursion case. @@ -203,7 +204,8 @@ TEST_F(CyclicAttrTypeReplacerBranchingRecusionPruningTest, testPruneAnywhere0) { EXPECT_EQ(invokeCount, 2); } -TEST_F(CyclicAttrTypeReplacerBranchingRecusionPruningTest, testPruneAnywhere1) { +TEST_F(CyclicAttrTypeReplacerBranchingRecursionPruningTest, + testPruneAnywhere1) { setBaseCase(std::nullopt); // Starting at 1. Cycle length is 3. @@ -212,7 +214,8 @@ TEST_F(CyclicAttrTypeReplacerBranchingRecusionPruningTest, testPruneAnywhere1) { EXPECT_EQ(invokeCount, 3); } -TEST_F(CyclicAttrTypeReplacerBranchingRecusionPruningTest, testPruneSpecific0) { +TEST_F(CyclicAttrTypeReplacerBranchingRecursionPruningTest, + testPruneSpecific0) { setBaseCase(0); // Starting at 0. Cycle length is 3. @@ -221,7 +224,8 @@ TEST_F(CyclicAttrTypeReplacerBranchingRecusionPruningTest, testPruneSpecific0) { EXPECT_EQ(invokeCount, 3); } -TEST_F(CyclicAttrTypeReplacerBranchingRecusionPruningTest, testPruneSpecific1) { +TEST_F(CyclicAttrTypeReplacerBranchingRecursionPruningTest, + testPruneSpecific1) { setBaseCase(0); // Starting at 1. Cycle length is 5 (1 -> 2 -> 0 -> 1 -> 2 -> Prune). diff --git a/mlir/unittests/IR/InterfaceAttachmentTest.cpp b/mlir/unittests/IR/InterfaceAttachmentTest.cpp index b6066dd5685dc..6fd9bce601a99 100644 --- a/mlir/unittests/IR/InterfaceAttachmentTest.cpp +++ b/mlir/unittests/IR/InterfaceAttachmentTest.cpp @@ -39,7 +39,7 @@ struct Model static unsigned staticGetSomeValuePlusArg(unsigned arg) { return 42 + arg; } }; -/// External interface model for the float type. Provides non-deafult and +/// External interface model for the float type. Provides non-default and /// overrides default methods. struct OverridingModel : public TestExternalTypeInterface::ExternalModel(UnknownLoc::get(&context)); ASSERT_FALSE(isa(moduleOp->getOperation())); - // We can attach an external interface and now the operaiton has it. + // We can attach an external interface and now the operation has it. ModuleOp::attachInterface(context); auto iface = dyn_cast(moduleOp->getOperation()); ASSERT_TRUE(iface != nullptr); diff --git a/mlir/unittests/IR/OpPropertiesTest.cpp b/mlir/unittests/IR/OpPropertiesTest.cpp index 365775d541ec3..aa5f075e860ff 100644 --- a/mlir/unittests/IR/OpPropertiesTest.cpp +++ b/mlir/unittests/IR/OpPropertiesTest.cpp @@ -16,7 +16,7 @@ using namespace mlir; namespace { -/// Simple structure definining a struct to define "properties" for a given +/// Simple structure defining a struct to define "properties" for a given /// operation. Default values are honored when creating an operation. struct TestProperties { int a = -1; diff --git a/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp b/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp index b667785c16f16..1f1a5d05b0c50 100644 --- a/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp +++ b/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp @@ -22,7 +22,7 @@ using namespace mlir; namespace { constexpr static llvm::StringLiteral kAttrName = "dltest.layout"; -constexpr static llvm::StringLiteral kEndiannesKeyName = "dltest.endianness"; +constexpr static llvm::StringLiteral kEndiannessKeyName = "dltest.endianness"; constexpr static llvm::StringLiteral kAllocaKeyName = "dltest.alloca_memory_space"; constexpr static llvm::StringLiteral kProgramKeyName = @@ -78,7 +78,7 @@ struct CustomDataLayoutSpec DataLayoutEntryListRef getEntries() const { return getImpl()->entries; } LogicalResult verifySpec(Location loc) { return success(); } StringAttr getEndiannessIdentifier(MLIRContext *context) const { - return Builder(context).getStringAttr(kEndiannesKeyName); + return Builder(context).getStringAttr(kEndiannessKeyName); } StringAttr getAllocaMemorySpaceIdentifier(MLIRContext *context) const { return Builder(context).getStringAttr(kAllocaKeyName); @@ -645,7 +645,7 @@ TEST(DataLayout, Caching) { // The second call should hit the cache. If it does not, the function in // SingleQueryType will be called and will abort the process. sum += layout.getTypeSize(SingleQueryType::get(&ctx)); - // Make sure the complier doesn't optimize away the query code. + // Make sure the compiler doesn't optimize away the query code. EXPECT_EQ(sum, 2u); // A fresh data layout has a new cache, so the call to it should be dispatched diff --git a/mlir/utils/emacs/mlir-lsp-client.el b/mlir/utils/emacs/mlir-lsp-client.el index 4397a55e7206a..8e8f1f2d0c56f 100644 --- a/mlir/utils/emacs/mlir-lsp-client.el +++ b/mlir/utils/emacs/mlir-lsp-client.el @@ -1,4 +1,4 @@ -;;; mlir-lsp-clinet.el --- LSP clinet for the MLIR. +;;; mlir-lsp-client.el --- LSP client for the MLIR. ;; Copyright (C) 2022 The MLIR Authors. ;; @@ -18,7 +18,7 @@ ;;; Commentary: -;; LSP clinet to use with `mlir-mode' that uses `mlir-lsp-server' or any +;; LSP client to use with `mlir-mode' that uses `mlir-lsp-server' or any ;; user made compatible server. ;;; Code: diff --git a/mlir/utils/generate-test-checks.py b/mlir/utils/generate-test-checks.py index 8faa425beace1..fe8cda67efcc8 100755 --- a/mlir/utils/generate-test-checks.py +++ b/mlir/utils/generate-test-checks.py @@ -258,8 +258,8 @@ def main(): parser.add_argument( "--source", type=str, - help="Print each CHECK chunk before each delimeter line in the source" - "file, respectively. The delimeter lines are identified by " + help="Print each CHECK chunk before each delimiter line in the source" + "file, respectively. The delimiter lines are identified by " "--source_delim_regex.", ) parser.add_argument("--source_delim_regex", type=str, default="func @") diff --git a/mlir/utils/spirv/gen_spirv_dialect.py b/mlir/utils/spirv/gen_spirv_dialect.py index 78c1022428d8a..b57f17d7e5574 100755 --- a/mlir/utils/spirv/gen_spirv_dialect.py +++ b/mlir/utils/spirv/gen_spirv_dialect.py @@ -109,22 +109,22 @@ def split_list_into_sublists(items): Arguments: - items: a list of strings """ - chuncks = [] + chunks = [] chunk = [] chunk_len = 0 for item in items: chunk_len += len(item) + 2 if chunk_len > 80: - chuncks.append(chunk) + chunks.append(chunk) chunk = [] chunk_len = len(item) + 2 chunk.append(item) if len(chunk) != 0: - chuncks.append(chunk) + chunks.append(chunk) - return chuncks + return chunks def uniquify_enum_cases(lst): diff --git a/mlir/utils/tree-sitter-mlir/dialect/arith.js b/mlir/utils/tree-sitter-mlir/dialect/arith.js index f77e2a758edfd..4a542dd2eba90 100644 --- a/mlir/utils/tree-sitter-mlir/dialect/arith.js +++ b/mlir/utils/tree-sitter-mlir/dialect/arith.js @@ -64,11 +64,11 @@ module.exports = { // operation ::= `arith.divf` $lhs `,` $rhs (`fastmath` `` // $fastmath^)? // attr-dict `:` type($result) - // operation ::= `arith.maximumf` $lhs `,` $rhs (`fastmath` `` - // $fastmath^)? + // operation ::= `arith.maximumf` $lhs `,` $rhs (`fastmath` + // `` $fastmath^)? // attr-dict `:` type($result) - // operation ::= `arith.minimumf` $lhs `,` $rhs (`fastmath` `` - // $fastmath^)? + // operation ::= `arith.minimumf` $lhs `,` $rhs (`fastmath` + // `` $fastmath^)? // attr-dict `:` type($result) // operation ::= `arith.mulf` $lhs `,` $rhs (`fastmath` `` // $fastmath^)? @@ -101,7 +101,7 @@ module.exports = { // $predicate `,` $lhs `,` $rhs attr-dict `:` type($lhs) seq(choice('arith.cmpi', 'arith.cmpf'), field('predicate', - choice('eq', 'ne', 'oeq', 'olt', 'ole', 'ogt', + choice('eq', 'ne', 'oeq', 'old', 'ole', 'ogt', 'oge', 'slt', 'sle', 'sgt', 'sge', 'ult', 'ule', 'ugt', 'uge', $.string_literal)), ',', field('lhs', $.value_use), ',', diff --git a/mlir/utils/tree-sitter-mlir/queries/highlights.scm b/mlir/utils/tree-sitter-mlir/queries/highlights.scm index 97aba2b266eca..348b35e91ce3e 100644 --- a/mlir/utils/tree-sitter-mlir/queries/highlights.scm +++ b/mlir/utils/tree-sitter-mlir/queries/highlights.scm @@ -24,7 +24,7 @@ "eq" "ne" "oeq" - "olt" + "old" "ole" "ogt" "oge" @@ -331,7 +331,7 @@ [ ":" "," -] @punctuation.delimeter +] @punctuation.delimiter [ "=" diff --git a/mlir/utils/tree-sitter-mlir/test/corpus/op.txt b/mlir/utils/tree-sitter-mlir/test/corpus/op.txt index d2914e24e65f9..8dafa63a011c1 100644 --- a/mlir/utils/tree-sitter-mlir/test/corpus/op.txt +++ b/mlir/utils/tree-sitter-mlir/test/corpus/op.txt @@ -351,7 +351,7 @@ func.func @gather_like( (float_type)))))))))))))) ================================================================================ -tensor.collapse_shape and tensor.expand_shape without reassocation +tensor.collapse_shape and tensor.expand_shape without reassociation ================================================================================ func.func @tensor_reshape_zero_dim(%arg0 : tensor<1x1xf32>, %arg1 : tensor) -> (tensor, tensor<1x1xf32>) { @@ -444,7 +444,7 @@ func.func @tensor_reshape_zero_dim(%arg0 : tensor<1x1xf32>, %arg1 : tensor) (float_type)))))))))))))) ================================================================================ -tensor.collapse_shape with reassocation +tensor.collapse_shape with reassociation ================================================================================ func.func @legal_collapsing_reshape_dynamic_tensor (%arg0: tensor) -> tensor diff --git a/mlir/utils/tree-sitter-mlir/test/highlight/controlflow.mlir b/mlir/utils/tree-sitter-mlir/test/highlight/controlflow.mlir index d3193838c3a73..4039faad6b623 100644 --- a/mlir/utils/tree-sitter-mlir/test/highlight/controlflow.mlir +++ b/mlir/utils/tree-sitter-mlir/test/highlight/controlflow.mlir @@ -3,7 +3,7 @@ func.func @simple(i64, i1) -> i64 { // ^ function // ^ punctuation.bracket // ^ type.builtin -// ^ punctuation.delimeter +// ^ punctuation.delimiter // ^ type.builtin // ^ punctuation.bracket // ^ operator diff --git a/mlir/utils/tree-sitter-mlir/test/highlight/func.mlir b/mlir/utils/tree-sitter-mlir/test/highlight/func.mlir index cc6f872cf7410..c059c9a67812c 100644 --- a/mlir/utils/tree-sitter-mlir/test/highlight/func.mlir +++ b/mlir/utils/tree-sitter-mlir/test/highlight/func.mlir @@ -3,9 +3,9 @@ func.func @test_addi(%arg0 : i64, %arg1 : i64) -> i64 { // ^ function // ^ punctuation.bracket // ^ variable.parameter -// ^ punctuation.delimeter +// ^ punctuation.delimiter // ^ type.builtin -// ^ punctuation.delimeter +// ^ punctuation.delimiter // ^ variable.parameter // ^ type.builtin // ^ punctuation.bracket diff --git a/mlir/utils/vscode/cpp-grammar.json b/mlir/utils/vscode/cpp-grammar.json index 36063c6a5210b..1f1135b1d5135 100644 --- a/mlir/utils/vscode/cpp-grammar.json +++ b/mlir/utils/vscode/cpp-grammar.json @@ -14,7 +14,7 @@ "name": "punctuation.definition.string.begin.cpp" }, "1": { - "name": "mlir.delimeter.raw.string.cpp" + "name": "mlir.delimiter.raw.string.cpp" } }, "end": "\\)(?i:mlir)\"", @@ -23,7 +23,7 @@ "name": "punctuation.definition.string.end.cpp" }, "1": { - "name": "mlir.delimeter.raw.string.cpp" + "name": "mlir.delimiter.raw.string.cpp" } }, "name": "mlir.raw.string.cpp",