Misc typos

[• luzpaz]

Summary

Found via codespell -q 3 -I ../clang-whitelist.txt
Where whitelist consists of:

archtype
cas
classs
checkk
compres
definit
frome
iff
inteval
ith
lod
methode
nd
optin
ot
pres
statics
te
thru

[• luzpaz]

Rebased and re-diffed

[• luzpaz]

Please advise how to proceed

[tra]

You may want to split the patch into smaller pieces -- per leaf directory, for example.
That way potential reviewers would at least be able to see the changes (hundreds of files in one patch is a bit too much), and the subset of changes would be small enough for someone to own it (or at least familiar enough with it to give approval).

[alexfh]

Thanks!
I've looked through all the fixes. Most of them look reasonable. I've reverted a few files where I found something suspicious or outright wrong and will commit the rest of the patch after I ensure the tests pass.

These files couldn't be patched:

include/clang/Basic/AttrDocs.td
lib/Basic/VirtualFileSystem.cpp
lib/CodeGen/CGExpr.cpp
lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp
lib/Driver/ToolChains/Hexagon.cpp
lib/Sema/Sema.cpp
lib/StaticAnalyzer/Core/CoreEngine.cpp
test/CodeGenCXX/ms-integer-static-data-members.cpp

The list of the files I reverted:

lib/ARCMigrate/FileRemapper.cpp
lib/AST/ExprConstant.cpp
lib/Frontend/CacheTokens.cpp
lib/Frontend/CompilerInvocation.cpp
lib/Headers/htmintrin.h
lib/Parse/Parser.cpp
lib/Sema/SemaDeclCXX.cpp
lib/Sema/SemaLookup.cpp
test/CodeGen/builtins-arm-exclusive.c
test/CodeGen/vectorcall.c
test/Modules/odr_hash.cpp
test/Sema/warn-documentation-fixits.cpp
test/Sema/warn-documentation-unknown-command.cpp

[alexfh]

Feel free to send the rest of the fixes as a separate patch.

bindings/python/clang/cindex.py

 # An expression whose specific kind is not exposed via this interface.
 #
 # Unexposed expressions have the same operations as any other kind of
 # expression; one can extract their location information, spelling, children,
 # etc. However, the specific kind of the expression is not reported.
 CursorKind.UNEXPOSED_EXPR = CursorKind(100)
 
 # An expression that refers to some value declaration, such as a function,
-# varible, or enumerator.
+# variable, or enumerator.
 CursorKind.DECL_REF_EXPR = CursorKind(101)
 
 # An expression that refers to a member of a struct, union, class, Objective-C
 # class, etc.
 CursorKind.MEMBER_REF_EXPR = CursorKind(102)
 
 # An expression that calls a function.
 CursorKind.CALL_EXPR = CursorKind(103)
def get_definition(self):
         some entity, return a cursor that points to the definition of that
         entity.
         """
         # TODO: Should probably check that this is either a reference or
         # declaration prior to issuing the lookup.
         return conf.lib.clang_getCursorDefinition(self)
 
     def get_usr(self):
-        """Return the Unified Symbol Resultion (USR) for the entity referenced
+        """Return the Unified Symbol Resolution (USR) for the entity referenced
         by the given cursor (or None).
 
         A Unified Symbol Resolution (USR) is a string that identifies a
         particular entity (function, class, variable, etc.) within a
         program. USRs can be compared across translation units to determine,
         e.g., when references in one translation refer to an entity defined in
         another translation unit."""
         return conf.lib.clang_getCursorUSR(self)

cmake/caches/Apple-stage2.cmake

 set(LLVM_ENABLE_MODULES ON CACHE BOOL "")
 set(LLVM_EXTERNALIZE_DEBUGINFO ON CACHE BOOL "")
 set(CLANG_PLUGIN_SUPPORT OFF CACHE BOOL "")
 set(BUG_REPORT_URL "http://developer.apple.com/bugreporter/" CACHE STRING "")
 
 set(LLVM_BUILD_EXTERNAL_COMPILER_RT ON CACHE BOOL "Build Compiler-RT with just-built clang")
 set(COMPILER_RT_ENABLE_IOS ON CACHE BOOL "Build iOS Compiler-RT libraries")
 
-set(LLVM_CREATE_XCODE_TOOLCHAIN ON CACHE BOOL "Generate targets to create and install an Xcode compatable toolchain")
+set(LLVM_CREATE_XCODE_TOOLCHAIN ON CACHE BOOL "Generate targets to create and install an Xcode compatible toolchain")
 
 # Make unit tests (if present) part of the ALL target
 set(LLVM_BUILD_TESTS ON CACHE BOOL "")
 
 set(LLVM_ENABLE_LTO ON CACHE BOOL "")
 set(CMAKE_C_FLAGS "-fno-stack-protector -fno-common -Wno-profile-instr-unprofiled" CACHE STRING "")
 set(CMAKE_CXX_FLAGS "-fno-stack-protector -fno-common -Wno-profile-instr-unprofiled" CACHE STRING "")
 if(LLVM_ENABLE_LTO AND NOT LLVM_ENABLE_LTO STREQUAL "THIN")

docs/LibASTMatchersReference.html

 
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;</td><td class="name" onclick="toggle('thisPointerType0')"><a name="thisPointerType0Anchor">thisPointerType</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="thisPointerType0"><pre>Matches if the expression's type either matches the specified
 matcher, or is a pointer to a type that matches the InnerMatcher.
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('forEachOverridden0')"><a name="forEachOverridden0Anchor">forEachOverridden</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt; InnerMatcher</td></tr>
-<tr><td colspan="4" class="doc" id="forEachOverridden0"><pre>Matches each method overriden by the given method. This matcher may
+<tr><td colspan="4" class="doc" id="forEachOverridden0"><pre>Matches each method overridden by the given method. This matcher may
 produce multiple matches.
 
 Given
   class A { virtual void f(); };
   class B : public A { void f(); };
   class C : public B { void f(); };
 cxxMethodDecl(ofClass(hasName("C")),
               forEachOverridden(cxxMethodDecl().bind("b"))).bind("d")

docs/analyzer/DesignDiscussions/InitializerLists.rst

 
 Approach (0): This can be trivially fixed by this patch, which causes pointers
 passed into initializer list expressions to immediately escape.
 
 This fix is overly conservative though. So i did a bit of investigation as to
 how model std::initializer_list better.
 
 According to the standard, std::initializer_list<T> is an object that has
-methods begin(), end(), and size(), where begin() returns a pointer to continous
+methods begin(), end(), and size(), where begin() returns a pointer to continuous
 array of size() objects of type T, and end() is equal to begin() plus size().
 The standard does hint that it should be possible to implement
 std::initializer_list<T> as a pair of pointers, or as a pointer and a size
 integer, however specific fields that the object would contain are an
 implementation detail.
 
 Ideally, we should be able to model the initializer list's methods precisely.
 Or, at least, it should be possible to explain to the analyzer that the list

docs/doxygen.cfg.in

 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_STYLESHEET        =
 
 # The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user-
 # defined cascading style sheet that is included after the standard style sheets
 # created by doxygen. Using this option one can overrule certain style aspects.
 # This is preferred over using HTML_STYLESHEET since it does not replace the
-# standard style sheet and is therefor more robust against future updates.
+# standard style sheet and is therefore more robust against future updates.
 # Doxygen will copy the style sheet file to the output directory. For an example
 # see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 HTML_EXTRA_STYLESHEET  =
 
 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the HTML output directory. Note

include/clang-c/Index.h

