[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).

[GabrielRavier]

Nvm I'm an idiot I thought this would update https://reviews.llvm.org/D130827

clang/bindings/python/clang/cindex.py

 CursorKind.OBJC_AT_FINALLY_STMT = CursorKind(218)
 
 # Objective-C's @throw statement.
 CursorKind.OBJC_AT_THROW_STMT = CursorKind(219)
 
 # 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.
 CursorKind.OBJC_FOR_COLLECTION_STMT = CursorKind(222)
 
 # C++'s catch statement.
 CursorKind.CXX_CATCH_STMT = CursorKind(223)
 

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
 # specific to multiple distributions instead.
 
 # Build an optimized toolchain for an example set of targets.
 set(CMAKE_BUILD_TYPE Release CACHE STRING "")
 set(LLVM_TARGETS_TO_BUILD

clang/docs/ClangFormat.rst

optional arguments:
     -i                    apply edits to files instead of displaying a diff
     -p NUM                strip the smallest prefix containing P slashes
     -regex PATTERN        custom pattern selecting file paths to reformat (case sensitive, overrides -iregex)
     -iregex PATTERN       custom pattern selecting file paths to reformat (case insensitive, overridden by -regex)
     -sort-includes        let clang-format sort include blocks
     -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
 
 To reformat all the lines in the latest Mercurial/:program:`hg` commit, do:
 
 .. code-block:: console
 
   hg diff -U0 --color=never | clang-format-diff.py -i -p1

clang/docs/JSONCompilationDatabase.rst

-  Build systems are inherently sequential in the build graph, for
    independently of the build still need the generated source code to
    exist, running tools multiple times over unchanging source does not
    require serialization of the runs according to the build dependency
    graph.
 
 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.
 
 Currently `CMake <https://cmake.org>`_ (since 2.8.5) supports generation
 of compilation databases for Unix Makefile builds (Ninja builds in the
 works) with the option ``CMAKE_EXPORT_COMPILE_COMMANDS``.
 
 For projects on Linux, there is an alternative to intercept compiler

clang/docs/LanguageExtensions.rst

 for lookup purposes, such as in the SYCL Integration Header.
 
 The value of this builtin is computed entirely at compile time, so it can be
 used in constant expressions. This value encodes lambda functions based on a
 stable numbering order in which they appear in their local declaration contexts.
 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.
 The resulting pattern is demanglable.  When non-lambda types are passed to the
 builtin, the mangler emits their usual pattern without any special treatment.
 
 **Syntax**:
 

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

 
 On-demand analysis
 __________________
 The analysis produces the necessary AST structure of external TUs during analysis. This requires the
 exact compiler invocations for each TU, which can be generated by hand, or by tools driving the analyzer.
 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.
 The mapping of external definitions implicitly uses a
 :doc:`compilation database <../../JSONCompilationDatabase>` to determine the compilation flags used.
 The analysis invocation must be provided with the directory which contains the mapping
 files, and the `invocation list` which is used to determine compiler flags.
 

clang/include/clang/AST/DeclCXX.h

Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
          TypeSourceInfo *TInfo, SourceLocation EndLocation,
          CXXConstructorDecl *Ctor = nullptr);
 
   static CXXDeductionGuideDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   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.
   TemplateDecl *getDeducedTemplate() const {
     return getDeclName().getCXXDeductionGuideTemplate();
   }
 
   /// Get the constructor from which this deduction guide was generated, if
