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 
21 using namespace clang;
22 using namespace clang::index;
23 
24 namespace {
25 
26 class IndexPPCallbacks final : public PPCallbacks {
27   std::shared_ptr<IndexingContext> IndexCtx;
28 
29 public:
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 
56 class 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 
62 public:
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 
75 protected:
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 
104 class IndexAction final : public ASTFrontendAction {
105   std::shared_ptr<IndexDataConsumer> DataConsumer;
106   IndexingOptions Opts;
107 
108 public:
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 
115 protected:
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 
126 std::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 
134 std::unique_ptr<FrontendAction>
135 index::createIndexingAction(std::shared_ptr<IndexDataConsumer> DataConsumer,
136                             const IndexingOptions &Opts) {
137   assert(DataConsumer != nullptr);
138   return std::make_unique<IndexAction>(std::move(DataConsumer), Opts);
139 }
140 
141 static bool topLevelDeclVisitor(void *context, const Decl *D) {
142   IndexingContext &IndexCtx = *static_cast<IndexingContext*>(context);
143   return IndexCtx.indexTopLevelDecl(D);
144 }
145 
146 static void indexTranslationUnit(ASTUnit &Unit, IndexingContext &IndexCtx) {
147   Unit.visitLocalTopLevelDecls(&IndexCtx, topLevelDeclVisitor);
148 }
149 
150 static void indexPreprocessorMacros(const Preprocessor &PP,
151                                     IndexDataConsumer &DataConsumer) {
152   for (const auto &M : PP.macros())
153     if (MacroDirective *MD = M.second.getLatest())
154       DataConsumer.handleMacroOccurrence(
155           M.first, MD->getMacroInfo(),
156           static_cast<unsigned>(index::SymbolRole::Definition),
157           MD->getLocation());
158 }
159 
160 void index::indexASTUnit(ASTUnit &Unit, IndexDataConsumer &DataConsumer,
161                          IndexingOptions Opts) {
162   IndexingContext IndexCtx(Opts, DataConsumer);
163   IndexCtx.setASTContext(Unit.getASTContext());
164   DataConsumer.initialize(Unit.getASTContext());
165   DataConsumer.setPreprocessor(Unit.getPreprocessorPtr());
166 
167   if (Opts.IndexMacrosInPreprocessor)
168     indexPreprocessorMacros(Unit.getPreprocessor(), DataConsumer);
169   indexTranslationUnit(Unit, IndexCtx);
170   DataConsumer.finish();
171 }
172 
173 void index::indexTopLevelDecls(ASTContext &Ctx, Preprocessor &PP,
174                                ArrayRef<const Decl *> Decls,
175                                IndexDataConsumer &DataConsumer,
176                                IndexingOptions Opts) {
177   IndexingContext IndexCtx(Opts, DataConsumer);
178   IndexCtx.setASTContext(Ctx);
179 
180   DataConsumer.initialize(Ctx);
181 
182   if (Opts.IndexMacrosInPreprocessor)
183     indexPreprocessorMacros(PP, DataConsumer);
184 
185   for (const Decl *D : Decls)
186     IndexCtx.indexTopLevelDecl(D);
187   DataConsumer.finish();
188 }
189 
190 std::unique_ptr<PPCallbacks>
191 index::indexMacrosCallback(IndexDataConsumer &Consumer, IndexingOptions Opts) {
192   return std::make_unique<IndexPPCallbacks>(
193       std::make_shared<IndexingContext>(Opts, Consumer));
194 }
195 
196 void index::indexModuleFile(serialization::ModuleFile &Mod, ASTReader &Reader,
197                             IndexDataConsumer &DataConsumer,
198                             IndexingOptions Opts) {
199   ASTContext &Ctx = Reader.getContext();
200   IndexingContext IndexCtx(Opts, DataConsumer);
201   IndexCtx.setASTContext(Ctx);
202   DataConsumer.initialize(Ctx);
203 
204   if (Opts.IndexMacrosInPreprocessor)
205     indexPreprocessorMacros(Reader.getPreprocessor(), DataConsumer);
206 
207   for (const Decl *D : Reader.getModuleFileLevelDecls(Mod)) {
208     IndexCtx.indexTopLevelDecl(D);
209   }
210   DataConsumer.finish();
211 }
212