[clang-tools-extra] Fixed a number of typos

[GabrielRavier]

Summary

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

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

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

[kadircet]

thanks, lgtm!

[kadircet]

also LMK if I should land this for you

[GabrielRavier]

Well I'm pretty sure I don't have commit rights to LLVM and it seems landing means to push the revision onto main, so that would be nice, yes

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

static bool hasRValueOverload(const CXXConstructorDecl *Ctor,
                               const ParmVarDecl *Param) {
   if (!Param->getType().getCanonicalType()->isLValueReferenceType()) {
     // The parameter is passed by value.
     return false;
   }
   const int ParamIdx = Param->getFunctionScopeIndex();
   const CXXRecordDecl *Record = Ctor->getParent();
 
-  // Check whether a ctor `C` forms a pair with `Ctor` under the aforementionned
+  // Check whether a ctor `C` forms a pair with `Ctor` under the aforementioned
   // rules.
   const auto IsRValueOverload = [&Ctor, ParamIdx](const CXXConstructorDecl *C) {
     if (C == Ctor || C->isDeleted() ||
         C->getNumParams() != Ctor->getNumParams())
       return false;
     for (int I = 0, E = C->getNumParams(); I < E; ++I) {
       const clang::QualType CandidateParamType =
           C->parameters()[I]->getType().getCanonicalType();

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

 
 namespace clang {
 namespace tidy {
 namespace performance {
 
 /// Finds calls to C math library functions with implicit float to double
 /// promotions.
 ///
-/// For example, warns on ::sin(0.f), because this funciton's parameter is a
+/// For example, warns on ::sin(0.f), because this function's parameter is a
 /// double.  You probably meant to call std::sin(0.f) (in C++), or sinf(0.f) (in
 /// C).
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/performance/type-promotion-in-math-fn.html
 class TypePromotionInMathFnCheck : public ClangTidyCheck {
 public:
   TypePromotionInMathFnCheck(StringRef Name, ClangTidyContext *Context);

clang-tools-extra/clangd/CodeComplete.h

struct CodeCompleteOptions {
   /// baseline model using A/B testing.
   std::function<DecisionForestScores(
       const SymbolQualitySignals &, const SymbolRelevanceSignals &, float Base)>
       DecisionForestScorer = &evaluateDecisionForest;
   /// Weight for combining NameMatch and Prediction of DecisionForest.
   /// CompletionScore is NameMatch * pow(Base, Prediction).
   /// The optimal value of Base largely depends on the semantics of the model
   /// and prediction score (e.g. algorithm used during training, number of
-  /// trees, etc.). Usually if the range of Prediciton is [-20, 20] then a Base
+  /// trees, etc.). Usually if the range of Prediction is [-20, 20] then a Base
   /// in [1.2, 1.7] works fine.
-  /// Semantics: E.g. For Base = 1.3, if the Prediciton score reduces by 2.6
+  /// Semantics: E.g. For Base = 1.3, if the Prediction score reduces by 2.6
   /// points then completion score reduces by 50% or 1.3^(-2.6).
   float DecisionForestBase = 1.3f;
 };
 
 // Semi-structured representation of a code-complete suggestion for our C++ API.
 // We don't use the LSP structures here (unlike most features) as we want
 // to expose more data to allow for more precise testing and evaluation.
 struct CodeCompletion {

clang-tools-extra/clangd/ConfigFragment.h

struct CompileFlagsBlock {
     /// Example:
     ///   Command: clang++ --include-directory=/usr/include -DFOO=42 foo.cc
     ///   Remove: [-I, -DFOO=*]
     ///   Result: clang++ foo.cc
     ///
     /// Flags added by the same CompileFlags entry will not be removed.
     std::vector<Located<std::string>> Remove;
 
-    /// Directory to search for compilation database (compile_comands.json etc).
-    /// Valid values are:
+    /// Directory to search for compilation database (compile_commands.json
+    /// etc). Valid values are:
     /// - A single path to a directory (absolute, or relative to the fragment)
     /// - Ancestors: search all parent directories (the default)
     /// - None: do not use a compilation database, just default flags.
     llvm::Optional<Located<std::string>> CompilationDatabase;
   };
   CompileFlagsBlock CompileFlags;
 
   /// Controls how clangd understands code outside the current file.

clang-tools-extra/clangd/DumpAST.cpp

class DumpVisitor : public RecursiveASTVisitor<DumpVisitor> {
   SourceRange getSourceRange(const T *Node) {
     return Node->getSourceRange();
   }
   // TemplateName doesn't have a real Loc node type.
   SourceRange getSourceRange(const TemplateName &Node) { return SourceRange(); }
   // Attr just uses a weird method name. Maybe we should fix it instead?
   SourceRange getSourceRange(const Attr *Node) { return Node->getRange(); }
 
-  // Kind is usualy the class name, without the suffix ("Type" etc).
+  // Kind is usually the class name, without the suffix ("Type" etc).
   // Where there's a set of variants instead, we use the 'Kind' enum values.
 
   std::string getKind(const Decl *D) { return D->getDeclKindName(); }
   std::string getKind(const Stmt *S) {
     std::string Result = S->getStmtClassName();
     if (llvm::StringRef(Result).endswith("Stmt") ||
         llvm::StringRef(Result).endswith("Expr"))
       Result.resize(Result.size() - 4);

clang-tools-extra/clangd/HeuristicResolver.cpp

std::vector<const NamedDecl *> HeuristicResolver::resolveMemberExpr(
   const Type *BaseType = ME->getBaseType().getTypePtrOrNull();
   if (ME->isArrow()) {
     BaseType = getPointeeType(BaseType);
   }
   if (!BaseType)
     return {};
   if (const auto *BT = BaseType->getAs<BuiltinType>()) {
     // If BaseType is the type of a dependent expression, it's just
-    // represented as BultinType::Dependent which gives us no information. We
-    // can get further by analyzing the depedent expression.
+    // represented as BuiltinType::Dependent which gives us no information. We
+    // can get further by analyzing the dependent expression.
     Expr *Base = ME->isImplicitAccess() ? nullptr : ME->getBase();
     if (Base && BT->getKind() == BuiltinType::Dependent) {
       BaseType = resolveExprToType(Base);
     }
   }
   return resolveDependentMember(BaseType, ME->getMember(), NoFilter);
 }
 

clang-tools-extra/clangd/IncludeCleaner.cpp

static bool mayConsiderUnused(const Inclusion &Inc, ParsedAST &AST,
   // self-contained, skip them.
   if (!AST.getPreprocessor().getHeaderSearchInfo().isFileMultipleIncludeGuarded(
           &FE->getFileEntry())) {
     dlog("{0} doesn't have header guard and will not be considered unused",
          FE->getName());
     return false;
   }
   for (auto &Filter : Cfg.Diagnostics.Includes.IgnoreHeader) {
-    // Convert the path to Unix slashes and try to match aginast the fiilter.
+    // Convert the path to Unix slashes and try to match against the filter.
     llvm::SmallString<64> Path(Inc.Resolved);
     llvm::sys::path::native(Path, llvm::sys::path::Style::posix);
     if (Filter(Inc.Resolved)) {
       dlog("{0} header is filtered out by the configuration", FE->getName());
       return false;
     }
   }
   return true;

clang-tools-extra/clangd/InlayHints.cpp

private:
   // make more sense but CallExpr only exposes the closing.) We heuristically
   // assume that if this location does not come from a macro definition, then
   // the entire argument list likely appears in the main file and can be hinted.
   void processCall(SourceLocation Anchor, const FunctionDecl *Callee,
                    llvm::ArrayRef<const Expr *> Args) {
     if (!Cfg.InlayHints.Parameters || Args.size() == 0 || !Callee)
       return;
 
-    // If the anchor location comes from a macro defintion, there's nowhere to
+    // If the anchor location comes from a macro definition, there's nowhere to
     // put hints.
     if (!AST.getSourceManager().getTopMacroCallerLoc(Anchor).isFileID())
       return;
 
     // The parameter name of a move or copy constructor is not very interesting.
     if (auto *Ctor = dyn_cast<CXXConstructorDecl>(Callee))
       if (Ctor->isCopyOrMoveConstructor())
         return;

clang-tools-extra/clangd/Quality.cpp

evaluateDecisionForest(const SymbolQualitySignals &Quality,
   E.setIsInstanceMember(Relevance.IsInstanceMember);
   E.setHadContextType(Relevance.HadContextType);
   E.setHadSymbolType(Relevance.HadSymbolType);
   E.setTypeMatchesPreferred(Relevance.TypeMatchesPreferred);
 
   DecisionForestScores Scores;
   // Exponentiating DecisionForest prediction makes the score of each tree a
   // multiplciative boost (like NameMatch). This allows us to weigh the
-  // prediciton score and NameMatch appropriately.
+  // prediction score and NameMatch appropriately.
   Scores.ExcludingName = pow(Base, Evaluate(E));
   // Following cases are not part of the generated training dataset:
   //  - Symbols with `NeedsFixIts`.
   //  - Forbidden symbols.
   //  - Keywords: Dataset contains only macros and decls.
   if (Relevance.NeedsFixIts)
     Scores.ExcludingName *= 0.5;
   if (Relevance.Forbidden)

clang-tools-extra/clangd/SemanticHighlighting.cpp

llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingKind K) {
   case HighlightingKind::InactiveCode:
     return OS << "InactiveCode";
   }
   llvm_unreachable("invalid HighlightingKind");
 }
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, HighlightingModifier K) {
   switch (K) {
   case HighlightingModifier::Declaration:
-    return OS << "decl"; // abbrevation for common case
+    return OS << "decl"; // abbreviation for common case
   default:
     return OS << toSemanticTokenModifier(K);
   }
 }
 
 bool operator==(const HighlightingToken &L, const HighlightingToken &R) {
   return std::tie(L.R, L.Kind, L.Modifiers) ==
          std::tie(R.R, R.Kind, R.Modifiers);

clang-tools-extra/clangd/benchmarks/CompletionModel/DecisionForestBenchmark.cpp

for (int I = 0; I < NumExamples; ++I) {
     E.setHadContextType(FlipCoin(0.6));       // Boolean.
     E.setHadSymbolType(FlipCoin(0.6));        // Boolean.
     E.setTypeMatchesPreferred(FlipCoin(0.5)); // Boolean.
     Examples.push_back(E);
   }
   return Examples;
 }
 
-void runDecisionForestPrediciton(const std::vector<Example> Examples) {
+void runDecisionForestPrediction(const std::vector<Example> Examples) {
   for (const Example &E : Examples)
     Evaluate(E);
 }
 
 static void decisionForestPredict(benchmark::State &State) {
   srand(0);
   for (auto _ : State) {
     State.PauseTiming();
     const std::vector<Example> Examples = generateRandomDataset(1000000);
     State.ResumeTiming();
-    runDecisionForestPrediciton(Examples);
+    runDecisionForestPrediction(Examples);
   }
 }
 BENCHMARK(decisionForestPredict);
 
 } // namespace
 } // namespace clangd
 } // namespace clang
 
 BENCHMARK_MAIN();

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

 /// Currently it only supports IWYU private pragma:
 /// https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUPragmas.md#iwyu-pragma-private
 ///
 /// We ignore other pragmas:
 /// - keep: this is common but irrelevant: we do not currently remove includes
 /// - export: this is common and potentially interesting, there are three cases:
 ///    * Points to a public header (common): we can suppress include2 if you
 ///      already have include1. Only marginally useful.
-///    * Points to a private header annotated with `private` (somewhat commmon):
+///    * Points to a private header annotated with `private` (somewhat common):
 ///      Not incrementally useful as we support private.
 ///    * Points to a private header without pragmas (rare). This is a reversed
 ///      private pragma, and is valuable but too rare to be worthwhile.
 /// - no_include: this is about as common as private, but only affects the
 ///   current file, so the value is smaller. We could add support.
 /// - friend: this is less common than private, has implementation difficulties,
 ///   and affects behavior in a limited scope.
 /// - associated: extremely rare
 std::unique_ptr<CommentHandler>
 collectIWYUHeaderMaps(CanonicalIncludes *Includes);
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_CANONICALINCLUDES_H

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

EXPECT_THAT(CaptureTUStatus.preambleStatuses(),
                   // Then goes idle and stays that way as we don't receive any
                   // more update requests.
                   PreambleAction::Idle));
   EXPECT_THAT(CaptureTUStatus.astStatuses(),
               ElementsAre(
                   // Starts handling the update action and blocks until the
                   // first preamble is built.
                   ASTAction::RunningAction,
-                  // Afterwqards it builds an AST for that preamble to publish
+                  // Afterwards it builds an AST for that preamble to publish
                   // diagnostics.
                   ASTAction::Building,
                   // Then goes idle.
                   ASTAction::Idle,
                   // Afterwards we start executing go-to-def.
                   ASTAction::RunningAction,
                   // Then go idle.
                   ASTAction::Idle));

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

for (StringRef Label : {"0", "1", "2", "3", "4", "5", "6", "7"}) {
     for (const auto &Point : Code.points(Label)) {
       EXPECT_THAT(findImplementations(AST, Point, Index.get()),
                   UnorderedPointwise(declRange(), Code.ranges(Label)))
           << Code.code() << " at " << Point << " for Label " << Label;
     }
   }
 }
 
-TEST(FindImplementations, CaptureDefintion) {
+TEST(FindImplementations, CaptureDefinition) {
   llvm::StringRef Test = R"cpp(
     struct Base {
       virtual void F^oo();
     };
     struct Child1 : Base {
       void $Decl[[Foo]]() override;
     };
     struct Child2 : Base {

clang-tools-extra/pseudo/gen/Main.cpp

 
 namespace clang {
 namespace pseudo {
 namespace {
 
 // Mangles a symbol name into a valid identifier.
 //
 // These follow names in the grammar fairly closely:
-//   nonterminal: `ptr-declartor` becomes `ptr_declarator`;
+//   nonterminal: `ptr-declarator` becomes `ptr_declarator`;
 //   punctuator: `,` becomes `COMMA`;
 //   keyword: `INT` becomes `INT`;
 //   terminal: `IDENTIFIER` becomes `IDENTIFIER`;
 std::string mangleSymbol(SymbolID SID, const Grammar &G) {
   static auto &TokNames = *new std::vector<std::string>{
 #define TOK(X) llvm::StringRef(#X).upper(),
 #define KEYWORD(Keyword, Condition) llvm::StringRef(#Keyword).upper(),
 #include "clang/Basic/TokenKinds.def"

clang-tools-extra/pseudo/lib/cxx/cxx.bnf

 # This is a C++ grammar from the C++ standard [1].
 #
 # The grammar is a superset of the true grammar requring semantic constraints to
-# resolve ambiguties. The grammar is context-free and ambiguous (beyond the
+# resolve ambiguities. The grammar is context-free and ambiguous (beyond the
 # limit of LR(k)). We use general parsing algorithm (e.g GLR) to handle the
 # grammar and generate a transition table which is used to drive the parsing.
 #
 # It aims to align with the ISO C++ grammar as much as possible. We adjust it
 # to fit the need for the grammar-based parser:
 #  - attributes are omitted, which will be handled as comments;
 #  - we don't allow nullable nonterminal symbols. There are few nullable
 #    nonterminals in the spec grammar, they are adjusted to be non-nullable;

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/virtual-class-destructor.cpp

 class PublicNonVirtualBaseClass {
   virtual void f();
 
 public:
   ~PublicNonVirtualBaseClass() {}
   // CHECK-FIXES: virtual ~PublicNonVirtualBaseClass() {}
 };
 
-class PublicNonVirtualNonBaseClass { // OK accoring to C.35, since this class does not have any virtual methods.
+class PublicNonVirtualNonBaseClass { // OK according to C.35, since this class does not have any virtual methods.
   void f();
 
 public:
   ~PublicNonVirtualNonBaseClass() {}
 };
 
 class ProtectedNonVirtualClass { // OK
 public: