[clang] Fixed a number of typos

[GabrielRavier]

Summary

I went over the output of the following mess of a command:

(ulimit -m 2000000; ulimit -v 2000000; git ls-files -z | parallel --xargs -0 cat | aspell list --mode=none --ignore-case | grep -E '^[A-Za-z][a-z]*$' | sort | uniq -c | sort -n | grep -vE '.{25}' | aspell pipe -W3 | grep : | cut -d' ' -f2 | less)

and proceeded to spend a few days looking at it to find probable typos
and fixed a few hundred of them in all of the llvm project (note, the
ones I found are not anywhere near all of them, but it seems like a
good start).

[junaire]

Hi, I think the main issue is that your patch contains another patch unintentionally, please fix that :)

clang/CMakeLists.txt

513 ↗

(On Diff #448815)

Why delete these lines?

clang/include/clang/Basic/JsonSupport.h

109 ↗

(On Diff #448815)

This is not a typo, right? And I think using llvm::is_contained is more impressive?

clang/include/clang/Sema/Sema.h

4022

Normally we don't clang-format legacy code like this, as it's bad for git blame.

clang/lib/Format/Format.cpp

1724 ↗

(On Diff #448815)

ditto

clang/lib/Headers/opencl-c.h

17856

Not sure if we want to format this...

clang/lib/Sema/SemaDeclAttr.cpp

1880 ↗

(On Diff #448815)

ditto

clang/test/CMakeLists.txt

154 ↗

(On Diff #448815)

Why drop this? I thought it was intentional?

clang/test/Interpreter/code-undo.cpp

3 ↗

(On Diff #448815)

why add this in a typo-fix patch?

clang/test/Interpreter/execute-weak.cpp

4 ↗

(On Diff #448815)

why add this in a typo-fix patch?

clang/test/Interpreter/execute.cpp

5 ↗

(On Diff #448815)

why add this in a typo-fix patch?

clang/test/Interpreter/global-dtor-win.cpp

1 ↗

(On Diff #448815)

Is this in main?

clang/tools/CMakeLists.txt

17 ↗

(On Diff #448815)

Why drop this?

clang/tools/clang-repl/ClangRepl.cpp

31 ↗

(On Diff #448815)

I think this patch contains another patch...

70 ↗

(On Diff #448815)

I think this patch contains another patch...

130 ↗

(On Diff #448815)

I think this patch contains another patch...

clang/unittests/CMakeLists.txt

38 ↗

(On Diff #448815)

Why drop this?

clang/unittests/Interpreter/ExceptionTests/InterpreterExceptionTest.cpp

116 ↗

(On Diff #448815)

I think this patch contains another patch...

[GabrielRavier]

Ooh yeah looks like there's some damage. Shouldn't have done this at 12:30 AM without looking at what that git rebase on the latest pull ended up doing... I'll go fix this asap

[GabrielRavier]

clang/lib/Headers/opencl-c.h

17856

Well, it is what clang-format did, so I don't really know... Is it also legacy code as mentioned above ?

[GabrielRavier]

Fixed it so that it doesn't accidentally revert all the changes made since my original diff

clang/include/clang/Sema/Sema.h

4022

I've undone the clang-formatting on this

[junaire]

clang/include/clang/Sema/Sema.h

4022

Oh, I'm sorry about it I think I missed something here. So basically if you touched the code then format it is a good choice. I thought there was nothing changed here but only formatting, that's something we usually want to avoid.

[GabrielRavier]

Reverted reversion of git clang-format on clang/include/clang/Sema/Sema.h

[GabrielRavier]

clang/include/clang/Sema/Sema.h

4022

I've un-undone the clang-formatting on this

[aaron.ballman]

Thanks for the typo fixes! All the changes look correct to me, so LGTM. Do you need someone to land this on your behalf? If so, what name and email address would you like used for patch attribution?

clang/lib/Headers/opencl-c.h

17856

I think it's fine to reformat this given that the code is being updated. I validated that the only identifiers changed here are parameter names (so there's no chance to break user code).

[GabrielRavier]

Do you need someone to land this on your behalf?

I assume so since landing seems to mean pushing the commit to the repo which I'm pretty sure I don't have the rights to do.

If so, what name and email address would you like used for patch attribution?

Gabriel Ravier, [e-mail]

(By the way, is there any way to make this information part of my Phabricator account so that I don't need to repeat this every time I submit a patch ? The patch I made for clang-tools-extra got in with the right name/email pair just fine without me having to say anything, so I was assuming it was there somewhere...)

[aaron.ballman]

In D130827#3691371, @GabrielRavier wrote:

Do you need someone to land this on your behalf?

I assume so since landing seems to mean pushing the commit to the repo which I'm pretty sure I don't have the rights to do.

Okie dokie! I try to double-check with anyone who I'm not used to seeing commits from.

If so, what name and email address would you like used for patch attribution?

Gabriel Ravier, [e-mail]

(By the way, is there any way to make this information part of my Phabricator account so that I don't need to repeat this every time I submit a patch ? The patch I made for clang-tools-extra got in with the right name/email pair just fine without me having to say anything, so I was assuming it was there somewhere...)

Thank you! I've gone ahead and landed the changes. I don't think there's a way to add the information to Phab in a way that all the code reviewers will notice. Some reviewers will land based on whatever email address you are using for Phabricator, others ask explicitly, some others will go look at prior reviews to see if they can find the info without asking, etc. FWIW, after you have a few patched submitted on your behalf, we'll often ask if you'd like to obtain commit privileges of your own (https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access).

[h-vetinari]

Thanks for chasing these down!

clang/include/clang/Basic/SourceManager.h

1922

Even though that line was touched, "in-memorty" seems to have managed to stay under the radar. One for the next round. ;-)

clang/bindings/python/clang/cindex.py

 # Objective-C's @synchronized statement.
 CursorKind.OBJC_AT_SYNCHRONIZED_STMT = CursorKind(220)
 
-# Objective-C's autorealease pool statement.
+# Objective-C's autorelease pool statement.
 CursorKind.OBJC_AUTORELEASE_POOL_STMT = CursorKind(221)
 
 # Objective-C's for collection statement.

clang/cmake/caches/MultiDistributionExample.cmake

 # This file sets up a CMakeCache for a simple build with multiple distributions.
-# Note that for a real distribution, you likely want to perform a boostrap
+# Note that for a real distribution, you likely want to perform a bootstrap
 # build; see clang/cmake/caches/DistributionExample.cmake and the
 # BuildingADistribution documentation for details. This cache file doesn't
 # demonstrate bootstrapping so it can focus on the configuration details

clang/docs/ClangFormat.rst

     -v, --verbose         be more verbose, ineffective without -i
     -style STYLE          formatting style to apply (LLVM, GNU, Google, Chromium, Microsoft, Mozilla, WebKit)
     -fallback-style FALLBACK_STYLE
-                          The name of the predefined style used as afallback in case clang-format is invoked with-style=file, but can not
+                          The name of the predefined style used as a fallback in case clang-format is invoked with-style=file, but can not
                           find the .clang-formatfile to use.
     -binary BINARY        location of binary to use for clang-format
 

clang/docs/JSONCompilationDatabase.rst

 Supported Systems
 =================
 
-Clang has the ablity to generate compilation database fragments via
+Clang has the ability to generate compilation database fragments via
 the :option:`-MJ argument <clang -MJ\<arg>>`. You can concatenate those
 fragments together between ``[`` and ``]`` to create a compilation database.
 

clang/docs/LanguageExtensions.rst

 Once this builtin is evaluated in a constexpr context, it is erroneous to use
 it in an instantiation which changes its value.
 
-In order to produce the unique name, the current implementation of the bultin
+In order to produce the unique name, the current implementation of the builtin
 uses Itanium mangling even if the host compilation uses a different name
 mangling scheme at runtime. The mangler marks all the lambdas required to name
 the SYCL kernel and emits a stable local ordering of the respective lambdas.

clang/docs/analyzer/user-docs/CrossTranslationUnit.rst

 The compiler invocation is a shell command that could be used to compile the TU-s main source file.
 The mapping from absolute source file paths of a TU to lists of compilation command segments used to
 compile said TU are given in YAML format referred to as `invocation list`, and must be passed as an
-analyer-config argument.
+analyzer-config argument.
 The index, which maps function USR names to source files containing them must also be generated by the
 `clang-extdef-mapping`. Entries in the index must *not* have an `.ast` suffix if the goal
 is to use On-demand analysis, as that extension signals that the entry is to be used as an PCH-dump.

clang/include/clang/AST/DeclCXX.h

   ExplicitSpecifier getExplicitSpecifier() { return ExplicitSpec; }
   const ExplicitSpecifier getExplicitSpecifier() const { return ExplicitSpec; }
 
-  /// Return true if the declartion is already resolved to be explicit.
+  /// Return true if the declaration is already resolved to be explicit.
   bool isExplicit() const { return ExplicitSpec.isExplicit(); }
 
   /// Get the template for which this guide performs deduction.

     return getCanonicalDecl()->getExplicitSpecifierInternal();
   }
 
-  /// Return true if the declartion is already resolved to be explicit.
+  /// Return true if the declaration is already resolved to be explicit.
   bool isExplicit() const { return getExplicitSpecifier().isExplicit(); }
 
   /// Iterates through the member/base initializer list.

     return getCanonicalDecl()->ExplicitSpec;
   }
 
-  /// Return true if the declartion is already resolved to be explicit.
+  /// Return true if the declaration is already resolved to be explicit.
   bool isExplicit() const { return getExplicitSpecifier().isExplicit(); }
   void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; }
 

clang/include/clang/AST/OpenMPClause.h

   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
-  /// \param N Number of allocators asssociated with the clause.
+  /// \param N Number of allocators associated with the clause.
   OMPUsesAllocatorsClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                           SourceLocation EndLoc, unsigned N)
       : OMPClause(llvm::omp::OMPC_uses_allocators, StartLoc, EndLoc),
         LParenLoc(LParenLoc), NumOfAllocators(N) {}
 
   /// Build an empty clause.
-  /// \param N Number of allocators asssociated with the clause.
+  /// \param N Number of allocators associated with the clause.
   ///
   explicit OMPUsesAllocatorsClause(unsigned N)
       : OMPClause(llvm::omp::OMPC_uses_allocators, SourceLocation(),

   /// \param LParenLoc Location of '('.
   /// \param ColonLoc Location of ':'.
   /// \param EndLoc Ending location of the clause.
-  /// \param N Number of locators asssociated with the clause.
+  /// \param N Number of locators associated with the clause.
   OMPAffinityClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                     SourceLocation ColonLoc, SourceLocation EndLoc, unsigned N)
       : OMPVarListClause<OMPAffinityClause>(llvm::omp::OMPC_affinity, StartLoc,
                                             LParenLoc, EndLoc, N) {}
 
   /// Build an empty clause.
-  /// \param N Number of locators asssociated with the clause.
+  /// \param N Number of locators associated with the clause.
   ///
   explicit OMPAffinityClause(unsigned N)
       : OMPVarListClause<OMPAffinityClause>(llvm::omp::OMPC_affinity,

clang/include/clang/Analysis/ConstructionContext.h

 /// of being immediately copied by an elidable copy/move constructor.
 /// For example, T t = T(123); includes a temporary T(123) that is immediately
 /// copied to variable t. In such cases the elidable copy can (but not
-/// necessarily should) be omitted ("elided") accodring to the rules of the
+/// necessarily should) be omitted ("elided") according to the rules of the
 /// language; the constructor would then construct variable t directly.
 /// This construction context contains information of the elidable constructor
 /// and its respective construction context.

clang/include/clang/Analysis/FlowSensitive/DataflowValues.h

   /// getBlockDataMap - Retrieves the internal map between CFGBlocks and
   /// dataflow values.  If the dataflow analysis operates in the forward
   /// direction, the values correspond to the dataflow values at the start
-  /// of the block.  Otherwise, for a backward analysis, the values correpsond
+  /// of the block.  Otherwise, for a backward analysis, the values correspond
   /// to the dataflow values at the end of the block.
   BlockDataMapTy& getBlockDataMap() { return BlockDataMap; }
   const BlockDataMapTy& getBlockDataMap() const { return BlockDataMap; }

clang/include/clang/Basic/AttrDocs.td

 applied to a definition. If ``allow_templates`` is given, template function
 definitions are considered as specializations of existing or assumed template
 declarations with the same name. The template parameters for the base functions
-are used to instantiate the specialization. If ``bind_to_declartion`` is given,
+are used to instantiate the specialization. If ``bind_to_declaration`` is given,
 apply the same variant rules to function declarations. This allows the user to
 override declarations with only a function declaration.
   }];

 
   does_not_exist x; // error: use of unresolved 'using_if_exists'
 
-The C++ spelling of the attribte (`[[clang::using_if_exists]]`) is also
+The C++ spelling of the attribute (`[[clang::using_if_exists]]`) is also
 supported as a clang extension, since ISO C++ doesn't support attributes in this
 position. If the entity referred to by the using-declaration is found by name
 lookup, the attribute has no effect. This attribute is useful for libraries

   command-line arguments.
 - ``used`` only zeros call-used registers used in the function. By ``used``, we
   mean a register whose contents have been set or referenced in the function.
-- ``used-gpr`` only zeros call-used GPR registers used in the funciton.
+- ``used-gpr`` only zeros call-used GPR registers used in the function.
 - ``used-arg`` only zeros call-used registers used to pass arguments to the
   function.
 - ``used-gpr-arg`` only zeros call-used GPR registers used to pass arguments to

 - ``all-gpr-arg`` zeros all call-used GPR registers used to pass arguments to
   the function.
 
-The default for the attribute is contolled by the ``-fzero-call-used-regs``
+The default for the attribute is controlled by the ``-fzero-call-used-regs``
 flag.
 
 .. _Return-Oriented Programming: https://en.wikipedia.org/wiki/Return-oriented_programming

clang/include/clang/Basic/BuiltinsVE.def

 #   define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) BUILTIN(ID, TYPE, ATTRS)
 #endif
 
-// The format of this database is decribed in clang/Basic/Builtins.def.
+// The format of this database is described in clang/Basic/Builtins.def.
 
 BUILTIN(__builtin_ve_vl_pack_f32p, "ULifC*fC*", "n")
 BUILTIN(__builtin_ve_vl_pack_f32a, "ULifC*", "n")

clang/include/clang/Basic/SourceManager.h

   }
 };
 
-/// SourceManager and necessary depdencies (e.g. VFS, FileManager) for a single
-/// in-memorty file.
+/// SourceManager and necessary dependencies (e.g. VFS, FileManager) for a
+/// single in-memorty file.
 class SourceManagerForFile {
 public:
-  /// Creates SourceManager and necessary depdencies (e.g. VFS, FileManager).
+  /// Creates SourceManager and necessary dependencies (e.g. VFS, FileManager).
   /// The main file in the SourceManager will be \p FileName with \p Content.
   SourceManagerForFile(StringRef FileName, StringRef Content);
 

clang/include/clang/ExtractAPI/Serialization/SymbolGraphSerializer.h

   /// Serialize an Objective-C container record.
   void serializeObjCContainerRecord(const ObjCContainerRecord &Record);
 
-  /// Serialize a macro defintion record.
+  /// Serialize a macro definition record.
   void serializeMacroDefinitionRecord(const MacroDefinitionRecord &Record);
 
   /// Serialize a typedef record.

clang/include/clang/Lex/DependencyDirectivesScanner.h

 
 /// Represents a directive that's lexed as part of the dependency directives
 /// scanning. It's used to track various preprocessor directives that could
-/// potentially have an effect on the depedencies.
+/// potentially have an effect on the dependencies.
 struct Directive {
   ArrayRef<Token> Tokens;
 

clang/include/clang/Sema/DeclSpec.h

     /// DeclSpec for the function with the qualifier related info.
     DeclSpec *MethodQualifiers;
 
-    /// AtttibuteFactory for the MethodQualifiers.
+    /// AttributeFactory for the MethodQualifiers.
     AttributeFactory *QualAttrFactory;
 
     union {

clang/include/clang/Sema/Sema.h

   /// Computing a type for the function argument may require running
   /// overloading, so we postpone its computation until it is actually needed.
   ///
-  /// Clients should be very careful when using this funciton, as it stores a
+  /// Clients should be very careful when using this function, as it stores a
   /// function_ref, clients should make sure all calls to get() with the same
   /// location happen while function_ref is alive.
   ///

 
   bool ResolveAndFixSingleFunctionTemplateSpecialization(
                       ExprResult &SrcExpr,
-                      bool DoFunctionPointerConverion = false,
+                      bool DoFunctionPointerConversion = false,
                       bool Complain = false,
                       SourceRange OpRangeForComplaining = SourceRange(),
                       QualType DestTypeForComplaining = QualType(),

clang/include/clang/Serialization/ASTReader.h

     /// The AST file was written by a different version of Clang.
     VersionMismatch,
 
-    /// The AST file was writtten with a different language/target
+    /// The AST file was written with a different language/target
     /// configuration.
     ConfigurationMismatch,
 

clang/include/clang/Serialization/SourceLocationEncoding.h

 // the size of typical serialized files. Storing them efficiently is important.
 //
 // We use integers optimized by VBR-encoding, because:
-//  - when abbrevations cannot be used, VBR6 encoding is our only choice
+//  - when abbreviations cannot be used, VBR6 encoding is our only choice
 //  - in the worst case a SourceLocation can be ~any 32-bit number, but in
 //    practice they are highly predictable
 //

clang/include/clang/StaticAnalyzer/Core/CheckerManager.h

 
   /// Constructs a CheckerManager without requiring an AST. No checker
   /// registration will take place. Only useful when one needs to print the
-  /// help flags through CheckerRegistryData, and the AST is unavalaible.
+  /// help flags through CheckerRegistryData, and the AST is unavailable.
   CheckerManager(AnalyzerOptions &AOptions, const LangOptions &LangOpts,
                  DiagnosticsEngine &Diags, ArrayRef<std::string> plugins);
 

clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h

   /// returned, which is better than nothing but does not represent
   /// the actual behavior of the program. The Idx parameter is used if we
   /// construct an array of objects. In that case it points to the index
-  /// of the continous memory region.
+  /// of the continuous memory region.
   /// E.g.:
   /// For `int arr[4]` this index can be 0,1,2,3.
   /// For `int arr2[3][3]` this index can be 0,1,...,7,8.
-  /// A multi-dimensional array is also a continous memory location in a
+  /// A multi-dimensional array is also a continuous memory location in a
   /// row major order, so for arr[0][0] Idx is 0 and for arr[2][2] Idx is 8.
   SVal computeObjectUnderConstruction(const Expr *E, ProgramStateRef State,
                                       const LocationContext *LCtx,

clang/include/clang/Tooling/Core/Replacement.h

   // applied.
   Replacements getCanonicalReplacements() const;
 
-  // If `R` and all existing replacements are order-indepedent, then merge it
+  // If `R` and all existing replacements are order-independent, then merge it
   // with `Replaces` and returns the merged replacements; otherwise, returns an
   // error.
   llvm::Expected<Replacements>

clang/include/clang/Tooling/Syntax/Tree.h

 //   - tree nodes correspond to language grammar constructs.
 //
 // The tree is initially built from an AST. Each node of a newly built tree
-// covers a continous subrange of expanded tokens (i.e. tokens after
+// covers a continuous subrange of expanded tokens (i.e. tokens after
 // preprocessing), the specific tokens coverered are stored in the leaf nodes of
 // a tree. A post-order traversal of a tree will visit leaf nodes in an order
 // corresponding the original order of expanded tokens.

clang/lib/AST/ASTContext.cpp

 }
 
 /// getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a
-/// type, in characters, before alignment adustments. This method does
+/// type, in characters, before alignment adjustments. This method does
 /// not work on incomplete types.
 CharUnits ASTContext::getTypeUnadjustedAlignInChars(QualType T) const {
   return toCharUnitsFromBits(getTypeUnadjustedAlign(T));

clang/lib/Analysis/CFG.cpp

 }
 
 /// createBlock - Used to lazily create blocks that are connected
-///  to the current (global) succcessor.
+///  to the current (global) successor.
 CFGBlock *CFGBuilder::createBlock(bool add_successor) {
   CFGBlock *B = cfg->createBlock();
   if (add_successor && Succ)

clang/lib/CodeGen/CGBuiltin.cpp

          "unexpected BPF builtin");
 
   // A sequence number, injected into IR builtin functions, to
-  // prevent CSE given the only difference of the funciton
+  // prevent CSE given the only difference of the function
   // may just be the debuginfo metadata.
   static uint32_t BuiltinSeqNum;
 

     auto Pair = EmitAtomicCompareExchange(
         LV, RValue::get(OldVal), RValue::get(Op2), E->getExprLoc(),
         llvm::AtomicOrdering::Monotonic, llvm::AtomicOrdering::Monotonic, true);
-    // Unlike c11's atomic_compare_exchange, accroding to
+    // Unlike c11's atomic_compare_exchange, according to
     // https://www.ibm.com/docs/en/xl-c-and-cpp-aix/16.1?topic=functions-compare-swap-compare-swaplp
     // > In either case, the contents of the memory location specified by addr
     // > are copied into the memory location specified by old_val_addr.

clang/lib/CodeGen/CGCall.cpp

 
   switch (RetAI.getKind()) {
   case ABIArgInfo::InAlloca:
-    // Aggregrates get evaluated directly into the destination.  Sometimes we
+    // Aggregates get evaluated directly into the destination.  Sometimes we
     // need to return the sret value in a register, though.
     assert(hasAggregateEvaluationKind(RetTy));
     if (RetAI.getInAllocaSRet()) {

       break;
     }
     case TEK_Aggregate:
-      // Do nothing; aggregrates get evaluated directly into the destination.
+      // Do nothing; aggregates get evaluated directly into the destination.
       break;
     case TEK_Scalar: {
       LValueBaseInfo BaseInfo;

clang/lib/CodeGen/CGOpenMPRuntime.cpp

     CodeGenFunction &CGF, QualType &KmpDependInfoTy,
     const OMPTaskDataTy::DependData &Data) {
   assert(Data.DepKind == OMPC_DEPEND_depobj &&
-         "Expected depobj dependecy kind.");
+         "Expected depobj dependency kind.");
   SmallVector<llvm::Value *, 4> Sizes;
   SmallVector<LValue, 4> SizeLVals;
   ASTContext &C = CGF.getContext();

                                          const OMPTaskDataTy::DependData &Data,
                                          Address DependenciesArray) {
   assert(Data.DepKind == OMPC_DEPEND_depobj &&
-         "Expected depobj dependecy kind.");
+         "Expected depobj dependency kind.");
   llvm::Value *ElSize = CGF.getTypeSize(KmpDependInfoTy);
   {
     OMPIteratorGeneratorScope IteratorScope(

   llvm::Value *NumOfDepobjElements = llvm::ConstantInt::get(CGF.IntPtrTy, 0);
   llvm::Value *NumOfRegularWithIterators =
       llvm::ConstantInt::get(CGF.IntPtrTy, 0);
-  // Calculate number of depobj dependecies and regular deps with the iterators.
+  // Calculate number of depobj dependencies and regular deps with the
+  // iterators.
   for (const OMPTaskDataTy::DependData &D : Dependencies) {
     if (D.DepKind == OMPC_DEPEND_depobj) {
       SmallVector<llvm::Value *, 4> Sizes =

     emitDependData(CGF, KmpDependInfoTy, &Pos, Dependencies[I],
                    DependenciesArray);
   }
-  // Copy regular dependecies with iterators.
+  // Copy regular dependencies with iterators.
   LValue PosLVal = CGF.MakeAddrLValue(
       CGF.CreateMemTemp(C.getSizeType(), "dep.counter.addr"), C.getSizeType());
   CGF.EmitStoreOfScalar(llvm::ConstantInt::get(CGF.SizeTy, Pos), PosLVal);

clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp

 
 namespace {
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
-/// Enum for accesseing the reserved_2 field of the ident_t struct.
+/// Enum for accessing the reserved_2 field of the ident_t struct.
 enum ModeFlagsTy : unsigned {
   /// Bit set to 1 when in SPMD mode.
   KMP_IDENT_SPMD_MODE = 0x01,

clang/lib/CrossTU/CrossTranslationUnit.cpp

       return llvm::make_error<IndexError>(index_error_code::missing_definition);
     }
 
-    // Search in the index for the filename where the definition of FuncitonName
+    // Search in the index for the filename where the definition of FunctionName
     // resides.
     if (llvm::Expected<ASTUnit *> FoundForFile =
             getASTUnitForFile(NameFileMap[FunctionName], DisplayCTUProgress)) {

clang/lib/Driver/ToolChains/Clang.cpp

     }
   } else if (IsOpenMPDevice) {
     // When compiling for the OpenMP device we want protected visibility by
-    // default. This prevents the device from accidenally preempting code on the
-    // host, makes the system more robust, and improves performance.
+    // default. This prevents the device from accidentally preempting code on
+    // the host, makes the system more robust, and improves performance.
     CmdArgs.push_back("-fvisibility");
     CmdArgs.push_back("protected");
   }

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

   if (Avail.isDefault())
     return None;
 
-  Object Availbility;
-  serializeObject(Availbility, "introducedVersion",
+  Object Availability;
+  serializeObject(Availability, "introducedVersion",
                   serializeSemanticVersion(Avail.Introduced));
-  serializeObject(Availbility, "deprecatedVersion",
+  serializeObject(Availability, "deprecatedVersion",
                   serializeSemanticVersion(Avail.Deprecated));
-  serializeObject(Availbility, "obsoletedVersion",
+  serializeObject(Availability, "obsoletedVersion",
                   serializeSemanticVersion(Avail.Obsoleted));
   if (Avail.isUnavailable())
-    Availbility["isUnconditionallyUnavailable"] = true;
+    Availability["isUnconditionallyUnavailable"] = true;
   if (Avail.isUnconditionallyDeprecated())
-    Availbility["isUnconditionallyDeprecated"] = true;
+    Availability["isUnconditionallyDeprecated"] = true;
 
-  return Availbility;
+  return Availability;
 }
 
 /// Get the language name string for interface language references.

clang/lib/Format/UnwrappedLineParser.h

   //
   // NextTok specifies the next token. A null pointer NextTok is supported, and
   // signifies either the absence of a next token, or that the next token
-  // shouldn't be taken into accunt for the analysis.
+  // shouldn't be taken into account for the analysis.
   void distributeComments(const SmallVectorImpl<FormatToken *> &Comments,
                           const FormatToken *NextTok);
 

clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp

                                 std::string &Result,
                                 ArrayRef<ObjCIvarDecl *> Ivars,
                                 ObjCInterfaceDecl *CDecl) {
-  // FIXME. visibilty of offset symbols may have to be set; for Darwin
+  // FIXME. visibility of offset symbols may have to be set; for Darwin
   // this is what happens:
   /**
    if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||

clang/lib/Headers/arm_acle.h

 /*
  * 9.4 Saturating intrinsics
  *
- * FIXME: Change guard to their corrosponding __ARM_FEATURE flag when Q flag
+ * FIXME: Change guard to their corresponding __ARM_FEATURE flag when Q flag
  * intrinsics are implemented and the flag is enabled.
  */
 /* 9.4.1 Width-specified saturation intrinsics */

clang/lib/Headers/opencl-c.h

     uint skip_block_partition_type, uint skip_motion_vector_mask,
     ulong motion_vectors, uchar bidirectional_weight, uchar skip_sad_adjustment,
     intel_sub_group_avc_sic_payload_t payload);
-intel_sub_group_avc_sic_payload_t __ovld
-intel_sub_group_avc_sic_configure_ipe(
-    uchar luma_intra_partition_mask, uchar intra_neighbour_availabilty,
+intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_configure_ipe(
+    uchar luma_intra_partition_mask, uchar intra_neighbour_availability,
     uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel,
     uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels,
     uchar intra_sad_adjustment, intel_sub_group_avc_sic_payload_t payload);
-intel_sub_group_avc_sic_payload_t __ovld
-intel_sub_group_avc_sic_configure_ipe(
-    uchar luma_intra_partition_mask, uchar intra_neighbour_availabilty,
+intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_configure_ipe(
+    uchar luma_intra_partition_mask, uchar intra_neighbour_availability,
     uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel,
     uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels,
     ushort left_edge_chroma_pixels, ushort upper_left_corner_chroma_pixel,

clang/lib/Lex/Lexer.cpp

     // recover after having emitted a diagnostic.
     if (!LooseMatch)
       return llvm::None;
-    // We do not offer missspelled character names suggestions here
+    // We do not offer misspelled character names suggestions here
     // as the set of what would be a valid suggestion depends on context,
     // and we should not make invalid suggestions.
   }

clang/lib/Parse/ParseStmt.cpp

 ///
 StmtResult Parser::ParseCompoundStatement(bool isStmtExpr,
                                           unsigned ScopeFlags) {
-  assert(Tok.is(tok::l_brace) && "Not a compount stmt!");
+  assert(Tok.is(tok::l_brace) && "Not a compound stmt!");
 
   // Enter a scope to hold everything within the compound stmt.  Compound
   // statements can always hold declarations.

clang/lib/Sema/SemaCodeComplete.cpp

 enum class OverloadCompare { BothViable, Dominates, Dominated };
 // Will Candidate ever be called on the object, when overloaded with Incumbent?
 // Returns Dominates if Candidate is always called, Dominated if Incumbent is
-// always called, BothViable if either may be called dependending on arguments.
+// always called, BothViable if either may be called depending on arguments.
 // Precondition: must actually be overloads!
 static OverloadCompare compareOverloads(const CXXMethodDecl &Candidate,
                                         const CXXMethodDecl &Incumbent,

clang/lib/Sema/SemaDecl.cpp

       continue;
     } else if (isa<OMPDeclareVariantAttr>(NewAttribute)) {
       // We allow to add OMP[Begin]DeclareVariantAttr to be added to
-      // declarations after defintions.
+      // declarations after definitions.
       ++I;
       continue;
     }

 /// (from the current #pragma code-seg value).
 ///
 /// \param FD Function being declared.
-/// \param IsDefinition Whether it is a definition or just a declarartion.
+/// \param IsDefinition Whether it is a definition or just a declaration.
 /// \returns A CodeSegAttr or SectionAttr to apply to the function or
 ///          nullptr if no attribute should be added.
 Attr *Sema::getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD,

   // Because typo correction is expensive, only do it if the implicit
   // function declaration is going to be treated as an error.
   //
-  // Perform the corection before issuing the main diagnostic, as some consumers
-  // use typo-correction callbacks to enhance the main diagnostic.
+  // Perform the correction before issuing the main diagnostic, as some
+  // consumers use typo-correction callbacks to enhance the main diagnostic.
   if (S && !ExternCPrev &&
       (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error)) {
     DeclFilterCCC<FunctionDecl> CCC{};

     else
       Diag(PrevDecl->getLocation(), diag::warn_redefine_extname_not_applied)
           << /*Variable*/(isa<FunctionDecl>(PrevDecl) ? 0 : 1) << PrevDecl;
-  // Otherwise, add a label atttibute to ExtnameUndeclaredIdentifiers.
+    // Otherwise, add a label attribute to ExtnameUndeclaredIdentifiers.
   } else
     (void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr));
 }

clang/lib/Sema/SemaDeclObjC.cpp

 
 /// DiagnoseDuplicateIvars -
 /// Check for duplicate ivars in the entire class at the start of
-/// \@implementation. This becomes necesssary because class extension can
+/// \@implementation. This becomes necessary because class extension can
 /// add ivars to a class in random order which will not be known until
 /// class's \@implementation is seen.
 void Sema::DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID,

clang/lib/Sema/SemaOverload.cpp

 /// Returns false if resolveAddressOfSingleOverloadCandidate fails.
 /// Otherwise, returns true. This may emit diagnostics and return true.
 bool Sema::resolveAndFixAddressOfSingleOverloadCandidate(
-    ExprResult &SrcExpr, bool DoFunctionPointerConverion) {
+    ExprResult &SrcExpr, bool DoFunctionPointerConversion) {
   Expr *E = SrcExpr.get();
   assert(E->getType() == Context.OverloadTy && "SrcExpr must be an overload");
 

   DiagnoseUseOfDecl(Found, E->getExprLoc());
   CheckAddressOfMemberAccess(E, DAP);
   Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found);
-  if (DoFunctionPointerConverion && Fixed->getType()->isFunctionType())
+  if (DoFunctionPointerConversion && Fixed->getType()->isFunctionType())
     SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
   else
     SrcExpr = Fixed;

 // expression, regardless of whether or not it succeeded.  Always
 // returns true if 'complain' is set.
 bool Sema::ResolveAndFixSingleFunctionTemplateSpecialization(
-                      ExprResult &SrcExpr, bool doFunctionPointerConverion,
-                      bool complain, SourceRange OpRangeForComplaining,
-                                           QualType DestTypeForComplaining,
-                                            unsigned DiagIDForComplaining) {
+    ExprResult &SrcExpr, bool doFunctionPointerConversion, bool complain,
+    SourceRange OpRangeForComplaining, QualType DestTypeForComplaining,
+    unsigned DiagIDForComplaining) {
   assert(SrcExpr.get()->getType() == Context.OverloadTy);
 
   OverloadExpr::FindResult ovl = OverloadExpr::find(SrcExpr.get());

         FixOverloadedFunctionReference(SrcExpr.get(), found, fn);
 
     // If desired, do function-to-pointer decay.
-    if (doFunctionPointerConverion) {
+    if (doFunctionPointerConversion) {
       SingleFunctionExpression =
         DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get());
       if (SingleFunctionExpression.isInvalid()) {

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

 
 // This trait is responsible for storing the index of the element that is to be
 // constructed in the next iteration. As a result a CXXConstructExpr is only
-// stored if it is array type. Also the index is the index of the continous
+// stored if it is array type. Also the index is the index of the continuous
 // memory region, which is important for multi-dimensional arrays. E.g:: int
 // arr[2][2]; assume arr[1][1] will be the next element under construction, so
 // the index is 3.

clang/lib/Tooling/AllTUsExecution.cpp

           [&](std::string Path) {
             Log("[" + std::to_string(Count()) + "/" + TotalNumStr +
                 "] Processing file " + Path);
-            // Each thread gets an indepent copy of a VFS to allow different
+            // Each thread gets an independent copy of a VFS to allow different
             // concurrent working directories.
             IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS =
                 llvm::vfs::createPhysicalFileSystem();

clang/lib/Tooling/Core/Replacement.cpp

     assert(R.getLength() == 0);
     // `I` is also an insertion, `R` and `I` conflict.
     if (I->getLength() == 0) {
-      // Check if two insertions are order-indepedent: if inserting them in
+      // Check if two insertions are order-independent: if inserting them in
       // either order produces the same text, they are order-independent.
       if ((R.getReplacementText() + I->getReplacementText()).str() !=
           (I->getReplacementText() + R.getReplacementText()).str())

     Replaces.insert(R);
   } else {
     // `I` overlaps with `R`. We need to check `R` against all overlapping
-    // replacements to see if they are order-indepedent. If they are, merge `R`
+    // replacements to see if they are order-independent. If they are, merge `R`
     // with them and replace them with the merged replacements.
     auto MergeBegin = I;
     auto MergeEnd = std::next(I);

clang/lib/Tooling/Syntax/Tokens.cpp

                SpelledTokens[NextSpelled].location() <= KnownEnd)
           ++NextSpelled;
         FlushMapping(); // Emits [NextSpelled, KnownEnd]
-        // Now the loop contitues and will emit (KnownEnd, Target).
+        // Now the loop continues and will emit (KnownEnd, Target).
       } else {
         ++NextSpelled;
       }

clang/test/CodeGen/vectorcall.c

 // Vectorcall in both architectures allows passing of an HVA as long as there is room,
 // even if it is not one of the first 6 arguments.  First pass puts p4 into a
 // register on both.  p9 ends up in a register in x86 only.  Second pass puts p1
-// in a register, does NOT put p7 in a register (since theres no room), then puts
+// in a register, does NOT put p7 in a register (since there's no room), then puts
 // p8 in a register.
 void __vectorcall HVAAnywhere(struct HFA2 p1, int p2, int p3, float p4, int p5, int p6, struct HFA4 p7, struct HFA2 p8, float p9){}
 // X32: define dso_local x86_vectorcallcc void @"\01HVAAnywhere@@88"(%struct.HFA2 inreg %p1.coerce, i32 inreg noundef %p2, i32 inreg noundef %p3, float inreg noundef %p4, i32 noundef %p5, i32 noundef %p6, %struct.HFA4* noundef %p7, %struct.HFA2 inreg %p8.coerce, float inreg noundef %p9)

clang/test/CodeGenCXX/target-features-error.cpp

       //expected-error@+1{{'~CtorAndDTor' requires target feature 'avx512f'}}
       c2.~CtorAndDTor();
     }
-    // FIXME: These need to be given a line number, however theres no good way
+    // FIXME: These need to be given a line number, however there's no good way
     // to get to the SourceLocation of anything by the time we're doing CodeGen
     // cleanups.
     //expected-error@*{{'~CtorAndDTor' requires target feature 'avx512f'}}

clang/test/SemaCXX/builtin-align-cxx.cpp

 static_assert(__builtin_align_down(&align32array[7], 4) == &align32array[4], "");
 static_assert(__builtin_align_down(&align32array[8], 4) == &align32array[8], "");
 
-// Achiving the same thing using casts to uintptr_t is not allowed:
+// Achieving the same thing using casts to uintptr_t is not allowed:
 static_assert((char *)((__UINTPTR_TYPE__)&align32array[7] & ~3) == &align32array[4], ""); // expected-error{{not an integral constant expression}}
 
 static_assert(__builtin_align_down(&align32array[1], 4) == &align32array[0], "");

clang/test/SemaOpenCL/usm-address-spaces-conversions.cl

  * spaces: global_device and global_host that are a subset of __global address
  * space. As ISO/IEC TR 18037 5.1.3 declares - it's possible to implicitly
  * convert a subset address space to a superset address space, while conversion
- * in a reversed direction could be achived only with an explicit cast */
+ * in a reversed direction could be achieved only with an explicit cast */
 
 #ifdef GENERIC
 #define AS_COMP __generic

clang/tools/clang-shlib/CMakeLists.txt

   endif()
   if (BUILD_SHARED_LIBS)
     # If we are building static libraries, then we don't need to add the static
-    # libraries as a depedency, because we are already linking against the
+    # libraries as a dependency, because we are already linking against the
     # individual object files.
     list(APPEND _DEPS $<TARGET_PROPERTY:${lib},INTERFACE_LINK_LIBRARIES>)
   endif()

clang/tools/include-mapping/gen_std.py

 #===------------------------------------------------------------------------===#
 
 """gen_std.py is a tool to generate a lookup table (from qualified names to
-include headers) for C/C++ Standard Library symbols by parsing archieved HTML
+include headers) for C/C++ Standard Library symbols by parsing archived HTML
 files from cppreference.
 
 The generated files are located in clang/include/Tooling/Inclusions.

clang/tools/scan-build-py/lib/libear/ear.c

   pthread_mutex_unlock(&mutex);
 }
 
-/* update environment assure that chilren processes will copy the desired
+/* update environment assure that children processes will copy the desired
  * behaviour */
 
 static int bear_capture_env_t(bear_env_t *env) {

     free((void *)*it);
   }
   free((void *)in);
-}
+}
 

clang/unittests/AST/StructuralEquivalenceTest.cpp

 }
 
 // This test is disabled for now.
-// FIXME Whether this is equivalent is dependendant on the target.
+// FIXME Whether this is equivalent is dependent on the target.
 TEST_F(StructuralEquivalenceTest, DISABLED_CharVsSignedChar) {
   auto Decls = makeNamedDecls("char foo;", "signed char foo;", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(Decls));

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

                 CallFunctionF));
   }
 
-  // Depedent calls don't match.
+  // Dependent calls don't match.
   EXPECT_TRUE(
       notMatches("void f(int); template <typename T> void g(T t) { f(t); }",
                  CallFunctionF));

clang/unittests/Tooling/SourceCodeTest.cpp

   Visitor.runOverAnnotated(R"cpp(
       #define ATTR __attribute__((deprecated("message")))
       $r[[ATTR
-      // Commment.
+      // Comment.
       int x;]])cpp");
 }
 

   Visit(R"cpp(
       #define ATTR __attribute__((deprecated("message")))
       $r[[ATTR
-      // Commment.
+      // Comment.
       int x;]])cpp");
 }
 

clang/utils/TableGen/NeonEmitter.cpp

   /// Return the index that parameter PIndex will sit at
   /// in a generated function call. This is often just PIndex,
   /// but may not be as things such as multiple-vector operands
-  /// and sret parameters need to be taken into accont.
+  /// and sret parameters need to be taken into account.
   unsigned getGeneratedParamIdx(unsigned PIndex) {
     unsigned Idx = 0;
     if (getReturnType().getNumVectors() > 1)

clang/utils/analyzer/SATest.py

     dock_parser.add_argument("--clang-dir", action="store", default="",
                              help="Path to find/install LLVM installation.")
     dock_parser.add_argument("rest", nargs=argparse.REMAINDER, default=[],
-                             help="Additionall args that will be forwarded "
+                             help="Additional args that will be forwarded "
                              "to the docker's entrypoint.")
     dock_parser.set_defaults(func=docker)
 

clang/utils/analyzer/exploded-graph-rewriter.py

             # Also on Windows macros __FILE__ produces specific delimiters `\`
             # and a directory or file may starts with the letter `l`.
             # Find all `\l` (like `,\l`, `}\l`, `[\l`) except `\\l`,
-            # because the literal as a rule containes multiple `\` before `\l`.
+            # because the literal as a rule contains multiple `\` before `\l`.
             node_label = re.sub(r'(?<!\\)\\l', '', node_label)
             logging.debug(node_label)
             json_node = json.loads(node_label)

clang/www/analyzer/installation.html

 
 <ul>
 <li><b>scan-build</b>: <tt>scan-build</tt> is the high-level command line utility for running the analyzer</li>
-<li><b>scan-view</b>: <tt>scan-view</tt> a companion comannd line
+<li><b>scan-view</b>: <tt>scan-view</tt> a companion command line
 utility to <tt>scan-build</tt>, <tt>scan-view</tt> is used to view
 analysis results generated by <tt>scan-build</tt>.  There is an option
 that one can pass to <tt>scan-build</tt> to cause <tt>scan-view</tt> to