enum CXCompletionChunkKind {
    * int add(int x, int y);
    * \endcode
    *
    * and the source code \c add(, where the code-completion point is after the
    * "(", the code-completion string will contain a "current parameter" chunk
    * for "int x", indicating that the current argument will initialize that
    * parameter. After typing further, to \c add(17, (where the code-completion
    * point is after the ","), the code-completion string will contain a
-   * "current paremeter" chunk to "int y".
+   * "current parameter" chunk to "int y".
    */
   CXCompletionChunk_CurrentParameter,
   /**
    * \brief A left parenthesis ('('), used to initiate a function call or
    * signal the beginning of a function parameter list.
    */
   CXCompletionChunk_LeftParen,
   /**

  * current location in the C/Objective-C/C++ grammar and the state of
  * semantic analysis, what completions to provide. These completions are
  * returned via a new \c CXCodeCompleteResults structure.
  *
  * Code completion itself is meant to be triggered by the client when the
  * user types punctuation characters or whitespace, at which point the
  * code-completion location will coincide with the cursor. For example, if \c p
  * is a pointer, code-completion might be triggered after the "-" and then
- * after the ">" in \c p->. When the code-completion location is afer the ">",
+ * after the ">" in \c p->. When the code-completion location is after the ">",
  * the completion results will provide, e.g., the members of the struct that
  * "p" points to. The client is responsible for placing the cursor at the
  * beginning of the token currently being typed, then filtering the results
  * based on the contents of the token. For example, when code-completing for
  * the expression \c p->get, the client should provide the location just after
  * the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the
  * client can filter the results based on the current token text ("get"), only
  * showing those results that start with "get". The intent of this interface

include/clang/AST/ASTContext.h

public:
   ///
   /// The return type should be T with all prior qualifiers minus the address
   /// space.
   QualType removeAddrSpaceQualType(QualType T) const;
 
   /// \brief Apply Objective-C protocol qualifiers to the given type.
   /// \param allowOnPointerType specifies if we can apply protocol
   /// qualifiers on ObjCObjectPointerType. It can be set to true when
-  /// contructing the canonical type of a Objective-C type parameter.
+  /// constructing the canonical type of a Objective-C type parameter.
   QualType applyObjCProtocolQualifiers(QualType type,
       ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
       bool allowOnPointerType = false) const;
 
   /// \brief Return the uniqued reference to the type for an Objective-C
   /// gc-qualified type.
   ///
   /// The retulting type has a union of the qualifiers from T and the gc

include/clang/AST/ASTTypeTraits.h

public:
   /// \brief For nodes which represent textual entities in the source code,
   /// return their SourceRange.  For all other nodes, return SourceRange().
   SourceRange getSourceRange() const;
 
   /// @{
   /// \brief Imposes an order on \c DynTypedNode.
   ///
   /// Supports comparison of nodes that support memoization.
-  /// FIXME: Implement comparsion for other node types (currently
+  /// FIXME: Implement comparison for other node types (currently
   /// only Stmt, Decl, Type and NestedNameSpecifier return memoization data).
   bool operator<(const DynTypedNode &Other) const {
     if (!NodeKind.isSame(Other.NodeKind))
       return NodeKind < Other.NodeKind;
 
     if (ASTNodeKind::getFromNodeKind<QualType>().isSame(NodeKind))
       return getUnchecked<QualType>().getAsOpaquePtr() <
              Other.getUnchecked<QualType>().getAsOpaquePtr();

include/clang/AST/CanonicalType.h

public:
   /// for the given type T. In that case, we reference members of the
   /// CanProxyAdaptor specialization. Otherwise, this operator will be hidden
   /// by the arrow operator in the primary CanProxyAdaptor template.
   const CanProxyAdaptor<T> *operator->() const {
     return static_cast<const CanProxyAdaptor<T> *>(this);
   }
 };
 
-/// \brief Replacable canonical proxy adaptor class that provides the link
+/// \brief Replaceable canonical proxy adaptor class that provides the link
 /// between a canonical type and the accessors of the type.
 ///
 /// The CanProxyAdaptor is a replaceable class template that is instantiated
 /// as part of each canonical proxy type. The primary template merely provides
 /// redirection to the underlying type (T), e.g., @c PointerType. One can
 /// provide specializations of this class template for each underlying type
 /// that provide accessors returning canonical types (@c CanQualType) rather
 /// than the more typical @c QualType, to propagate the notion of "canonical"

include/clang/AST/Comment.h

 /// Information about the declaration, useful to clients of FullComment.
 struct DeclInfo {
   /// Declaration the comment is actually attached to (in the source).
   /// Should not be NULL.
   const Decl *CommentDecl;
   
   /// CurrentDecl is the declaration with which the FullComment is associated.
   ///
-  /// It can be different from \c CommentDecl.  It happens when we we decide
+  /// It can be different from \c CommentDecl.  It happens when we decide
   /// that the comment originally attached to \c CommentDecl is fine for
   /// \c CurrentDecl too (for example, for a redeclaration or an overrider of
   /// \c CommentDecl).
   ///
   /// The information in the DeclInfo corresponds to CurrentDecl.
   const Decl *CurrentDecl;
   
   /// Parameters that can be referenced by \\param if \c CommentDecl is something

include/clang/AST/CommentLexer.h

class Token {
   /// tokens.
   unsigned Length;
 
   /// Contains text value associated with a token.
   const char *TextPtr;
 
   /// Integer value associated with a token.
   ///
-  /// If the token is a konwn command, contains command ID and TextPtr is
+  /// If the token is a known command, contains command ID and TextPtr is
   /// unused (command spelling can be found with CommandTraits).  Otherwise,
   /// contains the length of the string that starts at TextPtr.
   unsigned IntVal;
   
 public:
   SourceLocation getLocation() const LLVM_READONLY { return Loc; }
   void setLocation(SourceLocation SL) { Loc = SL; }
 

include/clang/AST/DataCollection.h

 //===--- DatatCollection.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 /// \brief This file declares helper methods for collecting data from AST nodes.
 ///
 /// To collect data from Stmt nodes, subclass ConstStmtVisitor and include
 /// StmtDataCollectors.inc after defining the macros that you need. This
 /// provides data collection implementations for most Stmt kinds. Note
-/// that that code requires some conditions to be met:
+/// that the code requires some conditions to be met:
 ///
 ///   - There must be a method addData(const T &Data) that accepts strings,
 ///     integral types as well as QualType. All data is forwarded using
 ///     to this method.
 ///   - The ASTContext of the Stmt must be accessible by the name Context.
 ///
 /// It is also possible to override individual visit methods. Have a look at
 /// the DataCollector in lib/Analysis/CloneDetection.cpp for a usage example.

include/clang/AST/DeclCXX.h

public:
   /// constructor for this class.
   bool needsOverloadResolutionForMoveConstructor() const {
     return data().NeedOverloadResolutionForMoveConstructor;
   }
 
   /// \brief Determine whether this class has a user-declared copy assignment
   /// operator.
   ///
-  /// When false, a copy assigment operator will be implicitly declared.
+  /// When false, a copy assignment operator will be implicitly declared.
   bool hasUserDeclaredCopyAssignment() const {
     return data().UserDeclaredSpecialMembers & SMF_CopyAssignment;
   }
 
   /// \brief Determine whether this class needs an implicit copy
   /// assignment operator to be lazily declared.
   bool needsImplicitCopyAssignment() const {
     return !(data().DeclaredSpecialMembers & SMF_CopyAssignment);
bool isDependentLambda() const {
     return isLambda() && getLambdaData().Dependent;
   }
 
   TypeSourceInfo *getLambdaTypeInfo() const {
     return getLambdaData().MethodTyInfo;
   }
 
   // \brief Determine whether this type is an Interface Like type for
-  // __interface inheritence purposes.
+  // __interface inheritance purposes.
   bool isInterfaceLike() const;
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) {
     return K >= firstCXXRecord && K <= lastCXXRecord;
   }
 };
 

include/clang/AST/Expr.h

public:
   /// an rvalue using any crazy technique (that has nothing to do with language
   /// standards) that we want to, even if the expression has side-effects. If
   /// this function returns true, it returns the folded constant in Result. If
   /// the expression is a glvalue, an lvalue-to-rvalue conversion will be
   /// applied.
   bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const;
 
   /// EvaluateAsBooleanCondition - Return true if this is a constant
-  /// which we we can fold and convert to a boolean condition using
+  /// which we can fold and convert to a boolean condition using
   /// any crazy technique that we want to, even if the expression has
   /// side-effects.
   bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx) const;
 
   enum SideEffectsKind {
     SE_NoSideEffects,          ///< Strictly evaluate the expression.
     SE_AllowUndefinedBehavior, ///< Allow UB that we can give a value, but not
                                ///< arbitrary unmodeled side effects.
public:
   bool isEqualityOp() const { return isEqualityOp(getOpcode()); }
 
   static bool isComparisonOp(Opcode Opc) { return Opc >= BO_Cmp && Opc<=BO_NE; }
   bool isComparisonOp() const { return isComparisonOp(getOpcode()); }
 
   static Opcode negateComparisonOp(Opcode Opc) {
     switch (Opc) {
     default:
-      llvm_unreachable("Not a comparsion operator.");
+      llvm_unreachable("Not a comparison operator.");
     case BO_LT: return BO_GE;
     case BO_GT: return BO_LE;
     case BO_LE: return BO_GT;
     case BO_GE: return BO_LT;
     case BO_EQ: return BO_NE;
     case BO_NE: return BO_EQ;
     }
   }
 
   static Opcode reverseComparisonOp(Opcode Opc) {
     switch (Opc) {
     default:
-      llvm_unreachable("Not a comparsion operator.");
+      llvm_unreachable("Not a comparison operator.");
     case BO_LT: return BO_GT;
     case BO_GT: return BO_LT;
     case BO_LE: return BO_GE;
     case BO_GE: return BO_LE;
     case BO_EQ:
     case BO_NE:
       return Opc;
     }

include/clang/AST/ExternalASTMerger.h

 
 public:
   ExternalASTMerger(const ImporterTarget &Target,
                     llvm::ArrayRef<ImporterSource> Sources);
 
   /// Add a set of ASTContexts as possible origins.
   ///
   /// Usually the set will be initialized in the constructor, but long-lived
-  /// ExternalASTMergers may neeed to import from new sources (for example,
+  /// ExternalASTMergers may need to import from new sources (for example,
   /// newly-parsed source files).
   ///
   /// Ensures that Importers does not gain duplicate entries as a result.
   void AddSources(llvm::ArrayRef<ImporterSource> Sources);
 
   /// Remove a set of ASTContexts as possible origins.
   ///
   /// Sometimes an origin goes away (for example, if a source file gets

include/clang/AST/NestedNameSpecifier.h

public:
   /// \brief Construct an empty nested-name-specifier.
   NestedNameSpecifierLoc() = default;
 
   /// \brief Construct a nested-name-specifier with source location information
   /// from
   NestedNameSpecifierLoc(NestedNameSpecifier *Qualifier, void *Data)
       : Qualifier(Qualifier), Data(Data) {}
 
-  /// \brief Evalutes true when this nested-name-specifier location is
+  /// \brief Evaluates true when this nested-name-specifier location is
   /// non-empty.
   explicit operator bool() const { return Qualifier; }
 
-  /// \brief Evalutes true when this nested-name-specifier location is
+  /// \brief Evaluates true when this nested-name-specifier location is
   /// empty.
   bool hasQualifier() const { return Qualifier; }
 
   /// \brief Retrieve the nested-name-specifier to which this instance
   /// refers.
   NestedNameSpecifier *getNestedNameSpecifier() const {
     return Qualifier;
   }

include/clang/AST/RecursiveASTVisitor.h

 /// are still visited, and the patterns of partial specializations
 /// are visited separately.  This behavior can be changed by
 /// overriding shouldVisitTemplateInstantiations() in the derived class
 /// to return true, in which case all known implicit and explicit
 /// instantiations will be visited at the same time as the pattern
 /// from which they were produced.
 ///
 /// By default, this visitor preorder traverses the AST. If postorder traversal
-/// is needed, the \c shouldTraversePostOrder method needs to be overriden
+/// is needed, the \c shouldTraversePostOrder method needs to be overridden
 /// to return \c true.
 template <typename Derived> class RecursiveASTVisitor {
 public:
   /// A queue used for performing data recursion over statements.
   /// Parameters involving this type are used to implement data
   /// recursion over Stmts and Exprs within this class, and should
   /// typically not be explicitly specified by derived classes.
   /// The bool bit indicates whether the statement has been traversed or not.

include/clang/AST/StmtOpenMP.h

struct DistCombinedHelperExprs {
     Expr *EUB;
     /// Distribute loop iteration variable init used when composing 'omp
     /// distribute'
     ///  with 'omp for' in a same construct
     Expr *Init;
     /// Distribute Loop condition used when composing 'omp distribute'
     ///  with 'omp for' in a same construct
     Expr *Cond;
-    /// Update of LowerBound for statically sheduled omp loops for
+    /// Update of LowerBound for statically scheduled omp loops for
     /// outer loop in combined constructs (e.g. 'distribute parallel for')
     Expr *NLB;
-    /// Update of UpperBound for statically sheduled omp loops for
+    /// Update of UpperBound for statically scheduled omp loops for
     /// outer loop in combined constructs (e.g. 'distribute parallel for')
     Expr *NUB;
   };
 
   /// \brief The expressions built for the OpenMP loop CodeGen for the
   /// whole collapsed loop nest.
   struct HelperExprs {
     /// \brief Loop iteration variable.
struct HelperExprs {
     /// \brief LowerBound - local variable passed to runtime.
     Expr *LB;
     /// \brief UpperBound - local variable passed to runtime.
     Expr *UB;
     /// \brief Stride - local variable passed to runtime.
     Expr *ST;
     /// \brief EnsureUpperBound -- expression UB = min(UB, NumIterations).
     Expr *EUB;
-    /// \brief Update of LowerBound for statically sheduled 'omp for' loops.
+    /// \brief Update of LowerBound for statically scheduled 'omp for' loops.
     Expr *NLB;
-    /// \brief Update of UpperBound for statically sheduled 'omp for' loops.
+    /// \brief Update of UpperBound for statically scheduled 'omp for' loops.
     Expr *NUB;
     /// \brief PreviousLowerBound - local variable passed to runtime in the
     /// enclosing schedule or null if that does not apply.
     Expr *PrevLB;
     /// \brief PreviousUpperBound - local variable passed to runtime in the
     /// enclosing schedule or null if that does not apply.
     Expr *PrevUB;
     /// \brief DistInc - increment expression for distribute loop when found

include/clang/AST/Type.h

#include "clang/Basic/OpenCLImageTypes.def"
   CXXRecordDecl *getAsCXXRecordDecl() const;
 
   /// \brief Retrieves the TagDecl that this type refers to, either
   /// because the type is a TagType or because it is the injected-class-name
   /// type of a class template or class template partial specialization.
   TagDecl *getAsTagDecl() const;
 
   /// If this is a pointer or reference to a RecordType, return the
-  /// CXXRecordDecl that that type refers to.
+  /// CXXRecordDecl that the type refers to.
   ///
   /// If this is not a pointer or reference, or the type being pointed to does
   /// not refer to a CXXRecordDecl, returns NULL.
   const CXXRecordDecl *getPointeeCXXRecordDecl() const;
 
   /// Get the DeducedType whose type will be deduced for a variable with
   /// an initializer of this type. This looks through declarators like pointer
   /// types, but not through decltype or typedefs.

include/clang/ASTMatchers/ASTMatchers.h

 /// \endcode
 AST_MATCHER_P(CXXMethodDecl, ofClass,
               internal::Matcher<CXXRecordDecl>, InnerMatcher) {
   const CXXRecordDecl *Parent = Node.getParent();
   return (Parent != nullptr &&
           InnerMatcher.matches(*Parent, Finder, Builder));
 }
 
-/// \brief Matches each method overriden by the given method. This matcher may
+/// \brief Matches each method overridden by the given method. This matcher may
 /// produce multiple matches.
 ///
 /// Given
 /// \code
 ///   class A { virtual void f(); };
 ///   class B : public A { void f(); };
 ///   class C : public B { void f(); };
 /// \endcode

include/clang/Analysis/Analyses/ThreadSafetyTraverse.h

 #include <ostream>
 
 namespace clang {
 namespace threadSafety {
 namespace til {
 
 // Defines an interface used to traverse SExprs.  Traversals have been made as
 // generic as possible, and are intended to handle any kind of pass over the
-// AST, e.g. visiters, copying, non-destructive rewriting, destructive
+// AST, e.g. visitors, copying, non-destructive rewriting, destructive
 // (in-place) rewriting, hashing, typing, etc.
 //
 // Traversals implement the functional notion of a "fold" operation on SExprs.
 // Each SExpr class provides a traverse method, which does the following:
 //   * e->traverse(v):
 //       // compute a result r_i for each subexpression e_i
 //       for (i = 1..n)  r_i = v.traverse(e_i);
 //       // combine results into a result for e,  where X is the class of e

include/clang/Analysis/CloneDetection.h

 /// First, this class needs several declarations with statement bodies which
 /// can be passed via analyzeCodeBody. Afterwards all statements can be
 /// searched for clones by calling findClones with a given list of constraints
 /// that should specify the wanted properties of the clones.
 ///
 /// The result of findClones can be further constrained with the constrainClones
 /// method.
 ///
-/// This class only searches for clones in exectuable source code
+/// This class only searches for clones in executable source code
 /// (e.g. function bodies). Other clones (e.g. cloned comments or declarations)
 /// are not supported.
 class CloneDetector {
 
 public:
   /// A collection of StmtSequences that share an arbitrary property.
   typedef llvm::SmallVector<StmtSequence, 8> CloneGroup;
 

include/clang/Basic/Attr.td

def InitSeg : Attr {
   }];
 }
 
 def LoopHint : Attr {
   /// #pragma clang loop <option> directive
   /// vectorize: vectorizes loop operations if State == Enable.
   /// vectorize_width: vectorize loop operations with width 'Value'.
   /// interleave: interleave multiple loop iterations if State == Enable.
-  /// interleave_count: interleaves 'Value' loop interations.
+  /// interleave_count: interleaves 'Value' loop iterations.
   /// unroll: fully unroll loop if State == Enable.
   /// unroll_count: unrolls loop 'Value' times.
   /// distribute: attempt to distribute loop if State == Enable
 
   /// #pragma unroll <argument> directive
   /// <no arg>: fully unrolls loop.
   /// boolean: fully unrolls loop if State == Enable.
   /// expression: unrolls loop 'Value' times.

include/clang/Basic/AttrDocs.td

.. code-block:: c++
     };
   }];
 }
 
 def NoThrowDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Clang supports the GNU style ``__attribute__((nothrow))`` and Microsoft style
-``__declspec(nothrow)`` attribute as an equivilent of `noexcept` on function
+``__declspec(nothrow)`` attribute as an equivalent of `noexcept` on function
 declarations. This attribute informs the compiler that the annotated function
 does not throw an exception. This prevents exception-unwinding. This attribute
 is particularly useful on functions in the C Standard Library that are
 guaranteed to not throw an exception.
     }];
 }
 
 def InternalLinkageDocs : Documentation {
def AbiTagsDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 The ``abi_tag`` attribute can be applied to a function, variable, class or
 inline namespace declaration to modify the mangled name of the entity. It gives
 the ability to distinguish between different versions of the same entity but
 with different ABI versions supported. For example, a newer version of a class
 could have a different set of data members and thus have a different size. Using
 the ``abi_tag`` attribute, it is possible to have different mangled names for
-a global variable of the class type. Therefor, the old code could keep using
+a global variable of the class type. Therefore, the old code could keep using
 the old manged name and the new code will use the new mangled name with tags.
   }];
 }
 
 def PreserveMostDocs : Documentation {
   let Category = DocCatCallingConvs;
   let Content = [{
 On X86-64 and AArch64 targets, this attribute changes the calling convention of

include/clang/Basic/DiagnosticSemaKinds.td

 def warn_pragma_pack_no_pop_eof : Warning<"unterminated "
   "'#pragma pack (push, ...)' at end of file">, InGroup<PragmaPack>;
 def note_pragma_pack_here : Note<
   "previous '#pragma pack' directive that modifies alignment is here">;
 def note_pragma_pack_pop_instead_reset : Note<
   "did you intend to use '#pragma pack (pop)' instead of '#pragma pack()'?">;
 // Follow the Microsoft implementation.
 def warn_pragma_pack_show : Warning<"value of #pragma pack(show) == %0">;
-def warn_pragma_pack_pop_identifer_and_alignment : Warning<
+def warn_pragma_pack_pop_identifier_and_alignment : Warning<
   "specifying both a name and alignment to 'pop' is undefined">;
 def warn_pragma_pop_failed : Warning<"#pragma %0(pop, ...) failed: %1">,
   InGroup<IgnoredPragmas>;
 def warn_cxx_ms_struct :
   Warning<"ms_struct may not produce Microsoft-compatible layouts for classes "
           "with base classes or virtual functions">,
   DefaultError, InGroup<IncompatibleMSStruct>;
 def warn_npot_ms_struct :

include/clang/Basic/Version.h

namespace clang {
   /// Clang was built.
   std::string getClangRepositoryPath();
 
   /// \brief Retrieves the repository path from which LLVM was built.
   ///
   /// This supports LLVM residing in a separate repository from clang.
   std::string getLLVMRepositoryPath();
 
-  /// \brief Retrieves the repository revision number (or identifer) from which
+  /// \brief Retrieves the repository revision number (or identifier) from which
   /// this Clang was built.
   std::string getClangRevision();
 
-  /// \brief Retrieves the repository revision number (or identifer) from which
+  /// \brief Retrieves the repository revision number (or identifier) from which
   /// LLVM was built.
   ///
   /// If Clang and LLVM are in the same repository, this returns the same
   /// string as getClangRevision.
   std::string getLLVMRevision();
 
   /// \brief Retrieves the full repository version that is an amalgamation of
   /// the information in getClangRepositoryPath() and getClangRevision().

include/clang/CodeGen/ConstantInitBuilder.h

public:
   };
 
   /// Add a placeholder value to the structure.  The returned position
   /// can be used to set the value later; it will not be invalidated by
   /// any intermediate operations except (1) filling the same position or
   /// (2) finishing the entire builder.
   ///
   /// This is useful for emitting certain kinds of structure which
-  /// contain some sort of summary field, generaly a count, before any
+  /// contain some sort of summary field, generally a count, before any
   /// of the data.  By emitting a placeholder first, the structure can
   /// be emitted eagerly.
   PlaceholderPosition addPlaceholder() {
     assert(!Finished && "cannot add more values after finishing builder");
     assert(!Frozen && "cannot add values while subbuilder is active");
     Builder.Buffer.push_back(nullptr);
     return Builder.Buffer.size() - 1;
   }

include/clang/Driver/Multilib.h

public:
   MultilibSet &FilterOut(const char *Regex);
 
   /// Add a completed Multilib to the set
   void push_back(const Multilib &M);
 
   /// Union this set of multilibs with another
   void combineWith(const MultilibSet &MS);
 
-  /// Remove all of thie multilibs from the set
+  /// Remove all of the multilibs from the set
   void clear() { Multilibs.clear(); }
 
   iterator begin() { return Multilibs.begin(); }
   const_iterator begin() const { return Multilibs.begin(); }
 
   iterator end() { return Multilibs.end(); }
   const_iterator end() const { return Multilibs.end(); }
 

include/clang/Frontend/ASTUnit.h

private:
   /// building the precompiled preamble fails, we won't try again for
   /// some number of calls.
   unsigned PreambleRebuildCounter = 0;
 
   /// \brief Cache pairs "filename - source location"
   ///
   /// Cache contains only source locations from preamble so it is
   /// guaranteed that they stay valid when the SourceManager is recreated.
-  /// This cache is used when loading preambule to increase performance
+  /// This cache is used when loading preamble to increase performance
   /// of that loading. It must be cleared when preamble is recreated.
   llvm::StringMap<SourceLocation> PreambleSrcLocCache;
 
   /// The contents of the preamble.
   llvm::Optional<PrecompiledPreamble> Preamble;
 
   /// \brief When non-NULL, this is the buffer used to store the contents of
   /// the main file when it has been padded for use with the precompiled

include/clang/Frontend/PrecompiledPreamble.h

bool CanReuse(const CompilerInvocation &Invocation,
                 vfs::FileSystem *VFS) const;
 
   /// Changes options inside \p CI to use PCH from this preamble. Also remaps
   /// main file to \p MainFileBuffer and updates \p VFS to ensure the preamble
   /// is accessible.
   /// Requires that CanReuse() is true.
   /// For in-memory preambles, PrecompiledPreamble instance continues to own the
   /// MemoryBuffer with the Preamble after this method returns. The caller is
-  /// reponsible for making sure the PrecompiledPreamble instance outlives the
+  /// responsible for making sure the PrecompiledPreamble instance outlives the
   /// compiler run and the AST that will be using the PCH.
   void AddImplicitPreamble(CompilerInvocation &CI,
                            IntrusiveRefCntPtr<vfs::FileSystem> &VFS,
                            llvm::MemoryBuffer *MainFileBuffer) const;
 
   /// Configure \p CI to use this preamble.
   /// Like AddImplicitPreamble, but doesn't assume CanReuse() is true.
   /// If this preamble does not match the file, it may parse differently.

include/clang/Lex/HeaderSearch.h

public:
   
   FileManager &getFileMgr() const { return FileMgr; }
 
   /// \brief Interface for setting the file search paths.
   void SetSearchPaths(const std::vector<DirectoryLookup> &dirs,
                       unsigned angledDirIdx, unsigned systemDirIdx,
                       bool noCurDirSearch) {
     assert(angledDirIdx <= systemDirIdx && systemDirIdx <= dirs.size() &&
-        "Directory indicies are unordered");
+        "Directory indices are unordered");
     SearchDirs = dirs;
     AngledDirIdx = angledDirIdx;
     SystemDirIdx = systemDirIdx;
     NoCurDirSearch = noCurDirSearch;
     //LookupFileCache.clear();
   }
 
   /// \brief Add an additional search path.

include/clang/Lex/ModuleMap.h

private:
   /// that is generated from the umbrella header.
   ///
   /// This mapping is used to map headers that haven't explicitly been named
   /// in the module map over to the module that includes them via its umbrella
   /// header.
   llvm::DenseMap<const DirectoryEntry *, Module *> UmbrellaDirs;
 
   /// \brief A generation counter that is used to test whether modules of the
-  /// same name may shadow or are illegal redefintions.
+  /// same name may shadow or are illegal redefinitions.
   ///
   /// Modules from earlier scopes may shadow modules from later ones.
   /// Modules from the same scope may not have the same name.
   unsigned CurrentModuleScopeID = 0;
 
   llvm::DenseMap<Module *, unsigned> ModuleScopeIDs;
 
   /// \brief The set of attributes that can be attached to a module.

include/clang/Lex/TokenLexer.h

private:
   /// them into a string.  \p VCtx is used to determine which token represents
   /// the first __VA_OPT__ replacement token.
   ///
   /// \param[in,out] ReplacementToks - Contains the current Replacement Tokens
   /// (prior to rescanning and token pasting), the tail end of which represents
   /// the tokens just expanded through __VA_OPT__ processing.  These (sub)
   /// sequence of tokens are folded into one stringified token.
   ///
-  /// \param[in] VCtx - contains relevent contextual information about the
+  /// \param[in] VCtx - contains relevant contextual information about the
   /// state of the tokens around and including the __VA_OPT__ token, necessary
   /// for stringification.
   void stringifyVAOPTContents(SmallVectorImpl<Token> &ReplacementToks,
                               const VAOptExpansionContext &VCtx,
                               SourceLocation VAOPTClosingParenLoc);
 
   /// Expand the arguments of a function-like macro so that we can quickly
   /// return preexpanded tokens from Tokens.

include/clang/Parse/Parser.h

struct LateParsedMethodDeclaration : public LateParsedDeclaration {
 
     Parser* Self;
 
     /// Method - The method declaration.
     Decl *Method;
 
     /// \brief Whether this member function had an associated template
     /// scope. When true, D is a template declaration.
-    /// othewise, it is a member function declaration.
+    /// otherwise, it is a member function declaration.
     bool TemplateScope;
 
     /// DefaultArgs - Contains the parameters of the function and
     /// their default arguments. At least one of the parameters will
     /// have a default argument, but all of the parameters of the
     /// method will be stored so that they can be reintroduced into
     /// scope at the appropriate times.
     SmallVector<LateParsedDefaultArgument, 8> DefaultArgs;
ParsingClass(Decl *TagOrTemplate, bool TopLevelClass, bool IsInterface)
         IsInterface(IsInterface), TagOrTemplate(TagOrTemplate) { }
 
     /// \brief Whether this is a "top-level" class, meaning that it is
     /// not nested within another class.
     bool TopLevelClass : 1;
 
     /// \brief Whether this class had an associated template
     /// scope. When true, TagOrTemplate is a template declaration;
-    /// othewise, it is a tag declaration.
+    /// otherwise, it is a tag declaration.
     bool TemplateScope : 1;
 
     /// \brief Whether this class is an __interface.
     bool IsInterface : 1;
 
     /// \brief The class or class template whose definition we are parsing.
     Decl *TagOrTemplate;
 

include/clang/Sema/AttributeList.h

AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
         Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
         IsTypeTagForDatatype(false), IsProperty(true), HasParsedType(false),
         HasProcessingCache(false) {
     new (&getPropertyDataBuffer()) PropertyData(getterId, setterId);
     AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
   }
 
   /// Type tag information is stored immediately following the arguments, if
-  /// any, at the end of the object.  They are mutually exlusive with
+  /// any, at the end of the object.  They are mutually exclusive with
   /// availability slots.
   TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() {
     return *reinterpret_cast<TypeTagForDatatypeData*>(getArgsBuffer()+NumArgs);
   }
   const TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() const {
     return *reinterpret_cast<const TypeTagForDatatypeData*>(getArgsBuffer()
                                                             + NumArgs);
   }

include/clang/Sema/TypoCorrection.h

public:
   explicit CorrectionCandidateCallback(IdentifierInfo *Typo = nullptr,
                                        NestedNameSpecifier *TypoNNS = nullptr)
       : Typo(Typo), TypoNNS(TypoNNS) {}
 
   virtual ~CorrectionCandidateCallback() = default;
 
   /// \brief Simple predicate used by the default RankCandidate to
   /// determine whether to return an edit distance of 0 or InvalidDistance.
-  /// This can be overrided by validators that only need to determine if a
+  /// This can be overridden by validators that only need to determine if a
   /// candidate is viable, without ranking potentially viable candidates.
-  /// Only ValidateCandidate or RankCandidate need to be overriden by a
+  /// Only ValidateCandidate or RankCandidate need to be overridden by a
   /// callback wishing to check the viability of correction candidates.
   /// The default predicate always returns true if the candidate is not a type
   /// name or keyword, true for types if WantTypeSpecifiers is true, and true
   /// for keywords if WantTypeSpecifiers, WantExpressionKeywords,
   /// WantCXXNamedCasts, WantRemainingKeywords, or WantObjCSuper is true.
   virtual bool ValidateCandidate(const TypoCorrection &candidate);
 
   /// \brief Method used by Sema::CorrectTypo to assign an "edit distance" rank

include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

public:
   /// interpreted as true and the "false" string is interpreted as false.
   ///
   /// If an option value is not provided, returns the given \p DefaultVal.
   /// @param [in] Name Name for option to retrieve.
   /// @param [in] DefaultVal Default value returned if no such option was
   /// specified.
   /// @param [in] C The optional checker parameter that can be used to restrict
   /// the search to the options of this particular checker (and its parents
-  /// dependening on search mode).
+  /// depending on search mode).
   /// @param [in] SearchInParents If set to true and the searched option was not
   /// specified for the given checker the options for the parent packages will
   /// be searched as well. The inner packages take precedence over the outer
   /// ones.
   bool getBooleanOption(StringRef Name, bool DefaultVal,
                         const ento::CheckerBase *C = nullptr,
                         bool SearchInParents = false);
 
   /// Variant that accepts a Optional value to cache the result.
   ///
   /// @param [in,out] V Return value storage, returned if parameter contains
   /// an existing valid option, else it is used to store a return value
   /// @param [in] Name Name for option to retrieve.
   /// @param [in] DefaultVal Default value returned if no such option was
   /// specified.
   /// @param [in] C The optional checker parameter that can be used to restrict
   /// the search to the options of this particular checker (and its parents
-  /// dependening on search mode).
+  /// depending on search mode).
   /// @param [in] SearchInParents If set to true and the searched option was not
   /// specified for the given checker the options for the parent packages will
   /// be searched as well. The inner packages take precedence over the outer
   /// ones.
   bool getBooleanOption(Optional<bool> &V, StringRef Name, bool DefaultVal,
                         const ento::CheckerBase *C  = nullptr,
                         bool SearchInParents = false);
 
   /// Interprets an option's string value as an integer value.
   ///
   /// If an option value is not provided, returns the given \p DefaultVal.
   /// @param [in] Name Name for option to retrieve.
   /// @param [in] DefaultVal Default value returned if no such option was
   /// specified.
   /// @param [in] C The optional checker parameter that can be used to restrict
   /// the search to the options of this particular checker (and its parents
-  /// dependening on search mode).
+  /// depending on search mode).
   /// @param [in] SearchInParents If set to true and the searched option was not
   /// specified for the given checker the options for the parent packages will
   /// be searched as well. The inner packages take precedence over the outer
   /// ones.
   int getOptionAsInteger(StringRef Name, int DefaultVal,
                          const ento::CheckerBase *C = nullptr,
                          bool SearchInParents = false);
 
   /// Query an option's string value.
   ///
   /// If an option value is not provided, returns the given \p DefaultVal.
   /// @param [in] Name Name for option to retrieve.
   /// @param [in] DefaultVal Default value returned if no such option was
   /// specified.
   /// @param [in] C The optional checker parameter that can be used to restrict
   /// the search to the options of this particular checker (and its parents
-  /// dependening on search mode).
+  /// depending on search mode).
   /// @param [in] SearchInParents If set to true and the searched option was not
   /// specified for the given checker the options for the parent packages will
   /// be searched as well. The inner packages take precedence over the outer
   /// ones.
   StringRef getOptionAsString(StringRef Name, StringRef DefaultVal,
                               const ento::CheckerBase *C = nullptr,
                               bool SearchInParents = false);
 

include/clang/StaticAnalyzer/Core/BugReporter/BugType.h

-//===---  BugType.h - Bug Information Desciption ----------------*- C++ -*-===//
+//===---  BugType.h - Bug Information Description ---------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //

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

 public:
   const static unsigned NoArgRequirement = std::numeric_limits<unsigned>::max();
 
   /// \brief Constructs a CallDescription object.
   ///
   /// @param FuncName The name of the function that will be matched.
   ///
   /// @param RequiredArgs The number of arguments that is expected to match a
-  /// call. Omit this parameter to match every occurance of call with a given
+  /// call. Omit this parameter to match every occurrence of call with a given
   /// name regardless the number of arguments.
   CallDescription(StringRef FuncName, unsigned RequiredArgs = NoArgRequirement)
       : FuncName(FuncName), RequiredArgs(RequiredArgs) {}
 
   /// \brief Get the name of the function that this object matches.
   StringRef getFunctionName() const { return FuncName; }
 };
 

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

protected:
   bool Finalized;
 
   bool HasGeneratedNodes = false;
 
   /// \brief The frontier set - a set of nodes which need to be propagated after
   /// the builder dies.
   ExplodedNodeSet &Frontier;
 
-  /// Checkes if the results are ready.
+  /// Checks if the results are ready.
   virtual bool checkResults() {
     return Finalized;
   }
 
   bool hasNoSinksInFrontier() {
     for (const auto  I : Frontier)
       if (I->isSink())
         return false;

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

private:
   static bool isKind(const NonLoc& V) {
     return V.getSubKind() == LazyCompoundValKind;
   }
 };
 
 /// \brief Value representing pointer-to-member.
 ///
 /// This value is qualified as NonLoc because neither loading nor storing
-/// operations are aplied to it. Instead, the analyzer uses the L-value coming
+/// operations are applied to it. Instead, the analyzer uses the L-value coming
 /// from pointer-to-member applied to an object.
 /// This SVal is represented by a DeclaratorDecl which can be a member function
 /// pointer or a member data pointer and a list of CXXBaseSpecifiers. This list
 /// is required to accumulate the pointer-to-member cast history to figure out
 /// the correct subobject field.
 class PointerToMember : public NonLoc {
   friend class ento::SValBuilder;
 

include/clang/Tooling/FileMatchTrie.h

public:
 
   /// \brief Insert a new absolute path. Relative paths are ignored.
   void insert(StringRef NewPath);
 
   /// \brief Finds the corresponding file in this trie.
   ///
   /// Returns file name stored in this trie that is equivalent to 'FileName'
   /// according to 'Comparator', if it can be uniquely identified. If there
-  /// are no matches an empty \c StringRef is returned. If there are ambigious
+  /// are no matches an empty \c StringRef is returned. If there are ambiguous
   /// matches, an empty \c StringRef is returned and a corresponding message
   /// written to 'Error'.
   StringRef findEquivalent(StringRef FileName,
                            raw_ostream &Error) const;
 
 private:
   FileMatchTrieNode *Root;
   std::unique_ptr<PathComparator> Comparator;
 };
 
 } // namespace tooling
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLING_FILEMATCHTRIE_H

include/clang/Tooling/Refactoring/RefactoringActionRule.h

 
 /// A refactoring action rule is a wrapper class around a specific refactoring
 /// action rule (SourceChangeRefactoringRule, etc) that, in addition to invoking
 /// the action, describes the requirements that determine when the action can be
 /// initiated.
 class RefactoringActionRule : public RefactoringActionRuleBase {
 public:
   /// Returns true when the rule has a source selection requirement that has
-  /// to be fullfilled before refactoring can be performed.
+  /// to be fulfilled before refactoring can be performed.
   virtual bool hasSelectionRequirement() = 0;
 
   /// Traverses each refactoring option used by the rule and invokes the
   /// \c visit callback in the consumer for each option.
   ///
   /// Options are visited in the order of use, e.g. if a rule has two
   /// requirements that use options, the options from the first requirement
   /// are visited before the options in the second requirement.
   virtual void visitRefactoringOptions(RefactoringOptionVisitor &Visitor) = 0;
 };
 
 } // end namespace tooling
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLING_REFACTOR_REFACTORING_ACTION_RULE_H

include/clang/Tooling/Refactoring/RefactoringResultConsumer.h

 /// An abstract interface that consumes the various refactoring results that can
 /// be produced by refactoring actions.
 ///
 /// A valid refactoring result must be handled by a \c handle method.
 class RefactoringResultConsumer {
 public:
   virtual ~RefactoringResultConsumer() {}
 
-  /// Handles an initation or an invication error. An initiation error typically
-  /// has a \c DiagnosticError payload that describes why initation failed.
+  /// Handles an initiation or an invication error. An initiation error typically
+  /// has a \c DiagnosticError payload that describes why initiation failed.
   virtual void handleError(llvm::Error Err) = 0;
 
   /// Handles the source replacements that are produced by a refactoring action.
   virtual void handle(AtomicChanges SourceReplacements) {
     defaultResultHandler();
   }
 
   /// Handles the symbol occurrences that are found by an interactive

include/clang/Tooling/Refactoring/Rename/RenamingAction.h

 private:
   QualifiedRenameRule(const NamedDecl *ND,
                       std::string NewQualifiedName)
       : ND(ND), NewQualifiedName(std::move(NewQualifiedName)) {}
 
   Expected<AtomicChanges>
   createSourceReplacements(RefactoringRuleContext &Context) override;
 
-  // A NamedDecl which indentifies the symbol being renamed.
+  // A NamedDecl which identifies the symbol being renamed.
   const NamedDecl *ND;
   // The new qualified name to change the symbol to.
   std::string NewQualifiedName;
 };
 
 /// Returns source replacements that correspond to the rename of the given
 /// symbol occurrences.
 llvm::Expected<std::vector<AtomicChange>>

include/clang/Tooling/Refactoring/Rename/SymbolName.h

 #include "llvm/ADT/StringRef.h"
 
 namespace clang {
 namespace tooling {
 
 /// A name of a symbol.
 ///
 /// Symbol's name can be composed of multiple strings. For example, Objective-C
-/// methods can contain multiple argument lables:
+/// methods can contain multiple argument labels:
 ///
 /// \code
 /// - (void) myMethodNamePiece: (int)x anotherNamePieces:(int)y;
 /// //       ^~ string 0 ~~~~~         ^~ string 1 ~~~~~
 /// \endcode
 class SymbolName {
 public:
   explicit SymbolName(StringRef Name) {

include/clang/Tooling/Tooling.h

public:
 
   /// \brief Clear the command line arguments adjuster chain.
   void clearArgumentsAdjusters();
 
   /// Runs an action over all files specified in the command line.
   ///
   /// \param Action Tool action.
   ///
-  /// \returns 0 on success; 1 if any error occured; 2 if there is no error but
+  /// \returns 0 on success; 1 if any error occurred; 2 if there is no error but
   /// some files are skipped due to missing compile commands.
   int run(ToolAction *Action);
 
   /// \brief Create an AST for each file specified in the command line and
   /// append them to ASTs.
   int buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs);
 
   /// \brief Returns the file manager used in the tool.

lib/ARCMigrate/ObjCMT.cpp

 }
 
 static bool MatchTwoAttributeLists(const AttrVec &Attrs1, const AttrVec &Attrs2,
                                    bool &AvailabilityArgsMatch) {
   // This list is very small, so this need not be optimized.
   for (unsigned i = 0, e = Attrs1.size(); i != e; i++) {
     bool match = false;
     for (unsigned j = 0, f = Attrs2.size(); j != f; j++) {
-      // Matching attribute kind only. Except for Availabilty attributes,
+      // Matching attribute kind only. Except for Availability attributes,
       // we are not getting into details of the attributes. For all practical purposes
       // this is sufficient.
       if (Attrs1[i]->getKind() == Attrs2[j]->getKind()) {
         if (AvailabilityArgsMatch)
           AvailabilityArgsMatch = AvailabilityAttrsMatch(Attrs1[i], Attrs2[j]);
         match = true;
         break;
       }

lib/AST/ASTContext.cpp

bool ASTContext::QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
   if (!OPT)
     return false;
   if (!IDecl->hasDefinition())
     return false;
   llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocols;
   CollectInheritedProtocols(IDecl, InheritedProtocols);
   if (InheritedProtocols.empty())
     return false;
-  // Check that if every protocol in list of id<plist> conforms to a protcol
+  // Check that if every protocol in list of id<plist> conforms to a protocol
   // of IDecl's, then bridge casting is ok.
   bool Conforms = false;
   for (auto *Proto : OPT->quals()) {
     Conforms = false;
     for (auto *PI : InheritedProtocols) {
       if (ProtocolCompatibleWithProtocol(Proto, PI)) {
         Conforms = true;
         break;
case Type::ObjCObject: {
     if (Ty->isObjCIdType()) {
       S += "{objc_object=}";
       return;
     }
     else if (Ty->isObjCClassType()) {
       S += "{objc_class=}";
       return;
     }
-    // TODO: Double check to make sure this intentially falls through.
+    // TODO: Double check to make sure this intentionally falls through.
     LLVM_FALLTHROUGH;
   }
   
   case Type::ObjCInterface: {
     // Ignore protocol qualifiers when mangling at this level.
     // @encode(class_name)
     ObjCInterfaceDecl *OI = T->castAs<ObjCObjectType>()->getInterface();
     S += '{';
case Type::ObjCObjectPointer: {
     if (OPT->isObjCIdType()) {
       S += '@';
       return;
     }
 
     if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
       // FIXME: Consider if we need to output qualifiers for 'Class<p>'.
       // Since this is a binary compatibility issue, need to consult with runtime
-      // folks. Fortunately, this is a *very* obsure construct.
+      // folks. Fortunately, this is a *very* obscure construct.
       S += '#';
       return;
     }
 
     if (OPT->isObjCQualifiedIdType()) {
       getObjCEncodingForTypeImpl(getObjCIdType(), S,
                                  ExpandPointedToStructures,
                                  ExpandStructures, FD);

lib/AST/DeclCXX.cpp

if (mayBeAbstract()) {
     bool Done = false;
     for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(), 
                                      MEnd = FinalOverriders->end();
          M != MEnd && !Done; ++M) {
       for (OverridingMethods::iterator SO = M->second.begin(), 
                                     SOEnd = M->second.end();
            SO != SOEnd && !Done; ++SO) {
         assert(SO->second.size() > 0 && 
-               "All virtual functions have overridding virtual functions");
+               "All virtual functions have overriding virtual functions");
         
         // C++ [class.abstract]p4:
         //   A class is abstract if it contains or inherits at least one
         //   pure virtual function for which the final overrider is pure
         //   virtual.
         if (SO->second.front().Method->isPure()) {
           data().Abstract = true;
           Done = true;
if ((getNumParams() < 1) ||
       (getDescribedFunctionTemplate() != nullptr))
     return false;
 
   const ParmVarDecl *Param = getParamDecl(0);
 
   ASTContext &Context = getASTContext();
   CanQualType ParamType = Context.getCanonicalType(Param->getType());
   
-  // Is it the same as our our class type?
+  // Is it the same as our class type?
   CanQualType ClassTy 
     = Context.getCanonicalType(Context.getTagDeclType(getParent()));
   if (ParamType.getUnqualifiedType() != ClassTy)
     return false;
   
   return true;  
 }
 

lib/AST/DeclObjC.cpp

 
 static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container,
                                             const ObjCMethodDecl *Method,
                                SmallVectorImpl<const ObjCMethodDecl *> &Methods,
                                             bool MovedToSuper) {
   if (!Container)
     return;
 
-  // In categories look for overriden methods from protocols. A method from
-  // category is not "overriden" since it is considered as the "same" method
+  // In categories look for overridden methods from protocols. A method from
+  // category is not "overridden" since it is considered as the "same" method
   // (same USR) as the one from the interface.
   if (const ObjCCategoryDecl *
         Category = dyn_cast<ObjCCategoryDecl>(Container)) {
     // Check whether we have a matching method at this category but only if we
     // are at the super class level.
     if (MovedToSuper)
       if (ObjCMethodDecl *
             Overridden = Container->getMethod(Method->getSelector(),

lib/AST/MicrosoftMangle.cpp

if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) {
       // to discriminate between named static data initializers in the same
       // scope.  This is handled differently from parameters, which use
       // positions to discriminate between multiple instances.
       if (const auto *MC = BD->getBlockManglingContextDecl())
         if (!isa<ParmVarDecl>(MC))
           if (const auto *ND = dyn_cast<NamedDecl>(MC))
             mangleUnqualifiedName(ND);
       // MS ABI and Itanium manglings are in inverted scopes.  In the case of a
-      // RecordDecl, mangle the entire scope hierachy at this point rather than
+      // RecordDecl, mangle the entire scope hierarchy at this point rather than
       // just the unqualified name to get the ordering correct.
       if (const auto *RD = dyn_cast<RecordDecl>(DC))
         mangleName(RD);
       else
         Out << '@';
       // void __cdecl
       Out << "YAX";
       // struct __block_literal *

lib/AST/Stmt.cpp

static struct StmtClassNameTable {
   unsigned Size;
 } StmtClassInfo[Stmt::lastStmtConstant+1];
 
 static StmtClassNameTable &getStmtInfoTableEntry(Stmt::StmtClass E) {
   static bool Initialized = false;
   if (Initialized)
     return StmtClassInfo[E];
 
-  // Intialize the table on the first use.
+  // Initialize the table on the first use.
   Initialized = true;
 #define ABSTRACT_STMT(STMT)
 #define STMT(CLASS, PARENT) \
   StmtClassInfo[(unsigned)Stmt::CLASS##Class].Name = #CLASS;    \
   StmtClassInfo[(unsigned)Stmt::CLASS##Class].Size = sizeof(CLASS);
 #include "clang/AST/StmtNodes.inc"
 
   return StmtClassInfo[E];

lib/AST/VTableBuilder.cpp

if (OverriddenMD) {
 
         assert(!MethodInfoMap.count(MD) &&
                "Should not have method info for this method yet!");
         MethodInfoMap.insert(std::make_pair(MD, MI));
         continue;
       }
 
       // In case we need a return adjustment, we'll add a new slot for
-      // the overrider. Mark the overriden method as shadowed by the new slot.
+      // the overrider. Mark the overridden method as shadowed by the new slot.
       OverriddenMethodInfo.Shadowed = true;
 
       // Force a special name mangling for a return-adjusting thunk
       // unless the method is the final overrider without this adjustment.
       ForceReturnAdjustmentMangling =
           !(MD == FinalOverriderMD && ThisAdjustmentOffset.isEmpty());
     } else if (Base.getBaseOffset() != WhichVFPtr.FullOffsetInMDC ||
                MD->size_overridden_methods()) {

lib/ASTMatchers/Dynamic/Parser.cpp

for (const auto &Completion : S->getMatcherCompletions(AcceptedTypes)) {
     addCompletion(CompToken, Completion);
   }
 
   for (const auto &Completion : getNamedValueCompletions(AcceptedTypes)) {
     addCompletion(CompToken, Completion);
   }
 }
 
-/// \brief Parse an <Expresssion>
+/// \brief Parse an <Expression>
 bool Parser::parseExpressionImpl(VariantValue *Value) {
   switch (Tokenizer->nextTokenKind()) {
   case TokenInfo::TK_Literal:
     *Value = Tokenizer->consumeNextToken().Value;
     return true;
 
   case TokenInfo::TK_Ident:
     return parseIdentifierPrefixImpl(Value);

lib/Analysis/CloneDetection.cpp

for (CloneDetector::CloneGroup &Group : Sequences) {
 
     // Check for each StmtSequence if its successor has the same hash value.
     // We don't check the last StmtSequence as it has no successor.
     // Note: The 'size - 1 ' in the condition is safe because we check for an
     // empty Group vector at the beginning of this function.
     for (unsigned i = 0; i < StmtsByHash.size() - 1; ++i) {
       const auto Current = StmtsByHash[i];
 
-      // It's likely that we just found an sequence of StmtSequences that
+      // It's likely that we just found a sequence of StmtSequences that
       // represent a CloneGroup, so we create a new group and start checking and
       // adding the StmtSequences in this sequence.
       CloneDetector::CloneGroup NewGroup;
 
       size_t PrototypeHash = Current.first;
 
       for (; i < StmtsByHash.size(); ++i) {
         // A different hash value means we have reached the end of the sequence.

lib/Analysis/ThreadSafetyCommon.cpp

for (auto *Pm : Parms) {
     til::SExpr *Lp = new (Arena) til::LiteralPtr(Pm);
     til::SExpr *Ld = new (Arena) til::Load(Lp);
     til::SExpr *V  = addStatement(Ld, nullptr, Pm);
     addVarDecl(Pm, V);
   }
 }
 
 void SExprBuilder::enterCFGBlock(const CFGBlock *B) {
-  // Intialize TIL basic block and add it to the CFG.
+  // Initialize TIL basic block and add it to the CFG.
   CurrentBB = lookupBlock(B);
   CurrentBB->reservePredecessors(B->pred_size());
   Scfg->add(CurrentBB);
 
   CurrentBlockInfo = &BBInfo[B->getBlockID()];
 
   // CurrentLVarMap is moved to ExitMap on block exit.
   // FIXME: the entry block will hold function parameters.
if (N == 1) {
     auto *Tm = new (Arena) til::Goto(BB, Idx);
     CurrentBB->setTerminator(Tm);
   }
   else if (N == 2) {
     til::SExpr *C = translate(B->getTerminatorCondition(true), nullptr);
     til::BasicBlock *BB1 = *It ? lookupBlock(*It) : nullptr;
     ++It;
     til::BasicBlock *BB2 = *It ? lookupBlock(*It) : nullptr;
-    // FIXME: make sure these arent' critical edges.
+    // FIXME: make sure these aren't critical edges.
     auto *Tm = new (Arena) til::Branch(C, BB1, BB2);
     CurrentBB->setTerminator(Tm);
   }
 }
 
 void SExprBuilder::handleSuccessor(const CFGBlock *Succ) {
   ++CurrentBlockInfo->UnprocessedSuccessors;
 }

lib/Basic/DiagnosticIDs.cpp

if (Result == diag::Severity::Warning && State->IgnoreAllWarnings)
     return diag::Severity::Ignored;
 
   // If -Werror is enabled, map warnings to errors unless explicitly disabled.
   if (Result == diag::Severity::Warning) {
     if (State->WarningsAsErrors && !Mapping.hasNoWarningAsError())
       Result = diag::Severity::Error;
   }
 
-  // If -Wfatal-errors is enabled, map errors to fatal unless explicity
+  // If -Wfatal-errors is enabled, map errors to fatal unless explicitly
   // disabled.
   if (Result == diag::Severity::Error) {
     if (State->ErrorsAsFatal && !Mapping.hasNoErrorAsFatal())
       Result = diag::Severity::Fatal;
   }
 
   // Custom diagnostics always are emitted in system headers.
   bool ShowInSystemHeader =

lib/Basic/SourceManager.cpp

void SourceManager::associateFileChunkWithMacroArgExp(
 
   unsigned EndOffs = BeginOffs + ExpansionLength;
 
   // Add a new chunk for this macro argument. A previous macro argument chunk
   // may have been lexed again, so e.g. if the map is
   //     0   -> SourceLocation()
   //     100 -> Expanded loc #1
   //     110 -> SourceLocation()
-  // and we found a new macro FileID that lexed from offet 105 with length 3,
+  // and we found a new macro FileID that lexed from offset 105 with length 3,
   // the new map will be:
   //     0   -> SourceLocation()
   //     100 -> Expanded loc #1
   //     105 -> Expanded loc #2
   //     108 -> Expanded loc #1
   //     110 -> SourceLocation()
   //
   // Since re-lexed macro chunks will always be the same size or less of

lib/Basic/Targets/PPC.cpp

void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
 
   // ABI options.
   if (ABI == "elfv1" || ABI == "elfv1-qpx")
     Builder.defineMacro("_CALL_ELF", "1");
   if (ABI == "elfv2")
     Builder.defineMacro("_CALL_ELF", "2");
 
   // This typically is only for a new enough linker (bfd >= 2.16.2 or gold), but
-  // our suppport post-dates this and it should work on all 64-bit ppc linux
+  // our support post-dates this and it should work on all 64-bit ppc linux
   // platforms. It is guaranteed to work on all elfv2 platforms.
   if (getTriple().getOS() == llvm::Triple::Linux && PointerWidth == 64)
     Builder.defineMacro("_CALL_LINUX", "1");
 
   // Subtarget options.
   Builder.defineMacro("__NATURAL_ALIGNMENT__");
   Builder.defineMacro("__REGISTER_PREFIX__", "");
 

lib/Basic/Targets/X86.cpp

bool X86TargetInfo::validateAsmConstraint(
   case 'D': // edi.
   case 'A': // edx:eax.
   case 't': // Top of floating point stack.
   case 'u': // Second from top of floating point stack.
   case 'q': // Any register accessible as [r]l: a, b, c, and d.
   case 'y': // Any MMX register.
   case 'v': // Any {X,Y,Z}MM register (Arch & context dependent)
   case 'x': // Any SSE register.
-  case 'k': // Any AVX512 mask register (same as Yk, additionaly allows k0
+  case 'k': // Any AVX512 mask register (same as Yk, additionally allows k0
             // for intermideate k reg operations).
   case 'Q': // Any register accessible as [r]h: a, b, c, and d.
   case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
   case 'l': // "Index" registers: any general register that can be used as an
             // index in a base+index memory access.
     Info.setAllowsRegister();
     return true;
   // Floating point constant constraints.

lib/CodeGen/BackendUtil.cpp

default:
     llvm_unreachable("Invalid optimization level!");
 
   case 1:
     return PassBuilder::O1;
 
   case 2:
     switch (Opts.OptimizeSize) {
     default:
-      llvm_unreachable("Invalide optimization level for size!");
+      llvm_unreachable("Invalid optimization level for size!");
 
     case 0:
       return PassBuilder::O2;
 
     case 1:
       return PassBuilder::Os;
 
     case 2:

lib/CodeGen/CGBlocks.cpp

 static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM,
                                           const CGBlockInfo &blockInfo) {
   return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo);
 }
 
 /// buildBlockDescriptor - Build the block descriptor meta-data for a block.
 /// buildBlockDescriptor is accessed from 5th field of the Block_literal
 /// meta-data and contains stationary information about the block literal.
-/// Its definition will have 4 (or optinally 6) words.
+/// Its definition will have 4 (or optionally 6) words.
 /// \code
 /// struct Block_descriptor {
 ///   unsigned long reserved;
 ///   unsigned long size;  // size of Block_literal metadata in bytes.
 ///   void *copy_func_helper_decl;  // optional copy helper.
 ///   void *destroy_func_decl; // optioanl destructor helper.
 ///   void *block_method_encoding_address; // @encode for block literal signature.
 ///   void *block_layout_info; // encoding of captured block variables.
if (auto *Helper =
         Offset += CGM.getDataLayout().getTypeAllocSize(I);
         elementTypes.push_back(I);
       }
     }
     info.BlockAlign = CharUnits::fromQuantity(BlockAlign);
     info.BlockSize = CharUnits::fromQuantity(Offset);
   } else {
     // The header is basically 'struct { void *; int; int; void *; void *; }'.
-    // Assert that that struct is packed.
+    // Assert that the struct is packed.
     assert(CGM.getIntSize() <= CGM.getPointerSize());
     assert(CGM.getIntAlign() <= CGM.getPointerAlign());
     assert((2 * CGM.getIntSize()).isMultipleOf(CGM.getPointerAlign()));
     info.BlockAlign = CGM.getPointerAlign();
     info.BlockSize = 3 * CGM.getPointerSize() + 2 * CGM.getIntSize();
     elementTypes.push_back(CGM.VoidPtrTy);
     elementTypes.push_back(CGM.IntTy);
     elementTypes.push_back(CGM.IntTy);
if (blockDecl->isConversionFromLambda()) {
       // special; we'll simply emit it directly.
       src = Address::invalid();
     } else if (CI.isByRef()) {
       if (BlockInfo && CI.isNested()) {
         // We need to use the capture from the enclosing block.
         const CGBlockInfo::Capture &enclosingCapture =
             BlockInfo->getCapture(variable);
 
-        // This is a [[type]]*, except that a byref entry wil just be an i8**.
+        // This is a [[type]]*, except that a byref entry will just be an i8**.
         src = Builder.CreateStructGEP(LoadBlockStruct(),
                                       enclosingCapture.getIndex(),
                                       enclosingCapture.getOffset(),
                                       "block.capture.addr");
       } else {
         auto I = LocalDeclMap.find(variable);
         assert(I != LocalDeclMap.end());
         src = I->second;

lib/CodeGen/CGBuiltin.cpp

EncompassingIntegerType(ArrayRef<struct WidthAndSignedness> Types) {
 
   // If any of the given types is signed, we must return a signed type.
   bool Signed = false;
   for (const auto &Type : Types) {
     Signed |= Type.Signed;
   }
 
   // The encompassing type must have a width greater than or equal to the width
-  // of the specified types.  Aditionally, if the encompassing type is signed,
+  // of the specified types.  Additionally, if the encompassing type is signed,
   // its width must be strictly greater than the width of any unsigned types
   // given.
   unsigned Width = 0;
   for (const auto &Type : Types) {
     unsigned MinWidth = Type.Width + (Signed && !Type.Signed);
     if (Width < MinWidth) {
       Width = MinWidth;
     }
CodeGenFunction::emitBuiltinObjectSize(const Expr *E, unsigned Type,
   Value *Ptr = EmittedE ? EmittedE : EmitScalarExpr(E);
   assert(Ptr->getType()->isPointerTy() &&
          "Non-pointer passed to __builtin_object_size?");
 
   Value *F = CGM.getIntrinsic(Intrinsic::objectsize, {ResType, Ptr->getType()});
 
   // LLVM only supports 0 and 2, make sure that we pass along that as a boolean.
   Value *Min = Builder.getInt1((Type & 2) != 0);
-  // For GCC compatability, __builtin_object_size treat NULL as unknown size.
+  // For GCC compatibility, __builtin_object_size treat NULL as unknown size.
   Value *NullIsUnknown = Builder.getTrue();
   return Builder.CreateCall(F, {Ptr, Min, NullIsUnknown});
 }
 
 // Many of MSVC builtins are on both x64 and ARM; to avoid repeating code, we
 // handle them here.
 enum class CodeGenFunction::MSVCIntrin {
   _BitScanForward,
llvm::StoreInst *Store =
                                  StoreSize);
     Store->setAtomic(llvm::AtomicOrdering::Release);
     return RValue::get(nullptr);
   }
 
   case Builtin::BI__sync_synchronize: {
     // We assume this is supposed to correspond to a C++0x-style
     // sequentially-consistent fence (i.e. this is only usable for
-    // synchonization, not device I/O or anything like that). This intrinsic
+    // synchronization, not device I/O or anything like that). This intrinsic
     // is really badly designed in the sense that in theory, there isn't
     // any way to safely use it... but in practice, it mostly works
     // to use it with non-atomic loads and stores to get acquire/release
     // semantics.
     Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent);
     return RValue::get(nullptr);
   }
 

 
   // See if we have a target specific intrinsic.
   const char *Name = getContext().BuiltinInfo.getName(BuiltinID);
   Intrinsic::ID IntrinsicID = Intrinsic::not_intrinsic;
   StringRef Prefix =
       llvm::Triple::getArchTypePrefix(getTarget().getTriple().getArch());
   if (!Prefix.empty()) {
     IntrinsicID = Intrinsic::getIntrinsicForGCCBuiltin(Prefix.data(), Name);
-    // NOTE we dont need to perform a compatibility flag check here since the
+    // NOTE we don't need to perform a compatibility flag check here since the
     // intrinsics are declared in Builtins*.def via LANGBUILTIN which filter the
     // MS builtins via ALL_MS_LANGUAGES and are filtered earlier.
     if (IntrinsicID == Intrinsic::not_intrinsic)
       IntrinsicID = Intrinsic::getIntrinsicForMSBuiltin(Prefix.data(), Name);
   }
 
   if (IntrinsicID != Intrinsic::not_intrinsic) {
     SmallVector<Value*, 16> Args;

lib/CodeGen/CGDebugInfo.cpp

static SmallString<256> getUniqueTagTypeName(const TagType *Ty,
 
   // TODO: This is using the RTTI name. Is there a better way to get
   // a unique string for a type?
   llvm::raw_svector_ostream Out(FullName);
   CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(QualType(Ty, 0), Out);
   return FullName;
 }
 
-/// \return the approproate DWARF tag for a composite type.
+/// \return the appropriate DWARF tag for a composite type.
 static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) {
    llvm::dwarf::Tag Tag;
   if (RD->isStruct() || RD->isInterface())
     Tag = llvm::dwarf::DW_TAG_structure_type;
   else if (RD->isUnion())
     Tag = llvm::dwarf::DW_TAG_union_type;
   else {
     // FIXME: This could be a struct type giving a default visibility different
if (ModRef != ModuleCache.end())
     return cast<llvm::DIModule>(ModRef->second);
 
   // Macro definitions that were defined with "-D" on the command line.
   SmallString<128> ConfigMacros;
   {
     llvm::raw_svector_ostream OS(ConfigMacros);
     const auto &PPOpts = CGM.getPreprocessorOpts();
     unsigned I = 0;
-    // Translate the macro definitions back into a commmand line.
+    // Translate the macro definitions back into a command line.
     for (auto &M : PPOpts.Macros) {
       if (++I > 1)
         OS << " ";
       const std::string &Macro = M.first;
       bool Undef = M.second;
       OS << "\"-" << (Undef ? 'U' : 'D');
       for (char c : Macro)
         switch (c) {
case llvm::dwarf::DW_TAG_enumeration_type:
     // them distinct if they are ODR-uniqued.
     if (FullName.empty())
       break;
     LLVM_FALLTHROUGH;
 
   case llvm::dwarf::DW_TAG_structure_type:
   case llvm::dwarf::DW_TAG_union_type:
   case llvm::dwarf::DW_TAG_class_type:
-    // Immediatley resolve to a distinct node.
+    // Immediately resolve to a distinct node.
     RealDecl =
         llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
     break;
   }
 
   RegionMap[Ty->getDecl()].reset(RealDecl);
   TypeCache[QualType(Ty, 0).getAsOpaquePtr()].reset(RealDecl);
 
if (VD->hasAttr<BlocksAttr>()) {
       Expr.push_back(offset.getQuantity());
     }
   } else if (const auto *RT = dyn_cast<RecordType>(VD->getType())) {
     // If VD is an anonymous union then Storage represents value for
     // all union fields.
     const RecordDecl *RD = RT->getDecl();
     if (RD->isUnion() && RD->isAnonymousStructOrUnion()) {
       // GDB has trouble finding local variables in anonymous unions, so we emit
-      // artifical local variables for each of the members.
+      // artificial local variables for each of the members.
       //
       // FIXME: Remove this code as soon as GDB supports this.
       // The debug info verifier in LLVM operates based on the assumption that a
       // variable has the same size as its storage and we had to disable the check
       // for artificial variables.
       for (const auto *Field : RD->fields()) {
         llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
         StringRef FieldName = Field->getName();

lib/CodeGen/CGExprAgg.cpp

if (Expr *op = findPeephole(E->getSubExpr(), peepholeTarget)) {
       return Visit(op);
     }
 
     // If we're converting an r-value of non-atomic type to an r-value
     // of atomic type, just emit directly into the relevant sub-object.
     if (isToAtomic) {
       AggValueSlot valueDest = Dest;
       if (!valueDest.isIgnored() && CGF.CGM.isPaddedAtomicType(atomicType)) {
-        // Zero-initialize.  (Strictly speaking, we only need to intialize
+        // Zero-initialize.  (Strictly speaking, we only need to initialize
         // the padding at the end, but this is simpler.)
         if (!Dest.isZeroed())
           CGF.EmitNullInitialization(Dest.getAddress(), atomicType);
 
         // Build a GEP to refer to the subobject.
         Address valueAddr =
             CGF.Builder.CreateStructGEP(valueDest.getAddress(), 0,
                                         CharUnits());

lib/CodeGen/CGExprComplex.cpp

ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
   if (E->getNumInits() == 2) {
     llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0));
     llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1));
     return ComplexPairTy(Real, Imag);
   } else if (E->getNumInits() == 1) {
     return Visit(E->getInit(0));
   }
 
-  // Empty init list intializes to null
+  // Empty init list initializes to null
   assert(E->getNumInits() == 0 && "Unexpected number of inits");
   QualType Ty = E->getType()->castAs<ComplexType>()->getElementType();
   llvm::Type* LTy = CGF.ConvertType(Ty);
   llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
   return ComplexPairTy(zeroConstant, zeroConstant);
 }
 
 ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {

lib/CodeGen/CGObjCMac.cpp

IvarOffsetValue = CGF.Builder.CreateAlignedLoad(IvarOffsetValue,
                                                   CGF.getSizeAlign(), "ivar");
   if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
     cast<llvm::LoadInst>(IvarOffsetValue)
         ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
                       llvm::MDNode::get(VMContext, None));
 
   // This could be 32bit int or 64bit integer depending on the architecture.
   // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
-  //  as this is what caller always expectes.
+  //  as this is what caller always expects.
   if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
     IvarOffsetValue = CGF.Builder.CreateIntCast(
         IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
   return IvarOffsetValue;
 }
 
 static void appendSelectorForMessageRefTable(std::string &buffer,
                                              Selector selector) {

lib/CodeGen/CGOpenCLRuntime.h

virtual void EmitWorkGroupLocalVarDecl(CodeGenFunction &CGF,
                                          const VarDecl &D);
 
   virtual llvm::Type *convertOpenCLSpecificType(const Type *T);
 
   virtual llvm::Type *getPipeType(const PipeType *T);
 
   llvm::PointerType *getSamplerType(const Type *T);
 
-  // \brief Returnes a value which indicates the size in bytes of the pipe
+  // \brief Returns a value which indicates the size in bytes of the pipe
   // element.
   virtual llvm::Value *getPipeElemSize(const Expr *PipeArg);
 
-  // \brief Returnes a value which indicates the alignment in bytes of the pipe
+  // \brief Returns a value which indicates the alignment in bytes of the pipe
   // element.
   virtual llvm::Value *getPipeElemAlign(const Expr *PipeArg);
 
   /// \return __generic void* type.
   llvm::PointerType *getGenericVoidPointerType();
 
   /// \return enqueued block information for enqueued block.
   EnqueuedBlockInfo emitOpenCLEnqueuedBlock(CodeGenFunction &CGF,

lib/CodeGen/CGOpenMPRuntime.h

private:
 
   /// List of addresses of original shared variables/expressions.
   SmallVector<std::pair<LValue, LValue>, 4> SharedAddresses;
   /// Sizes of the reduction items in chars.
   SmallVector<std::pair<llvm::Value *, llvm::Value *>, 4> Sizes;
   /// Base declarations for the reduction items.
   SmallVector<const VarDecl *, 4> BaseDecls;
 
-  /// Emits lvalue for shared expresion.
+  /// Emits lvalue for shared expression.
   LValue emitSharedLValue(CodeGenFunction &CGF, const Expr *E);
   /// Emits upper bound for shared expression (if array section).
   LValue emitSharedLValueUB(CodeGenFunction &CGF, const Expr *E);
   /// Performs aggregate initialization.
   /// \param N Number of reduction item in the common list.
   /// \param PrivateAddr Address of the corresponding private item.
   /// \param SharedLVal Address of the original shared variable.
   /// \param DRD Declare reduction construct used for reduction item.
public:
 
   /// Emit code for doacross ordered directive with 'depend' clause.
   /// \param C 'depend' clause with 'sink|source' dependency kind.
   virtual void emitDoacrossOrdered(CodeGenFunction &CGF,
                                    const OMPDependClause *C);
 
   /// Translates the native parameter of outlined function if this is required
   /// for target.
-  /// \param FD Field decl from captured record for the paramater.
+  /// \param FD Field decl from captured record for the parameter.
   /// \param NativeParam Parameter itself.
   virtual const VarDecl *translateParameter(const FieldDecl *FD,
                                             const VarDecl *NativeParam) const {
     return NativeParam;
   }
 
   /// Gets the address of the native argument basing on the address of the
   /// target-specific parameter.
public:
 
   /// Emit code for doacross ordered directive with 'depend' clause.
   /// \param C 'depend' clause with 'sink|source' dependency kind.
   void emitDoacrossOrdered(CodeGenFunction &CGF,
                            const OMPDependClause *C) override;
 
   /// Translates the native parameter of outlined function if this is required
   /// for target.
-  /// \param FD Field decl from captured record for the paramater.
+  /// \param FD Field decl from captured record for the parameter.
   /// \param NativeParam Parameter itself.
   const VarDecl *translateParameter(const FieldDecl *FD,
                                     const VarDecl *NativeParam) const override;
 
   /// Gets the address of the native argument basing on the address of the
   /// target-specific parameter.
   /// \param NativeParam Parameter itself.
   /// \param TargetParam Corresponding target-specific parameter.
   Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam,
                               const VarDecl *TargetParam) const override;
 };
 
 } // namespace CodeGen
 } // namespace clang
 
 #endif

lib/CodeGen/CGOpenMPRuntime.cpp

void CGOpenMPRuntime::createOffloadEntriesAndInfoMetadata() {
   // can easily figure out what to emit. The produced metadata looks like
   // this:
   //
   // !omp_offload.info = !{!1, ...}
   //
   // Right now we only generate metadata for function that contain target
   // regions.
 
-  // If we do not have entries, we dont need to do anything.
+  // If we do not have entries, we don't need to do anything.
   if (OffloadEntriesInfoManager.empty())
     return;
 
   llvm::Module &M = CGM.getModule();
   llvm::LLVMContext &C = M.getContext();
   SmallVector<const OffloadEntriesInfoManagerTy::OffloadEntryInfo *, 16>
       OrderedEntries(OffloadEntriesInfoManager.size());
 
for (unsigned i = 0; i < NumDependencies; ++i) {
       CGF.EmitStoreOfScalar(llvm::ConstantInt::get(LLVMFlagsTy, DepKind),
                             FlagsLVal);
     }
     DependenciesArray = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
         CGF.Builder.CreateStructGEP(DependenciesArray, 0, CharUnits::Zero()),
         CGF.VoidPtrTy);
   }
 
-  // NOTE: routine and part_id fields are intialized by __kmpc_omp_task_alloc()
+  // NOTE: routine and part_id fields are initialized by __kmpc_omp_task_alloc()
   // libcall.
   // Build kmp_int32 __kmpc_omp_task_with_deps(ident_t *, kmp_int32 gtid,
   // kmp_task_t *new_task, kmp_int32 ndeps, kmp_depend_info_t *dep_list,
   // kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list) if dependence
   // list is not empty
   auto *ThreadID = getThreadID(CGF, Loc);
   auto *UpLoc = emitUpdateLocation(CGF, Loc);
   llvm::Value *TaskArgs[] = { UpLoc, ThreadID, NewTask };
void CGOpenMPRuntime::emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc,
                                        llvm::Value *TaskFunction,
                                        QualType SharedsTy, Address Shareds,
                                        const Expr *IfCond,
                                        const OMPTaskDataTy &Data) {
   if (!CGF.HaveInsertPoint())
     return;
   TaskResultTy Result =
       emitTaskInit(CGF, Loc, D, TaskFunction, SharedsTy, Shareds, Data);
-  // NOTE: routine and part_id fields are intialized by __kmpc_omp_task_alloc()
+  // NOTE: routine and part_id fields are initialized by __kmpc_omp_task_alloc()
   // libcall.
   // Call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t *task, int
   // if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int nogroup, int
   // sched, kmp_uint64 grainsize, void *task_dup);
   llvm::Value *ThreadID = getThreadID(CGF, Loc);
   llvm::Value *UpLoc = emitUpdateLocation(CGF, Loc);
   llvm::Value *IfVal;
   if (IfCond) {
public:
   void generateInfoForComponentList(
       OpenMPMapClauseKind MapType, OpenMPMapClauseKind MapTypeModifier,
       OMPClauseMappableExprCommon::MappableExprComponentListRef Components,
       MapBaseValuesArrayTy &BasePointers, MapValuesArrayTy &Pointers,
       MapValuesArrayTy &Sizes, MapFlagsArrayTy &Types,
       bool IsFirstComponentList, bool IsImplicit) const {
 
     // The following summarizes what has to be generated for each map and the
-    // types bellow. The generated information is expressed in this order:
+    // types below. The generated information is expressed in this order:
     // base pointer, section pointer, size, flags
     // (to add to the ones that come from the map type and modifier).
     //
     // double d;
     // int i[100];
     // float *p;
     //
     // struct S1 {

lib/CodeGen/CGOpenMPRuntimeNVPTX.h

public:
   /// Returns specified OpenMP runtime function for the current OpenMP
   /// implementation.  Specialized for the NVPTX device.
   /// \param Function OpenMP runtime function.
   /// \return Specified function.
   llvm::Constant *createNVPTXRuntimeFunction(unsigned Function);
 
   /// Translates the native parameter of outlined function if this is required
   /// for target.
-  /// \param FD Field decl from captured record for the paramater.
+  /// \param FD Field decl from captured record for the parameter.
   /// \param NativeParam Parameter itself.
   const VarDecl *translateParameter(const FieldDecl *FD,
                                     const VarDecl *NativeParam) const override;
 
   /// Gets the address of the native argument basing on the address of the
   /// target-specific parameter.
   /// \param NativeParam Parameter itself.
   /// \param TargetParam Corresponding target-specific parameter.

lib/CodeGen/CGRecordLayoutBuilder.cpp

 ///   a zero sized (empty struct) storage type.
 /// * Clang reads the complete type rather than the base type when generating
 ///   code to access fields.  Bitfields in tail position with tail padding may
 ///   be clipped in the base class but not the complete class (we may discover
 ///   that the tail padding is not used in the complete class.) However,
 ///   because LLVM reads from the complete type it can generate incorrect code
 ///   if we do not clip the tail padding off of the bitfield in the complete
 ///   layout.  This introduces a somewhat awkward extra unnecessary clip stage.
-///   The location of the clip is stored internally as a sentinal of type
+///   The location of the clip is stored internally as a sentinel of type
 ///   SCISSOR.  If LLVM were updated to read base types (which it probably
 ///   should because locations of things such as VBases are bogus in the llvm
 ///   type anyway) then we could eliminate the SCISSOR.
 /// * Itanium allows nearly empty primary virtual bases.  These bases don't get
 ///   get their own storage because they're laid out as part of another base
 ///   or at the beginning of the structure.  Determining if a VBase actually
 ///   gets storage awkwardly involves a walk of all bases.
 /// * VFPtrs and VBPtrs do *not* make a record NotZeroInitializable.
 struct CGRecordLowering {
   // MemberInfo is a helper structure that contains information about a record
   // member.  In additional to the standard member types, there exists a
-  // sentinal member type that ensures correct rounding.
+  // sentinel member type that ensures correct rounding.
   struct MemberInfo {
     CharUnits Offset;
     enum InfoKind { VFPtr, VBPtr, Field, Base, VBase, Scissor } Kind;
     llvm::Type *Data;
     union {
       const FieldDecl *FD;
       const CXXRecordDecl *RD;
     };
struct CGRecordLowering {
   /// not the primary vbase of some base class.
   bool hasOwnStorage(const CXXRecordDecl *Decl, const CXXRecordDecl *Query);
   void calculateZeroInit();
   /// \brief Lowers bitfield storage types to I8 arrays for bitfields with tail
   /// padding that is or can potentially be used.
   void clipTailPadding();
   /// \brief Determines if we need a packed llvm struct.
   void determinePacked(bool NVBaseType);
-  /// \brief Inserts padding everwhere it's needed.
+  /// \brief Inserts padding everywhere it's needed.
   void insertPadding();
   /// \brief Fills out the structures that are ultimately consumed.
   void fillOutputFields();
   // Input memoization fields.
   CodeGenTypes &Types;
   const ASTContext &Context;
   const RecordDecl *D;
   const CXXRecordDecl *RD;
void CGRecordLowering::determinePacked(bool NVBaseType) {
   // record's alignment, it must be packed.
   if (Members.back().Offset % Alignment)
     Packed = true;
   // If the non-virtual sub-object is not a multiple of the non-virtual
   // sub-object's alignment, it must be packed.  We cannot have a packed
   // non-virtual sub-object and an unpacked complete object or vise versa.
   if (NVSize % NVAlignment)
     Packed = true;
-  // Update the alignment of the sentinal.
+  // Update the alignment of the sentinel.
   if (!Packed)
     Members.back().Data = getIntNType(Context.toBits(Alignment));
 }
 
 void CGRecordLowering::insertPadding() {
   std::vector<std::pair<CharUnits, CharUnits> > Padding;
   CharUnits Size = CharUnits::Zero();
   for (std::vector<MemberInfo>::const_iterator Member = Members.begin(),

lib/CodeGen/CGStmt.cpp

void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) {
   }
 
   // Returning from an outlined SEH helper is UB, and we already warn on it.
   if (IsOutlinedSEHHelper) {
     Builder.CreateUnreachable();
     Builder.ClearInsertionPoint();
   }
 
-  // Emit the result value, even if unused, to evalute the side effects.
+  // Emit the result value, even if unused, to evaluate the side effects.
   const Expr *RV = S.getRetValue();
 
   // Treat block literals in a return expression as if they appeared
   // in their own scope.  This permits a small, easily-implemented
   // exception to our over-conservative rules about not jumping to
   // statements following block literals with non-trivial cleanups.
   RunCleanupsScope cleanupScope(*this);
   if (const ExprWithCleanups *cleanups =

lib/CodeGen/CGStmtOpenMP.cpp

bool IsRegistered = PrivateScope.addPrivate(OrigVD, [&]() -> Address {
       Address InitAddr = Builder.CreateBitCast(InitAddrIt->second, AddrTy);
       setAddrOfLocalVar(InitVD, InitAddr);
 
       // Emit private declaration, it will be initialized by the value we
       // declaration we just added to the local declarations map.
       EmitDecl(*PvtVD);
 
       // The initialization variables reached its purpose in the emission
-      // ofthe previous declaration, so we don't need it anymore.
+      // of the previous declaration, so we don't need it anymore.
       LocalDeclMap.erase(InitVD);
 
       // Return the address of the private variable.
       return GetAddrOfLocalVar(PvtVD);
     });
     assert(IsRegistered && "firstprivate var already registered as private");
     // Silence the warning about unused variable.
     (void)IsRegistered;
void CodeGenFunction::EmitOMPTargetDataDirective(
   DevicePointerPrivActionTy PrivAction(PrivatizeDevicePointers);
 
   auto &&CodeGen = [&S, &Info, &PrivatizeDevicePointers](
                        CodeGenFunction &CGF, PrePostActionTy &Action) {
     auto &&InnermostCodeGen = [&S](CodeGenFunction &CGF, PrePostActionTy &) {
       CGF.EmitStmt(S.getInnermostCapturedStmt()->getCapturedStmt());
     };
 
-    // Codegen that selects wheather to generate the privatization code or not.
+    // Codegen that selects whether to generate the privatization code or not.
     auto &&PrivCodeGen = [&S, &Info, &PrivatizeDevicePointers,
                           &InnermostCodeGen](CodeGenFunction &CGF,
                                              PrePostActionTy &Action) {
       RegionCodeGenTy RCG(InnermostCodeGen);
       PrivatizeDevicePointers = false;
 
       // Call the pre-action to change the status of PrivatizeDevicePointers if
       // needed.

lib/CodeGen/CGVTables.cpp

switch (RD->getTemplateSpecializationKind()) {
 
     case TSK_ExplicitInstantiationDefinition:
       return NonDiscardableODRLinkage;
   }
 
   llvm_unreachable("Invalid TemplateSpecializationKind!");
 }
 
-/// This is a callback from Sema to tell us that that a particular vtable is
+/// This is a callback from Sema to tell us that a particular vtable is
 /// required to be emitted in this translation unit.
 ///
 /// This is only called for vtables that _must_ be emitted (mainly due to key
 /// functions).  For weak vtables, CodeGen tracks when they are needed and
 /// emits them as-needed.
 void CodeGenModule::EmitVTable(CXXRecordDecl *theClass) {
   VTables.GenerateClassData(theClass);
 }

lib/CodeGen/CodeGenFunction.h

private:
   llvm::BasicBlock *TrapBB;
 
   /// Terminate funclets keyed by parent funclet pad.
   llvm::MapVector<llvm::Value *, llvm::BasicBlock *> TerminateFunclets;
 
   /// True if we need emit the life-time markers.
   const bool ShouldEmitLifetimeMarkers;
 
-  /// Add OpenCL kernel arg metadata and the kernel attribute meatadata to
+  /// Add OpenCL kernel arg metadata and the kernel attribute metadata to
   /// the function metadata.
   void EmitOpenCLKernelMetadata(const FunctionDecl *FD,
                                 llvm::Function *Fn);
 
 public:
   CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false);
   ~CodeGenFunction();
 
llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn,
                                        const CGFunctionInfo &FnInfo,
                                        GlobalDecl GD, const ThunkInfo &Thunk);
 
   void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type,
                         FunctionArgList &Args);
 
   void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init);
 
-  /// Struct with all informations about dynamic [sub]class needed to set vptr.
+  /// Struct with all information about dynamic [sub]class needed to set vptr.
   struct VPtr {
     BaseSubobject Base;
     const CXXRecordDecl *NearestVBase;
     CharUnits OffsetFromNearestVBase;
     const CXXRecordDecl *VTableClass;
   };
 
   /// Initialize the vtable pointer of the given subobject.

lib/CodeGen/CodeGenModule.h

public:
   ///
   /// For languages without explicit address spaces, if D has default address
   /// space, target-specific global or constant address space may be returned.
   LangAS GetGlobalVarAddressSpace(const VarDecl *D);
 
   /// Return the llvm::Constant for the address of the given global variable.
   /// If Ty is non-null and if the global doesn't exist, then it will be created
   /// with the specified type instead of whatever the normal requested type
-  /// would be. If IsForDefinition is true, it is guranteed that an actual
+  /// would be. If IsForDefinition is true, it is guaranteed that an actual
   /// global with type Ty will be returned, not conversion of a variable with
   /// the same mangled name but some other type.
   llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D,
                                      llvm::Type *Ty = nullptr,
                                      ForDefinition_t IsForDefinition
                                        = NotForDefinition);
 
   /// Return the address of the given function. If Ty is non-null, then this
public:
   SanitizerMetadata *getSanitizerMetadata() {
     return SanitizerMD.get();
   }
 
   void addDeferredVTable(const CXXRecordDecl *RD) {
     DeferredVTables.push_back(RD);
   }
 
-  /// Emit code for a singal global function or var decl. Forward declarations
+  /// Emit code for a single global function or var decl. Forward declarations
   /// are emitted lazily.
   void EmitGlobal(GlobalDecl D);
 
   bool TryEmitDefinitionAsAlias(GlobalDecl Alias, GlobalDecl Target);
   bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D);
 
   llvm::GlobalValue *GetGlobalValue(StringRef Ref);
 

lib/CodeGen/CodeGenModule.cpp

 /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
 /// create and return an llvm GlobalVariable with the specified type.  If there
 /// is something in the module with the specified name, return it potentially
 /// bitcasted to the right type.
 ///
 /// If D is non-null, it specifies a decl that correspond to this.  This is used
 /// to set the attributes on the global when it is first created.
 ///
-/// If IsForDefinition is true, it is guranteed that an actual global with
+/// If IsForDefinition is true, it is guaranteed that an actual global with
 /// type Ty will be returned, not conversion of a variable with the same
 /// mangled name but some other type.
 llvm::Constant *
 CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
                                      llvm::PointerType *Ty,
                                      const VarDecl *D,
                                      ForDefinition_t IsForDefinition) {
   // Lookup the entry, lazily creating it if necessary.
if (supportsCOMDAT() && GV->isWeakForLinker() &&
     GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
 
   return GV;
 }
 
 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
 /// given global variable.  If Ty is non-null and if the global doesn't exist,
 /// then it will be created with the specified type instead of whatever the
-/// normal requested type would be. If IsForDefinition is true, it is guranteed
+/// normal requested type would be. If IsForDefinition is true, it is guaranteed
 /// that an actual global with type Ty will be returned, not conversion of a
 /// variable with the same mangled name but some other type.
 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
                                                   llvm::Type *Ty,
                                            ForDefinition_t IsForDefinition) {
   assert(D->hasGlobalStorage() && "Not a global variable");
   QualType ASTTy = D->getType();
   if (!Ty)
static bool isVarDeclStrongDefinition(const ASTContext &Context,
   if (D->getInit() || D->hasExternalStorage())
     return true;
 
   // A variable cannot be both common and exist in a section.
   if (D->hasAttr<SectionAttr>())
     return true;
 
   // A variable cannot be both common and exist in a section.
-  // We dont try to determine which is the right section in the front-end.
+  // We don't try to determine which is the right section in the front-end.
   // If no specialized section name is applicable, it will resort to default.
   if (D->hasAttr<PragmaClangBSSSectionAttr>() ||
       D->hasAttr<PragmaClangDataSectionAttr>() ||
       D->hasAttr<PragmaClangRodataSectionAttr>())
     return true;
 
   // Thread local vars aren't considered common linkage.
   if (D->getTLSKind())
ConstantAddress CodeGenModule::GetAddrOfGlobalTemporary(
   // Create a global variable for this lifetime-extended temporary.
   llvm::GlobalValue::LinkageTypes Linkage =
       getLLVMLinkageVarDefinition(VD, Constant);
   if (Linkage == llvm::GlobalVariable::ExternalLinkage) {
     const VarDecl *InitVD;
     if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
         isa<CXXRecordDecl>(InitVD->getLexicalDeclContext())) {
       // Temporaries defined inside a class get linkonce_odr linkage because the
-      // class can be defined in multipe translation units.
+      // class can be defined in multiple translation units.
       Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
     } else {
       // There is no need for this temporary to have external linkage if the
       // VarDecl has external linkage.
       Linkage = llvm::GlobalVariable::InternalLinkage;
     }
   }
   auto TargetAS = getContext().getTargetAddressSpace(AddrSpace);

lib/CodeGen/CoverageMappingGen.cpp

for (const auto &I : SkippedRanges) {
 
       auto CovFileID = getCoverageFileID(LocStart);
       if (!CovFileID)
         continue;
       SpellingRegion SR{SM, LocStart, LocEnd};
       auto Region = CounterMappingRegion::makeSkipped(
           *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd);
       // Make sure that we only collect the regions that are inside
-      // the souce code of this function.
+      // the source code of this function.
       if (Region.LineStart >= FileLineRanges[*CovFileID].first &&
           Region.LineEnd <= FileLineRanges[*CovFileID].second)
         MappingRegions.push_back(Region);
     }
   }
 
   /// \brief Generate the coverage counter mapping regions from collected
   /// source regions.

lib/CodeGen/ItaniumCXXABI.cpp

 }
 
 void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
   // Naked functions have no prolog.
   if (CGF.CurFuncDecl && CGF.CurFuncDecl->hasAttr<NakedAttr>())
     return;
 
   /// Initialize the 'this' slot. In the Itanium C++ ABI, no prologue
-  /// adjustments are required, becuase they are all handled by thunks.
+  /// adjustments are required, because they are all handled by thunks.
   setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));
 
   /// Initialize the 'vtt' slot if needed.
   if (getStructorImplicitParamDecl(CGF)) {
     getStructorImplicitParamValue(CGF) = CGF.Builder.CreateLoad(
         CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), "vtt");
   }
 

lib/CodeGen/MicrosoftCXXABI.cpp

 //
 // ClassHieararchyDescriptor: Contains information about a class hierarchy.
 //   Used during dynamic_cast to walk a class hierarchy.  References a base
 //   class array and the size of said array.
 //
 // BaseClassArray: Contains a list of classes in a hierarchy.  BaseClassArray is
 //   somewhat of a misnomer because the most derived class is also in the list
 //   as well as multiple copies of virtual bases (if they occur multiple times
-//   in the hiearchy.)  The BaseClassArray contains one BaseClassDescriptor for
+//   in the hierarchy.)  The BaseClassArray contains one BaseClassDescriptor for
 //   every path in the hierarchy, in pre-order depth first order.  Note, we do
 //   not declare a specific llvm type for BaseClassArray, it's merely an array
 //   of BaseClassDescriptor pointers.
 //
 // BaseClassDescriptor: Contains information about a class in a class hierarchy.
 //   BaseClassDescriptor is also somewhat of a misnomer for the same reason that
 //   BaseClassArray is.  It contains information about a class within a
 //   hierarchy such as: is this base is ambiguous and what is its offset in the
MicrosoftCXXABI::getAddrOfCXXCtorClosure(const CXXConstructorDecl *CD,
 
   // Constructors for classes which utilize virtual bases have an additional
   // parameter which indicates whether or not it is being delegated to by a more
   // derived constructor.
   ImplicitParamDecl IsMostDerived(getContext(), /*DC=*/nullptr,
                                   SourceLocation(),
                                   &getContext().Idents.get("is_most_derived"),
                                   getContext().IntTy, ImplicitParamDecl::Other);
-  // Only add the parameter to the list if thie class has virtual bases.
+  // Only add the parameter to the list if the class has virtual bases.
   if (RD->getNumVBases() > 0)
     FunctionArgs.push_back(&IsMostDerived);
 
   // Start defining the function.
   auto NL = ApplyDebugLocation::CreateEmpty(CGF);
   CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo,
                     FunctionArgs, CD->getLocation(), SourceLocation());
   // Create a scope with an artificial location for the body of this function.

lib/CodeGen/TargetInfo.h

virtual llvm::Constant *performAddrSpaceCast(CodeGenModule &CGM,
                                                llvm::Constant *V,
                                                LangAS SrcAddr, LangAS DestAddr,
                                                llvm::Type *DestTy) const;
 
