llvm-project

1
//===--- Symbol.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 "Symbol.h"
10

11
#include <cmath>
12

13
namespace clang {
14
namespace clangd {
15

16
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Symbol::SymbolFlag F) {
17
  if (F == Symbol::None)
18
    return OS << "None";
19
  std::string S;
20
  if (F & Symbol::Deprecated)
21
    S += "deprecated|";
22
  if (F & Symbol::IndexedForCodeCompletion)
23
    S += "completion|";
24
  return OS << llvm::StringRef(S).rtrim('|');
25
}
26

27
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Symbol &S) {
28
  return OS << S.Scope << S.Name;
29
}
30

31
float quality(const Symbol &S) {
32
  // This avoids a sharp gradient for tail symbols, and also neatly avoids the
33
  // question of whether 0 references means a bad symbol or missing data.
34
  if (S.References < 3)
35
    return 1;
36
  return std::log(S.References);
37
}
38

39
SymbolSlab::const_iterator SymbolSlab::find(const SymbolID &ID) const {
40
  auto It = llvm::partition_point(Symbols,
41
                                  [&](const Symbol &S) { return S.ID < ID; });
42
  if (It != Symbols.end() && It->ID == ID)
43
    return It;
44
  return Symbols.end();
45
}
46

47
// Copy the underlying data of the symbol into the owned arena.
48
static void own(Symbol &S, llvm::UniqueStringSaver &Strings) {
49
  visitStrings(S, [&](llvm::StringRef &V) { V = Strings.save(V); });
50
}
51

52
void SymbolSlab::Builder::insert(const Symbol &S) {
53
  own(Symbols[S.ID] = S, UniqueStrings);
54
}
55

56
SymbolSlab SymbolSlab::Builder::build() && {
57
  // Sort symbols into vector so the slab can binary search over them.
58
  std::vector<Symbol> SortedSymbols;
59
  SortedSymbols.reserve(Symbols.size());
60
  for (auto &Entry : Symbols)
61
    SortedSymbols.push_back(std::move(Entry.second));
62
  llvm::sort(SortedSymbols,
63
             [](const Symbol &L, const Symbol &R) { return L.ID < R.ID; });
64
  // We may have unused strings from overwritten symbols.
65
  // In practice, these are extremely small, it's not worth compacting.
66
  return SymbolSlab(std::move(Arena), std::move(SortedSymbols));
67
}
68

69
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SymbolSlab &Slab) {
70
  OS << "{";
71
  llvm::StringRef Sep = "";
72
  for (const auto &S : Slab) {
73
    OS << Sep << S;
74
    Sep = ", ";
75
  }
76
  OS << "}";
77
  return OS;
78
}
79
} // namespace clangd
80
} // namespace clang
81