llvm/clang/lib/Index/IndexingContext.cpp

//===- IndexingContext.cpp - Indexing context data ------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "IndexingContext.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Attr.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Index/IndexDataConsumer.h"

usingnamespaceclang;
usingnamespaceindex;

static bool isGeneratedDecl(const Decl *D) { … }

bool IndexingContext::shouldIndex(const Decl *D) { … }

const LangOptions &IndexingContext::getLangOpts() const { … }

bool IndexingContext::shouldIndexFunctionLocalSymbols() const { … }

bool IndexingContext::shouldIndexImplicitInstantiation() const { … }

bool IndexingContext::shouldIndexParametersInDeclarations() const { … }

bool IndexingContext::shouldIndexTemplateParameters() const { … }

bool IndexingContext::handleDecl(const Decl *D,
                                 SymbolRoleSet Roles,
                                 ArrayRef<SymbolRelation> Relations) { … }

bool IndexingContext::handleDecl(const Decl *D, SourceLocation Loc,
                                 SymbolRoleSet Roles,
                                 ArrayRef<SymbolRelation> Relations,
                                 const DeclContext *DC) { … }

bool IndexingContext::handleReference(const NamedDecl *D, SourceLocation Loc,
                                      const NamedDecl *Parent,
                                      const DeclContext *DC,
                                      SymbolRoleSet Roles,
                                      ArrayRef<SymbolRelation> Relations,
                                      const Expr *RefE) { … }

static void reportModuleReferences(const Module *Mod,
                                   ArrayRef<SourceLocation> IdLocs,
                                   const ImportDecl *ImportD,
                                   IndexDataConsumer &DataConsumer) { … }

bool IndexingContext::importedModule(const ImportDecl *ImportD) { … }

bool IndexingContext::isTemplateImplicitInstantiation(const Decl *D) { … }

bool IndexingContext::shouldIgnoreIfImplicit(const Decl *D) { … }

static const CXXRecordDecl *
getDeclContextForTemplateInstationPattern(const Decl *D) { … }

static const Decl *adjustTemplateImplicitInstantiation(const Decl *D) { … }

static bool isDeclADefinition(const Decl *D, const DeclContext *ContainerDC, ASTContext &Ctx) { … }

/// Whether the given NamedDecl should be skipped because it has no name.
static bool shouldSkipNamelessDecl(const NamedDecl *ND) { … }

static const Decl *adjustParent(const Decl *Parent) { … }

static const Decl *getCanonicalDecl(const Decl *D) { … }

static bool shouldReportOccurrenceForSystemDeclOnlyMode(
    bool IsRef, SymbolRoleSet Roles, ArrayRef<SymbolRelation> Relations) { … }

bool IndexingContext::handleDeclOccurrence(const Decl *D, SourceLocation Loc,
                                           bool IsRef, const Decl *Parent,
                                           SymbolRoleSet Roles,
                                           ArrayRef<SymbolRelation> Relations,
                                           const Expr *OrigE,
                                           const Decl *OrigD,
                                           const DeclContext *ContainerDC) { … }

void IndexingContext::handleMacroDefined(const IdentifierInfo &Name,
                                         SourceLocation Loc,
                                         const MacroInfo &MI) { … }

void IndexingContext::handleMacroUndefined(const IdentifierInfo &Name,
                                           SourceLocation Loc,
                                           const MacroInfo &MI) { … }

void IndexingContext::handleMacroReference(const IdentifierInfo &Name,
                                           SourceLocation Loc,
                                           const MacroInfo &MI) { … }

bool IndexingContext::shouldIndexMacroOccurrence(bool IsRef,
                                                 SourceLocation Loc) { … }