forked from OSchip/llvm-project
236 lines
8.3 KiB
C++
236 lines
8.3 KiB
C++
//===- IndexingAction.cpp - Frontend index action -------------------------===//
|
|
//
|
|
// 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 "clang/Index/IndexingAction.h"
|
|
#include "IndexingContext.h"
|
|
#include "clang/Frontend/CompilerInstance.h"
|
|
#include "clang/Frontend/FrontendAction.h"
|
|
#include "clang/Frontend/MultiplexConsumer.h"
|
|
#include "clang/Index/IndexDataConsumer.h"
|
|
#include "clang/Lex/PPCallbacks.h"
|
|
#include "clang/Lex/Preprocessor.h"
|
|
#include "clang/Serialization/ASTReader.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include <memory>
|
|
|
|
using namespace clang;
|
|
using namespace clang::index;
|
|
|
|
namespace {
|
|
|
|
class IndexPPCallbacks final : public PPCallbacks {
|
|
std::shared_ptr<IndexingContext> IndexCtx;
|
|
|
|
public:
|
|
IndexPPCallbacks(std::shared_ptr<IndexingContext> IndexCtx)
|
|
: IndexCtx(std::move(IndexCtx)) {}
|
|
|
|
void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
|
|
SourceRange Range, const MacroArgs *Args) override {
|
|
IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
|
|
Range.getBegin(), *MD.getMacroInfo());
|
|
}
|
|
|
|
void MacroDefined(const Token &MacroNameTok,
|
|
const MacroDirective *MD) override {
|
|
IndexCtx->handleMacroDefined(*MacroNameTok.getIdentifierInfo(),
|
|
MacroNameTok.getLocation(),
|
|
*MD->getMacroInfo());
|
|
}
|
|
|
|
void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
|
|
const MacroDirective *Undef) override {
|
|
if (!MD.getMacroInfo()) // Ignore noop #undef.
|
|
return;
|
|
IndexCtx->handleMacroUndefined(*MacroNameTok.getIdentifierInfo(),
|
|
MacroNameTok.getLocation(),
|
|
*MD.getMacroInfo());
|
|
}
|
|
};
|
|
|
|
class IndexASTConsumer final : public ASTConsumer {
|
|
std::shared_ptr<IndexDataConsumer> DataConsumer;
|
|
std::shared_ptr<IndexingContext> IndexCtx;
|
|
std::shared_ptr<Preprocessor> PP;
|
|
std::function<bool(const Decl *)> ShouldSkipFunctionBody;
|
|
|
|
public:
|
|
IndexASTConsumer(std::shared_ptr<IndexDataConsumer> DataConsumer,
|
|
const IndexingOptions &Opts,
|
|
std::shared_ptr<Preprocessor> PP,
|
|
std::function<bool(const Decl *)> ShouldSkipFunctionBody)
|
|
: DataConsumer(std::move(DataConsumer)),
|
|
IndexCtx(new IndexingContext(Opts, *this->DataConsumer)),
|
|
PP(std::move(PP)),
|
|
ShouldSkipFunctionBody(std::move(ShouldSkipFunctionBody)) {
|
|
assert(this->DataConsumer != nullptr);
|
|
assert(this->PP != nullptr);
|
|
}
|
|
|
|
protected:
|
|
void Initialize(ASTContext &Context) override {
|
|
IndexCtx->setASTContext(Context);
|
|
IndexCtx->getDataConsumer().initialize(Context);
|
|
IndexCtx->getDataConsumer().setPreprocessor(PP);
|
|
PP->addPPCallbacks(std::make_unique<IndexPPCallbacks>(IndexCtx));
|
|
}
|
|
|
|
bool HandleTopLevelDecl(DeclGroupRef DG) override {
|
|
return IndexCtx->indexDeclGroupRef(DG);
|
|
}
|
|
|
|
void HandleInterestingDecl(DeclGroupRef DG) override {
|
|
// Ignore deserialized decls.
|
|
}
|
|
|
|
void HandleTopLevelDeclInObjCContainer(DeclGroupRef DG) override {
|
|
IndexCtx->indexDeclGroupRef(DG);
|
|
}
|
|
|
|
void HandleTranslationUnit(ASTContext &Ctx) override {
|
|
DataConsumer->finish();
|
|
}
|
|
|
|
bool shouldSkipFunctionBody(Decl *D) override {
|
|
return ShouldSkipFunctionBody(D);
|
|
}
|
|
};
|
|
|
|
class IndexAction final : public ASTFrontendAction {
|
|
std::shared_ptr<IndexDataConsumer> DataConsumer;
|
|
IndexingOptions Opts;
|
|
|
|
public:
|
|
IndexAction(std::shared_ptr<IndexDataConsumer> DataConsumer,
|
|
const IndexingOptions &Opts)
|
|
: DataConsumer(std::move(DataConsumer)), Opts(Opts) {
|
|
assert(this->DataConsumer != nullptr);
|
|
}
|
|
|
|
protected:
|
|
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
|
|
StringRef InFile) override {
|
|
return std::make_unique<IndexASTConsumer>(
|
|
DataConsumer, Opts, CI.getPreprocessorPtr(),
|
|
/*ShouldSkipFunctionBody=*/[](const Decl *) { return false; });
|
|
}
|
|
};
|
|
|
|
} // anonymous namespace
|
|
|
|
std::unique_ptr<ASTConsumer> index::createIndexingASTConsumer(
|
|
std::shared_ptr<IndexDataConsumer> DataConsumer,
|
|
const IndexingOptions &Opts, std::shared_ptr<Preprocessor> PP,
|
|
std::function<bool(const Decl *)> ShouldSkipFunctionBody) {
|
|
return std::make_unique<IndexASTConsumer>(DataConsumer, Opts, PP,
|
|
ShouldSkipFunctionBody);
|
|
}
|
|
|
|
std::unique_ptr<ASTConsumer> clang::index::createIndexingASTConsumer(
|
|
std::shared_ptr<IndexDataConsumer> DataConsumer,
|
|
const IndexingOptions &Opts, std::shared_ptr<Preprocessor> PP) {
|
|
std::function<bool(const Decl *)> ShouldSkipFunctionBody = [](const Decl *) {
|
|
return false;
|
|
};
|
|
if (Opts.ShouldTraverseDecl)
|
|
ShouldSkipFunctionBody =
|
|
[ShouldTraverseDecl(Opts.ShouldTraverseDecl)](const Decl *D) {
|
|
return !ShouldTraverseDecl(D);
|
|
};
|
|
return createIndexingASTConsumer(std::move(DataConsumer), Opts, std::move(PP),
|
|
std::move(ShouldSkipFunctionBody));
|
|
}
|
|
|
|
std::unique_ptr<FrontendAction>
|
|
index::createIndexingAction(std::shared_ptr<IndexDataConsumer> DataConsumer,
|
|
const IndexingOptions &Opts) {
|
|
assert(DataConsumer != nullptr);
|
|
return std::make_unique<IndexAction>(std::move(DataConsumer), Opts);
|
|
}
|
|
|
|
static bool topLevelDeclVisitor(void *context, const Decl *D) {
|
|
IndexingContext &IndexCtx = *static_cast<IndexingContext*>(context);
|
|
return IndexCtx.indexTopLevelDecl(D);
|
|
}
|
|
|
|
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()) {
|
|
auto *MI = MD->getMacroInfo();
|
|
// When using modules, it may happen that we find #undef of a macro that
|
|
// was defined in another module. In such case, MI may be nullptr, since
|
|
// we only look for macro definitions in the current TU. In that case,
|
|
// there is nothing to index.
|
|
if (!MI)
|
|
continue;
|
|
|
|
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);
|
|
IndexCtx.setASTContext(Unit.getASTContext());
|
|
DataConsumer.initialize(Unit.getASTContext());
|
|
DataConsumer.setPreprocessor(Unit.getPreprocessorPtr());
|
|
|
|
if (Opts.IndexMacrosInPreprocessor)
|
|
indexPreprocessorMacros(Unit.getPreprocessor(), DataConsumer);
|
|
indexTranslationUnit(Unit, IndexCtx);
|
|
DataConsumer.finish();
|
|
}
|
|
|
|
void index::indexTopLevelDecls(ASTContext &Ctx, Preprocessor &PP,
|
|
ArrayRef<const Decl *> Decls,
|
|
IndexDataConsumer &DataConsumer,
|
|
IndexingOptions Opts) {
|
|
IndexingContext IndexCtx(Opts, DataConsumer);
|
|
IndexCtx.setASTContext(Ctx);
|
|
|
|
DataConsumer.initialize(Ctx);
|
|
|
|
if (Opts.IndexMacrosInPreprocessor)
|
|
indexPreprocessorMacros(PP, DataConsumer);
|
|
|
|
for (const Decl *D : Decls)
|
|
IndexCtx.indexTopLevelDecl(D);
|
|
DataConsumer.finish();
|
|
}
|
|
|
|
std::unique_ptr<PPCallbacks>
|
|
index::indexMacrosCallback(IndexDataConsumer &Consumer, IndexingOptions Opts) {
|
|
return std::make_unique<IndexPPCallbacks>(
|
|
std::make_shared<IndexingContext>(Opts, Consumer));
|
|
}
|
|
|
|
void index::indexModuleFile(serialization::ModuleFile &Mod, ASTReader &Reader,
|
|
IndexDataConsumer &DataConsumer,
|
|
IndexingOptions Opts) {
|
|
ASTContext &Ctx = Reader.getContext();
|
|
IndexingContext IndexCtx(Opts, DataConsumer);
|
|
IndexCtx.setASTContext(Ctx);
|
|
DataConsumer.initialize(Ctx);
|
|
|
|
if (Opts.IndexMacrosInPreprocessor)
|
|
indexPreprocessorMacros(Reader.getPreprocessor(), DataConsumer);
|
|
|
|
for (const Decl *D : Reader.getModuleFileLevelDecls(Mod)) {
|
|
IndexCtx.indexTopLevelDecl(D);
|
|
}
|
|
DataConsumer.finish();
|
|
}
|