public:
 
   ExplicitSpecifier getExplicitSpecifier() {
     return getCanonicalDecl()->getExplicitSpecifierInternal();
   }
   const ExplicitSpecifier getExplicitSpecifier() const {
     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.
   using init_iterator = CXXCtorInitializer **;
 
   /// Iterates through the member/base initializer list.
   using init_const_iterator = CXXCtorInitializer *const *;
 
public:
   ExplicitSpecifier getExplicitSpecifier() {
     return getCanonicalDecl()->ExplicitSpec;
   }
 
   const ExplicitSpecifier getExplicitSpecifier() const {
     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; }
 
   /// Returns the type that this conversion function is converting to.
   QualType getConversionType() const {
     return getType()->castAs<FunctionType>()->getReturnType();
   }
 

clang/include/clang/AST/OpenMPClause.h

private:
   /// Total number of allocators in the clause.
   unsigned NumOfAllocators = 0;
 
   /// Build clause.
   ///
   /// \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(),
                   SourceLocation()),
         NumOfAllocators(N) {}
 
   unsigned numTrailingObjects(OverloadToken<Expr *>) const {
     return NumOfAllocators * static_cast<int>(ExprOffsets::Total);
class OMPAffinityClause final
   SourceLocation ColonLoc;
 
   /// Build clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \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,
                                             SourceLocation(), SourceLocation(),
                                             SourceLocation(), N) {}
 
   /// Sets the affinity modifier for the clause, if any.
   void setModifier(Expr *E) {

clang/include/clang/Analysis/ConstructionContext.h

static bool classof(const ConstructionContext *CC) {
     return CC->getKind() == SimpleTemporaryObjectKind;
   }
 };
 
 /// Represents a temporary object that is constructed for the sole purpose
 /// 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.
 class ElidedTemporaryObjectConstructionContext
     : public TemporaryObjectConstructionContext {
   const CXXConstructExpr *ElidedCE;
   const ConstructionContext *ElidedCC;
 

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

public:
   ///  dataflow values.  Usually used by a dataflow solver to compute
   ///  values for blocks.
   EdgeDataMapTy& getEdgeDataMap() { return EdgeDataMap; }
   const EdgeDataMapTy& getEdgeDataMap() const { return EdgeDataMap; }
 
   /// 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; }
 
   /// getStmtDataMap - Retrieves the internal map between Stmts and
   /// dataflow values.
   StmtDataMapTy& getStmtDataMap() {
     if (!StmtDataMap) StmtDataMap = new StmtDataMapTy();

clang/include/clang/Basic/AttrDocs.td

 applied to a definition. If ``disable_implicit_base`` is given, we will not
 introduce an implicit base function for a variant if no base function was
 found. The variant is still generated but will never be called, due to the
 absence of a base function and consequently calls to a base function.
 The allow extensions change when the ``begin declare variant`` effect is
 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.
   }];
 }
 
 def LeafDocs : Documentation {
   let Category = DocCatVariable;
   let Content = [{

 .. code-block:: c++
 
   namespace empty_namespace {};
   __attribute__((using_if_exists))
   using empty_namespace::does_not_exist; // no error!
 
   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
 (primarily, libc++) that wish to redeclare a set of declarations in another
 namespace, when the availability of those declarations is difficult or
 impossible to detect at compile time with the preprocessor.
   }];
 }

 
 The `choice` parameters gives the programmer flexibility to choose the subset
 of the call-used registers to be zeroed:
 
 - ``skip`` doesn't zero any call-used registers. This choice overrides any
   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
   the function.
 - ``all`` zeros all call-used registers.
 - ``all-gpr`` zeros all call-used GPR registers.
 - ``all-arg`` zeros all call-used registers used to pass arguments to the
   function.
 - ``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
   }];
 }
 
 def NumThreadsDocs : Documentation {
   let Category = DocCatFunction;

clang/include/clang/Basic/BuiltinsVE.def

 // this file must define the BUILTIN macro to make use of this information.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(BUILTIN) && !defined(TARGET_BUILTIN)
 #   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")
 
 BUILTIN(__builtin_ve_vl_extract_vm512u, "V256bV512b", "n")
 BUILTIN(__builtin_ve_vl_extract_vm512l, "V256bV512b", "n")
 BUILTIN(__builtin_ve_vl_insert_vm512u, "V512bV512bV256b", "n")
 BUILTIN(__builtin_ve_vl_insert_vm512l, "V512bV512bV256b", "n")
 
 // Use generated BUILTIN definitions
 #include "clang/Basic/BuiltinsVEVL.gen.def"
 
 #undef BUILTIN
 #undef TARGET_BUILTIN

clang/include/clang/Basic/SourceManager.h

 public:
   explicit BeforeThanCompare(SourceManager &SM) : SM(SM) {}
 
   bool operator()(SourceRange LHS, SourceRange RHS) const {
     return SM.isBeforeInTranslationUnit(LHS.getBegin(), RHS.getBegin());
   }
 };
 
-/// 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);
 
   SourceManager &get() {
     assert(SourceMgr);
     return *SourceMgr;
   }
 

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

private:
   void serializeEnumRecord(const EnumRecord &Record);
 
   /// Serialize a struct record.
   void serializeStructRecord(const StructRecord &Record);
 
   /// 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.
   void serializeTypedefRecord(const TypedefRecord &Record);
 
   /// Push a component to the current path components stack.
   ///
   /// \param Component The component to push onto the path components stack.

clang/include/clang/Lex/DependencyDirectivesScanner.h

enum DirectiveKind : uint8_t {
   cxx_import_decl,
   cxx_export_module_decl,
   cxx_export_import_decl,
   pp_eof,
 };
 
 /// 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;
 
   /// The kind of token.
   DirectiveKind Kind = pp_none;
 
   Directive() = default;
   Directive(DirectiveKind K, ArrayRef<Token> Tokens)

clang/include/clang/Sema/DeclSpec.h

struct FunctionTypeInfo {
     /// Params - This is a pointer to a new[]'d array of ParamInfo objects that
     /// describe the parameters specified by this function declarator.  null if
     /// there are no parameters specified.
     ParamInfo *Params;
 
     /// DeclSpec for the function with the qualifier related info.
     DeclSpec *MethodQualifiers;
 
-    /// AtttibuteFactory for the MethodQualifiers.
+    /// AttributeFactory for the MethodQualifiers.
     AttributeFactory *QualAttrFactory;
 
     union {
       /// Pointer to a new[]'d array of TypeAndRange objects that
       /// contain the types in the function's dynamic exception specification
       /// and their locations, if there is one.
       TypeAndRange *Exceptions;
 

clang/include/clang/Sema/Sema.h

public:
   void enterReturn(Sema &S, SourceLocation Tok);
   void enterVariableInit(SourceLocation Tok, Decl *D);
   /// Handles e.g. BaseType{ .D = Tok...
   void enterDesignatedInitializer(SourceLocation Tok, QualType BaseType,
                                   const Designation &D);
   /// 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.
   ///
   /// The callback should also emit signature help as a side-effect, but only
   /// if the completion point has been reached.
   void enterFunctionArgument(SourceLocation Tok,
                              llvm::function_ref<QualType()> ComputeType);
 
bool resolveAndFixAddressOfSingleOverloadCandidate(
       ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);
 
