clang/lib/Index/IndexingAction.cpp

   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   void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
  56                SourceRange Range) override {
  57     if (!MD.getMacroInfo()) // Ignore nonexistent macro.
  58       return;
  59     // Note: this is defined(M), not #define M
  60     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
  61                                    MacroNameTok.getLocation(),
  62                                    *MD.getMacroInfo());
  63   }
  64   void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
  65              const MacroDefinition &MD) override {
  66     if (!MD.getMacroInfo()) // Ignore non-existent macro.
  67       return;
  68     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
  69                                    MacroNameTok.getLocation(),
  70                                    *MD.getMacroInfo());
  71   }
  72   void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
  73               const MacroDefinition &MD) override {
  74     if (!MD.getMacroInfo()) // Ignore nonexistent macro.
  75       return;
  76     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
  77                                    MacroNameTok.getLocation(),
  78                                    *MD.getMacroInfo());
  79   }
  80
  81   using PPCallbacks::Elifdef;
  82   using PPCallbacks::Elifndef;
  83   void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
  84                const MacroDefinition &MD) override {
  85     if (!MD.getMacroInfo()) // Ignore non-existent macro.
  86       return;
  87     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
  88                                    MacroNameTok.getLocation(),
  89                                    *MD.getMacroInfo());
  90   }
  91   void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
  92                 const MacroDefinition &MD) override {
  93     if (!MD.getMacroInfo()) // Ignore non-existent macro.
  94       return;
  95     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
  96                                    MacroNameTok.getLocation(),
  97                                    *MD.getMacroInfo());
  98   }
  99 };
 100
 101 class IndexASTConsumer final : public ASTConsumer {
 102   std::shared_ptr<IndexDataConsumer> DataConsumer;
 103   std::shared_ptr<IndexingContext> IndexCtx;
 104   std::shared_ptr<Preprocessor> PP;
 105   std::function<bool(const Decl *)> ShouldSkipFunctionBody;
 106
 107 public:
 108   IndexASTConsumer(std::shared_ptr<IndexDataConsumer> DataConsumer,
 109                    const IndexingOptions &Opts,
 110                    std::shared_ptr<Preprocessor> PP,
 111                    std::function<bool(const Decl *)> ShouldSkipFunctionBody)
 112       : DataConsumer(std::move(DataConsumer)),
 113         IndexCtx(new IndexingContext(Opts, *this->DataConsumer)),
 114         PP(std::move(PP)),
 115         ShouldSkipFunctionBody(std::move(ShouldSkipFunctionBody)) {
 116     assert(this->DataConsumer != nullptr);
 117     assert(this->PP != nullptr);
 118   }
 119
 120 protected:
 121   void Initialize(ASTContext &Context) override {
 122     IndexCtx->setASTContext(Context);
 123     IndexCtx->getDataConsumer().initialize(Context);
 124     IndexCtx->getDataConsumer().setPreprocessor(PP);
 125     PP->addPPCallbacks(std::make_unique<IndexPPCallbacks>(IndexCtx));
 126   }
 127
 128   bool HandleTopLevelDecl(DeclGroupRef DG) override {
 129     return IndexCtx->indexDeclGroupRef(DG);
 130   }
 131
 132   void HandleInterestingDecl(DeclGroupRef DG) override {
 133     // Ignore deserialized decls.
 134   }
 135
 136   void HandleTopLevelDeclInObjCContainer(DeclGroupRef DG) override {
 137     IndexCtx->indexDeclGroupRef(DG);
 138   }
 139
 140   void HandleTranslationUnit(ASTContext &Ctx) override {
 141     DataConsumer->finish();
 142   }
 143
 144   bool shouldSkipFunctionBody(Decl *D) override {
 145     return ShouldSkipFunctionBody(D);
 146   }
 147 };
 148
 149 class IndexAction final : public ASTFrontendAction {
 150   std::shared_ptr<IndexDataConsumer> DataConsumer;
 151   IndexingOptions Opts;
 152
 153 public:
 154   IndexAction(std::shared_ptr<IndexDataConsumer> DataConsumer,
 155               const IndexingOptions &Opts)
 156       : DataConsumer(std::move(DataConsumer)), Opts(Opts) {
 157     assert(this->DataConsumer != nullptr);
 158   }
 159
 160 protected:
 161   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
 162                                                  StringRef InFile) override {
 163     return std::make_unique<IndexASTConsumer>(
 164         DataConsumer, Opts, CI.getPreprocessorPtr(),
 165         /*ShouldSkipFunctionBody=*/[](const Decl *) { return false; });
 166   }
 167 };
 168
 169 } // anonymous namespace
 170
 171 std::unique_ptr<ASTConsumer> index::createIndexingASTConsumer(
 172     std::shared_ptr<IndexDataConsumer> DataConsumer,
 173     const IndexingOptions &Opts, std::shared_ptr<Preprocessor> PP,
 174     std::function<bool(const Decl *)> ShouldSkipFunctionBody) {
 175   return std::make_unique<IndexASTConsumer>(DataConsumer, Opts, PP,
 176                                             ShouldSkipFunctionBody);
 177 }
 178
 179 std::unique_ptr<ASTConsumer> clang::index::createIndexingASTConsumer(
 180     std::shared_ptr<IndexDataConsumer> DataConsumer,
 181     const IndexingOptions &Opts, std::shared_ptr<Preprocessor> PP) {
 182   std::function<bool(const Decl *)> ShouldSkipFunctionBody = [](const Decl *) {
 183     return false;
 184   };
 185   if (Opts.ShouldTraverseDecl)
 186     ShouldSkipFunctionBody =
 187         [ShouldTraverseDecl(Opts.ShouldTraverseDecl)](const Decl *D) {
 188           return !ShouldTraverseDecl(D);
 189         };
 190   return createIndexingASTConsumer(std::move(DataConsumer), Opts, std::move(PP),
 191                                    std::move(ShouldSkipFunctionBody));
 192 }
 193
 194 std::unique_ptr<FrontendAction>
 195 index::createIndexingAction(std::shared_ptr<IndexDataConsumer> DataConsumer,
 196                             const IndexingOptions &Opts) {
 197   assert(DataConsumer != nullptr);
 198   return std::make_unique<IndexAction>(std::move(DataConsumer), Opts);
 199 }
 200
 201 static bool topLevelDeclVisitor(void *context, const Decl *D) {
 202   IndexingContext &IndexCtx = *static_cast<IndexingContext*>(context);
 203   return IndexCtx.indexTopLevelDecl(D);
 204 }
 205
 206 static void indexTranslationUnit(ASTUnit &Unit, IndexingContext &IndexCtx) {
 207   Unit.visitLocalTopLevelDecls(&IndexCtx, topLevelDeclVisitor);
 208 }
 209
 210 static void indexPreprocessorMacro(const IdentifierInfo *II,
 211                                    const MacroInfo *MI,
 212                                    MacroDirective::Kind DirectiveKind,
 213                                    SourceLocation Loc,
 214                                    IndexDataConsumer &DataConsumer) {
 215   // When using modules, it may happen that we find #undef of a macro that
 216   // was defined in another module. In such case, MI may be nullptr, since
 217   // we only look for macro definitions in the current TU. In that case,
 218   // there is nothing to index.
 219   if (!MI)
 220     return;
 221
 222   // Skip implicit visibility change.
 223   if (DirectiveKind == MacroDirective::MD_Visibility)
 224     return;
 225
 226   auto Role = DirectiveKind == MacroDirective::MD_Define
 227                   ? SymbolRole::Definition
 228                   : SymbolRole::Undefinition;
 229   DataConsumer.handleMacroOccurrence(II, MI, static_cast<unsigned>(Role), Loc);
 230 }
 231
 232 static void indexPreprocessorMacros(Preprocessor &PP,
 233                                     IndexDataConsumer &DataConsumer) {
 234   for (const auto &M : PP.macros()) {
 235     for (auto *MD = M.second.getLatest(); MD; MD = MD->getPrevious()) {
 236       indexPreprocessorMacro(M.first, MD->getMacroInfo(), MD->getKind(),
 237                              MD->getLocation(), DataConsumer);
 238     }
 239   }
 240 }
 241
 242 static void indexPreprocessorModuleMacros(Preprocessor &PP,
 243                                           serialization::ModuleFile &Mod,
 244                                           IndexDataConsumer &DataConsumer) {
 245   for (const auto &M : PP.macros()) {
 246     if (M.second.getLatest() == nullptr) {
 247       for (auto *MM : PP.getLeafModuleMacros(M.first)) {
 248         auto *OwningMod = MM->getOwningModule();
 249         if (OwningMod && OwningMod->getASTFile() == Mod.File) {
 250           if (auto *MI = MM->getMacroInfo()) {
 251             indexPreprocessorMacro(M.first, MI, MacroDirective::MD_Define,
 252                                    MI->getDefinitionLoc(), DataConsumer);
 253           }
 254         }
 255       }
 256     }
 257   }
 258 }
 259
 260 void index::indexASTUnit(ASTUnit &Unit, IndexDataConsumer &DataConsumer,
 261                          IndexingOptions Opts) {
 262   IndexingContext IndexCtx(Opts, DataConsumer);
 263   IndexCtx.setASTContext(Unit.getASTContext());
 264   DataConsumer.initialize(Unit.getASTContext());
 265   DataConsumer.setPreprocessor(Unit.getPreprocessorPtr());
 266
 267   if (Opts.IndexMacrosInPreprocessor)
 268     indexPreprocessorMacros(Unit.getPreprocessor(), DataConsumer);
 269   indexTranslationUnit(Unit, IndexCtx);
 270   DataConsumer.finish();
 271 }
 272
 273 void index::indexTopLevelDecls(ASTContext &Ctx, Preprocessor &PP,
 274                                ArrayRef<const Decl *> Decls,
 275                                IndexDataConsumer &DataConsumer,
 276                                IndexingOptions Opts) {
 277   IndexingContext IndexCtx(Opts, DataConsumer);
 278   IndexCtx.setASTContext(Ctx);
 279
 280   DataConsumer.initialize(Ctx);
 281
 282   if (Opts.IndexMacrosInPreprocessor)
 283     indexPreprocessorMacros(PP, DataConsumer);
 284
 285   for (const Decl *D : Decls)
 286     IndexCtx.indexTopLevelDecl(D);
 287   DataConsumer.finish();
 288 }
 289
 290 std::unique_ptr<PPCallbacks>
 291 index::indexMacrosCallback(IndexDataConsumer &Consumer, IndexingOptions Opts) {
 292   return std::make_unique<IndexPPCallbacks>(
 293       std::make_shared<IndexingContext>(Opts, Consumer));
 294 }
 295
 296 void index::indexModuleFile(serialization::ModuleFile &Mod, ASTReader &Reader,
 297                             IndexDataConsumer &DataConsumer,
 298                             IndexingOptions Opts) {
 299   ASTContext &Ctx = Reader.getContext();
 300   IndexingContext IndexCtx(Opts, DataConsumer);
 301   IndexCtx.setASTContext(Ctx);
 302   DataConsumer.initialize(Ctx);
 303
 304   if (Opts.IndexMacrosInPreprocessor) {
 305     indexPreprocessorModuleMacros(Reader.getPreprocessor(), Mod, DataConsumer);
 306   }
 307
 308   for (const Decl *D : Reader.getModuleFileLevelDecls(Mod)) {
 309     IndexCtx.indexTopLevelDecl(D);
 310   }
 311   DataConsumer.finish();
 312 }