[clang-tools-extra] NFC: Fix trivial typo in documents and comments

[kiszk]

Summary

This also includes the build failure due to https://reviews.llvm.org/D77458

[kiszk]

@sammccall, I am very sorry that I led to the build break due to my misoperation in https://reviews.llvm.org/D77458

[Eugene.Zelenko]

In D77482#1962000, @kiszk wrote:

@sammccall, I am very sorry that I led to the build break due to my misoperation in https://reviews.llvm.org/D77458

You could just update diff in existing revision. No need to create new one.

[kiszk]

Thank you for letting me know. I will do that.

[kiszk]

I have done in https://reviews.llvm.org/D77458

[Eugene.Zelenko]

In D77482#1962272, @kiszk wrote:

I have done in https://reviews.llvm.org/D77458

Just abandon this revision.

clang-tools-extra/clang-change-namespace/ChangeNamespace.h

 // definitions. Classes/functions in the moved namespace will have new
 // namespaces while references to symbols (e.g. types, functions) which are not
 // defined in the changed namespace will be correctly qualified by prepending
 // namespace specifiers before them.
 // This will try to add shortest namespace specifiers possible. When a symbol
 // reference needs to be fully-qualified, this adds a "::" prefix to the
 // namespace specifiers unless the new namespace is the global namespace.
 // For classes, only classes that are declared/defined in the given namespace in
-// speficifed files will be moved: forward declarations will remain in the old
+// specified files will be moved: forward declarations will remain in the old
 // namespace.
 // For example, changing "a" to "x":
 // Old code:
 //   namespace a {
 //   class FWD;
 //   class A { FWD *fwd; }
 //   }  // a
 // New code:
private:
   // For example, if `OldNamespace` is "a::b::c" and `NewNamespace` is
   // "a::x::y", then `DiffNewNamespace` will be "x::y".
   std::string DiffNewNamespace;
   // A regex pattern that matches files to be processed.
   std::string FilePattern;
   llvm::Regex FilePatternRE;
   // Information about moved namespaces grouped by file.
   // Since we are modifying code in old namespaces (e.g. add namespace
-  // spedifiers) as well as moving them, we store information about namespaces
+  // specifiers) as well as moving them, we store information about namespaces
   // to be moved and only move them after all modifications are finished (i.e.
   // in `onEndOfTranslationUnit`).
   std::map<std::string, std::vector<MoveNamespace>> MoveNamespaces;
   // Information about forward declaration insertions grouped by files.
   // A class forward declaration is not moved, so it will be deleted from the
   // moved code block and inserted back into the old namespace. The insertion
   // will be done after removing the code from the old namespace and before
   // inserting it to the new namespace.

clang-tools-extra/clang-change-namespace/ChangeNamespace.cpp