   FunctionDecl *
   ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
                                               bool Complain = false,
                                               DeclAccessPair *Found = nullptr);
 
   bool ResolveAndFixSingleFunctionTemplateSpecialization(
-                      ExprResult &SrcExpr,
-                      bool DoFunctionPointerConverion = false,
-                      bool Complain = false,
-                      SourceRange OpRangeForComplaining = SourceRange(),
-                      QualType DestTypeForComplaining = QualType(),
-                      unsigned DiagIDForComplaining = 0);
+      ExprResult &SrcExpr, bool DoFunctionPointerConversion = false,
+      bool Complain = false, SourceRange OpRangeForComplaining = SourceRange(),
 
-
   Expr *FixOverloadedFunctionReference(Expr *E,
                                        DeclAccessPair FoundDecl,
                                        FunctionDecl *Fn);
   ExprResult FixOverloadedFunctionReference(ExprResult,
                                             DeclAccessPair FoundDecl,
                                             FunctionDecl *Fn);
 
   void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,

clang/include/clang/Serialization/ASTReader.h

enum ASTReadResult {
 
     /// The AST file is out-of-date relative to its input files,
     /// and needs to be regenerated.
     OutOfDate,
 
     /// 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,
 
     /// The AST file has errors.
     HadErrors
   };
 
   using ModuleFile = serialization::ModuleFile;

clang/include/clang/Serialization/SourceLocationEncoding.h

 //===--- SourceLocationEncoding.h - Small serialized locations --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Source locations are stored pervasively in the AST, making up a third of
 // 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
 //
 // We encode the integer so that likely values encode as small numbers that
 // turn into few VBR chunks:
 //  - the invalid sentinel location is a very common value: it encodes as 0
 //  - the "macro or not" bit is stored at the bottom of the integer
 //    (rather than at the top, as in memory), so macro locations can have

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

public:
   /// checkers. Useful for unit testing, unless the checker infrastructure
   /// itself is tested.
   CheckerManager(ASTContext &Context, AnalyzerOptions &AOptions,
                  const Preprocessor &PP)
       : CheckerManager(Context, AOptions, PP, {}, {}) {}
 
   /// 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);
 
   ~CheckerManager();
 
   void setCurrentCheckerName(CheckerNameRef name) { CurrentCheckerName = name; }
   CheckerNameRef getCurrentCheckerName() const { return CurrentCheckerName; }
 

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

public:
 
   /// Find location of the object that is being constructed by a given
   /// constructor. This should ideally always succeed but due to not being
   /// fully implemented it sometimes indicates that it failed via its
   /// out-parameter CallOpts; in such cases a fake temporary region is
   /// 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,
                                       const ConstructionContext *CC,
                                       EvalCallOptions &CallOpts,
                                       unsigned Idx = 0);
 
   /// Update the program state with all the path-sensitive information

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

private:
   Replacement getReplacementInChangedCode(const Replacement &R) const;
 
   // Returns a set of replacements that is equivalent to the current
   // replacements by merging all adjacent replacements. Two sets of replacements
   // are considered equivalent if they have the same effect when they are
   // 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>
   mergeIfOrderIndependent(const Replacement &R) const;
 
   ReplacementsImpl Replaces;
 };
 

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

 //===- Tree.h - structure of the syntax tree ------------------*- C++ -*-=====//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 // Defines the basic structure of the syntax tree. There are two kinds of nodes:
 //   - leaf nodes correspond to tokens,
 //   - 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.
 //
 // This is still work in progress and highly experimental, we leave room for
 // ourselves to completely change the design and/or implementation.
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_TOOLING_SYNTAX_TREE_H

clang/lib/AST/ASTContext.cpp

 CharUnits ASTContext::getTypeAlignInChars(QualType T) const {
   return toCharUnitsFromBits(getTypeAlign(T));
 }
 CharUnits ASTContext::getTypeAlignInChars(const Type *T) const {
   return toCharUnitsFromBits(getTypeAlign(T));
 }
 
 /// 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));
 }
 CharUnits ASTContext::getTypeUnadjustedAlignInChars(const Type *T) const {
   return toCharUnitsFromBits(getTypeUnadjustedAlign(T));
 }
 

clang/lib/Analysis/CFG.cpp

std::unique_ptr<CFG> CFGBuilder::buildCFG(const Decl *D, Stmt *Statement) {
   if (BuildOpts.AddRichCXXConstructors)
     assert(ConstructionContextMap.empty() &&
            "Not all construction contexts were cleaned up!");
 
   return std::move(cfg);
 }
 
 /// 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)
     addSuccessor(B, Succ);
   return B;
 }
 
 /// createNoReturnBlock - Used to create a block is a 'noreturn' point in the

clang/lib/CodeGen/CGBuiltin.cpp

