1//===- IndexingAction.cpp - Frontend index action -------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "clang/Index/IndexingAction.h"
10#include "IndexingContext.h"
11#include "clang/Frontend/CompilerInstance.h"
12#include "clang/Frontend/FrontendAction.h"
13#include "clang/Frontend/MultiplexConsumer.h"
14#include "clang/Index/IndexDataConsumer.h"
15#include "clang/Lex/PPCallbacks.h"
16#include "clang/Lex/Preprocessor.h"
17#include "clang/Serialization/ASTReader.h"
18#include "llvm/ADT/STLExtras.h"
19#include <memory>
20
21using namespace clang;
22using namespace clang::index;
23
24namespace {
25
26class IndexPPCallbacks final : public PPCallbacks {
27  std::shared_ptr<IndexingContext> IndexCtx;
28
29public:
30  IndexPPCallbacks(std::shared_ptr<IndexingContext> IndexCtx)
31      : IndexCtx(std::move(IndexCtx)) {}
32
33  void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
34                    SourceRange Range, const MacroArgs *Args) override {
35    IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
36                                   Range.getBegin(), *MD.getMacroInfo());
37  }
38
39  void MacroDefined(const Token &MacroNameTok,
40                    const MacroDirective *MD) override {
41    IndexCtx->handleMacroDefined(*MacroNameTok.getIdentifierInfo(),
42                                 MacroNameTok.getLocation(),
43                                 *MD->getMacroInfo());
44  }
45
46  void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
47                      const MacroDirective *Undef) override {
48    if (!MD.getMacroInfo())  // Ignore noop #undef.
49      return;
50    IndexCtx->handleMacroUndefined(*MacroNameTok.getIdentifierInfo(),
51                                   MacroNameTok.getLocation(),
52                                   *MD.getMacroInfo());
53  }
54};
55
56class IndexASTConsumer final : public ASTConsumer {
57  std::shared_ptr<IndexDataConsumer> DataConsumer;
58  std::shared_ptr<IndexingContext> IndexCtx;
59  std::shared_ptr<Preprocessor> PP;
60  std::function<bool(const Decl *)> ShouldSkipFunctionBody;
61
62public:
63  IndexASTConsumer(std::shared_ptr<IndexDataConsumer> DataConsumer,
64                   const IndexingOptions &Opts,
65                   std::shared_ptr<Preprocessor> PP,
66                   std::function<bool(const Decl *)> ShouldSkipFunctionBody)
67      : DataConsumer(std::move(DataConsumer)),
68        IndexCtx(new IndexingContext(Opts, *this->DataConsumer)),
69        PP(std::move(PP)),
70        ShouldSkipFunctionBody(std::move(ShouldSkipFunctionBody)) {
71    assert(this->DataConsumer != nullptr);
72    assert(this->PP != nullptr);
73  }
74
75protected:
76  void Initialize(ASTContext &Context) override {
77    IndexCtx->setASTContext(Context);
78    IndexCtx->getDataConsumer().initialize(Context);
79    IndexCtx->getDataConsumer().setPreprocessor(PP);
80    PP->addPPCallbacks(std::make_unique<IndexPPCallbacks>(IndexCtx));
81  }
82
83  bool HandleTopLevelDecl(DeclGroupRef DG) override {
84    return IndexCtx->indexDeclGroupRef(DG);
85  }
86
87  void HandleInterestingDecl(DeclGroupRef DG) override {
88    // Ignore deserialized decls.
89  }
90
91  void HandleTopLevelDeclInObjCContainer(DeclGroupRef DG) override {
92    IndexCtx->indexDeclGroupRef(DG);
93  }
94
95  void HandleTranslationUnit(ASTContext &Ctx) override {
96    DataConsumer->finish();
97  }
98
99  bool shouldSkipFunctionBody(Decl *D) override {
100    return ShouldSkipFunctionBody(D);
101  }
102};
103
104class IndexAction final : public ASTFrontendAction {
105  std::shared_ptr<IndexDataConsumer> DataConsumer;
106  IndexingOptions Opts;
107
108public:
109  IndexAction(std::shared_ptr<IndexDataConsumer> DataConsumer,
110              const IndexingOptions &Opts)
111      : DataConsumer(std::move(DataConsumer)), Opts(Opts) {
112    assert(this->DataConsumer != nullptr);
113  }
114
115protected:
116  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
117                                                 StringRef InFile) override {
118    return std::make_unique<IndexASTConsumer>(
119        DataConsumer, Opts, CI.getPreprocessorPtr(),
120        /*ShouldSkipFunctionBody=*/[](const Decl *) { return false; });
121  }
122};
123
124} // anonymous namespace
125
126std::unique_ptr<ASTConsumer> index::createIndexingASTConsumer(
127    std::shared_ptr<IndexDataConsumer> DataConsumer,
128    const IndexingOptions &Opts, std::shared_ptr<Preprocessor> PP,
129    std::function<bool(const Decl *)> ShouldSkipFunctionBody) {
130  return std::make_unique<IndexASTConsumer>(DataConsumer, Opts, PP,
131                                            ShouldSkipFunctionBody);
132}
133
134std::unique_ptr<ASTConsumer> clang::index::createIndexingASTConsumer(
135    std::shared_ptr<IndexDataConsumer> DataConsumer,
136    const IndexingOptions &Opts, std::shared_ptr<Preprocessor> PP) {
137  std::function<bool(const Decl *)> ShouldSkipFunctionBody = [](const Decl *) {
138    return false;
139  };
140  if (Opts.ShouldTraverseDecl)
141    ShouldSkipFunctionBody =
142        [ShouldTraverseDecl(Opts.ShouldTraverseDecl)](const Decl *D) {
143          return !ShouldTraverseDecl(D);
144        };
145  return createIndexingASTConsumer(std::move(DataConsumer), Opts, std::move(PP),
146                                   std::move(ShouldSkipFunctionBody));
147}
148
149std::unique_ptr<FrontendAction>
150index::createIndexingAction(std::shared_ptr<IndexDataConsumer> DataConsumer,
151                            const IndexingOptions &Opts) {
152  assert(DataConsumer != nullptr);
153  return std::make_unique<IndexAction>(std::move(DataConsumer), Opts);
154}
155
156static bool topLevelDeclVisitor(void *context, const Decl *D) {
157  IndexingContext &IndexCtx = *static_cast<IndexingContext*>(context);
158  return IndexCtx.indexTopLevelDecl(D);
159}
160
161static void indexTranslationUnit(ASTUnit &Unit, IndexingContext &IndexCtx) {
162  Unit.visitLocalTopLevelDecls(&IndexCtx, topLevelDeclVisitor);
163}
164
165static void indexPreprocessorMacros(const Preprocessor &PP,
166                                    IndexDataConsumer &DataConsumer) {
167  for (const auto &M : PP.macros())
168    if (MacroDirective *MD = M.second.getLatest())
169      DataConsumer.handleMacroOccurrence(
170          M.first, MD->getMacroInfo(),
171          static_cast<unsigned>(index::SymbolRole::Definition),
172          MD->getLocation());
173}
174
175void index::indexASTUnit(ASTUnit &Unit, IndexDataConsumer &DataConsumer,
176                         IndexingOptions Opts) {
177  IndexingContext IndexCtx(Opts, DataConsumer);
178  IndexCtx.setASTContext(Unit.getASTContext());
179  DataConsumer.initialize(Unit.getASTContext());
180  DataConsumer.setPreprocessor(Unit.getPreprocessorPtr());
181
182  if (Opts.IndexMacrosInPreprocessor)
183    indexPreprocessorMacros(Unit.getPreprocessor(), DataConsumer);
184  indexTranslationUnit(Unit, IndexCtx);
185  DataConsumer.finish();
186}
187
188void index::indexTopLevelDecls(ASTContext &Ctx, Preprocessor &PP,
189                               ArrayRef<const Decl *> Decls,
190                               IndexDataConsumer &DataConsumer,
191                               IndexingOptions Opts) {
192  IndexingContext IndexCtx(Opts, DataConsumer);
193  IndexCtx.setASTContext(Ctx);
194
195  DataConsumer.initialize(Ctx);
196
197  if (Opts.IndexMacrosInPreprocessor)
198    indexPreprocessorMacros(PP, DataConsumer);
199
200  for (const Decl *D : Decls)
201    IndexCtx.indexTopLevelDecl(D);
202  DataConsumer.finish();
203}
204
205std::unique_ptr<PPCallbacks>
206index::indexMacrosCallback(IndexDataConsumer &Consumer, IndexingOptions Opts) {
207  return std::make_unique<IndexPPCallbacks>(
208      std::make_shared<IndexingContext>(Opts, Consumer));
209}
210
211void index::indexModuleFile(serialization::ModuleFile &Mod, ASTReader &Reader,
212                            IndexDataConsumer &DataConsumer,
213                            IndexingOptions Opts) {
214  ASTContext &Ctx = Reader.getContext();
215  IndexingContext IndexCtx(Opts, DataConsumer);
216  IndexCtx.setASTContext(Ctx);
217  DataConsumer.initialize(Ctx);
218
219  if (Opts.IndexMacrosInPreprocessor)
220    indexPreprocessorMacros(Reader.getPreprocessor(), DataConsumer);
221
222  for (const Decl *D : Reader.getModuleFileLevelDecls(Mod)) {
223    IndexCtx.indexTopLevelDecl(D);
224  }
225  DataConsumer.finish();
226}
227