clang-tools-extra/clangd/index/IndexAction.cpp

   1 //===--- IndexAction.cpp -----------------------------------------*- C++-*-===//
   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 "IndexAction.h"
  10 #include "AST.h"
  11 #include "Headers.h"
  12 #include "clang-include-cleaner/Record.h"
  13 #include "index/Relation.h"
  14 #include "index/SymbolCollector.h"
  15 #include "index/SymbolOrigin.h"
  16 #include "clang/AST/ASTConsumer.h"
  17 #include "clang/AST/ASTContext.h"
  18 #include "clang/Basic/SourceLocation.h"
  19 #include "clang/Basic/SourceManager.h"
  20 #include "clang/Frontend/CompilerInstance.h"
  21 #include "clang/Frontend/FrontendAction.h"
  22 #include "clang/Index/IndexingAction.h"
  23 #include "clang/Index/IndexingOptions.h"
  24 #include <cstddef>
  25 #include <functional>
  26 #include <memory>
  27 #include <optional>
  28 #include <utility>
  29
  30 namespace clang {
  31 namespace clangd {
  32 namespace {
  33
  34 std::optional<std::string> toURI(OptionalFileEntryRef File) {
  35   if (!File)
  36     return std::nullopt;
  37   auto AbsolutePath = File->getFileEntry().tryGetRealPathName();
  38   if (AbsolutePath.empty())
  39     return std::nullopt;
  40   return URI::create(AbsolutePath).toString();
  41 }
  42
  43 // Collects the nodes and edges of include graph during indexing action.
  44 // Important: The graph generated by those callbacks might contain cycles and
  45 // self edges.
  46 struct IncludeGraphCollector : public PPCallbacks {
  47 public:
  48   IncludeGraphCollector(const SourceManager &SM, IncludeGraph &IG)
  49       : SM(SM), IG(IG) {}
  50
  51   // Populates everything except direct includes for a node, which represents
  52   // edges in the include graph and populated in inclusion directive.
  53   // We cannot populate the fields in InclusionDirective because it does not
  54   // have access to the contents of the included file.
  55   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
  56                    SrcMgr::CharacteristicKind FileType,
  57                    FileID PrevFID) override {
  58     // We only need to process each file once. So we don't care about anything
  59     // but entries.
  60     if (Reason != FileChangeReason::EnterFile)
  61       return;
  62
  63     const auto FileID = SM.getFileID(Loc);
  64     auto File = SM.getFileEntryRefForID(FileID);
  65     auto URI = toURI(File);
  66     if (!URI)
  67       return;
  68     auto I = IG.try_emplace(*URI).first;
  69
  70     auto &Node = I->getValue();
  71     // Node has already been populated.
  72     if (Node.URI.data() == I->getKeyData()) {
  73 #ifndef NDEBUG
  74       auto Digest = digestFile(SM, FileID);
  75       assert(Digest && Node.Digest == *Digest &&
  76              "Same file, different digest?");
  77 #endif
  78       return;
  79     }
  80     if (auto Digest = digestFile(SM, FileID))
  81       Node.Digest = std::move(*Digest);
  82     if (FileID == SM.getMainFileID())
  83       Node.Flags |= IncludeGraphNode::SourceFlag::IsTU;
  84     Node.URI = I->getKey();
  85   }
  86
  87   // Add edges from including files to includes.
  88   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
  89                           llvm::StringRef FileName, bool IsAngled,
  90                           CharSourceRange FilenameRange,
  91                           OptionalFileEntryRef File, llvm::StringRef SearchPath,
  92                           llvm::StringRef RelativePath,
  93                           const Module *SuggestedModule, bool ModuleImported,
  94                           SrcMgr::CharacteristicKind FileType) override {
  95     auto IncludeURI = toURI(File);
  96     if (!IncludeURI)
  97       return;
  98
  99     auto IncludingURI = toURI(SM.getFileEntryRefForID(SM.getFileID(HashLoc)));
 100     if (!IncludingURI)
 101       return;
 102
 103     auto NodeForInclude = IG.try_emplace(*IncludeURI).first->getKey();
 104     auto NodeForIncluding = IG.try_emplace(*IncludingURI);
 105
 106     NodeForIncluding.first->getValue().DirectIncludes.push_back(NodeForInclude);
 107   }
 108
 109   // Sanity check to ensure we have already populated a skipped file.
 110   void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
 111                    SrcMgr::CharacteristicKind FileType) override {
 112 #ifndef NDEBUG
 113     auto URI = toURI(SkippedFile);
 114     if (!URI)
 115       return;
 116     auto I = IG.try_emplace(*URI);
 117     assert(!I.second && "File inserted for the first time on skip.");
 118     assert(I.first->getKeyData() == I.first->getValue().URI.data() &&
 119            "Node have not been populated yet");
 120 #endif
 121   }
 122
 123 private:
 124   const SourceManager &SM;
 125   IncludeGraph &IG;
 126 };
 127
 128 // Wraps the index action and reports index data after each translation unit.
 129 class IndexAction : public ASTFrontendAction {
 130 public:
 131   IndexAction(std::shared_ptr<SymbolCollector> C,
 132               std::unique_ptr<include_cleaner::PragmaIncludes> PI,
 133               const index::IndexingOptions &Opts,
 134               std::function<void(SymbolSlab)> SymbolsCallback,
 135               std::function<void(RefSlab)> RefsCallback,
 136               std::function<void(RelationSlab)> RelationsCallback,
 137               std::function<void(IncludeGraph)> IncludeGraphCallback)
 138       : SymbolsCallback(SymbolsCallback), RefsCallback(RefsCallback),
 139         RelationsCallback(RelationsCallback),
 140         IncludeGraphCallback(IncludeGraphCallback), Collector(C),
 141         PI(std::move(PI)), Opts(Opts) {
 142     this->Opts.ShouldTraverseDecl = [this](const Decl *D) {
 143       // Many operations performed during indexing is linear in terms of depth
 144       // of the decl (USR generation, name lookups, figuring out role of a
 145       // reference are some examples). Since we index all the decls nested
 146       // inside, it becomes quadratic. So we give up on nested symbols.
 147       if (isDeeplyNested(D))
 148         return false;
 149       auto &SM = D->getASTContext().getSourceManager();
 150       auto FID = SM.getFileID(SM.getExpansionLoc(D->getLocation()));
 151       if (!FID.isValid())
 152         return true;
 153       return Collector->shouldIndexFile(FID);
 154     };
 155   }
 156
 157   std::unique_ptr<ASTConsumer>
 158   CreateASTConsumer(CompilerInstance &CI, llvm::StringRef InFile) override {
 159     PI->record(CI.getPreprocessor());
 160     if (IncludeGraphCallback != nullptr)
 161       CI.getPreprocessor().addPPCallbacks(
 162           std::make_unique<IncludeGraphCollector>(CI.getSourceManager(), IG));
 163
 164     return index::createIndexingASTConsumer(Collector, Opts,
 165                                             CI.getPreprocessorPtr());
 166   }
 167
 168   bool BeginInvocation(CompilerInstance &CI) override {
 169     // We want all comments, not just the doxygen ones.
 170     CI.getLangOpts().CommentOpts.ParseAllComments = true;
 171     CI.getLangOpts().RetainCommentsFromSystemHeaders = true;
 172     // Index the whole file even if there are warnings and -Werror is set.
 173     // Avoids some analyses too. Set in two places as we're late to the party.
 174     CI.getDiagnosticOpts().IgnoreWarnings = true;
 175     CI.getDiagnostics().setIgnoreAllWarnings(true);
 176     // Instruct the parser to ask our ASTConsumer if it should skip function
 177     // bodies. The ASTConsumer will take care of skipping only functions inside
 178     // the files that we have already processed.
 179     CI.getFrontendOpts().SkipFunctionBodies = true;
 180     return true;
 181   }
 182
 183   void EndSourceFileAction() override {
 184     SymbolsCallback(Collector->takeSymbols());
 185     if (RefsCallback != nullptr)
 186       RefsCallback(Collector->takeRefs());
 187     if (RelationsCallback != nullptr)
 188       RelationsCallback(Collector->takeRelations());
 189     if (IncludeGraphCallback != nullptr) {
 190 #ifndef NDEBUG
 191       // This checks if all nodes are initialized.
 192       for (const auto &Node : IG)
 193         assert(Node.getKeyData() == Node.getValue().URI.data());
 194 #endif
 195       IncludeGraphCallback(std::move(IG));
 196     }
 197   }
 198
 199 private:
 200   std::function<void(SymbolSlab)> SymbolsCallback;
 201   std::function<void(RefSlab)> RefsCallback;
 202   std::function<void(RelationSlab)> RelationsCallback;
 203   std::function<void(IncludeGraph)> IncludeGraphCallback;
 204   std::shared_ptr<SymbolCollector> Collector;
 205   std::unique_ptr<include_cleaner::PragmaIncludes> PI;
 206   index::IndexingOptions Opts;
 207   IncludeGraph IG;
 208 };
 209
 210 } // namespace
 211
 212 std::unique_ptr<FrontendAction> createStaticIndexingAction(
 213     SymbolCollector::Options Opts,
 214     std::function<void(SymbolSlab)> SymbolsCallback,
 215     std::function<void(RefSlab)> RefsCallback,
 216     std::function<void(RelationSlab)> RelationsCallback,
 217     std::function<void(IncludeGraph)> IncludeGraphCallback) {
 218   index::IndexingOptions IndexOpts;
 219   IndexOpts.SystemSymbolFilter =
 220       index::IndexingOptions::SystemSymbolFilterKind::All;
 221   // We index function-local classes and its member functions only.
 222   IndexOpts.IndexFunctionLocals = true;
 223   Opts.CollectIncludePath = true;
 224   if (Opts.Origin == SymbolOrigin::Unknown)
 225     Opts.Origin = SymbolOrigin::Static;
 226   Opts.StoreAllDocumentation = false;
 227   if (RefsCallback != nullptr) {
 228     Opts.RefFilter = RefKind::All;
 229     Opts.RefsInHeaders = true;
 230   }
 231   auto PragmaIncludes = std::make_unique<include_cleaner::PragmaIncludes>();
 232   Opts.PragmaIncludes = PragmaIncludes.get();
 233   return std::make_unique<IndexAction>(std::make_shared<SymbolCollector>(Opts),
 234                                        std::move(PragmaIncludes), IndexOpts,
 235                                        SymbolsCallback, RefsCallback,
 236                                        RelationsCallback, IncludeGraphCallback);
 237 }
 238
 239 } // namespace clangd
 240 } // namespace clang