Value *CodeGenFunction::EmitBPFBuiltinExpr(unsigned BuiltinID,
                                            const CallExpr *E) {
   assert((BuiltinID == BPF::BI__builtin_preserve_field_info ||
           BuiltinID == BPF::BI__builtin_btf_type_id ||
           BuiltinID == BPF::BI__builtin_preserve_type_info ||
           BuiltinID == BPF::BI__builtin_preserve_enum_value) &&
          "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;
 
   switch (BuiltinID) {
   default:
     llvm_unreachable("Unexpected BPF builtin");
   case BPF::BI__builtin_preserve_field_info: {
     const Expr *Arg = E->getArg(0);
case PPC::BI__builtin_ppc_compare_and_swaplp: {
     Address OldValAddr = EmitPointerWithAlignment(E->getArg(1));
     Value *OldVal = Builder.CreateLoad(OldValAddr);
     QualType AtomicTy = E->getArg(0)->getType()->getPointeeType();
     LValue LV = MakeAddrLValue(Addr, AtomicTy);
     Value *Op2 = EmitScalarExpr(E->getArg(2));
     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.
     // But it hasn't specified storing to OldValAddr is atomic or not and
     // which order to use. Now following XL's codegen, treat it as a normal
     // store.
     Value *LoadedVal = Pair.first.getScalarVal();
     Builder.CreateStore(LoadedVal, OldValAddr);

clang/lib/CodeGen/CGCall.cpp

void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
 
   llvm::DebugLoc RetDbgLoc;
   llvm::Value *RV = nullptr;
   QualType RetTy = FI.getReturnType();
   const ABIArgInfo &RetAI = FI.getReturnInfo();
 
   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()) {
       llvm::Function::arg_iterator EI = CurFn->arg_end();
       --EI;
       llvm::Value *ArgStruct = &*EI;
       llvm::Value *SRet = Builder.CreateStructGEP(
           FI.getArgStruct(), ArgStruct, RetAI.getInAllocaFieldIndex());
case ABIArgInfo::Indirect: {
     case TEK_Complex: {
       ComplexPairTy RT =
         EmitLoadOfComplex(MakeAddrLValue(ReturnValue, RetTy), EndLoc);
       EmitStoreOfComplex(RT, MakeNaturalAlignAddrLValue(&*AI, RetTy),
                          /*isInit*/ true);
       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;
       TBAAAccessInfo TBAAInfo;
       CharUnits Alignment =
           CGM.getNaturalTypeAlignment(RetTy, &BaseInfo, &TBAAInfo);
       Address ArgAddr(&*AI, ConvertType(RetTy), Alignment);
       LValue ArgVal =

clang/lib/CodeGen/CGOpenMPRuntime.cpp

for (const Expr *E : Data.DepExprs) {
     }
   }
 }
 
 SmallVector<llvm::Value *, 4> CGOpenMPRuntime::emitDepobjElementsSizes(
     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();
   {
     OMPIteratorGeneratorScope IteratorScope(
         CGF, cast_or_null<OMPIteratorExpr>(
                  Data.IteratorExpr ? Data.IteratorExpr->IgnoreParenImpCasts()
                                    : nullptr));

 }
 
 void CGOpenMPRuntime::emitDepobjElements(CodeGenFunction &CGF,
                                          QualType &KmpDependInfoTy,
                                          LValue PosLVal,
                                          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(
         CGF, cast_or_null<OMPIteratorExpr>(
                  Data.IteratorExpr ? Data.IteratorExpr->IgnoreParenImpCasts()
                                    : nullptr));
     for (unsigned I = 0, End = Data.DepExprs.size(); I < End; ++I) {
       const Expr *E = Data.DepExprs[I];
unsigned NumDependencies = std::accumulate(
       });
   QualType FlagsTy;
   getDependTypes(C, KmpDependInfoTy, FlagsTy);
   bool HasDepobjDeps = false;
   bool HasRegularWithIterators = false;
   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 =
           emitDepobjElementsSizes(CGF, KmpDependInfoTy, D);
       for (llvm::Value *Size : Sizes) {
         NumOfDepobjElements =
             CGF.Builder.CreateNUWAdd(NumOfDepobjElements, Size);
       }
std::pair<llvm::Value *, Address> CGOpenMPRuntime::emitDependClause(
   unsigned Pos = 0;
   for (unsigned I = 0, End = Dependencies.size(); I < End; ++I) {
     if (Dependencies[I].DepKind == OMPC_DEPEND_depobj ||
         Dependencies[I].IteratorExpr)
       continue;
     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);
   for (unsigned I = 0, End = Dependencies.size(); I < End; ++I) {
     if (Dependencies[I].DepKind == OMPC_DEPEND_depobj ||
         !Dependencies[I].IteratorExpr)
       continue;
     emitDependData(CGF, KmpDependInfoTy, &PosLVal, Dependencies[I],

clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp

else
     emitNonSPMDKernel(D, ParentName, OutlinedFn, OutlinedFnID, IsOffloadEntry,
                       CodeGen);
 
   setPropertyExecutionMode(CGM, OutlinedFn->getName(), Mode);
 }
 
 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,
   /// Bit set to 1 when a simplified runtime is used.
   KMP_IDENT_SIMPLE_RT_MODE = 0x02,
   LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/KMP_IDENT_SIMPLE_RT_MODE)
 };
 

clang/lib/CrossTU/CrossTranslationUnit.cpp

if (llvm::Error IndexLoadError =
       return std::move(IndexLoadError);
 
     // Check if there is an entry in the index for the function.
     if (!NameFileMap.count(FunctionName)) {
       ++NumNotInOtherTU;
       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)) {
 
       // Update the cache.
       NameASTUnitMap[FunctionName] = *FoundForFile;
       return *FoundForFile;
 

clang/lib/Driver/ToolChains/Clang.cpp

if (A->getOption().matches(options::OPT_fvisibility_EQ)) {
       assert(A->getOption().matches(options::OPT_fvisibility_ms_compat));
       CmdArgs.push_back("-fvisibility");
       CmdArgs.push_back("hidden");
       CmdArgs.push_back("-ftype-visibility");
       CmdArgs.push_back("default");
     }
   } 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");
   }
 
   if (!RawTriple.isPS4())
     if (const Arg *A =
             Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass,
                             options::OPT_fno_visibility_from_dllstorageclass)) {

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

 /// i.e. \c __attribute__((unavailable)) and \c __attribute__((deprecated)).
 ///
 /// \returns \c None if the symbol has default availability attributes, or
 /// an \c Object containing the formatted availability information.
 Optional<Object> serializeAvailability(const AvailabilityInfo &Avail) {
   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.
 StringRef getLanguageName(Language Lang) {
   switch (Lang) {
   case Language::C:
     return "c";
   case Language::ObjC:

clang/lib/Format/UnwrappedLineParser.h

private:
   // should be added as comments before the next token.
   //
   // Comments specifies the sequence of comment tokens to analyze. They get
   // either pushed to the current line or added to the comments before the next
   // token.
   //
   // 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);
 
   // Adds the comment preceding the next token to unwrapped lines.
   void flushComments(bool NewlineBeforeNext);
   void pushToken(FormatToken *Tok);
   void calculateBraceTypes(bool ExpectClassBody = false);
 

clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp

static void Write__extendedMethodTypes_initializer(RewriteModernObjC &RewriteObj,
   }
 }
 
 static void Write_IvarOffsetVar(RewriteModernObjC &RewriteObj,
                                 ASTContext *Context,
                                 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 ||
        Ivar->getAccessControl() == ObjCIvarDecl::Package ||
        Class->getVisibility() == HiddenVisibility)
      Visibility should be: HiddenVisibility;
    else
      Visibility should be: DefaultVisibility;

clang/lib/Headers/arm_acle.h

 __smulwt(int32_t __a, int32_t __b) {
   return __builtin_arm_smulwt(__a, __b);
 }
 #endif
 
 /*
  * 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 */
 #if __ARM_FEATURE_SAT
 #define __ssat(x, y) __builtin_arm_ssat(x, y)
 #define __usat(x, y) __builtin_arm_usat(x, y)
 #endif
 

clang/lib/Headers/opencl-c.h

 intel_sub_group_avc_sic_payload_t __ovld
 intel_sub_group_avc_sic_initialize(
     ushort2 src_coord);
 intel_sub_group_avc_sic_payload_t __ovld
 intel_sub_group_avc_sic_configure_skc(
     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,
     ushort upper_edge_chroma_pixels, uchar intra_sad_adjustment,
     intel_sub_group_avc_sic_payload_t payload);
 uint __ovld
 intel_sub_group_avc_sic_get_motion_vector_mask(
     uint skip_block_partition_type, uchar direction);

clang/lib/Lex/Lexer.cpp

if (!isLexingRawMode()) {
                    makeCharRange(*this, StartName, CurPtr - CharSize),
                    LooseMatch->Name);
       }
     }
     // When finding a match using Unicode loose matching rules
     // 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.
   }
 
   if (Diagnose && PP && !LooseMatch)
     Diag(BufferPtr, PP->getLangOpts().CPlusPlus2b
                         ? diag::warn_cxx2b_delimited_escape_sequence
                         : diag::ext_delimited_escape_sequence)

clang/lib/Parse/ParseStmt.cpp

 /// [GNU]   label-declaration
 /// [GNU]   label-declarations label-declaration
 ///
 /// [GNU] label-declaration:
 /// [GNU]   '__label__' identifier-list ';'
 ///
 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.
   ParseScope CompoundScope(this, ScopeFlags);
 
   // Parse the statements in the body.
   return ParseCompoundStatementBody(isStmtExpr);
 }

clang/lib/Sema/SemaCodeComplete.cpp

 static void setInBaseClass(ResultBuilder::Result &R) {
   R.Priority += CCD_InBaseClass;
   R.InBaseClass = true;
 }
 
 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,
                                         const Qualifiers &ObjectQuals,
                                         ExprValueKind ObjectKind) {
   // Base/derived shadowing is handled elsewhere.
   if (Candidate.getDeclContext() != Incumbent.getDeclContext())
     return OverloadCompare::BothViable;

clang/lib/Sema/SemaDecl.cpp

if (isa<C11NoReturnAttr>(NewAttribute)) {
       // Don't warn about applying selectany to implicitly inline variables.
       // Older compilers and language modes would require the use of selectany
       // to make such variables inline, and it would have no effect if we
       // honored it.
       ++I;
       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;
     }
 
     S.Diag(NewAttribute->getLocation(),
            diag::warn_attribute_precede_definition);
     S.Diag(Def->getLocation(), diag::note_previous_definition);
     NewAttributes.erase(NewAttributes.begin() + I);

 }
 
 /// Returns an implicit CodeSegAttr if a __declspec(code_seg) is found on a
 /// containing class. Otherwise it will return implicit SectionAttr if the
 /// function is a definition and there is an active value on CodeSegStack
 /// (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,
                                                        bool IsDefinition) {
   if (Attr *A = getImplicitCodeSegAttrFromClass(*this, FD))
     return A;
   if (!FD->hasAttr<SectionAttr>() && IsDefinition &&
       CodeSegStack.CurrentValue)
else if (getLangOpts().C99)
     diag_id = diag::ext_implicit_function_decl_c99;
   else
     diag_id = diag::warn_implicit_function_decl;
 
   TypoCorrection Corrected;
   // 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{};
     Corrected = CorrectTypo(DeclarationNameInfo(&II, Loc), LookupOrdinaryName,
                             S, nullptr, CCC, CTK_NonError);
   }
 
   Diag(Loc, diag_id) << &II;
void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name,
   // 2) has external linkage
   // already exists, add a label attribute to it.
   if (PrevDecl && (isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) {
     if (isDeclExternC(PrevDecl))
       PrevDecl->addAttr(Attr);
     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));
 }
 
 void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
                              SourceLocation PragmaLoc,
                              SourceLocation NameLoc) {
   Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);