   /// Get the syncscope used in LLVM IR.
   virtual llvm::SyncScope::ID getLLVMSyncScopeID(SyncScope S,
                                                  llvm::LLVMContext &C) const;
 
-  /// Inteface class for filling custom fields of a block literal for OpenCL.
+  /// Interface class for filling custom fields of a block literal for OpenCL.
   class TargetOpenCLBlockHelper {
   public:
     typedef std::pair<llvm::Value *, StringRef> ValueTy;
     TargetOpenCLBlockHelper() {}
     virtual ~TargetOpenCLBlockHelper() {}
     /// Get the custom field types for OpenCL blocks.
     virtual llvm::SmallVector<llvm::Type *, 1> getCustomFieldTypes() = 0;
     /// Get the custom field values for OpenCL blocks.

lib/CodeGen/VarBypassDetector.cpp

for (auto *I : DS->decls())
       if (!BuildScopeInformation(I, origParentScope))
         return false;
     return true;
   }
 
   case Stmt::CaseStmtClass:
   case Stmt::DefaultStmtClass:
   case Stmt::LabelStmtClass:
-    llvm_unreachable("the loop bellow handles labels and cases");
+    llvm_unreachable("the loop below handles labels and cases");
     break;
 
   default:
     break;
   }
 
   for (const Stmt *SubStmt : S->children()) {
     if (!SubStmt)

lib/Driver/Driver.cpp

static llvm::Triple computeTargetTriple(const Driver &D,
   // FIXME: Already done in Compilation *Driver::BuildCompilation
   if (const Arg *A = Args.getLastArg(options::OPT_target))
     DefaultTargetTriple = A->getValue();
 
   llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
 
   // Handle Apple-specific options available here.
   if (Target.isOSBinFormatMachO()) {
-    // If an explict Darwin arch name is given, that trumps all.
+    // If an explicit Darwin arch name is given, that trumps all.
     if (!DarwinArchName.empty()) {
       tools::darwin::setTripleTypeForMachOArchName(Target, DarwinArchName);
       return Target;
     }
 
     // Handle the Darwin '-arch' flag.
     if (Arg *A = Args.getLastArg(options::OPT_arch)) {
       StringRef ArchName = A->getValue();

lib/Driver/ToolChains/Arch/ARM.cpp

void arm::getARMTargetFeatures(const ToolChain &TC,
   // Setting -msoft-float/-mfloat-abi=soft effectively disables the FPU (GCC
   // ignores the -mfpu options in this case).
   // Note that the ABI can also be set implicitly by the target selected.
   if (ABI == arm::FloatABI::Soft) {
     llvm::ARM::getFPUFeatures(llvm::ARM::FK_NONE, Features);
 
     // Disable hardware FP features which have been enabled.
     // FIXME: Disabling vfp2 and neon should be enough as all the other
-    //        features are dependant on these 2 features in LLVM. However
+    //        features are dependent on these 2 features in LLVM. However
     //        there is currently no easy way to test this in clang, so for
     //        now just be explicit and disable all known dependent features
     //        as well.
     for (std::string Feature : {"vfp2", "vfp3", "vfp4", "fp-armv8", "fullfp16",
                                 "neon", "crypto", "dotprod"})
       if (std::find(std::begin(Features), std::end(Features), "+" + Feature) != std::end(Features))
         Features.push_back(Args.MakeArgString("-" + Feature));
   }

lib/Driver/ToolChains/Clang.cpp

if (ABIName) {
     CmdArgs.push_back("-target-abi");
     CmdArgs.push_back(ABIName);
   }
 }
 
 void Clang::AddRISCVTargetArgs(const ArgList &Args,
                                ArgStringList &CmdArgs) const {
   // FIXME: currently defaults to the soft-float ABIs. Will need to be
-  // expanded to select ilp32f, ilp32d, lp64f, lp64d when appropiate.
+  // expanded to select ilp32f, ilp32d, lp64f, lp64d when appropriate.
   const char *ABIName = nullptr;
   const llvm::Triple &Triple = getToolChain().getTriple();
   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
     ABIName = A->getValue();
   else if (Triple.getArch() == llvm::Triple::riscv32)
     ABIName = "ilp32";
   else if (Triple.getArch() == llvm::Triple::riscv64)
     ABIName = "lp64";

 }
 
 static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
                                        bool OFastEnabled, const ArgList &Args,
                                        ArgStringList &CmdArgs) {
   // Handle various floating point optimization flags, mapping them to the
   // appropriate LLVM code generation flags. This is complicated by several
   // "umbrella" flags, so we do this by stepping through the flags incrementally
-  // adjusting what we think is enabled/disabled, then at the end settting the
+  // adjusting what we think is enabled/disabled, then at the end setting the
   // LLVM flags based on the final state.
   bool HonorINFs = true;
   bool HonorNaNs = true;
   // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
   bool MathErrno = TC.IsMathErrnoDefault();
   bool AssociativeMath = false;
   bool ReciprocalMath = false;
   bool SignedZeros = true;
#endif
 
   // -fthreadsafe-static is default, except for MSVC compatibility versions less
   // than 19.
   if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
                     options::OPT_fno_threadsafe_statics,
                     !IsWindowsMSVC || IsMSVC2015Compatible))
     CmdArgs.push_back("-fno-threadsafe-statics");
 
-  // -fno-delayed-template-parsing is default, except when targetting MSVC.
+  // -fno-delayed-template-parsing is default, except when targeting MSVC.
   // Many old Windows SDK versions require this to parse.
   // FIXME: MSVC introduced /Zc:twoPhase- to disable this behavior in their
   // compiler. We should be able to disable this by default at some point.
   if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
                    options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
     CmdArgs.push_back("-fdelayed-template-parsing");
 
   // -fgnu-keywords default varies depending on language; only pass if

lib/Driver/ToolChains/CommonArgs.cpp

tools::ParsePICArgs(const ToolChain &ToolChain, const ArgList &Args) {
   Arg *LastRWPIArg = Args.getLastArg(options::OPT_frwpi, options::OPT_fno_rwpi);
   if (LastRWPIArg && LastRWPIArg->getOption().matches(options::OPT_frwpi)) {
     if (!EmbeddedPISupported)
       ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
           << LastRWPIArg->getSpelling() << Triple.str();
     RWPI = true;
   }
 
-  // ROPI and RWPI are not comaptible with PIC or PIE.
+  // ROPI and RWPI are not compatible with PIC or PIE.
   if ((ROPI || RWPI) && (PIC || PIE))
     ToolChain.getDriver().Diag(diag::err_drv_ropi_rwpi_incompatible_with_pic);
 
   // When targettng MIPS64 with N64, the default is PIC, unless -mno-abicalls is
   // used.
   if ((Triple.getArch() == llvm::Triple::mips64 ||
        Triple.getArch() == llvm::Triple::mips64el) &&
       Args.hasArg(options::OPT_mno_abicalls))

lib/Driver/ToolChains/Cuda.cpp

if (Version >= CudaVersion::CUDA_90) {
         // Process all bitcode filenames that look like
         // libdevice.compute_XX.YY.bc
         const StringRef LibDeviceName = "libdevice.";
         if (!(FileName.startswith(LibDeviceName) && FileName.endswith(".bc")))
           continue;
         StringRef GpuArch = FileName.slice(
             LibDeviceName.size(), FileName.find('.', LibDeviceName.size()));
         LibDeviceMap[GpuArch] = FilePath.str();
-        // Insert map entries for specifc devices with this compute
+        // Insert map entries for specific devices with this compute
         // capability. NVCC's choice of the libdevice library version is
         // rather peculiar and depends on the CUDA version.
         if (GpuArch == "compute_20") {
           LibDeviceMap["sm_20"] = FilePath;
           LibDeviceMap["sm_21"] = FilePath;
           LibDeviceMap["sm_32"] = FilePath;
         } else if (GpuArch == "compute_30") {
           LibDeviceMap["sm_30"] = FilePath;

lib/Format/UnwrappedLineParser.h

private:
   // Decides which comment tokens should be added to the current line and which
   // 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 absense of a next token, or that the next token
+  // signifies either the absence of a next token, or that the next token
   // shouldn't be taken into accunt 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);

lib/Frontend/ASTMerge.cpp

-//===-- ASTMerge.cpp - AST Merging Frontent Action --------------*- C++ -*-===//
+//===-- ASTMerge.cpp - AST Merging Frontend Action --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "clang/Frontend/ASTUnit.h"

lib/Frontend/CompilerInstance.cpp

case llvm::LockFileManager::LFS_Shared:
       case llvm::LockFileManager::Res_OwnerDied:
         continue; // try again to get the lock.
       case llvm::LockFileManager::Res_Timeout:
         // Since PCMCache takes care of correctness, we try waiting for another
         // process to complete the build so clang does not do it done twice. If
         // case of timeout, build it ourselves.
         Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
             << Module->Name;
-        // Clear the lock file so that future invokations can make progress.
+        // Clear the lock file so that future invocations can make progress.
         Locked.unsafeRemoveLockFile();
         continue;
       }
       break;
     }
 
     // Try to read the module file, now that we've compiled it.
     ASTReader::ASTReadResult ReadResult =

lib/Frontend/DiagnosticRenderer.cpp

void DiagnosticRenderer::emitIncludeStack(FullSourceLoc Loc, PresumedLoc PLoc,
   if (IncludeLoc.isValid())
     emitIncludeStackRecursively(IncludeLoc);
   else {
     emitModuleBuildStack(Loc.getManager());
     emitImportStack(Loc);
   }
 }
 
-/// \brief Helper to recursivly walk up the include stack and print each layer
+/// \brief Helper to recursively walk up the include stack and print each layer
 /// on the way back down.
 void DiagnosticRenderer::emitIncludeStackRecursively(FullSourceLoc Loc) {
   if (Loc.isInvalid()) {
     emitModuleBuildStack(Loc.getManager());
     return;
   }
 
   PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
if (Loc.isInvalid()) {
     emitModuleBuildStack(Loc.getManager());
     return;
   }
 
   std::pair<FullSourceLoc, StringRef> NextImportLoc = Loc.getModuleImportLoc();
   emitImportStackRecursively(NextImportLoc.first, NextImportLoc.second);
 }
 
-/// \brief Helper to recursivly walk up the import stack and print each layer
+/// \brief Helper to recursively walk up the import stack and print each layer
 /// on the way back down.
 void DiagnosticRenderer::emitImportStackRecursively(FullSourceLoc Loc,
                                                     StringRef ModuleName) {
   if (ModuleName.empty()) {
     return;
   }
 
   PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
static bool checkLocForMacroArgExpansion(SourceLocation Loc,
   if (SM.isMacroArgExpansion(Loc, &MacroLoc)) {
     if (ArgumentLoc == MacroLoc) return true;
   }
 
   return false;
 }
 
 /// Check if all the locations in the range have the same macro argument
-/// expansion, and that that expansion starts with ArgumentLoc.
+/// expansion, and that the expansion starts with ArgumentLoc.
 static bool checkRangeForMacroArgExpansion(CharSourceRange Range,
                                            const SourceManager &SM,
                                            SourceLocation ArgumentLoc) {
   SourceLocation BegLoc = Range.getBegin(), EndLoc = Range.getEnd();
   while (BegLoc != EndLoc) {
     if (!checkLocForMacroArgExpansion(BegLoc, SM, ArgumentLoc))
       return false;
     BegLoc.getLocWithOffset(1);

lib/Frontend/ModuleDependencyCollector.cpp

static bool isCaseSensitivePath(StringRef Path) {
   SmallString<256> TmpDest = Path, UpperDest, RealDest;
   // Remove component traversals, links, etc.
   if (!real_path(Path, TmpDest))
     return true; // Current default value in vfs.yaml
   Path = TmpDest;
 
   // Change path to all upper case and ask for its real path, if the latter
   // exists and is equal to Path, it's not case sensitive. Default to case
-  // sensitive in the absense of realpath, since this is what the VFSWriter
+  // sensitive in the absence of realpath, since this is what the VFSWriter
   // already expects when sensitivity isn't setup.
   for (auto &C : Path)
     UpperDest.push_back(toUppercase(C));
   if (real_path(UpperDest, RealDest) && Path.equals(RealDest))
     return false;
   return true;
 }
 

lib/Frontend/Rewrite/RewriteModernObjC.cpp

static void Write_IvarOffsetVar(RewriteModernObjC &RewriteObj,
                                 ArrayRef<ObjCIvarDecl *> Ivars, 
                                 ObjCInterfaceDecl *CDecl) {
   // FIXME. visibilty 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 shoud be: HiddenVisibility;
+     Visibility should be: HiddenVisibility;
    else
-     Visibility shoud be: DefaultVisibility;
+     Visibility should be: DefaultVisibility;
   */
   
   Result += "\n";
   for (unsigned i =0, e = Ivars.size(); i < e; i++) {
     ObjCIvarDecl *IvarDecl = Ivars[i];
     if (Context->getLangOpts().MicrosoftExt)
       Result += "__declspec(allocate(\".objc_ivar$B\")) ";
     

lib/Frontend/SerializedDiagnosticPrinter.cpp

void SDiagsWriter::EmitBlockInfoBlock() {
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));  // Diag level.
   AddSourceLocationAbbrev(*Abbrev);
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category.  
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // Text size.
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text.
   Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
   
-  // Emit abbrevation for RECORD_CATEGORY.
+  // Emit abbreviation for RECORD_CATEGORY.
   Abbrev = std::make_shared<BitCodeAbbrev>();
   Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY));
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID.
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));  // Text size.
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));      // Category text.
   Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
 
-  // Emit abbrevation for RECORD_SOURCE_RANGE.
+  // Emit abbreviation for RECORD_SOURCE_RANGE.
   Abbrev = std::make_shared<BitCodeAbbrev>();
   Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE));
   AddRangeLocationAbbrev(*Abbrev);
   Abbrevs.set(RECORD_SOURCE_RANGE,
               Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
   
   // Emit the abbreviation for RECORD_DIAG_FLAG.
   Abbrev = std::make_shared<BitCodeAbbrev>();

lib/Headers/__clang_cuda_builtin_vars.h

#define __CUDA_DEVICE_BUILTIN(FIELD, INTRINSIC)                                \
   }
 
 #if __cplusplus >= 201103L
 #define __DELETE =delete
 #else
 #define __DELETE
 #endif
 
