[NFC] Fix typos in Clangd and Clang

[kbobyrev]

Rebase on top of master, fix the build and apply formatting.

[MaskRay]

Renaming handleDeclOccurence, handleMacroOccurence and handleModuleOccurence are definitely not NFC because they are public APIs that can be used by downstream projects.

[kbobyrev]

In D71455#1787266, @MaskRay wrote:

Renaming handleDeclOccurence, handleMacroOccurence and handleModuleOccurence are definitely not NFC because they are public APIs that can be used by downstream projects.

I'm sorry if it broke some donwstream buildbots for the projects. I thought NFC is something that does not change behavior of the code (which is the case in this patch?) so is there something else that can make a patch NFC?

Also, if there is anything I could help with (e.g. submitting patches to some projects you know are affected by this change) please let me know.

[ilya-biryukov]

In addition to that, NFC is also often used as a way to tag commits that should not cause any problems.
wrt to this change, I don't think anything was done wrong. It even went through review, although often we don't send reviews for NFC changes.

Downstream projects should be ready to update their code when public API changes like this happen, LLVM does not promise to keep a stable public interface in the C++ APIs.

clang-tools-extra/clangd/AST.cpp

public:
   bool VisitFunctionDecl(FunctionDecl *D) {
     if (!D->getTypeSourceInfo())
       return true;
     // Loc of auto in return type (c++14).
     auto CurLoc = D->getReturnTypeSourceRange().getBegin();
     // Loc of "auto" in operator auto()
     if (CurLoc.isInvalid() && dyn_cast<CXXConversionDecl>(D))
       CurLoc = D->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
-    // Loc of "auto" in function with traling return type (c++11).
+    // Loc of "auto" in function with trailing return type (c++11).
     if (CurLoc.isInvalid())
       CurLoc = D->getSourceRange().getBegin();
     if (CurLoc != SearchedLocation)
       return true;
 
     const AutoType *AT = D->getReturnType()->getContainedAutoType();
     if (AT && !AT->getDeducedType().isNull()) {
       DeducedType = AT->getDeducedType();

clang-tools-extra/clangd/ClangdServer.cpp

auto Action = [Pos, CB = std::move(CB),
     CB(clangd::locateSymbolAt(InpAST->AST, Pos, Index));
   };
 
   WorkScheduler.runWithAST("Definitions", File, std::move(Action));
 }
 
 void ClangdServer::switchSourceHeader(
     PathRef Path, Callback<llvm::Optional<clangd::Path>> CB) {
-  // We want to return the result as fast as possible, stragety is:
+  // We want to return the result as fast as possible, strategy is:
   //  1) use the file-only heuristic, it requires some IO but it is much
   //     faster than building AST, but it only works when .h/.cc files are in
   //     the same directory.
   //  2) if 1) fails, we use the AST&Index approach, it is slower but supports
   //     different code layout.
   if (auto CorrespondingFile =
           getCorrespondingHeaderOrSource(Path, FSProvider.getFileSystem()))
     return CB(std::move(CorrespondingFile));

clang-tools-extra/clangd/CodeComplete.cpp

 
 private:
   struct BundledEntry {
     std::string SnippetSuffix;
     std::string Signature;
     std::string ReturnType;
   };
 
-  // If all BundledEntrys have the same value for a property, return it.
+  // If all BundledEntries have the same value for a property, return it.
   template <std::string BundledEntry::*Member>
   const std::string *onlyValue() const {
     auto B = Bundled.begin(), E = Bundled.end();
     for (auto I = B + 1; I != E; ++I)
       if (I->*Member != B->*Member)
         return nullptr;
     return &(B->*Member);
   }
llvm::Optional<SymbolID> getSymbolID(const CodeCompletionResult &R,
   case CodeCompletionResult::RK_Macro:
     return clang::clangd::getSymbolID(R.Macro->getName(), R.MacroDefInfo, SM);
   case CodeCompletionResult::RK_Keyword:
     return None;
   }
   llvm_unreachable("unknown CodeCompletionResult kind");
 }
 
-// Scopes of the paritial identifier we're trying to complete.
+// Scopes of the partial identifier we're trying to complete.
 // It is used when we query the index for more completion results.
 struct SpecifiedScope {
   // The scopes we should look in, determined by Sema.
   //
   // If the qualifier was fully resolved, we look for completions in these
   // scopes; if there is an unresolved part of the qualifier, it should be
   // resolved within these scopes.
   //
void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
     llvm::sort(ScoredSignatures, [](const ScoredSignature &L,
                                     const ScoredSignature &R) {
       // Ordering follows:
       // - Less number of parameters is better.
       // - Function is better than FunctionType which is better than
       // Function Template.
       // - High score is better.
       // - Shorter signature is better.
-      // - Alphebatically smaller is better.
+      // - Alphabetically smaller is better.
       if (L.Quality.NumberOfParameters != R.Quality.NumberOfParameters)
         return L.Quality.NumberOfParameters < R.Quality.NumberOfParameters;
       if (L.Quality.NumberOfOptionalParameters !=
           R.Quality.NumberOfOptionalParameters)
         return L.Quality.NumberOfOptionalParameters <
                R.Quality.NumberOfOptionalParameters;
       if (L.Quality.Kind != R.Quality.Kind) {
         using OC = CodeCompleteConsumer::OverloadCandidate;
SymbolSlab queryIndex() {
     SymbolSlab::Builder ResultsBuilder;
     if (Opts.Index->fuzzyFind(
             Req, [&](const Symbol &Sym) { ResultsBuilder.insert(Sym); }))
       Incomplete = true;
     return std::move(ResultsBuilder).build();
   }
 
   // Merges Sema and Index results where possible, to form CompletionCandidates.
-  // \p Identifiers is raw idenfiers that can also be completion condidates.
+  // \p Identifiers is raw idenfiers that can also be completion candidates.
   // Identifiers are not merged with results from index or sema.
   // Groups overloads if desired, to form CompletionCandidate::Bundles. The
   // bundles are scored and top results are returned, best to worst.
   std::vector<ScoredBundle>
   mergeResults(const std::vector<CodeCompletionResult> &SemaResults,
                const SymbolSlab &IndexResults,
                const std::vector<RawIdentifier> &IdentifierResults) {
     trace::Span Tracer("Merge and score results");

clang-tools-extra/clangd/Diagnostics.h

struct ClangdDiagnosticOptions {
   /// message.
   bool DisplayFixesCount = true;
 };
 
 /// Contains basic information about a diagnostic.
 struct DiagBase {
   std::string Message;
   // Intended to be used only in error messages.
-  // May be relative, absolute or even artifically constructed.
+  // May be relative, absolute or even artificially constructed.
   std::string File;
   // Absolute path to containing file, if available.
   llvm::Optional<std::string> AbsFile;
 
   clangd::Range Range;
   DiagnosticsEngine::Level Severity = DiagnosticsEngine::Note;
   std::string Category;
   // Since File is only descriptive, we store a separate flag to distinguish

clang-tools-extra/clangd/Diagnostics.cpp

 /// Capitalizes the first word in the diagnostic's message.
 std::string capitalize(std::string Message) {
   if (!Message.empty())
     Message[0] = llvm::toUpper(Message[0]);
   return Message;
 }
 
 /// Returns a message sent to LSP for the main diagnostic in \p D.
-/// This message may include notes, if they're not emited in some other way.
+/// This message may include notes, if they're not emitted in some other way.
 /// Example output:
 ///
 ///     no matching function for call to 'foo'
 ///
 ///     main.cpp:3:5: note: candidate function not viable: requires 2 arguments
 ///
 ///     dir1/dir2/dir3/../../dir4/header.h:12:23
 ///     note: candidate function not viable: requires 3 arguments

clang-tools-extra/clangd/FindTarget.cpp

llvm::SmallVector<ReferenceLoc, 2> refInTypeLoc(TypeLoc L) {
 
   Visitor V;
   V.Visit(L.getUnqualifiedLoc());
   if (!V.Ref)
     return {};
   return {*V.Ref};
 }
 
-class ExplicitReferenceColletor
-    : public RecursiveASTVisitor<ExplicitReferenceColletor> {
+class ExplicitReferenceCollector
+    : public RecursiveASTVisitor<ExplicitReferenceCollector> {
 public:
-  ExplicitReferenceColletor(llvm::function_ref<void(ReferenceLoc)> Out)
+  ExplicitReferenceCollector(llvm::function_ref<void(ReferenceLoc)> Out)
       : Out(Out) {
     assert(Out);
   }
 
   bool VisitTypeLoc(TypeLoc TTL) {
     if (TypeLocsToSkip.count(TTL.getBeginLoc().getRawEncoding()))
       return true;
     visitNode(DynTypedNode::create(TTL));
private:
   /// TraverseElaboratedTypeSpecifierLoc for details.
   llvm::DenseSet</*SourceLocation*/ unsigned> TypeLocsToSkip;
 };
 } // namespace
 
 void findExplicitReferences(const Stmt *S,
                             llvm::function_ref<void(ReferenceLoc)> Out) {
   assert(S);
-  ExplicitReferenceColletor(Out).TraverseStmt(const_cast<Stmt *>(S));
+  ExplicitReferenceCollector(Out).TraverseStmt(const_cast<Stmt *>(S));
 }
 void findExplicitReferences(const Decl *D,
                             llvm::function_ref<void(ReferenceLoc)> Out) {
   assert(D);
-  ExplicitReferenceColletor(Out).TraverseDecl(const_cast<Decl *>(D));
+  ExplicitReferenceCollector(Out).TraverseDecl(const_cast<Decl *>(D));
 }
 void findExplicitReferences(const ASTContext &AST,
                             llvm::function_ref<void(ReferenceLoc)> Out) {
-  ExplicitReferenceColletor(Out).TraverseAST(const_cast<ASTContext &>(AST));
+  ExplicitReferenceCollector(Out).TraverseAST(const_cast<ASTContext &>(AST));
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, DeclRelation R) {
   switch (R) {
 #define REL_CASE(X)                                                            \
   case DeclRelation::X:                                                        \
     return OS << #X;
     REL_CASE(Alias);

clang-tools-extra/clangd/FormattedString.cpp

 namespace clang {
 namespace clangd {
 namespace markup {
 
 namespace {
 /// Escape a markdown text block. Ensures the punctuation will not introduce
 /// any of the markdown constructs.
 std::string renderText(llvm::StringRef Input) {
-  // Escaping ASCII punctiation ensures we can't start a markdown construct.
+  // Escaping ASCII punctuation ensures we can't start a markdown construct.
   constexpr llvm::StringLiteral Punctuation =
       R"txt(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)txt";
 
   std::string R;
   for (size_t From = 0; From < Input.size();) {
     size_t Next = Input.find_first_of(Punctuation, From);
     R += Input.substr(From, Next - From);
     if (Next == llvm::StringRef::npos)
for (char C : Input) {
     MaxBackticks = std::max(MaxBackticks, Backticks);
     Backticks = 0;
   }
   MaxBackticks = std::max(Backticks, MaxBackticks);
   // Use the corresponding number of backticks to start and end a code block.
   return std::string(/*Repeat=*/std::max(3u, MaxBackticks + 1), '`');
 }
 
-// Trims the input and concatanates whitespace blocks into a single ` `.
+// Trims the input and concatenates whitespace blocks into a single ` `.
 std::string canonicalizeSpaces(std::string Input) {
   // Goes over the string and preserves only a single ` ` for any whitespace
   // chunks, the rest is moved to the end of the string and dropped in the end.
   auto WritePtr = Input.begin();
   llvm::SmallVector<llvm::StringRef, 4> Words;
   llvm::SplitString(Input, Words);
   if (Words.empty())
     return "";
-  // Go over each word and and add it to the string.
+  // Go over each word and add it to the string.
   for (llvm::StringRef Word : Words) {
     llvm::for_each(Word, [&WritePtr](const char C) { *WritePtr++ = C; });
     // Separate from next block.
     *WritePtr++ = ' ';
   }
   // Get rid of extra spaces, -1 is for the trailing space introduced with last
   // word.
   Input.resize(WritePtr - Input.begin() - 1);

clang-tools-extra/clangd/TUScheduler.cpp

auto Task = [=]() mutable {
     }
 
     // We only need to build the AST if diagnostics were requested.
     if (WantDiags == WantDiagnostics::No)
       return;
 
     {
       std::lock_guard<std::mutex> Lock(PublishMu);
-      // No need to rebuild the AST if we won't send the diagnotics. However,
+      // No need to rebuild the AST if we won't send the diagnostics. However,
       // note that we don't prevent preamble rebuilds.
       if (!CanPublishResults)
         return;
     }
 
     // Get the AST for diagnostics.
     llvm::Optional<std::unique_ptr<ParsedAST>> AST = IdleASTs.take(this);
     if (!AST) {

clang-tools-extra/clangd/Transport.h

public:
     virtual bool onNotify(llvm::StringRef Method, llvm::json::Value) = 0;
     virtual bool onCall(llvm::StringRef Method, llvm::json::Value Params,
                         llvm::json::Value ID) = 0;
     virtual bool onReply(llvm::json::Value ID,
                          llvm::Expected<llvm::json::Value> Result) = 0;
   };
   // Called by Clangd to receive messages from the client.
   // The transport should in turn invoke the handler to process messages.
-  // If handler returns false, the transport should immedately exit the loop.
+  // If handler returns false, the transport should immediately exit the loop.
   // (This is used to implement the `exit` notification).
   // Otherwise, it returns an error when the transport becomes unusable.
   virtual llvm::Error loop(MessageHandler &) = 0;
 };
 
 // Controls the way JSON-RPC messages are encoded (both input and output).
 enum JSONStreamStyle {
   // Encoding per the LSP specification, with mandatory Content-Length header.

clang-tools-extra/clangd/XRefs.cpp

SymbolLocation toIndexLocation(const Location &Loc, std::string &URIStorage) {
   return SymLoc;
 }
 
 // Returns the preferred location between an AST location and an index location.
 SymbolLocation getPreferredLocation(const Location &ASTLoc,
                                     const SymbolLocation &IdxLoc,
                                     std::string &Scratch) {
   // Also use a dummy symbol for the index location so that other fields (e.g.
-  // definition) are not factored into the preferrence.
+  // definition) are not factored into the preference.
   Symbol ASTSym, IdxSym;
   ASTSym.ID = IdxSym.ID = SymbolID("dummy_id");
   ASTSym.CanonicalDeclaration = toIndexLocation(ASTLoc, Scratch);
   IdxSym.CanonicalDeclaration = IdxLoc;
   auto Merged = mergeSymbol(ASTSym, IdxSym);
   return Merged.CanonicalDeclaration;
 }
 
References.erase(std::unique(References.begin(), References.end(),
                                    return std::tie(L.Loc, L.Role) ==
                                           std::tie(R.Loc, R.Role);
                                  }),
                      References.end());
     return std::move(References);
   }
 
   bool
-  handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles,
+  handleDeclOccurrence(const Decl *D, index::SymbolRoleSet Roles,
                        llvm::ArrayRef<index::SymbolRelation> Relations,
                        SourceLocation Loc,
                        index::IndexDataConsumer::ASTNodeInfo ASTNode) override {
     assert(D->isCanonicalDecl() && "expect D to be a canonical declaration");
     const SourceManager &SM = AST.getSourceManager();
     Loc = SM.getFileLoc(Loc);
     if (isInsideMainFile(Loc, SM) && CanonicalTargets.count(D))
       References.push_back({Loc, Roles});
     return true;
   }
 

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

 //===--- FileIndex.h - Index for files. ---------------------------- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // FileIndex implements SymbolIndex for symbols from a set of files. Symbols are
-// maintained at source-file granuality (e.g. with ASTs), and files can be
+// maintained at source-file granularity (e.g. with ASTs), and files can be
 // updated dynamically.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_FILEINDEX_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_INDEX_FILEINDEX_H
 
 #include "Index.h"

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

public:
 
   void initialize(ASTContext &Ctx) override;
 
   void setPreprocessor(std::shared_ptr<Preprocessor> PP) override {
     this->PP = std::move(PP);
   }
 
   bool
-  handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles,
+  handleDeclOccurrence(const Decl *D, index::SymbolRoleSet Roles,
                        ArrayRef<index::SymbolRelation> Relations,
                        SourceLocation Loc,
                        index::IndexDataConsumer::ASTNodeInfo ASTNode) override;
 
-  bool handleMacroOccurence(const IdentifierInfo *Name, const MacroInfo *MI,
+  bool handleMacroOccurrence(const IdentifierInfo *Name, const MacroInfo *MI,
                              index::SymbolRoleSet Roles,
                              SourceLocation Loc) override;
 
   SymbolSlab takeSymbols() { return std::move(Symbols).build(); }
   RefSlab takeRefs() { return std::move(Refs).build(); }
   RelationSlab takeRelations() { return std::move(Relations).build(); }
 
   /// Returns true if we are interested in references and declarations from \p
   /// FID. If this function return false, bodies of functions inside those files
   /// will be skipped to decrease indexing time.

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

bool SymbolCollector::shouldCollectSymbol(const NamedDecl &ND,
 
   // Avoid indexing internal symbols in protobuf generated headers.
   if (isPrivateProtoDecl(ND))
     return false;
   return true;
 }
 
 // Always return true to continue indexing.
-bool SymbolCollector::handleDeclOccurence(
+bool SymbolCollector::handleDeclOccurrence(
     const Decl *D, index::SymbolRoleSet Roles,
     llvm::ArrayRef<index::SymbolRelation> Relations, SourceLocation Loc,
     index::IndexDataConsumer::ASTNodeInfo ASTNode) {
   assert(ASTCtx && PP.get() && "ASTContext and Preprocessor must be set.");
   assert(CompletionAllocator && CompletionTUInfo);
   assert(ASTNode.OrigD);
-  // Indexing API puts cannonical decl into D, which might not have a valid
+  // Indexing API puts canonical decl into D, which might not have a valid
   // source location for implicit/built-in decls. Fallback to original decl in
   // such cases.
   if (D->getLocation().isInvalid())
     D = ASTNode.OrigD;
   // If OrigD is an declaration associated with a friend declaration and it's
   // not a definition, skip it. Note that OrigD is the occurrence that the
   // collector is currently visiting.
   if ((ASTNode.OrigD->getFriendObjectKind() !=
else if (isPreferredDeclaration(*OriginalDecl, Roles))
     BasicSymbol = addDeclaration(*OriginalDecl, std::move(*ID), IsMainFileOnly);
 
   if (Roles & static_cast<unsigned>(index::SymbolRole::Definition))
     addDefinition(*OriginalDecl, *BasicSymbol);
 
   return true;
 }
 
-bool SymbolCollector::handleMacroOccurence(const IdentifierInfo *Name,
+bool SymbolCollector::handleMacroOccurrence(const IdentifierInfo *Name,
                                             const MacroInfo *MI,
                                             index::SymbolRoleSet Roles,
                                             SourceLocation Loc) {
   assert(PP.get());
 
   const auto &SM = PP->getSourceManager();
   auto DefLoc = MI->getDefinitionLoc();
   auto SpellingLoc = SM.getSpellingLoc(Loc);
   bool IsMainFileSymbol = SM.isInMainFile(SM.getExpansionLoc(DefLoc));
 
   // Builtin macros don't have useful locations and aren't needed in completion.
void SymbolCollector::finish() {
   llvm::DenseMap<FileID, std::string> URICache;
   auto GetURI = [&](FileID FID) -> llvm::Optional<std::string> {
     auto Found = URICache.find(FID);
     if (Found == URICache.end()) {
       if (auto *FileEntry = SM.getFileEntryForID(FID)) {
         auto FileURI = toURI(SM, FileEntry->getName(), Opts);
         Found = URICache.insert({FID, FileURI}).first;
       } else {
-        // Ignore cases where we can not find a corresponding file entry
-        // for the loc, thoses are not interesting, e.g. symbols formed
-        // via macro concatenation.
+        // Ignore cases where we can not find a corresponding file entry for
+        // given location, e.g. symbols formed via macro concatenation.
         return None;
       }
     }
     return Found->second;
   };
   auto CollectRef =
       [&](SymbolID ID,
           const std::pair<SourceLocation, index::SymbolRoleSet> &LocAndRole) {

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

if (!AffectedFileCode) {
       elog("Fail to read file content: {0}", AffectedFileCode.takeError());
       continue;
     }
     auto RenameRanges =
         adjustRenameRanges(*AffectedFileCode, RenameDecl.getNameAsString(),
                            std::move(FileAndOccurrences.second),
                            RenameDecl.getASTContext().getLangOpts());
     if (!RenameRanges) {
-      // Our heuristice fails to adjust rename ranges to the current state of
+      // Our heuristics fails to adjust rename ranges to the current state of
       // the file, it is most likely the index is stale, so we give up the
       // entire rename.
       return llvm::make_error<llvm::StringError>(
           llvm::formatv("Index results don't match the content of file {0} "
                         "(the index may be stale)",
                         FilePath),
           llvm::inconvertibleErrorCode());
     }
     auto RenameEdit =
         buildRenameEdit(FilePath, *AffectedFileCode, *RenameRanges, NewName);
     if (!RenameEdit) {
       return llvm::make_error<llvm::StringError>(
           llvm::formatv("fail to build rename edit for file {0}: {1}", FilePath,
                         llvm::toString(RenameEdit.takeError())),
           llvm::inconvertibleErrorCode());
     }
     if (!RenameEdit->Replacements.empty())
       Results.insert({FilePath, std::move(*RenameEdit)});
   }
   return Results;
 }
 
-// A simple edit is eithor changing line or column, but not both.
+// A simple edit is either changing line or column, but not both.
 bool impliesSimpleEdit(const Position &LHS, const Position &RHS) {
   return LHS.line == RHS.line || LHS.character == RHS.character;
 }
 
 // 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

clang/include/clang/Index/IndexDataConsumer.h

public:
 
   virtual ~IndexDataConsumer() = default;
 
   virtual void initialize(ASTContext &Ctx) {}
 
   virtual void setPreprocessor(std::shared_ptr<Preprocessor> PP) {}
 
   /// \returns true to continue indexing, or false to abort.
-  virtual bool handleDeclOccurence(const Decl *D, SymbolRoleSet Roles,
+  virtual bool handleDeclOccurrence(const Decl *D, SymbolRoleSet Roles,
                                     ArrayRef<SymbolRelation> Relations,
                                     SourceLocation Loc, ASTNodeInfo ASTNode) {
     return true;
   }
 
   /// \returns true to continue indexing, or false to abort.
-  virtual bool handleMacroOccurence(const IdentifierInfo *Name,
+  virtual bool handleMacroOccurrence(const IdentifierInfo *Name,
                                      const MacroInfo *MI, SymbolRoleSet Roles,
                                      SourceLocation Loc) {
     return true;
   }
 
   /// \returns true to continue indexing, or false to abort.
   ///
   /// This will be called for each module reference in an import decl.
   /// For "@import MyMod.SubMod", there will be a call for 'MyMod' with the
   /// 'reference' role, and a call for 'SubMod' with the 'declaration' role.
-  virtual bool handleModuleOccurence(const ImportDecl *ImportD,
+  virtual bool handleModuleOccurrence(const ImportDecl *ImportD,
                                       const Module *Mod, SymbolRoleSet Roles,
                                       SourceLocation Loc) {
     return true;
   }
 
   virtual void finish() {}
 };
 
 } // namespace index
 } // namespace clang
 
 #endif

clang/lib/Index/IndexingAction.cpp

 static void indexTranslationUnit(ASTUnit &Unit, IndexingContext &IndexCtx) {
   Unit.visitLocalTopLevelDecls(&IndexCtx, topLevelDeclVisitor);
 }
 
 static void indexPreprocessorMacros(const Preprocessor &PP,
                                     IndexDataConsumer &DataConsumer) {
   for (const auto &M : PP.macros())
     if (MacroDirective *MD = M.second.getLatest())
-      DataConsumer.handleMacroOccurence(
+      DataConsumer.handleMacroOccurrence(
           M.first, MD->getMacroInfo(),
           static_cast<unsigned>(index::SymbolRole::Definition),
           MD->getLocation());
 }
 
 void index::indexASTUnit(ASTUnit &Unit, IndexDataConsumer &DataConsumer,
                          IndexingOptions Opts) {
   IndexingContext IndexCtx(Opts, DataConsumer);

clang/lib/Index/IndexingContext.cpp

 static void reportModuleReferences(const Module *Mod,
                                    ArrayRef<SourceLocation> IdLocs,
                                    const ImportDecl *ImportD,
                                    IndexDataConsumer &DataConsumer) {
   if (!Mod)
     return;
   reportModuleReferences(Mod->Parent, IdLocs.drop_back(), ImportD,
                          DataConsumer);
-  DataConsumer.handleModuleOccurence(ImportD, Mod,
-                                     (SymbolRoleSet)SymbolRole::Reference,
-                                     IdLocs.back());
+  DataConsumer.handleModuleOccurrence(
+      ImportD, Mod, (SymbolRoleSet)SymbolRole::Reference, IdLocs.back());
 }
 
 bool IndexingContext::importedModule(const ImportDecl *ImportD) {
   if (ImportD->isInvalidDecl())
     return true;
 
   SourceLocation Loc;
   auto IdLocs = ImportD->getIdentifierLocs();
if (!ImportD->isImplicit() && Mod->Parent && !IdLocs.empty()) {
     reportModuleReferences(Mod->Parent, IdLocs.drop_back(), ImportD,
                            DataConsumer);
   }
 
   SymbolRoleSet Roles = (unsigned)SymbolRole::Declaration;
   if (ImportD->isImplicit())
     Roles |= (unsigned)SymbolRole::Implicit;
 
-  return DataConsumer.handleModuleOccurence(ImportD, Mod, Roles, Loc);
+  return DataConsumer.handleModuleOccurrence(ImportD, Mod, Roles, Loc);
 }
 
 bool IndexingContext::isTemplateImplicitInstantiation(const Decl *D) {
   TemplateSpecializationKind TKind = TSK_Undeclared;
   if (const ClassTemplateSpecializationDecl *
       SD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
     TKind = SD->getSpecializationKind();
   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
bool IndexingContext::handleDeclOccurrence(const Decl *D, SourceLocation Loc,
   }
 
   for (auto &Rel : Relations) {
     addRelation(SymbolRelation(Rel.Roles,
                                Rel.RelatedSymbol->getCanonicalDecl()));
   }
 
   IndexDataConsumer::ASTNodeInfo Node{OrigE, OrigD, Parent, ContainerDC};
-  return DataConsumer.handleDeclOccurence(D, Roles, FinalRelations, Loc, Node);
+  return DataConsumer.handleDeclOccurrence(D, Roles, FinalRelations, Loc, Node);
 }
 
 void IndexingContext::handleMacroDefined(const IdentifierInfo &Name,
                                          SourceLocation Loc,
                                          const MacroInfo &MI) {
   SymbolRoleSet Roles = (unsigned)SymbolRole::Definition;
-  DataConsumer.handleMacroOccurence(&Name, &MI, Roles, Loc);
+  DataConsumer.handleMacroOccurrence(&Name, &MI, Roles, Loc);
 }
 
 void IndexingContext::handleMacroUndefined(const IdentifierInfo &Name,
                                            SourceLocation Loc,
                                            const MacroInfo &MI) {
   SymbolRoleSet Roles = (unsigned)SymbolRole::Undefinition;
-  DataConsumer.handleMacroOccurence(&Name, &MI, Roles, Loc);
+  DataConsumer.handleMacroOccurrence(&Name, &MI, Roles, Loc);
 }
 
 void IndexingContext::handleMacroReference(const IdentifierInfo &Name,
                                            SourceLocation Loc,
                                            const MacroInfo &MI) {
   SymbolRoleSet Roles = (unsigned)SymbolRole::Reference;
-  DataConsumer.handleMacroOccurence(&Name, &MI, Roles, Loc);
+  DataConsumer.handleMacroOccurrence(&Name, &MI, Roles, Loc);
 }

clang/tools/c-index-test/core_main.cpp

public:
   void initialize(ASTContext &Ctx) override {
     ASTNameGen.reset(new ASTNameGenerator(Ctx));
   }
 
   void setPreprocessor(std::shared_ptr<Preprocessor> PP) override {
     this->PP = std::move(PP);
   }
 
-  bool handleDeclOccurence(const Decl *D, SymbolRoleSet Roles,
+  bool handleDeclOccurrence(const Decl *D, SymbolRoleSet Roles,
                             ArrayRef<SymbolRelation> Relations,
                             SourceLocation Loc, ASTNodeInfo ASTNode) override {
     ASTContext &Ctx = D->getASTContext();
     SourceManager &SM = Ctx.getSourceManager();
 
     Loc = SM.getFileLoc(Loc);
     FileID FID = SM.getFileID(Loc);
     unsigned Line = SM.getLineNumber(FID, SM.getFileOffset(Loc));
     unsigned Col = SM.getColumnNumber(FID, SM.getFileOffset(Loc));
     OS << Line << ':' << Col << " | ";
for (auto &SymRel : Relations) {
       OS << " | ";
       printSymbolNameAndUSR(SymRel.RelatedSymbol, Ctx, OS);
       OS << '\n';
     }
 
     return true;
   }
 
-  bool handleModuleOccurence(const ImportDecl *ImportD,
-                             const clang::Module *Mod,
-                             SymbolRoleSet Roles, SourceLocation Loc) override {
+  bool handleModuleOccurrence(const ImportDecl *ImportD,
+                              const clang::Module *Mod, SymbolRoleSet Roles,
+                              SourceLocation Loc) override {
     ASTContext &Ctx = ImportD->getASTContext();
     SourceManager &SM = Ctx.getSourceManager();
 
     Loc = SM.getFileLoc(Loc);
     FileID FID = SM.getFileID(Loc);
     unsigned Line = SM.getLineNumber(FID, SM.getFileOffset(Loc));
     unsigned Col = SM.getColumnNumber(FID, SM.getFileOffset(Loc));
     OS << Line << ':' << Col << " | ";
 
     printSymbolInfo(getSymbolInfo(ImportD), OS);
     OS << " | ";
 
     printSymbolNameAndUSR(Mod, OS);
     OS << " | ";
 
     printSymbolRoles(Roles, OS);
     OS << " |\n";
 
     return true;
   }
 
-  bool handleMacroOccurence(const IdentifierInfo *Name, const MacroInfo *MI,
+  bool handleMacroOccurrence(const IdentifierInfo *Name, const MacroInfo *MI,
                              SymbolRoleSet Roles, SourceLocation Loc) override {
     assert(PP);
     SourceManager &SM = PP->getSourceManager();
 
     Loc = SM.getFileLoc(Loc);
     FileID FID = SM.getFileID(Loc);
     unsigned Line = SM.getLineNumber(FID, SM.getFileOffset(Loc));
     unsigned Col = SM.getColumnNumber(FID, SM.getFileOffset(Loc));
     OS << Line << ':' << Col << " | ";

clang/tools/libclang/CXIndexDataConsumer.h

public:
   void addContainerInMap(const DeclContext *DC, CXIdxClientContainer container);
 
   CXIdxClientEntity getClientEntity(const Decl *D) const;
   void setClientEntity(const Decl *D, CXIdxClientEntity client);
 
   static bool isTemplateImplicitInstantiation(const Decl *D);
 
 private:
-  bool handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles,
+  bool handleDeclOccurrence(const Decl *D, index::SymbolRoleSet Roles,
                             ArrayRef<index::SymbolRelation> Relations,
                             SourceLocation Loc, ASTNodeInfo ASTNode) override;
 
-  bool handleModuleOccurence(const ImportDecl *ImportD, const Module *Mod,
+  bool handleModuleOccurrence(const ImportDecl *ImportD, const Module *Mod,
                               index::SymbolRoleSet Roles,
                               SourceLocation Loc) override;
 
   void finish() override;
 
   bool handleDecl(const NamedDecl *D,
                   SourceLocation Loc, CXCursor Cursor,
                   DeclInfo &DInfo,
                   const DeclContext *LexicalDC = nullptr,
                   const DeclContext *SemaDC = nullptr);

clang/tools/libclang/CXIndexDataConsumer.cpp

 };
 
 CXSymbolRole getSymbolRole(SymbolRoleSet Role) {
   // CXSymbolRole mirrors low 9 bits of clang::index::SymbolRole.
   return CXSymbolRole(static_cast<uint32_t>(Role) & ((1 << 9) - 1));
 }
 }
 
-bool CXIndexDataConsumer::handleDeclOccurence(
+bool CXIndexDataConsumer::handleDeclOccurrence(
     const Decl *D, SymbolRoleSet Roles, ArrayRef<SymbolRelation> Relations,
     SourceLocation Loc, ASTNodeInfo ASTNode) {
   Loc = getASTContext().getSourceManager().getFileLoc(Loc);
 
   if (Roles & (unsigned)SymbolRole::Reference) {
     const NamedDecl *ND = dyn_cast<NamedDecl>(D);
     if (!ND)
       return true;
if (!LexicalDC) {
       }
     }
     IndexingDeclVisitor(*this, Loc, LexicalDC).Visit(ASTNode.OrigD);
   }
 
   return !shouldAbort();
 }
 
-bool CXIndexDataConsumer::handleModuleOccurence(const ImportDecl *ImportD,
+bool CXIndexDataConsumer::handleModuleOccurrence(const ImportDecl *ImportD,
                                                  const Module *Mod,
                                                  SymbolRoleSet Roles,
                                                  SourceLocation Loc) {
   if (Roles & (SymbolRoleSet)SymbolRole::Declaration)
     IndexingDeclVisitor(*this, SourceLocation(), nullptr).Visit(ImportD);
   return !shouldAbort();
 }
 
 void CXIndexDataConsumer::finish() {
   indexDiagnostics();
 }

clang/unittests/Index/IndexTests.cpp

 
 class Indexer : public IndexDataConsumer {
 public:
   void initialize(ASTContext &Ctx) override {
     AST = &Ctx;
     IndexDataConsumer::initialize(Ctx);
   }
 
-  bool handleDeclOccurence(const Decl *D, SymbolRoleSet Roles,
+  bool handleDeclOccurrence(const Decl *D, SymbolRoleSet Roles,
                             ArrayRef<SymbolRelation>, SourceLocation Loc,
                             ASTNodeInfo) override {
     const auto *ND = llvm::dyn_cast<NamedDecl>(D);
     if (!ND)
       return true;
     TestSymbol S;
     S.SymInfo = getSymbolInfo(D);
     S.QName = ND->getQualifiedNameAsString();
     S.WrittenPos = Position::fromSourceLocation(Loc, AST->getSourceManager());
     S.DeclPos =
         Position::fromSourceLocation(D->getLocation(), AST->getSourceManager());
     S.Roles = Roles;
     Symbols.push_back(std::move(S));
     return true;
   }
 
-  bool handleMacroOccurence(const IdentifierInfo *Name, const MacroInfo *MI,
+  bool handleMacroOccurrence(const IdentifierInfo *Name, const MacroInfo *MI,
                              SymbolRoleSet Roles, SourceLocation Loc) override {
     TestSymbol S;
     S.SymInfo = getSymbolInfoForMacro(*MI);
     S.QName = Name->getName();
     S.WrittenPos = Position::fromSourceLocation(Loc, AST->getSourceManager());
     S.DeclPos = Position::fromSourceLocation(MI->getDefinitionLoc(),
                                              AST->getSourceManager());
     S.Roles = Roles;
     Symbols.push_back(std::move(S));