clang/lib/Sema/SemaDeclObjC.cpp

for (unsigned i = 0, e = Methods.size(); i < e; i++) {
     HelperSelectorsForTypoCorrection(SelectedMethods,
                                      Sel.getAsString(), Methods[i]);
   }
   return (SelectedMethods.size() == 1) ? SelectedMethods[0] : nullptr;
 }
 
 /// 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,
                                   ObjCInterfaceDecl *SID) {
   for (auto *Ivar : ID->ivars()) {
     if (Ivar->isInvalidDecl())
       continue;
     if (IdentifierInfo *II = Ivar->getIdentifier()) {

clang/lib/Sema/SemaOverload.cpp

 /// Given an overloaded function, tries to turn it into a non-overloaded
 /// function reference using resolveAddressOfSingleOverloadCandidate. This
 /// will perform access checks, diagnose the use of the resultant decl, and, if
 /// requested, potentially perform a function-to-pointer decay.
 ///
 /// 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");
 
   DeclAccessPair DAP;
   FunctionDecl *Found = resolveAddressOfSingleOverloadCandidate(E, DAP);
   if (!Found || Found->isCPUDispatchMultiVersion() ||
       Found->isCPUSpecificMultiVersion())
     return false;
 
   // Emitting multiple diagnostics for a function that is both inaccessible and
   // unavailable is consistent with our behavior elsewhere. So, always check
   // for both.
   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;
   return true;
 }
 
 /// Given an expression that refers to an overloaded function, try to
 /// resolve that overloaded function expression down to a single function.

 // because it identifies a single function template specialization.
 //
 // Last three arguments should only be supplied if Complain = true
 //
 // Return true if it was logically possible to so resolve the
 // 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,
   assert(SrcExpr.get()->getType() == Context.OverloadTy);
 
   OverloadExpr::FindResult ovl = OverloadExpr::find(SrcExpr.get());
 
   DeclAccessPair found;
   ExprResult SingleFunctionExpression;
   if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
                            ovl.Expression, /*complain*/ false, &found)) {
if (!ovl.HasFormOfMemberPointer &&
       return true;
     }
 
     // Fix the expression to refer to 'fn'.
     SingleFunctionExpression =
         FixOverloadedFunctionReference(SrcExpr.get(), found, fn);
 
     // If desired, do function-to-pointer decay.
-    if (doFunctionPointerConverion) {
+    if (doFunctionPointerConversion) {
       SingleFunctionExpression =
         DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get());
       if (SingleFunctionExpression.isInvalid()) {
         SrcExpr = ExprError();
         return true;
       }
     }
   }

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

 
 typedef llvm::ImmutableMap<ConstructedObjectKey, SVal>
     ObjectsUnderConstructionMap;
 REGISTER_TRAIT_WITH_PROGRAMSTATE(ObjectsUnderConstruction,
                                  ObjectsUnderConstructionMap)
 
 // 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.
 typedef llvm::ImmutableMap<
     std::pair<const CXXConstructExpr *, const LocationContext *>, unsigned>
     IndexOfElementToConstructMap;
 REGISTER_TRAIT_WITH_PROGRAMSTATE(IndexOfElementToConstruct,
                                  IndexOfElementToConstructMap)

