clang-tools  9.0.0
MemIndex.cpp
Go to the documentation of this file.
1 //===--- MemIndex.cpp - Dynamic in-memory symbol index. ----------*- 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 "MemIndex.h"
10 #include "FuzzyMatch.h"
11 #include "Logger.h"
12 #include "Quality.h"
13 #include "Trace.h"
14 #include "clang/Index/IndexSymbol.h"
15 
16 namespace clang {
17 namespace clangd {
18 
19 std::unique_ptr<SymbolIndex> MemIndex::build(SymbolSlab Slab, RefSlab Refs,
21  // Store Slab size before it is moved.
22  const auto BackingDataSize = Slab.bytes() + Refs.bytes();
23  auto Data = std::make_pair(std::move(Slab), std::move(Refs));
24  return llvm::make_unique<MemIndex>(Data.first, Data.second, Relations,
25  std::move(Data), BackingDataSize);
26 }
27 
29  const FuzzyFindRequest &Req,
30  llvm::function_ref<void(const Symbol &)> Callback) const {
31  assert(!StringRef(Req.Query).contains("::") &&
32  "There must be no :: in query.");
33  trace::Span Tracer("MemIndex fuzzyFind");
34 
36  Req.Limit ? *Req.Limit : std::numeric_limits<size_t>::max());
37  FuzzyMatcher Filter(Req.Query);
38  bool More = false;
39  for (const auto Pair : Index) {
40  const Symbol *Sym = Pair.second;
41 
42  // Exact match against all possible scopes.
43  if (!Req.AnyScope && !llvm::is_contained(Req.Scopes, Sym->Scope))
44  continue;
45  if (Req.RestrictForCodeCompletion &&
47  continue;
48 
49  if (auto Score = Filter.match(Sym->Name))
50  if (Top.push({*Score * quality(*Sym), Sym}))
51  More = true; // An element with smallest score was discarded.
52  }
53  auto Results = std::move(Top).items();
54  SPAN_ATTACH(Tracer, "results", static_cast<int>(Results.size()));
55  for (const auto &Item : Results)
56  Callback(*Item.second);
57  return More;
58 }
59 
61  llvm::function_ref<void(const Symbol &)> Callback) const {
62  trace::Span Tracer("MemIndex lookup");
63  for (const auto &ID : Req.IDs) {
64  auto I = Index.find(ID);
65  if (I != Index.end())
66  Callback(*I->second);
67  }
68 }
69 
70 void MemIndex::refs(const RefsRequest &Req,
71  llvm::function_ref<void(const Ref &)> Callback) const {
72  trace::Span Tracer("MemIndex refs");
73  uint32_t Remaining =
74  Req.Limit.getValueOr(std::numeric_limits<uint32_t>::max());
75  for (const auto &ReqID : Req.IDs) {
76  auto SymRefs = Refs.find(ReqID);
77  if (SymRefs == Refs.end())
78  continue;
79  for (const auto &O : SymRefs->second) {
80  if (Remaining > 0 && static_cast<int>(Req.Filter & O.Kind)) {
81  --Remaining;
82  Callback(O);
83  }
84  }
85  }
86 }
87 
89  const RelationsRequest &Req,
90  llvm::function_ref<void(const SymbolID &, const Symbol &)> Callback) const {
91  uint32_t Remaining =
92  Req.Limit.getValueOr(std::numeric_limits<uint32_t>::max());
93  for (const SymbolID &Subject : Req.Subjects) {
94  LookupRequest LookupReq;
95  auto It = Relations.find(std::make_pair(Subject, Req.Predicate));
96  if (It != Relations.end()) {
97  for (const auto &Obj : It->second) {
98  if (Remaining > 0) {
99  --Remaining;
100  LookupReq.IDs.insert(Obj);
101  }
102  }
103  }
104  lookup(LookupReq, [&](const Symbol &Object) { Callback(Subject, Object); });
105  }
106 }
107 
109  return Index.getMemorySize() + Refs.getMemorySize() +
110  Relations.getMemorySize() + BackingDataSize;
111 }
112 
113 } // namespace clangd
114 } // namespace clang
size_t bytes() const
Definition: Symbol.h:192
An immutable symbol container that stores a set of symbols.
Definition: Symbol.h:177
llvm::DenseSet< SymbolID > IDs
Definition: Index.h:68
bool AnyScope
If set to true, allow symbols from any scope.
Definition: Index.h:39
bool RestrictForCodeCompletion
If set to true, only symbols for completion support will be considered.
Definition: Index.h:44
An efficient structure of storing large set of symbol references in memory.
Definition: Ref.h:69
llvm::Optional< uint32_t > Limit
If set, limit the number of relations returned from the index.
Definition: Index.h:80
void refs(const RefsRequest &Req, llvm::function_ref< void(const Ref &)> Callback) const override
Finds all occurrences (e.g.
Definition: MemIndex.cpp:70
llvm::DenseSet< SymbolID > IDs
Definition: Index.h:64
Represents a symbol occurrence in the source file.
Definition: Ref.h:52
std::vector< CodeCompletionResult > Results
llvm::unique_function< void(llvm::Expected< T >)> Callback
A Callback<T> is a void function that accepts Expected<T>.
Definition: Function.h:28
llvm::StringRef Scope
The containing namespace. e.g. "" (global), "ns::" (top-level namespace).
Definition: Symbol.h:44
index::SymbolRole Predicate
Definition: Index.h:78
std::vector< std::string > Scopes
If this is non-empty, symbols must be in at least one of the scopes (e.g.
Definition: Index.h:36
size_t estimateMemoryUsage() const override
Returns estimated size of index (in bytes).
Definition: MemIndex.cpp:108
void relations(const RelationsRequest &Req, llvm::function_ref< void(const SymbolID &, const Symbol &)> Callback) const override
Definition: MemIndex.cpp:88
llvm::Optional< float > Score
static std::unique_ptr< SymbolIndex > build(SymbolSlab Symbols, RefSlab Refs, RelationSlab Relations)
Builds an index from slabs. The index takes ownership of the data.
Definition: MemIndex.cpp:19
Whether or not this symbol is meant to be used for the code completion.
Definition: Symbol.h:119
SymbolFlag Flags
Definition: Symbol.h:128
std::string Query
A query string for the fuzzy find.
Definition: Index.h:29
llvm::Optional< float > match(llvm::StringRef Word)
Definition: FuzzyMatch.cpp:92
bool push(value_type &&V)
Definition: Quality.h:160
RelationSlab Relations
llvm::DenseSet< SymbolID > Subjects
Definition: Index.h:77
The class presents a C++ symbol, e.g.
Definition: Symbol.h:36
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
llvm::StringRef Name
The unqualified name of the symbol, e.g. "bar" (for ns::bar).
Definition: Symbol.h:42
llvm::Optional< uint32_t > Limit
If set, limit the number of refers returned from the index.
Definition: Index.h:73
llvm::Optional< uint32_t > Limit
The number of top candidates to return.
Definition: Index.h:42
void lookup(const LookupRequest &Req, llvm::function_ref< void(const Symbol &)> Callback) const override
Looks up symbols with any of the given symbol IDs and applies Callback on each matched symbol...
Definition: MemIndex.cpp:60
size_t bytes() const
Definition: Ref.h:87
RefSlab Refs
Records an event whose duration is the lifetime of the Span object.
Definition: Trace.h:82
#define SPAN_ATTACH(S, Name, Expr)
Attach a key-value pair to a Span event.
Definition: Trace.h:98
bool fuzzyFind(const FuzzyFindRequest &Req, llvm::function_ref< void(const Symbol &)> Callback) const override
Matches symbols in the index fuzzily and applies Callback on each matched symbol before returning...
Definition: MemIndex.cpp:28
TopN<T> is a lossy container that preserves only the "best" N elements.
Definition: Quality.h:152