-// Make sure nobody can create instances of the special varible types.  nvcc
+// Make sure nobody can create instances of the special variable types.  nvcc
 // also disallows taking address of special variables, so we disable address-of
 // operator as well.
 #define __CUDA_DISALLOW_BUILTINVAR_ACCESS(TypeName)                            \
   __attribute__((device)) TypeName() __DELETE;                                 \
   __attribute__((device)) TypeName(const TypeName &) __DELETE;                 \
   __attribute__((device)) void operator=(const TypeName &) const __DELETE;     \
   __attribute__((device)) TypeName *operator&() const __DELETE
 

lib/Headers/__wmmintrin_aes.h

 ///    A 128-bit integer vector containing the expanded key.
 /// \returns A 128-bit integer vector containing the transformed value.
 static __inline__ __m128i __DEFAULT_FN_ATTRS
 _mm_aesimc_si128(__m128i __V)
 {
   return (__m128i)__builtin_ia32_aesimc128((__v2di)__V);
 }
 
-/// \brief Generates a round key for AES encyption, operating on 128-bit data
+/// \brief Generates a round key for AES encryption, operating on 128-bit data
 ///    specified in the first source operand and using an 8-bit round constant
 ///    specified by the second source operand, and writes the result to the
 ///    destination.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// \code
 /// __m128i _mm_aeskeygenassist_si128(__m128i C, const int R);

lib/Headers/htmxlintrin.h

 #endif /* __powerpc__ */
 
 #ifdef __s390__
 
 #include <stdint.h>
 
 /* These intrinsics are being made available for compatibility with
    the IBM XL compiler.  For documentation please see the "z/OS XL
-   C/C++ Programming Guide" publically available on the web.  */
+   C/C++ Programming Guide" publicly available on the web.  */
 
 static __inline long __attribute__((__always_inline__, __nodebug__))
 __TM_simple_begin ()
 {
   return __builtin_tbegin_nofloat (0);
 }
 
 static __inline long __attribute__((__always_inline__, __nodebug__))

lib/Headers/stdint.h

  * that is represented in the standard integer types.
  *
  * The standard also requires minimum-width types be defined for 8-, 16-, 32-,
  * and 64-bit widths regardless of whether there are corresponding exact-width
  * types.
  *
  * To accommodate targets that are missing types that are exactly 8, 16, 32, or
  * 64 bits wide, this implementation takes an approach of cascading
- * redefintions, redefining __int_leastN_t to successively smaller exact-width
+ * redefinitions, redefining __int_leastN_t to successively smaller exact-width
  * types. It is therefore important that the types are defined in order of
  * descending widths.
  *
  * We currently assume that the minimum-width types and the fastest
  * minimum-width types are the same. This is allowed by the standard, but is
  * suboptimal.
  *
  * In violation of the standard, some targets do not implement a type that is

  * The presence of limit macros are completely optional in C99.  This
  * implementation defines limits for all of the types (exact- and
  * minimum-width) that it defines above, using the limits of the minimum-width
  * type for any types that do not have exact-width representations.
  *
  * As in the type definitions, this section takes an approach of
  * successive-shrinking to determine which limits to use for the standard (8,
  * 16, 32, 64) bit widths when they don't have exact representations. It is
- * therefore important that the defintions be kept in order of decending
+ * therefore important that the definitions be kept in order of decending
  * widths.
  *
  * Note that C++ should not check __STDC_LIMIT_MACROS here, contrary to the
  * claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]).
  */
 
 #ifdef __INT64_TYPE__
 # define INT64_MAX           INT64_C( 9223372036854775807)

lib/Lex/HeaderSearch.cpp

Module *HeaderSearch::lookupModule(StringRef ModuleName, bool AllowSearch) {
 
   StringRef SearchName = ModuleName;
   Module = lookupModule(ModuleName, SearchName);
 
   // The facility for "private modules" -- adjacent, optional module maps named
   // module.private.modulemap that are supposed to define private submodules --
   // may have different flavors of names: FooPrivate, Foo_Private and Foo.Private.
   //
-  // Foo.Private is now depracated in favor of Foo_Private. Users of FooPrivate
+  // Foo.Private is now deprecated in favor of Foo_Private. Users of FooPrivate
   // should also rename to Foo_Private. Representing private as submodules
   // could force building unwanted dependencies into the parent module and cause
   // dependency cycles.
   if (!Module && SearchName.consume_back("_Private"))
     Module = lookupModule(ModuleName, SearchName);
   if (!Module && SearchName.consume_back("Private"))
     Module = lookupModule(ModuleName, SearchName);
   return Module;

lib/Lex/Lexer.cpp

StringRef Lexer::getSourceText(CharSourceRange Range,
 
   if (Invalid) *Invalid = false;
   return file.substr(beginInfo.second, EndOffs - beginInfo.second);
 }
 
 StringRef Lexer::getImmediateMacroName(SourceLocation Loc,
                                        const SourceManager &SM,
                                        const LangOptions &LangOpts) {
-  assert(Loc.isMacroID() && "Only reasonble to call this on macros");
+  assert(Loc.isMacroID() && "Only reasonable to call this on macros");
 
   // Find the location of the immediate macro expansion.
   while (true) {
     FileID FID = SM.getFileID(Loc);
     const SrcMgr::SLocEntry *E = &SM.getSLocEntry(FID);
     const SrcMgr::ExpansionInfo &Expansion = E->getExpansion();
     Loc = Expansion.getExpansionLocStart();
     if (!Expansion.isMacroArgExpansion())
StringRef Lexer::getImmediateMacroName(SourceLocation Loc,
   std::pair<FileID, unsigned> ExpansionInfo = SM.getDecomposedLoc(Loc);
   unsigned MacroTokenLength = Lexer::MeasureTokenLength(Loc, SM, LangOpts);
   StringRef ExpansionBuffer = SM.getBufferData(ExpansionInfo.first);
   return ExpansionBuffer.substr(ExpansionInfo.second, MacroTokenLength);
 }
 
 StringRef Lexer::getImmediateMacroNameForDiagnostics(
     SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts) {
-  assert(Loc.isMacroID() && "Only reasonble to call this on macros");
+  assert(Loc.isMacroID() && "Only reasonable to call this on macros");
   // Walk past macro argument expanions.
   while (SM.isMacroArgExpansion(Loc))
     Loc = SM.getImmediateExpansionRange(Loc).first;
 
   // If the macro's spelling has no FileID, then it's actually a token paste
   // or stringization (or similar) and not a macro at all.
   if (!SM.getFileEntryForID(SM.getFileID(SM.getSpellingLoc(Loc))))
     return {};
if (SawNewline) {
     TokAtPhysicalStartOfLine = true;
   }
 
   BufferPtr = CurPtr;
   return false;
 }
 
 /// We have just read the // characters from input.  Skip until we find the
-/// newline character thats terminate the comment.  Then update BufferPtr and
+/// newline character that terminates the comment.  Then update BufferPtr and
 /// return.
 ///
 /// If we're in KeepCommentMode or any CommentHandler has inserted
 /// some tokens, this will store the first token and return true.
 bool Lexer::SkipLineComment(Token &Result, const char *CurPtr,
                             bool &TokAtPhysicalStartOfLine) {
   // If Line comments aren't explicitly enabled for this language, emit an
   // extension warning.
LexNextToken:
   case '/':
     // 6.4.9: Comments
     Char = getCharAndSize(CurPtr, SizeTmp);
     if (Char == '/') {         // Line comment.
       // Even if Line comments are disabled (e.g. in C89 mode), we generally
       // want to lex this as a comment.  There is one problem with this though,
       // that in one particular corner case, this can change the behavior of the
       // resultant program.  For example, In  "foo //**/ bar", C89 would lex
-      // this as "foo / bar" and langauges with Line comments would lex it as
+      // this as "foo / bar" and languages with Line comments would lex it as
       // "foo".  Check to see if the character after the second slash is a '*'.
       // If so, we will lex that as a "/" instead of the start of a comment.
       // However, we never do this if we are just preprocessing.
       bool TreatAsComment = LangOpts.LineComment &&
                             (LangOpts.CPlusPlus || !LangOpts.TraditionalCPP);
       if (!TreatAsComment)
         if (!(PP && PP->isPreprocessedOutput()))
           TreatAsComment = getCharAndSize(CurPtr+SizeTmp, SizeTmp2) != '*';

lib/Lex/MacroArgs.cpp

if (tok::isStringLiteral(Tok.getKind()) || // "foo", u8R"x(foo)x"_bar, etc.
           Result.resize(CurStrLen+ActualTokLen);
       }
     }
   }
 
   // If the last character of the string is a \, and if it isn't escaped, this
   // is an invalid string literal, diagnose it as specified in C99.
   if (Result.back() == '\\') {
-    // Count the number of consequtive \ characters.  If even, then they are
+    // Count the number of consecutive \ characters.  If even, then they are
     // just escaped backslashes, otherwise it's an error.
     unsigned FirstNonSlash = Result.size()-2;
     // Guaranteed to find the starting " if nothing else.
     while (Result[FirstNonSlash] == '\\')
       --FirstNonSlash;
     if ((Result.size()-1-FirstNonSlash) & 1) {
       // Diagnose errors for things like: #define F(X) #X   /   F(\)
       PP.Diag(ArgToks[-1], diag::pp_invalid_string_literal);

lib/Lex/PPDirectives.cpp

void Preprocessor::HandleUserDiagnosticDirective(Token &Tok,
                                                  bool isWarning) {
   // PTH doesn't emit #warning or #error directives.
   if (CurPTHLexer)
     return CurPTHLexer->DiscardToEndOfLine();
 
   // Read the rest of the line raw.  We do this because we don't want macros
   // to be expanded and we don't require that the tokens be valid preprocessing
   // tokens.  For example, this is allowed: "#warning `   'foo".  GCC does
-  // collapse multiple consequtive white space between tokens, but this isn't
+  // collapse multiple consecutive white space between tokens, but this isn't
   // specified by the standard.
   SmallString<128> Message;
   CurLexer->ReadToEndOfLine(&Message);
 
   // Find the first non-whitespace character, so that we can make the
   // diagnostic more succinct.
   StringRef Msg = StringRef(Message).ltrim(' ');
 

lib/Lex/PTHLexer.cpp

do {
     uint32_t Offset = endian::readNext<uint32_t, little, aligned>(CurPPCondPtr);
 
     // Read the target table index from the side-table.
     TableIdx = endian::readNext<uint32_t, little, aligned>(CurPPCondPtr);
 
     // Compute the actual memory address of the '#' token data for this entry.
     HashEntryI = TokBuf + Offset;
 
-    // Optmization: "Sibling jumping".  #if...#else...#endif blocks can
+    // Optimization: "Sibling jumping".  #if...#else...#endif blocks can
     //  contain nested blocks.  In the side-table we can jump over these
     //  nested blocks instead of doing a linear search if the next "sibling"
     //  entry is not at a location greater than LastHashTokPtr.
     if (HashEntryI < LastHashTokPtr && TableIdx) {
       // In the side-table we are still at an entry for a '#' token that
       // is earlier than the last one we saw.  Check if the location we would
       // stride gets us closer.
       const unsigned char* NextPPCondPtr =

lib/Lex/TokenLexer.cpp

for (unsigned I = 0, E = NumTokens; I != E; ++I) {
     // Okay, we have a token that is either the LHS or RHS of a paste (##)
     // argument.  It gets substituted as its non-pre-expanded tokens.
     const Token *ArgToks = ActualArgs->getUnexpArgument(ArgNo);
     unsigned NumToks = MacroArgs::getArgLength(ArgToks);
     if (NumToks) {  // Not an empty argument?
       bool VaArgsPseudoPaste = false;
       // If this is the GNU ", ## __VA_ARGS__" extension, and we just learned
       // that __VA_ARGS__ expands to multiple tokens, avoid a pasting error when
-      // the expander trys to paste ',' with the first token of the __VA_ARGS__
+      // the expander tries to paste ',' with the first token of the __VA_ARGS__
       // expansion.
       if (NonEmptyPasteBefore && ResultToks.size() >= 2 &&
           ResultToks[ResultToks.size()-2].is(tok::comma) &&
           (unsigned)ArgNo == Macro->getNumParams()-1 &&
           Macro->isVariadic()) {
         VaArgsPseudoPaste = true;
         // Remove the paste operator, report use of the extension.
         PP.Diag(ResultToks.pop_back_val().getLocation(), diag::ext_paste_comma);

lib/Parse/ParseDecl.cpp

 bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
                               const ParsedTemplateInfo &TemplateInfo,
                               AccessSpecifier AS, DeclSpecContext DSC,
                               ParsedAttributesWithRange &Attrs) {
   assert(Tok.is(tok::identifier) && "should have identifier");
 
   SourceLocation Loc = Tok.getLocation();
   // If we see an identifier that is not a type name, we normally would
-  // parse it as the identifer being declared.  However, when a typename
+  // parse it as the identifier being declared.  However, when a typename
   // is typo'd or the definition is not included, this will incorrectly
   // parse the typename as the identifier name and fall over misparsing
   // later parts of the diagnostic.
   //
   // As such, we try to do some look-ahead in cases where this would
   // otherwise be an "implicit-int" case to see if this is invalid.  For
   // example: "static foo_t x = 4;"  In this case, if we parsed foo_t as
   // an identifier with implicit int, we'd get a parse error because the
case tok::kw___read_write:
       ParseOpenCLQualifiers(DS.getAttributes());
       break;
 
     case tok::kw___unaligned:
       isInvalid = DS.SetTypeQual(DeclSpec::TQ_unaligned, Loc, PrevSpec, DiagID,
                                  getLangOpts());
       break;
     case tok::kw___uptr:
-      // GNU libc headers in C mode use '__uptr' as an identifer which conflicts
+      // GNU libc headers in C mode use '__uptr' as an identifier which conflicts
       // with the MS modifier keyword.
       if ((AttrReqs & AR_DeclspecAttributesParsed) && !getLangOpts().CPlusPlus &&
           IdentifierRequired && DS.isEmpty() && NextToken().is(tok::semi)) {
         if (TryKeywordIdentFallback(false))
           continue;
       }
       LLVM_FALLTHROUGH;
     case tok::kw___sptr:

lib/Parse/ParsePragma.cpp

if (IsAny)
     if (AnyParens.consumeClose())
       return true;
 
   return false;
 }
 
 namespace {
 
-/// Describes the stage at which attribute subject rule parsing was interruped.
+/// Describes the stage at which attribute subject rule parsing was interrupted.
 enum class MissingAttributeSubjectRulesRecoveryPoint {
   Comma,
   ApplyTo,
   Equals,
   Any,
   None,
 };
 
void PragmaMSPragma::HandlePragma(Preprocessor &PP,
   AnnotTok.setLocation(Tok.getLocation());
   AnnotTok.setAnnotationEndLoc(Tok.getLocation());
   SmallVector<Token, 8> TokenVector;
   // Suck up all of the tokens before the eod.
   for (; Tok.isNot(tok::eod); PP.Lex(Tok)) {
     TokenVector.push_back(Tok);
     AnnotTok.setAnnotationEndLoc(Tok.getLocation());
   }
-  // Add a sentinal EoF token to the end of the list.
+  // Add a sentinel EoF token to the end of the list.
   TokenVector.push_back(EoF);
   // We must allocate this array with new because EnterTokenStream is going to
   // delete it later.
   auto TokenArray = llvm::make_unique<Token[]>(TokenVector.size());
   std::copy(TokenVector.begin(), TokenVector.end(), TokenArray.get());
   auto Value = new (PP.getPreprocessorAllocator())
       std::pair<std::unique_ptr<Token[]>, size_t>(std::move(TokenArray),
                                                   TokenVector.size());

lib/Sema/SemaAttr.cpp

if (AlignmentVal == Sema::kMac68kAlignmentSentinel)
       Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k";
     else
       Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
   }
   // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
   // "#pragma pack(pop, identifier, n) is undefined"
   if (Action & Sema::PSK_Pop) {
     if (Alignment && !SlotLabel.empty())
-      Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment);
+      Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment);
     if (PackStack.Stack.empty())
       Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty";
   }
 
   PackStack.Act(PragmaLoc, Action, SlotLabel, AlignmentVal);
 }
 
 void Sema::DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind,

lib/Sema/SemaCast.cpp

if (SrcPointee->isVoidType()) {
       }
       else if (CStyle && DestType->isBlockPointerType()) {
         // allow c-style cast of void * to block pointers.
         Kind = CK_AnyPointerToBlockPointerCast;
         return TC_Success;
       }
     }
   }
-  // Allow arbitray objective-c pointer conversion with static casts.
+  // Allow arbitrary objective-c pointer conversion with static casts.
   if (SrcType->isObjCObjectPointerType() &&
       DestType->isObjCObjectPointerType()) {
     Kind = CK_BitCast;
     return TC_Success;
   }
   // Allow ns-pointer to cf-pointer conversion in either direction
   // with static casts.
   if (!CStyle &&

lib/Sema/SemaChecking.cpp

bool Sema::CheckMipsBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
   case Mips::BI__builtin_msa_sat_u_h:
   case Mips::BI__builtin_msa_slli_h:
   case Mips::BI__builtin_msa_srai_h:
   case Mips::BI__builtin_msa_srari_h:
   case Mips::BI__builtin_msa_srli_h:
   case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15; break;
   case Mips::BI__builtin_msa_binsli_h:
   case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15; break;
-  // These intrinsics take an unsigned 5 bit immedate.
+  // These intrinsics take an unsigned 5 bit immediate.
   // The first block of intrinsics actually have an unsigned 5 bit field,
   // not a df/n field.
   case Mips::BI__builtin_msa_clei_u_b:
   case Mips::BI__builtin_msa_clei_u_h:
   case Mips::BI__builtin_msa_clei_u_w:
   case Mips::BI__builtin_msa_clei_u_d:
   case Mips::BI__builtin_msa_clti_u_b:
   case Mips::BI__builtin_msa_clti_u_h:
void CheckFormatHandler::EmitFormatDiagnostic(PartialDiagnostic PDiag,
                                               SourceLocation Loc,
                                               bool IsStringLocation,
                                               Range StringRange,
                                               ArrayRef<FixItHint> FixIt) {
   EmitFormatDiagnostic(S, inFunctionCall, Args[FormatIdx], PDiag,
                        Loc, IsStringLocation, StringRange, FixIt);
 }
 
-/// \brief If the format string is not within the funcion call, emit a note
+/// \brief If the format string is not within the function call, emit a note
 /// so that the function call and string are in diagnostic messages.
 ///
 /// \param InFunctionCall if true, the format string is within the function
 /// call and only one diagnostic message will be produced.  Otherwise, an
 /// extra note will be emitted pointing to location of the format string.
 ///
 /// \param ArgumentExpr the expression that is passed as the format string
 /// argument in the function call.  Used for getting locations when two
if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
       ::CheckBoolLikeConversion(S, SubExpr, BO->getExprLoc());
   }
 
   if (const UnaryOperator *U = dyn_cast<UnaryOperator>(E))
     if (U->getOpcode() == UO_LNot)
       ::CheckBoolLikeConversion(S, U->getSubExpr(), CC);
 }
 
-/// Diagnose integer type and any valid implicit convertion to it.
+/// Diagnose integer type and any valid implicit conversion to it.
 static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E, const QualType &IntT) {
   // Taking into account implicit conversions,
   // allow any integer.
   if (!E->getType()->isIntegerType()) {
     S.Diag(E->getLocStart(),
            diag::err_opencl_enqueue_kernel_invalid_local_size_type);
     return true;
   }
for (ParmVarDecl *Param : Parameters) {
     //   variable length array types.
     QualType PType = Param->getOriginalType();
     // FIXME: This diagnostic should point the '[*]' if source-location
     // information is added for it.
     diagnoseArrayStarInParamType(*this, PType, Param->getLocation());
 
     // If the parameter is a c++ class type and it has to be destructed in the
     // callee function, declare the destructor so that it can be called by the
-    // callee function. Do not perfom any direct access check on the dtor here.
+    // callee function. Do not perform any direct access check on the dtor here.
     if (!Param->isInvalidDecl()) {
       if (CXXRecordDecl *ClassDecl = Param->getType()->getAsCXXRecordDecl()) {
         if (!ClassDecl->isInvalidDecl() &&
             !ClassDecl->hasIrrelevantDestructor() &&
             !ClassDecl->isDependentContext() &&
             Context.isParamDestroyedInCallee(Param->getType())) {
           CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl);
           MarkFunctionReferenced(Param->getLocation(), Destructor);

lib/Sema/SemaCodeComplete.cpp

 
 /// \brief Returns a placeholder string that corresponds to an Objective-C block
 /// declaration.
 ///
 /// \param BlockDecl A declaration with an Objective-C block type.
 ///
 /// \param Block The most relevant type location for that block type.
 ///
-/// \param SuppressBlockName Determines wether or not the name of the block
+/// \param SuppressBlockName Determines whether or not the name of the block
 /// declaration is included in the resulting string.
 static std::string
 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
                        FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
                        bool SuppressBlockName, bool SuppressBlock,
                        Optional<ArrayRef<QualType>> ObjCSubsts) {
   std::string Result;
   QualType ResultType = Block.getTypePtr()->getReturnType();

lib/Sema/SemaCoroutine.cpp

if (auto *TE = dyn_cast<TypoExpr>(Result.get())) {
     return ExprError();
   }
 
   return S.ActOnCallExpr(nullptr, Result.get(), Loc, Args, Loc, nullptr);
 }
 
 // See if return type is coroutine-handle and if so, invoke builtin coro-resume
 // on its address. This is to enable experimental support for coroutine-handle
-// returning await_suspend that results in a guranteed tail call to the target
+// returning await_suspend that results in a guaranteed tail call to the target
 // coroutine.
 static Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E,
                            SourceLocation Loc) {
   if (RetType->isReferenceType())
     return nullptr;
   Type const *T = RetType.getTypePtr();
   if (!T->isClassType() && !T->isStructureType())
     return nullptr;

lib/Sema/SemaDecl.cpp

bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
     return false;
   }
 };
 
 enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted };
 } // end anonymous namespace
 
 /// \brief Report an error regarding overriding, along with any relevant
-/// overriden methods.
+/// overridden methods.
 ///
 /// \param DiagID the primary error to report.
 /// \param MD the overriding method.
 /// \param OEK which overrides to include as notes.
 static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD,
                             OverrideErrorKind OEK = OEK_All) {
   S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
   for (const CXXMethodDecl *O : MD->overridden_methods()) {
if (VDecl->isLocalVarDecl()) {
     } else {
       Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
         << DclT << Init->getSourceRange();
       VDecl->setInvalidDecl();
     }
   } else if (VDecl->isFileVarDecl()) {
     // In C, extern is typically used to avoid tentative definitions when
     // declaring variables in headers, but adding an intializer makes it a
-    // defintion. This is somewhat confusing, so GCC and Clang both warn on it.
+    // definition. This is somewhat confusing, so GCC and Clang both warn on it.
     // In C++, extern is often used to give implictly static const variables
     // external linkage, so don't warn in that case. If selectany is present,
     // this might be header code intended for C and C++ inclusion, so apply the
     // C++ rules.
     if (VDecl->getStorageClass() == SC_Extern &&
         ((!getLangOpts().CPlusPlus && !VDecl->hasAttr<SelectAnyAttr>()) ||
          !Context.getBaseElementType(VDecl->getType()).isConstQualified()) &&
         !(getLangOpts().CPlusPlus && VDecl->isExternC()) &&
if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
 
             for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
                                              MEnd = FinalOverriders.end();
                  M != MEnd; ++M) {
               for (OverridingMethods::iterator SO = M->second.begin(),
                                             SOEnd = M->second.end();
                    SO != SOEnd; ++SO) {
                 assert(SO->second.size() > 0 &&
-                       "Virtual function without overridding functions?");
+                       "Virtual function without overriding functions?");
                 if (SO->second.size() == 1)
                   continue;
 
                 // C++ [class.virtual]p2:
                 //   In a derived class, if a virtual member function of a base
                 //   class subobject has more than one final overrider the
                 //   program is ill-formed.
                 Diag(Record->getLocation(), diag::err_multiple_final_overriders)

lib/Sema/SemaDeclAttr.cpp

 }
 
 /// Actually emit an availability diagnostic for a reference to an unavailable
 /// decl.
 ///
 /// \param Ctx The context that the reference occurred in
 /// \param ReferringDecl The exact declaration that was referenced.
 /// \param OffendingDecl A related decl to \c ReferringDecl that has an
-/// availability attribute corrisponding to \c K attached to it. Note that this
+/// availability attribute corresponding to \c K attached to it. Note that this
 /// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and
 /// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl
 /// and OffendingDecl is the EnumDecl.
 static void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K,
                                       Decl *Ctx, const NamedDecl *ReferringDecl,
                                       const NamedDecl *OffendingDecl,
                                       StringRef Message,
                                       ArrayRef<SourceLocation> Locs,

lib/Sema/SemaDeclObjC.cpp

for (auto *method : PDecl->instance_methods()) {
                                           true /* followsSuper */,
                                           nullptr /* category */))) {
             // If a method is not implemented in the category implementation but
             // has been declared in its primary class, superclass,
             // or in one of their protocols, no need to issue the warning. 
             // This is because method will be implemented in the primary class 
             // or one of its super class implementation.
             
-            // Ugly, but necessary. Method declared in protcol might have
+            // Ugly, but necessary. Method declared in protocol might have
             // have been synthesized due to a property declared in the class which
             // uses the protocol.
             if (ObjCMethodDecl *MethodInClass =
                   IDecl->lookupMethod(method->getSelector(),
                                       true /* instance */,
                                       true /* shallowCategoryLookup */,
                                       false /* followSuper */))
               if (C || MethodInClass->isPropertyAccessor())
static bool FilterMethodsByTypeBound(ObjCMethodDecl *Method,
   if (ObjCInterfaceDecl *MethodInterface = Method->getClassInterface()) {
     // We allow methods declared within classes that are part of the hierarchy
     // of the class bound (superclass of, subclass of, or the same as the class
     // bound).
     return MethodInterface == BoundInterface ||
            MethodInterface->isSuperClassOf(BoundInterface) ||
            BoundInterface->isSuperClassOf(MethodInterface);
   }
-  llvm_unreachable("unknow method context");
+  llvm_unreachable("unknown method context");
 }
 
 /// We first select the type of the method: Instance or Factory, then collect
 /// all methods with that type.
 bool Sema::CollectMultipleMethodsInGlobalPool(
     Selector Sel, SmallVectorImpl<ObjCMethodDecl *> &Methods,
     bool InstanceFirst, bool CheckTheOther,
     const ObjCObjectType *TypeBound) {

lib/Sema/SemaExpr.cpp

if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
       // of one failure would be terrible for indexing/etc.
       if (result.isInvalid()) continue;
 
       InitArgList[I] = result.get();
     }
   }
 
   // Semantic analysis for initializers is done by ActOnDeclarator() and
-  // CheckInitializer() - it requires knowledge of the object being intialized.
+  // CheckInitializer() - it requires knowledge of the object being initialized.
 
   InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList,
                                                RBraceLoc);
   E->setType(Context.VoidTy); // FIXME: just a place holder for now.
   return E;
 }
 
 /// Do an explicit extend of the given block pointer if we're in ARC.

 
 /// Test if a (constant) integer Int can be casted to floating point type
 /// FloatTy without losing precision.
 static bool canConvertIntTyToFloatTy(Sema &S, ExprResult *Int,
                                      QualType FloatTy) {
   QualType IntTy = Int->get()->getType().getUnqualifiedType();
 
   // Determine if the integer constant can be expressed as a floating point
-  // number of the appropiate type.
+  // number of the appropriate type.
   llvm::APSInt Result;
   bool CstInt = Int->get()->EvaluateAsInt(Result, S.Context);
   uint64_t Bits = 0;
   if (CstInt) {
     // Reject constants that would be truncated if they were converted to
     // the floating point type. Test by simple to/from conversion.
     // FIXME: Ideally the conversion to an APFloat and from an APFloat
     //        could be avoided if there was a convertFromAPInt method
case UO_Imag:
     }
     break;
   case UO_Extension:
     resultType = Input.get()->getType();
     VK = Input.get()->getValueKind();
     OK = Input.get()->getObjectKind();
     break;
   case UO_Coawait:
-    // It's unnessesary to represent the pass-through operator co_await in the
+    // It's unnecessary to represent the pass-through operator co_await in the
     // AST; just return the input expression instead.
     assert(!Input.get()->getType()->isDependentType() &&
                    "the co_await expression must be non-dependant before "
                    "building operator co_await");
     return Input;
   }
   if (resultType.isNull() || Input.isInvalid())
     return ExprError();

