reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

   49 struct Symbol;

References

   40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
   45   ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
   46   const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
   66   using mapped_type = ValueT;
   69   using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
   71       DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
  185   ValueT lookup(const_arg_type_t<KeyT> Val) const {
  195   std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
  202   std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
  249   std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
  299   ValueT &operator[](const KeyT &Key) {
  311   ValueT &operator[](KeyT &&Key) {
  380         ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
  392       const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
  516                             ValueArgs &&... Values) {
  520     ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
  526                                       ValueT &&Value, LookupKeyT &Lookup) {
  684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
  685                                      KeyT, ValueT, KeyInfoT, BucketT> {
  690   using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
 1163   using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
 1199       const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)

   39     T value;
   72   T &getValue() LLVM_LVALUE_FUNCTION noexcept {
   76   T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
   81   T &&getValue() && noexcept {
   89     ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
   97       ::new ((void *)std::addressof(value)) T(y);
  216   optional_detail::OptionalStorage<T> Storage;
  219   using value_type = T;
  224   Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
  227   Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
  230   Optional &operator=(T &&y) {
  241   static inline Optional create(const T *y) {
  245   Optional &operator=(const T &y) {
  253   const T *getPointer() const { return &Storage.getValue(); }
  254   T *getPointer() { return &Storage.getValue(); }
  255   const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  256   T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  260   const T *operator->() const { return getPointer(); }
  261   T *operator->() { return getPointer(); }
  262   const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
  263   T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
  266   constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
  271   T &&getValue() && { return std::move(Storage.getValue()); }
  272   T &&operator*() && { return std::move(Storage.getValue()); }
  275   T getValueOr(U &&value) && {

   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
   91   typedef PointerLikeTypeTraits<T *> NonConst;
   93   static inline const void *getAsVoidPointer(const T *P) {
   96   static inline const T *getFromVoidPointer(const void *P) {

  313   using Signature_enumeration = void (*)(class IO&, T&);
  322     (sizeof(test<ScalarEnumerationTraits<T>>(nullptr)) == 1);
  329   using Signature_bitset = void (*)(class IO&, T&);
  337   static bool const value = (sizeof(test<ScalarBitSetTraits<T>>(nullptr)) == 1);
  344   using Signature_input = StringRef (*)(StringRef, void*, T&);
  345   using Signature_output = void (*)(const T&, void*, raw_ostream&);
  357       (sizeof(test<ScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
  364   using Signature_input = StringRef (*)(StringRef, void *, T &);
  365   using Signature_output = void (*)(const T &, void *, raw_ostream &);
  375       (sizeof(test<BlockScalarTraits<T>>(nullptr, nullptr)) == 1);
  380   using Signature_input = StringRef (*)(StringRef, StringRef, void *, T &);
  381   using Signature_output = void (*)(const T &, void *, raw_ostream &,
  383   using Signature_mustQuote = QuotingType (*)(const T &, StringRef);
  393       (sizeof(test<TaggedScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
  412   using Signature_mapping = void (*)(class IO &, T &);
  419   static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
  438   using Signature_validate = StringRef (*)(class IO &, T &);
  445   static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
  452   using Signature_size = size_t (*)(class IO&, T&);
  460   static bool const value =  (sizeof(test<SequenceTraits<T>>(nullptr)) == 1);
  467   using Signature_input = void (*)(IO &io, StringRef key, T &v);
  476       (sizeof(test<CustomMappingTraits<T>>(nullptr)) == 1);
  516   using Signature_size = size_t (*)(class IO &, T &);
  524   static bool const value = (sizeof(test<DocumentListTraits<T>>(nullptr))==1);
  528   using Signature_getKind = NodeKind (*)(const T &);
  535   static bool const value = (sizeof(test<PolymorphicTraits<T>>(nullptr)) == 1);
  957 void doMapping(IO &io, T &Val, Context &Ctx) {
  961 template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
  962   MappingTraits<T>::mapping(io, Val);
 1078 typename std::enable_if<unvalidatedMappingTraits<T, Context>::value, void>::type
 1079 yamlize(IO &io, T &Val, bool, Context &Ctx) {
 1080   if (has_FlowTraits<MappingTraits<T>>::value) {
 1791 inline typename std::enable_if<has_MappingTraits<T, EmptyContext>::value,
 1793 operator<<(Output &yout, T &map) {

   91     T t;
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  145       std::is_copy_constructible<detail::trivial_helper<T>>::value;
  147       !std::is_copy_constructible<T>::value;
  151       std::is_move_constructible<detail::trivial_helper<T>>::value;
  153       !std::is_move_constructible<T>::value;
  157       is_copy_assignable<detail::trivial_helper<T>>::value;
  159       !is_copy_assignable<T>::value;
  163       is_move_assignable<detail::trivial_helper<T>>::value;
  165       !is_move_assignable<T>::value;
  169       std::is_destructible<detail::trivial_helper<T>>::value;

  166   const Symbol *IndexResult = nullptr;
  311       Completion.Deprecated |= (C.IndexResult->Flags & Symbol::Deprecated);
 1550     llvm::DenseSet<const Symbol *> UsedIndexResults;
 1567     for (const auto &IndexResult : IndexResults) {

   42 llvm::Expected<Location> symbolToLocation(const Symbol &Sym,

   25 llvm::Expected<Location> symbolToLocation(const Symbol &Sym,

   49 llvm::SmallVector<llvm::StringRef, 1> getRankedIncludes(const Symbol &Sym);

  168   for (const auto &Sym : Syms) {

  192 void SymbolQualitySignals::merge(const Symbol &IndexResult) {
  193   Deprecated |= (IndexResult.Flags & Symbol::Deprecated);
  194   ImplementationDetail |= (IndexResult.Flags & Symbol::ImplementationDetail);
  284 void SymbolRelevanceSignals::merge(const Symbol &IndexResult) {
  288   if (!(IndexResult.Flags & Symbol::VisibleOutsideFile)) {

   78   void merge(const Symbol &IndexResult);
  140   void merge(const Symbol &IndexResult);

  128   Symbol ASTSym, IdxSym;
  132   auto Merged = mergeSymbol(ASTSym, IdxSym);
 1084 symbolToTypeHierarchyItem(const Symbol &S, const SymbolIndex *Index,
 1094   THI.deprecated = (S.Flags & Symbol::Deprecated);

  225     llvm::DenseSet<const Symbol *> Symbols;
  246   for (const auto &Sym : *Index.Symbols) {
  291     for (const auto *S : FileIt.second.Symbols)

  136   std::vector<const Symbol *> AllSymbols;
  137   std::vector<Symbol> SymsStorage;
  140     llvm::DenseMap<SymbolID, Symbol> Merged;
  142       for (const auto &Sym : *Slab) {
  168       for (const auto &Sym : *Slab) {
  209       RefsStorage.size() * sizeof(Ref) + SymsStorage.size() * sizeof(Symbol);

   61                           llvm::function_ref<void(const Symbol &)> CB) const {
   65                        llvm::function_ref<void(const Symbol &)> CB) const {
   74     llvm::function_ref<void(const SymbolID &, const Symbol &)> CB) const {

   96             llvm::function_ref<void(const Symbol &)> Callback) const = 0;
  103          llvm::function_ref<void(const Symbol &)> Callback) const = 0;
  118       llvm::function_ref<void(const SymbolID &Subject, const Symbol &Object)>
  136                  llvm::function_ref<void(const Symbol &)>) const override;
  138               llvm::function_ref<void(const Symbol &)>) const override;
  142                  llvm::function_ref<void(const SymbolID &, const Symbol &)>)

   30     llvm::function_ref<void(const Symbol &)> Callback) const {
   35   TopN<std::pair<float, const Symbol *>> Top(
   40     const Symbol *Sym = Pair.second;
   46         !(Sym->Flags & Symbol::IndexedForCodeCompletion))
   61                       llvm::function_ref<void(const Symbol &)> Callback) const {
   90     llvm::function_ref<void(const SymbolID &, const Symbol &)> Callback) const {

   25     for (const Symbol &S : Symbols)
   53             llvm::function_ref<void(const Symbol &)> Callback) const override;
   56               llvm::function_ref<void(const Symbol &)> Callback) const override;
   62                  llvm::function_ref<void(const SymbolID &, const Symbol &)>
   69   llvm::DenseMap<SymbolID, const Symbol *> Index;

   32     llvm::function_ref<void(const Symbol &)> Callback) const {
   64   for (const Symbol &S : Dyn)
   72     llvm::function_ref<void(const Symbol &)> Callback) const {
   80     const Symbol *Sym = B.find(S.ID);
   88     if (const Symbol *Sym = B.find(ID))
  125     llvm::function_ref<void(const SymbolID &, const Symbol &)> Callback) const {
  165 Symbol mergeSymbol(const Symbol &L, const Symbol &R) {
  165 Symbol mergeSymbol(const Symbol &L, const Symbol &R) {
  165 Symbol mergeSymbol(const Symbol &L, const Symbol &R) {
  176   Symbol S = PreferR ? R : L;        // The target symbol we're merging into.
  177   const Symbol &O = PreferR ? L : R; // The "other" less-preferred symbol.

   20 Symbol mergeSymbol(const Symbol &L, const Symbol &R);
   20 Symbol mergeSymbol(const Symbol &L, const Symbol &R);
   20 Symbol mergeSymbol(const Symbol &L, const Symbol &R);
   40                  llvm::function_ref<void(const Symbol &)>) const override;
   42               llvm::function_ref<void(const Symbol &)>) const override;
   46                  llvm::function_ref<void(const SymbolID &, const Symbol &)>)

  282 void writeSymbol(const Symbol &Sym, const StringTableOut &Strings,
  311 Symbol readSymbol(Reader &Data, llvm::ArrayRef<llvm::StringRef> Strings) {
  312   Symbol Sym;
  532   std::vector<Symbol> Symbols;
  533   for (const auto &Sym : *Data.Symbols) {
  587     for (const auto &Sym : Symbols)

   77 std::string toYAML(const Symbol &);

   14 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Symbol::SymbolFlag F) {
   15   if (F == Symbol::None)
   18   if (F & Symbol::Deprecated)
   20   if (F & Symbol::IndexedForCodeCompletion)
   25 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Symbol &S) {
   29 float quality(const Symbol &S) {
   46 static void own(Symbol &S, llvm::UniqueStringSaver &Strings) {
   50 void SymbolSlab::Builder::insert(const Symbol &S) {
   56   std::vector<Symbol> SortedSymbols;
   65   for (auto &S : SortedSymbols)

  132 inline Symbol::SymbolFlag operator|(Symbol::SymbolFlag A,
  132 inline Symbol::SymbolFlag operator|(Symbol::SymbolFlag A,
  133                                     Symbol::SymbolFlag B) {
  137 inline Symbol::SymbolFlag &operator|=(Symbol::SymbolFlag &A,
  137 inline Symbol::SymbolFlag &operator|=(Symbol::SymbolFlag &A,
  138                                       Symbol::SymbolFlag B) {
  142 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Symbol &S);
  143 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Symbol::SymbolFlag);
  147 template <typename Callback> void visitStrings(Symbol &S, const Callback &CB) {
  173 float quality(const Symbol &S);
  179   using const_iterator = std::vector<Symbol>::const_iterator;
  181   using value_type = Symbol;
  194            Symbols.capacity() * sizeof(Symbol);
  205     void insert(const Symbol &S);
  211     const Symbol *find(const SymbolID &ID) {
  224     llvm::DenseMap<SymbolID, Symbol> Symbols;
  232   std::vector<Symbol> Symbols;  // Sorted by SymbolID to allow lookup.

  327   const Symbol *BasicSymbol = Symbols.find(*ID);
  388   Symbol S;
  392     S.Flags |= Symbol::IndexedForCodeCompletion;
  393     S.Flags |= Symbol::VisibleOutsideFile;
  448 void SymbolCollector::setIncludeLocation(const Symbol &S, SourceLocation Loc) {
  460     if (const auto *S = Symbols.find(ID)) {
  461       Symbol Inc = *S;
  493     if (const Symbol *S = Symbols.find(Entry.first)) {
  497         Symbol NewSym = *S;
  551 const Symbol *SymbolCollector::addDeclaration(const NamedDecl &ND, SymbolID ID,
  556   Symbol S;
  567     S.Flags |= Symbol::IndexedForCodeCompletion;
  569     S.Flags |= Symbol::ImplementationDetail;
  571     S.Flags |= Symbol::VisibleOutsideFile;
  584     S.Flags |= Symbol::Deprecated;
  598   if (!(S.Flags & Symbol::IndexedForCodeCompletion)) {
  614   if (S.Flags & Symbol::IndexedForCodeCompletion) {
  626                                     const Symbol &DeclSym) {
  632   Symbol S = DeclSym;

  123   const Symbol *addDeclaration(const NamedDecl &, SymbolID,
  125   void addDefinition(const NamedDecl &, const Symbol &DeclSymbol);
  139   void setIncludeLocation(const Symbol &S, SourceLocation);

   41   llvm::Optional<clang::clangd::Symbol> Symbol;
   91   NormalizedSymbolFlag(IO &, Symbol::SymbolFlag F) {
   95   Symbol::SymbolFlag denormalize(IO &) {
  177                       clang::clangd::Symbol::IncludeHeaderWithReferences &Inc) {
  184   static void mapping(IO &IO, Symbol &Sym) {
  186     MappingNormalization<NormalizedSymbolFlag, Symbol::SymbolFlag> NSymbolFlag(
  316       MappingTraits<Symbol>::mapping(IO, *Variant.Symbol);
  337   for (const auto &Sym : *O.Symbols) {
  388 std::string toYAML(const Symbol &S) {
  393     Symbol Sym = S; // copy: Yout<< requires mutability.

   50 std::vector<Token> generateSearchTokens(const Symbol &Sym) {
   58   if (Sym.Flags & Symbol::IndexedForCodeCompletion)
   69   std::vector<std::pair<float, const Symbol *>> ScoredSymbols(Symbols.size());
   72     const Symbol *Sym = Symbols[I];
   92     const auto *Sym = Symbols[SymbolRank];
  164                     llvm::function_ref<void(const Symbol &)> Callback) const {
  221     const auto *Sym = Symbols[SymbolDocID];
  243                  llvm::function_ref<void(const Symbol &)> Callback) const {
  268     llvm::function_ref<void(const SymbolID &, const Symbol &)> Callback) const {
  289   size_t Bytes = Symbols.size() * sizeof(const Symbol *);

   75             llvm::function_ref<void(const Symbol &)> Callback) const override;
   78               llvm::function_ref<void(const Symbol &)> Callback) const override;
   84                  llvm::function_ref<void(const SymbolID &, const Symbol &)>
   98   std::vector<const Symbol *> Symbols;
  101   llvm::DenseMap<SymbolID, const Symbol *> LookupTable;

   50           for (const auto &Sym : S) {
   51             if (const auto *Existing = Symbols.find(Sym.ID))

  167   auto Common = *Syms.begin();
  603   Symbol TestSymbol;

   92 std::unique_ptr<SymbolIndex> memIndex(std::vector<Symbol> Symbols) {
   94   for (const auto &Sym : Symbols)
  101                                std::vector<Symbol> IndexSymbols = {},
  118                                std::vector<Symbol> IndexSymbols = {},
  139                                std::vector<Symbol> IndexSymbols = {},
  153                                         std::vector<Symbol> IndexSymbols = {},
  169 Symbol withReferences(int N, Symbol S) {
  169 Symbol withReferences(int N, Symbol S) {
  448   auto Func = func("ns::func");
  674   Symbol Sym = cls("ns::X");
  712   Symbol SymX = cls("ns::X");
  713   Symbol SymY = cls("ns::Y");
  877   Symbol Class = cls("XYZ");
  879       Class.Flags & ~(Symbol::IndexedForCodeCompletion));
  880   Symbol Func = func("XYZ::foooo");
  882       Func.Flags & ~(Symbol::IndexedForCodeCompletion));
 1007                          std::vector<Symbol> IndexSymbols = {}) {
 1025                          std::vector<Symbol> IndexSymbols = {}) {
 1159             llvm::function_ref<void(const Symbol &)> Callback) const override {
 1167               llvm::function_ref<void(const Symbol &)>) const override {}
 1173                  llvm::function_ref<void(const SymbolID &, const Symbol &)>)
 1425   Symbol NoArgsGFunc = func("GFuncC");
 1920   Symbol Foo0 = sym("foo", index::SymbolKind::Function, "@F@\\0#");
 1922   Symbol Foo1 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#");
 1924   Symbol Foo2 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#I#");
 2176   Symbol Sym = func("Func");
 2198   Symbol Sym = func("Func");
 2210   Symbol Sym;
 2214   Sym.Flags |= Symbol::IndexedForCodeCompletion;
 2647   std::vector<Symbol> Syms = {func("xxx"), func("a::xxx"), func("ns::b::xxx"),

  630   auto CodeCompletionSymbol = symbol("Completion");
  631   auto NonCodeCompletionSymbol = symbol("NoCompletion");
  632   CodeCompletionSymbol.Flags = Symbol::SymbolFlag::IndexedForCodeCompletion;
  633   NonCodeCompletionSymbol.Flags = Symbol::SymbolFlag::None;
  634   std::vector<Symbol> Symbols{CodeCompletionSymbol, NonCodeCompletionSymbol};
  645   auto RootSymbol = symbol("root::abc");
  647   auto CloseSymbol = symbol("close::abc");
  650   std::vector<Symbol> Symbols{CloseSymbol, RootSymbol};
  678   auto Foo = symbol("foo");
  679   auto Bar = symbol("bar");
  702   auto Parent = symbol("Parent");
  703   auto Child1 = symbol("Child1");
  704   auto Child2 = symbol("Child2");
  706   std::vector<Symbol> Symbols{Parent, Child1, Child2};
  724   auto Sym1 = symbol("t1");
  726   auto Sym2 = symbol("t2");
  729   std::vector<Symbol> Symbols{Sym1, Sym2};
  748   Symbol S = symbol("TempSpec");

  522     Symbol Sym = cls(S.QName);
  523     Sym.Flags |= Symbol::IndexedForCodeCompletion;
  577   Symbol Sym = cls("ns::X");
  578   Sym.Flags |= Symbol::IndexedForCodeCompletion;

   60 Symbol symbol(llvm::StringRef ID) {
   61   Symbol Sym;
  112   auto X1 = symbol("x");
  114   auto X2 = symbol("x");
  246   Symbol Vector = *It++;
  247   Symbol MakeVector = *It++;
  319   auto Foo =

  125   std::vector<Symbol> Symbols = {symbol("1"), symbol("2"), symbol("3"),
  230   Symbol S = symbol("TempSpec");
  291   Symbol L, R;
  305   Symbol M = mergeSymbol(L, R);
  318   Symbol L, R;
  326   Symbol M = mergeSymbol(L, R);
  339   Symbol L, R;
  345   Symbol M = mergeSymbol(L, R);
  361   auto Foo = findSymbol(HeaderSymbols, "Foo");
  411   Symbol L, R;
  416   Symbol M = mergeSymbol(L, R);
  425   Symbol L, R;
  434   Symbol M = mergeSymbol(L, R);

   67   Symbol F = findSymbol(Symbols, "_f");
  388   const Symbol &FooSym = findSymbol(Symbols, "Foo::foo");
  391   const Symbol &BarSym = findSymbol(Symbols, "Foo::bar");
  396   const Symbol &TplSym = findSymbol(Symbols, "Foo::tpl");
  440   const Symbol &CtorSym = findSymbol(Symbols, "Foo::Foo");

  117   auto Sym1 = *ParsedYAML->Symbols->find(
  119   auto Sym2 = *ParsedYAML->Symbols->find(
  162   for (const auto &Sym : Slab)

   89   return static_cast<bool>(arg.Flags & Symbol::IndexedForCodeCompletion) ==
   92 MATCHER(Deprecated, "") { return arg.Flags & Symbol::Deprecated; }
   94   return arg.Flags & Symbol::ImplementationDetail;
   97   return static_cast<bool>(arg.Flags & Symbol::VisibleOutsideFile);
  690   const Symbol &Base = findSymbol(Symbols, "Base");
  691   const Symbol &Derived = findSymbol(Symbols, "Derived");

   16 Symbol symbol(llvm::StringRef QName) {
   17   Symbol Sym;
   39 Symbol sym(llvm::StringRef QName, index::SymbolKind Kind,
   41   Symbol Sym;
   55   Sym.Flags |= Symbol::IndexedForCodeCompletion;
   60 Symbol func(llvm::StringRef Name) { // Assumes the function has no args.
   64 Symbol cls(llvm::StringRef Name) {
   68 Symbol var(llvm::StringRef Name) {
   72 Symbol ns(llvm::StringRef Name) {
   90 std::string getQualifiedName(const Symbol &Sym) {

   19 Symbol symbol(llvm::StringRef QName);
   23 Symbol sym(llvm::StringRef QName, index::SymbolKind Kind,
   26 Symbol func(llvm::StringRef Name);
   28 Symbol cls(llvm::StringRef Name);
   30 Symbol var(llvm::StringRef Name);
   32 Symbol ns(llvm::StringRef Name);
   41 std::string getQualifiedName(const Symbol &Sym);

   97 const Symbol &findSymbol(const SymbolSlab &Slab, llvm::StringRef QName) {
   98   const Symbol *Result = nullptr;
   99   for (const Symbol &S : Slab) {

   73 const Symbol &findSymbol(const SymbolSlab &, llvm::StringRef QName);

 1832   Symbol IndexSym = func("indexSymbol");

  387       using allocator_type = allocator<_Tp>;
  389       using value_type = _Tp;
  392       using pointer = _Tp*;
  395       using const_pointer = const _Tp*;
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  475 	{ __a.construct(__p, std::forward<_Args>(__args)...); }
  486 	destroy(allocator_type& __a, _Up* __p)

  108     class allocator: public __allocator_base<_Tp>
  113       typedef _Tp*       pointer;
  114       typedef const _Tp* const_pointer;
  115       typedef _Tp&       reference;
  116       typedef const _Tp& const_reference;
  117       typedef _Tp        value_type;
  137 	allocator(const allocator<_Tp1>&) throw() { }

   46     inline _GLIBCXX_CONSTEXPR _Tp*
   47     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept
  104     : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
  105                     is_copy_constructible<_Tp>>::type { };
  136     inline _GLIBCXX17_CONSTEXPR _Tp*
  137     addressof(_Tp& __r) noexcept
  143     const _Tp* addressof(const _Tp&&) = delete;
  143     const _Tp* addressof(const _Tp&&) = delete;
  184     typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
  185 			      is_move_constructible<_Tp>,
  186 			      is_move_assignable<_Tp>>::value>::type
  187     swap(_Tp& __a, _Tp& __b)
  187     swap(_Tp& __a, _Tp& __b)
  198       _Tp __tmp = _GLIBCXX_MOVE(__a);

  176 	operator()(_Iterator __it, _Value& __val)
  214 	operator()(_Value& __val, _Iterator __it)

   74     _Construct(_T1* __p, _Args&&... __args)
   74     _Construct(_T1* __p, _Args&&... __args)
   75     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
   97     _Destroy(_Tp* __pointer)
  204 	     allocator<_Tp>&)

  129 		_Distance __holeIndex, _Distance __topIndex, _Tp __value,
  215 		  _Distance __len, _Tp __value, _Compare __comp)

 1224     __make_move_if_noexcept_iterator(_Tp* __i)

  181       typedef _Tp                         value_type;
  183       typedef _Tp*                        pointer;
  184       typedef _Tp&                        reference;
  192       typedef _Tp                         value_type;
  194       typedef const _Tp*                  pointer;
  195       typedef const _Tp&                  reference;

  209     : private __pair_base<_T1, _T2>
  212       typedef _T2 second_type;   /// @c second_type is the second bound type
  215       _T2 second;                /// @c second is a copy of the second object
  252       using _PCCP = _PCC<true, _T1, _T2>;
  260       constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  283 			    _T1, _T2>;
  311        constexpr pair(_U1&& __x, const _T2& __y)
  318        explicit constexpr pair(_U1&& __x, const _T2& __y)
  380 		       is_copy_assignable<_T2>>::value,
  391 		       is_move_assignable<_T2>>::value,
  403 				is_assignable<_T2&, const _U2&>>::value,
  403 				is_assignable<_T2&, const _U2&>>::value,
  405 	operator=(const pair<_U1, _U2>& __p)
  414 				is_assignable<_T2&, _U2&&>>::value,
  414 				is_assignable<_T2&, _U2&&>>::value,
  416 	operator=(pair<_U1, _U2>&& __p)

  288 			   _ForwardIterator __result, allocator<_Tp>&)

   77 	rebind<_Tp>::other _Tp_alloc_type;
  216     class vector : protected _Vector_base<_Tp, _Alloc>
  227       typedef _Vector_base<_Tp, _Alloc>			_Base;
  232       typedef _Tp					value_type;
  919       _Tp*
  923       const _Tp*
  962 	emplace_back(_Args&&... __args);
 1483 	_M_realloc_insert(iterator __position, _Args&&... __args);

  101 				     std::forward<_Args>(__args)...);
  105 	  _M_realloc_insert(end(), std::forward<_Args>(__args)...);
  418 				   std::forward<_Args>(__args)...);

  117       { typedef typename _Base_type::template rebind_alloc<_Tp> other; };

   63       typedef _Tp*       pointer;
   64       typedef const _Tp* const_pointer;
   65       typedef _Tp&       reference;
   66       typedef const _Tp& const_reference;
   67       typedef _Tp        value_type;
   84 	new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
  111 	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
  130       { return size_t(-1) / sizeof(_Tp); }
  135 	construct(_Up* __p, _Args&&... __args)
  135 	construct(_Up* __p, _Args&&... __args)
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  140 	destroy(_Up* __p) { __p->~_Up(); }

   50       typedef _E 		value_type;
   51       typedef const _E& 	reference;
   52       typedef const _E& 	const_reference;
   54       typedef const _E* 	iterator;
   55       typedef const _E* 	const_iterator;

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  326     : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
  354     : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
  567     : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  631     : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  762     typename add_rvalue_reference<_Tp>::type declval() noexcept;
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  798       typedef decltype(__test<_Tp>(0)) type;
  811                remove_all_extents<_Tp>::type>::type
  825     : public __is_destructible_safe<_Tp>::type
  889       typedef decltype(__test<_Tp>(0)) type;
  894     : public __and_<__not_<is_void<_Tp>>,
  895                     __is_default_constructible_impl<_Tp>>
  915     : public __is_default_constructible_atom<_Tp>::type
  921     : public __is_default_constructible_safe<_Tp>::type
  984       typedef decltype(__test<_Tp, _Arg>(0)) type;
  989     : public __and_<is_destructible<_Tp>,
  990                     __is_direct_constructible_impl<_Tp, _Arg>>
 1072 			 __is_direct_constructible_ref_cast<_Tp, _Arg>,
 1073 			 __is_direct_constructible_new_safe<_Tp, _Arg>
 1079     : public __is_direct_constructible_new<_Tp, _Arg>::type
 1119     : public __is_direct_constructible<_Tp, _Arg>
 1130     : public __is_constructible_impl<_Tp, _Args...>::type
 1142     : public is_constructible<_Tp, const _Tp&>
 1142     : public is_constructible<_Tp, const _Tp&>
 1148     : public __is_copy_constructible_impl<_Tp>
 1160     : public is_constructible<_Tp, _Tp&&>
 1160     : public is_constructible<_Tp, _Tp&&>
 1166     : public __is_move_constructible_impl<_Tp>
 1215     : public __and_<is_constructible<_Tp, _Args...>,
 1216 		    __is_nt_constructible_impl<_Tp, _Args...>>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1252     : public __is_nothrow_move_constructible_impl<_Tp>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1292     : public __is_copy_assignable_impl<_Tp>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1310     : public __is_move_assignable_impl<_Tp>
 1377     static void __helper(const _Tp&);
 1380     static true_type __test(const _Tp&,
 1381                             decltype(__helper<const _Tp&>({}))* = 0);
 1390     typedef decltype(__test(declval<_Tp>())) type;
 1395       : public __is_implicitly_default_constructible_impl<_Tp>::type
 1400       : public __and_<is_default_constructible<_Tp>,
 1401                       __is_implicitly_default_constructible_safe<_Tp>>
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 1955     { typedef _Tp     type; };
 2574       typename remove_reference<_Tp>::type>::type>::type

 1809   bool operator()(const T& x) const {
 1824     return MatcherCast<const T&>(matcher_).Matches(x);
 1844   AssertionResult operator()(const char* value_text, const T& x) const {
 1856     const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
 1856     const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
 2200   bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
 2211   bool MatchAndExplainImpl(false_type /* is_not_pointer */, const Class& obj,
 2217   bool MatchAndExplainImpl(true_type /* is_pointer */, const Class* p,
 3914   internal::FieldMatcher<Class, FieldType> > Field(

  116   inline Message& operator <<(const T& val) {

  223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
  366 void UniversalPrint(const T& value, ::std::ostream* os);
  373                     const C& container, ::std::ostream* os) {
  439                     const T& value, ::std::ostream* os) {
  455 void PrintTo(const T& value, ::std::ostream* os) {
  478   DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
  699   static void Print(const T& value, ::std::ostream* os) {
  784   static void Print(const T& value, ::std::ostream* os) {
  853 void UniversalPrint(const T& value, ::std::ostream* os) {
  856   typedef T T1;
  981 ::std::string PrintToString(const T& value) {
  983   internal::UniversalTersePrinter<T>::Print(value, &ss);

   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   37   return StreamSwitch<T>::printable(V);
   54   const T& V;
   55   friend std::ostream &operator<<(std::ostream &S, const RawStreamProxy<T> &V) {
   69   static const RawStreamProxy<T> printable(const T &V) { return {V}; }
   69   static const RawStreamProxy<T> printable(const T &V) { return {V}; }

  795 struct RemoveConst { typedef T type; };  // NOLINT