if (!isDeclVisibleAtLocation(*Result.SourceManager, NamespaceAlias, DeclCtx,
       continue;
     StringRef FromDeclNameRef = FromDeclName;
     if (FromDeclNameRef.consume_front(
             NamespaceAlias->getNamespace()->getQualifiedNameAsString() +
             "::")) {
       std::string AliasName = NamespaceAlias->getNameAsString();
       std::string AliasQualifiedName =
           NamespaceAlias->getQualifiedNameAsString();
-      // We only consider namespace aliases define in the global namepspace or
+      // We only consider namespace aliases define in the global namespace or
       // in namespaces that are directly visible from the reference, i.e.
       // ancestor of the `OldNs`. Note that declarations in ancestor namespaces
       // but not visible in the new namespace is filtered out by
       // "IsVisibleInNewNs" matcher.
       if (AliasQualifiedName != AliasName) {
         // The alias is defined in some namespace.
         assert(StringRef(AliasQualifiedName).endswith("::" + AliasName));
         llvm::StringRef AliasNs =

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

void Generator::addInfoToIndex(Index &Idx, const doc::Info *Info) {
   Index *I = &Idx;
   // The Namespace vector includes the upper-most namespace at the end so the
   // loop will start from the end to find each of the namespaces.
   for (const auto &R : llvm::reverse(Info->Namespace)) {
     // Look for the current namespace in the children of the index I is
     // pointing.
     auto It = std::find(I->Children.begin(), I->Children.end(), R.USR);
     if (It != I->Children.end()) {
-      // If it is found, just change I to point the namespace refererence found.
+      // If it is found, just change I to point the namespace reference found.
       I = &*It;
     } else {
       // If it is not found a new reference is created
       I->Children.emplace_back(R.USR, R.Name, R.RefType, R.Path);
       // I is updated with the reference of the new namespace reference
       I = &I->Children.back();
     }
   }

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

 
 // 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 directory path for class C info will be
 // <root>/A/B
 //
 // namespace A {
-// namesapce B {
+// namespace B {
 //
 // class C {};
 //
 // }
 // }
 llvm::SmallString<128>
 getInfoRelativePath(const llvm::SmallVectorImpl<doc::Reference> &Namespaces) {
   llvm::SmallString<128> Path;

clang-tools-extra/clang-include-fixer/IncludeFixer.h

private:
   bool MinimizeIncludePaths;
 
   /// The fallback format style for formatting after insertion if no
   /// clang-format config file was found.
   std::string FallbackStyle;
 };
 
 /// Create replacements, which are generated by clang-format, for the
-/// missing header and mising qualifiers insertions. The function uses the
+/// missing header and missing qualifiers insertions. The function uses the
 /// first header for insertion.
 ///
 /// \param Code The source code.
 /// \param Context The context which contains all information for creating
 /// clang-include-fixer replacements.
 /// \param Style clang-format style being used.
 /// \param AddQualifiers  Whether we should add qualifiers to all instances of
 /// an unidentified symbol.

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

public:
   struct QuerySymbolInfo {
     /// The raw symbol name being queried in database. This name might
     /// miss some namespace qualifiers, and will be replaced by a fully
     /// qualified one.
     std::string RawIdentifier;
 
     /// The qualifiers of the scope in which SymbolIdentifier lookup
     /// occurs. It is represented as a sequence of names and scope resolution
-    /// operatiors ::, ending with a scope resolution operator (e.g. a::b::).
+    /// operators ::, ending with a scope resolution operator (e.g. a::b::).
     /// Empty if SymbolIdentifier is not in a specific scope.
     std::string ScopedQualifiers;
 
     /// The replacement range of RawIdentifier.
     tooling::Range Range;
   };
 
   IncludeFixerContext() = default;

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

 
 using find_all_symbols::SymbolInfo;
 using find_all_symbols::SymbolAndSignals;
 
 // Calculate a score based on whether we think the given header is closely
 // related to the given source file.
 static double similarityScore(llvm::StringRef FileName,
                               llvm::StringRef Header) {
-  // Compute the maximum number of common path segements between Header and
+  // Compute the maximum number of common path segments between Header and
   // a suffix of FileName.
   // We do not do a full longest common substring computation, as Header
   // specifies the path we would directly #include, so we assume it is rooted
   // relatively to a subproject of the repository.
   int MaxSegments = 1;
   for (auto FileI = llvm::sys::path::begin(FileName),
             FileE = llvm::sys::path::end(FileName);
        FileI != FileE; ++FileI) {

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

void FindAllSymbols::registerMatchers(MatchFinder *MatchFinder) {
   // We only match symbols from header files, i.e. not from main files (see
   // function's comment for detailed explanation).
   auto CommonFilter =
       allOf(unless(isImplicit()), unless(isExpansionInMainFile()));
 
   auto HasNSOrTUCtxMatcher =
       hasDeclContext(anyOf(namespaceDecl(), translationUnitDecl()));
 
-  // We need seperate rules for C record types and C++ record types since some
+  // We need separate rules for C record types and C++ record types since some
   // template related matchers are inapplicable on C record declarations.
   //
   // Matchers specific to C++ code.
   // All declarations should be in namespace or translation unit.
   auto CCMatcher =
       allOf(HasNSOrTUCtxMatcher, unless(IsInSpecialization),
             unless(ast_matchers::isTemplateInstantiation()),
             unless(isInstantiated()), unless(isFullySpecialized()));

clang-tools-extra/clang-include-fixer/find-all-symbols/tool/run-find-all-symbols.py

while not os.path.isfile(os.path.join(result, path)):
     if os.path.realpath(result) == '/':
       print 'Error: could not find compilation database.'
       sys.exit(1)
     result += '../'
   return os.path.realpath(result)
 
 
 def MergeSymbols(directory, args):
-  """Merge all symbol files (yaml) in a given directaory into a single file."""
+  """Merge all symbol files (yaml) in a given directory into a single file."""
   invocation = [args.binary, '-merge-dir='+directory, args.saving_path]
   subprocess.call(invocation)
   print 'Merge is finished. Saving results in ' + args.saving_path
 
 
 def run_find_all_symbols(args, tmpdir, build_path, queue):
   """Takes filenames out of queue and runs find-all-symbols on them."""
   while True:

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

 
 def main():
   parser = argparse.ArgumentParser(
       description='Vim integration for clang-include-fixer')
   parser.add_argument('-db', default='yaml',
                       help='clang-include-fixer input format.')
   parser.add_argument('-input', default='',
                       help='String to initialize the database.')
-  # Don't throw exception when parsing unknown arguements to make the script
+  # Don't throw exception when parsing unknown arguments to make the script
   # work in neovim.
   # Neovim (at least v0.2.1) somehow mangles the sys.argv in a weird way: it
   # will pass additional arguments (e.g. "-c script_host.py") to sys.argv,
   # which makes the script fail.
   args, _ = parser.parse_known_args()
 
   # Get the current text.
   buf = vim.current.buffer

clang-tools-extra/clang-move/Move.cpp

if (const auto *FileEntry = SM.getFileEntryForID(SM.getFileID(HashLoc)))
                             FileEntry->getName(), FilenameRange, SM);
   }
 
 private:
   const SourceManager &SM;
   ClangMoveTool *const MoveTool;
 };
 
-/// Add a declatration being moved to new.h/cc. Note that the declaration will
+/// Add a declaration being moved to new.h/cc. Note that the declaration will
 /// also be deleted in old.h/cc.
 void MoveDeclFromOldFileToNewFile(ClangMoveTool *MoveTool, const NamedDecl *D) {
   MoveTool->getMovedDecls().push_back(D);
   MoveTool->addRemovedDecl(D);
   MoveTool->getUnremovedDeclsInOldHeader().erase(D);
 }
 
 class FunctionDeclarationMatch : public MatchFinder::MatchCallback {
for (const auto &NS : CurrentNamespaces)
     NewCode += "} // namespace " + NS + "\n";
 
   if (IsHeader)
     NewCode += "\n#endif // " + GuardName + "\n";
   return tooling::Replacements(tooling::Replacement(FileName, 0, 0, NewCode));
 }
 
 // Return a set of all decls which are used/referenced by the given Decls.
-// Specically, given a class member declaration, this method will return all
+// Specifically, given a class member declaration, this method will return all
 // decls which are used by the whole class.
 llvm::DenseSet<const Decl *>
 getUsedDecls(const HelperDeclRefGraph *RG,
              const std::vector<const NamedDecl *> &Decls) {
   assert(RG);
   llvm::DenseSet<const CallGraphNode *> Nodes;
   for (const auto *D : Decls) {
     auto Result = RG->getReachableNodes(
for (auto &FileAndReplacements : Context->FileToReplacements) {
     StringRef FilePath = FileAndReplacements.first;
     // Add #include of new header to old header.
     if (Context->Spec.OldDependOnNew &&
         MakeAbsolutePath(SM, FilePath) ==
             makeAbsolutePath(Context->Spec.OldHeader)) {
       // FIXME: Minimize the include path like clang-include-fixer.
       std::string IncludeNewH =
           "#include \"" + Context->Spec.NewHeader + "\"\n";
-      // This replacment for inserting header will be cleaned up at the end.
+      // This replacement for inserting header will be cleaned up at the end.
       auto Err = FileAndReplacements.second.add(
           tooling::Replacement(FilePath, UINT_MAX, 0, IncludeNewH));
       if (Err)
         llvm::errs() << llvm::toString(std::move(Err)) << "\n";
     }
 
     auto SI = FilePathToFileID.find(FilePath);
     // Ignore replacements for new.h/cc.
for (const auto *MovedDecl : MovedDecls) {
     else
       NewCCDecls.push_back(MovedDecl);
   }
 
   auto UsedDecls = getUsedDecls(RGBuilder.getGraph(), RemovedDecls);
   std::vector<const NamedDecl *> ActualNewCCDecls;
 
   // Filter out all unused helpers in NewCCDecls.
-  // We only move the used helpers (including transively used helpers) and the
+  // We only move the used helpers (including transitively used helpers) and the
   // given symbols being moved.
   for (const auto *D : NewCCDecls) {
     if (llvm::is_contained(HelperDeclarations, D) &&
         !UsedDecls.count(HelperDeclRGBuilder::getOutmostClassOrFunDecl(
             D->getCanonicalDecl())))
       continue;
 
     LLVM_DEBUG(llvm::dbgs() << "Helper used in new.cc: " << D->getNameAsString()

clang-tools-extra/clang-reorder-fields/ReorderFieldsAction.cpp

for (BoundNodes &BN : FoundExprs)
     if (auto *MemExpr = BN.getNodeAs<MemberExpr>("ME"))
       if (auto *FD = dyn_cast<FieldDecl>(MemExpr->getMemberDecl()))
         Results.insert(FD);
   return Results;
 }
 
 /// Reorders fields in the definition of a struct/class.
 ///
-/// At the moment reodering of fields with
+/// At the moment reordering of fields with
 /// different accesses (public/protected/private) is not supported.
 /// \returns true on success.
 static bool reorderFieldsInDefinition(
     const RecordDecl *Definition, ArrayRef<unsigned> NewFieldsOrder,
     const ASTContext &Context,
     std::map<std::string, tooling::Replacements> &Replacements) {
   assert(Definition && "Definition is null");
 
   SmallVector<const FieldDecl *, 10> Fields;
   for (const auto *Field : Definition->fields())
     Fields.push_back(Field);
 
   // Check that the permutation of the fields doesn't change the accesses
   for (const auto *Field : Definition->fields()) {
     const auto FieldIndex = Field->getFieldIndex();
     if (Field->getAccess() != Fields[NewFieldsOrder[FieldIndex]]->getAccess()) {
-      llvm::errs() << "Currently reodering of fields with different accesses "
+      llvm::errs() << "Currently reordering of fields with different accesses "
                       "is not supported\n";
       return false;
     }
   }
 
   for (const auto *Field : Definition->fields()) {
     const auto FieldIndex = Field->getFieldIndex();
     if (FieldIndex == NewFieldsOrder[FieldIndex])

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

if (IntLit)
     return IntLit->getValue().getLimitedValue();
 
   assert(FloatLit != nullptr && "Neither IntLit nor FloatLit set");
   return FloatLit->getValueAsApproximateDouble();
 }
 
 // Given the scale of a duration and a `Multiplier`, determine if `Multiplier`
 // would produce a new scale.  If so, return a tuple containing the new scale
-// and a suitable Multipler for that scale, otherwise `None`.
+// and a suitable Multiplier for that scale, otherwise `None`.
 static llvm::Optional<std::tuple<DurationScale, double>>
 GetNewScaleSingleStep(DurationScale OldScale, double Multiplier) {
   switch (OldScale) {
   case DurationScale::Hours:
     if (Multiplier <= 1.0 / 60.0)
       return std::make_tuple(DurationScale::Minutes, Multiplier * 60.0);
     break;
 

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

truncateIfIntegral(const FloatingLiteral &FloatLiteral) {
   return llvm::None;
 }
 
 const std::pair<llvm::StringRef, llvm::StringRef> &
 getDurationInverseForScale(DurationScale Scale) {
   static const llvm::IndexedMap<std::pair<llvm::StringRef, llvm::StringRef>,
                                 DurationScale2IndexFunctor>
       InverseMap = []() {
-        // TODO: Revisit the immediately invoked lamba technique when
+        // TODO: Revisit the immediately invoked lambda technique when
         // IndexedMap gets an initializer list constructor.
         llvm::IndexedMap<std::pair<llvm::StringRef, llvm::StringRef>,
                          DurationScale2IndexFunctor>
             InverseMap;
         InverseMap.resize(6);
         InverseMap[DurationScale::Hours] =
             std::make_pair("::absl::ToDoubleHours", "::absl::ToInt64Hours");
         InverseMap[DurationScale::Minutes] =

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

diag(Node->getBeginLoc(), "perform subtraction in the time domain")
       << FixItHint::CreateReplacement(Node->getSourceRange(), Replacement);
 }
 
 void TimeSubtractionCheck::registerMatchers(MatchFinder *Finder) {
   for (auto ScaleName :
        {"Hours", "Minutes", "Seconds", "Millis", "Micros", "Nanos"}) {
     std::string TimeInverse = (llvm::Twine("ToUnix") + ScaleName).str();
     llvm::Optional<DurationScale> Scale = getScaleForTimeInverse(TimeInverse);
-    assert(Scale && "Unknow scale encountered");
+    assert(Scale && "Unknown scale encountered");
 
     auto TimeInverseMatcher = callExpr(callee(
         functionDecl(hasName((llvm::Twine("::absl::") + TimeInverse).str()))
             .bind("func_decl")));
 
     // Match the cases where we know that the result is a 'Duration' and the
     // first argument is a 'Time'. Just knowing the type of the first operand
     // is not sufficient, since the second operand could be either a 'Time' or

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

for (size_t i = 0; i + 1 < N; i++) {
             !areStatementsIdentical(Branches[i]->IgnoreContainers(),
                                     Branches[j]->IgnoreContainers(), Context))
           continue;
 
         NumCopies++;
         KnownAsClone[j] = true;
 
         if (NumCopies == 2) {
-          // We report the first occurence only when we find the second one.
+          // We report the first occurrence only when we find the second one.
           diag(Branches[i]->getBeginLoc(),
                "repeated branch in conditional chain");
           SourceLocation End =
               Lexer::getLocForEndOfToken(Branches[i]->getEndLoc(), 0,
                                          *Result.SourceManager, getLangOpts());
           if (End.isValid()) {
             diag(End, "end of the original", DiagnosticIDs::Note);
           }
while (BeginCurrent < End) {
       // complete family of consecutive identical branches.
       if (EndCurrent > BeginCurrent + 1) {
         diag(BeginCurrent->front()->getBeginLoc(),
              "switch has %0 consecutive identical branches")
             << static_cast<int>(std::distance(BeginCurrent, EndCurrent));
 
         SourceLocation EndLoc = (EndCurrent - 1)->back()->getEndLoc();
         // If the case statement is generated from a macro, it's SourceLocation
-        // may be invalid, resuling in an assertation failure down the line.
+        // may be invalid, resulting in an assertion failure down the line.
         // While not optimal, try the begin location in this case, it's still
         // better then nothing.
         if (EndLoc.isInvalid())
           EndLoc = (EndCurrent - 1)->back()->getBeginLoc();
 
         if (EndLoc.isMacroID())
           EndLoc = Context.getSourceManager().getExpansionLoc(EndLoc);
         EndLoc = Lexer::getLocForEndOfToken(EndLoc, 0, *Result.SourceManager,

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

void FoldInitTypeCheck::doCheck(const BuiltinType &IterValueType,
   if (!isValidBuiltinFold(IterValueType, InitType, Context)) {
     diag(CallNode.getExprLoc(), "folding type %0 into type %1 might result in "
                                 "loss of precision")
         << IterValueType.desugar() << InitType.desugar();
   }
 }
 
 void FoldInitTypeCheck::check(const MatchFinder::MatchResult &Result) {
-  // Given the iterator and init value type retreived by the matchers,
+  // Given the iterator and init value type retrieved by the matchers,
   // we check that the ::value_type of the iterator is compatible with
   // the init value type.
   const auto *InitType = Result.Nodes.getNodeAs<BuiltinType>("InitType");
   const auto *IterValueType =
       Result.Nodes.getNodeAs<BuiltinType>("IterValueType");
   assert(InitType != nullptr);
   assert(IterValueType != nullptr);
 

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

Finder->addMatcher(
       cxxNewExpr(isArray(), hasArraySize(BadArg)).bind("Alloc"), this);
 }
 
 void MisplacedOperatorInStrlenInAllocCheck::check(
     const MatchFinder::MatchResult &Result) {
   const Expr *Alloc = Result.Nodes.getNodeAs<CallExpr>("Alloc");
   if (!Alloc)
     Alloc = Result.Nodes.getNodeAs<CXXNewExpr>("Alloc");
-  assert(Alloc && "Matched node bound by 'Alloc' shoud be either 'CallExpr'"
+  assert(Alloc && "Matched node bound by 'Alloc' should be either 'CallExpr'"
          " or 'CXXNewExpr'");
 
   const auto *StrLen = Result.Nodes.getNodeAs<CallExpr>("StrLen");
   const auto *BinOp = Result.Nodes.getNodeAs<BinaryOperator>("BinOp");
 
   const StringRef StrLenText = Lexer::getSourceText(
       CharSourceRange::getTokenRange(StrLen->getSourceRange()),
       *Result.SourceManager, getLangOpts());
   const StringRef Arg0Text = Lexer::getSourceText(

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

void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
   // Detect strange double-sizeof expression like: sizeof(sizeof(...));
   // Note: The expression 'sizeof(sizeof(0))' is accepted.
   Finder->addMatcher(
       expr(sizeOfExpr(has(ignoringParenImpCasts(expr(
                hasSizeOfDescendant(8, expr(SizeOfExpr, unless(SizeOfZero))))))))
           .bind("sizeof-sizeof-expr"),
       this);
 
-  // Detect sizeof in pointer aritmetic like: N * sizeof(S) == P1 - P2 or
+  // Detect sizeof in pointer arithmetic like: N * sizeof(S) == P1 - P2 or
   // (P1 - P2) / sizeof(S) where P1 and P2 are pointers to type S.
   const auto PtrDiffExpr = binaryOperator(
       hasOperatorName("-"),
       hasLHS(expr(hasType(hasUnqualifiedDesugaredType(pointerType(pointee(
           hasUnqualifiedDesugaredType(type().bind("left-ptr-type")))))))),
       hasRHS(expr(hasType(hasUnqualifiedDesugaredType(pointerType(pointee(
           hasUnqualifiedDesugaredType(type().bind("right-ptr-type")))))))));
 

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

 }
 
 void SuspiciousEnumUsageCheck::checkSuspiciousBitmaskUsage(
     const Expr *NodeExpr, const EnumDecl *EnumDec) {
   const auto *EnumExpr = dyn_cast<DeclRefExpr>(NodeExpr);
   const auto *EnumConst =
       EnumExpr ? dyn_cast<EnumConstantDecl>(EnumExpr->getDecl()) : nullptr;
 
-  // Report the parameter if neccessary.
+  // Report the parameter if necessary.
   if (!EnumConst) {
     diag(EnumDec->getInnerLocStart(), BitmaskVarErrorMessage)
         << countNonPowOfTwoLiteralNum(EnumDec);
     diag(EnumExpr->getExprLoc(), BitmaskNoteMessage, DiagnosticIDs::Note);
   } else if (isNonPowerOf2NorNullLiteral(EnumConst)) {
     diag(EnumConst->getSourceRange().getBegin(), BitmaskErrorMessage);
     diag(EnumExpr->getExprLoc(), BitmaskNoteMessage, DiagnosticIDs::Note);
   }

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

const auto *ConcatenatedLiteral =
       Result.Nodes.getNodeAs<StringLiteral>("str");
   assert(InitializerList && ConcatenatedLiteral);
 
   // Skip small arrays as they often generate false-positive.
   unsigned int Size = InitializerList->getNumInits();
   if (Size < SizeThreshold)
     return;
 
-  // Count the number of occurence of concatenated string literal.
+  // Count the number of occurrence of concatenated string literal.
   unsigned int Count = 0;
   for (unsigned int i = 0; i < Size; ++i) {
     const Expr *Child = InitializerList->getInit(i)->IgnoreImpCasts();
     if (const auto *Literal = dyn_cast<StringLiteral>(Child)) {
       if (Literal->getNumConcatenated() > 1)
         ++Count;
     }
   }

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

 void UnusedRaiiCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
 
   // We ignore code expanded from macros to reduce the number of false
   // positives.
   if (E->getBeginLoc().isMacroID())
     return;
 
-  // Don't emit a warning for the last statement in the surrounding compund
+  // Don't emit a warning for the last statement in the surrounding compound
   // statement.
   const auto *CS = Result.Nodes.getNodeAs<CompoundStmt>("compound");
   if (E == CS->body_back())
     return;
 
   // Emit a warning.
   auto D = diag(E->getBeginLoc(), "object destroyed immediately after "
                                   "creation; did you mean to name the object?");

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

 UseAfterMoveFinder::UseAfterMoveFinder(ASTContext *TheContext)
     : Context(TheContext) {}
 
 bool UseAfterMoveFinder::find(Stmt *FunctionBody, const Expr *MovingCall,
                               const ValueDecl *MovedVariable,
                               UseAfterMove *TheUseAfterMove) {
   // Generate the CFG manually instead of through an AnalysisDeclContext because
   // it seems the latter can't be used to generate a CFG for the body of a
-  // labmda.
+  // lambda.
   //
   // We include implicit and temporary destructors in the CFG so that
   // destructors marked [[noreturn]] are handled correctly in the control flow
   // analysis. (These are used in some styles of assertion macros.)
   CFG::BuildOptions Options;
   Options.AddImplicitDtors = true;
   Options.AddTemporaryDtors = true;
   std::unique_ptr<CFG> TheCFG =

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

bool OwningMemoryCheck::handleDeletion(const BoundNodes &Nodes) {
   }
   return false;
 }
 
 bool OwningMemoryCheck::handleLegacyConsumers(const BoundNodes &Nodes) {
   // Result of matching for legacy consumer-functions like `::free()`.
   const auto *LegacyConsumer = Nodes.getNodeAs<CallExpr>("legacy_consumer");
 
-  // FIXME: `freopen` should be handled seperately because it takes the filename
+  // FIXME: `freopen` should be handled separately because it takes the filename
   // as a pointer, which should not be an owner. The argument that is an owner
   // is known and the false positive coming from the filename can be avoided.
   if (LegacyConsumer) {
     diag(LegacyConsumer->getBeginLoc(),
          "calling legacy resource function without passing a 'gsl::owner<>'")
         << LegacyConsumer->getSourceRange();
     return true;
   }

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

private:
   // To fix: Add () or {}.
   void checkUninitializedTrivialType(const ASTContext &Context,
                                      const VarDecl *Var);
 
   // Whether arrays need to be initialized or not. Default is false.
   bool IgnoreArrays;
 
   // Whether fix-its for initialization of fundamental type use assignment
-  // instead of brace initalization. Only effective in C++11 mode. Default is
+  // instead of brace initialization. Only effective in C++11 mode. Default is
   // false.
   bool UseAssignment;
 };
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_MEMBER_INIT_H

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

if (Init->isWritten()) {
 
       // Gets either the field or base class being initialized by the provided
       // initializer.
       const auto *InitDecl =
           Init->isAnyMemberInitializer()
               ? static_cast<const NamedDecl *>(Init->getAnyMember())
               : Init->getBaseClass()->getAsCXXRecordDecl();
 
-      // Add all fields between current field up until the next intializer.
+      // Add all fields between current field up until the next initializer.
       for (; Decl != std::end(OrderedDecls) && *Decl != InitDecl; ++Decl) {
         if (const auto *D = dyn_cast<T>(*Decl)) {
           if (DeclsToInit.count(D) > 0)
             Insertions.back().Initializers.emplace_back(getName(D));
         }
       }
 
       Insertions.emplace_back(InitializerPlacement::After, Init);

clang-tools-extra/clang-tidy/fuchsia/MultipleInheritanceCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_MULTIPLE_INHERITANCE_H
 
 #include "../ClangTidyCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace fuchsia {
 
-/// Mulitple implementation inheritance is discouraged.
+/// Multiple implementation inheritance is discouraged.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-multiple-inheritance.html
 class MultipleInheritanceCheck : public ClangTidyCheck {
 public:
   MultipleInheritanceCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {

clang-tools-extra/clang-tidy/hicpp/ExceptionBaseclassCheck.cpp

Finder->addMatcher(
               hasType(qualType(hasCanonicalType(hasDeclaration(cxxRecordDecl(
                   isSameOrDerivedFrom(hasName("::std::exception")))))))))),
           // This condition is always true, but will bind to the
           // template value if the thrown type is templated.
           anyOf(has(expr(
                     hasType(substTemplateTypeParmType().bind("templ_type")))),
                 anything()),
           // Bind to the declaration of the type of the value that
-          // is thrown. 'anything()' is necessary to always suceed
+          // is thrown. 'anything()' is necessary to always succeed
           // in the 'eachOf' because builtin types are not
           // 'namedDecl'.
           eachOf(has(expr(hasType(namedDecl().bind("decl")))), anything()))
           .bind("bad_throw"),
       this);
 }
 
 void ExceptionBaseclassCheck::check(const MatchFinder::MatchResult &Result) {

clang-tools-extra/clang-tidy/hicpp/MultiwayPathsCoveredCheck.cpp

while (CurrentCase) {
 
     CurrentCase = CurrentCase->getNextSwitchCase();
   }
 
   return std::make_pair(CaseCount, HasDefault);
 }
 
 /// This function calculate 2 ** Bits and returns
-/// numeric_limits<std::size_t>::max() if an overflow occured.
+/// numeric_limits<std::size_t>::max() if an overflow occurred.
 static std::size_t twoPow(std::size_t Bits) {
   return Bits >= std::numeric_limits<std::size_t>::digits
              ? std::numeric_limits<std::size_t>::max()
              : static_cast<size_t>(1) << Bits;
 }
 
 /// Get the number of possible values that can be switched on for the type T.
 ///
void MultiwayPathsCoveredCheck::handleSwitchWithoutDefault(
   // Determine the number of case labels. Because 'default' is not present
   // and duplicating case labels is not allowed this number represents
   // the number of codepaths. It can be directly compared to 'MaxPathsPossible'
   // to see if some cases are missing.
   // CaseCount == 0 is caught in DegenerateSwitch. Necessary because the
   // matcher used for here does not match on degenerate 'switch'.
   assert(CaseCount > 0 && "Switch statement without any case found. This case "
                           "should be excluded by the matcher and is handled "
-                          "separatly.");
+                          "separately.");
   std::size_t MaxPathsPossible = [&]() {
     if (const auto *GeneralCondition =
             Result.Nodes.getNodeAs<DeclRefExpr>("non-enum-condition")) {
       return getNumberOfPossibleValues(GeneralCondition->getType(),
                                        *Result.Context);
     }
     if (const auto *BitfieldDecl =
             Result.Nodes.getNodeAs<FieldDecl>("bitfield")) {

clang-tools-extra/clang-tidy/misc/NoRecursionCheck.cpp

 
 void NoRecursionCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(translationUnitDecl().bind("TUDecl"), this);
 }
 
 void NoRecursionCheck::handleSCC(ArrayRef<CallGraphNode *> SCC) {
   assert(!SCC.empty() && "Empty SCC does not make sense.");
 
-  // First of all, call out every stongly connected function.
+  // First of all, call out every strongly connected function.
   for (CallGraphNode *N : SCC) {
     FunctionDecl *D = N->getDefinition();
     diag(D->getLocation(), "function %0 is within a recursive call chain") << D;
   }
 
   // Now, SCC only tells us about strongly connected function declarations in
   // the call graph. It doesn't *really* tell us about the cycles they form.
   // And there may be more than one cycle in SCC.
   // So let's form a call stack that eventually exposes *some* cycle.
   const CallStackTy EventuallyCyclicCallStack = PathfindSomeCycle(SCC);
   assert(!EventuallyCyclicCallStack.empty() && "We should've found the cycle");
 
   // While last node of the call stack does cause a loop, due to the way we
-  // pathfind the cycle, the loop does not nessesairly begin at the first node
+  // pathfind the cycle, the loop does not necessarily begin at the first node
   // of the call stack, so drop front nodes of the call stack until it does.
   const auto CyclicCallStack =
       ArrayRef<CallGraphNode::CallRecord>(EventuallyCyclicCallStack)
           .drop_until([LastNode = EventuallyCyclicCallStack.back()](
                           CallGraphNode::CallRecord FrontNode) {
             return FrontNode == LastNode;
           });
   assert(CyclicCallStack.size() >= 2 && "Cycle requires at least 2 frames");

 
 void NoRecursionCheck::check(const MatchFinder::MatchResult &Result) {
   // Build call graph for the entire translation unit.
   const auto *TU = Result.Nodes.getNodeAs<TranslationUnitDecl>("TUDecl");
   CallGraph CG;
   CG.addToCallGraph(const_cast<TranslationUnitDecl *>(TU));
 
   // Look for cycles in call graph,
-  // by looking for Strongly Connected Comonents (SCC's)
+  // by looking for Strongly Connected Components (SCC's)
   for (llvm::scc_iterator<CallGraph *> SCCI = llvm::scc_begin(&CG),
                                        SCCE = llvm::scc_end(&CG);
        SCCI != SCCE; ++SCCI) {
     if (!SCCI.hasCycle()) // We only care about cycles, not standalone nodes.
       continue;
     handleSCC(*SCCI);
   }
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

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

bool ForLoopIndexUseVisitor::TraverseCXXOperatorCallExpr(
 
   default:
     break;
   }
   return VisitorBase::TraverseCXXOperatorCallExpr(OpCall);
 }
 
 /// If we encounter an array with IndexVar as the index of an
-/// ArraySubsriptExpression, note it as a consistent usage and prune the
+/// ArraySubscriptExpression, note it as a consistent usage and prune the
 /// AST traversal.
 ///
 /// For example, given
 /// \code
 ///   const int N = 5;
 ///   int arr[N];
 /// \endcode
 /// This is intended to permit

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

void MakeSmartPtrCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Type = Result.Nodes.getNodeAs<QualType>(PointerType);
   const auto *New = Result.Nodes.getNodeAs<CXXNewExpr>(NewExpression);
 
   // Skip when this is a new-expression with `auto`, e.g. new auto(1)
   if (New->getType()->getPointeeType()->getContainedAutoType())
     return;
 
   // Be conservative for cases where we construct an array without any
-  // initalization.
+  // initialization.
   // For example,
   //    P.reset(new int[5]) // check fix: P = std::make_unique<int []>(5)
   //
   // The fix of the check has side effect, it introduces default initialization
   // which maybe unexpected and cause performance regression.
   if (New->isArray() && !New->hasInitializer())
     return;
   if (Construct)

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

void UseAutoCheck::registerMatchers(MatchFinder *Finder) {
     Finder->addMatcher(makeCombinedMatcher(), this);
 }
 
 void UseAutoCheck::replaceIterators(const DeclStmt *D, ASTContext *Context) {
   for (const auto *Dec : D->decls()) {
     const auto *V = cast<VarDecl>(Dec);
     const Expr *ExprInit = V->getInit();
 
-    // Skip expressions with cleanups from the intializer expression.
+    // Skip expressions with cleanups from the initializer expression.
     if (const auto *E = dyn_cast<ExprWithCleanups>(ExprInit))
       ExprInit = E->getSubExpr();
 
     const auto *Construct = dyn_cast<CXXConstructExpr>(ExprInit);
     if (!Construct)
       continue;
 
     // Ensure that the constructor receives a single argument.

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

private:
   /// non-macro SourceLocation of the argument in the arg list to that macro.
   /// These results are returned via \c MacroLoc and \c ArgLoc respectively.
   /// These values are undefined if the return value is false.
   ///
   /// \returns false if one of the returned SourceLocations would be a
   /// SourceLocation pointing within the definition of another macro.
   bool getMacroAndArgLocations(SourceLocation Loc, SourceLocation &ArgLoc,
                                SourceLocation &MacroLoc) {
-    assert(Loc.isMacroID() && "Only reasonble to call this on macros");
+    assert(Loc.isMacroID() && "Only reasonable to call this on macros");
 
     ArgLoc = Loc;
 
     // Find the location of the immediate macro expansion.
     while (true) {
       std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(ArgLoc);
       const SrcMgr::SLocEntry *E = &SM.getSLocEntry(LocInfo.first);
       const SrcMgr::ExpansionInfo &Expansion = E->getExpansion();

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

void UseTrailingReturnTypeCheck::check(const MatchFinder::MatchResult &Result) {
   if (ReturnTypeCVRange.isInvalid())
     return;
 
   // Check if unqualified names in the return type conflict with other entities
   // after the rewrite.
   // FIXME: this could be done better, by performing a lookup of all
   // unqualified names in the return type in the scope of the function. If the
   // lookup finds a different entity than the original entity identified by the
-  // name, then we can either not perform a rewrite or explicitely qualify the
+  // name, then we can either not perform a rewrite or explicitly qualify the
   // entity. Such entities could be function parameter names, (inherited) class
   // members, template parameters, etc.
   UnqualNameVisitor UNV{*F};
   UNV.TraverseTypeLoc(FTL.getReturnLoc());
   if (UNV.Collision) {
     diag(F->getLocation(), Message);
     return;
   }

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

static CheckResult checkDef(const clang::FunctionDecl *Def,
   if (!Tok)
     return Result;
 
   Result.ConstRange =
       CharSourceRange::getCharRange(Tok->getLocation(), Tok->getEndLoc());
   Result.Hints.push_back(FixItHint::CreateRemoval(Result.ConstRange));
 
   // Fix the definition and any visible declarations, but don't warn
-  // seperately for each declaration. Instead, associate all fixes with the
+  // separately for each declaration. Instead, associate all fixes with the
   // single warning at the definition.
   for (const FunctionDecl *Decl = Def->getPreviousDecl(); Decl != nullptr;
        Decl = Decl->getPreviousDecl()) {
     if (llvm::Optional<Token> T = findConstToRemove(Decl, MatchResult))
       Result.Hints.push_back(FixItHint::CreateRemoval(
           CharSourceRange::getCharRange(T->getLocation(), T->getEndLoc())));
     else
       // `getInnerLocStart` gives the start of the return type.

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

Finder->addMatcher(
                 hasCastKind(CK_MemberPointerToBoolean)),
           // Exclude case of using if or while statements with variable
           // declaration, e.g.:
           //   if (int var = functionCall()) {}
           unless(
               hasParent(stmt(anyOf(ifStmt(), whileStmt()), has(declStmt())))),
           // Exclude cases common to implicit cast to and from bool.
           unless(exceptionCases), unless(has(boolXor)),
-          // Retrive also parent statement, to check if we need additional
+          // Retrieve also parent statement, to check if we need additional
           // parens in replacement.
           anyOf(hasParent(stmt().bind("parentStmt")), anything()),
           unless(isInTemplateInstantiation()),
           unless(hasAncestor(functionTemplateDecl())))
           .bind("implicitCastToBool"),
       this);
 
   auto boolComparison = binaryOperator(hasAnyOperatorName("==", "!="),

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

declRanges(const DeclStmt *DS, const SourceManager &SM,
   // FIXME: Member pointers are not transformed correctly right now, that's
   // why they are treated as problematic here.
   if (typeIsMemberPointer(FirstDecl->getType().IgnoreParens().getTypePtr()))
     return None;
 
   // Consider the following case: 'int * pointer, value = 42;'
   // Created slices (inclusive)    [  ][       ] [         ]
   // Because 'getBeginLoc' points to the start of the variable *name*, the
-  // location of the pointer must be determined separatly.
+  // location of the pointer must be determined separately.
   SourceLocation Start = findStartOfIndirection(
       FirstDecl->getLocation(),
       countIndirections(FirstDecl->getType().IgnoreParens().getTypePtr()), SM,
       LangOpts);
 
   // Fix function-pointer declarations that have a '(' in front of the
   // pointer.
   // Example: 'void (*f2)(int), (*g2)(int, float) = gg;'
   // Slices:   [   ][        ] [                     ]
   if (FirstDecl->getType()->isFunctionPointerType())
     Start = findPreviousTokenKind(Start, SM, LangOpts, tok::l_paren);
 
-  // It is popssible that a declarator is wrapped with parens.
+  // It is possible that a declarator is wrapped with parens.
   // Example: 'float (((*f_ptr2)))[42], *f_ptr3, ((f_value2)) = 42.f;'
   // The slice for the type-part must not contain these parens. Consequently
   // 'Start' is moved to the most left paren if there are parens.
   while (true) {
     if (Start.isInvalid() || Start.isMacroID())
       break;
 
     Token T = getPreviousToken(Start, SM, LangOpts);

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

public:
   }
 
   // If OnConstObject is true, then this is a MemberExpr using
   // a constant this, i.e. 'const S' or 'const S *'.
   bool VisitUser(const MemberExpr *Member, bool OnConstObject) {
     if (Member->isBoundMemberFunction(Ctxt)) {
       if (!OnConstObject || Member->getFoundDecl().getAccess() != AS_public) {
         // Non-public non-static member functions might not preserve the
-        // logical costness. E.g. in
+        // logical constness. E.g. in
         // class C {
         //   int &data() const;
         // public:
         //   int &get() { return data(); }
         // };
         // get() uses a private const method, but must not be made const
         // itself.
         return false; // Stop traversal.

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

if (EndLine - StartLine + 1 <= ShortNamespaceLines)
     return;
 
   // Find next token after the namespace closing brace.
   SourceLocation AfterRBrace = Lexer::getLocForEndOfToken(
       ND->getRBraceLoc(), /*Offset=*/0, Sources, getLangOpts());
   SourceLocation Loc = AfterRBrace;
   SourceLocation LBraceLoc = ND->getBeginLoc();
 
-  // Currently for nested namepsace (n1::n2::...) the AST matcher will match foo
+  // Currently for nested namespace (n1::n2::...) the AST matcher will match foo
   // then bar instead of a single match. So if we got a nested namespace we have
   // to skip the next ones.
   for (const auto &EndOfNameLocation : Ends) {
     if (Sources.isBeforeInTranslationUnit(ND->getLocation(), EndOfNameLocation))
       return;
   }
 
   llvm::Optional<std::string> NamespaceNameAsWritten =

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

 void UppercaseLiteralSuffixCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "NewSuffixes",
                 utils::options::serializeStringList(NewSuffixes));
   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 }
 
 void UppercaseLiteralSuffixCheck::registerMatchers(MatchFinder *Finder) {
-  // Sadly, we can't check whether the literal has sufix or not.
+  // Sadly, we can't check whether the literal has suffix or not.
   // E.g. i32 suffix still results in 'BuiltinType::Kind::Int'.
   // And such an info is not stored in the *Literal itself.
   Finder->addMatcher(
       stmt(eachOf(integerLiteral().bind(IntegerLiteralCheck::Name),
                   floatLiteral().bind(FloatingLiteralCheck::Name)),
            unless(anyOf(hasParent(userDefinedLiteral()),
                         hasAncestor(isImplicit()),
                         hasAncestor(substNonTypeTemplateParmExpr())))),

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

ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::throwsException(
   auto Result = ExceptionInfo::createUnknown();
   if (const auto *FPT = Func->getType()->getAs<FunctionProtoType>()) {
     for (const QualType &Ex : FPT->exceptions())
       Result.registerException(Ex.getTypePtr());
   }
   return Result;
 }
 
-/// Analyzes a single statment on it's throwing behaviour. This is in principle
+/// Analyzes a single statement on it's throwing behaviour. This is in principle
 /// possible except some 'Unknown' functions are called.
 ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::throwsException(
     const Stmt *St, const ExceptionInfo::Throwables &Caught,
     llvm::SmallSet<const FunctionDecl *, 32> &CallStack) {
   auto Results = ExceptionInfo::createNonThrowing();
   if (!St)
     return Results;
 

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

 /// Checks whether spelling location of \p Loc is in header file.
 bool isSpellingLocInHeaderFile(SourceLocation Loc, SourceManager &SM,
                                const FileExtensionsSet &HeaderFileExtensions);
 
 /// Returns recommended default value for the list of header file
 /// extensions.
 inline StringRef defaultHeaderFileExtensions() { return ";h;hh;hpp;hxx"; }
 
-/// Returns recommended default value for the list of implementaiton file
+/// Returns recommended default value for the list of implementation file
 /// extensions.
 inline StringRef defaultImplementationFileExtensions() {
   return "c;cc;cpp;cxx";
 }
 
 /// Returns recommended default value for the list of file extension
 /// delimiters.
 inline StringRef defaultFileExtensionDelimiters() { return ",;"; }

clang-tools-extra/clangd/AST.cpp

for (const auto *D : DC->decls()) {
       if (auto *UDD = llvm::dyn_cast<UsingDirectiveDecl>(D))
         VisibleNamespaceDecls.insert(
             UDD->getNominatedNamespace()->getCanonicalDecl());
     }
   }
   return VisibleNamespaceDecls;
 }
 
-// Goes over all parents of SourceContext until we find a comman ancestor for
+// Goes over all parents of SourceContext until we find a common ancestor for
 // DestContext and SourceContext. Any qualifier including and above common
 // ancestor is redundant, therefore we stop at lowest common ancestor.
 // In addition to that stops early whenever IsVisible returns true. This can be
 // used to implement support for "using namespace" decls.
 std::string
 getQualification(ASTContext &Context, const DeclContext *DestContext,
                  const DeclContext *SourceContext,
                  llvm::function_ref<bool(NestedNameSpecifier *)> IsVisible) {

clang-tools-extra/clangd/ClangdLSPServer.h

auto HandleReply =
             llvm::Expected<llvm::json::Value> RawResponse) mutable {
           Response Rsp;
           if (!RawResponse) {
             CB(RawResponse.takeError());
           } else if (fromJSON(*RawResponse, Rsp)) {
             CB(std::move(Rsp));
           } else {
             elog("Failed to decode {0} response", *RawResponse);
-            CB(llvm::make_error<LSPError>("failed to decode reponse",
+            CB(llvm::make_error<LSPError>("failed to decode response",
                                           ErrorCode::InvalidParams));
           }
         };
     callRaw(Method, std::move(Params), std::move(HandleReply));
   }
   void callRaw(StringRef Method, llvm::json::Value Params,
                Callback<llvm::json::Value> CB);
   void notify(StringRef Method, llvm::json::Value Params);

clang-tools-extra/clangd/Diagnostics.cpp

if (SyntheticMessage && Info.getNumFixItHints() == 1) {
           M << "insert '";
           writeCodeToFixMessage(M, Insert);
           M << "'";
         }
         // Don't allow source code to inject newlines into diagnostics.
         std::replace(Message.begin(), Message.end(), '\n', ' ');
       }
     }
-    if (Message.empty()) // either !SytheticMessage, or we failed to make one.
+    if (Message.empty()) // either !SyntheticMessage, or we failed to make one.
       Info.FormatDiagnostic(Message);
     LastDiag->Fixes.push_back(
         Fix{std::string(Message.str()), std::move(Edits)});
     return true;
   };
 
   if (!isNote(DiagLevel)) {
     // Handle the new main diagnostic.

clang-tools-extra/clangd/FindSymbols.h

 
 /// Helper function for deriving an LSP Location for a Symbol.
 llvm::Expected<Location> symbolToLocation(const Symbol &Sym,
                                           llvm::StringRef TUPath);
 
 /// Searches for the symbols matching \p Query. The syntax of \p Query can be
 /// the non-qualified name or fully qualified of a symbol. For example,
 /// "vector" will match the symbol std::vector and "std::vector" would also
-/// match it. Direct children of scopes (namepaces, etc) can be listed with a
+/// match it. Direct children of scopes (namespaces, etc) can be listed with a
 /// trailing
 /// "::". For example, "std::" will list all children of the std namespace and
 /// "::" alone will list all children of the global namespace.
 /// \p Limit limits the number of results returned (0 means no limit).
 /// \p HintPath This is used when resolving URIs. If empty, URI resolution can
 /// fail if a hint path is required for the scheme of a specific URI.
 llvm::Expected<std::vector<SymbolInformation>>
 getWorkspaceSymbols(llvm::StringRef Query, int Limit,

clang-tools-extra/clangd/FindTarget.h

void findExplicitReferences(const Decl *D,
                             llvm::function_ref<void(ReferenceLoc)> Out);
 void findExplicitReferences(const ASTContext &AST,
                             llvm::function_ref<void(ReferenceLoc)> Out);
 
 /// Find declarations explicitly referenced in the source code defined by \p N.
 /// For templates, will prefer to return a template instantiation whenever
 /// possible. However, can also return a template pattern if the specialization
 /// cannot be picked, e.g. in dependent code or when there is no corresponding
-/// Decl for a template instantitation, e.g. for templated using decls:
+/// Decl for a template instantiation, e.g. for templated using decls:
 ///    template <class T> using Ptr = T*;
 ///    Ptr<int> x;
 ///    ^~~ there is no Decl for 'Ptr<int>', so we return the template pattern.
 /// \p Mask should not contain TemplatePattern or TemplateInstantiation.
 llvm::SmallVector<const NamedDecl *, 1>
 explicitReferenceTargets(ast_type_traits::DynTypedNode N,
                          DeclRelationSet Mask);
 

clang-tools-extra/clangd/FindTarget.cpp

targetDecl(const ast_type_traits::DynTypedNode &N, DeclRelationSet Mask) {
   }
   return Result;
 }
 
 llvm::SmallVector<const NamedDecl *, 1>
 explicitReferenceTargets(DynTypedNode N, DeclRelationSet Mask) {
   assert(!(Mask & (DeclRelation::TemplatePattern |
                    DeclRelation::TemplateInstantiation)) &&
-         "explicitRefenceTargets handles templates on its own");
+         "explicitReferenceTargets handles templates on its own");
   auto Decls = allTargetDecls(N);
 
   // We prefer to return template instantiation, but fallback to template
   // pattern if instantiation is not available.
   Mask |= DeclRelation::TemplatePattern | DeclRelation::TemplateInstantiation;
 
   llvm::SmallVector<const NamedDecl *, 1> TemplatePatterns;
   llvm::SmallVector<const NamedDecl *, 1> Targets;

clang-tools-extra/clangd/FormattedString.cpp

llvm::copy_if(TrimmedText, std::back_inserter(AdjustedResult),
                                           &C - TrimmedText.data() + 1)
                               // We allow at most two newlines.
                               .endswith("\n\n\n");
                 });
 
   return AdjustedResult;
 }
 
-// Seperates two blocks with extra spacing. Note that it might render strangely
+// Separates two blocks with extra spacing. Note that it might render strangely
 // in vscode if the trailing block is a codeblock, see
 // https://github.com/microsoft/vscode/issues/88416 for details.
 class Ruler : public Block {
 public:
   void renderMarkdown(llvm::raw_ostream &OS) const override {
     // Note that we need an extra new line before the ruler, otherwise we might
     // make previous block a title instead of introducing a ruler.
     OS << "\n---\n";

clang-tools-extra/clangd/Hover.h

struct HoverInfo {
   index::SymbolKind Kind = index::SymbolKind::Unknown;
   std::string Documentation;
   /// Source code containing the definition of the symbol.
   std::string Definition;
 
   /// Pretty-printed variable type.
   /// Set only for variables.
   llvm::Optional<std::string> Type;
-  /// Set for functions and lambadas.
+  /// Set for functions and lambdas.
   llvm::Optional<std::string> ReturnType;
   /// Set for functions, lambdas and macros with parameters.
   llvm::Optional<std::vector<Param>> Parameters;
   /// Set for all templates(function, class, variable).
   llvm::Optional<std::vector<Param>> TemplateParameters;
   /// Contains the evaluated value of the symbol if available.
   llvm::Optional<std::string> Value;
 

clang-tools-extra/clangd/Hover.cpp

Index->lookup(Req, [&](const Symbol &S) {
     Hover.Documentation = std::string(S.Documentation);
   });
 }
 
 // Default argument might exist but be unavailable, in the case of unparsed
 // arguments for example. This function returns the default argument if it is
 // available.
 const Expr *getDefaultArg(const ParmVarDecl *PVD) {
-  // Default argument can be unparsed or uninstatiated. For the former we
+  // Default argument can be unparsed or uninstantiated. For the former we
   // can't do much, as token information is only stored in Sema and not
   // attached to the AST node. For the latter though, it is safe to proceed as
   // the expression is still valid.
   if (!PVD->hasDefaultArg() || PVD->hasUnparsedDefaultArg())
     return nullptr;
   return PVD->hasUninstantiatedDefaultArg() ? PVD->getUninstantiatedDefaultArg()
                                             : PVD->getDefaultArg();
 }

 
 /// Generate a \p Hover object given the macro \p MacroDecl.
 HoverInfo getHoverContents(const DefinedMacro &Macro, ParsedAST &AST) {
   HoverInfo HI;
   SourceManager &SM = AST.getSourceManager();
   HI.Name = std::string(Macro.Name);
   HI.Kind = index::SymbolKind::Macro;
   // FIXME: Populate documentation
-  // FIXME: Pupulate parameters
+  // FIXME: Populate parameters
 
   // Try to get the full definition, not just the name
   SourceLocation StartLoc = Macro.Info->getDefinitionLoc();
   SourceLocation EndLoc = Macro.Info->getDefinitionEndLoc();
   if (EndLoc.isValid()) {
     EndLoc = Lexer::getLocForEndOfToken(EndLoc, 0, SM, AST.getLangOpts());
     bool Invalid;
     StringRef Buffer = SM.getBufferData(SM.getFileID(StartLoc), &Invalid);
if (!Documentation.empty())
     parseDocumentation(Documentation, Output);
 
   if (!Definition.empty()) {
     Output.addRuler();
     std::string ScopeComment;
     // Drop trailing "::".
     if (!LocalScope.empty()) {
       // Container name, e.g. class, method, function.
-      // We might want to propogate some info about container type to print
+      // We might want to propagate some info about container type to print
       // function foo, class X, method X::bar, etc.
       ScopeComment =
           "// In " + llvm::StringRef(LocalScope).rtrim(':').str() + '\n';
     } else if (NamespaceScope && !NamespaceScope->empty()) {
       ScopeComment = "// In namespace " +
                      llvm::StringRef(*NamespaceScope).rtrim(':').str() + '\n';
     }
     // Note that we don't print anything for global namespace, to not annoy

clang-tools-extra/clangd/ParsedAST.cpp

ParsedAST::build(llvm::StringRef Version,
   const FrontendInputFile &MainInput = Clang->getFrontendOpts().Inputs[0];
   if (!Action->BeginSourceFile(*Clang, MainInput)) {
     log("BeginSourceFile() failed when building AST for {0}",
         MainInput.getFile());
     return None;
   }
 
   // Set up ClangTidy. Must happen after BeginSourceFile() so ASTContext exists.
-  // Clang-tidy has some limitiations to ensure reasonable performance:
+  // Clang-tidy has some limitations to ensure reasonable performance:
   //  - checks don't see all preprocessor events in the preamble
   //  - matchers run only over the main-file top-level decls (and can't see
   //    ancestors outside this scope).
   // In practice almost all checks work well without modifications.
   std::vector<std::unique_ptr<tidy::ClangTidyCheck>> CTChecks;
   ast_matchers::MatchFinder CTFinder;
   llvm::Optional<tidy::ClangTidyContext> CTContext;
   {
std::size_t ParsedAST::getUsedBytes() const {
   // FIXME(ibiryukov): we do not account for the dynamically allocated part of
   // Message and Fixes inside each diagnostic.
   std::size_t Total =
       clangd::getUsedBytes(LocalTopLevelDecls) + clangd::getUsedBytes(Diags);
 
   // FIXME: the rest of the function is almost a direct copy-paste from
   // libclang's clang_getCXTUResourceUsage. We could share the implementation.
 
-  // Sum up variaous allocators inside the ast context and the preprocessor.
+  // Sum up various allocators inside the ast context and the preprocessor.
   Total += AST.getASTAllocatedMemory();
   Total += AST.getSideTableAllocatedMemory();
   Total += AST.Idents.getAllocator().getTotalMemory();
   Total += AST.Selectors.getTotalMemory();
 
   Total += AST.getSourceManager().getContentCacheSize();
   Total += AST.getSourceManager().getDataStructureSizes();
   Total += AST.getSourceManager().getMemoryBufferSizes().malloc_bytes;

clang-tools-extra/clangd/PathMapping.cpp

 #include <algorithm>
 #include <tuple>
 
 namespace clang {
 namespace clangd {
 llvm::Optional<std::string> doPathMapping(llvm::StringRef S,
                                           PathMapping::Direction Dir,
                                           const PathMappings &Mappings) {
-  // Retrun early to optimize for the common case, wherein S is not a file URI
+  // Return early to optimize for the common case, wherein S is not a file URI
   if (!S.startswith("file://"))
     return llvm::None;
   auto Uri = URI::parse(S);
   if (!Uri) {
     llvm::consumeError(Uri.takeError());
     return llvm::None;
   }
   for (const auto &Mapping : Mappings) {

clang-tools-extra/clangd/Preamble.cpp

vlog("Reusing preamble version {0} for version {1} of {2}",
          OldPreamble->Version, Inputs.Version, FileName);
     return OldPreamble;
   }
   if (OldPreamble)
     vlog("Rebuilding invalidated preamble for {0} version {1} "
          "(previous was version {2})",
          FileName, Inputs.Version, OldPreamble->Version);
   else
-    vlog("Building first preamble for {0} verson {1}", FileName,
+    vlog("Building first preamble for {0} version {1}", FileName,
          Inputs.Version);
 
   trace::Span Tracer("BuildPreamble");
   SPAN_ATTACH(Tracer, "File", FileName);
   StoreDiags PreambleDiagnostics;
   llvm::IntrusiveRefCntPtr<DiagnosticsEngine> PreambleDiagsEngine =
       CompilerInstance::createDiagnostics(&CI.getDiagnosticOpts(),
                                           &PreambleDiagnostics, false);

clang-tools-extra/clangd/Quality.cpp

 
 float SymbolQualitySignals::evaluate() const {
   float Score = 1;
 
   // This avoids a sharp gradient for tail symbols, and also neatly avoids the
   // question of whether 0 references means a bad symbol or missing data.
   if (References >= 10) {
     // Use a sigmoid style boosting function, which flats out nicely for large
-    // numbers (e.g. 2.58 for 1M refererences).
+    // numbers (e.g. 2.58 for 1M references).
     // The following boosting function is equivalent to:
     //   m = 0.06
     //   f = 12.0
     //   boost = f * sigmoid(m * std::log(References)) - 0.5 * f + 0.59
     // Sample data points: (10, 1.00), (100, 1.41), (1000, 1.82),
     //                     (10K, 2.21), (100K, 2.58), (1M, 2.94)
     float S = std::pow(References, -0.06);
     Score *= 6.0 * (1 - S) / (1 + S) + 0.59;

clang-tools-extra/clangd/QueryDriverDatabase.cpp

extractSystemIncludes(PathRef Driver, llvm::StringRef Lang,
   auto BufOrError = llvm::MemoryBuffer::getFile(StdErrPath);
   if (!BufOrError) {
     elog("System include extraction: failed to read {0} with error {1}",
          StdErrPath, BufOrError.getError().message());
     return {};
   }
 
   auto Includes = parseDriverOutput(BufOrError->get()->getBuffer());
-  log("System include extractor: succesfully executed {0}, got includes: "
+  log("System include extractor: successfully executed {0}, got includes: "
       "\"{1}\"",
       Driver, llvm::join(Includes, ", "));
   return Includes;
 }
 
 tooling::CompileCommand &
 addSystemIncludes(tooling::CompileCommand &Cmd,
                   llvm::ArrayRef<std::string> SystemIncludes) {

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

void BackgroundIndex::update(
   llvm::StringMap<File> Files;
   URIToFileCache URICache(MainFile);
   for (const auto &IndexIt : *Index.Sources) {
     const auto &IGN = IndexIt.getValue();
     // Note that sources do not contain any information regarding missing
     // headers, since we don't even know what absolute path they should fall in.
     const auto AbsPath = URICache.resolve(IGN.URI);
     const auto DigestIt = ShardVersionsSnapshot.find(AbsPath);
-    // File has different contents, or indexing was successfull this time.
+    // File has different contents, or indexing was successful this time.
     if (DigestIt == ShardVersionsSnapshot.end() ||
         DigestIt->getValue().Digest != IGN.Digest ||
         (DigestIt->getValue().HadErrors && !HadErrors))
       Files.try_emplace(AbsPath).first->getValue().Digest = IGN.Digest;
   }
   // This map is used to figure out where to store relations.
   llvm::DenseMap<SymbolID, File *> SymbolIDToFile;
   for (const auto &Sym : *Index.Symbols) {

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

std::unique_ptr<SymbolIndex> loadIndex(llvm::StringRef SymbolFilename,
   trace::Span Tracer("BuildIndex");
   auto Index = UseDex ? dex::Dex::build(std::move(Symbols), std::move(Refs),
                                         std::move(Relations))
                       : MemIndex::build(std::move(Symbols), std::move(Refs),
                                         std::move(Relations));
   vlog("Loaded {0} from {1} with estimated memory usage {2} bytes\n"
        "  - number of symbols: {3}\n"
        "  - number of refs: {4}\n"
-       "  - numnber of relations: {5}",
+       "  - number of relations: {5}",
        UseDex ? "Dex" : "MemIndex", SymbolFilename,
        Index->estimateMemoryUsage(), NumSym, NumRefs, NumRelations);
   return Index;
 }
 
 } // namespace clangd
 } // namespace clang

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

 
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 
 namespace clang {
 namespace clangd {
 
 // Describes the source of information about a symbol.
-// Mainly useful for debugging, e.g. understanding code completion reuslts.
+// Mainly useful for debugging, e.g. understanding code completion results.
 // This is a bitfield as information can be combined from several sources.
 enum class SymbolOrigin : uint8_t {
   Unknown = 0,
   AST = 1 << 0,        // Directly from the AST (indexes should not set this).
   Dynamic = 1 << 1,    // From the dynamic index of opened files.
   Static = 1 << 2,     // From the static, externally-built index.
   Merge = 1 << 3,      // A non-trivial index merge was performed.
   Identifier = 1 << 4, // Raw identifiers in file.

clang-tools-extra/clangd/index/dex/Trigram.cpp

std::vector<Token> generateIdentifierTrigrams(llvm::StringRef Identifier) {
   }
 
   llvm::DenseSet<Token> UniqueTrigrams;
 
   auto Add = [&](std::string Chars) {
     UniqueTrigrams.insert(Token(Token::Kind::Trigram, Chars));
   };
 
-  // Iterate through valid sequneces of three characters Fuzzy Matcher can
+  // Iterate through valid sequences of three characters Fuzzy Matcher can
   // process.
   for (size_t I = 0; I < LowercaseIdentifier.size(); ++I) {
     // Skip delimiters.
     if (Roles[I] != Head && Roles[I] != Tail)
       continue;
     for (const unsigned J : Next[I]) {
       if (J == 0)
         continue;

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

 /// Returns None if there is no dirty buffer for the given file.
 using DirtyBufferGetter =
     llvm::function_ref<llvm::Optional<std::string>(PathRef AbsPath)>;
 
 struct RenameOptions {
   /// If true, enable cross-file rename; otherwise, only allows to rename a
   /// symbol that's only used in the current file.
   bool AllowCrossFile = false;
-  /// The mamimum number of affected files (0 means no limit), only meaningful
+  /// The maximum number of affected files (0 means no limit), only meaningful
   /// when AllowCrossFile = true.
   /// If the actual number exceeds the limit, rename is forbidden.
   size_t LimitFiles = 50;
   /// If true, format the rename edits, only meaningful in ClangdServer layer.
   bool WantFormat = false;
 };
 
 struct RenameInputs {

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

 }
 
 // Return all rename occurrences in the main file.
 std::vector<SourceLocation> findOccurrencesWithinFile(ParsedAST &AST,
                                                       const NamedDecl &ND) {
   trace::Span Tracer("FindOccurrenceeWithinFile");
   // If the cursor is at the underlying CXXRecordDecl of the
   // ClassTemplateDecl, ND will be the CXXRecordDecl. In this case, we need to
-  // get the primary template maunally.
+  // get the primary template manually.
   // getUSRsForDeclaration will find other related symbols, e.g. virtual and its
   // overriddens, primary template and all explicit specializations.
   // FIXME: Get rid of the remaining tooling APIs.
   const auto *RenameDecl =
       ND.getDescribedTemplate() ? ND.getDescribedTemplate() : &ND;
   std::vector<std::string> RenameUSRs =
       tooling::getUSRsForDeclaration(RenameDecl, AST.getASTContext());
   llvm::DenseSet<SymbolID> TargetIDs;

 
 // Performs a DFS to enumerate all possible near-miss matches.
 // It finds the locations where the indexed occurrences are now spelled in
 // Lexed occurrences, a near miss is defined as:
 //   - a near miss maps all of the **name** occurrences from the index onto a
 //     *subset* of lexed occurrences (we allow a single name refers to more
 //     than one symbol)
 //   - all indexed occurrences must be mapped, and Result must be distinct and
-//     preseve order (only support detecting simple edits to ensure a
+//     preserve order (only support detecting simple edits to ensure a
 //     robust mapping)
 //   - each indexed -> lexed occurrences mapping correspondence may change the
 //     *line* or *column*, but not both (increases chance of a robust mapping)
 void findNearMiss(
     std::vector<size_t> &PartialMatch, ArrayRef<Range> IndexedRest,
     ArrayRef<Range> LexedRest, int LexedIndex, int &Fuel,
     llvm::function_ref<void(const std::vector<size_t> &)> MatchedCB) {
   if (--Fuel < 0)

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

 // Only qualifiers that refer exclusively to namespaces (no record types) are
 // supported. There is some guessing of appropriate place to insert the using
 // declaration. If we find any existing usings, we insert it there. If not, we
 // insert right after the inner-most relevant namespace declaration. If there is
 // none, or there is, but it was declared via macro, we insert above the first
 // top level decl.
 //
 // Currently this only removes qualifier from under the cursor. In the future,
-// we should improve this to remove qualifier from all occurences of this
+// we should improve this to remove qualifier from all occurrences of this
 // symbol.
 class AddUsing : public Tweak {
 public:
   const char *id() const override;
 
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override;

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

llvm::Expected<std::string> qualifyAllDecls(const FunctionDecl *FD,
   // - DeclRefExpr: ns2::foo()          -> ns1::ns2::foo();
   // - UsingDecls:
   //    using ns2::foo      -> using ns1::ns2::foo
   //    using namespace ns2 -> using namespace ns1::ns2
   //    using ns3 = ns2     -> using ns3 = ns1::ns2
   //
   // Go over all references inside a function body to generate replacements that
   // will qualify those. So that body can be moved into an arbitrary file.
-  // We perform the qualification by qualyfying the first type/decl in a
+  // We perform the qualification by qualifying the first type/decl in a
   // (un)qualified name. e.g:
   //    namespace a { namespace b { class Bar{}; void foo(); } }
   //    b::Bar x; -> a::b::Bar x;
   //    foo(); -> a::b::foo();
 
   auto *TargetContext = Target->getLexicalDeclContext();
   const SourceManager &SM = FD->getASTContext().getSourceManager();
 
for (auto &Entry : RefLocs) {
     for (SourceLocation RefLoc : Entry.second) {
       CharSourceRange ReplaceRange;
       // In case of unnamed parameters, we have an empty char range, whereas we
       // have a tokenrange at RefLoc with named parameters.
       if (OldName.empty())
         ReplaceRange = CharSourceRange::getCharRange(RefLoc, RefLoc);
       else
         ReplaceRange = CharSourceRange::getTokenRange(RefLoc, RefLoc);
-      // If occurence is coming from a macro expansion, try to get back to the
+      // If occurrence is coming from a macro expansion, try to get back to the
       // file range.
       if (RefLoc.isMacroID()) {
         ReplaceRange = Lexer::makeFileCharRange(ReplaceRange, SM, LangOpts);
         // Bail out if we need to replace macro bodies.
         if (ReplaceRange.isInvalid()) {
           auto Err = llvm::createStringError(
               llvm::inconvertibleErrorCode(),
               "Cant rename parameter inside macro body.");
const FunctionDecl *findTarget(const FunctionDecl *FD) {
   auto PrevDecl = FD;
   while (PrevDecl->getPreviousDecl() != CanonDecl) {
     PrevDecl = PrevDecl->getPreviousDecl();
     assert(PrevDecl && "Found specialization without template decl");
   }
   return PrevDecl;
 }
 
-// Returns the begining location for a FunctionDecl. Returns location of
+// Returns the beginning location for a FunctionDecl. Returns location of
 // template keyword for templated functions.
 const SourceLocation getBeginLoc(const FunctionDecl *FD) {
   // Include template parameter list.
   if (auto *FTD = FD->getDescribedFunctionTemplate())
     return FTD->getBeginLoc();
   return FD->getBeginLoc();
 }
 

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

getFunctionSourceCode(const FunctionDecl *FD, llvm::StringRef TargetNamespace,
   DelAttr(FD->getAttr<OverrideAttr>());
   DelAttr(FD->getAttr<FinalAttr>());
 
   if (FD->isVirtualAsWritten()) {
     SourceRange SpecRange{FD->getBeginLoc(), FD->getLocation()};
     bool HasErrors = true;
 
     // Clang allows duplicating virtual specifiers so check for multiple
-    // occurances.
+    // occurrences.
     for (const auto &Tok : TokBuf.expandedTokens(SpecRange)) {
       if (Tok.kind() != tok::kw_virtual)
         continue;
       auto Spelling = TokBuf.spelledForExpanded(llvm::makeArrayRef(Tok));
       if (!Spelling) {
         HasErrors = true;
         break;
       }

 // between foo and baz for inserting bar.
 llvm::Expected<InsertionPoint> getInsertionPoint(llvm::StringRef Contents,
                                                  llvm::StringRef QualifiedName,
                                                  const LangOptions &LangOpts) {
   auto Region = getEligiblePoints(Contents, QualifiedName, LangOpts);
 
   assert(!Region.EligiblePoints.empty());
   // FIXME: This selection can be made smarter by looking at the definition
-  // locations for adjacent decls to Source. Unfortunately psudeo parsing in
+  // locations for adjacent decls to Source. Unfortunately pseudo parsing in
   // getEligibleRegions only knows about namespace begin/end events so we
   // can't match function start/end positions yet.
   auto Offset = positionToOffset(Contents, Region.EligiblePoints.back());
   if (!Offset)
     return Offset.takeError();
   return InsertionPoint{Region.EnclosingNamespace, *Offset};
 }
 

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

 // begins in selection range, ends in selection range and any scope that begins
 // outside the selection range, ends outside as well.
 const Node *getParentOfRootStmts(const Node *CommonAnc) {
   if (!CommonAnc)
     return nullptr;
   const Node *Parent = nullptr;
   switch (CommonAnc->Selected) {
   case SelectionTree::Selection::Unselected:
-    // Typicaly a block, with the { and } unselected, could also be ForStmt etc
+    // Typically a block, with the { and } unselected, could also be ForStmt etc
     // Ensure all Children are RootStmts.
     Parent = CommonAnc;
     break;
   case SelectionTree::Selection::Partial:
     // Only a fully-selected single statement can be selected.
     return nullptr;
   case SelectionTree::Selection::Complete:
     // If the Common Ancestor is completely selected, then it's a root statement
public:
     }
 
     bool VisitDecl(Decl *D) {
       Info.createDeclInfo(D, CurrentLocation);
       return true;
     }
 
     bool VisitDeclRefExpr(DeclRefExpr *DRE) {
-      // Find the corresponding Decl and mark it's occurence.
+      // Find the corresponding Decl and mark it's occurrence.
       const Decl *D = DRE->getDecl();
       auto *DeclInfo = Info.getDeclInfoFor(D);
       // If no Decl was found, the Decl must be outside the enclosingFunc.
       if (!DeclInfo)
         DeclInfo = Info.createDeclInfo(D, ZoneRelative::OutsideFunc);
       DeclInfo->markOccurence(CurrentLocation);
       // FIXME: check if reference mutates the Decl being referred.
       return true;

clang-tools-extra/clangd/tool/ClangdMain.cpp

if (TweakList.getNumOccurrences())
       return llvm::is_contained(TweakList, T.id());
     return true;
   };
   llvm::Optional<OffsetEncoding> OffsetEncodingFromFlag;
   if (ForceOffsetEncoding != OffsetEncoding::UnsupportedEncoding)
     OffsetEncodingFromFlag = ForceOffsetEncoding;
 
   clangd::RenameOptions RenameOpts;
-  // Shall we allow to custimize the file limit?
+  // Shall we allow to customize the file limit?
   RenameOpts.AllowCrossFile = CrossFileRename;
 
   ClangdLSPServer LSPServer(
       *TransportLayer, FSProvider, CCOpts, RenameOpts, CompileCommandsDirPath,
       /*UseDirBasedCDB=*/CompileArgsFrom == FilesystemCompileArgs,
       OffsetEncodingFromFlag, Opts);
   llvm::set_thread_name("clangd.main");
   int ExitCode = LSPServer.run()

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

TEST(CompletionTest, ContextWords) {
   enum class Color { RED, YELLOW, BLUE };
 
   // (blank lines so the definition above isn't "context")
 
   // "It was a yellow car," he said. "Big yellow car, new."
   auto Finish = Color::^
   )cpp");
   // Yellow would normally sort last (alphabetic).
-  // But the recent mention shuold bump it up.
+  // But the recent mention should bump it up.
   ASSERT_THAT(Results.Completions,
               HasSubsequence(Named("YELLOW"), Named("BLUE")));
 }
 
 TEST(CompletionTest, GlobalQualified) {
   auto Results = completions(
       R"cpp(
           void f() { ::^ }
TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) {
   TestTU TU;
   TU.ExtraArgs.push_back("-I" + testPath("sub"));
   TU.AdditionalFiles["sub/bar.h"] = "";
   auto BarURI = URI::create(testPath("sub/bar.h")).toString();
 
   Symbol Sym = cls("ns::X");
   Sym.CanonicalDeclaration.FileURI = BarURI.c_str();
   Sym.IncludeHeaders.emplace_back(BarURI, 1);
-  // Shoten include path based on search directory and insert.
+  // Shorten include path based on search directory and insert.
   Annotations Test("int main() { ns::^ }");
   TU.Code = Test.code().str();
   auto Results = completions(TU, Test.point(), {Sym});
   EXPECT_THAT(Results.Completions,
               ElementsAre(AllOf(Named("X"), InsertInclude("\"bar.h\""))));
   // Can be disabled via option.
   CodeCompleteOptions NoInsertion;
   NoInsertion.InsertIncludes = CodeCompleteOptions::NeverInsert;
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 directory and insert.
+  // Shorten include path based on search directory and insert.
   auto Results = completions(R"cpp(
           namespace ns {
             class X;
             class Y {};
           }
           int main() { ns::^ }
       )cpp",
                              {SymX, SymY});

 
 TEST(CompletionTest, IgnoreCompleteInExcludedPPBranchWithRecoveryContext) {
   auto Results = completions(R"cpp(
     int bar(int param_in_bar) {
     }
 
     int foo(int param_in_foo) {
 #if 0
-  // In recorvery mode, "param_in_foo" will also be suggested among many other
+  // In recovery mode, "param_in_foo" will also be suggested among many other
   // unrelated symbols; however, this is really a special case where this works.
   // If the #if block is outside of the function, "param_in_foo" is still
   // suggested, but "bar" and "foo" are missing. So the recovery mode doesn't
   // really provide useful results in excluded branches.
   par^
 #endif
     }
 )cpp");

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

for (int I = 1;; I++) {
       assert(Macro);
       auto SID = getSymbolID(Macro->Name, Macro->Info, SM);
 
       EXPECT_THAT(ExpectedRefs,
                   UnorderedElementsAreArray(ActualMacroRefs.MacroRefs[*SID]))
           << "Annotation=" << I << ", MacroName=" << Macro->Name
           << ", Test = " << Test;
     }
-    // Unkown macros.
+    // Unknown macros.
     EXPECT_THAT(AST.getMacros().UnknownMacros,
                 UnorderedElementsAreArray(T.ranges("Unknown")))
         << "Unknown macros doesn't match in " << Test;
   }
 }
 } // namespace
 } // namespace clangd
 } // namespace clang

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

 class FindExplicitReferencesTest : public ::testing::Test {
 protected:
   struct AllRefs {
     std::string AnnotatedCode;
     std::string DumpedReferences;
   };
 
   /// Parses \p Code, finds function or namespace '::foo' and annotates its body
-  /// with results of findExplicitReferecnces.
+  /// with results of findExplicitReferences.
   /// See actual tests for examples of annotation format.
   AllRefs annotateReferencesInFoo(llvm::StringRef Code) {
     TestTU TU;
     TU.Code = std::string(Code);
 
     // FIXME: Auto-completion in a template requires disabling delayed template
     // parsing.
     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");

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

TEST(HeaderSourceSwitchTest, FromHeaderToSource) {
   Testing.Code = R"cpp(
   void B_Sym1() {}
   void B_Sym2() {}
   )cpp";
   for (auto &Sym : Testing.headerSymbols())
     AllSymbols.insert(Sym);
   auto Index = MemIndex::build(std::move(AllSymbols).build(), {}, {});
 
-  // Test for swtich from .h header to .cc source
+  // Test for switch from .h header to .cc source
   struct {
     llvm::StringRef HeaderCode;
     llvm::Optional<std::string> ExpectedSource;
   } TestCases[] = {
       {"// empty, no header found", llvm::None},
       {R"cpp(
          // no definition found in the index.
          void NonDefinition();

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

 
 TEST(ParsePathMappingTests, UnixPath) {
   // Relative unix path
   EXPECT_TRUE(failedParse("a/b=/root"));
   // Absolute unix path
   llvm::Expected<PathMappings> ParsedMappings = parsePathMappings("/A/b=/root");
   ASSERT_TRUE(bool(ParsedMappings));
   EXPECT_THAT(*ParsedMappings, ElementsAre(Mapping("/A/b", "/root")));
-  // Aboslute unix path w/ backslash
+  // Absolute unix path w/ backslash
   ParsedMappings = parsePathMappings(R"(/a/b\\ar=/root)");
   ASSERT_TRUE(bool(ParsedMappings));
   EXPECT_THAT(*ParsedMappings, ElementsAre(Mapping(R"(/a/b\\ar)", "/root")));
 }
 
 TEST(ParsePathMappingTests, ImproperFormat) {
   // uneven mappings
   EXPECT_TRUE(failedParse("/home/myuser1="));

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

llvm::StringRef FooCC;
         }
       )cpp",
       },
       {
           // class templates.
           R"cpp(
         template <typename T>
         class [[Foo]] {};
-        // FIXME: explicit template specilizations are not supported due the
+        // FIXME: explicit template specializations are not supported due the
         // clangd index limitations.
         template <>
         class Foo<double> {};
       )cpp",
           R"cpp(
         #include "foo.h"
         void func() {
           [[F^oo]]<int> foo;

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

std::pair<const char *, std::vector<SymbolDetails>>
               {CreateExpectedSymbolDetails("foo", "", "c:@S@foo")}},
           {
               R"cpp( // Type reference - definition
           struct foo {};
           void bar(fo^o*);
         )cpp",
               {CreateExpectedSymbolDetails("foo", "", "c:@S@foo")}},
           {
-              R"cpp( // Type Reference - template argumen
+              R"cpp( // Type Reference - template argument
           struct foo {};
           template<class T> struct bar {};
           void baz() {
             bar<fo^o> b;
           }
         )cpp",
               {CreateExpectedSymbolDetails("foo", "", "c:@S@foo")}},
           {

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

TEST_F(ExtractFunctionTest, FunctionTest) {
   EXPECT_EQ(apply("auto lam = [](){ [[int x;]] }; "), "unavailable");
   // Partial statements aren't extracted.
   EXPECT_THAT(apply("int [[x = 0]];"), "unavailable");
 
   // Ensure that end of Zone and Beginning of PostZone being adjacent doesn't
   // lead to break being included in the extraction zone.
   EXPECT_THAT(apply("for(;;) { [[int x;]]break; }"), HasSubstr("extracted"));
   // FIXME: ExtractFunction should be unavailable inside loop construct
-  // initalizer/condition.
+  // initializer/condition.
   EXPECT_THAT(apply(" for([[int i = 0;]];);"), HasSubstr("extracted"));
   // Don't extract because needs hoisting.
   EXPECT_THAT(apply(" [[int a = 5;]] a++; "), StartsWith("fail"));
   // Extract certain return
   EXPECT_THAT(apply(" if(true) [[{ return; }]] "), HasSubstr("extracted"));
   // Don't extract uncertain return
   EXPECT_THAT(apply(" if(true) [[if (false) return;]] "), StartsWith("fail"));
 }

clang-tools-extra/docs/clang-tidy/checks/abseil-no-internal-dependencies.rst

 subl.. title:: clang-tidy - abseil-no-internal-dependencies
 
 abseil-no-internal-dependencies
 ===============================
 
 Warns if code using Abseil depends on internal details. If something is in a
 namespace that includes the word “internal”, code is not allowed to depend upon
-it beaucse it’s an implementation detail. They cannot friend it, include it,
+it because it’s an implementation detail. They cannot friend it, include it,
 you mention it or refer to it in any way. Doing so violates Abseil's
 compatibility guidelines and may result in breakage. See
 https://abseil.io/about/compatibility for more information.
 
 The following cases will result in warnings:
 
 .. code-block:: c++
 
   absl::strings_internal::foo();
   // warning triggered on this line
   class foo {
     friend struct absl::container_internal::faa;
     // warning triggered on this line
   };
   absl::memory_internal::MakeUniqueResult();
   // warning triggered on this line

clang-tools-extra/docs/clang-tidy/checks/bugprone-misplaced-pointer-arithmetic-in-alloc.rst

 .. title:: clang-tidy - bugprone-misplaced-pointer-arithmetic-in-alloc
 
-bugprone-misplaced-pointer-artithmetic-in-alloc
+bugprone-misplaced-pointer-arithmetic-in-alloc
 ===============================================
 
 Finds cases where an integer expression is added to or subtracted from the
 result of a memory allocation function (``malloc()``, ``calloc()``,
 ``realloc()``, ``alloca()``) instead of its argument. The check detects error
 cases even if one of these functions is called by a constant function pointer.
 
 Example code:

clang-tools-extra/docs/clang-tidy/checks/bugprone-virtual-near-miss.rst

 .. title:: clang-tidy - bugprone-virtual-near-miss
 
 bugprone-virtual-near-miss
 ==========================
 
 Warn if a function is a near miss (ie. the name is very similar and the function
-signiture is the same) to a virtual function from a base class.
+signature is the same) to a virtual function from a base class.
 
 Example:
 
 .. code-block:: c++
 
   struct Base {
     virtual void func();
   };
 
   struct Derived : Base {
     virtual funk();
     // warning: 'Derived::funk' has a similar name and the same signature as virtual method 'Base::func'; did you mean to override it?
   };

clang-tools-extra/docs/clang-tidy/checks/performance-inefficient-vector-operation.rst

for (int i = 0; i < n; ++i) {
     // memory reallocations in v. This can be avoid by inserting a 'reserve(n)'
     // statement before the for statement.
   }
 
   SomeProto p;
   for (int i = 0; i < n; ++i) {
     p.add_xxx(n);
     // This will trigger the warning since the add_xxx may cause multiple memory
-    // relloacations. This can be avoid by inserting a
+    // reallocations. This can be avoid by inserting a
     // 'p.mutable_xxx().Reserve(n)' statement before the for statement.
   }
 
 * For-range loops like ``for (range-declaration : range_expression)``, the type
   of ``range_expression`` can be ``std::vector``, ``std::array``,
   ``std::deque``, ``std::set``, ``std::unordered_set``, ``std::map``,
   ``std::unordered_set``:
 

clang-tools-extra/docs/clang-tidy/checks/portability-restrict-system-includes.rst

 
 .. code-block:: c++
 
   #include <curses.h>       // Good: allowed system header.
   #include <openssl/ssl.h>  // Good: allowed system header.
   #include <zlib.h>         // Bad: disallowed system header.
   #include "src/myfile.h"   // Good: non-system header always allowed.
 
-Since the opions support globbing you can use wildcarding to allow groups of
+Since the options support globbing you can use wildcarding to allow groups of
 headers.
 
 `-*,openssl/*.h` will allow all openssl headers but disallow any others.
 
 .. code-block:: c++
 
   #include <curses.h>       // Bad: disallowed system header.
   #include <openssl/ssl.h>  // Good: allowed system header.

clang-tools-extra/docs/clang-tidy/checks/readability-convert-member-functions-to-static.rst

 .. title:: clang-tidy - readability-convert-member-functions-to-static
 
 readability-convert-member-functions-to-static
 ==============================================
 
 Finds non-static member functions that can be made ``static``
 because the functions don't use ``this``.
 
-After applying modifications as suggested by the check, runnnig the check again
+After applying modifications as suggested by the check, running the check again
 might find more opportunities to mark member functions ``static``.
 
 After making a member function ``static``, you might want to run the check
 `readability-static-accessed-through-instance <readability-static-accessed-through-instance.html>`_ to replace calls like
 ``Instance.method()`` by ``Class::method()``.

clang-tools-extra/docs/clang-tidy/checks/readability-make-member-function-const.rst

public:
     const int *get() const;
     // const_cast disables this check.
     S *get() {
       return const_cast<int*>(const_cast<const C*>(this)->get());
     }
     ...
   };
 
-After applying modifications as suggested by the check, runnnig the check again
+After applying modifications as suggested by the check, running the check again
 might find more opportunities to mark member functions ``const``.

clang-tools-extra/docs/doxygen.cfg.in

 # the HTML documentation. When you change the font size after a successful
 # doxygen run you need to manually remove any form_*.png images from the HTML
 # output directory to force them to be regenerated.
 # Minimum value: 8, maximum value: 50, default value: 10.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 FORMULA_FONTSIZE       = 10
 
-# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
 # generated for formulas are transparent PNGs. Transparent PNGs are not
 # supported properly for IE 6.0, but are supported on all modern browsers.
 #
 # Note that when changing this option you need to delete any form_*.png files in
 # the HTML output directory before the changes have effect.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 

clang-tools-extra/docs/pp-trace.rst

With real data:::
   ...
 
 In all but one case (MacroDirective) the "Argument" scalars have the same
 name as the argument in the corresponding PPCallbacks callback function.
 
 Callback Details
 ----------------
 
-The following sections describe the pupose and output format for each callback.
+The following sections describe the purpose and output format for each callback.
 
 Click on the callback name in the section heading to see the Doxygen
 documentation for the callback.
 
 The argument descriptions table describes the callback argument information
 displayed.
 
 The Argument Name field in most (but not all) cases is the same name as the

clang-tools-extra/modularize/CoverageChecker.h

public:
   /// \return True if no errors.
   bool collectModuleHeaders(const clang::Module &Mod);
 
   /// Collect headers from an umbrella directory.
   /// \param UmbrellaDirName The umbrella directory name.
   /// \return True if no errors.
   bool collectUmbrellaHeaders(llvm::StringRef UmbrellaDirName);
 
-  /// Collect headers rferenced from an umbrella file.
+  /// Collect headers referenced from an umbrella file.
   /// \param UmbrellaHeaderName The umbrella file path.
   /// \return True if no errors.
   bool collectUmbrellaHeaderHeaders(llvm::StringRef UmbrellaHeaderName);
 
   /// Called from CoverageCheckerCallbacks to track a header included
   /// from an umbrella header.
   /// \param HeaderName The header file path.
   void collectUmbrellaHeaderHeader(llvm::StringRef HeaderName);

clang-tools-extra/modularize/CoverageChecker.cpp

for (sys::fs::directory_iterator I(Directory.str(), EC), E; I != E;
     if (!ModularizeUtilities::isHeader(File))
       continue;
     // Save header name.
     ModuleMapHeadersSet.insert(ModularizeUtilities::getCanonicalPath(File));
   }
   return true;
 }
 
-// Collect headers rferenced from an umbrella file.
+// Collect headers referenced from an umbrella file.
 bool
 CoverageChecker::collectUmbrellaHeaderHeaders(StringRef UmbrellaHeaderName) {
 
   SmallString<256> PathBuf(ModuleMapDirectory);
 
   // If directory is empty, it's the current directory.
   if (ModuleMapDirectory.length() == 0)
     sys::fs::current_path(PathBuf);

clang-tools-extra/modularize/Modularize.cpp

 // need to edit this file to suit the needs of your headers.
 //
 // An example command line for generating a module.modulemap file:
 //
 //   modularize -module-map-path=module.modulemap -root-module=myroot \
 //      headerlist.txt
 //
 // Note that if the headers in the header list have partial paths, sub-modules
-// will be created for the subdirectires involved, assuming that the
+// will be created for the subdirectories involved, assuming that the
 // subdirectories contain headers to be grouped into a module, but still with
 // individual modules for the headers in the subdirectory.
 //
 // See the ModuleAssistant.cpp file comments for additional details about the
 // implementation of the assistant mode.
 //
 // Future directions:
 //

clang-tools-extra/modularize/PreprocessorTracker.cpp

 // passed down to the AST action and consumer objects in modularize. For
 // each new compilation instance, the consumer calls the
 // PreprocessorTracker's handleNewPreprocessorEntry function, which sets
 // up a PreprocessorCallbacks object for the preprocessor. At the end of
 // the compilation instance, the PreprocessorTracker's
 // handleNewPreprocessorExit function handles cleaning up with respect
 // to the preprocessing instance.
 //
-// The PreprocessorCallbacks object uses an overidden FileChanged callback
+// The PreprocessorCallbacks object uses an overridden FileChanged callback
 // to determine when a header is entered and exited (including exiting the
 // header during #include directives). It calls PreprocessorTracker's
 // handleHeaderEntry and handleHeaderExit functions upon entering and
 // exiting a header. These functions manage a stack of header handles
 // representing by a vector, pushing and popping header handles as headers
 // are entered and exited. When a HeaderInclusionPath object is created,
 // it simply copies this stack.
 //

 // PreprocessorTrackerImpl's addMacroExpansionInstance function looks for
 // an existing MacroExpansionTracker entry in its map of MacroExampleTracker
 // objects. If none exists, it adds one with one MacroExpansionInstance and
 // returns. If a MacroExpansionTracker object already exists, it looks for
 // an existing MacroExpansionInstance object stored in the
 // MacroExpansionTracker object, one that matches the macro expanded value
 // and the macro definition location. If a matching MacroExpansionInstance
 // object is found, it just adds the current HeaderInclusionPath object to
-// it. If not found, it creates and stores a new MacroExpantionInstance
+// it. If not found, it creates and stores a new MacroExpansionInstance
 // object. The addMacroExpansionInstance function calls a couple of helper
 // functions to get the pre-formatted location and source line strings for
 // the macro reference and the macro definition stored as string handles.
 // These helper functions use the current source manager from the
 // preprocessor. This is done in advance at this point in time because the
 // source manager doesn't exist at the time of the reporting.
 //
 // For conditional check, the PreprocessorCallbacks class overrides the
while (Buffer < BufferEnd) {
     }
     Buffer++;
   }
   size_t Length = EndPtr - BeginPtr;
   return llvm::StringRef(BeginPtr, Length).str();
 }
 
 // Get the string for the Unexpanded macro instance.
-// The soureRange is expected to end at the last token
+// The sourceRange is expected to end at the last token
 // for the macro instance, which in the case of a function-style
 // macro will be a ')', but for an object-style macro, it
 // will be the macro name itself.
 static std::string getMacroUnexpandedString(clang::SourceRange Range,
                                             clang::Preprocessor &PP,
                                             llvm::StringRef MacroName,
                                             const clang::MacroInfo *MI) {
   clang::SourceLocation BeginLoc(Range.getBegin());

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

 /// exist beyond the lifetime of this object, because it's deleted by the
 /// preprocessor automatically in its destructor.
 ///
 /// This class supports a mechanism for inhibiting trace output for
 /// specific callbacks by name, for the purpose of eliminating output for
 /// callbacks of no interest that might clutter the output.
 ///
 /// Following the constructor and destructor function declarations, the
-/// overidden callback functions are defined.  The remaining functions are
+/// overridden callback functions are defined.  The remaining functions are
 /// helpers for recording the trace data, to reduce the coupling between it
 /// and the recorded data structure.
 class PPCallbacksTracker : public PPCallbacks {
 public:
   /// Note that all of the arguments are references, and owned
   /// by the caller.
   /// \param Filters - List of (Glob,Enabled) pairs used to filter callbacks.
   /// \param CallbackCalls - Trace buffer.
   /// \param PP - The preprocessor.  Needed for getting some argument strings.
   PPCallbacksTracker(const FilterType &Filters,
                      std::vector<CallbackCall> &CallbackCalls,
                      Preprocessor &PP);
 
   ~PPCallbacksTracker() override;
 
-  // Overidden callback functions.
+  // Overridden callback functions.
 
   void FileChanged(SourceLocation Loc, PPCallbacks::FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID = FileID()) override;
   void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
                    SrcMgr::CharacteristicKind FileType) override;
   bool FileNotFound(llvm::StringRef FileName,
                     llvm::SmallVectorImpl<char> &RecoveryPath) override;

clang-tools-extra/test/clang-move/move-used-helper-decls.cpp

 // RUN: mkdir -p %T/used-helper-decls
 // RUN: cp %S/Inputs/helper_decls_test*  %T/used-helper-decls/
 // RUN: cd %T/used-helper-decls
 
 // ----------------------------------------------------------------------------
-// Test moving used helper function and its transively used functions.
+// Test moving used helper function and its transitively used functions.
 // ----------------------------------------------------------------------------
 // RUN: clang-move -names="a::Class1" -new_cc=%T/used-helper-decls/new_helper_decls_test.cpp -new_header=%T/used-helper-decls/new_helper_decls_test.h -old_cc=%T/used-helper-decls/helper_decls_test.cpp -old_header=../used-helper-decls/helper_decls_test.h %T/used-helper-decls/helper_decls_test.cpp -- -std=c++11
 // RUN: FileCheck -input-file=%T/used-helper-decls/new_helper_decls_test.cpp -check-prefix=CHECK-NEW-CLASS1-CPP %s
 // RUN: FileCheck -input-file=%T/used-helper-decls/helper_decls_test.cpp -check-prefix=CHECK-OLD-CLASS1-CPP %s
 
 // CHECK-NEW-CLASS1-CPP: #include "{{.*}}new_helper_decls_test.h"
 // CHECK-NEW-CLASS1-CPP-SAME: {{[[:space:]]}}
 // CHECK-NEW-CLASS1-CPP-NEXT: namespace {
 // CHECK-NEW-CLASS1-CPP-NEXT: void HelperFun1() {}
 // CHECK-NEW-CLASS1-CPP-SAME: {{[[:space:]]}}
 // CHECK-NEW-CLASS1-CPP-NEXT: void HelperFun2() { HelperFun1(); }
 // CHECK-NEW-CLASS1-CPP-NEXT: } // namespace
 // CHECK-NEW-CLASS1-CPP-SAME: {{[[:space:]]}}
 // CHECK-NEW-CLASS1-CPP-NEXT: namespace a {
 // CHECK-NEW-CLASS1-CPP-NEXT: void Class1::f() { HelperFun2(); }
 // CHECK-NEW-CLASS1-CPP-NEXT: } // namespace a
 //
 // CHECK-OLD-CLASS1-CPP: void HelperFun1() {}
 // CHECK-OLD-CLASS1-CPP-NOT: void HelperFun2() { HelperFun1(); }
 // CHECK-OLD-CLASS1-CPP-NOT: void Class1::f() { HelperFun2(); }
 // CHECK-OLD-CLASS1-CPP: void Class2::f() {
 // CHECK-OLD-CLASS1-CPP:   HelperFun1();
 
 
 // ----------------------------------------------------------------------------
-// Test moving used helper function and its transively used static variables.
+// Test moving used helper function and its transitively used static variables.
 // ----------------------------------------------------------------------------
 // RUN: cp %S/Inputs/helper_decls_test*  %T/used-helper-decls/
 // RUN: clang-move -names="a::Class2" -new_cc=%T/used-helper-decls/new_helper_decls_test.cpp -new_header=%T/used-helper-decls/new_helper_decls_test.h -old_cc=%T/used-helper-decls/helper_decls_test.cpp -old_header=../used-helper-decls/helper_decls_test.h %T/used-helper-decls/helper_decls_test.cpp -- -std=c++11
 // RUN: FileCheck -input-file=%T/used-helper-decls/new_helper_decls_test.cpp -check-prefix=CHECK-NEW-CLASS2-CPP %s
 // RUN: FileCheck -input-file=%T/used-helper-decls/helper_decls_test.cpp -check-prefix=CHECK-OLD-CLASS2-CPP %s
 
 // CHECK-NEW-CLASS2-CPP: #include "{{.*}}new_helper_decls_test.h"
 // CHECK-NEW-CLASS2-CPP-SAME: {{[[:space:]]}}

 // CHECK-NEW-CLASS5-CPP-NEXT: } // namespace a
 
 // CHECK-OLD-CLASS5-CPP-NOT: const int K1 = 1;
 // CHECK-OLD-CLASS5-CPP: static const int K2 = 2;
 // CHECK-OLD-CLASS5-CPP: static void HelperFun3() { K2; }
 // CHECK-OLD-CLASS5-CPP: static const int K4 = HelperC3::I;
 // CHECK-OLD-CLASS5-CPP-NOT: void Class5::f() {
 
 
 // ----------------------------------------------------------------------------
-// Test moving helper variables and their transively used helper classes.
+// Test moving helper variables and their transitively used helper classes.
 // ----------------------------------------------------------------------------
 // RUN: cp %S/Inputs/helper_decls_test*  %T/used-helper-decls/
 // RUN: clang-move -names="a::Class6" -new_cc=%T/used-helper-decls/new_helper_decls_test.cpp -new_header=%T/used-helper-decls/new_helper_decls_test.h -old_cc=%T/used-helper-decls/helper_decls_test.cpp -old_header=../used-helper-decls/helper_decls_test.h %T/used-helper-decls/helper_decls_test.cpp -- -std=c++11
 // RUN: FileCheck -input-file=%T/used-helper-decls/new_helper_decls_test.cpp -check-prefix=CHECK-NEW-CLASS6-CPP %s
 // RUN: FileCheck -input-file=%T/used-helper-decls/helper_decls_test.cpp -check-prefix=CHECK-OLD-CLASS6-CPP %s
 
 // CHECK-NEW-CLASS6-CPP: #include "{{.*}}new_helper_decls_test.h"
 // CHECK-NEW-CLASS6-CPP-SAME: {{[[:space:]]}}

 // CHECK-NEW-CLASS7-CPP-NEXT: }
 // CHECK-NEW-CLASS7-CPP-NEXT: } // namespace a
 //
 // CHECK-OLD-CLASS7-CPP-NOT: static const int K6 = 6;
 // CHECK-OLD-CLASS7-CPP-NOT: static void HelperFun6() {}
 // CHECK-OLD-CLASS7-CPP-NOT: int Class7::f() {
 // CHECK-OLD-CLASS7-CPP-NOT: int Class7::g() {
 
 
 // ----------------------------------------------------------------------------
-// Test moving helper function and its transively used helper variables.
+// Test moving helper function and its transitively used helper variables.
 // ----------------------------------------------------------------------------
 // RUN: cp %S/Inputs/helper_decls_test*  %T/used-helper-decls/
 // RUN: clang-move -names="a::Fun1" -new_cc=%T/used-helper-decls/new_helper_decls_test.cpp -new_header=%T/used-helper-decls/new_helper_decls_test.h -old_cc=%T/used-helper-decls/helper_decls_test.cpp -old_header=../used-helper-decls/helper_decls_test.h %T/used-helper-decls/helper_decls_test.cpp -- -std=c++11
 // RUN: FileCheck -input-file=%T/used-helper-decls/new_helper_decls_test.cpp -check-prefix=CHECK-NEW-FUN1-CPP %s
 // RUN: FileCheck -input-file=%T/used-helper-decls/helper_decls_test.cpp -check-prefix=CHECK-OLD-FUN1-CPP %s
 
 // CHECK-NEW-FUN1-CPP: #include "{{.*}}new_helper_decls_test.h"
 // CHECK-NEW-FUN1-CPP-SAME: {{[[:space:]]}}

 // CHECK-NEW-FUN2-H-NEXT: } // namespace a
 
 // CHECK-NEW-FUN2-CPP: #include "{{.*}}new_helper_decls_test.h"
 // CHECK-NEW-FUN2-CPP-SAME: {{[[:space:]]}}
 
 // CHECK-OLD-FUN2-H-NOT: inline void Fun2() {}
 
 // ----------------------------------------------------------------------------
-// Test moving used helper function and its transively used functions.
+// Test moving used helper function and its transitively used functions.
 // ----------------------------------------------------------------------------
 // RUN: cp %S/Inputs/helper_decls_test*  %T/used-helper-decls/
 // RUN: clang-move -names="b::Fun3" -new_cc=%T/used-helper-decls/new_helper_decls_test.cpp -new_header=%T/used-helper-decls/new_helper_decls_test.h -old_cc=%T/used-helper-decls/helper_decls_test.cpp -old_header=../used-helper-decls/helper_decls_test.h %T/used-helper-decls/helper_decls_test.cpp -- -std=c++11
 // RUN: FileCheck -input-file=%T/used-helper-decls/new_helper_decls_test.cpp -check-prefix=CHECK-NEW-FUN3-CPP %s
 // RUN: FileCheck -input-file=%T/used-helper-decls/helper_decls_test.cpp -check-prefix=CHECK-OLD-FUN3-CPP %s
 
 // CHECK-NEW-FUN3-CPP: #include "{{.*}}new_helper_decls_test.h"
 // CHECK-NEW-FUN3-CPP-SAME: {{[[:space:]]}}

clang-tools-extra/test/clang-tidy/checkers/Inputs/performance-unnecessary-value-param/header-fixed.h

 // struct ABC is expensive to copy and should be
-// passed as a const referece.
+// passed as a const reference.
 struct ABC {
   ABC(const ABC&);
   int get(int) const;
 };
 
 
 int f1(int n,              const ABC& v1,   const ABC& v2); // line 9
 
 int f1(int n, ABC v1); // line 11
 
 
 
 int f2(        int n,       const ABC& v2); // line 15

clang-tools-extra/test/clang-tidy/checkers/Inputs/performance-unnecessary-value-param/header.h

 // struct ABC is expensive to copy and should be
-// passed as a const referece.
+// passed as a const reference.
 struct ABC {
   ABC(const ABC&);
   int get(int) const;
 };
 
 
 int f1(int n,              ABC v1,   ABC v2); // line 9
 
 int f1(int n, ABC v1); // line 11
 
 
 
 int f2(        int n,       ABC v2); // line 15

clang-tools-extra/test/clang-tidy/checkers/abseil-duration-subtraction.cpp

#define THIRTY absl::Seconds(30)
   // CHECK-FIXES: absl::ToDoubleSeconds(THIRTY - absl::Seconds(1))
 #undef THIRTY
 
   // Some other contexts
   if (absl::ToDoubleSeconds(d) - 1.0 > 10) {}
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: perform subtraction in the duration domain [abseil-duration-subtraction]
   // CHECK-FIXES: if (absl::ToDoubleSeconds(d - absl::Seconds(1)) > 10) {}
 
-  // A nested occurance
+  // A nested occurrence
   x = absl::ToDoubleSeconds(d) - absl::ToDoubleSeconds(absl::Seconds(5));
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: perform subtraction in the duration domain [abseil-duration-subtraction]
   // CHECK-FIXES: absl::ToDoubleSeconds(d - absl::Seconds(5))
   x = absl::ToDoubleSeconds(d) - absl::ToDoubleSeconds(absl::Seconds(absl::ToDoubleSeconds(d1)));
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: perform subtraction in the duration domain [abseil-duration-subtraction]
   // CHECK-FIXES: absl::ToDoubleSeconds(d - absl::Seconds(absl::ToDoubleSeconds(d1)))
 
   // These should not match

clang-tools-extra/test/clang-tidy/checkers/bugprone-branch-clone.cpp

case 92:
     z *= 2;
     break;
   default:
     z++;
   }
   return z + 92;
 }
 
-// The child of the switch statement is not neccessarily a compound statement,
+// The child of the switch statement is not necessarily a compound statement,
 // do not crash in this unusual case.
 char no_real_body(int in, int &out) {
   switch (in)
   case 42:
     return 'A';
 
   if (in > 77)
 // CHECK-MESSAGES: :[[@LINE+1]]:5: warning: repeated branch in conditional chain [bugprone-branch-clone]

clang-tools-extra/test/clang-tidy/checkers/bugprone-throw-keyword-missing.cpp

 
 template <class Exception>
 void f(int i, Exception excToBeThrown) {}
 
 void funcCallWithTempExcTest() {
   f(5, RegularException());
 }
 
-// Global variable initilization test.
+// Global variable initialization test.
 RegularException exc = RegularException();
 RegularException *excptr = new RegularException();
 
 void localVariableInitTest() {
   RegularException exc = RegularException();
   RegularException *excptr = new RegularException();
 }
 

clang-tools-extra/test/clang-tidy/checkers/cert-throw-exception-type.cpp

 // RUN: %check_clang_tidy -std=c++11,c++14 %s cert-err60-cpp %t -- -- -fcxx-exceptions
-// FIXME: Split off parts of this test that rely on dynamic exeption
+// FIXME: Split off parts of this test that rely on dynamic exception
 // specifications, and run this test in all language modes.
 
 struct S {};
 struct T : S {};
 struct U {
   U() = default;
   U(const U&) = default;
 };

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

 // RUN: %check_clang_tidy %s cppcoreguidelines-no-malloc %t \
 // RUN: -config='{CheckOptions: \
 // RUN:  [{key: cppcoreguidelines-no-malloc.Allocations, value: "::malloc;::align_malloc;::calloc"},\
 // RUN:   {key: cppcoreguidelines-no-malloc.Reallocations, value: "::realloc;::align_realloc"},\
 // RUN:   {key: cppcoreguidelines-no-malloc.Deallocations, value: "::free;::align_free"}]}' \
 // RUN: --
 
 using size_t = __SIZE_TYPE__;
 
 void *malloc(size_t size);
-void *align_malloc(size_t size, unsigned short aligmnent);
+void *align_malloc(size_t size, unsigned short alignment);
 void *calloc(size_t num, size_t size);
 void *realloc(void *ptr, size_t size);
 void *align_realloc(void *ptr, size_t size, unsigned short alignment);
 void free(void *ptr);
 void *align_free(void *ptr);
 
 void malloced_array() {
   int *array0 = (int *)malloc(sizeof(int) * 20);

clang-tools-extra/test/clang-tidy/checkers/fuchsia-multiple-inheritance.cpp

 public:
   virtual int baz() = 0;
 };
 
 // Shouldn't warn on forward declarations.
 class Bad_Child1;
 
 // Inherits from multiple concrete classes.
-// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting mulitple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
+// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting multiple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
 // CHECK-NEXT: class Bad_Child1 : public Base_A, Base_B {};
 class Bad_Child1 : public Base_A, Base_B {};
 
-// CHECK-MESSAGES: [[@LINE+1]]:1: warning: inheriting mulitple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
+// CHECK-MESSAGES: [[@LINE+1]]:1: warning: inheriting multiple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
 class Bad_Child2 : public Base_A, Interface_A_with_member {
   virtual int foo() override { return 0; }
 };
 
-// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting mulitple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
+// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting multiple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
 // CHECK-NEXT: class Bad_Child3 : public Interface_with_A_Parent, Base_B {
 class Bad_Child3 : public Interface_with_A_Parent, Base_B {
   virtual int baz() override { return 0; }
 };
 
 // Easy cases of single inheritance
 class Simple_Child1 : public Base_A {};
 class Simple_Child2 : public Interface_A {

 
 class Good_Child3 : public Base_A_child, Interface_C, Interface_B {
   virtual int bar() override { return 0; }
   virtual int blat() override { return 0; }
 };
 
 struct B1 { int x; };
 struct B2 { int x;};
-// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting mulitple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
+// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting multiple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
 // CHECK-NEXT: struct D : B1, B2 {};
 struct D1 : B1, B2 {};
 
 struct Base1 { virtual void foo() = 0; };
 struct V1 : virtual Base1 {};
 struct V2 : virtual Base1 {};
 struct D2 : V1, V2 {};
 
 struct Base2 { virtual void foo(); };
 struct V3 : virtual Base2 {};
 struct V4 : virtual Base2 {};
 struct D3 : V3, V4 {};
 
 struct Base3 {};
 struct V5 : virtual Base3 { virtual void f(); };
 struct V6 : virtual Base3 { virtual void g(); };
-// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting mulitple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
+// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting multiple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
 // CHECK-NEXT: struct D4 : V5, V6 {};
 struct D4 : V5, V6 {};
 
 struct Base4 {};
 struct V7 : virtual Base4 { virtual void f() = 0; };
 struct V8 : virtual Base4 { virtual void g() = 0; };
 struct D5 : V7, V8 {};
 
 struct Base5 { virtual void f() = 0; };
 struct V9 : virtual Base5 { virtual void f(); };
 struct V10 : virtual Base5 { virtual void g() = 0; };
 struct D6 : V9, V10 {};
 
 struct Base6 { virtual void f(); };
 struct Base7 { virtual void g(); };
 struct V15 : virtual Base6 { virtual void f() = 0; };
 struct V16 : virtual Base7 { virtual void g() = 0; };
-// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting mulitple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
+// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting multiple classes that aren't pure virtual is discouraged [fuchsia-multiple-inheritance]
 // CHECK-NEXT: struct D9 : V15, V16 {};
 struct D9 : V15, V16 {};
 
 struct Static_Base { static void foo(); };
 struct V11 : virtual Static_Base {};
 struct V12 : virtual Static_Base {};
 struct D7 : V11, V12 {};
 

clang-tools-extra/test/clang-tidy/checkers/hicpp-signed-bitwise-bug34747.cpp

 // RUN: %check_clang_tidy %s hicpp-signed-bitwise %t --
 
 // Note: this test expects no diagnostics, but FileCheck cannot handle that,
 // hence the use of | count 0.
 
 template <typename C>
 struct OutputStream {
   OutputStream &operator<<(C);
 };
 
 template <typename C>
 struct foo {
   typedef OutputStream<C> stream_type;
   foo(stream_type &o) {
-    o << 'x'; // warning occured here, fixed now
+    o << 'x'; // warning occurred here, fixed now
   }
 };
 
 void bar(OutputStream<signed char> &o) {
   foo<signed char> f(o);
 }
 
 void silence_lit() {
   int SValue = 42;
   int SResult;
 
   SResult = SValue & 1;
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
 }

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

void initialization(int T, Base b) {
   PE1.reset(new E{});
   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use std::make_unique instead
   // CHECK-FIXES: PE1 = std::make_unique<E>();
 
   // No warnings for `auto` new expression.
   PE1.reset(new auto(E()));
 
   //============================================================================
-  //  NOTE: For initlializer-list constructors, the check only gives warnings,
+  //  NOTE: For initializer-list constructors, the check only gives warnings,
   //  and no fixes are generated.
   //============================================================================
 
   // Initialization with the initializer-list constructor.
   std::unique_ptr<E> PE2 = std::unique_ptr<E>(new E{1, 2});
   // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use std::make_unique instead
   // CHECK-FIXES: std::unique_ptr<E> PE2 = std::unique_ptr<E>(new E{1, 2});
   PE2.reset(new E{1, 2});

clang-tools-extra/test/clang-tidy/checkers/modernize-redundant-void-arg.cpp

 void (*fb)() = nullptr;
 
 void (*fc)() = bar;
 
 typedef void (function_ptr)(void);
 // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: {{.*}} in typedef
 // CHECK-FIXES: {{^}}typedef void (function_ptr)();{{$}}
 
-// intentionally not LLVM style to check preservation of whitesapce
+// intentionally not LLVM style to check preservation of whitespace
 typedef void (function_ptr2)
     (
         void
     );
 // CHECK-MESSAGES: :[[@LINE-2]]:9: warning: {{.*}} in typedef
 // CHECK-FIXES:      {{^typedef void \(function_ptr2\)$}}
 // CHECK-FIXES-NEXT: {{^    \($}}
 // CHECK-FIXES-NEXT: {{^        $}}
 // CHECK-FIXES-NEXT: {{^    \);$}}
 
-// intentionally not LLVM style to check preservation of whitesapce
+// intentionally not LLVM style to check preservation of whitespace
 typedef
 void
 (
 *
 (
 *
 returns_fn_returns_fn_void_void_t2
 (

 void (gronk::*p2)(void) = &gronk::foo;
 // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: {{.*}} in variable declaration with initializer
 // CHECK-FIXES: {{^}}void (gronk::*p2)() = &gronk::foo;{{$}}
 
 typedef void (gronk::*member_function_ptr)(void);
 // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: {{.*}} in typedef
 // CHECK-FIXES: {{^}}typedef void (gronk::*member_function_ptr)();{{$}}
 
-// intentionally not LLVM style to check preservation of whitesapce
+// intentionally not LLVM style to check preservation of whitespace
 typedef void (gronk::*member_function_ptr2)
     (
         void
     );
 // CHECK-MESSAGES: :[[@LINE-2]]:9: warning: {{.*}} in typedef
 // CHECK-FIXES:      {{^typedef void \(gronk::\*member_function_ptr2\)$}}
 // CHECK-FIXES-NEXT: {{^    \($}}
 // CHECK-FIXES-NEXT: {{^        $}}
 // CHECK-FIXES-NEXT: {{^    \);$}}
 
 void gronk::foo() {
   void (*f1)(void) = &::bar;
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}} in variable declaration with initializer
   // CHECK-FIXES: {{^  }}void (*f1)() = &::bar;{{$}}
 
   void (*f2)(void);
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}} in variable declaration
   // CHECK-FIXES: {{^  }}void (*f2)();{{$}}
 
-  // intentionally not LLVM style to check preservation of whitesapce
+  // intentionally not LLVM style to check preservation of whitespace
   void (*f3)
       (
           void
       );
   // CHECK-MESSAGES: :[[@LINE-2]]:11: warning: {{.*}} in variable declaration
   // CHECK-FIXES:      {{^  }}void (*f3){{$}}
   // CHECK-FIXES-NEXT: {{^      \($}}
   // CHECK-FIXES-NEXT: {{^          $}}
   // CHECK-FIXES-NEXT: {{^      \);$}}
 }
 
 void gronk::bar(void) {
 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: {{.*}} in function definition
 // CHECK-FIXES: {{^}}void gronk::bar() {{{$}}
   void (gronk::*p3)(void) = &gronk::foo;
   // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: {{.*}} in variable declaration with initializer
   // CHECK-FIXES: {{^  }}void (gronk::*p3)() = &gronk::foo;{{$}}
 
   void (gronk::*p4)(void);
   // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: {{.*}} in variable declaration
   // CHECK-FIXES: {{^  }}void (gronk::*p4)();{{$}}
 
-  // intentionally not LLVM style to check preservation of whitesapce
+  // intentionally not LLVM style to check preservation of whitespace
   void (gronk::*p5)
       (
           void
       );
   // CHECK-MESSAGES: :[[@LINE-2]]:11: warning: {{.*}} in variable declaration
   // CHECK-FIXES:      {{^  }}void (gronk::*p5){{$}}
   // CHECK-FIXES-NEXT: {{^      \($}}
   // CHECK-FIXES-NExT: {{^          $}}
   // CHECK-FIXES-NExT: {{^      \);$}}
 }
 
-// intentionally not LLVM style to check preservation of whitesapce
+// intentionally not LLVM style to check preservation of whitespace
 void gronk::bar2
   (
   void
   )
 // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: {{.*}} in function definition
 // CHECK-FIXES:      {{^void gronk::bar2$}}
 // CHECK-FIXES-NEXT: {{^  \($}}
 // CHECK-FIXES-NEXT: {{^  $}}
// CHECK-FIXES: {{^}}nutter::nutter() {{{$}}
   // CHECK-MESSAGES: :[[@LINE-2]]:32: warning: {{.*}} in cast expression
   // CHECK-FIXES: void (*f4)() = (void (*)()) 0;{{$}}
 
   void (*f5)(void) = reinterpret_cast<void (*)(void)>(0);
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: {{.*}} in variable declaration with initializer
   // CHECK-MESSAGES: :[[@LINE-2]]:48: warning: {{.*}} in named cast
   // CHECK-FIXES: void (*f5)() = reinterpret_cast<void (*)()>(0);{{$}}
 
-  // intentionally not LLVM style to check preservation of whitesapce
+  // intentionally not LLVM style to check preservation of whitespace
   void (*f6)(void) = static_cast<void (*)
       (
           void
       )>(0);
   // CHECK-MESSAGES: :[[@LINE-4]]:14: warning: {{.*}} in variable declaration with initializer
   // CHECK-MESSAGES: :[[@LINE-3]]:11: warning: {{.*}} in named cast
   // CHECK-FIXES:      {{^  }}void (*f6)() = static_cast<void (*){{$}}
   // CHECK-FIXES-NEXT: {{^      \($}}
   // CHECK-FIXES-NEXT: {{^          $}}
   // CHECK-FIXES-NEXT: {{^      }})>(0);{{$}}
 
-  // intentionally not LLVM style to check preservation of whitesapce
+  // intentionally not LLVM style to check preservation of whitespace
   void (*f7)(void) = (void (*)
       (
           void
       )) 0;
   // CHECK-MESSAGES: :[[@LINE-4]]:14: warning: {{.*}} in variable declaration with initializer
   // CHECK-MESSAGES: :[[@LINE-3]]:11: warning: {{.*}} in cast expression
   // CHECK-FIXES:      {{^  }}void (*f7)() = (void (*){{$}}
   // CHECK-FIXES-NEXT: {{^      \($}}
   // CHECK-FIXES-NEXT: {{^          $}}
   // CHECK-FIXES-NEXT: {{^      \)\) 0;$}}
 
-  // intentionally not LLVM style to check preservation of whitesapce
+  // intentionally not LLVM style to check preservation of whitespace
   void (*f8)(void) = reinterpret_cast<void (*)
       (
           void
       )>(0);
   // CHECK-MESSAGES: :[[@LINE-4]]:14: warning: {{.*}} in variable declaration with initializer
   // CHECK-MESSAGES: :[[@LINE-3]]:11: warning: {{.*}} in named cast
   // CHECK-FIXES:      {{^  }}void (*f8)() = reinterpret_cast<void (*){{$}}
   // CHECK-FIXES-NEXT: {{^      \($}}

clang-tools-extra/unittests/clang-include-fixer/IncludeFixerTest.cpp

EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nnamespace b{\nbar b;\n}\n} "
             runIncludeFixer("namespace a {\nnamespace b{\nbar b;\n}\n}\n"));
   EXPECT_EQ("c::b::bar b;\n",
             runIncludeFixer("c::b::bar b;\n"));
   EXPECT_EQ("#include \"bar.h\"\nnamespace d {\na::b::bar b;\n}\n",
             runIncludeFixer("namespace d {\nbar b;\n}\n"));
   EXPECT_EQ("#include \"bar2.h\"\nnamespace c {\na::c::bar b;\n}\n",
             runIncludeFixer("namespace c {\nbar b;\n}\n"));
 
-  // Test common qualifers reduction.
+  // Test common qualifiers reduction.
   EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nnamespace d {\nb::bar b;\n}\n} "
             "// namespace a\n",
             runIncludeFixer("namespace a {\nnamespace d {\nbar b;\n}\n}\n"));
   EXPECT_EQ("#include \"bar.h\"\nnamespace d {\nnamespace a {\na::b::bar "
             "b;\n}\n} // namespace d\n",
             runIncludeFixer("namespace d {\nnamespace a {\nbar b;\n}\n}\n"));
 
   // Test nested classes.

clang-tools-extra/unittests/clang-move/ClangMoveTests.cpp

TEST(ClangMove, DumpDecls) {
   std::vector<DeclarationReporter::Declaration> Results;
   for (const auto &DelPair : Reporter.getDeclarationList())
     Results.push_back(DelPair);
   EXPECT_THAT(ExpectedDeclarations,
               testing::UnorderedElementsAreArray(Results));
 }
 
 } // namespace
-} // namespce move
+} // namespace move
 } // namespace clang

clang-tools-extra/unittests/clang-tidy/ClangTidyTest.h

if (const auto *ChosenFix = tooling::selectFirstFix(Error))
           }
         }
       }
   }
   if (Errors)
     *Errors = std::move(Diags);
   auto Result = tooling::applyAllReplacements(Code, Fixes);
   if (!Result) {
-    // FIXME: propogate the error.
+    // FIXME: propagate the error.
     llvm::consumeError(Result.takeError());
     return "";
   }
   return *Result;
 }
 
 #define EXPECT_NO_CHANGES(Check, Code)                                         \
   EXPECT_EQ(Code, runCheckOnCode<Check>(Code))
 
 } // namespace test
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANG_TIDY_CLANGTIDYTEST_H