lib/Sema/SemaExprCXX.cpp

static bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
   //   The process for determining whether an operand expression E1 of type T1
   //   can be converted to match an operand expression E2 of type T2 is defined
   //   as follows:
   //   -- If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
   //      implicitly converted to type "lvalue reference to T2", subject to the
   //      constraint that in the conversion the reference must bind directly to
   //      an lvalue.
   //   -- If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
-  //      implicitly conveted to the type "rvalue reference to R2", subject to
+  //      implicitly converted to the type "rvalue reference to R2", subject to
   //      the constraint that the reference must bind directly.
   if (To->isLValue() || To->isXValue()) {
     QualType T = To->isLValue() ? Self.Context.getLValueReferenceType(ToType)
                                 : Self.Context.getRValueReferenceType(ToType);
 
     InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
 
     InitializationSequence InitSeq(Self, Entity, Kind, From);

lib/Sema/SemaExprObjC.cpp

if (receiverIsIdLike || ReceiverType->isBlockPointerType() ||
             CollectMultipleMethodsInGlobalPool(Sel, Methods,
                                                false/*InstanceFirst*/,
                                                true/*CheckTheOther*/);
             if (!Methods.empty()) {
               // We choose the first method as the initial candidate, then try
               // to select a better one.
               Method = Methods[0];
 
-              // If we find an instance method, emit waring.
+              // If we find an instance method, emit warning.
               if (Method->isInstanceMethod()) {
                 if (const ObjCInterfaceDecl *ID =
                     dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) {
                   if (ID->getSuperClass())
                     Diag(SelLoc, diag::warn_root_inst_method_not_found)
                         << Sel << SourceRange(LBracLoc, RBracLoc);
                 }
               }

lib/Sema/SemaInit.cpp

if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
     return;
 
   // Delegate everything else to a subfunction.
   TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
                                  T1Quals, cv2T2, T2, T2Quals, Sequence);
 }
 
 /// Determine whether an expression is a non-referenceable glvalue (one to
-/// which a reference can never bind). Attemting to bind a reference to
+/// which a reference can never bind). Attempting to bind a reference to
 /// such a glvalue will always create a temporary.
 static bool isNonReferenceableGLValue(Expr *E) {
   return E->refersToBitField() || E->refersToVectorElement();
 }
 
 /// \brief Reference initialization without resolving overloaded functions.
 static void TryReferenceInitializationCore(Sema &S,
                                            const InitializedEntity &Entity,

lib/Sema/SemaOverload.cpp

for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
     NamedDecl *D = F.getDecl()->getUnderlyingDecl();
     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
       ArrayRef<Expr *> FunctionArgs = Args;
       if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
         QualType ObjectType;
         Expr::Classification ObjectClassification;
         if (Args.size() > 0) {
           if (Expr *E = Args[0]) {
-            // Use the explit base to restrict the lookup:
+            // Use the explicit base to restrict the lookup:
             ObjectType = E->getType();
             ObjectClassification = E->Classify(Context);
           } // .. else there is an implit base.
           FunctionArgs = Args.slice(1);
         }
         AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
                            cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
                            ObjectClassification, FunctionArgs, CandidateSet,
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
       }
     } else {
       FunctionTemplateDecl *FunTmpl = cast<FunctionTemplateDecl>(D);
       if (isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()) &&
           !cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl())->isStatic()) {
         QualType ObjectType;
         Expr::Classification ObjectClassification;
         if (Expr *E = Args[0]) {
-          // Use the explit base to restrict the lookup:
+          // Use the explicit base to restrict the lookup:
           ObjectType = E->getType();
           ObjectClassification = E->Classify(Context);
         } // .. else there is an implit base.
         AddMethodTemplateCandidate(
             FunTmpl, F.getPair(),
             cast<CXXRecordDecl>(FunTmpl->getDeclContext()),
             ExplicitTemplateArgs, ObjectType, ObjectClassification,
             Args.slice(1), CandidateSet, SuppressUserConversions,
static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
   case OR_Deleted: {
     SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_deleted_call)
       << (*Best)->Function->isDeleted()
       << ULE->getName()
       << SemaRef.getDeletedOrUnavailableSuffix((*Best)->Function)
       << Fn->getSourceRange();
     CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args);
 
-    // We emitted an error for the unvailable/deleted function call but keep
+    // We emitted an error for the unavailable/deleted function call but keep
     // the call in the AST.
     FunctionDecl *FDecl = (*Best)->Function;
     Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
     return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
                                          ExecConfig);
   }
   }
 
switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
     case OR_No_Viable_Function: {
       // C++ [over.match.oper]p9:
       //   If the operator is the operator , [...] and there are no
       //   viable functions, then the operator is assumed to be the
       //   built-in operator and interpreted according to clause 5.
       if (Opc == BO_Comma)
         break;
 
-      // For class as left operand for assignment or compound assigment
+      // For class as left operand for assignment or compound assignment
       // operator do not fall through to handling in built-in, but report that
       // no overloaded assignment operator found
       ExprResult Result = ExprError();
       if (Args[0]->getType()->isRecordType() &&
           Opc >= BO_Assign && Opc <= BO_OrAssign) {
         Diag(OpLoc,  diag::err_ovl_no_viable_oper)
              << BinaryOperator::getOpcodeStr(Opc)
              << Args[0]->getSourceRange() << Args[1]->getSourceRange();

lib/Sema/SemaStmt.cpp

if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {
         //    int vla[b];
         //    b = -1;   <-- This should not affect the num of iterations below
         //    for (int &c : vla) { .. }
         //  }
 
         // FIXME: This results in codegen generating IR that recalculates the
         // run-time number of elements (as opposed to just using the IR Value
         // that corresponds to the run-time value of each bound that was
-        // generated when the array was created.) If this proves too embarassing
+        // generated when the array was created.) If this proves too embarrassing
         // even for unoptimized IR, consider passing a magic-value/cookie to
         // codegen that then knows to simply use that initial llvm::Value (that
         // corresponds to the bound at time of array creation) within
         // getelementptr.  But be prepared to pay the price of increasing a
         // customized form of coupling between the two components - which  could
         // be hard to maintain as the codebase evolves.
 
         ExprResult SizeOfVLAExprR = ActOnUnaryExprOrTypeTraitExpr(
if (isa<UnaryOperator>(E)) {
     const CXXOperatorCallExpr *Call = cast<CXXOperatorCallExpr>(E);
     const FunctionDecl *FD = Call->getDirectCallee();
     QualType ReturnType = FD->getReturnType();
     ReturnsReference = ReturnType->isReferenceType();
   }
 
   if (ReturnsReference) {
     // Loop variable creates a temporary.  Suggest either to go with
-    // non-reference loop variable to indiciate a copy is made, or
+    // non-reference loop variable to indicate a copy is made, or
     // the correct time to bind a const reference.
     SemaRef.Diag(VD->getLocation(), diag::warn_for_range_const_reference_copy)
         << VD << VariableType << E->getType();
     QualType NonReferenceType = VariableType.getNonReferenceType();
     NonReferenceType.removeLocalConst();
     QualType NewReferenceType =
         SemaRef.Context.getLValueReferenceType(E->getType().withConst());
     SemaRef.Diag(VD->getLocStart(), diag::note_use_type_or_non_reference)
static void DiagnoseForRangeConstVariableCopies(Sema &SemaRef,
   SemaRef.Diag(VD->getLocStart(), diag::note_use_reference_type)
       << SemaRef.Context.getLValueReferenceType(VariableType)
       << VD->getSourceRange();
 }
 
 /// DiagnoseForRangeVariableCopies - Diagnose three cases and fixes for them.
 /// 1) for (const foo &x : foos) where foos only returns a copy.  Suggest
 ///    using "const foo x" to show that a copy is made
-/// 2) for (const bar &x : foos) where bar is a temporary intialized by bar.
+/// 2) for (const bar &x : foos) where bar is a temporary initialized by bar.
 ///    Suggest either "const bar x" to keep the copying or "const foo& x" to
 ///    prevent the copy.
 /// 3) for (const foo x : foos) where x is constructed from a reference foo.
 ///    Suggest "const foo &x" to prevent the copy.
 static void DiagnoseForRangeVariableCopies(Sema &SemaRef,
                                            const CXXForRangeStmt *ForStmt) {
   if (SemaRef.Diags.isIgnored(diag::warn_for_range_const_reference_copy,
                               ForStmt->getLocStart()) &&

lib/Sema/SemaTemplate.cpp

case TSK_ExplicitSpecialization:
       Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
         << PrevDecl;
       Diag(PrevDecl->getLocation(),
            diag::note_previous_template_specialization);
       HasNoEffect = true;
       return false;
 
     case TSK_ExplicitInstantiationDeclaration:
-      // We're explicity instantiating a definition for something for which we
+      // We're explicitly instantiating a definition for something for which we
       // were previously asked to suppress instantiations. That's fine.
 
       // C++0x [temp.explicit]p4:
       //   For a given set of template parameters, if an explicit instantiation
       //   of a template appears after a declaration of an explicit
       //   specialization for that template, the explicit instantiation has no
       //   effect.
       for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {

lib/Sema/SemaTemplateDeduction.cpp

case TemplateArgument::Declaration:
     // bound.
     if (Y.getKind() == TemplateArgument::Integral) {
       if (Y.wasDeducedFromArrayBound())
         return TemplateArgument(Context, Y.getAsIntegral(),
                                 X.getParamTypeForDecl());
       return Y;
     }
 
-    // If we deduced two declarations, make sure they they refer to the
+    // If we deduced two declarations, make sure that they refer to the
     // same declaration.
     if (Y.getKind() == TemplateArgument::Declaration &&
         isSameDeclaration(X.getAsDecl(), Y.getAsDecl()))
       return X;
 
     // All other combinations are incompatible.
     return DeducedTemplateArgument();
 

lib/Sema/SemaType.cpp

 }
 
 static void deduceOpenCLImplicitAddrSpace(TypeProcessingState &State,
                                           QualType &T, TypeAttrLocation TAL) {
   Declarator &D = State.getDeclarator();
 
   // Handle the cases where address space should not be deduced.
   //
-  // The pointee type of a pointer type is alwasy deduced since a pointer always
+  // The pointee type of a pointer type is always deduced since a pointer always
   // points to some memory location which should has an address space.
   //
   // There are situations that at the point of certain declarations, the address
   // space may be unknown and better to be left as default. For example, when
-  // definining a typedef or struct type, they are not associated with any
+  // defining a typedef or struct type, they are not associated with any
   // specific address space. Later on, they may be used with any address space
   // to declare a variable.
   //
   // The return value of a function is r-value, therefore should not have
   // address space.
   //
   // The void type does not occupy memory, therefore should not have address
   // space, except when it is used as a pointee type.

lib/Sema/TreeTransform.h

 /// template arguments for their corresponding template parameters; a similar
 /// transformation is performed for non-type template parameters and
 /// template template parameters.
 ///
 /// This tree-transformation template uses static polymorphism to allow
 /// subclasses to customize any of its operations. Thus, a subclass can
 /// override any of the transformation or rebuild operators by providing an
 /// operation with the same signature as the default implementation. The
-/// overridding function should not be virtual.
+/// overriding function should not be virtual.
 ///
 /// Semantic tree transformations are split into two stages, either of which
 /// can be replaced by a subclass. The "transform" step transforms an AST node
 /// or the parts of an AST node using the various transformation functions,
 /// then passes the pieces on to the "rebuild" step, which constructs a new AST
 /// node of the appropriate kind from the pieces. The default transformation
 /// routines recursively transform the operands to composite AST nodes (e.g.,
 /// the pointee type of a PointerType node) and, if any of those operand nodes

lib/Serialization/ASTReader.cpp

if (Complain) {
       Error(ErrorStr);
     }
     // Record that we didn't find the file.
     F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
     return InputFile();
   }
 
   // Check if there was a request to override the contents of the file
-  // that was part of the precompiled header. Overridding such a file
+  // that was part of the precompiled header. Overriding such a file
   // can lead to problems when lexing using the source locations from the
   // PCH.
   SourceManager &SM = getSourceManager();
   // FIXME: Reject if the overrides are different.
   if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
     if (Complain)
       Error(diag::err_fe_pch_file_overridden, Filename);
     // After emitting the diagnostic, recover by disabling the override so

lib/Serialization/ASTWriter.cpp

 //===----------------------------------------------------------------------===//
 // Declaration Serialization
 //===----------------------------------------------------------------------===//
 
 /// \brief Write the block containing all of the declaration IDs
 /// lexically declared within the given DeclContext.
 ///
 /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the
-/// bistream, or 0 if no block was written.
+/// bitstream, or 0 if no block was written.
 uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
                                                  DeclContext *DC) {
   if (DC->decls_empty())
     return 0;
 
   uint64_t Offset = Stream.GetCurrentBitNo();
   SmallVector<uint32_t, 128> KindDeclPairs;
   for (const auto *D : DC->decls()) {

lib/StaticAnalyzer/Checkers/ChrootChecker.cpp

if (!FD)
     return;
 
   ASTContext &Ctx = C.getASTContext();
   if (!II_chroot)
     II_chroot = &Ctx.Idents.get("chroot");
   if (!II_chdir)
     II_chdir = &Ctx.Idents.get("chdir");
 
-  // Ingnore chroot and chdir.
+  // Ignore chroot and chdir.
   if (FD->getIdentifier() == II_chroot || FD->getIdentifier() == II_chdir)
     return;
 
   // If jail state is ROOT_CHANGED, generate BugReport.
   void *const* k = C.getState()->FindGDM(ChrootChecker::getTag());
   if (k)
     if (isRootChanged((intptr_t) *k))
       if (ExplodedNode *N = C.generateNonFatalErrorNode()) {

lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp

static const Expr *stripCastsAndSugar(const Expr *E) {
   if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
     E = POE->getSyntacticForm()->IgnoreParenImpCasts();
   if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E))
     E = OVE->getSourceExpr()->IgnoreParenImpCasts();
   return E;
 }
 
 static bool isObjCTypeParamDependent(QualType Type) {
-  // It is illegal to typedef parameterized types inside an interface. Therfore
+  // It is illegal to typedef parameterized types inside an interface. Therefore
   // an Objective-C type can only be dependent on a type parameter when the type
   // parameter structurally present in the type itself.
   class IsObjCTypeParamDependentTypeVisitor
       : public RecursiveASTVisitor<IsObjCTypeParamDependentTypeVisitor> {
   public:
     IsObjCTypeParamDependentTypeVisitor() : Result(false) {}
     bool VisitObjCTypeParamType(const ObjCTypeParamType *Type) {
       if (isa<ObjCTypeParamDecl>(Type->getDecl())) {

lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp

 //  invalidated. We call an instance variable ivalidatable if it is an object of
 //  a class which contains an invalidation method. There could be multiple
 //  methods annotated with such annotations per class, either one can be used
 //  to invalidate the ivar. An ivar or property are considered to be
 //  invalidated if they are being assigned 'nil' or an invalidation method has
 //  been called on them. An invalidation method should either invalidate all
 //  the ivars or call another invalidation method (on self).
 //
-//  Partial invalidor annotation allows to addess cases when ivars are
+//  Partial invalidor annotation allows to address cases when ivars are
 //  invalidated by other methods, which might or might not be called from
 //  the invalidation method. The checker checks that each invalidation
 //  method and all the partial methods cumulatively invalidate all ivars.
 //    __attribute__((annotate("objc_instance_variable_invalidator_partial")));
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangSACheckers.h"

lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

 ///
 /// We cannot use the path sensitive check because the macro argument we are
 /// checking for (comment) is not used and thus not present in the AST,
 /// so we use Lexer on the original macro call and retrieve the value of
 /// the comment. If it's empty or nil, we raise a warning.
 void EmptyLocalizationContextChecker::MethodCrawler::VisitObjCMessageExpr(
     const ObjCMessageExpr *ME) {
 
-  // FIXME: We may be able to use PPCallbacks to check for empy context
+  // FIXME: We may be able to use PPCallbacks to check for empty context
   // comments as part of preprocessing and avoid this re-lexing hack.
   const ObjCInterfaceDecl *OD = ME->getReceiverInterface();
   if (!OD)
     return;
 
   const IdentifierInfo *odInfo = OD->getIdentifier();
 
   if (!(odInfo->isStr("NSBundle") &&
bool PluralMisuseChecker::MethodCrawler::VisitConditionalOperator(
   return true;
 }
 
 void PluralMisuseChecker::MethodCrawler::reportPluralMisuseError(
     const Stmt *S) const {
   // Generate the bug report.
   BR.EmitBasicReport(AC->getDecl(), Checker, "Plural Misuse",
                      "Localizability Issue (Apple)",
-                     "Plural cases are not supported accross all languages. "
+                     "Plural cases are not supported across all languages. "
                      "Use a .stringsdict file instead",
                      PathDiagnosticLocation(S, BR.getSourceManager(), AC));
 }
 
 //===----------------------------------------------------------------------===//
 // Checker registration.
 //===----------------------------------------------------------------------===//
 

lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp

private:
 
   bool isGlobalConstString(SVal V) const;
 
   bool isNonnullType(QualType Ty) const;
 };
 
 } // namespace
 
-/// Lazily initialize cache for required identifier informations.
+/// Lazily initialize cache for required identifier information.
 void NonnullGlobalConstantsChecker::initIdentifierInfo(ASTContext &Ctx) const {
   if (NSStringII)
     return;
 
   NSStringII = &Ctx.Idents.get("NSString");
   CFStringRefII = &Ctx.Idents.get("CFStringRef");
   CFBooleanRefII = &Ctx.Idents.get("CFBooleanRef");
 }

lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp

 // heuristics to suppress warnings in some cases) but will not warn if the
 // invariant has already been violated along the path (either directly or
 // indirectly). As a practical matter, this prevents the analyzer from
 // (1) warning on defensive code paths where a nullability precondition is
 // determined to have been violated, (2) warning additional times after an
 // initial direct violation has been discovered, and (3) warning after a direct
 // violation that has been implicitly or explicitly suppressed (for
 // example, with a cast of NULL to _Nonnull). In essence, once an invariant
-// violation is detected on a path, this checker will be esentially turned off
+// violation is detected on a path, this checker will be essentially turned off
 // for the rest of the analysis
 //
 // The analyzer takes this approach (rather than generating a sink node) to
 // ensure coverage of defensive paths, which may be important for backwards
 // compatibility in codebases that were developed without nullability in mind.
 REGISTER_TRAIT_WITH_PROGRAMSTATE(InvariantViolated, bool)
 
 enum class NullConstraint { IsNull, IsNotNull, Unknown };

lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp

const RetainSummary * find(const ObjCInterfaceDecl *D, Selector S) {
     // Cache the summary with original key to make the next lookup faster
     // and return the iterator.
     const RetainSummary *Summ = I->second;
     M[K] = Summ;
     return Summ;
   }
 
   const RetainSummary *find(IdentifierInfo* II, Selector S) {
-    // FIXME: Class method lookup.  Right now we dont' have a good way
+    // FIXME: Class method lookup.  Right now we don't have a good way
     // of going between IdentifierInfo* and the class hierarchy.
     MapTy::iterator I = M.find(ObjCSummaryKey(II, S));
 
     if (I == M.end())
       I = M.find(ObjCSummaryKey(S));
 
     return I == M.end() ? nullptr : I->second;
   }

lib/StaticAnalyzer/Core/ExprEngineCXX.cpp

for (ExplodedNodeSet::iterator I = DstPreCall.begin(), E = DstPreCall.end();
       performTrivialCopy(Bldr, *I, *Call);
 
   } else {
     for (ExplodedNodeSet::iterator I = DstPreCall.begin(), E = DstPreCall.end();
          I != E; ++I)
       defaultEvalCall(Bldr, *I, *Call, CallOpts);
   }
 
-  // If the CFG was contructed without elements for temporary destructors
+  // If the CFG was constructed without elements for temporary destructors
   // and the just-called constructor created a temporary object then
   // stop exploration if the temporary object has a noreturn constructor.
   // This can lose coverage because the destructor, if it were present
   // in the CFG, would be called at the end of the full expression or
   // later (for life-time extended temporaries) -- but avoids infeasible
   // paths when no-return temporary destructors are used for assertions.
   const AnalysisDeclContext *ADC = LCtx->getAnalysisDeclContext();
   if (!ADC->getCFGBuildOptions().AddTemporaryDtors) {

lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp

while (Node) {
     Node = *Node->pred_begin();
   }
 
   return std::make_pair(S, Blk);
 }
 
 /// Adjusts a return value when the called function's return type does not
 /// match the caller's expression type. This can happen when a dynamic call
-/// is devirtualized, and the overridding method has a covariant (more specific)
+/// is devirtualized, and the overriding method has a covariant (more specific)
 /// return type than the parent's method. For C++ objects, this means we need
 /// to add base casts.
 static SVal adjustReturnValue(SVal V, QualType ExpectedTy, QualType ActualTy,
                               StoreManager &StoreMgr) {
   // For now, the only adjustments we handle apply only to locations.
   if (!V.getAs<Loc>())
     return V;
 

lib/StaticAnalyzer/Core/Store.cpp

while (const CXXRecordDecl *MRClass = getCXXRecordType(MR)) {
     // derived class has a zero offset from the base class), then it's safe
     // to strip the cast; if it's invalid, -Wreinterpret-base-class should
     // catch it. In the interest of performance, the analyzer will silently
     // do the wrong thing in the invalid case (because offsets for subregions
     // will be wrong).
     const MemRegion *Uncasted = MR->StripCasts(/*IncludeBaseCasts=*/false);
     if (Uncasted == MR) {
       // We reached the bottom of the hierarchy and did not find the derived
-      // class. We we must be casting the base to derived, so the cast should
+      // class. We must be casting the base to derived, so the cast should
       // fail.
       break;
     }
 
     MR = Uncasted;
   }
 
   // We failed if the region we ended up with has perfect type info.

lib/StaticAnalyzer/Frontend/ModelInjector.cpp

void ModelInjector::onBodySynthesis(const NamedDecl *D) {
   Instance.getPreprocessor().FinalizeForModelFile();
 
   Instance.resetAndLeakSourceManager();
   Instance.resetAndLeakFileManager();
   Instance.resetAndLeakPreprocessor();
 
   // The preprocessor enters to the main file id when parsing is started, so
   // the main file id is changed to the model file during parsing and it needs
-  // to be reseted to the former main file id after parsing of the model file
+  // to be reset to the former main file id after parsing of the model file
   // is done.
   SM.setMainFileID(mainFileID);
 }

lib/Tooling/ASTDiff/ASTDiff.cpp

if (!Context)
     return Val;
   if (auto *Namespace = dyn_cast<NamespaceDecl>(Context))
     ContextPrefix = Namespace->getQualifiedNameAsString();
   else if (auto *Record = dyn_cast<RecordDecl>(Context))
     ContextPrefix = Record->getQualifiedNameAsString();
   else if (AST.getLangOpts().CPlusPlus11)
     if (auto *Tag = dyn_cast<TagDecl>(Context))
       ContextPrefix = Tag->getQualifiedNameAsString();
-  // Strip the qualifier, if Val refers to somthing in the current scope.
+  // Strip the qualifier, if Val refers to something in the current scope.
   // But leave one leading ':' in place, so that we know that this is a
   // relative path.
   if (!ContextPrefix.empty() && StringRef(Val).startswith(ContextPrefix))
     Val = Val.substr(ContextPrefix.size() + 1);
   return Val;
 }
 
 std::string SyntaxTree::Impl::getRelativeName(const NamedDecl *ND) const {

lib/Tooling/Core/Replacement.cpp

 }
 
 // `R` and `Replaces` are order-independent if applying them in either order
 // has the same effect, so we need to compare replacements associated to
 // applying them in either order.
 llvm::Expected<Replacements>
 Replacements::mergeIfOrderIndependent(const Replacement &R) const {
   Replacements Rs(R);
-  // A Replacements set containg a single replacement that is `R` referring to
+  // A Replacements set containing a single replacement that is `R` referring to
   // the code after the existing replacements `Replaces` are applied.
   Replacements RsShiftedByReplaces(getReplacementInChangedCode(R));
   // A Replacements set that is `Replaces` referring to the code after `R` is
   // applied.
   Replacements ReplacesShiftedByRs;
   for (const auto &Replace : Replaces)
     ReplacesShiftedByRs.Replaces.insert(
         Rs.getReplacementInChangedCode(Replace));

lib/Tooling/FileMatchTrie.cpp

public:
   ///
   /// If multiple paths fit 'FileName' equally well, \c IsAmbiguous is set to
   /// \c true and an empty string is returned. If no path fits 'FileName', an
   /// empty string is returned. \c ConsumedLength denotes the number of
   /// \c Filename's trailing characters already consumed during recursion.
   ///
   /// To find the best matching node for a given path 'p', the
   /// \c findEquivalent() function is called recursively for each path segment
-  /// (back to fron) of 'p' until a node 'n' is reached that does not ..
+  /// (back to front) of 'p' until a node 'n' is reached that does not ..
   /// - .. have children. In this case it is checked
   ///   whether the stored path is equivalent to 'p'. If yes, the best match is
   ///   found. Otherwise continue with the parent node as if this node did not
   ///   exist.
   /// - .. a child matching the next path segment. In this case, all children of
   ///   'n' are an equally good match for 'p'. All children are of 'n' are found
   ///   recursively and their equivalence to 'p' is determined. If none are
   ///   equivalent, continue with the parent node as if 'n' didn't exist. If one

lib/Tooling/Refactoring/Rename/USRLocFinder.cpp

createRenameAtomicChanges(llvm::ArrayRef<std::string> USRs,
 
   std::vector<tooling::AtomicChange> AtomicChanges;
   auto Replace = [&](SourceLocation Start, SourceLocation End,
                      llvm::StringRef Text) {
     tooling::AtomicChange ReplaceChange = tooling::AtomicChange(SM, Start);
     llvm::Error Err = ReplaceChange.replace(
         SM, CharSourceRange::getTokenRange(Start, End), Text);
     if (Err) {
-      llvm::errs() << "Faile to add replacement to AtomicChange: "
+      llvm::errs() << "Failed to add replacement to AtomicChange: "
                    << llvm::toString(std::move(Err)) << "\n";
       return;
     }
     AtomicChanges.push_back(std::move(ReplaceChange));
   };
 
   for (const auto &RenameInfo : Finder.getRenameInfos()) {
     std::string ReplacedName = NewName.str();

test/ASTMerge/namespace/test.cpp

 // RUN: %clang_cc1 -emit-pch -std=c++1z -o %t.1.ast %S/Inputs/namespace1.cpp
 // RUN: %clang_cc1 -emit-pch -std=c++1z -o %t.2.ast %S/Inputs/namespace2.cpp
 // RUN: not %clang_cc1 -std=c++1z -ast-merge %t.1.ast -ast-merge %t.2.ast -fsyntax-only %s 2>&1 | FileCheck %s
 
 static_assert(TestAliasName::z == 4);
 static_assert(ContainsInline::z == 10);
 
 void testImport() {
   typedef TestUnresolvedTypenameAndValueDecls::Derived<int> Imported;
-  Imported a; // Successfull instantiation
+  Imported a; // Successful instantiation
   static_assert(sizeof(Imported::foo) == sizeof(int));
   static_assert(sizeof(TestUnresolvedTypenameAndValueDecls::Derived<double>::NewUnresolvedUsingType) == sizeof(double));
 }
 
 
 // CHECK: namespace2.cpp:16:17: error: external variable 'z' declared with incompatible types in different translation units ('double' vs. 'float')
 // CHECK: namespace1.cpp:16:16: note: declared here with type 'float'

test/Analysis/analyzeOneFunction.m

 
 @implementation Test1
 
 @synthesize text;
 
 -(id)myMethod {
   Test1 *cell = [[[Test1 alloc] init] autorelease];
 
-  NSString *string1 = [[NSString alloc] initWithFormat:@"test %f", 0.0]; // No warning: this function is not analized.
+  NSString *string1 = [[NSString alloc] initWithFormat:@"test %f", 0.0]; // No warning: this function is not analyzed.
   cell.text = string1;
 
   return cell;
 }
 
 -(id)myMethodWithY:(int)Y withX:(int)X {
   Test1 *cell = [[[Test1 alloc] init] autorelease];
 
   NSString *string1 = [[NSString alloc] initWithFormat:@"test %f %d", 0.0, X+Y]; // expected-warning {{Potential leak}}
   cell.text = string1;
 
   return cell;
 }
 
 @end

test/Analysis/copypaste/macro-complexity.cpp

int manualMacro(int a, int b) { // expected-warning{{Duplicate code detected}}
   return a > b ? -a * a : -b * b;
 }
 
 int manualMacroClone(int a, int b) { // expected-note{{Similar code here}}
   return a > b ? -a * a : -b * b;
 }
 
 // Now we actually use the macro to generate the same AST as above. They
-// shouldn't be reported because the macros only slighly increase the complexity
+// shouldn't be reported because the macros only slightly increase the complexity
 // value and the resulting code will never pass the MinimumCloneComplexity
 // constraint.
 
 int macro(int a, int b) {
   return MACRO_FOO(a, b);
 }
 
 int macroClone(int a, int b) {

test/Analysis/dead-stores.c

void rdar8405222() {
     
   if (show)
       i = 5; // no-warning
 
   if (show)
     rdar8405222_aux(i);
 }
 
-// Look through chains of assignements, e.g.: int x = y = 0, when employing
+// Look through chains of assignments, e.g.: int x = y = 0, when employing
 // silencing heuristics.
 int radar11185138_foo() {
   int x, y;
   x = y = 0; // expected-warning {{never read}}
   return y;
 }
 
 int rdar11185138_bar() {

test/Analysis/dynamic_type_check.m

 void testTypeCheck(NSString* str) {
   id obj = str;
   NSNumber *num = obj; // expected-warning {{}}
   (void)num;
 }
 
 void testForwardDeclarations(NSString* str) {
   id obj = str;
-  // Do not warn, since no information is available wether MyType is a sub or
+  // Do not warn, since no information is available whether MyType is a sub or
   // super class of any other type.
   MyType *num = obj; // no warning
   (void)num;
 }

test/Analysis/localization.m

 }
 
 // Plural Misuse Checker Tests
 // These tests are modeled off incorrect uses of the many-one pattern
 // from real projects. 
 
 - (NSString *)test1:(int)plural {
     if (plural) {
-        return MCLocalizedString(@"TYPE_PLURAL"); // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return MCLocalizedString(@"TYPE_PLURAL"); // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     }
     return MCLocalizedString(@"TYPE");
 }
 
 - (NSString *)test2:(int)numOfReminders {
     if (numOfReminders > 0) {
-        return [NSString stringWithFormat:@"%@, %@", @"Test", (numOfReminders != 1) ? [NSString stringWithFormat:NSLocalizedString(@"%@ Reminders", @"Plural count of reminders"), numOfReminders] : [NSString stringWithFormat:NSLocalizedString(@"1 reminder", @"One reminder")]]; // expected-warning 2 {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note 2 {{Plural}}
+        return [NSString stringWithFormat:@"%@, %@", @"Test", (numOfReminders != 1) ? [NSString stringWithFormat:NSLocalizedString(@"%@ Reminders", @"Plural count of reminders"), numOfReminders] : [NSString stringWithFormat:NSLocalizedString(@"1 reminder", @"One reminder")]]; // expected-warning 2 {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note 2 {{Plural}}
     } 
     return nil;
 }
 
 - (void)test3 {
     NSString *count;
     if (self.unreadArticlesCount > 1)
     {
-        count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Stories", @"Plural count for new stories")]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Stories", @"Plural count for new stories")]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     } else {
-        count = [count stringByAppendingFormat:@"%@",  KHLocalizedString(@"New Story", @"One new story")]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        count = [count stringByAppendingFormat:@"%@",  KHLocalizedString(@"New Story", @"One new story")]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     }
 }
 
 - (NSString *)test4:(int)count {
     if ( count == 1 )
     {
-        return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     } else {
-        return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     }
 }
 
 - (NSString *)test5:(int)count {
   int test = count == 1;
     if (test)
     {
-        return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     } else {
-        return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     }
 }
 
 // This tests the heuristic that the direct parent IfStmt must match the isCheckingPlurality confition to avoid false positives generated from complex code (generally the pattern we're looking for is simple If-Else)
 
 - (NSString *)test6:(int)sectionIndex {
   int someOtherVariable = 0;
     if (sectionIndex == 1)
     {
     // Do some other crazy stuff
     if (someOtherVariable)
           return KHLocalizedString(@"OK",nil); // no-warning
     } else {
-        return KHLocalizedString(@"value.plural",nil); // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return KHLocalizedString(@"value.plural",nil); // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     }
   return nil;
 }
 
 // False positives that we are not accounting for involve matching the heuristic
 // of having 1 or 2 in the RHS of a BinaryOperator and having a localized string 
 // in the body of the IfStmt. This is seen a lot when checking for the section
 // indexpath of something like a UITableView

test/Analysis/misc-ps-region-store.m

void pr8015_C() {
   int number = pr8015_A();
   const char *numbers[] = { "zero" };    
   if (number == 0) {
       pr8015_B(numbers[number]); // no-warning
   }
 }
 
 // Tests that we correctly handle that 'number' is perfectly constrained
-// after 'if (nunber == 0)', allowing us to resolve that
+// after 'if (number == 0)', allowing us to resolve that
 // numbers[number] == numbers[0].
 void pr8015_D_FIXME() {
   int number = pr8015_A();
   const char *numbers[] = { "zero" };
   if (number == 0) {
     if (numbers[number] == numbers[0])
       return;
     // Unreachable.

test/Analysis/new.cpp

void testNewDeleteNoWarn() {
   delete p2; // no-warning
 
   int *p3 = new int; // no-warning
 }
 
 // unix.Malloc does not know about operators new/delete.
 void testDeleteMallocked() {
   int *x = (int *)malloc(sizeof(int));
-  delete x; // FIXME: Shoud detect pointer escape and keep silent after 'delete' is modeled properly.
+  delete x; // FIXME: Should detect pointer escape and keep silent after 'delete' is modeled properly.
 } // expected-warning{{Potential leak of memory pointed to by 'x'}}
 
 void testDeleteOpAfterFree() {
   int *p = (int *)malloc(sizeof(int));
   free(p);
   operator delete(p); // expected-warning{{Use of memory after it is freed}}
 }
 

test/Analysis/nullability.mm

- (instancetype _Nonnull)initWithNonnullReturnAndNilReturnViaLocal {
   return other;
 }
 @end
 
 @interface SubClassWithInitializers : ClassWithInitializers
 @end
 
 @implementation SubClassWithInitializers
-// Note: Because this is overridding
+// Note: Because this is overriding
 // -[ClassWithInitializers initWithNonnullReturnAndSelfCheckingIdiom],
 // the return type of this method becomes implicitly id _Nonnull.
 - (id)initWithNonnullReturnAndSelfCheckingIdiom {
   if (self = [super initWithNonnullReturnAndSelfCheckingIdiom]) {
   }
 
   return self; // no-warning
 }

test/Analysis/objc-properties.m

 
 @interface MyClass;
 @end
 @interface TestProperty :NSObject {
   MyClass *_Z;
   id _nonSynth;
 }
 
-  @property (assign, nonatomic) MyClass* A; // explicitely synthesized, not implemented, non-default ivar name
+  @property (assign, nonatomic) MyClass* A; // explicitly synthesized, not implemented, non-default ivar name
 
   @property (assign) MyClass* X;  // automatically synthesized, not implemented
 
   @property (assign, nonatomic) MyClass* Y; // automatically synthesized, implemented
 
   @property (assign, nonatomic) MyClass* Z; // non-synthesized ivar, implemented setter
   @property (readonly) id nonSynth;  // non-synthesized, explicitly implemented to return ivar with expected name
   
@implementation TestProperty
   - (void) someMethod: (MyClass*)In {
     (__A) = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}}
     _X = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}}
     _Y = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}}
     _Z = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}}
     _nonSynth = 0; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}}
   }
 @end
 No newline at end of file

test/Analysis/objc/direct-ivar-assignment-in-annotated-functions.m

 
 
 @interface TestProperty : AnnotatedClass {
   MyClass *_Z;
   id _nonSynth;
   MyClass* _NotA __attribute__((annotate("objc_allow_direct_instance_variable_assignment")));
 }
 
-  @property (assign, nonatomic) MyClass* A; // explicitely synthesized, not implemented, non-default ivar name
+  @property (assign, nonatomic) MyClass* A; // explicitly synthesized, not implemented, non-default ivar name
 
   @property (assign) MyClass* X;  // automatically synthesized, not implemented
 
   @property (assign, nonatomic) MyClass* Y; // automatically synthesized, implemented
 
   @property (assign, nonatomic) MyClass* Z; // non-synthesized ivar, implemented setter
   @property (readonly) id nonSynth;  // non-synthesized, explicitly implemented to return ivar with expected name
   
- (void) someMethodNotAnnaotated: (MyClass*)In {
     (__A) = In; 
     _X = In; // no-warning
     _Y = In; // no-warning
     _Z = In; // no-warning
     _nonSynth = 0; // no-warning
   }
 
 @end
 No newline at end of file

test/Analysis/retain-release-path-notes.m

 }
 
 -(id)initZ {
   self = [super init];
   return self;
 }
 
 +(void)test {
-  // initX is inlined since we explicitely mark it as interesting
+  // initX is inlined since we explicitly mark it as interesting
   id x = [[MyObj alloc] initX]; // expected-warning {{Potential leak of an object}}
                                 // expected-note@-1 {{Method returns an instance of MyObj with a +1 retain count}}
                                 // expected-note@-2 {{Calling 'initX'}}
                                 // expected-note@-3 {{Returning from 'initX'}}
                                 // expected-note@-4 {{Object leaked: allocated object is not referenced later in this execution path and has a retain count of +1}}
   // initI is inlined because the allocation happens within initY
   id y = [[MyObj alloc] initY];
                                 // expected-note@-1 {{Calling 'initY'}}

test/Analysis/string.c

void strsep_changes_input_string() {
   // character. For now, we just model the invalidation.
   clang_analyzer_eval(str[1] == 'b'); // expected-warning{{UNKNOWN}}
 }
 
 //===----------------------------------------------------------------------===
 // FIXMEs
 //===----------------------------------------------------------------------===
 
-// The analyzer_eval call below should evaluate to true. We are being too 
-// aggressive in marking the (length of) src symbol dead. The length of dst 
-// depends on src. This could be explicitely specified in the checker or the 
+// The analyzer_eval call below should evaluate to true. We are being too
+// aggressive in marking the (length of) src symbol dead. The length of dst
+// depends on src. This could be explicitly specified in the checker or the
 // logic for handling MetadataSymbol in SymbolManager needs to change.
 void strcat_symbolic_src_length(char *src) {
   char dst[8] = "1234";
   strcat(dst, src);
   clang_analyzer_eval(strlen(dst) >= 4); // expected-warning{{UNKNOWN}}
 }
 
 

test/CXX/special/class.init/class.inhctor.init/p1.cpp

struct Param {
     int n;
   };
 
   constexpr A::A(Param p) : a(p.n) {}
 
   constexpr B b(1);
   constexpr B c(1);
   static_assert(b.a == 1, "p should be initialized before B() is executed");
-  static_assert(c.a == 7, "b not initialzed properly");
+  static_assert(c.a == 7, "b not initialized properly");
 }
 
 namespace default_args {
   // We work around a defect in P0136R1 where it would reject reasonable
   // code like the following:
   struct Base {
     Base(int = 0);
   };
   struct Derived : Base {
     using Base::Base;
   };
   Derived d;
   // FIXME: Once a fix is standardized, implement it.
 }

test/CodeGen/arm64_vdup.c

float64x1_t test_vdup_n_f64(float64_t a1) {
   // CHECK@ insertelement {{.*, i32 0 *$}}
 }
 */
 
 float16x8_t test_vdupq_n_f16(float16_t *a1) {
   // CHECK-LABEL: test_vdupq_n_f16
   return vdupq_n_f16(*a1);
   // match that an element is inserted into parts 0-7.  The backend better
-  // turn that into a single dup intruction
+  // turn that into a single dup instruction
   // CHECK: insertelement {{.*, i32 0 *$}}
   // CHECK: insertelement {{.*, i32 1 *$}}
   // CHECK: insertelement {{.*, i32 2 *$}}
   // CHECK: insertelement {{.*, i32 3 *$}}
   // CHECK: insertelement {{.*, i32 4 *$}}
   // CHECK: insertelement {{.*, i32 5 *$}}
   // CHECK: insertelement {{.*, i32 6 *$}}
   // CHECK: insertelement {{.*, i32 7 *$}}
 }

test/CodeGen/debug-info-block-out-return.c

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -debug-info-kind=limited -fblocks -emit-llvm -o - %s | FileCheck %s
 
 // Check that arg numbering is not affected by LLVM IR argument numbering -
 // since the latter is affected by return-by-out-parameter ABI requirements
 
 // 1 for the argument number (1 indexed), 2 for the line number
 // 16777218 == 1 << 24 | 2
 // 33554434 == 2 << 24 | 2
 // This explains the two magic numbers below, testing that these two arguments
 // are numbered correctly. If they are not numbered correctly they may appear
 // out of order or not at all (the latter would occur if they were both assigned
 // the same argument number by mistake).
 
 // CHECK: !DILocalVariable(name: ".block_descriptor", arg: 1,{{.*}}line: 2,
 // CHECK: !DILocalVariable(name: "param", arg: 2,{{.*}}line: 2,
 
-// Line directive so we don't have to worry about how many lines preceed the
+// Line directive so we don't have to worry about how many lines precede the
 // test code (as the line number is mangled in with the argument number as shown
 // above)
 #line 1
 typedef struct { int array[12]; } BigStruct_t;
 BigStruct_t (^a)() = ^(int param) {
     BigStruct_t b;
     return b;
 };

test/CodeGen/pr3518.c

 // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
 // PR 3518
-// Some of the objects were coming out as unintialized (external) before 3518
+// Some of the objects were coming out as uninitialized (external) before 3518
 // was fixed.  Internal names are different between llvm-gcc and clang so they
 // are not tested.
 
 extern void abort (void);
 
 // CHECK: @.compoundliteral = internal global %struct.A { i32 1, i32 2 }
 // CHECK: @.compoundliteral.1 = internal global %struct.A { i32 3, i32 4 }
 // CHECK: @.compoundliteral.2 = internal global %struct.B { %struct.A* @.compoundliteral, %struct.A* @.compoundliteral.1 }

test/CodeGenCUDA/device-stub.cu

 // CHECK: define internal void @__cuda_register_globals
 // CHECK: call{{.*}}cudaRegisterFunction(i8** %0, {{.*}}kernelfunc
 // CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}device_var{{.*}}i32 0, i32 4, i32 0, i32 0
 // CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}constant_var{{.*}}i32 0, i32 4, i32 1, i32 0
 // CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}ext_device_var{{.*}}i32 1, i32 4, i32 0, i32 0
 // CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}ext_constant_var{{.*}}i32 1, i32 4, i32 1, i32 0
 // CHECK: ret void
 
-// Test that we've built contructor..
+// Test that we've built constructor..
 // CHECK: define internal void @__cuda_module_ctor
 //   .. that calls __cudaRegisterFatBinary(&__cuda_fatbin_wrapper)
 // CHECK: call{{.*}}cudaRegisterFatBinary{{.*}}__cuda_fatbin_wrapper
 //   .. stores return value in __cuda_gpubin_handle
 // CHECK-NEXT: store{{.*}}__cuda_gpubin_handle
 //   .. and then calls __cuda_register_globals
 // CHECK-NEXT: call void @__cuda_register_globals
 

test/CodeGenCUDA/propagate-metadata.cu

 // RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FTZ \
 // RUN:   --check-prefix=NOFAST
 
 // RUN: %clang_cc1 -x cuda %s -emit-llvm -mlink-cuda-bitcode %t.bc \
 // RUN:   -fno-trapping-math -fcuda-flush-denormals-to-zero -o - \
 // RUN:   -fcuda-is-device -menable-unsafe-fp-math -triple nvptx-unknown-unknown \
 // RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FAST
 
-// Wrap everything in extern "C" so we don't ahve to worry about name mangling
+// Wrap everything in extern "C" so we don't have to worry about name mangling
 // in the IR.
 extern "C" {
 #ifdef LIB
 
 // This function is defined in the library and only declared in the main
 // compilation.
 void lib_fn() {}
 

test/CodeGenCXX/abstract-class-ctors-dtors.cpp

 // RUN: %clang_cc1 %s -triple x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
 
-// Check that we dont emit the complete constructor/destructor for this class.
+// Check that we don't emit the complete constructor/destructor for this class.
 struct A {
   virtual void f() = 0;
   A();
   ~A();
 };
 
 // CHECK-NOT: define void @_ZN1AC1Ev
 // CHECK-LABEL: define void @_ZN1AC2Ev
 // CHECK-LABEL: define void @_ZN1AD2Ev
 // CHECK-LABEL: define void @_ZN1AD1Ev
 A::A() { }
 
 A::~A() { }

test/CodeGenCXX/ctor-dtor-alias.cpp

 // RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases | FileCheck --check-prefix=NOOPT %s
 
 // RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-passes > %t
 // RUN: FileCheck --check-prefix=CHECK1 --input-file=%t %s
 // RUN: FileCheck --check-prefix=CHECK2 --input-file=%t %s
 // RUN: FileCheck --check-prefix=CHECK3 --input-file=%t %s
 // RUN: FileCheck --check-prefix=CHECK4 --input-file=%t %s
 // RUN: FileCheck --check-prefix=CHECK5 --input-file=%t %s
 // RUN: FileCheck --check-prefix=CHECK6 --input-file=%t %s
 
 // RUN: %clang_cc1 %s -triple i686-pc-windows-gnu -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-passes | FileCheck --check-prefix=COFF %s
 
 namespace test1 {
-// Test that we produce the apropriate comdats when creating aliases to
+// Test that we produce the appropriate comdats when creating aliases to
 // weak_odr constructors and destructors.
 
 // CHECK1: @_ZN5test16foobarIvEC1Ev = weak_odr alias void {{.*}} @_ZN5test16foobarIvEC2Ev
 // CHECK1: @_ZN5test16foobarIvED1Ev = weak_odr alias void (%"struct.test1::foobar"*), void (%"struct.test1::foobar"*)* @_ZN5test16foobarIvED2Ev
 // CHECK1: define weak_odr void @_ZN5test16foobarIvEC2Ev({{.*}} comdat($_ZN5test16foobarIvEC5Ev)
 // CHECK1: define weak_odr void @_ZN5test16foobarIvED2Ev({{.*}} comdat($_ZN5test16foobarIvED5Ev)
 // CHECK1: define weak_odr void @_ZN5test16foobarIvED0Ev({{.*}} comdat($_ZN5test16foobarIvED5Ev)
 // CHECK1-NOT: comdat

test/CodeGenCXX/debug-info-class-nolimit.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin -debug-info-kind=standalone -o - -emit-llvm %s | FileCheck %s
 
 // We had a bug in -fstandalone-debug where UnicodeString would not be completed
-// when it was required to be complete. This orginally manifested as an
+// when it was required to be complete. This originally manifested as an
 // assertion in CodeView emission on Windows with some dllexport stuff, but it's
 // more general than that.
 
 struct UnicodeString;
 UnicodeString *force_fwd_decl;
 struct UnicodeString {
 private:
   virtual ~UnicodeString();

test/CodeGenCXX/duplicate-mangled-name.cpp

 }
 
 float foo() {
   return _ZN2nm3abcE + nm::abc;
 }
 
 #else
 
-#error Unknwon test
+#error Unknown test
 
 #endif
 

test/CodeGenOpenCL/amdgpu-nullptr.cl

 constant char *p3;
 
 // CHECK: @p4 = common local_unnamed_addr addrspace(1) global i8 addrspace(1)* null, align 8
 global char *p4;
 
 // CHECK: @p5 = common local_unnamed_addr addrspace(1) global i8* null, align 8
 generic char *p5;
 
-// Test default initialization of sturcture.
+// Test default initialization of structure.
 
 // CHECK: @S1 = weak local_unnamed_addr addrspace(1) global %struct.StructTy1 { i8 addrspace(5)* null, i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), i8 addrspace(4)* null, i8 addrspace(1)* null, i8* null }, align 8
 StructTy1 S1;
 
 // CHECK: @S2 = common local_unnamed_addr addrspace(1) global %struct.StructTy2 zeroinitializer, align 8
 StructTy2 S2;
 
 // Test default initialization of array.
test_cast_null_pointer_to_sizet_calee((size_t)((private char*)0),
                                         (size_t)((generic char*)0));
   test_cast_null_pointer_to_sizet_calee((size_t)((private char*)NULL),
                                         (size_t)((local char*)NULL),
                                         (size_t)((global char*)NULL),
                                         (size_t)((constant char*)0), // NULL cannot be casted to constant pointer since it is defined as a generic pointer
                                         (size_t)((generic char*)NULL));
 }
 
-// Test comparision between null pointers.
+// Test comparison between null pointers.
 #define TEST_EQ00(addr1, addr2) int test_eq00_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)0; }
 #define TEST_EQ0N(addr1, addr2) int test_eq0N_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)NULL; }
 #define TEST_EQN0(addr1, addr2) int test_eqN0_##addr1##_##addr2(void) { return (addr1 char*)NULL == (addr2 char*)0; }
 #define TEST_EQNN(addr1, addr2) int test_eqNN_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)NULL; }
 #define TEST_NE00(addr1, addr2) int test_ne00_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)0; }
 #define TEST_NE0N(addr1, addr2) int test_ne0N_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)NULL; }
 #define TEST_NEN0(addr1, addr2) int test_neN0_##addr1##_##addr2(void) { return (addr1 char*)NULL != (addr2 char*)0; }
 #define TEST_NENN(addr1, addr2) int test_neNN_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)NULL; }

test/Driver/config-file2.c

 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir=%S/Inputs/config2 --config x86_64-qqq2 -m32 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD1
 // CHECK-RELOAD1: Target: i386
 // CHECK-RELOAD1: Configuration file: {{.*}}Inputs{{.}}config2{{.}}i386.cfg
 
 
 //--- Invocation `clang --config x86_64-qqq2 -m32` loads `x86_64-qqq2.cfg` if `i386-qqq2.cfg` and `i386.cfg` do not exist.
 //
 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq2 -m32 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD2
-// note: target is overriden due to -m32
+// note: target is overridden due to -m32
 // CHECK-RELOAD2: Target: i386
 // CHECK-RELOAD2: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64-qqq2.cfg
 
 
 //--- Invocation `clang --config i386-qqq3 -m64` loads `x86_64.cfg` if `x86_64-qqq3.cfg` does not exist.
 //
 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config i386-qqq3 -m64 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD3
 // CHECK-RELOAD3: Target: x86_64
 // CHECK-RELOAD3: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64.cfg
 
 
 //--- Invocation `clang --config x86_64-qqq -target i386` loads `i386-qqq.cfg` if the latter exists.
 //
 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq -target i386 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD4
 // CHECK-RELOAD4: Target: i386
 // CHECK-RELOAD4: Configuration file: {{.*}}Inputs{{.}}config{{.}}i386-qqq.cfg
 
 
 //--- Invocation `clang --config x86_64-qqq2 -target i386` loads `x86_64-qqq2.cfg` if `i386-qqq2.cfg` and `i386.cfg` do not exist.
 //
 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq2 -target i386 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD5
-// note: target is overriden due to -target i386
+// note: target is overridden due to -target i386
 // CHECK-RELOAD5: Target: i386
 // CHECK-RELOAD5: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64-qqq2.cfg
 
 
 //--- Invocation `clang --config x86_64-qqq -target i386 -m64` loads `x86_64-qqq.cfg`.
 //
 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq -target i386 -m64 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD6
 // CHECK-RELOAD6: Target: x86_64
 // CHECK-RELOAD6: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64-qqq.cfg

test/Driver/cuda-options.cu

 // RUN:    -check-prefix LINK %s
 
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \
 // RUN:   --cuda-compile-host-device %s 2>&1 \
 // RUN: | FileCheck -check-prefix DEVICE -check-prefix DEVICE-NOSAVE \
 // RUN:    -check-prefix HOST -check-prefix INCLUDES-DEVICE \
 // RUN:    -check-prefix LINK %s
 
-// Verify that --cuda-gpu-arch option passes the correct GPU archtecture to
+// Verify that --cuda-gpu-arch option passes the correct GPU architecture to
 // device compilation.
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-gpu-arch=sm_30 -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix DEVICE -check-prefix DEVICE-NOSAVE \
 // RUN:    -check-prefix DEVICE-SM30 -check-prefix HOST \
 // RUN:    -check-prefix INCLUDES-DEVICE -check-prefix NOLINK %s
 
 // Verify that there is one device-side compilation per --cuda-gpu-arch args
 // and that all results are included on the host side.

 // Verify that device-side results are passed to the correct tool when
 // -fno-integrated-as is used.
 // RUN: %clang -### -target x86_64-linux-gnu -fno-integrated-as -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix DEVICE -check-prefix DEVICE-NOSAVE \
 // RUN:    -check-prefix HOST -check-prefix HOST-NOSAVE \
 // RUN:    -check-prefix HOST-AS -check-prefix NOLINK %s
 
 // Verify that --[no-]cuda-gpu-arch arguments are handled correctly.
-// a) --no-cuda-gpu-arch=X negates preceeding --cuda-gpu-arch=X
+// a) --no-cuda-gpu-arch=X negates preceding --cuda-gpu-arch=X
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \
 // RUN:   --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \
 // RUN:   --no-cuda-gpu-arch=sm_35 \
 // RUN:   -c %s 2>&1 \
 // RUN: | FileCheck -check-prefixes NOARCH-SM20,ARCH-SM30,NOARCH-SM35 %s
 
-// b) --no-cuda-gpu-arch=X negates more than one preceeding --cuda-gpu-arch=X
+// b) --no-cuda-gpu-arch=X negates more than one preceding --cuda-gpu-arch=X
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \
 // RUN:   --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \
 // RUN:   --no-cuda-gpu-arch=sm_35 \
 // RUN:   -c %s 2>&1 \
 // RUN: | FileCheck -check-prefixes NOARCH-SM20,ARCH-SM30,NOARCH-SM35 %s
 
-// c) if --no-cuda-gpu-arch=X negates all preceeding --cuda-gpu-arch=X
+// c) if --no-cuda-gpu-arch=X negates all preceding --cuda-gpu-arch=X
 //    we default to sm_20 -- same as if no --cuda-gpu-arch were passed.
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \
 // RUN:   --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \
 // RUN:   --no-cuda-gpu-arch=sm_35 --no-cuda-gpu-arch=sm_30 \
 // RUN:   -c %s 2>&1 \
 // RUN: | FileCheck -check-prefixes ARCH-SM20,NOARCH-SM30,NOARCH-SM35 %s
 
 // d) --no-cuda-gpu-arch=X is a no-op if there's no preceding --cuda-gpu-arch=X

test/Driver/darwin-version.c

 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TNO-OSV4 %s
 // CHECK-VERSION-TNO-OSV4: overriding '-miphoneos-version-min=10.1.0.1' option with '--target=arm64-apple-ios10.1.0'
 
 // RUN: %clang -target x86_64-apple-macos10.6 -mmacos-version-min=10.6 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TNO-SAME %s
 // CHECK-VERSION-TNO-SAME-NOT: overriding
 // CHECK-VERSION-TNO-SAME-NOT: argument unused during compilation
 
-// Target with OS version is not overriden by -m<os>-version-min variables:
+// Target with OS version is not overridden by -m<os>-version-min variables:
 
 // RUN: %clang -target x86_64-apple-macos10.11.2 -mmacos-version-min=10.6 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV1 %s
 // CHECK-VERSION-TIGNORE-OSV1: "x86_64-apple-macosx10.11.2"
 
 // RUN: %clang -target arm64-apple-ios11.0 -mios-version-min=9.0 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV2 %s
 // CHECK-VERSION-TIGNORE-OSV2: "arm64-apple-ios11.0.0"
 
 // RUN: %clang -target arm64-apple-tvos11.0 -mtvos-version-min=9.0 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV3 %s
 // CHECK-VERSION-TIGNORE-OSV3: "arm64-apple-tvos11.0.0"
 
 // RUN: %clang -target armv7k-apple-watchos3 -mwatchos-version-min=4 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV4 %s
 // CHECK-VERSION-TIGNORE-OSV4: "thumbv7k-apple-watchos3.0.0"
 
-// Target without OS version inlcudes the OS given by -m<os>-version-min arguments:
+// Target without OS version includes the OS given by -m<os>-version-min arguments:
 
 // RUN: %clang -target x86_64-apple-macos -mmacos-version-min=10.11 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG1 %s
 // CHECK-VERSION-USE-OS-ARG1: "x86_64-apple-macosx10.11.0"
 
 // RUN: %clang -target arm64-apple-ios -mios-version-min=9.0 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG2 %s
 // CHECK-VERSION-USE-OS-ARG2: "arm64-apple-ios9.0.0"
 
 // RUN: %clang -target arm64-apple-tvos -mtvos-version-min=10.0 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG3 %s
 // CHECK-VERSION-USE-OS-ARG3: "arm64-apple-tvos10.0.0"
 
 // RUN: %clang -target armv7k-apple-watchos -mwatchos-version-min=4 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG4 %s
 // CHECK-VERSION-USE-OS-ARG4: "thumbv7k-apple-watchos4.0.0"
 
-// Target with OS version is not overriden by environment variables:
+// Target with OS version is not overridden by environment variables:
 
 // RUN: env MACOSX_DEPLOYMENT_TARGET=10.1 \
 // RUN:   %clang -target i386-apple-macos10.5 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TMACOS-CMD %s
 // CHECK-VERSION-TMACOS-CMD: "i386-apple-macosx10.5.0"
 
 // RUN: env IPHONEOS_DEPLOYMENT_TARGET=10.1 \
 // RUN:   %clang -target arm64-apple-ios11 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TIOS-CMD %s
 // CHECK-VERSION-TIOS-CMD: "arm64-apple-ios11.0.0"
 
 // RUN: env TVOS_DEPLOYMENT_TARGET=8.3.1 \
 // RUN:   %clang -target arm64-apple-tvos9 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TTVOS-CMD %s
 // CHECK-VERSION-TTVOS-CMD: "arm64-apple-tvos9.0.0"
 
 // RUN: env WATCHOS_DEPLOYMENT_TARGET=2 \
 // RUN:   %clang -target armv7k-apple-watchos3 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TWATCHOS-CMD %s
 // CHECK-VERSION-TWATCHOS-CMD: "thumbv7k-apple-watchos3.0.0"
 
-// Target with OS version is not overriden by the SDK:
+// Target with OS version is not overridden by the SDK:
 
 // RUN: %clang -target armv7-apple-ios9 -Wno-missing-sysroot -isysroot SDKs/iPhoneOS11.0.sdk -c -### %s 2>&1 | \
 // RUN: FileCheck --check-prefix=CHECK-VERSION-TIOS-SDK %s
 // CHECK-VERSION-TIOS-SDK: thumbv7-apple-ios9
 
 // RUN: %clang -target armv7k-apple-watchos4 -Wno-missing-sysroot -isysroot SDKs/WatchOS3.0.sdk -c -### %s 2>&1 | \
 // RUN: FileCheck --check-prefix=CHECK-VERSION-TWATCHOS-SDK %s
 // CHECK-VERSION-TWATCHOS-SDK: thumbv7k-apple-watchos4
 
 // RUN: %clang -target armv7-apple-tvos9 -Wno-missing-sysroot -isysroot SDKs/AppleTVOS11.0.sdk -c -### %s 2>&1 | \
 // RUN: FileCheck --check-prefix=CHECK-VERSION-TTVOS-SDK %s
 // CHECK-VERSION-TTVOS-SDK: thumbv7-apple-tvos9
 
-// Target with OS version is not overriden by arch:
+// Target with OS version is not overridden by arch:
 
 // RUN: %clang -target uknown-apple-macos10.11.2 -arch=armv7k -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TIGNORE-ARCH1 %s
 // CHECK-VERSION-TIGNORE-ARCH1: "unknown-apple-macosx10.11.2"
 
 // Target can be used to specify the environment:
 
 // RUN: %clang -target x86_64-apple-ios11-simulator -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TENV-SIM1 %s
 // CHECK-VERSION-TENV-SIM1: "x86_64-apple-ios11.0.0-simulator"
 
 // RUN: %clang -target armv7k-apple-ios10.1-simulator -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TENV-SIM2 %s
 // CHECK-VERSION-TENV-SIM2: "thumbv7k-apple-ios10.1.0-simulator"

test/Driver/fsanitize-blacklist.c

 // Check that combining ubsan and another sanitizer results in both blacklists being used.
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined,address -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLACKLIST --check-prefix=CHECK-DEFAULT-ASAN-BLACKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blacklist=
 
 // Ignore -fsanitize-blacklist flag if there is no -fsanitize flag.
 // RUN: %clang -target x86_64-linux-gnu -fsanitize-blacklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SANITIZE --check-prefix=DELIMITERS
 // CHECK-NO-SANITIZE-NOT: -fsanitize-blacklist
 
 // Ignore -fsanitize-blacklist flag if there is no -fsanitize flag.
-// Now, check for the absense of -fdepfile-entry flags.
+// Now, check for the absence of -fdepfile-entry flags.
 // RUN: %clang -target x86_64-linux-gnu -fsanitize-blacklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SANITIZE2 --check-prefix=DELIMITERS
 // CHECK-NO-SANITIZE2-NOT: -fdepfile-entry
 
 // Flag -fno-sanitize-blacklist wins if it is specified later.
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-blacklist=%t.good -fno-sanitize-blacklist %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-BLACKLIST --check-prefix=DELIMITERS
 // CHECK-NO-BLACKLIST-NOT: -fsanitize-blacklist
 
 // Driver barks on unexisting blacklist files.

test/Driver/hexagon-hvx.c

 
 // No hvx target feature must be added if -mno-hvx occurs last
 // RUN: %clang -c %s -### -target hexagon-unknown-elf -mv62 -mno-hvx \
 // RUN:  2>&1 | FileCheck -check-prefix=CHECK-NOHVX %s
 // RUN: %clang -c %s -### -target hexagon-unknown-elf -mv62 -mhvx -mno-hvx \
 // RUN:  2>&1 | FileCheck -check-prefix=CHECK-NOHVX %s
 // CHECK-NOHVX-NOT: "-target-feature" "+hvx
 
-// Hvx target feature should be added if -mno-hvx doesnot occur last
+// Hvx target feature should be added if -mno-hvx doesn't occur last
 // RUN: %clang -c %s -### -target hexagon-unknown-elf -mv62 -mno-hvx -mhvx\
 // RUN:  2>&1 | FileCheck -check-prefix=CHECK-HVXFEAT %s
 // CHECK-HVXFEAT: "-target-feature" "+hvxv62"
 
 // With -mhvx, the version of hvx defaults to Cpu
 // RUN: %clang -c %s -### -target hexagon-unknown-elf -mv60 -mhvx \
 // RUN:  2>&1 | FileCheck -check-prefix=CHECK-HVX-DEFAULT %s
 // CHECK-HVX-DEFAULT: "-target-feature" "+hvxv60"

test/Driver/rtti-options.cpp

 // Check that we emit warnings/errors for different combinations of
-// exceptions, rtti, and vptr sanitizer flags when targetting the PS4.
+// exceptions, rtti, and vptr sanitizer flags when targeting the PS4.
 // No warnings/errors should be emitted for unknown, except if combining
 // the vptr sanitizer with -fno-rtti
 
 // Special cases: -fcxx-exceptions in C code should warn about unused arguments
 // We should also not have any rtti-related arguments
 // RUN: %clang -x c -### -target x86_64-scei-ps4 -c -fcxx-exceptions %s 2>&1 | FileCheck -check-prefix=CHECK-UNUSED -check-prefix=CHECK-RTTI -check-prefix=CHECK-NO-RTTI %s
 // RUN: %clang -x c -### -target x86_64-unknown-unknown -c -fcxx-exceptions %s 2>&1 | FileCheck -check-prefix=CHECK-UNUSED -check-prefix=CHECK-RTTI -check-prefix=CHECK-NO-RTTI %s
 

test/Headers/ms-null-ms-header-vs-stddef.cpp

 // RUN: %clang_cc1 -fsyntax-only -triple i686-pc-win32 -fms-compatibility -fms-compatibility-version=17.00 %s
 // RUN: %clang_cc1 -fsyntax-only -triple i386-mingw32 %s
 
 // Something in MSVC's headers (pulled in e.g. by <crtdefs.h>) defines __null
-// to something, mimick that.
+// to something, mimic that.
 #define __null
 
 #include <stddef.h>
 
 // __null is used as a type annotation in MS headers, with __null defined to
 // nothing in regular builds. This should continue to work even with stddef.h
 // included.
 void f(__null void* p) { }
 
 // NULL should work fine even with __null defined to nothing.
 void* p = NULL;

test/Index/headerfile-comment-to-html.m

 // CHECK-NEXT:         (CXComment_Paragraph
 // CHECK-NEXT:           (CXComment_Text Text=[ This is Sensor on the Device.] HasTrailingNewline)
 // CHECK-NEXT:           (CXComment_Text Text=[    Its purpose is not to Sense Device's heat.]))))]
 
 /*!
     \brief Test that headerfile can come after brief.
     \headerfile VTDevice.h <VTFoundation/VTDevice.h>
 
-    More property decription goes here.
+    More property description goes here.
 */
 @interface VTDevice : Device
 @end
-// CHECK: headerfile-comment-to-html.m:[[@LINE-2]]:12: ObjCInterfaceDecl=VTDevice:{{.*}} FullCommentAsXML=[<Other file="{{[^"]+}}headerfile-comment-to-html.m" line="[[@LINE-2]]" column="12"><Name>VTDevice</Name><USR>c:objc(cs)VTDevice</USR><Headerfile><Para> VTDevice.h &lt;VTFoundation/VTDevice.h&gt;</Para></Headerfile><Declaration>@interface VTDevice : Device\n@end</Declaration><Abstract><Para> Test that headerfile can come after brief.    </Para></Abstract><Discussion><Para>    More property decription goes here.</Para></Discussion></Other>]
+// CHECK: headerfile-comment-to-html.m:[[@LINE-2]]:12: ObjCInterfaceDecl=VTDevice:{{.*}} FullCommentAsXML=[<Other file="{{[^"]+}}headerfile-comment-to-html.m" line="[[@LINE-2]]" column="12"><Name>VTDevice</Name><USR>c:objc(cs)VTDevice</USR><Headerfile><Para> VTDevice.h &lt;VTFoundation/VTDevice.h&gt;</Para></Headerfile><Declaration>@interface VTDevice : Device\n@end</Declaration><Abstract><Para> Test that headerfile can come after brief.    </Para></Abstract><Discussion><Para>    More property description goes here.</Para></Discussion></Other>]
 // CHECK-NEXT:  CommentAST=[
 // CHECK-NEXT:    (CXComment_FullComment
 // CHECK-NEXT:       (CXComment_Paragraph IsWhitespace
 // CHECK-NEXT:         (CXComment_Text Text=[    ] IsWhitespace))
 // CHECK-NEXT:       (CXComment_BlockCommand CommandName=[brief]
 // CHECK-NEXT:         (CXComment_Paragraph
 // CHECK-NEXT:           (CXComment_Text Text=[ Test that headerfile can come after brief.] HasTrailingNewline)
 // CHECK-NEXT:           (CXComment_Text Text=[    ] IsWhitespace)))
 // CHECK-NEXT:       (CXComment_BlockCommand CommandName=[headerfile]
 // CHECK-NEXT:         (CXComment_Paragraph
 // CHECK-NEXT:           (CXComment_Text Text=[ VTDevice.h ])
 // CHECK-NEXT:           (CXComment_Text Text=[<VTFoundation])
 // CHECK-NEXT:           (CXComment_Text Text=[/VTDevice.h>])))
 // CHECK-NEXT:       (CXComment_Paragraph
-// CHECK-NEXT:         (CXComment_Text Text=[    More property decription goes here.])))]
+// CHECK-NEXT:         (CXComment_Text Text=[    More property description goes here.])))]
 
 /*!
   \headerfile  <stdio.h>
 */
 extern void uses_stdio_h();
 // CHECK: headerfile-comment-to-html.m:[[@LINE-1]]:13: FunctionDecl=uses_stdio_h:{{.*}} FullCommentAsXML=[<Function file="{{[^"]+}}headerfile-comment-to-html.m" line="[[@LINE-1]]" column="13"><Name>uses_stdio_h</Name><USR>c:@F@uses_stdio_h</USR><Headerfile><Para>  &lt;stdio.h&gt;</Para></Headerfile><Declaration>extern void uses_stdio_h()</Declaration></Function>]
 // CHECK-NEXT:  CommentAST=[
 // CHECK-NEXT:    (CXComment_FullComment

test/Misc/ast-print-pragmas-xfail.cpp

 // RUN: %clang_cc1 %s -ast-print -o - | FileCheck %s
 
 // FIXME: Test fails because attribute order is reversed by ParsedAttributes.
 // XFAIL: *
 
 void run1(int *List, int Length) {
   int i = 0;
-// CEHCK: #pragma loop vectorize(4)
+// CHECK: #pragma loop vectorize(4)
 // CHECK-NEXT: #pragma loop interleave(8)
 // CHECK-NEXT: #pragma loop vectorize(enable)
 // CHECK-NEXT: #pragma loop interleave(enable)
 #pragma loop vectorize(4)
 #pragma loop interleave(8)
 #pragma loop vectorize(enable)
 #pragma loop interleave(enable)
 // CHECK-NEXT: while (i < Length)
   while (i < Length) {
     List[i] = i;
     i++;
   }
 }

test/Misc/warning-flags.c

 CHECK-NEXT:   warn_no_constructor_for_refconst
 CHECK-NEXT:   warn_not_compound_assign
 CHECK-NEXT:   warn_objc_property_copy_missing_on_block
 CHECK-NEXT:   warn_objc_protocol_qualifier_missing_id
 CHECK-NEXT:   warn_on_superclass_use
 CHECK-NEXT:   warn_pp_convert_to_positive
 CHECK-NEXT:   warn_pp_expr_overflow
 CHECK-NEXT:   warn_pp_line_decimal
-CHECK-NEXT:   warn_pragma_pack_pop_identifer_and_alignment
+CHECK-NEXT:   warn_pragma_pack_pop_identifier_and_alignment
 CHECK-NEXT:   warn_pragma_pack_show
 CHECK-NEXT:   warn_property_getter_owning_mismatch
 CHECK-NEXT:   warn_register_objc_catch_parm
 CHECK-NEXT:   warn_related_result_type_compatibility_class
 CHECK-NEXT:   warn_related_result_type_compatibility_protocol
 CHECK-NEXT:   warn_template_export_unsupported
 CHECK-NEXT:   warn_template_spec_extra_headers
 CHECK-NEXT:   warn_tentative_incomplete_array

test/OpenMP/target_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
 // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
 
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER

test/OpenMP/target_parallel_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
 // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
 
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER

test/OpenMP/target_parallel_for_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
 // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
 
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER

test/OpenMP/target_parallel_for_simd_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
 // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
 
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER

test/OpenMP/target_simd_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
 // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
 
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER

test/OpenMP/target_teams_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
 // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
 
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER

test/OpenMP/target_teams_distribute_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
 // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
 
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER

test/OpenMP/target_teams_distribute_parallel_for_simd_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
 // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
 
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER

test/OpenMP/target_teams_distribute_simd_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
 // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
 
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER

test/Parser/brackets.c

void test1() {
   // expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the identifier}}
   // CHECK: {{^}}  int []b = {0,1,4,9,16};
   // CHECK: {{^}}      ~~ ^
   // CHECK: {{^}}         []
   // CHECK: fix-it:{{.*}}:{[[@LINE-5]]:7-[[@LINE-5]]:9}:""
   // CHECK: fix-it:{{.*}}:{[[@LINE-6]]:10-[[@LINE-6]]:10}:"[]"
 
   int c = a[0];
-  int d = b[0]; // No undeclared identifer error here.
+  int d = b[0]; // No undeclared identifier error here.
 
   int *e = a;
-  int *f = b; // No undeclared identifer error here.
+  int *f = b; // No undeclared identifier error here.
 }
 
 struct S {
   int [1][1]x;
   // expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the identifier}}
   // CHECK: {{^}}  int [1][1]x;
   // CHECK: {{^}}      ~~~~~~ ^
   // CHECK: {{^}}             [1][1]

test/Parser/brackets.cpp

void test1() {
   // expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the name}}
   // CHECK: {{^}}  int []b = {0,1,4,9,16};
   // CHECK: {{^}}      ~~ ^
   // CHECK: {{^}}         []
   // CHECK: fix-it:{{.*}}:{[[@LINE-5]]:7-[[@LINE-5]]:9}:""
   // CHECK: fix-it:{{.*}}:{[[@LINE-6]]:10-[[@LINE-6]]:10}:"[]"
 
   int c = a[0];
-  int d = b[0];  // No undeclared identifer error here.
+  int d = b[0];  // No undeclared identifier error here.
 
   int *e = a;
-  int *f = b;  // No undeclared identifer error here.
+  int *f = b;  // No undeclared identifier error here.
 
   int[1] g[2];
   // expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the name}}
   // CHECK: {{^}}  int[1] g[2];
   // CHECK: {{^}}     ~~~     ^
   // CHECK: {{^}}             [1]
   // CHECK: fix-it:{{.*}}:{[[@LINE-5]]:6-[[@LINE-5]]:9}:""
   // CHECK: fix-it:{{.*}}:{[[@LINE-6]]:14-[[@LINE-6]]:14}:"[1]"

test/Preprocessor/macro_paste_commaext.c

 // RUN: %clang_cc1 %s -E | FileCheck --strict-whitespace --match-full-lines %s
 
 // In the following tests, note that the output is sensitive to the
-// whitespace *preceeding* the varargs argument, as well as to
+// whitespace *preceding* the varargs argument, as well as to
 // interior whitespace. AFAIK, this is the only case where whitespace
-// preceeding an argument matters, and might be considered a bug in
+// preceding an argument matters, and might be considered a bug in
 // GCC. Nevertheless, since this feature is a GCC extension in the
 // first place, we'll follow along.
 
 #define debug(format, ...) format, ## __VA_ARGS__)
 // CHECK:V);
 debug(V);
 // CHECK:W,1, 2);
 debug(W,1, 2);
 // CHECK:X, 1, 2);
 debug(X, 1, 2 );
 // CHECK:Y,);
 debug(Y, );
 // CHECK:Z,);
 debug(Z,);

test/Sema/attr-availability-tvos.c

 
 void test_tvos() {
   f0_tvos(0); // expected-warning{{'f0_tvos' is deprecated: first deprecated in tvOS 2.1}}
   f1_tvos(0);
   f2_tvos(0); // expected-warning{{'f2_tvos' is deprecated: first deprecated in tvOS 3.0}}
   f3_tvos(0);
   f4_tvos(0); // expected-error{{'f4_tvos' is unavailable: obsoleted in tvOS 3.0}}
   // We get no warning here because any explicit 'tvos' availability causes
-  // the ios availablity to not implicitly become 'tvos' availability.  Otherwise we'd get
+  // the ios availability to not implicitly become 'tvos' availability.  Otherwise we'd get
   // a deprecated warning.
   f5_tvos(0); // no-warning
   f5_attr_reversed_tvos(0); // no-warning
   // We get a deprecated warning here because both attributes are explicitly 'tvos'.
   f5b_tvos(0); // expected-warning {{'f5b_tvos' is deprecated: first deprecated in tvOS 3.0}}
   // We get a deprecated warning here because both attributes are 'ios' (both get mapped to 'tvos').
   f5c_tvos(0); // expected-warning {{'f5c_tvos' is deprecated: first deprecated in tvOS 3.0}}
   f6_tvos(0); // expected-warning{{'f6_tvos' is deprecated: first deprecated in tvOS 3.0}}
 }

test/Sema/attr-availability-watchos.c

 
 void test_watchos() {
   f0_watchos(0); // expected-warning{{'f0_watchos' is deprecated: first deprecated in watchOS 2.1}}
   f1_watchos(0);
   f2_watchos(0); // expected-warning{{'f2_watchos' is deprecated: first deprecated in watchOS 3.0}}
   f3_watchos(0);
   f4_watchos(0); // expected-error{{'f4_watchos' is unavailable: obsoleted in watchOS 3.0}}
   // We get no warning here because any explicit 'watchos' availability causes
-  // the ios availablity to not implicitly become 'watchos' availability.  Otherwise we'd get
+  // the ios availability to not implicitly become 'watchos' availability.  Otherwise we'd get
   // a deprecated warning.
   f5_watchos(0); // no-warning
   f5_attr_reversed_watchos(0); // no-warning
   // We get a deprecated warning here because both attributes are explicitly 'watchos'.
   f5b_watchos(0); // expected-warning {{'f5b_watchos' is deprecated: first deprecated in watchOS 3.0}}
   // We get a deprecated warning here because both attributes are 'ios' (both get mapped to 'watchos').
   f5c_watchos(0); // expected-warning {{'f5c_watchos' is deprecated: first deprecated in watchOS 2.0}}
   f6_watchos(0); // expected-warning {{'f6_watchos' is deprecated: first deprecated in watchOS 3.0}}
 }

test/Sema/pr30372.c

 // REQUIRES: x86-registered-target
 // RUN: %clang_cc1 %s -triple i386-pc-windows-msvc18.0.0 -disable-free -fms-volatile -fms-extensions -fms-compatibility -fms-compatibility-version=18 -std=c++11 -x c++
 
-// Check that the parser catching an 'error' from forward declaration of "location" does not lexer out it's subsequent declation.
+// Check that the parser catching an 'error' from forward declaration of "location" does not lexer out it's subsequent declaration.
 
 void foo() {
   __asm {
     jl         location
  location:
     ret
   }
 }

test/Sema/self-comparison.c

int array_comparisons() {
   return array1 == array1; // expected-warning{{self-comparison always evaluates to true}}
   return array1 != array1; // expected-warning{{self-comparison always evaluates to false}}
   return array1 < array1; // expected-warning{{self-comparison always evaluates to false}}
   return array1 <= array1; // expected-warning{{self-comparison always evaluates to true}}
   return array1 > array1; // expected-warning{{self-comparison always evaluates to false}}
   return array1 >= array1; // expected-warning{{self-comparison always evaluates to true}}
 
   //
-  // compare differrent arrays
+  // compare different arrays
   //
   return array1 == array2; // expected-warning{{array comparison always evaluates to false}}
   return array1 != array2; // expected-warning{{array comparison always evaluates to true}}
 
   //
   // we don't know what these are going to be
   //
   return array1 < array2; // expected-warning{{array comparison always evaluates to a constant}}

test/Sema/tls.c

 // Test that TLS is correctly considered supported or unsupported for the
 // different targets.
 
 // Linux supports TLS.
 // RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fsyntax-only %s
 // RUN: %clang_cc1 -triple i386-pc-linux-gnu -fsyntax-only %s
 
 // Darwin supports TLS since 10.7.
 // RUN: not %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only %s
 // RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -fsyntax-only %s
 
 // RUN: %clang_cc1 -triple x86_64-pc-win32 -fsyntax-only %s
 // RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only %s
 
-// OpenBSD suppports TLS.
+// OpenBSD supports TLS.
 // RUN: %clang_cc1 -triple x86_64-pc-openbsd -fsyntax-only %s
 // RUN: %clang_cc1 -triple i386-pc-openbsd -fsyntax-only %s
 
-// Haiku does not suppport TLS.
+// Haiku does not support TLS.
 // RUN: not %clang_cc1 -triple i586-pc-haiku -fsyntax-only %s
 
 __thread int x;

test/Sema/uninit-variables.c

 }
 
 void test15() {
   int x = x; // no-warning: signals intended lack of initialization.
 }
 
 int test15b() {
   // Warn here with the self-init, since it does result in a use of
-  // an unintialized variable and this is the root cause.
+  // an uninitialized variable and this is the root cause.
   int x = x; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}}
   return x;
 }
 
 // Don't warn in the following example; shows dataflow confluence.
 char *test16_aux();
 void test16() {
   char *p = test16_aux();

test/Sema/vector-gcc-compat.c

void logicTest(void) {
 
   v2i64_r = 1 << v2i64_a;
   v2i64_r = 1 >> v2i64_a;
 
   v2i64_a <<= 1;
   v2i64_a >>= 1;
 }
 
-// For operations with floating point types, we check that interger constants
+// For operations with floating point types, we check that integer constants
 // can be respresented, or failing that checking based on the integer types.
 void floatTestConstant(void) {
   // Test that constants added to floats must be expressible as floating point
   // numbers.
   v4f32 v4f32_a = {0.4f, 0.4f, 0.4f, 0.4f};
   v4f32_a = v4f32_a + 1;
   v4f32_a = v4f32_a + 0xFFFFFF;
   v4f32_a = v4f32_a + (-1567563LL);

test/Sema/vector-gcc-compat.cpp

void logicTest(void) {
 
   v2i64_r = 1 << v2i64_a;
   v2i64_r = 1 >> v2i64_a;
 
   v2i64_a <<= 1;
   v2i64_a >>= 1;
 }
 
-// For operations with floating point types, we check that interger constants
+// For operations with floating point types, we check that integer constants
 // can be respresented, or failing that checking based on the integer types.
 void floatTestConstant(void) {
   // Test that constants added to floats must be expressible as floating point
   // numbers.
   v4f32 v4f32_a = {0.4f, 0.4f, 0.4f, 0.4f};
   v4f32_a = v4f32_a + 1;
   v4f32_a = v4f32_a + 0xFFFFFF;
   v4f32_a = v4f32_a + (-1567563LL); // expected-warning {{'long long' is incompatible with C++98}}

test/Sema/warn-documentation.m

 
 @implementation rdar14024851 // expected-error {{reimplementation}}
 /// \brief comment
 -(void)meth {}
 @end
 
 // rdar://14124644
 @interface test_vararg1
-/// @param[in] arg somthing
+/// @param[in] arg something
 /// @param[in] ... This is vararg
 - (void) VarArgMeth : (id)arg, ...;
 @end
 
 @implementation test_vararg1
-/// @param[in] arg somthing
+/// @param[in] arg something
 /// @param[in] ... This is vararg
 - (void) VarArgMeth : (id)arg, ... {}
 @end
 
 /**
  * blockPointerVariable
  *
  * @param i is integer.

test/Sema/warn-string-conversion.c

 // RUN: %clang_cc1 -verify -fsyntax-only -Wstring-conversion %s
 
 void do_nothing();
 void assert_error();
 
 #define assert1(expr) \
   if (expr)           \
     do_nothing();     \
   else                \
   assert_error()
 
 #define assert2(expr) \
   ((expr) ? do_nothing() : assert_error())
 
-// Expection for common assert form.
+// Exception for common assert form.
 void test1() {
   assert1(0 && "foo");
   assert1("foo" && 0);
   assert1(0 || "foo"); // expected-warning {{string literal}}
   assert1("foo"); // expected-warning {{string literal}}
 
   assert2(0 && "foo");
   assert2("foo" && 0);

test/SemaCUDA/function-template-overload.cu

 template <typename T> __host__ __device__ HDType overload_hd(T a) { return HDType(); }
 // expected-note@-1 {{previous declaration is here}}
 // expected-note@-2 2 {{candidate template ignored: could not match 'HDType' against 'HType'}}
 template <typename T> __device__ HDType overload_hd(T a);
 // expected-error@-1 {{__device__ function 'overload_hd' cannot overload __host__ __device__ function 'overload_hd'}}
 __device__ HDType overload_hd(int a); // OK.
 
 // Verify that target attributes are taken into account when we
-// explicitly specialize or instantiate function tempaltes.
+// explicitly specialize or instantiate function templates.
 template <> __host__ HType overload_hd(int a);
 // expected-error@-1 {{no function template matches function template specialization 'overload_hd'}}
 template __host__ HType overload_hd(long a);
 // expected-error@-1 {{explicit instantiation of 'overload_hd' does not refer to a function template, variable template, member function, member class, or static data member}}
 __host__ HType overload_hd(int a); // OK
 
 template <typename T> __host__ T overload_h(T a); // expected-note {{previous declaration is here}}
 template <typename T> __host__ __device__ T overload_h(T a);

test/SemaCXX/conditional-expr.cpp

void test()
   (void)(i1 ? base : fin); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
   (void)(i1 ? fin : base); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
 
   // b2.2 (non-hierarchy)
   i1 = i1 ? I() : i1;
   i1 = i1 ? i1 : I();
   I i2(i1 ? I() : J());
   I i3(i1 ? J() : I());
-  // "the type [it] woud have if E2 were converted to an rvalue"
+  // "the type [it] would have if E2 were converted to an rvalue"
   vfn pfn = i1 ? F() : test;
   pfn = i1 ? test : F();
   (void)(i1 ? A() : B()); // expected-error {{conversion from 'B' to 'A' is ambiguous}}
   (void)(i1 ? B() : A()); // expected-error {{conversion from 'B' to 'A' is ambiguous}}
   (void)(i1 ? 1 : Ambig()); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}}
   (void)(i1 ? Ambig() : 1); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}}
   // By the way, this isn't an lvalue:
   &(i1 ? i1 : i2); // expected-error {{cannot take the address of an rvalue}}

test/SemaCXX/err_typecheck_assign_const_filecheck.cpp

void test4(const A Ca) {
   Ca.CSb.Sc.d.e.num = 5;
   Ca.getCB().Sc.d.e.num = 5;
   Ca.getSCB().Sc.d.e.num = 5;
 
   // CHECK-NOT: error:
   // CHECK-NOT: note:
 }
 
-// Only display notes for relavent cases.
+// Only display notes for relevant cases.
 void test5(const A Ca) {
   Ca.Mb.c.d.Ce.num = 5;
   // CHECK-NOT: error:
   // CHECK: error:{{.*}} 'Ce'
   // CHECK-NOT: note:
   // CHECK: note:{{.*}} 'Ce'
   // CHECK-NOT: note:
 

test/SemaCXX/type-traits.cpp

 
 static_assert(has_unique_object_representations<InheritsFromNoPadding>::value, "types without padding are");
 
 struct VirtuallyInheritsFromNoPadding : virtual NoPadding {
   int c;
   int d;
 };
 
-static_assert(!has_unique_object_representations<VirtuallyInheritsFromNoPadding>::value, "No virtual inheritence");
+static_assert(!has_unique_object_representations<VirtuallyInheritsFromNoPadding>::value, "No virtual inheritance");
 
 struct Padding {
   char a;
   int b;
 };
 
 //static_assert(!has_unique_object_representations<Padding>::value, "but not with padding");
 

test/SemaCXX/uninitialized.cpp

 // Test self-references within initializers which are guaranteed to be
 // uninitialized.
 int a = a; // no-warning: used to signal intended lack of initialization.
 int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
 int c = (c + c); // expected-warning 2 {{variable 'c' is uninitialized when used within its own initialization}}
 int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
 int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
 
-// Thes don't warn as they don't require the value.
+// These don't warn as they don't require the value.
 int g = sizeof(g);
 void* ptr = &ptr;
 int h = bar(&h);
 int i = boo(i);
 int j = far(j);
 int k = __alignof__(k);
 
 int l = k ? l : l;  // expected-warning 2{{variable 'l' is uninitialized when used within its own initialization}}

 void test_stuff () {
   int a = a; // no-warning: used to signal intended lack of initialization.
   int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
   int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}}
   int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}}
   int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
   int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
 
-  // Thes don't warn as they don't require the value.
+  // These don't warn as they don't require the value.
   int g = sizeof(g);
   void* ptr = &ptr;
   int h = bar(&h);
   int i = boo(i);
   int j = far(j);
   int k = __alignof__(k);
 
   int l = k ? l : l;  // expected-warning {{variable 'l' is uninitialized when used within its own initialization}}
void test_stuff () {
   for (;;) {
     int a = a; // no-warning: used to signal intended lack of initialization.
     int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
     int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}}
     int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}}
     int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
     int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
 
-    // Thes don't warn as they don't require the value.
+    // These don't warn as they don't require the value.
     int g = sizeof(g);
     void* ptr = &ptr;
     int h = bar(&h);
     int i = boo(i);
     int j = far(j);
     int k = __alignof__(k);
 
     int l = k ? l : l;  // expected-warning {{variable 'l' is uninitialized when used within its own initialization}}

 
 namespace statics {
   static int a = a; // no-warning: used to signal intended lack of initialization.
   static int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
   static int c = (c + c); // expected-warning 2{{variable 'c' is uninitialized when used within its own initialization}}
   static int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
   static int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
 
-  // Thes don't warn as they don't require the value.
+  // These don't warn as they don't require the value.
   static int g = sizeof(g);
   int gg = g;  // Silence unneeded warning
   static void* ptr = &ptr;
   static int h = bar(&h);
   static int i = boo(i);
   static int j = far(j);
   static int k = __alignof__(k);
 
namespace statics {
   void test() {
     static int a = a; // no-warning: used to signal intended lack of initialization.
     static int b = b + 1; // expected-warning {{static variable 'b' is suspiciously used within its own initialization}}
     static int c = (c + c); // expected-warning 2{{static variable 'c' is suspiciously used within its own initialization}}
     static int d = ({ d + d ;}); // expected-warning 2{{static variable 'd' is suspiciously used within its own initialization}}
     static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}}
     static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}}
 
-    // Thes don't warn as they don't require the value.
+    // These don't warn as they don't require the value.
     static int g = sizeof(g);
     static void* ptr = &ptr;
     static int h = bar(&h);
     static int i = boo(i);
     static int j = far(j);
     static int k = __alignof__(k);
 
     static int l = k ? l : l;  // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}}
void test() {
     for (;;) {
       static int a = a; // no-warning: used to signal intended lack of initialization.
       static int b = b + 1; // expected-warning {{static variable 'b' is suspiciously used within its own initialization}}
       static int c = (c + c); // expected-warning 2{{static variable 'c' is suspiciously used within its own initialization}}
       static int d = ({ d + d ;}); // expected-warning 2{{static variable 'd' is suspiciously used within its own initialization}}
       static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}}
       static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}}
 
-      // Thes don't warn as they don't require the value.
+      // These don't warn as they don't require the value.
       static int g = sizeof(g);
       static void* ptr = &ptr;
       static int h = bar(&h);
       static int i = boo(i);
       static int j = far(j);
       static int k = __alignof__(k);
 
       static int l = k ? l : l;  // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}}

test/SemaCXX/vector.cpp

void test_implicit_conversions(bool Cond, char16 c16, longlong16 ll16,
   (void)(rto_c16 += to_c16e);
   (void)(rto_c16 -= to_c16e);
   (void)(rto_c16 *= to_c16e);
   (void)(rto_c16 /= to_c16e);
 
   (void)(Cond? to_c16 : to_c16e);
   (void)(Cond? to_ll16e : to_ll16);
 
-  // These 2 are convertable with -flax-vector-conversions (default)
+  // These 2 are convertible with -flax-vector-conversions (default)
   (void)(Cond? to_c16 : to_ll16);
   (void)(Cond? to_c16e : to_ll16e);
 }
 
 typedef float fltx2 __attribute__((__vector_size__(8)));
 typedef float fltx4 __attribute__((__vector_size__(16)));
 typedef double dblx2 __attribute__((__vector_size__(16)));
 typedef double dblx4 __attribute__((__vector_size__(32)));

test/SemaCXX/warn-thread-safety-analysis.cpp

void main() {
   Bar bar;
   bar.Test1();
 }
 } // end namespace thread_annot_lock_49
 
 namespace thread_annot_lock_61_modified {
   // Modified to fix the compiler errors
   // Test the fix for a bug introduced by the support of pass-by-reference
-  // paramters.
+  // parameters.
   struct Foo { Foo &operator<< (bool) {return *this;} };
   Foo &getFoo();
   struct Bar { Foo &func () {return getFoo();} };
   struct Bas { void operator& (Foo &) {} };
   void mumble()
   {
     Bas() & Bar().func() << "" << "";
     Bas() & Bar().func() << "";
void foo9() {
     }
   }
 
   // Test use-def chains: back edges
   void foo10() {
     bool b = mu.TryLock();
 
     while (cond) {
-      if (b) {   // b should be uknown at this point b/c of the loop
+      if (b) {   // b should be unknown at this point b/c of the loop
         a = 10;  // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}}
       }
       b = !b;
     }
   }
 
   // Test merge of exclusive trylock
   void foo11() {

test/SemaCXX/warn-unreachable.cpp

struct TestUnreachableB {
   static void foo();
 };
 
 void test_unreachable_templates_harness() {
   test_unreachable_templates<TestUnreachableA>();
   test_unreachable_templates<TestUnreachableB>(); 
 }
 
-// Do warn about explict template specializations, as they represent
+// Do warn about explicit template specializations, as they represent
 // actual concrete functions that somebody wrote.
 
 template <typename T> void funcToSpecialize() {}
 template <> void funcToSpecialize<int>() {
   halt();
   dead(); // expected-warning {{will never be executed}}
 }
 

test/SemaObjC/arc-peformselector.m

- (id) Meth {
   return [self performSelector : @selector(init)];
   return [self performSelector : sel1]; // expected-warning {{performSelector may cause a leak because its selector is unknown}} \
           // expected-note {{used here}}
   return [self performSelector: (@selector(PlusZero))];
 
   return [self performSelector : @selector(PlusZero)];
   return [self performSelector : @selector(PlusOne)]; // expected-error {{performSelector names a selector which retains the object}}
 
-  // Avoid the unkown selector warning for more complicated performSelector
+  // Avoid the unknown selector warning for more complicated performSelector
   // variations because it produces too many false positives.
   [self performSelector: sel1 withObject:0 afterDelay:0 inModes:0];
 
   return [self performSelector: @selector(self)]; // No error, -self is not +1!
 }
 
 - (id)performSelector:(SEL)aSelector { return 0; }
 - (id)performSelector:(SEL)aSelector withObject:(id)object { return 0; }
 - (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2 { return 0; }
 - (void)performSelector:(SEL)aSelector withObject:(id)anArgument afterDelay:(double)delay inModes:(I *)modes { }
 @end

test/SemaObjC/compare-qualified-class.m

 @property (nonatomic, copy) ClassB<ProtocolX> *aProperty;
 - (ClassA<ProtocolY> *)aMethod;
 - (ClassA<ProtocolY> *)anotherMethod;
 @end
 
 @implementation OtherClass
 - (ClassA<ProtocolY> *)aMethod {
     // This does not work, even though ClassB subclasses from A and conforms to Y
-    // because the property type explicity adds ProtocolX conformance
+    // because the property type explicitly adds ProtocolX conformance
     // even though ClassB already conforms to ProtocolX
     return self.aProperty;
 }
 - (ClassA<ProtocolY> *)anotherMethod {
     // This works, even though all it is doing is removing an explicit
     // protocol conformance that ClassB already conforms to
     return (ClassB *)self.aProperty;
 }
 @end

test/SemaObjC/property-ivar-mismatch.m

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
-// Test that arithmatic types on property and its ivar have exact match.
+// Test that arithmetic types on property and its ivar have exact match.
 
 @interface Test4 
 {
    char ivar; // expected-note{{instance variable is declared here}}
 }
 @property int prop;
 @end
 

tools/c-index-test/c-index-test.c

#ifdef CLANG_HAVE_LIBXML
   }
 
   ValidationCtxt = xmlRelaxNGNewValidCtxt(Schema);
   status = xmlRelaxNGValidateDoc(ValidationCtxt, Doc);
   if (!status)
     printf(" CommentXMLValid");
   else if (status > 0) {
     xmlErrorPtr Error = xmlGetLastError();
-    printf(" CommentXMLInvalid [not vaild XML: %s]", Error->message);
+    printf(" CommentXMLInvalid [not valid XML: %s]", Error->message);
   } else
     printf(" libXMLError");
 
   xmlRelaxNGFreeValidCtxt(ValidationCtxt);
   xmlFreeDoc(Doc);
   xmlRelaxNGFree(Schema);
   xmlRelaxNGFreeParserCtxt(RNGParser);
 #endif

tools/clang-format/clang-format.el

(let ((file-start (clang-format--bufferpos-to-filepos start 'approximate
         ;; otherwise the offsets calculated above are off.  For simplicity, we
         ;; always use ‘utf-8-unix’ and ignore the buffer coding system.
         (default-process-coding-system '(utf-8-unix . utf-8-unix)))
     (unwind-protect
         (let ((status (apply #'call-process-region
                              nil nil clang-format-executable
                              nil `(,temp-buffer ,temp-file) nil
                              `("-output-replacements-xml"
-                               ;; Gaurd against a nil assume-file-name.
+                               ;; Guard against a nil assume-file-name.
                                ;; If the clang-format option -assume-filename
                                ;; is given a blank string it will crash as per
                                ;; the following bug report
                                ;; https://bugs.llvm.org/show_bug.cgi?id=34667
                                ,@(and assume-file-name
                                       (list "-assume-filename" assume-file-name))
                                "-style" ,style
                                "-offset" ,(number-to-string file-start)

tools/libclang/CIndex.cpp

void EnqueueVisitor::VisitMemberExpr(const MemberExpr *M) {
   // If the base of the member access expression is an implicit 'this', don't
   // visit it.
   // FIXME: If we ever want to show these implicit accesses, this will be
   // unfortunate. However, clang_getCursor() relies on this behavior.
   if (M->isImplicitAccess())
     return;
 
   // Ignore base anonymous struct/union fields, otherwise they will shadow the
-  // real field that that we are interested in.
+  // real field that we are interested in.
   if (auto *SubME = dyn_cast<MemberExpr>(M->getBase())) {
     if (auto *FD = dyn_cast_or_null<FieldDecl>(SubME->getMemberDecl())) {
       if (FD->isAnonymousStructOrUnion()) {
         AddStmt(SubME->getBase());
         return;
       }
     }
   }
case VarDecl::TLS_Static:
       return CXTLS_Static;
     }
   }
 
   return CXTLS_None;
 }
 
  /// \brief If the given cursor is the "templated" declaration
- /// descibing a class or function template, return the class or
+ /// describing a class or function template, return the class or
  /// function template.
 static const Decl *maybeGetTemplateCursor(const Decl *D) {
   if (!D)
     return nullptr;
 
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
     if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate())
       return FunTmpl;

tools/libclang/CXCursor.h

 
 ASTContext &getCursorContext(CXCursor Cursor);
 ASTUnit *getCursorASTUnit(CXCursor Cursor);
 CXTranslationUnit getCursorTU(CXCursor Cursor);
 
 void getOverriddenCursors(CXCursor cursor,
                           SmallVectorImpl<CXCursor> &overridden);
   
-/// \brief Create an opaque  pool used for fast generation of overriden
+/// \brief Create an opaque pool used for fast generation of overridden
 /// CXCursor arrays.
 void *createOverridenCXCursorsPool();
 
-/// \brief Dispose of the overriden CXCursors pool.
+/// \brief Dispose of the overridden CXCursors pool.
 void disposeOverridenCXCursorsPool(void *pool);
   
 /// \brief Returns a index/location pair for a selector identifier if the cursor
 /// points to one.
 std::pair<int, SourceLocation> getSelectorIdentifierIndexAndLoc(CXCursor);
 static inline int getSelectorIdentifierIndex(CXCursor cursor) {
   return getSelectorIdentifierIndexAndLoc(cursor).first;
 }

tools/libclang/CXCursor.cpp

void clang_getOverriddenCursors(CXCursor cursor,
 
   // Use the first entry to contain a back reference to the vector.
   // This is a complete hack.
   CXCursor backRefCursor = MakeCXCursorInvalid(CXCursor_InvalidFile, TU);
   backRefCursor.data[0] = Vec;
   assert(cxcursor::getCursorTU(backRefCursor) == TU);
   Vec->push_back(backRefCursor);
 
-  // Get the overriden cursors.
+  // Get the overridden cursors.
   cxcursor::getOverriddenCursors(cursor, *Vec);
   
-  // Did we get any overriden cursors?  If not, return Vec to the pool
+  // Did we get any overridden cursors?  If not, return Vec to the pool
   // of available cursor vectors.
   if (Vec->size() == 1) {
     pool.AvailableCursors.push_back(Vec);
     return;
   }
 
-  // Now tell the caller about the overriden cursors.
+  // Now tell the caller about the overridden cursors.
   assert(Vec->size() > 1);
   *overridden = &((*Vec)[1]);
   *num_overridden = Vec->size() - 1;
 }
 
 void clang_disposeOverriddenCursors(CXCursor *overridden) {
   if (!overridden)
     return;

tools/scan-build-py/README.md

 The major difference is how and when the analyzer is run. The `scan-build`
 tool has three distinct model to run the analyzer:
 
 1.  Use compiler wrappers to make actions.
     The compiler wrappers does run the real compiler and the analyzer.
     This is the default behaviour, can be enforced with `--override-compiler`
     flag.
 
-2.  Use special library to intercept compiler calls durring the build process.
+2.  Use special library to intercept compiler calls during the build process.
     The analyzer run against each modules after the build finished.
     Use `--intercept-first` flag to get this model.
 
-3.  Use compiler wrappers to intercept compiler calls durring the build process.
+3.  Use compiler wrappers to intercept compiler calls during the build process.
     The analyzer run against each modules after the build finished.
     Use `--intercept-first` and `--override-compiler` flags together to get
     this model.
 
 The 1. and 3. are using compiler wrappers, which works only if the build
 process respects the `CC` and `CXX` environment variables. (Some build
 process can override these variable as command line parameter only. This case
 you need to pass the compiler wrappers manually. eg.: `intercept-build
 --override-compiler make CC=intercept-cc CXX=intercept-c++ all` where the
 original build command would have been `make all` only.)
 
 The 1. runs the analyzer right after the real compilation. So, if the build
 process removes removes intermediate modules (generated sources) the analyzer
 output still kept.
 
 The 2. and 3. generate the compilation database first, and filters out those
-modules which are not exists. So, it's suitable for incremental analysis durring
+modules which are not exists. So, it's suitable for incremental analysis during
 the development.
 
 The 2. mode is available only on FreeBSD and Linux. Where library preload
 is available from the dynamic loader. Not supported on OS X (unless System
 Integrity Protection feature is turned off).
 
 `intercept-build` command uses only the 2. and 3. mode to generate the
 compilation database. `analyze-build` does only run the analyzer against the

tools/scan-build-py/libscanbuild/analyze.py

 
 
 def need_analyzer(args):
     """ Check the intent of the build command.
 
     When static analyzer run against project configure step, it should be
     silent and no need to run the analyzer or generate report.
 
-    To run `scan-build` against the configure step might be neccessary,
+    To run `scan-build` against the configure step might be necessary,
     when compiler wrappers are used. That's the moment when build setup
     check the compiler and capture the location for the build process. """
 
     return len(args) and not re.search('configure|autogen', args[0])
 
 
 def prefix_with(constant, pieces):
     """ From a sequence create another sequence where every second element
@require(['command',  # entry from compilation database
           'output_format',  # it's 'plist', 'html', both or plist-multi-file
           'output_failures',  # generate crash reports or not
           'ctu'])  # ctu control options
 def run(opts):
     """ Entry point to run (or not) static analyzer against a single entry
     of the compilation database.
 
     This complex task is decomposed into smaller methods which are calling
-    each other in chain. If the analyzis is not possibe the given method
+    each other in chain. If the analyzis is not possible the given method
     just return and break the chain.
 
     The passed parameter is a python dictionary. Each method first check
     that the needed parameters received. (This is done by the 'require'
     decorator. It's like an 'assert' to check the contract between the
     caller and the called method.) """
 
     try:

tools/scan-build-py/libscanbuild/arguments.py

advanced.add_argument(
         '--internal-stats',
         action='store_true',
         help="""Generate internal analyzer statistics.""")
     advanced.add_argument(
         '--maxloop',
         '-maxloop',
         metavar='<loop count>',
         type=int,
-        help="""Specifiy the number of times a block can be visited before
+        help="""Specify the number of times a block can be visited before
         giving up. Increase for more comprehensive coverage at a cost of
         speed.""")
     advanced.add_argument(
         '--store',
         '-store',
         metavar='<model>',
         dest='store_model',
         choices=['region', 'basic'],

tools/scan-build/bin/scan-build

if (/^Xcode (.+)$/) {
           $oldBehavior = 0;
           last;
         }
       }
     }
   }
   close(DETECT_XCODE);
 
-  # If --override-compiler is explicitely requested, resort to the old
+  # If --override-compiler is explicitly requested, resort to the old
   # behavior regardless of Xcode version.
   if ($Options{OverrideCompiler}) {
     $oldBehavior = 1;
   }
 
   if ($oldBehavior == 0) {
     my $OutputDir = $EnvVars->{"OUTPUT_DIR"};
     my $CLANG = $EnvVars->{"CLANG"};
-no-failure-reports
    and preprocessed source files.
 
  -stats
 
    Generates visitation statistics for the project being analyzed.
 
  -maxloop <loop count>
 
-   Specifiy the number of times a block can be visited before giving up.
+   Specify the number of times a block can be visited before giving up.
    Default is 4. Increase for more comprehensive coverage at a cost of speed.
 
  -internal-stats
 
    Generate internal analyzer statistics.
 
  --use-analyzer [Xcode|path to clang]
  --use-analyzer=[Xcode|path to clang]

tools/scan-build/man/scan-build.1

 .It Fl constraints Op Ar model
 Specify the contraint engine used by the analyzer.  By default the
 .Ql range
 model is used.  Specifying
 .Ql basic
 uses a simpler, less powerful constraint model used by checker-0.160
 and earlier.
 .It Fl maxloop Ar N
-Specifiy the number of times a block can be visited before giving
+Specify the number of times a block can be visited before giving
 up. Default is 4. Increase for more comprehensive coverage at a
 cost of speed.
 .It Fl no-failure-reports
 Do not create a
 .Ql failures
 subdirectory that includes analyzer crash reports and preprocessed
 source files.
 .It Fl stats

tools/scan-view/share/startfile.py

def _invoke(self, cmdline):
         if not setsid:
             setsid = getattr(os, 'setpgrp', None)
 
         pipe = subprocess.Popen(cmdline, stdin=inout, stdout=inout,
                                 stderr=inout, close_fds=closefds,
                                 preexec_fn=setsid, startupinfo=startupinfo)
 
         # It is assumed that this kind of tools (gnome-open, kfmclient,
-        # exo-open, xdg-open and open for OSX) immediately exit after lauching
+        # exo-open, xdg-open and open for OSX) immediately exit after launching
         # the specific application
         returncode = pipe.wait()
         if hasattr(self, 'fixreturncode'):
             returncode = self.fixreturncode(returncode)
         return not returncode
 
     def open(self, filename):
         if isinstance(filename, basestring):
             cmdline = self.args + [filename]
         else:
             # assume it is a sequence
             cmdline = self.args + filename
         try:
             return self._invoke(cmdline)
         except OSError:
             return False
 
 
 # Platform support for Windows
 if sys.platform[:3] == 'win':
 
     class Start(BaseController):
-        '''Controller for the win32 start progam through os.startfile.'''
+        '''Controller for the win32 start program through os.startfile.'''
 
         def open(self, filename):
             try:
                 os.startfile(filename)
             except WindowsError:
                 # [Error 22] No application is associated with the specified
                 # file for this operation: '<URL>'
                 return False
else:
 
 
     if os.environ.get("DISPLAY"):
         register_X_controllers()
     _open = get()
 
 
 def open(filename):
-    '''Open a file or an URL in the registered default application.'''
+    '''Open a file or a URL in the registered default application.'''
 
     return _open(filename)

utils/TableGen/NeonEmitter.cpp

class Intrinsic {
   /// signedness (i32), while some (ClassB) have no type at all, only a width
   /// (32).
   ClassKind CK;
   /// The list of DAGs for the body. May be empty, in which case we should
   /// emit a builtin call.
   ListInit *Body;
   /// The architectural #ifdef guard.
   std::string Guard;
-  /// Set if the Unvailable bit is 1. This means we don't generate a body,
+  /// Set if the Unavailable bit is 1. This means we don't generate a body,
   /// just an "unavailable" attribute on a declaration.
   bool IsUnavailable;
   /// Is this intrinsic safe for big-endian? or does it need its arguments
   /// reversing?
   bool BigEndianSafe;
 
   /// The types of return value [0] and parameters [1..].
   std::vector<Type> Types;

utils/bash-autocomplete.sh

 # Please add "source /path/to/bash-autocomplete.sh" to your .bashrc to use this.
 
 _clang_filedir()
 {
   # _filedir function provided by recent versions of bash-completion package is
   # better than "compgen -f" because the former honors spaces in pathnames while
   # the latter doesn't. So we use compgen only when _filedir is not provided.
   _filedir 2> /dev/null || COMPREPLY=( $( compgen -f ) )
 }
 
 _clang()
 {
   local cur prev words cword arg flags w1 w2
   # If latest bash-completion is not supported just initialize COMPREPLY and
-  # initialize variables by setting manualy.
+  # initialize variables by setting manually.
   _init_completion -n 2> /dev/null
   if [[ "$?" != 0 ]]; then
     COMPREPLY=()
     cword=$COMP_CWORD
     cur="${COMP_WORDS[$cword]}"
   fi
 
   w1="${COMP_WORDS[$cword - 1]}"

utils/check_cfc/check_cfc.py

def run_step(command, my_env, error_on_failure):
     p = subprocess.Popen(command, stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE, env=my_env, shell=is_windows())
     (stdout, stderr) = p.communicate()
     if p.returncode != 0:
         raise WrapperStepException(error_on_failure, stdout, stderr)
 
 def get_temp_file_name(suffix):
     """Get a temporary file name with a particular suffix. Let the caller be
-    reponsible for deleting it."""
+    responsible for deleting it."""
     tf = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
     tf.close()
     return tf.name
 
 class WrapperCheck(object):
     """Base class for a check. Subclass this to add a check."""
     def __init__(self, output_file_a):
         """Record the base output file that will be compared against."""

utils/clangdiag.py

def setDiagBreakpoint(frame, bp_loc, dict):
     if id is None:
         print('clangdiag: id is None')
         return False
 
     # Don't need to test this time, since we did that in enable.
     target = frame.GetThread().GetProcess().GetTarget()
     diagtool = getDiagtool(target)
     name = subprocess.check_output([diagtool, "find-diagnostic-id", id]).rstrip();
-    # Make sure we only consider errors, warnings, and extentions.
+    # Make sure we only consider errors, warnings, and extensions.
     # FIXME: Make this configurable?
     prefixes = ['err_', 'warn_', 'exp_']
     if len([prefix for prefix in prefixes+[''] if name.startswith(prefix)][0]):
         bp = target.BreakpointCreateBySourceRegex(name, lldb.SBFileSpec())
         bp.AddName("clang::Diagnostic")
 
     return False
 
 def enable(exe_ctx, args):
     # Always disable existing breakpoints
     disable(exe_ctx)
 
     target = exe_ctx.GetTarget()
     numOfBreakpoints = target.GetNumBreakpoints()
 
     if args.id:
-        # Make sure we only consider errors, warnings, and extentions.
+        # Make sure we only consider errors, warnings, and extensions.
         # FIXME: Make this configurable?
         prefixes = ['err_', 'warn_', 'exp_']
         if len([prefix for prefix in prefixes+[''] if args.id.startswith(prefix)][0]):
             bp = target.BreakpointCreateBySourceRegex(args.id, lldb.SBFileSpec())
             bp.AddName("clang::Diagnostic")
         else:
             diagtool = getDiagtool(target)
             list = subprocess.check_output([diagtool, "list-warnings"]).rstrip();

www/OpenProjects.html

<li><b>XML Representation of ASTs</b>: Clang maintains a rich Abstract Syntax Tree that describes the program. Clang could emit an XML document that describes the program, which others tools could consume rather than being tied directly to the Clang binary.The XML representation needs to meet several requirements:
   <ul>
     <li><i>General</i>, so that it's able to represent C/C++/Objective-C abstractly, and isn't tied to the specific internal ASTs that Clang uses.</li>
     <li><i>Documented</i>, with appropriate Schema against which the output of Clang's XML formatter can be verified.</li>
     <li><i>Stable</i> across Clang versions.</li>
   </ul></li>
 
 <li><b>Configuration Manager</b>: Clang/LLVM works on a large number of
 architectures and operating systems and can cross-compile to a similarly large
-number of configurations, but the pitfalls of chosing the command-line
+number of configurations, but the pitfalls of choosing the command-line
 options, making sure the right sub-architecture is chosen and that the correct
 optional elements of your particular system can be a pain.
 
 <p>A tool that would investigate hosts and targets, and store the configuration
 in files that can later be used by Clang itself to avoid command-line options,
 especially the ones regarding which target options to use, would greatle alleviate
 this problem. A simple tool, with little or no dependency on LLVM itself, that
 will investigate a target architecture by probing hardware, software, libraries

www/analyzer/alpha_checks.html

 Warns against using one vs. many plural pattern in code 
 when generating localized strings.
 </div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 NSString *reminderText = 
   NSLocalizedString(@"None", @"Indicates no reminders");
 if (reminderCount == 1) {
-  // Warning: Plural cases are not supported accross all languages. 
+  // Warning: Plural cases are not supported across all languages.
   // Use a .stringsdict file instead
   reminderText = 
     NSLocalizedString(@"1 Reminder", @"Indicates single reminder");
 } else if (reminderCount >= 2) {
-  // Warning: Plural cases are not supported accross all languages.
+  // Warning: Plural cases are not supported across all languages.
   // Use a .stringsdict file instead
   reminderText = 
     [NSString stringWithFormat:
       NSLocalizedString(@"%@ Reminders", @"Indicates multiple reminders"),
         reminderCount];
 }
 </pre></div></div></td></tr>
 
void test() {
   sprintf(buf, s); // warn: untrusted data as a format string
 }
 </pre></div><div class="separator"></div>
 <div class="example"><pre>
 void test() {
   size_t ts;
   scanf("%zd", &ts); // 'ts' marked as tainted
   int *p = (int *)malloc(ts * sizeof(int)); 
-    // warn: untrusted data as bufer size
+    // warn: untrusted data as buffer size
 }
 </pre></div></div></td></tr>
 
 </tbody></table>
 
 <!-- ============================= unix alpha ============================= -->
 <h3 id="unix_alpha_checkers">Unix Alpha Checkers</h3>
 <table class="checkers">

www/analyzer/available_checks.html

 <tr><td><div class="namedescr expandable"><span class="name">
 core.uninitialized.Assign</span><span class="lang">
 (C)</span><div class="descr">
 Check for assigning uninitialized values.</div></div></td>
 <td><div class="exampleContainer expandable">
 <div class="example"><pre>
 void test() {
   int x;
-  x |= 1; // warn: left expression is unitialized
+  x |= 1; // warn: left expression is uninitialized
 }
 </pre></div></div></td></tr>
 
 
 <tr><td><div class="namedescr expandable"><span class="name">
 core.uninitialized.Branch</span><span class="lang">
 (C)</span><div class="descr">
 Check for uninitialized values used as branch conditions.</div></div></td>

www/diagnostics.html

<pre>
   <span class="loc">t.cpp:9:3:</span> <span class="err">error:</span> <span class="msg">template specialization requires 'template&lt;&gt;'</span>
     struct iterator_traits&lt;file_iterator&gt; {
     <span class="point">^</span>
     <span class="snip">template&lt;&gt; </span>
 </pre>
 
 <h2>Template Type Diffing</h2>
 
-<p>Templates types can be long and difficult to read.  Moreso when part of an
+<p>Templates types can be long and difficult to read.  More so when part of an
 error message.  Instead of just printing out the type name, Clang has enough
 information to remove the common elements and highlight the differences.  To
 show the template structure more clearly, the templated type can also be
 printed as an indented text tree.</p>
 
 Default: template diff with type elision
 <pre>
 <span class="loc">t.cc:4:5:</span> <span class="note">note:</span> candidate function not viable: no known conversion from 'vector&lt;map&lt;[...], <span class="template-highlight">float</span>&gt;&gt;' to 'vector&lt;map&lt;[...], <span class="template-highlight">double</span>&gt;&gt;' for 1st argument;

www/features.html

 <!--=======================================================================-->
 
 <p>A major focus of our work on clang is to make it fast, light and scalable.
 The library-based architecture of clang makes it straight-forward to time and
 profile the cost of each layer of the stack, and the driver has a number of
 options for performance analysis. Many detailed benchmarks can be found online.</p>
 
 <p>Compile time performance is important, but when using clang as an API, often
-memory use is even moreso: the less memory the code takes the more code you can
+memory use is even more so: the less memory the code takes the more code you can
 fit into memory at a time (useful for whole program analysis tools, for
 example).</p>
 
 <p>In addition to being efficient when pitted head-to-head against GCC in batch
 mode, clang is built with a <a href="#libraryarch">library based
 architecture</a> that makes it relatively easy to adapt it and build new tools
 with it.  This means that it is often possible to apply out-of-the-box thinking
 and novel techniques to improve compilation in various ways.</p>

www/get_involved.html

 
 <p>Clang has always been designed as a platform for experimentation,
 allowing programmers to easily extend the compiler to support great
 new language features and tools. At some point, the authors of these
 extensions may propose that the extensions become a part of Clang
 itself, to benefit the whole Clang community. But not every idea--not
 even every great idea--should become part of Clang. Extensions
 (particularly language extensions) pose a long-term maintenance burden
-on Clang, and therefore the benefits of the extension must outweight
+on Clang, and therefore the benefits of the extension must outweigh
 those costs. Hence, these are the seven criteria used to evaluate the
 merits of a proposed extension:</p>
 
 <ol>
   <li>Evidence of a significant user community: This is based on a number of factors, including an actual, existing user community, the perceived likelihood that users would adopt such a feature if it were available, and any "trickle-down" effects that come from, e.g., a library adopting the feature and providing benefits to its users.</li>
 
   <li>A specific need to reside within the Clang tree: There are some extensions that would be better expressed as a separate tool, and should remain as separate tools even if they end up being hosted as part of the LLVM umbrella project.</li>