clang/lib/Tooling/AllTUsExecution.cpp

llvm::Error AllTUsToolExecutor::execute(
 
   {
     llvm::ThreadPool Pool(llvm::hardware_concurrency(ThreadCount));
     for (std::string File : Files) {
       Pool.async(
           [&](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();
             ClangTool Tool(Compilations, {Path},
                            std::make_shared<PCHContainerOperations>(), FS);
             Tool.appendArgumentsAdjuster(Action.second);
             Tool.appendArgumentsAdjuster(getDefaultArgumentsAdjusters());
             for (const auto &FileAndContent : OverlayFiles)

clang/lib/Tooling/Core/Replacement.cpp

llvm::Error Replacements::add(const Replacement &R) {
   // entries that start at the end can still be conflicting if R is an
   // insertion.
   auto I = Replaces.lower_bound(AtEnd);
   // If `I` starts at the same offset as `R`, `R` must be an insertion.
   if (I != Replaces.end() && R.getOffset() == I->getOffset()) {
     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())
         return llvm::make_error<ReplacementError>(
             replacement_error::insert_conflict, R, *I);
       // If insertions are order-independent, we can merge them.
       Replacement NewR(
           R.getFilePath(), R.getOffset(), 0,
if (!Overlap(R, *I)) {
     //   - If `R` is an insertion, `I` must not be an insertion since it would
     //   have come after `AtEnd`.
     //   - If `R` is not an insertion, `I` must be an insertion; otherwise, `R`
     //   and `I` would have overlapped.
     // In either case, we can safely insert `R`.
     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);
     while (I != Replaces.begin()) {
       --I;
       // If `I` doesn't overlap with `R`, don't merge it.
       if (!Overlap(R, *I))
         break;

clang/lib/Tooling/Syntax/Tokens.cpp

while (NextSpelled < SpelledTokens.size() &&
       SourceLocation KnownEnd =
           CollectedExpansions.lookup(SpelledTokens[NextSpelled].location());
       if (KnownEnd.isValid()) {
         FlushMapping(); // Emits [Start, NextSpelled)
         while (NextSpelled < SpelledTokens.size() &&
                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;
       }
     }
     FlushMapping();
   }
 
   // Consumes the NextExpanded token and others that are part of the same run.

clang/test/CodeGen/vectorcall.c

 // x86 should pass p2, p6 and p7 in registers, then p1 in the second pass.
 struct HFA2 __vectorcall AddParticles(struct HFA2 p1, float p2, struct HFA4 p3, int p4, struct HFA2 p5, float p6, float p7, int p8){ return p1;}
 // X32: define dso_local x86_vectorcallcc %struct.HFA2 @"\01AddParticles@@84"(%struct.HFA2 inreg %p1.coerce, float inreg noundef %p2, %struct.HFA4* inreg noundef %p3, i32 inreg noundef %p4, %struct.HFA2* noundef %p5, float inreg noundef %p6, float inreg noundef %p7, i32 noundef %p8)
 // X64: define dso_local x86_vectorcallcc %struct.HFA2 @"\01AddParticles@@104"(%struct.HFA2 inreg %p1.coerce, float noundef %p2, %struct.HFA4* noundef %p3, i32 noundef %p4, %struct.HFA2 inreg %p5.coerce, float noundef %p6, float noundef %p7, i32 noundef %p8)
 
 // 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)
 // X64: define dso_local x86_vectorcallcc void @"\01HVAAnywhere@@112"(%struct.HFA2 inreg %p1.coerce, i32 noundef %p2, i32 noundef %p3, float noundef %p4, i32 noundef %p5, i32 noundef %p6, %struct.HFA4* noundef %p7, %struct.HFA2 inreg %p8.coerce, float noundef %p9)
 
 #ifndef __x86_64__
 // This covers the three ways XMM values can be passed on 32-bit x86:
 // - directly in XMM register (xmm5)

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

void usage() {
     //expected-error@+1{{'CtorAndDTor' requires target feature 'avx512f'}}
     CtorAndDTor c;
     {
       //expected-error@+1{{'CtorAndDTor' requires target feature 'avx512f'}}
       CtorAndDTor c2;
       //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'}}
     //expected-error@*{{'~CtorAndDTor' requires target feature 'avx512f'}}
   }
 }
 #endif

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

 static_assert(__builtin_align_down(&align32array[2], 4) == &align32array[0], "");
 static_assert(__builtin_align_down(&align32array[3], 4) == &align32array[0], "");
 static_assert(__builtin_align_down(&align32array[4], 4) == &align32array[4], "");
 static_assert(__builtin_align_down(&align32array[5], 4) == &align32array[4], "");
 static_assert(__builtin_align_down(&align32array[6], 4) == &align32array[4], "");
 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], "");
 static_assert(__builtin_align_down(&align32array[1], 64) == &align32array[0], ""); // expected-error{{not an integral constant expression}}
 // expected-note@-1{{cannot constant evaluate the result of adjusting alignment to 64}}
 
 // Add some checks for __builtin_is_aligned:
 static_assert(__builtin_is_aligned(&align32array[0], 32), "");

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

 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0
 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DGENERIC
 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DCONSTANT
 // RUN: %clang_cc1 %s -ffake-address-space-map -verify -pedantic -fsyntax-only -cl-std=CL2.0 -DLOCAL
 
 /* USM (unified shared memory) extension for OpenCLC 2.0 adds two new address
  * 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
 #else
 #define AS_COMP __global
 #endif // GENERIC
 
 #ifdef CONSTANT

clang/tools/clang-shlib/CMakeLists.txt

if(XCODE)
     # Xcode doesn't support object libraries, so we have to trick it into
     # linking the static libraries instead.
     list(APPEND _DEPS "-force_load" ${lib})
   else()
     list(APPEND _OBJECTS $<TARGET_OBJECTS:obj.${lib}>)
   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 libraries are redundant since we are linking all the individual
   # object files into libclang-cpp.so, so filter them out from _DEPS.
   # This avoids problems with LLVM global data when building with
   # BUILD_SHARED_LIBS=ON

clang/tools/include-mapping/gen_std.py

 #!/usr/bin/env python
 #===- gen_std.py -  ------------------------------------------*- python -*--===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===------------------------------------------------------------------------===#
 
 """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.
 
 Caveats and FIXMEs:
   - only symbols directly in "std" namespace are added, we should also add std's
     subnamespace symbols (e.g. chrono).
   - symbols with multiple variants or defined in multiple headers aren't added,

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

if (fclose(fd)) {
     perror("bear: fclose");
     pthread_mutex_unlock(&mutex);
     exit(EXIT_FAILURE);
   }
   free((void *)cwd);
   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) {
   int status = 1;
   for (size_t it = 0; it < ENV_SIZE; ++it) {
     char const *const env_value = getenv(env_names[it]);
     char const *const env_copy = (env_value) ? strdup(env_value) : env_value;
     (*env)[it] = env_copy;
static size_t bear_strings_length(char const *const *const in) {
   return result;
 }
 
 static void bear_strings_release(char const **in) {
   for (char const *const *it = in; (it) && (*it); ++it) {
     free((void *)*it);
   }
   free((void *)in);
-}
+}
 

clang/unittests/AST/StructuralEquivalenceTest.cpp

 }
 
 TEST_F(StructuralEquivalenceTest, Char) {
   auto Decls = makeNamedDecls("char foo;", "char foo;", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(Decls));
 }
 
 // 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));
 }
 
 TEST_F(StructuralEquivalenceTest, ForwardRecordDecl) {
   auto Decls = makeNamedDecls("struct foo;", "struct foo;", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(Decls));

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

if (!GetParam().hasDelayedTemplateParsing()) {
     // Dependent contexts, but a non-dependent call.
     EXPECT_TRUE(
         matches("void f(); template <int N> void g() { f(); }", CallFunctionF));
     EXPECT_TRUE(
         matches("void f(); template <int N> struct S { void g() { f(); } };",
                 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));
   EXPECT_TRUE(
       notMatches("void f(int);"
                  "template <typename T> struct S { void g(T t) { f(t); } };",
                  CallFunctionF));
 

clang/unittests/Tooling/SourceCodeTest.cpp

Visitor.runOverAnnotated(R"cpp(
       #define ATTR __attribute__((deprecated("message")))
       $r[[ATTR
       int x;]])cpp");
 
   // Includes attributes and comments together.
   Visitor.runOverAnnotated(R"cpp(
       #define ATTR __attribute__((deprecated("message")))
       $r[[ATTR
-      // Commment.
+      // Comment.
       int x;]])cpp");
 }
 
 TEST(SourceCodeTest, getAssociatedRangeClasses) {
   struct RecordDeclsVisitor : AnnotatedCodeVisitor<RecordDeclsVisitor> {
     bool VisitRecordDecl(RecordDecl *Decl) { return VisitDeclHelper(Decl); }
   };
   RecordDeclsVisitor Visitor;
Visit(R"cpp(
       #define ATTR __attribute__((deprecated("message")))
       $r[[ATTR
       int x;]])cpp");
 
   // Includes attributes and comments together.
   Visit(R"cpp(
       #define ATTR __attribute__((deprecated("message")))
       $r[[ATTR
-      // Commment.
+      // Comment.
       int x;]])cpp");
 }
 
 TEST(SourceCodeTest, getAssociatedRangeInvalidForPartialExpansions) {
   struct FailingVarDeclsVisitor : TestVisitor<FailingVarDeclsVisitor> {
     FailingVarDeclsVisitor() {}
     bool VisitVarDecl(VarDecl *Decl) {
       EXPECT_TRUE(getAssociatedRange(*Decl, *Context).isInvalid());

clang/utils/TableGen/NeonEmitter.cpp

public:
   Type getPolymorphicKeyType() const { return Types[PolymorphicKeyType]; }
 
   /// Return true if the prototype has a scalar argument.
   bool protoHasScalar() const;
 
   /// 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)
       // Multiple vectors are passed as sret.
       ++Idx;
 
     for (unsigned I = 0; I < PIndex; ++I)
       Idx += std::max(1U, getParamType(I).getNumVectors());

clang/utils/analyzer/SATest.py

dock_parser.add_argument("--llvm-project-dir", action="store",
                              help="Path to LLVM source code. Defaults "
                              "to the repo where this script is located. ")
     dock_parser.add_argument("--build-dir", action="store", default="",
                              help="Path to a directory where docker should "
                              "build LLVM code.")
     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)
 
     # benchmark subcommand
     bench_parser = subparsers.add_parser(
         "benchmark",
         help="Run benchmarks by building a set of projects multiple times.")
 

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

def add_raw_line(self, raw_line):
                                         .replace('\\<', '\\\\<') \
                                         .replace('\\>', '\\\\>') \
                                         .rstrip(',')
             # Handle `\l` separately because a string literal can be in code
             # like "string\\literal" with the `\l` inside.
             # 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)
             self.nodes[node_id].construct(node_id, json_node)
             return
         logging.debug('Skipping.')
 
 

clang/www/analyzer/installation.html

 
 <p>Most of the files in the <b><tt>checker-XXX</tt></b> directory will
 be supporting files for the analyzer that you can simply ignore.  Most
 users will only care about two files, which are located at the top of
 the <b><tt>checker-XXX</tt></b> directory:</p>
 
 <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
 run as soon as it the analysis of a build completes</li>
 </ul>
 
 <h4>Running scan-build</h4>