[clang-tools-extra] NFC: Fix trivial typos in comments

[merge_guards_bot]

Unit tests: pass. 61173 tests passed, 0 failed and 729 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[kiszk]

Rebase with master

[merge_guards_bot]

Unit tests: pass. 61180 tests passed, 0 failed and 729 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[aaron.ballman]

This is fantastic, thank you for much for all the typo fixes! This LGTM. Do you need someone to commit on your behalf?

[kiszk]

I do not have commit rights to the repository. Could someone commit this change if it is OK?
Kazuaki Ishizaki <[e-mail]>

[aaron.ballman]

Thank you for the patch! I've committed on your behalf in b7ecf1c1c373c53183ef6ef66efbe4237ff7b96d.

clang-tools-extra/clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp

for (const auto &FileAndReplacements : GroupedReplacements) {
     for (const auto &R : FileAndReplacements.second) {
       llvm::Error Err =
           FileChange.replace(SM, BeginLoc.getLocWithOffset(R.getOffset()),
                              R.getLength(), R.getReplacementText());
       if (Err) {
         // FIXME: This will report conflicts by pair using a file+offset format
         // which is not so much human readable.
         // A first improvement could be to translate offset to line+col. For
-        // this and without loosing error message some modifications arround
+        // this and without loosing error message some modifications around
         // `tooling::ReplacementError` are need (access to
         // `getReplacementErrString`).
         // A better strategy could be to add a pretty printer methods for
         // conflict reporting. Methods that could be parameterized to report a
         // conflict in different format, file+offset, file+line+col, or even
         // more human readable using VCS conflict markers.
         // For now, printing directly the error reported by `AtomicChange` is
         // the easiest solution.

clang-tools-extra/clang-doc/BitcodeReader.h

private:
   // Allocate the relevant type of info and add read data to the object.
   template <typename T>
   llvm::Expected<std::unique_ptr<Info>> createInfo(unsigned ID);
 
   // Helper function to step through blocks to find and dispatch the next record
   // or block to be read.
   Cursor skipUntilRecordOrBlock(unsigned &BlockOrRecordID);
 
-  // Helper function to set up the approriate type of Info.
+  // Helper function to set up the appropriate type of Info.
   llvm::Expected<std::unique_ptr<Info>> readBlockToInfo(unsigned ID);
 
   llvm::BitstreamCursor &Stream;
   Optional<llvm::BitstreamBlockInfo> BlockInfo;
   FieldId CurrentReferenceField;
 };
 
 } // namespace doc
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_BITCODEREADER_H

clang-tools-extra/clang-doc/Representation.h

struct Reference {
   bool operator==(const Reference &Other) const {
     return std::tie(USR, Name, RefType) ==
            std::tie(Other.USR, Other.Name, Other.RefType);
   }
 
   bool mergeable(const Reference &Other);
   void merge(Reference &&I);
 
-  SymbolID USR = SymbolID(); // Unique identifer for referenced decl
+  SymbolID USR = SymbolID(); // Unique identifier for referenced decl
   SmallString<16> Name;      // Name of type (possibly unresolved).
   InfoType RefType = InfoType::IT_default; // Indicates the type of this
                                            // Reference (namespace, record,
                                            // function, enum, default).
   // Path of directory where the clang-doc generated file will be saved
   // (possibly unresolved)
   llvm::SmallString<128> Path;
   // Indicates if the info's parent is the global namespace, or if the info is

clang-tools-extra/clang-doc/Serialize.cpp

 template <typename T>
 static void
 populateParentNamespaces(llvm::SmallVector<Reference, 4> &Namespaces,
                          const T *D, bool &IsAnonymousNamespace);
 
 // A function to extract the appropriate relative path for a given info's
 // documentation. The path returned is a composite of the parent namespaces.
 //
-// Example: Given the below, the diretory path for class C info will be
+// Example: Given the below, the directory path for class C info will be
 // <root>/A/B
 //
 // namespace A {
 // namesapce B {
 //
 // class C {};
 //
 // }

clang-tools-extra/clang-doc/tool/ClangDocMain.cpp

 //===-- ClangDocMain.cpp - ClangDoc -----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This tool for generating C and C++ documenation from source code
+// This tool for generating C and C++ documentation from source code
 // and comments. Generally, it runs a LibTooling FrontendAction on source files,
 // mapping each declaration in those files to its USR and serializing relevant
 // information into LLVM bitcode. It then runs a pass over the collected
 // declaration information, reducing by USR. There is an option to dump this
 // intermediate result to bitcode. Finally, it hands the reduced information
 // off to a generator, which does the final parsing from the intermediate
 // representation to the desired output format.
 //

clang-tools-extra/clang-include-fixer/IncludeFixerContext.cpp

SplitQualifiers(llvm::StringRef StringQualifiers) {
   StringQualifiers.split(Qualifiers, "::");
   return Qualifiers;
 }
 
 std::string createQualifiedNameForReplacement(
     llvm::StringRef RawSymbolName,
     llvm::StringRef SymbolScopedQualifiersName,
     const find_all_symbols::SymbolInfo &MatchedSymbol) {
-  // No need to add missing qualifiers if SymbolIndentifer has a global scope
+  // No need to add missing qualifiers if SymbolIdentifier has a global scope
   // operator "::".
   if (RawSymbolName.startswith("::"))
     return RawSymbolName;
 
   std::string QualifiedName = MatchedSymbol.getQualifiedName();
 
   // For nested classes, the qualified name constructed from database misses
   // some stripped qualifiers, because when we search a symbol in database,

clang-tools-extra/clang-include-fixer/tool/clang-include-fixer.el

(let ((process (if (and (fboundp 'make-process)
                    (clang-include-fixer--start-process callback args))))
     (save-restriction
       (widen)
       (process-send-region process (point-min) (point-max)))
     (process-send-eof process))
   nil)
 
 (defun clang-include-fixer--make-process (callback args)
-  "Start a new clang-incude-fixer process using `make-process'.
+  "Start a new clang-include-fixer process using `make-process'.
 CALLBACK is called after the process finishes successfully; it is
 called with a single argument, the buffer where standard output
 has been inserted.  ARGS is a list of additional command line
 arguments.  Return the new process object."
   (let ((stdin (current-buffer))
         (stdout (generate-new-buffer "*clang-include-fixer output*"))
         (stderr (generate-new-buffer "*clang-include-fixer errors*")))
     (make-process :name "clang-include-fixer"
                   :buffer stdout
                   :command (clang-include-fixer--command args)
                   :coding 'utf-8-unix
                   :noquery t
                   :connection-type 'pipe
                   :sentinel (clang-include-fixer--sentinel stdin stdout stderr
                                                            callback)
                   :stderr stderr)))
 
 (defun clang-include-fixer--start-process (callback args)
-  "Start a new clang-incude-fixer process using `start-file-process'.
+  "Start a new clang-include-fixer process using `start-file-process'.
 CALLBACK is called after the process finishes successfully; it is
 called with a single argument, the buffer where standard output
 has been inserted.  ARGS is a list of additional command line
 arguments.  Return the new process object."
   (let* ((stdin (current-buffer))
          (stdout (generate-new-buffer "*clang-include-fixer output*"))
          (process-connection-type nil)
          (process (apply #'start-file-process "clang-include-fixer" stdout

clang-tools-extra/clang-move/tool/ClangMove.cpp

-//===-- ClangMove.cpp - move defintion to new file --------------*- C++ -*-===//
+//===-- ClangMove.cpp - move definition to new file -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Move.h"

clang-tools-extra/clang-tidy/abseil/FasterStrsplitDelimiterCheck.cpp

void FasterStrsplitDelimiterCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   // Binds to one character string literals.
   const auto SingleChar =
       expr(ignoringParenCasts(stringLiteral(lengthIsOne()).bind("Literal")));
 
   // Binds to a string_view (either absl or std) that was passed by value and
-  // contructed from string literal.
+  // constructed from string literal.
   auto StringViewArg = ignoringElidableConstructorCall(ignoringImpCasts(
       cxxConstructExpr(hasType(recordDecl(hasName("::absl::string_view"))),
                        hasArgument(0, ignoringParenImpCasts(SingleChar)))));
 
   // Need to ignore the elidable constructor as otherwise there is no match for
   // c++14 and earlier.
   auto ByAnyCharArg =
       expr(has(ignoringElidableConstructorCall(

clang-tools-extra/clang-tidy/abseil/TimeSubtractionCheck.cpp

const auto *MaybeCallArg = selectFirst<const CallExpr>(
                          callExpr(callee(functionDecl(hasName(
                                       getDurationFactoryForScale(*Scale)))))
                              .bind("arg"))),
                      *BinOp, *Result.Context));
     if (MaybeCallArg && MaybeCallArg->getArg(0)->IgnoreImpCasts() == BinOp &&
         !InsideMacroDefinition(Result, MaybeCallArg->getSourceRange())) {
       // Handle the case where the matched expression is inside a call which
       // converts it from the inverse to a Duration.  In this case, we replace
-      // the outer with just the subtraction expresison, which gives the right
+      // the outer with just the subtraction expression, which gives the right
       // type and scale, taking care again about parenthesis.
       bool NeedParens = parensRequired(Result, MaybeCallArg);
 
       emitDiagnostic(
           MaybeCallArg,
           (llvm::Twine(NeedParens ? "(" : "") +
            rewriteExprFromNumberToTime(Result, *Scale, BinOp->getLHS()) +
            " - " +

clang-tools-extra/clang-tidy/bugprone/ForwardDeclarationNamespaceCheck.cpp

if (RecordDecl->isThisDeclarationADefinition()) {
       // NOTE: even a declaration does have definition, we still need it to
       // compare with other declarations.
       DeclNameToDeclarations[DeclName].push_back(RecordDecl);
     }
   } else {
     const auto *Decl = Result.Nodes.getNodeAs<FriendDecl>("friend_decl");
     assert(Decl && "Decl is neither record_decl nor friend decl!");
 
-    // Classes used in friend delarations are not marked referenced in AST,
+    // Classes used in friend declarations are not marked referenced in AST,
     // so we need to check classes used in friend declarations manually to
     // reduce the rate of false positive.
     // For example, in
     //    \code
     //      struct A;
     //      struct B { friend A; };
     //    \endcode
     // `A` will not be marked as "referenced" in the AST.

clang-tools-extra/clang-tidy/bugprone/StringLiteralWithEmbeddedNulCheck.cpp

for (size_t i = 0; i < Node.getLength(); ++i)
     if (Node.getCodeUnit(i) == '\0')
       return true;
   return false;
 }
 } // namespace
 
 void StringLiteralWithEmbeddedNulCheck::registerMatchers(MatchFinder *Finder) {
   // Match a string that contains embedded NUL character. Extra-checks are
-  // applied in |check| to find incorectly escaped characters.
+  // applied in |check| to find incorrectly escaped characters.
   Finder->addMatcher(stringLiteral(containsNul()).bind("strlit"), this);
 
   // The remaining checks only apply to C++.
   if (!getLangOpts().CPlusPlus)
     return;
 
   const auto StrLitWithNul =
       ignoringParenImpCasts(stringLiteral(containsNul()).bind("truncated"));

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

 
 namespace {
 
 AST_MATCHER(CXXRecordDecl, hasDefaultConstructor) {
   return Node.hasDefaultConstructor();
 }
 
 // Iterate over all the fields in a record type, both direct and indirect (e.g.
-// if the record contains an anonmyous struct).
+// if the record contains an anonymous struct).
 template <typename T, typename Func>
 void forEachField(const RecordDecl &Record, const T &Fields, Func &&Fn) {
   for (const FieldDecl *F : Fields) {
     if (F->isAnonymousStructOrUnion()) {
       if (const CXXRecordDecl *R = F->getType()->getAsCXXRecordDecl())
         forEachField(*R, R->fields(), Fn);
     } else {
       Fn(F);
for (const CXXCtorInitializer *Init : Ctor->inits()) {
           return; // We can only initialize one member of a union.
         FieldsToInit.erase(Init->getAnyMember());
       }
     }
     removeFieldsInitializedInBody(*Ctor->getBody(), Context, FieldsToInit);
   }
 
   // Collect all fields in order, both direct fields and indirect fields from
-  // anonmyous record types.
+  // anonymous record types.
   SmallVector<const FieldDecl *, 16> OrderedFields;
   forEachField(ClassDecl, ClassDecl.fields(),
                [&](const FieldDecl *F) { OrderedFields.push_back(F); });
 
   // Collect all the fields we need to initialize, including indirect fields.
   SmallPtrSet<const FieldDecl *, 16> AllFieldsToInit;
   forEachField(ClassDecl, FieldsToInit,
                [&](const FieldDecl *F) { AllFieldsToInit.insert(F); });

clang-tools-extra/clang-tidy/cppcoreguidelines/SlicingCheck.cpp

const auto IsDerivedFromBaseDecl =
       cxxRecordDecl(isDerivedFrom(equalsBoundNode("BaseDecl")))
           .bind("DerivedDecl");
   const auto HasTypeDerivedFromBaseDecl =
       anyOf(hasType(IsDerivedFromBaseDecl),
             hasType(references(IsDerivedFromBaseDecl)));
   const auto IsWithinDerivedCtor =
       hasParent(cxxConstructorDecl(ofClass(equalsBoundNode("DerivedDecl"))));
 
-  // Assignement slicing: "a = b;" and "a = std::move(b);" variants.
+  // Assignment slicing: "a = b;" and "a = std::move(b);" variants.
   const auto SlicesObjectInAssignment =
       callExpr(callee(cxxMethodDecl(anyOf(isCopyAssignmentOperator(),
                                           isMoveAssignmentOperator()),
                                     OfBaseClass)),
                hasArgument(1, HasTypeDerivedFromBaseDecl));
 
   // Construction slicing: "A a{b};" and "f(b);" variants. Note that in case of
   // slicing the letter will create a temporary and therefore call a ctor.

clang-tools-extra/clang-tidy/google/GlobalNamesInHeadersCheck.cpp

if (Result.SourceManager->isInMainFile(
     // unless that file is a header.
     if (!utils::isSpellingLocInHeaderFile(
             D->getBeginLoc(), *Result.SourceManager, HeaderFileExtensions))
       return;
   }
 
   if (const auto *UsingDirective = dyn_cast<UsingDirectiveDecl>(D)) {
     if (UsingDirective->getNominatedNamespace()->isAnonymousNamespace()) {
-      // Anynoumous namespaces inject a using directive into the AST to import
+      // Anonymous namespaces inject a using directive into the AST to import
       // the names into the containing namespace.
       // We should not have them in headers, but there is another warning for
       // that.
       return;
     }
   }
 
   diag(D->getBeginLoc(),
        "using declarations in the global namespace in headers are prohibited");
 }
 
 } // namespace readability
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/google/IntegerTypesCheck.h

 
 namespace tidy {
 namespace google {
 namespace runtime {
 
 /// Finds uses of `short`, `long` and `long long` and suggest replacing them
 /// with `u?intXX(_t)?`.
 ///
-/// Correspondig cpplint.py check: 'runtime/int'.
+/// Corresponding cpplint.py check: 'runtime/int'.
 class IntegerTypesCheck : public ClangTidyCheck {
 public:
   IntegerTypesCheck(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Options) override;
 
 private:

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

 
 } // namespace
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 void AvoidCArraysCheck::registerMatchers(MatchFinder *Finder) {
-  // std::array<> is avaliable since C++11.
+  // std::array<> is available since C++11.
   if (!getLangOpts().CPlusPlus11)
     return;
 
   Finder->addMatcher(
       typeLoc(hasValidBeginLoc(), hasType(arrayType()),
               unless(anyOf(hasParent(parmVarDecl(isArgvOfMain())),
                            hasParent(varDecl(isExternC())),
                            hasParent(fieldDecl(

clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp

if (const auto *NewConstruct = New->getConstructExpr()) {
       if (NewConstruct->isStdInitListInitialization() ||
           HasListIntializedArgument(NewConstruct)) {
         // FIXME: Add fixes for direct initialization with the initializer-list
         // constructor. Similar to the above CallInit case, the type has to be
         // specified explicitly in the fixes.
         //   struct S { S(std::initializer_list<int>); };
         //   struct S2 { S2(S, int); };
         //   smart_ptr<S>(new S{1, 2, 3});  // C++11 direct list-initialization
-        //   smart_ptr<S>(new S{});  // use initializer-list consturctor
+        //   smart_ptr<S>(new S{});  // use initializer-list constructor
         //   smart_ptr<S2>()new S2{ {1,2}, 3 }; // have a list-initialized arg
         // The above cases have to be replaced with:
         //   std::make_smart_ptr<S>(std::initializer_list<int>({1, 2, 3}));
         //   std::make_smart_ptr<S>(std::initializer_list<int>({}));
         //   std::make_smart_ptr<S2>(S{1, 2}, 3);
         return false;
       } else {
         // Direct initialization with ordinary constructors.

clang-tools-extra/clang-tidy/modernize/UseAutoCheck.cpp

for (const auto *Dec : D->decls()) {
     if (E != E->IgnoreConversionOperator()) {
       // We hit a conversion operator. Early-out now as they imply an implicit
       // conversion from a different type. Could also mean an explicit
       // conversion from the same type but that's pretty rare.
       return;
     }
 
     if (const auto *NestedConstruct = dyn_cast<CXXConstructExpr>(E)) {
-      // If we ran into an implicit conversion contructor, can't convert.
+      // If we ran into an implicit conversion constructor, can't convert.
       //
       // FIXME: The following only checks if the constructor can be used
       // implicitly, not if it actually was. Cases where the converting
       // constructor was used explicitly won't get converted.
       if (NestedConstruct->getConstructor()->isConvertingConstructor(false))
         return;
     }
     if (!Context->hasSameType(V->getType(), E->getType()))

clang-tools-extra/clang-tidy/modernize/UseNullptrCheck.cpp

AST_MATCHER(Type, sugaredNullptrType) {
   if (const auto *BT = dyn_cast<BuiltinType>(DesugaredType))
     return BT->getKind() == BuiltinType::NullPtr;
   return false;
 }
 
 /// Create a matcher that finds implicit casts as well as the head of a
 /// sequence of zero or more nested explicit casts that have an implicit cast
 /// to null within.
-/// Finding sequences of explict casts is necessary so that an entire sequence
+/// Finding sequences of explicit casts is necessary so that an entire sequence
 /// can be replaced instead of just the inner-most implicit cast.
 StatementMatcher makeCastSequenceMatcher() {
   StatementMatcher ImplicitCastToNull = implicitCastExpr(
       anyOf(hasCastKind(CK_NullToPointer), hasCastKind(CK_NullToMemberPointer)),
       unless(hasImplicitDestinationType(qualType(substTemplateTypeParmType()))),
       unless(hasSourceExpression(hasType(sugaredNullptrType()))));
 
   return castExpr(anyOf(ImplicitCastToNull,

clang-tools-extra/clang-tidy/performance/InefficientAlgorithmCheck.h

 namespace clang {
 namespace tidy {
 namespace performance {
 
 /// Warns on inefficient use of STL algorithms on associative containers.
 ///
 /// Associative containers implements some of the algorithms as methods which
 /// should be preferred to the algorithms in the algorithm header. The methods
-/// can take advanatage of the order of the elements.
+/// can take advantage of the order of the elements.
 class InefficientAlgorithmCheck : public ClangTidyCheck {
 public:
   InefficientAlgorithmCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_INEFFICIENTALGORITHMCHECK_H

clang-tools-extra/clang-tidy/performance/InefficientVectorOperationCheck.cpp

AddMatcher(VectorDecl, VectorVarDeclName, VectorVarDeclStmtName,
              AppendMethodDecl, PushBackOrEmplaceBackCallName, Finder);
 
   if (EnableProto) {
     const auto ProtoDecl =
         cxxRecordDecl(isDerivedFrom("::proto2::MessageLite"));
 
     // A method's name starts with "add_" might not mean it's an add field
     // call; it could be the getter for a proto field of which the name starts
-    // with "add_". So we exlude const methods.
+    // with "add_". So we exclude const methods.
     const auto AddFieldMethodDecl =
         cxxMethodDecl(matchesName("::add_"), unless(isConst()));
     AddMatcher(ProtoDecl, ProtoVarDeclName, ProtoVarDeclStmtName,
                AddFieldMethodDecl, ProtoAddFieldCallName, Finder);
   }
 }
 
 void InefficientVectorOperationCheck::check(

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h

enum class ShouldFixStatus {
     /// i.e no message, no fixup.
     IgnoreFailureThreshold,
 
     InsideMacro, /// If the identifier was used or declared within a macro we
                  /// won't offer a fixup for safety reasons.
   };
 
   /// Holds an identifier name check failure, tracking the kind of the
-  /// identifer, its possible fixup and the starting locations of all the
+  /// identifier, its possible fixup and the starting locations of all the
   /// identifier usages.
   struct NamingCheckFailure {
     std::string KindName;
     std::string Fixup;
 
     /// Whether the failure should be fixed or not.
     ///
     /// ie: if the identifier was used or declared within a macro we won't offer

clang-tools-extra/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

bool checkIfFixItHintIsApplicable(
   //    definition is most up-to-date, and use it to generate replacements.
   //  * If only function declarations are seen, there is no easy way to tell
   //    which is up-to-date and which is not, so don't do anything.
   // TODO: This may be changed later, but for now it seems the reasonable
   // solution.
   if (!ParameterSourceDeclaration->isThisDeclarationADefinition())
     return false;
 
-  // Assumption: if parameter is not referenced in function defintion body, it
+  // Assumption: if parameter is not referenced in function definition body, it
   // may indicate that it's outdated, so don't touch it.
   if (!SourceParam->isReferenced())
     return false;
 
   // In case there is the primary template definition and (possibly several)
   // template specializations (and each with possibly several redeclarations),
   // it is not at all clear what to change.
   if (OriginalDeclaration->getTemplatedKind() ==

clang-tools-extra/clang-tidy/utils/ExceptionAnalyzer.h

 namespace utils {
 
 /// This class analysis if a `FunctionDecl` can in principle throw an
 /// exception, either directly or indirectly. It can be configured to ignore
 /// custom exception types.
 class ExceptionAnalyzer {
 public:
   enum class State : std::int8_t {
-    Throwing = 0,    ///< The function can definitly throw given an AST.
+    Throwing = 0,    ///< The function can definitely throw given an AST.
     NotThrowing = 1, ///< This function can not throw, given an AST.
     Unknown = 2,     ///< This can happen for extern functions without available
                      ///< definition.
   };
 
   /// Bundle the gathered information about an entity like a function regarding
   /// it's exception behaviour. The 'NonThrowing'-state can be considered as the
   /// neutral element in terms of information propagation.

clang-tools-extra/clang-tidy/utils/NamespaceAliaser.cpp

NamespaceAliaser::createAlias(ASTContext &Context, const Stmt &Statement,
   const FunctionDecl *Function = getSurroundingFunction(Context, Statement);
   if (!Function || !Function->hasBody())
     return None;
 
   if (AddedAliases[Function].count(Namespace.str()) != 0)
     return None;
 
   // FIXME: Doesn't consider the order of declarations.
-  // If we accidentially pick an alias defined later in the function,
+  // If we accidentally pick an alias defined later in the function,
   // the output won't compile.
   // FIXME: Also doesn't consider file or class-scope aliases.
 
   const auto *ExistingAlias = selectFirst<NamedDecl>(
       "alias",
       match(functionDecl(hasBody(compoundStmt(has(declStmt(
                 has(namespaceAliasDecl(hasTargetNamespace(hasName(Namespace)))
                         .bind("alias"))))))),

clang-tools-extra/clangd/AST.h

 /// macro (e.g. a change in definition offset can result in a different USR). We
 /// could change these semantics in the future by reimplementing this funcure
 /// (e.g. avoid USR for macros).
 llvm::Optional<SymbolID> getSymbolID(const llvm::StringRef MacroName,
                                      const MacroInfo *MI,
                                      const SourceManager &SM);
 
 /// Returns a QualType as string. The result doesn't contain unwritten scopes
-/// like annoymous/inline namespace.
+/// like anonymous/inline namespace.
 std::string printType(const QualType QT, const DeclContext &CurContext);
 
 /// Indicates if \p D is a template instantiation implicitly generated by the
 /// compiler, e.g.
 ///     template <class T> struct vector {};
 ///     vector<int> v; // 'vector<int>' is an implicit instantiation
 bool isImplicitTemplateInstantiation(const NamedDecl *D);
 /// Indicates if \p D is an explicit template specialization, e.g.

clang-tools-extra/clangd/ClangdLSPServer.h

private:
   bool SupportsOffsetsInSignatureHelp = false;
   // Store of the current versions of the open documents.
   DraftStore DraftMgr;
 
   // The CDB is created by the "initialize" LSP method.
   bool UseDirBasedCDB;                     // FIXME: make this a capability.
   llvm::Optional<Path> CompileCommandsDir; // FIXME: merge with capability?
   std::unique_ptr<GlobalCompilationDatabase> BaseCDB;
-  // CDB is BaseCDB plus any comands overridden via LSP extensions.
+  // CDB is BaseCDB plus any commands overridden via LSP extensions.
   llvm::Optional<OverlayCDB> CDB;
   ClangdServer::Options ClangdServerOpts;
   llvm::Optional<OffsetEncoding> NegotiatedOffsetEncoding;
   // The ClangdServer is created by the "initialize" LSP method.
   llvm::Optional<ClangdServer> Server;
 };
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDLSPSERVER_H

clang-tools-extra/clangd/CodeComplete.cpp

SymbolSlab queryIndex() {
     SymbolSlab::Builder ResultsBuilder;
     if (Opts.Index->fuzzyFind(
             Req, [&](const Symbol &Sym) { ResultsBuilder.insert(Sym); }))
       Incomplete = true;
     return std::move(ResultsBuilder).build();
   }
 
   // Merges Sema and Index results where possible, to form CompletionCandidates.
-  // \p Identifiers is raw idenfiers that can also be completion candidates.
+  // \p Identifiers is raw identifiers that can also be completion candidates.
   // Identifiers are not merged with results from index or sema.
   // Groups overloads if desired, to form CompletionCandidate::Bundles. The
   // bundles are scored and top results are returned, best to worst.
   std::vector<ScoredBundle>
   mergeResults(const std::vector<CodeCompletionResult> &SemaResults,
                const SymbolSlab &IndexResults,
                const std::vector<RawIdentifier> &IdentifierResults) {
     trace::Span Tracer("Merge and score results");

clang-tools-extra/clangd/Context.h

 
 private:
   struct Data;
   Context(std::shared_ptr<const Data> DataPtr);
 
 public:
   /// Same as Context::empty(), please use Context::empty() instead.
   /// Constructor is defined to workaround a bug in MSVC's version of STL.
-  /// (arguments of std::future<> must be default-construcitble in MSVC).
+  /// (arguments of std::future<> must be default-constructible in MSVC).
   Context() = default;
 
   /// Copy operations for this class are deleted, use an explicit clone() method
   /// when you need a copy of the context instead.
   Context(Context const &) = delete;
   Context &operator=(const Context &) = delete;
 
   Context(Context &&) = default;

clang-tools-extra/clangd/FindTarget.cpp

void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
       // We want to keep it as non-declaration references, as the
       // "using namespace" declaration doesn't have a name.
       Refs.push_back(ReferenceLoc{D->getQualifierLoc(),
                                   D->getIdentLocation(),
                                   /*IsDecl=*/false,
                                   {D->getNominatedNamespaceAsWritten()}});
     }
 
     void VisitUsingDecl(const UsingDecl *D) {
-      // "using ns::identifer;" is a non-declaration reference.
+      // "using ns::identifier;" is a non-declaration reference.
       Refs.push_back(
           ReferenceLoc{D->getQualifierLoc(), D->getLocation(), /*IsDecl=*/false,
                        explicitReferenceTargets(DynTypedNode::create(*D),
                                                 DeclRelation::Underlying)});
     }
 
     void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
       // For namespace alias, "namespace Foo = Target;", we add two references.

clang-tools-extra/clangd/Hover.cpp

for (const EnumConstantDecl *ECD :
         return llvm::formatv("{0} ({1})", ECD->getNameAsString(), Val).str();
   }
   return Constant.Val.getAsString(Ctx, E->getType());
 }
 
 llvm::Optional<std::string> printExprValue(const SelectionTree::Node *N,
                                            const ASTContext &Ctx) {
   for (; N; N = N->Parent) {
-    // Try to evaluate the first evaluable enclosing expression.
+    // Try to evaluate the first evaluatable enclosing expression.
     if (const Expr *E = N->ASTNode.get<Expr>()) {
       if (auto Val = printExprValue(E, Ctx))
         return Val;
     } else if (N->ASTNode.get<Decl>() || N->ASTNode.get<Stmt>()) {
       // Refuse to cross certain non-exprs. (TypeLoc are OK as part of Exprs).
       // This tries to ensure we're showing a value related to the cursor.
       break;
     }

clang-tools-extra/clangd/IncludeFixer.cpp

std::vector<Fix> IncludeFixer::fix(DiagnosticsEngine::Level DiagLevel,
   case diag::err_no_template_suggest:
   case diag::err_undeclared_use:
   case diag::err_undeclared_use_suggest:
   case diag::err_undeclared_var_use:
   case diag::err_undeclared_var_use_suggest:
   case diag::err_no_member: // Could be no member in namespace.
   case diag::err_no_member_suggest:
     if (LastUnresolvedName) {
-      // Try to fix unresolved name caused by missing declaraion.
+      // Try to fix unresolved name caused by missing declaration.
       // E.g.
       //   clang::SourceManager SM;
       //          ~~~~~~~~~~~~~
       //          UnresolvedName
       //   or
       //   namespace clang {  SourceManager SM; }
       //                      ~~~~~~~~~~~~~
       //                      UnresolvedName
if (!Spelled)
       return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                      "Header not on include path");
     return std::make_pair(
         std::move(*Spelled),
         Inserter->shouldInsertInclude(*ResolvedDeclaring, *ResolvedInserted));
   };
 
   std::vector<Fix> Fixes;
-  // Deduplicate fixes by include headers. This doesn't distiguish symbols in
+  // Deduplicate fixes by include headers. This doesn't distinguish symbols in
   // different scopes from the same header, but this case should be rare and is
   // thus ignored.
   llvm::StringSet<> InsertedHeaders;
   for (const auto &Sym : Syms) {
     for (const auto &Inc : getRankedIncludes(Sym)) {
       if (auto ToInclude = Inserted(Sym, Inc)) {
         if (ToInclude->second) {
           auto I = InsertedHeaders.try_emplace(ToInclude->first);

clang-tools-extra/clangd/ParsedAST.h

public:
 
   /// This function returns top-level decls present in the main file of the AST.
   /// The result does not include the decls that come from the preamble.
   /// (These should be const, but RecursiveASTVisitor requires Decl*).
   ArrayRef<Decl *> getLocalTopLevelDecls();
 
   const std::vector<Diag> &getDiagnostics() const;
 
-  /// Returns the esitmated size of the AST and the accessory structures, in
+  /// Returns the estimated size of the AST and the accessory structures, in
   /// bytes. Does not include the size of the preamble.
   std::size_t getUsedBytes() const;
   const IncludeStructure &getIncludeStructure() const;
   const CanonicalIncludes &getCanonicalIncludes() const;
 
   /// Gets all macro references (definition, expansions) present in the main
   /// file, including those in the preamble region.
   const MainFileMacros &getMacros() const;

clang-tools-extra/clangd/Protocol.h

struct Diagnostic {
   /// Only with capability textDocument.publishDiagnostics.codeActionsInline.
   /// (These actions can also be obtained using textDocument/codeAction).
   llvm::Optional<std::vector<CodeAction>> codeActions;
 };
 llvm::json::Value toJSON(const Diagnostic &);
 
 /// A LSP-specific comparator used to find diagnostic in a container like
 /// std:map.
-/// We only use the required fields of Diagnostic to do the comparsion to avoid
+/// We only use the required fields of Diagnostic to do the comparison to avoid
 /// any regression issues from LSP clients (e.g. VScode), see
 /// https://git.io/vbr29
 struct LSPDiagnosticCompare {
   bool operator()(const Diagnostic &LHS, const Diagnostic &RHS) const {
     return std::tie(LHS.range, LHS.message) < std::tie(RHS.range, RHS.message);
   }
 };
 bool fromJSON(const llvm::json::Value &, Diagnostic &);

clang-tools-extra/clangd/SemanticHighlighting.h

 /// (https://manual.macromates.com/en/language_grammars).
 llvm::StringRef toTextMateScope(HighlightingKind Kind);
 
 /// Convert to LSP's semantic highlighting information.
 std::vector<SemanticHighlightingInformation>
 toSemanticHighlightingInformation(llvm::ArrayRef<LineHighlightings> Tokens);
 
 /// Return a line-by-line diff between two highlightings.
-///  - if the tokens on a line are the same in both hightlightings, this line is
+///  - if the tokens on a line are the same in both highlightings, this line is
 ///  omitted.
 ///  - if a line exists in New but not in Old, the tokens on this line are
 ///  emitted.
 ///  - if a line does not exist in New but exists in Old, an empty line is
 ///  emitted (to tell client to clear the previous highlightings on this line).
 ///
 /// REQUIRED: Old and New are sorted.
 std::vector<LineHighlightings>
 diffHighlightings(ArrayRef<HighlightingToken> New,
                   ArrayRef<HighlightingToken> Old);
 
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/TUScheduler.h

 struct InputsAndAST {
   const ParseInputs &Inputs;
   ParsedAST *
 };
 
 struct InputsAndPreamble {
   llvm::StringRef Contents;
   const tooling::CompileCommand &Command;
-  // This can be nullptr if no preamble is availble.
+  // This can be nullptr if no preamble is available.
   const PreambleData *Preamble;
 };
 
 /// Determines whether diagnostics should be generated for a file snapshot.
 enum class WantDiagnostics {
   Yes,  /// Diagnostics must be generated for this snapshot.
   No,   /// Diagnostics must not be generated for this snapshot.
   Auto, /// Diagnostics must be generated for this snapshot or a subsequent one,

clang-tools-extra/clangd/Trace.h

 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace clangd {
 namespace trace {
 
 /// A consumer of trace events. The events are produced by Spans and trace::log.
-/// Implmentations of this interface must be thread-safe.
+/// Implementations of this interface must be thread-safe.
 class EventTracer {
 public:
   virtual ~EventTracer() = default;
 
   /// Called when event that has a duration starts. \p Name describes the event.
   /// Returns a derived context that will be destroyed when the event ends.
   /// Usually implementations will store an object in the returned context
   /// whose destructor records the end of the event.

clang-tools-extra/clangd/clients/clangd-vscode/src/extension.ts

const clientOptions: vscodelc.LanguageClientOptions = {
             { scheme: 'file', language: 'c' },
             { scheme: 'file', language: 'cpp' },
             // cuda is not supported by vscode, but our extension does.
             { scheme: 'file', language: 'cuda' },
             { scheme: 'file', language: 'objective-c'},
             { scheme: 'file', language: 'objective-cpp'}
         ],
         synchronize: !syncFileEvents ? undefined : {
-        // FIXME: send sync file events when clangd provides implemenatations.
+        // FIXME: send sync file events when clangd provides implementations.
         },
         initializationOptions: { clangdFileStatus: true },
         // Do not switch to output window when clangd returns output
         revealOutputChannelOn: vscodelc.RevealOutputChannelOn.Never
     };
 
   const clangdClient = new ClangdLanguageClient('Clang Language Server',
                                                 serverOptions, clientOptions);

clang-tools-extra/clangd/index/CanonicalIncludes.cpp

-//===-- CanonicalIncludes.h - remap #inclue headers--------------*- C++ -*-===//
+//===-- CanonicalIncludes.h - remap #include headers-------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CanonicalIncludes.h"

clang-tools-extra/clangd/index/Symbol.h

struct IncludeHeaderWithReferences {
     ///
     /// Note that the include header is a canonical include for the symbol and
     /// can be different from FileURI in the CanonicalDeclaration.
     llvm::StringRef IncludeHeader = "";
     /// The number of translation units that reference this symbol and include
     /// this header. This number is only meaningful if aggregated in an index.
     unsigned References = 0;
   };
-  /// One Symbol can potentially be incuded via different headers.
+  /// One Symbol can potentially be included via different headers.
   ///   - If we haven't seen a definition, this covers all declarations.
   ///   - If we have seen a definition, this covers declarations visible from
   ///   any definition.
   /// Only set when the symbol is indexed for completion.
   llvm::SmallVector<IncludeHeaderWithReferences, 1> IncludeHeaders;
 
   enum SymbolFlag : uint8_t {
     None = 0,
     /// Whether or not this symbol is meant to be used for the code completion.
     /// See also isIndexedForCodeCompletion().
     /// Note that we don't store completion information (signature, snippet,
-    /// type, inclues) if the symbol is not indexed for code completion.
+    /// type, includes) if the symbol is not indexed for code completion.
     IndexedForCodeCompletion = 1 << 0,
     /// Indicates if the symbol is deprecated.
     Deprecated = 1 << 1,
     /// Symbol is an implementation detail.
     ImplementationDetail = 1 << 2,
     /// Symbol is visible to other files (not e.g. a static helper function).
     VisibleOutsideFile = 1 << 3,
   };

clang-tools-extra/clangd/refactor/Rename.cpp

size_t renameRangeAdjustmentCost(ArrayRef<Range> Indexed, ArrayRef<Range> Lexed,
   int LastDLine = 0, LastDColumn = 0;
   int Cost = 0;
   for (size_t I = 0; I < Indexed.size(); ++I) {
     int DLine = Indexed[I].start.line - Lexed[MappedIndex[I]].start.line;
     int DColumn =
         Indexed[I].start.character - Lexed[MappedIndex[I]].start.character;
     int Line = Indexed[I].start.line;
     if (Line != LastLine)
-      LastDColumn = 0; // colmun offsets don't carry cross lines.
+      LastDColumn = 0; // column offsets don't carry cross lines.
     Cost += abs(DLine - LastDLine) + abs(DColumn - LastDColumn);
     std::tie(LastLine, LastDLine, LastDColumn) = std::tie(Line, DLine, DColumn);
   }
   return Cost;
 }
 
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/refactor/tweaks/DefineInline.cpp

if (AstNode.get<CompoundStmt>() &&
       SelNode->Selected == SelectionTree::Complete) {
     if (const SelectionTree::Node *P = SelNode->Parent)
       return P->ASTNode.get<FunctionDecl>();
   }
   return nullptr;
 }
 
 // Checks the decls mentioned in Source are visible in the context of Target.
-// Achives that by checking declaraions occur before target location in
+// Achieves that by checking declarations occur before target location in
 // translation unit or declared in the same class.
 bool checkDeclsAreVisible(const llvm::DenseSet<const Decl *> &DeclRefs,
                           const FunctionDecl *Target, const SourceManager &SM) {
   SourceLocation TargetLoc = Target->getLocation();
   // To be used in visibility check below, decls in a class are visible
   // independent of order.
   const RecordDecl *Class = nullptr;
   if (const auto *MD = llvm::dyn_cast<CXXMethodDecl>(Target))

clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp

TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) {
   FS.Files[BarHeader] = "";
 
   IgnoreDiagnostics DiagConsumer;
   ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
   auto BarURI = URI::create(BarHeader).toString();
   Symbol Sym = cls("ns::X");
   Sym.CanonicalDeclaration.FileURI = BarURI.c_str();
   Sym.IncludeHeaders.emplace_back(BarURI, 1);
-  // Shoten include path based on search dirctory and insert.
+  // Shoten include path based on search directory and insert.
   auto Results = completions(Server,
                              R"cpp(
           int main() { ns::^ }
       )cpp",
                              {Sym});
   EXPECT_THAT(Results.Completions,
               ElementsAre(AllOf(Named("X"), InsertInclude("\"bar.h\""))));
   // Can be disabled via option.
TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) {
   Symbol SymX = cls("ns::X");
   Symbol SymY = cls("ns::Y");
   std::string BarHeader = testPath("bar.h");
   auto BarURI = URI::create(BarHeader).toString();
   SymX.CanonicalDeclaration.FileURI = BarURI.c_str();
   SymY.CanonicalDeclaration.FileURI = BarURI.c_str();
   SymX.IncludeHeaders.emplace_back("<bar>", 1);
   SymY.IncludeHeaders.emplace_back("<bar>", 1);
-  // Shoten include path based on search dirctory and insert.
+  // Shoten include path based on search directory and insert.
   auto Results = completions(Server,
                              R"cpp(
           namespace ns {
             class X;
             class Y {};
           }
           int main() { ns::^ }
       )cpp",

clang-tools-extra/clangd/unittests/HoverTests.cpp

const std::function<void(HoverInfo &)> ExpectedBuilder;
             void foo() {
               int I = 0;
               decltype(I) J = I;
               ^[[decltype]](J) K = J;
             }
           )cpp",
           [](HoverInfo &HI) { HI.Name = "int"; }},
       {
-          R"cpp(// More compilcated structured types.
+          R"cpp(// More complicated structured types.
             int bar();
             ^[[auto]] (*foo)() = bar;
           )cpp",
           [](HoverInfo &HI) { HI.Name = "int"; }},
       {
           R"cpp(// Should not crash when evaluating the initializer.
             struct Test {};
             void test() { Test && [[te^st]] = {}; }

clang-tools-extra/clangd/unittests/RenameTests.cpp

 namespace {
 
 using testing::Eq;
 using testing::Pair;
 using testing::IsEmpty;
 using testing::UnorderedElementsAre;
 using testing::UnorderedElementsAreArray;
 
-// Covnert a Range to a Ref.
+// Convert a Range to a Ref.
 Ref refWithRange(const clangd::Range &Range, const std::string &URI) {
   Ref Result;
   Result.Kind = RefKind::Reference;
   Result.Location.Start.setLine(Range.start.line);
   Result.Location.Start.setColumn(Range.start.character);
   Result.Location.End.setLine(Range.end.line);
   Result.Location.End.setColumn(Range.end.character);
   Result.Location.FileURI = URI.c_str();
Case Cases[] = {
 
       {R"cpp(// disallow -- symbol is indexable and has other refs in index.
         void f() {
           Out^side s;
         }
       )cpp",
        "used outside main file", HeaderFile, Index},
 
-      {R"cpp(// disallow -- symbol in annonymous namespace in header is not indexable.
+      {R"cpp(// disallow -- symbol in anonymous namespace in header is not indexable.
         namespace {
         class Unin^dexable {};
         }
       )cpp",
        "not eligible for indexing", HeaderFile, Index},
 
-      {R"cpp(// allow -- symbol in annonymous namespace in non-header file is indexable.
+      {R"cpp(// allow -- symbol in anonymous namespace in non-header file is indexable.
         namespace {
         class [[F^oo]] {};
         }
       )cpp",
        nullptr, !HeaderFile, Index},
 
       {R"cpp(// disallow -- namespace symbol isn't supported
         namespace n^s {}

clang-tools-extra/clangd/unittests/SymbolInfoTests.cpp

std::pair<const char *, std::vector<SymbolDetails>>
               {CreateExpectedSymbolDetails("bar", "foo::", "c:@E@foo@bar")}},
           {
               R"cpp( // Parameters in declarations
           void foo(int ba^r);
         )cpp",
               {CreateExpectedSymbolDetails("bar", "foo",
                                            "c:TestTU.cpp@50@F@foo#I#@bar")}},
           {
-              R"cpp( // Type inferrence with auto keyword
+              R"cpp( // Type inference with auto keyword
           struct foo {};
           foo getfoo() { return foo{}; }
           void f() {
             au^to a = getfoo();
           }
         )cpp",
               {/* not implemented */}},
           {

clang-tools-extra/clangd/unittests/SyncAPI.cpp

~CaptureProxy() {
     assert(Future.valid() && "conversion to callback was not called");
     assert(!Target->hasValue());
     Target->emplace(std::move(*Future.get()));
   }
 
 private:
   llvm::Optional<T> *Target;
   // Using shared_ptr to workaround compilation errors with MSVC.
-  // MSVC only allows default-construcitble and copyable objects as future<>
+  // MSVC only allows default-constructible and copyable objects as future<>
   // arguments.
   std::promise<std::shared_ptr<T>> Promise;
   std::future<std::shared_ptr<T>> Future;
 };
 
 template <typename T> CaptureProxy<T> capture(llvm::Optional<T> &Target) {
   return CaptureProxy<T>(Target);
 }

clang-tools-extra/clangd/unittests/TUSchedulerTests.cpp

S.runWithPreamble("", Added, TUScheduler::Stale,
                     });
   // remove() shouldn't crash on missing files.
   S.remove(Added);
 }
 
 TEST_F(TUSchedulerTests, WantDiagnostics) {
   std::atomic<int> CallbackCount(0);
   {
-    // To avoid a racy test, don't allow tasks to actualy run on the worker
+    // To avoid a racy test, don't allow tasks to actually run on the worker
     // thread until we've scheduled them all.
     Notification Ready;
     TUScheduler S(
         CDB, getDefaultAsyncThreadsCount(),
         /*StorePreamblesInMemory=*/true, captureDiags(),
         /*UpdateDebounce=*/std::chrono::steady_clock::duration::zero(),
         ASTRetentionPolicy());
     auto Path = testPath("foo.cpp");

clang-tools-extra/clangd/unittests/TweakTests.cpp

void f(int b = [[1]]) {
       if(int a = 1)
         if([[a + 1]] == 4)
           a = [[[[a]] +]] 1;
       // for loop
       for(int a = 1, b = 2, c = 3; a > [[b + c]]; [[a++]])
         a = [[a + 1]];
       // lambda
       auto lamb = [&[[a]], &[[b]]](int r = [[1]]) {return 1;}
-      // assigment
+      // assignment
       xyz([[a = 5]]);
       xyz([[a *= 5]]);
       // Variable DeclRefExpr
       a = [[b]];
       // statement expression
       [[xyz()]];
       while (a)
         [[++a]];

clang-tools-extra/clangd/unittests/TypeHierarchyTests.cpp

::testing::Matcher<TypeHierarchyItem> Parents(ParentMatchers... ParentsM) {
   return Field(&TypeHierarchyItem::parents,
                HasValue(UnorderedElementsAre(ParentsM...)));
 }
 template <class... ChildMatchers>
 ::testing::Matcher<TypeHierarchyItem> Children(ChildMatchers... ChildrenM) {
   return Field(&TypeHierarchyItem::children,
                HasValue(UnorderedElementsAre(ChildrenM...)));
 }
-// Note: "not resolved" is differnt from "resolved but empty"!
+// Note: "not resolved" is different from "resolved but empty"!
 MATCHER(ParentsNotResolved, "") { return !arg.parents; }
 MATCHER(ChildrenNotResolved, "") { return !arg.children; }
 
 TEST(FindRecordTypeAt, TypeOrVariable) {
   Annotations Source(R"cpp(
 struct Ch^ild2 {
   int c;
 };

clang-tools-extra/clangd/unittests/XRefsTests.cpp

TEST(LocateSymbol, WithIndex) {
 
   Test = Annotations(R"cpp(// forward declaration in AST.
         class [[Foo]];
         F^oo* create();
       )cpp");
   EXPECT_THAT(LocateWithIndex(Test),
               ElementsAre(Sym("Foo", Test.range(), SymbolHeader.range("foo"))));
 
-  Test = Annotations(R"cpp(// defintion in AST.
+  Test = Annotations(R"cpp(// definition in AST.
         class [[Forward]] {};
         F^orward create();
       )cpp");
   EXPECT_THAT(
       LocateWithIndex(Test),
       ElementsAre(Sym("Forward", SymbolHeader.range("forward"), Test.range())));
 }
 

clang-tools-extra/docs/clang-tidy/checks/bugprone-branch-clone.rst

.. code-block:: c++
     case 'B':
       return 11;
     default:
       return 10;
     }
 
 Here the check reports that the ``'a'`` and ``'A'`` branches are identical
 (and that the ``'b'`` and ``'B'`` branches are also identical), but does not
-report that the ``default:`` branch is also idenical to the first two branches.
+report that the ``default:`` branch is also identical to the first two branches.
 If this is indeed the correct behavior, then it could be implemented as:
 
 .. code-block:: c++
 
     switch (ch) {
     case 'a':
     case 'A':
       return 10;

clang-tools-extra/docs/clang-tidy/checks/cert-mem57-cpp.rst

 .. title:: clang-tidy - cert-mem57-cpp
 
 cert-mem57-cpp
 ==============
 
 This check flags uses of default ``operator new`` where the type has extended
 alignment (an alignment greater than the fundamental alignment). (The default
-``operator new`` is guaranteed to provide the correct alignmment if the
+``operator new`` is guaranteed to provide the correct alignment if the
 requested alignment is less or equal to the fundamental alignment).
 Only cases are detected (by design) where the ``operator new`` is not
 user-defined and is not a placement new (the reason is that in these cases we
 assume that the user provided the correct memory allocation).
 
 This check corresponds to the CERT C++ Coding Standard rule
 `MEM57-CPP. Avoid using default operator new for over-aligned types
 <https://wiki.sei.cmu.edu/confluence/display/cplusplus/MEM57-CPP.+Avoid+using+default+operator+new+for+over-aligned+types>`_.

clang-tools-extra/docs/clang-tidy/checks/hicpp-undelegated-constructor.rst

-.. title:: clang-tidy - hicpp-undelegated-construtor
+.. title:: clang-tidy - hicpp-undelegated-constructor
 .. meta::
    :http-equiv=refresh: 5;URL=bugprone-undelegated-constructor.html
 
 hicpp-undelegated-constructor
 =============================
 
 This check is an alias for `bugprone-undelegated-constructor <bugprone-undelegated-constructor.html>`_.
 Partially implements `rule 12.4.5 <http://www.codingstandard.com/rule/12-4-5-use-delegating-constructors-to-reduce-code-duplication/>`_ 

clang-tools-extra/docs/clang-tidy/checks/readability-identifier-naming.rst

 .. title:: clang-tidy - readability-identifier-naming
 
 readability-identifier-naming
 =============================
 
 Checks for identifiers naming style mismatch.
 
 This check will try to enforce coding guidelines on the identifiers naming. It
 supports one of the following casing types and tries to convert from one to
 another if a mismatch is detected
 
-Casing types inclde:
+Casing types include:
 
  - ``lower_case``,
  - ``UPPER_CASE``,
  - ``camelBack``,
  - ``CamelCase``,
  - ``camel_Snake_Back``,
  - ``Camel_Snake_Case``,
  - ``aNy_CasE``.

clang-tools-extra/modularize/Modularize.cpp

 // For example, in examining headers, it detects whether the same entity
 // (say, a NULL macro or size_t typedef) is defined in multiple headers
 // or whether a header produces different definitions under
 // different circumstances. These conditions cause modules built from the
 // headers to behave poorly, and should be fixed before introducing a module
 // map.
 //
 // Modularize takes as input either one or more module maps (by default,
-// "module.modulemap") or one or more text files contatining lists of headers
+// "module.modulemap") or one or more text files containing lists of headers
 // to check.
 //
 // In the case of a module map, the module map must be well-formed in
 // terms of syntax.  Modularize will extract the header file names
 // from the map.  Only normal headers are checked, assuming headers
 // marked "private", "textual", or "exclude" are not to be checked
 // as a top-level include, assuming they either are included by
 // other headers which are checked, or they are not suitable for

clang-tools-extra/modularize/PreprocessorTracker.cpp

 //   Macro defined here.
 //
 // The Basic Idea ('Extern "C/C++" {}' Or 'namespace {}') With Nested
 // '#include' Checking)
 //
 // To check for '#include' directives nested inside 'Extern "C/C++" {}'
 // or 'namespace {}' blocks, we keep track of the '#include' directives
 // while running the preprocessor, and later during a walk of the AST
-// we call a function to check for any '#include' directies inside
+// we call a function to check for any '#include' directives inside
 // an 'Extern "C/C++" {}' or 'namespace {}' block, given its source
 // range.
 //
 // Design and Implementation Details (Macro and Conditional Checking)
 //
 // A PreprocessorTrackerImpl class implements the PreprocessorTracker
 // interface. It uses a PreprocessorCallbacks class derived from PPCallbacks
 // to track preprocessor activity, namely entering/exiting a header, macro
private:
   ConditionalExpansionMap ConditionalExpansions;
   bool InNestedHeader;
 };
 
 } // namespace
 
 // PreprocessorTracker functions.
 
-// PreprocessorTracker desctructor.
+// PreprocessorTracker destructor.
 PreprocessorTracker::~PreprocessorTracker() {}
 
 // Create instance of PreprocessorTracker.
 PreprocessorTracker *PreprocessorTracker::create(
     llvm::SmallVector<std::string, 32> &Headers,
     bool DoBlockCheckHeaderListOnly) {
   return new PreprocessorTrackerImpl(Headers, DoBlockCheckHeaderListOnly);
 }

clang-tools-extra/pp-trace/PPCallbacksTracker.cpp

void PPCallbacksTracker::PragmaMessage(SourceLocation Loc,
                                        llvm::StringRef Str) {
   beginCallback("PragmaMessage");
   appendArgument("Loc", Loc);
   appendArgument("Namespace", Namespace);
   appendArgument("Kind", Kind, PragmaMessageKindStrings);
   appendArgument("Str", Str);
 }
 
-// Callback invoked when a #pragma gcc dianostic push directive
+// Callback invoked when a #pragma gcc diagnostic push directive
 // is read.
 void PPCallbacksTracker::PragmaDiagnosticPush(SourceLocation Loc,
                                               llvm::StringRef Namespace) {
   beginCallback("PragmaDiagnosticPush");
   appendArgument("Loc", Loc);
   appendArgument("Namespace", Namespace);
 }
 
-// Callback invoked when a #pragma gcc dianostic pop directive
+// Callback invoked when a #pragma gcc diagnostic pop directive
 // is read.
 void PPCallbacksTracker::PragmaDiagnosticPop(SourceLocation Loc,
                                              llvm::StringRef Namespace) {
   beginCallback("PragmaDiagnosticPop");
   appendArgument("Loc", Loc);
   appendArgument("Namespace", Namespace);
 }
 
-// Callback invoked when a #pragma gcc dianostic directive is read.
+// Callback invoked when a #pragma gcc diagnostic directive is read.
 void PPCallbacksTracker::PragmaDiagnostic(SourceLocation Loc,
                                           llvm::StringRef Namespace,
                                           diag::Severity Mapping,
                                           llvm::StringRef Str) {
   beginCallback("PragmaDiagnostic");
   appendArgument("Loc", Loc);
   appendArgument("Namespace", Namespace);
   appendArgument("Mapping", (unsigned)Mapping, MappingStrings);

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-no-malloc-custom.cpp

 void newed_array() {
   int *new_array = new int[10]; // OK(1)
 }
 
 void arbitrary_call() {
   // we dont want every function to raise the warning even if malloc is in the name
   malloced_array(); // OK(2)
 
-  // completly unrelated function call to malloc
+  // completely unrelated function call to malloc
   newed_array(); // OK(3)
 }

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-no-malloc.cpp

 void newed_array() {
   int *new_array = new int[10]; // OK(1)
 }
 
 void arbitrary_call() {
   // we dont want every function to raise the warning even if malloc is in the name
   malloced_array(); // OK(2)
 
-  // completly unrelated function call to malloc
+  // completely unrelated function call to malloc
   newed_array(); // OK(3)
 }

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-owning-memory-containers.cpp

 
 private:
   T *data;
   unsigned long size;
 };
 
 } // namespace std
 
-// All of the following codesnippets should be valid with appropriate 'owner<>' anaylsis,
+// All of the following codesnippets should be valid with appropriate 'owner<>' analysis,
 // but currently the type information of 'gsl::owner<>' gets lost in typededuction.
 int main() {
   std::vector<gsl::owner<int *>> OwnerStdVector(100, nullptr);
 
   // Rangebased looping in resource vector.
   for (auto *Element : OwnerStdVector) {
     Element = new int(42);
     // CHECK-NOTES: [[@LINE-1]]:5: warning: assigning newly created 'gsl::owner<>' to non-owner 'int *'

clang-tools-extra/test/clang-tidy/checkers/modernize-make-unique.cpp

 // RUN: %check_clang_tidy -std=c++14-or-later %s modernize-make-unique %t -- -- -I %S/Inputs/modernize-smart-ptr
 
 #include "unique_ptr.h"
 #include "initializer_list.h"
 // CHECK-FIXES: #include <memory>
 
 struct Base {
   Base();
   Base(int, int);
 };
 
void initialization(int T, Base b) {
   // CHECK-FIXES: FFs = std::make_unique<Foo[]>(Num2);
 
   std::unique_ptr<int[]> FI;
   FI.reset(new int[5]()); // default initialization.
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning:
   // CHECK-FIXES: FI = std::make_unique<int[]>(5);
 
   // The check doesn't give warnings and fixes for cases where the original new
-  // expresion doesn't do any initialization.
+  // expression doesn't do any initialization.
   FI.reset(new int[5]);
   FI.reset(new int[Num]);
   FI.reset(new int[Num2]);
 }
 
 void aliases() {
   typedef std::unique_ptr<int> IntPtr;
   IntPtr Typedef = IntPtr(new int);

clang-tools-extra/test/clang-tidy/checkers/modernize-use-nullptr-basic.cpp

void test_assignment() {
   int *p2 = NULL;
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr
   // CHECK-FIXES: int *p2 = nullptr;
 
   p2 = p1;
   // CHECK-FIXES: p2 = p1;
 
   const int null = 0;
   int *p3 = null;
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr
   // CHECK-FIXES: int *p3 = nullptr;
 
   p3 = NULL;
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use nullptr
   // CHECK-FIXES: p3 = nullptr;
 
   int *p4 = p3;
   // CHECK-FIXES: int *p4 = p3;
 
   p4 = null;
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: use nullptr
   // CHECK-FIXES: p4 = nullptr;
 
   int i1 = 0;
 
   int i2 = NULL;
 
   int i3 = null;
Bar(T *p) : m_p(p) {
     m_p = static_cast<T*>(NULL);
     // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use nullptr
     // CHECK-FIXES: m_p = static_cast<T*>(nullptr);
 
     m_p = static_cast<T*>(reinterpret_cast<int*>((void*)NULL));
     // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: use nullptr
     // CHECK-FIXES: m_p = static_cast<T*>(nullptr);
 
     m_p = static_cast<T*>(p ? p : static_cast<void*>(g_null));
     // CHECK-MESSAGES: :[[@LINE-1]]:54: warning: use nullptr
     // CHECK-FIXES: m_p = static_cast<T*>(p ? p : static_cast<void*>(nullptr));
 
     T *p2 = static_cast<T*>(reinterpret_cast<int*>((void*)NULL));
     // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use nullptr
     // CHECK-FIXES: T *p2 = static_cast<T*>(nullptr);
 
     m_p = NULL;

 };
 
 struct Baz {
   Baz() : i(0) {}
   int i;
 };
 
 void test_cxx_cases() {
   Foo f(g_null);
   // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use nullptr
   // CHECK-FIXES: Foo f(nullptr);
 
   f.bar(NULL);
   // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use nullptr
   // CHECK-FIXES: f.bar(nullptr);
 
   f.baz(g_null);
 
   f.m_p1 = 0;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use nullptr
   // CHECK-FIXES: f.m_p1 = nullptr;
 
   Bar<int> b(g_null);
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: use nullptr
   // CHECK-FIXES: Bar<int> b(nullptr);
 
   Baz b2;
   int Baz::*memptr(0);
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use nullptr
   // CHECK-FIXES: int Baz::*memptr(nullptr);
 
   memptr = 0;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use nullptr
   // CHECK-FIXES: memptr = nullptr;
 }
 
 void test_function_default_param1(void *p = 0);
 // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: use nullptr
 // CHECK-FIXES: void test_function_default_param1(void *p = nullptr);
 
 void test_function_default_param2(void *p = NULL);
 // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: use nullptr
 // CHECK-FIXES: void test_function_default_param2(void *p = nullptr);
 
 void test_function_default_param3(void *p = g_null);
 // CHECK-MESSAGES: :[[@LINE-1]]:45: warning: use nullptr
 // CHECK-FIXES: void test_function_default_param3(void *p = nullptr);
 
 void test_function(int *p) {}
 
 void test_function_no_ptr_param(int i) {}
 
 void test_function_call() {
   test_function(0);
   // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use nullptr
   // CHECK-FIXES: test_function(nullptr);
 
   test_function(NULL);
   // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use nullptr
   // CHECK-FIXES: test_function(nullptr);
 
   test_function(g_null);
   // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use nullptr
   // CHECK-FIXES: test_function(nullptr);
 
   test_function_no_ptr_param(0);
 }
 
 char *test_function_return1() {
   return 0;
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr
   // CHECK-FIXES: return nullptr;
 }
 
 void *test_function_return2() {
   return NULL;
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr
   // CHECK-FIXES: return nullptr;
 }
 
 long *test_function_return3() {
   return g_null;
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr
   // CHECK-FIXES: return nullptr;
 }
 
 int test_function_return4() {
   return 0;
 }
 
 int test_function_return5() {
   return NULL;
 }
 
 int test_function_return6() {
   return g_null;
 }
 
 int *test_function_return_cast1() {
   return(int)0;
   // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use nullptr
   // CHECK-FIXES: return nullptr;
 }
 
 int *test_function_return_cast2() {
 #define RET return
   RET(int)0;
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: use nullptr
   // CHECK-FIXES: RET nullptr;
 #undef RET
 }
 
 // Test parentheses expressions resulting in a nullptr.
 int *test_parentheses_expression1() {
   return(0);
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr
   // CHECK-FIXES: return(nullptr);
 }
 
 int *test_parentheses_expression2() {
   return(int(0.f));
   // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: use nullptr
   // CHECK-FIXES: return(nullptr);
 }
 
 int *test_nested_parentheses_expression() {
   return((((0))));
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr
   // CHECK-FIXES: return((((nullptr))));

 }
 
 void test_const_pointers_abiguous() {
   const_ambiguous_function((int*)0);
   // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use nullptr
   // CHECK-FIXES: const_ambiguous_function((int*)nullptr);
 }
 
-// Test where the implicit cast to null is surrounded by another implict cast
-// with possible explict casts in-between.
+// Test where the implicit cast to null is surrounded by another implicit cast
+// with possible explicit casts in-between.
 void test_const_pointers() {
   const int *const_p1 = 0;
   // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr
   // CHECK-FIXES: const int *const_p1 = nullptr;
   const int *const_p2 = NULL;
   // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr
   // CHECK-FIXES: const int *const_p2 = nullptr;
   const int *const_p3 = (int)0;
   // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr
   // CHECK-FIXES: const int *const_p3 = nullptr;
   const int *const_p4 = (int)0.0f;
   // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: use nullptr
   // CHECK-FIXES: const int *const_p4 = nullptr;
   const int *const_p5 = (int*)0;
   // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: use nullptr
   // CHECK-FIXES: const int *const_p5 = (int*)nullptr;
   int *t;
   const int *const_p6 = static_cast<int*>(t ? t : static_cast<int*>(0));
   // CHECK-MESSAGES: :[[@LINE-1]]:69: warning: use nullptr

clang-tools-extra/test/clang-tidy/checkers/performance-unnecessary-value-param-arc.m

 // RUN: clang-tidy %s -checks=-*,performance-unnecessary-value-param -- \
 // RUN:   -xobjective-c -fobjc-abi-version=2 -fobjc-arc | count 0
 
 #if !__has_feature(objc_arc)
 #error Objective-C ARC not enabled as expected
 #endif
 
 // Passing an Objective-C ARC-managed object to a C function should
 // not raise performance-unnecessary-value-param.
 void foo(id object) { }
 
-// Same for explcitly non-ARC-managed Objective-C objects.
+// Same for explicitly non-ARC-managed Objective-C objects.
 void bar(__unsafe_unretained id object) { }
 
 // Same for Objective-c classes.
 void baz(Class c) { }

clang-tools-extra/test/clang-tidy/checkers/performance-unnecessary-value-param-arc.mm

 // RUN: clang-tidy %s -checks=-*,performance-unnecessary-value-param -- \
 // RUN:   -xobjective-c++ -fobjc-abi-version=2 -fobjc-arc | count 0
 
 #if !__has_feature(objc_arc)
 #error Objective-C ARC not enabled as expected
 #endif
 
 // Passing an Objective-C ARC-managed object to a C function should
 // not raise performance-unnecessary-value-param.
 void foo(id object) { }
 
-// Same for explcitly non-ARC-managed Objective-C objects.
+// Same for explicitly non-ARC-managed Objective-C objects.
 void bar(__unsafe_unretained id object) { }
 
 // Same for Objective-c classes.
 void baz(Class c) { }

clang-tools-extra/test/clang-tidy/checkers/readability-redundant-declaration.cpp

 // RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: readability-redundant-declaration.IgnoreMacros, \
 // RUN:               value: 0}]}"
 //
 // With -fms-compatibility and -DEXTERNINLINE, the extern inline shouldn't
 // produce additional diagnostics, so same check suffix as before:
 // RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: readability-redundant-declaration.IgnoreMacros, \
 // RUN:               value: 0}]}" -- -fms-compatibility -DEXTERNINLINE
 //
-// With -fno-ms-compatiblity, DEXTERNINLINE causes additional output.
+// With -fno-ms-compatibility, DEXTERNINLINE causes additional output.
 // (The leading ',' means "default checks in addition to NOMSCOMPAT checks.)
 // RUN: %check_clang_tidy -check-suffix=,NOMSCOMPAT \
 // RUN:   %s readability-redundant-declaration %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: readability-redundant-declaration.IgnoreMacros, \
 // RUN:               value: 0}]}" -- -fno-ms-compatibility -DEXTERNINLINE
 
 extern int Xyz;

clang-tools-extra/unittests/clang-include-fixer/find-all-symbols/FindAllSymbolsTests.cpp

Symbol =
       SymbolInfo("C_struct", SymbolInfo::SymbolKind::Class, HeaderName, {});
   EXPECT_EQ(1, seen(Symbol));
   EXPECT_EQ(1, used(Symbol));
 }
 
 TEST_F(FindAllSymbolsTest, CXXRecordSymbols) {
   static const char Header[] = R"(
       struct Glob {};
-      struct A; // Not a defintion, ignored.
-      class NOP; // Not a defintion, ignored
+      struct A; // Not a definition, ignored.
+      class NOP; // Not a definition, ignored
       namespace na {
       struct A {
         struct AAAA {};
         int x;
         int y;
         void f() {}
       };
       };  //