|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
include/llvm/ADT/ArrayRef.h 43 using iterator = const T *;
44 using const_iterator = const T *;
50 const T *Data = nullptr;
66 /*implicit*/ ArrayRef(const T &OneElt)
70 /*implicit*/ ArrayRef(const T *data, size_t length)
74 ArrayRef(const T *begin, const T *end)
74 ArrayRef(const T *begin, const T *end)
81 /*implicit*/ ArrayRef(const SmallVectorTemplateCommon<T, U> &Vec)
87 /*implicit*/ ArrayRef(const std::vector<T, A> &Vec)
92 /*implicit*/ constexpr ArrayRef(const std::array<T, N> &Arr)
97 /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
100 /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec)
145 const T *data() const { return Data; }
151 const T &front() const {
157 const T &back() const {
163 template <typename Allocator> ArrayRef<T> copy(Allocator &A) {
178 ArrayRef<T> slice(size_t N, size_t M) const {
184 ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); }
187 ArrayRef<T> drop_front(size_t N = 1) const {
193 ArrayRef<T> drop_back(size_t N = 1) const {
200 template <class PredicateT> ArrayRef<T> drop_while(PredicateT Pred) const {
206 template <class PredicateT> ArrayRef<T> drop_until(PredicateT Pred) const {
211 ArrayRef<T> take_front(size_t N = 1) const {
218 ArrayRef<T> take_back(size_t N = 1) const {
226 template <class PredicateT> ArrayRef<T> take_while(PredicateT Pred) const {
232 template <class PredicateT> ArrayRef<T> take_until(PredicateT Pred) const {
239 const T &operator[](size_t Index) const {
249 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
257 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
263 std::vector<T> vec() const {
270 operator std::vector<T>() const {
include/llvm/ADT/DenseMap.h 40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
43 KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
44 const KeyT &getFirst() const { return std::pair<KeyT, ValueT>::first; }
45 ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
46 const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
65 using key_type = KeyT;
66 using mapped_type = ValueT;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
78 if (shouldReverseIterate<KeyT>())
88 if (shouldReverseIterate<KeyT>())
121 const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
122 if (is_trivially_copyable<KeyT>::value &&
145 size_type count(const_arg_type_t<KeyT> Val) const {
150 iterator find(const_arg_type_t<KeyT> Val) {
156 const_iterator find(const_arg_type_t<KeyT> Val) const {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
195 std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
195 std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
202 std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
202 std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
210 std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
229 std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
249 std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
249 std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
272 bool erase(const KeyT &Val) {
291 value_type& FindAndConstruct(const KeyT &Key) {
299 ValueT &operator[](const KeyT &Key) {
299 ValueT &operator[](const KeyT &Key) {
303 value_type& FindAndConstruct(KeyT &&Key) {
311 ValueT &operator[](KeyT &&Key) {
311 ValueT &operator[](KeyT &&Key) {
334 const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
349 const KeyT EmptyKey = getEmptyKey();
351 ::new (&B->getFirst()) KeyT(EmptyKey);
369 const KeyT EmptyKey = getEmptyKey();
370 const KeyT TombstoneKey = getTombstoneKey();
380 ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
399 if (is_trivially_copyable<KeyT>::value &&
406 KeyT(other.getBuckets()[i].getFirst());
414 static unsigned getHashValue(const KeyT &Val) {
419 static unsigned getHashValue(const LookupKeyT &Val) {
423 static const KeyT getEmptyKey() {
429 static const KeyT getTombstoneKey() {
437 if (shouldReverseIterate<KeyT>()) {
447 if (shouldReverseIterate<KeyT>()) {
515 BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
520 ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
525 BucketT *InsertIntoBucketWithLookup(BucketT *TheBucket, KeyT &&Key,
526 ValueT &&Value, LookupKeyT &Lookup) {
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
566 const KeyT EmptyKey = getEmptyKey();
578 bool LookupBucketFor(const LookupKeyT &Val,
590 const KeyT EmptyKey = getEmptyKey();
591 const KeyT TombstoneKey = getTombstoneKey();
629 bool LookupBucketFor(const LookupKeyT &Val, BucketT *&FoundBucket) {
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
685 KeyT, ValueT, KeyInfoT, BucketT> {
685 KeyT, ValueT, KeyInfoT, BucketT> {
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
1163 using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
1186 if (shouldReverseIterate<KeyT>()) {
1199 const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
1204 if (shouldReverseIterate<KeyT>())
1210 if (shouldReverseIterate<KeyT>())
1232 if (shouldReverseIterate<KeyT>()) {
1249 const KeyT Empty = KeyInfoT::getEmptyKey();
1250 const KeyT Tombstone = KeyInfoT::getTombstoneKey();
1259 const KeyT Empty = KeyInfoT::getEmptyKey();
1260 const KeyT Tombstone = KeyInfoT::getTombstoneKey();
include/llvm/ADT/DenseMapInfo.h 186 using Pair = std::pair<T, U>;
186 using Pair = std::pair<T, U>;
187 using FirstInfo = DenseMapInfo<T>;
188 using SecondInfo = DenseMapInfo<U>;
include/llvm/ADT/DenseSet.h 35 KeyT key;
38 KeyT &getFirst() { return key; }
39 const KeyT &getFirst() const { return key; }
55 static_assert(sizeof(typename MapTy::value_type) == sizeof(ValueT),
63 using key_type = ValueT;
64 using value_type = ValueT;
69 DenseSetImpl(std::initializer_list<ValueT> Elems)
91 size_type count(const_arg_type_t<ValueT> V) const {
95 bool erase(const ValueT &V) {
112 using value_type = ValueT;
120 ValueT &operator*() { return I->getFirst(); }
121 const ValueT &operator*() const { return I->getFirst(); }
122 ValueT *operator->() { return &I->getFirst(); }
123 const ValueT *operator->() const { return &I->getFirst(); }
138 using value_type = ValueT;
147 const ValueT &operator*() const { return I->getFirst(); }
148 const ValueT *operator->() const { return &I->getFirst(); }
165 iterator find(const_arg_type_t<ValueT> V) { return Iterator(TheMap.find(V)); }
166 const_iterator find(const_arg_type_t<ValueT> V) const {
187 std::pair<iterator, bool> insert(const ValueT &V) {
192 std::pair<iterator, bool> insert(ValueT &&V) {
200 std::pair<iterator, bool> insert_as(const ValueT &V,
205 std::pair<iterator, bool> insert_as(ValueT &&V, const LookupKeyT &LookupKey) {
250 ValueT, DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,
250 ValueT, DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,
251 detail::DenseSetPair<ValueT>>,
254 detail::DenseSetImpl<ValueT,
255 DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,
256 detail::DenseSetPair<ValueT>>,
260 using BaseT::BaseT;
include/llvm/ADT/Optional.h 144 T value;
160 explicit OptionalStorage(in_place_t, Args &&... args)
161 : value(std::forward<Args>(args)...), hasVal(true) {}
172 T &getValue() LLVM_LVALUE_FUNCTION noexcept {
176 T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
181 T &&getValue() && noexcept {
206 ::new ((void *)std::addressof(value)) T(std::move(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) && {
282 bool operator==(const Optional<T> &X, const Optional<U> &Y) {
282 bool operator==(const Optional<T> &X, const Optional<U> &Y) {
316 bool operator==(const Optional<T> &X, NoneType) {
321 bool operator==(NoneType, const Optional<T> &X) {
include/llvm/Support/AlignOf.h 30 T t;
39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
50 llvm::detail::SizerImpl<T, Ts...>)];
include/llvm/Support/Error.h 437 static const bool isRef = std::is_reference<T>::value;
439 using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
444 using storage_type = typename std::conditional<isRef, wrap, T>::type;
445 using value_type = T;
448 using reference = typename std::remove_reference<T>::type &;
449 using const_reference = const typename std::remove_reference<T>::type &;
450 using pointer = typename std::remove_reference<T>::type *;
451 using const_pointer = const typename std::remove_reference<T>::type *;
474 Expected(OtherT &&Val,
475 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
475 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
483 new (getStorage()) storage_type(std::forward<OtherT>(Val));
492 Expected(Expected<OtherT> &&Other,
493 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
493 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
594 template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
731 T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
731 T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
include/llvm/Support/YAMLTraits.h 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);
849 template <typename T> void mapRequired(const char *Key, T &Val) {
941 void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
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) {
1310 MappingNormalization(IO &i_o, TFinal &Obj)
1335 TFinal &Result;
include/llvm/Support/type_traits.h 31 using UnderlyingT = typename std::remove_reference<T>::type;
65 using type = const T &;
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;
tools/clang/tools/extra/clangd/AST.cpp 199 llvm::Optional<SymbolID> getSymbolID(const Decl *D) {
206 llvm::Optional<SymbolID> getSymbolID(const IdentifierInfo &II,
tools/clang/tools/extra/clangd/AST.h 63 llvm::Optional<SymbolID> getSymbolID(const Decl *D);
72 llvm::Optional<SymbolID> getSymbolID(const IdentifierInfo &II,
tools/clang/tools/extra/clangd/CodeComplete.cpp 487 llvm::Optional<SymbolID> getSymbolID(const CodeCompletionResult &R,
794 llvm::Optional<SymbolID> IDForDoc;
852 llvm::DenseMap<SymbolID, std::string> FetchedDocs;
tools/clang/tools/extra/clangd/IncludeFixer.cpp 427 IncludeFixer::lookupCached(const SymbolID &ID) const {
tools/clang/tools/extra/clangd/IncludeFixer.h 88 mutable llvm::DenseMap<SymbolID, SymbolSlab> LookupCache;
92 llvm::Optional<const SymbolSlab *> lookupCached(const SymbolID &ID) const;
tools/clang/tools/extra/clangd/Protocol.h 859 llvm::Optional<SymbolID> ID;
tools/clang/tools/extra/clangd/XRefs.cpp 286 llvm::DenseMap<SymbolID, size_t> ResultIndex;
1108 static void fillSubTypes(const SymbolID &ID,
1241 if (Optional<SymbolID> ID = getSymbolID(CXXRD))
1262 if (Expected<SymbolID> ID = SymbolID::fromStr(*Item.data)) {
1262 if (Expected<SymbolID> ID = SymbolID::fromStr(*Item.data)) {
tools/clang/tools/extra/clangd/index/Background.cpp 245 llvm::DenseMap<SymbolID, File *> SymbolIDToFile;
267 llvm::DenseMap<const Ref *, SymbolID> RefToIDs;
tools/clang/tools/extra/clangd/index/FileIndex.cpp 140 llvm::DenseMap<SymbolID, Symbol> Merged;
166 llvm::DenseSet<SymbolID> AddedSymbols;
179 llvm::DenseMap<SymbolID, llvm::ArrayRef<Ref>> AllRefs;
181 llvm::DenseMap<SymbolID, llvm::SmallVector<Ref, 4>> MergedRefs;
tools/clang/tools/extra/clangd/index/Index.cpp 74 llvm::function_ref<void(const SymbolID &, const Symbol &)> CB) const {
tools/clang/tools/extra/clangd/index/Index.h 64 llvm::DenseSet<SymbolID> IDs;
68 llvm::DenseSet<SymbolID> IDs;
77 llvm::DenseSet<SymbolID> Subjects;
118 llvm::function_ref<void(const SymbolID &Subject, const Symbol &Object)>
142 llvm::function_ref<void(const SymbolID &, const Symbol &)>)
tools/clang/tools/extra/clangd/index/MemIndex.cpp 63 for (const auto &ID : Req.IDs) {
75 for (const auto &ReqID : Req.IDs) {
90 llvm::function_ref<void(const SymbolID &, const Symbol &)> Callback) const {
93 for (const SymbolID &Subject : Req.Subjects) {
98 for (const auto &Obj : It->second) {
tools/clang/tools/extra/clangd/index/MemIndex.h 27 for (const std::pair<SymbolID, llvm::ArrayRef<Ref>> &R : Refs)
62 llvm::function_ref<void(const SymbolID &, const Symbol &)>
69 llvm::DenseMap<SymbolID, const Symbol *> Index;
71 llvm::DenseMap<SymbolID, llvm::ArrayRef<Ref>> Refs;
75 llvm::DenseMap<std::pair<SymbolID, uint8_t>, std::vector<SymbolID>> Relations;
75 llvm::DenseMap<std::pair<SymbolID, uint8_t>, std::vector<SymbolID>> Relations;
tools/clang/tools/extra/clangd/index/Merge.cpp 51 llvm::DenseSet<SymbolID> SeenDynamicSymbols;
87 for (const auto &ID : RemainingIDs)
125 llvm::function_ref<void(const SymbolID &, const Symbol &)> Callback) const {
131 llvm::DenseSet<std::pair<SymbolID, SymbolID>> SeenRelations;
131 llvm::DenseSet<std::pair<SymbolID, SymbolID>> SeenRelations;
tools/clang/tools/extra/clangd/index/Merge.h 46 llvm::function_ref<void(const SymbolID &, const Symbol &)>)
tools/clang/tools/extra/clangd/index/Ref.cpp 35 void RefSlab::Builder::insert(const SymbolID &ID, const Ref &S) {
48 std::vector<std::pair<SymbolID, llvm::ArrayRef<Ref>>> Result;
tools/clang/tools/extra/clangd/index/Ref.h 72 using value_type = std::pair<SymbolID, llvm::ArrayRef<Ref>>;
97 void insert(const SymbolID &ID, const Ref &S);
104 llvm::DenseMap<SymbolID, std::set<Ref>> Refs;
tools/clang/tools/extra/clangd/index/Relation.cpp 17 RelationSlab::lookup(const SymbolID &Subject, RelationKind Predicate) const {
tools/clang/tools/extra/clangd/index/Relation.h 30 SymbolID Subject;
32 SymbolID Object;
65 llvm::iterator_range<iterator> lookup(const SymbolID &Subject,
tools/clang/tools/extra/clangd/index/Serialization.cpp 107 SymbolID consumeID() {
108 llvm::StringRef Raw = consume(SymbolID::RawSize); // short if truncated.
109 return LLVM_UNLIKELY(err()) ? SymbolID() : SymbolID::fromRaw(Raw);
344 void writeRefs(const SymbolID &ID, llvm::ArrayRef<Ref> Refs,
354 std::pair<SymbolID, std::vector<Ref>>
356 std::pair<SymbolID, std::vector<Ref>> Result;
380 SymbolID Subject = Data.consumeID();
382 SymbolID Object = Data.consumeID();
546 std::vector<std::pair<SymbolID, std::vector<Ref>>> Refs;
tools/clang/tools/extra/clangd/index/Serialization.h 78 std::string toYAML(const std::pair<SymbolID, ArrayRef<Ref>> &);
tools/clang/tools/extra/clangd/index/Symbol.cpp 37 SymbolSlab::const_iterator SymbolSlab::find(const SymbolID &ID) const {
tools/clang/tools/extra/clangd/index/Symbol.h 38 SymbolID ID;
187 const_iterator find(const SymbolID &SymID) const;
208 void erase(const SymbolID &ID) { Symbols.erase(ID); }
211 const Symbol *find(const SymbolID &ID) {
224 llvm::DenseMap<SymbolID, Symbol> Symbols;
tools/clang/tools/extra/clangd/index/SymbolCollector.cpp 419 const NamedDecl &ND, const SymbolID &ID,
551 const Symbol *SymbolCollector::addDeclaration(const NamedDecl &ND, SymbolID ID,
tools/clang/tools/extra/clangd/index/SymbolCollector.h 123 const Symbol *addDeclaration(const NamedDecl &, SymbolID,
126 void processRelations(const NamedDecl &ND, const SymbolID &ID,
138 llvm::DenseMap<SymbolID, FileID> IncludeFiles;
tools/clang/tools/extra/clangd/index/SymbolID.cpp 26 SymbolID SymbolID::fromRaw(llvm::StringRef Raw) {
27 SymbolID ID;
35 llvm::Expected<SymbolID> SymbolID::fromStr(llvm::StringRef Str) {
46 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SymbolID &ID) {
50 llvm::hash_code hash_value(const SymbolID &ID) {
52 static_assert(sizeof(size_t) <= SymbolID::RawSize,
tools/clang/tools/extra/clangd/index/SymbolID.h 36 bool operator==(const SymbolID &Sym) const {
39 bool operator<(const SymbolID &Sym) const {
47 static SymbolID fromRaw(llvm::StringRef);
51 static llvm::Expected<SymbolID> fromStr(llvm::StringRef);
57 llvm::hash_code hash_value(const SymbolID &ID);
60 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SymbolID &ID);
68 static inline clang::clangd::SymbolID getEmptyKey() {
69 static clang::clangd::SymbolID EmptyKey("EMPTYKEY");
72 static inline clang::clangd::SymbolID getTombstoneKey() {
73 static clang::clangd::SymbolID TombstoneKey("TOMBSTONEKEY");
76 static unsigned getHashValue(const clang::clangd::SymbolID &Sym) {
79 static bool isEqual(const clang::clangd::SymbolID &LHS,
80 const clang::clangd::SymbolID &RHS) {
tools/clang/tools/extra/clangd/index/YAMLSerialization.cpp 38 std::pair<clang::clangd::SymbolID, std::vector<clang::clangd::Ref>>;
72 NormalizedSymbolID(IO &, const SymbolID &ID) {
77 SymbolID denormalize(IO &I) {
78 auto ID = SymbolID::fromStr(HexString);
185 MappingNormalization<NormalizedSymbolID, SymbolID> NSymbolID(IO, Sym.ID);
259 MappingNormalization<NormalizedSymbolID, SymbolID> NSymbolID(IO,
295 static void mapping(IO &IO, SymbolID &ID) {
296 MappingNormalization<NormalizedSymbolID, SymbolID> NSymbolID(IO, ID);
399 std::string toYAML(const std::pair<SymbolID, llvm::ArrayRef<Ref>> &Data) {
tools/clang/tools/extra/clangd/index/dex/Dex.cpp 245 for (const auto &ID : Req.IDs) {
257 for (const auto &ID : Req.IDs)
268 llvm::function_ref<void(const SymbolID &, const Symbol &)> Callback) const {
272 for (const SymbolID &Subject : Req.Subjects) {
277 for (const auto &Object : It->second) {
tools/clang/tools/extra/clangd/index/dex/Dex.h 84 llvm::function_ref<void(const SymbolID &, const Symbol &)>
101 llvm::DenseMap<SymbolID, const Symbol *> LookupTable;
110 llvm::DenseMap<SymbolID, llvm::ArrayRef<Ref>> Refs;
113 llvm::DenseMap<std::pair<SymbolID, uint8_t>, std::vector<SymbolID>> Relations;
113 llvm::DenseMap<std::pair<SymbolID, uint8_t>, std::vector<SymbolID>> Relations;
tools/clang/tools/extra/clangd/index/dex/dexp/Dexp.cpp 50 std::vector<SymbolID> getSymbolIDsFromIndex(llvm::StringRef QualifiedName,
65 std::vector<SymbolID> SymIDs;
175 std::vector<SymbolID> IDs;
177 auto SID = SymbolID::fromStr(ID);
222 std::vector<SymbolID> IDs;
224 auto SID = SymbolID::fromStr(ID);
tools/clang/tools/extra/clangd/unittests/BackgroundIndexTests.cpp 240 SymbolID A = findSymbol(*ShardHeader->Symbols, "A_CC").ID;
241 SymbolID B = findSymbol(*ShardSource->Symbols, "B_CC").ID;
tools/clang/tools/extra/clangd/unittests/CodeCompleteTests.cpp 1173 llvm::function_ref<void(const SymbolID &, const Symbol &)>)
tools/clang/tools/extra/clangd/unittests/DexTests.cpp 671 llvm::DenseMap<SymbolID, std::vector<Ref>> Refs;
713 std::vector<SymbolID> Results;
tools/clang/tools/extra/clangd/unittests/FileIndexTests.cpp 74 std::unique_ptr<RefSlab> refSlab(const SymbolID &ID, const char *Path) {
129 SymbolID ID("1");
363 SymbolID A = findSymbol(TU.headerSymbols(), "A").ID;
tools/clang/tools/extra/clangd/unittests/IndexTests.cpp 80 SymbolID A{"A"};
81 SymbolID B{"B"};
82 SymbolID C{"C"};
83 SymbolID D{"D"};
98 SymbolID A{"A"};
99 SymbolID B{"B"};
100 SymbolID C{"C"};
tools/clang/tools/extra/clangd/unittests/SerializationTests.cpp 96 MATCHER_P(ID, I, "") { return arg.ID == cantFail(SymbolID::fromStr(I)); }
118 cantFail(SymbolID::fromStr("057557CEBF6E6B2D")));
120 cantFail(SymbolID::fromStr("057557CEBF6E6B2E")));
152 SymbolID Base = cantFail(SymbolID::fromStr("6481EE7AF2841756"));
152 SymbolID Base = cantFail(SymbolID::fromStr("6481EE7AF2841756"));
153 SymbolID Derived = cantFail(SymbolID::fromStr("6512AEC512EA3A2D"));
153 SymbolID Derived = cantFail(SymbolID::fromStr("6512AEC512EA3A2D"));
tools/clang/tools/extra/clangd/unittests/SyncAPI.cpp 140 RefSlab getRefs(const SymbolIndex &Index, SymbolID ID) {
tools/clang/tools/extra/clangd/unittests/SyncAPI.h 54 RefSlab getRefs(const SymbolIndex &Index, SymbolID ID);
tools/clang/tools/extra/clangd/unittests/TestIndex.cpp 107 llvm::ArrayRef<SymbolID> IDs) {
tools/clang/tools/extra/clangd/unittests/TestIndex.h 52 llvm::ArrayRef<SymbolID> IDs);
tools/clang/tools/extra/clangd/unittests/TypeHierarchyTests.cpp 463 SymbolID findSymbolIDByName(SymbolIndex *Index, llvm::StringRef Name,
465 SymbolID Result;
481 std::vector<SymbolID> collectSubtypes(SymbolID Subject, SymbolIndex *Index) {
481 std::vector<SymbolID> collectSubtypes(SymbolID Subject, SymbolIndex *Index) {
482 std::vector<SymbolID> Result;
504 SymbolID Parent = findSymbolIDByName(Index.get(), "Parent");
505 SymbolID Child1a = findSymbolIDByName(Index.get(), "Child1a");
506 SymbolID Child1b = findSymbolIDByName(Index.get(), "Child1b");
507 SymbolID Child2 = findSymbolIDByName(Index.get(), "Child2");
525 SymbolID Parent1 = findSymbolIDByName(Index.get(), "Parent1");
526 SymbolID Parent2 = findSymbolIDByName(Index.get(), "Parent2");
527 SymbolID Parent3 = findSymbolIDByName(Index.get(), "Parent3");
528 SymbolID Child = findSymbolIDByName(Index.get(), "Child");
546 SymbolID Parent = findSymbolIDByName(Index.get(), "Parent");
547 SymbolID Child = findSymbolIDByName(Index.get(), "Child");
568 SymbolID Parent = findSymbolIDByName(Index.get(), "Parent");
569 SymbolID ParentSpec = findSymbolIDByName(Index.get(), "Parent", "<int>");
570 SymbolID Child1 = findSymbolIDByName(Index.get(), "Child1");
571 SymbolID Child2 = findSymbolIDByName(Index.get(), "Child2");
591 SymbolID Parent = findSymbolIDByName(Index.get(), "Parent");
592 SymbolID ChildSpec = findSymbolIDByName(Index.get(), "Child", "<int>");
609 SymbolID Parent = findSymbolIDByName(Index.get(), "Parent");
610 SymbolID Child = findSymbolIDByName(Index.get(), "Child");
tools/clang/tools/extra/clangd/unittests/XRefsTests.cpp 2157 mutable Optional<llvm::DenseSet<SymbolID>> RefIDs;
usr/include/c++/7.4.0/bits/alloc_traits.h 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)
486 destroy(allocator_type& __a, _Up* __p)
usr/include/c++/7.4.0/bits/allocator.h 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() { }
usr/include/c++/7.4.0/bits/move.h 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;
usr/include/c++/7.4.0/bits/stl_algobase.h 356 static _Tp*
357 __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
357 __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
357 __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
361 is_move_assignable<_Tp>,
362 is_copy_assignable<_Tp>>;
368 __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
usr/include/c++/7.4.0/bits/stl_construct.h 204 allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_iterator.h 1224 __make_move_if_noexcept_iterator(_Tp* __i)
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 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;
usr/include/c++/7.4.0/bits/stl_pair.h 100 return __and_<is_constructible<_T1, const _U1&>,
100 return __and_<is_constructible<_T1, const _U1&>,
101 is_constructible<_T2, const _U2&>>::value;
101 is_constructible<_T2, const _U2&>>::value;
107 return __and_<is_convertible<const _U1&, _T1>,
107 return __and_<is_convertible<const _U1&, _T1>,
108 is_convertible<const _U2&, _T2>>::value;
108 is_convertible<const _U2&, _T2>>::value;
114 return __and_<is_constructible<_T1, _U1&&>,
114 return __and_<is_constructible<_T1, _U1&&>,
115 is_constructible<_T2, _U2&&>>::value;
115 is_constructible<_T2, _U2&&>>::value;
121 return __and_<is_convertible<_U1&&, _T1>,
121 return __and_<is_convertible<_U1&&, _T1>,
122 is_convertible<_U2&&, _T2>>::value;
122 is_convertible<_U2&&, _T2>>::value;
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
129 is_convertible<_U2&&, _T2>>;
129 is_convertible<_U2&&, _T2>>;
133 return __and_<is_constructible<_T1, const _U1&>,
133 return __and_<is_constructible<_T1, const _U1&>,
134 is_constructible<_T2, _U2&&>,
134 is_constructible<_T2, _U2&&>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
143 is_convertible<const _U2&, _T2>>;
143 is_convertible<const _U2&, _T2>>;
147 return __and_<is_constructible<_T1, _U1&&>,
147 return __and_<is_constructible<_T1, _U1&&>,
148 is_constructible<_T2, const _U2&&>,
148 is_constructible<_T2, const _U2&&>,
209 : private __pair_base<_T1, _T2>
209 : private __pair_base<_T1, _T2>
211 typedef _T1 first_type; /// @c first_type is the first bound type
212 typedef _T2 second_type; /// @c second_type is the second bound type
214 _T1 first; /// @c first is a copy of the first object
215 _T2 second; /// @c second is a copy of the second object
252 using _PCCP = _PCC<true, _T1, _T2>;
252 using _PCCP = _PCC<true, _T1, _T2>;
260 constexpr pair(const _T1& __a, const _T2& __b)
260 constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
283 _T1, _T2>;
283 _T1, _T2>;
291 constexpr pair(const pair<_U1, _U2>& __p)
311 constexpr pair(_U1&& __x, const _T2& __y)
311 constexpr pair(_U1&& __x, const _T2& __y)
318 explicit constexpr pair(_U1&& __x, const _T2& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
332 explicit pair(const _T1& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
360 constexpr pair(pair<_U1, _U2>&& __p)
379 __and_<is_copy_assignable<_T1>,
380 is_copy_assignable<_T2>>::value,
390 __and_<is_move_assignable<_T1>,
391 is_move_assignable<_T2>>::value,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
403 is_assignable<_T2&, const _U2&>>::value,
403 is_assignable<_T2&, const _U2&>>::value,
405 operator=(const pair<_U1, _U2>& __p)
405 operator=(const pair<_U1, _U2>& __p)
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
414 is_assignable<_T2&, _U2&&>>::value,
414 is_assignable<_T2&, _U2&&>>::value,
416 operator=(pair<_U1, _U2>&& __p)
416 operator=(pair<_U1, _U2>&& __p)
522 constexpr pair<typename __decay_and_strip<_T1>::__type,
523 typename __decay_and_strip<_T2>::__type>
524 make_pair(_T1&& __x, _T2&& __y)
524 make_pair(_T1&& __x, _T2&& __y)
526 typedef typename __decay_and_strip<_T1>::__type __ds_type1;
527 typedef typename __decay_and_strip<_T2>::__type __ds_type2;
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
usr/include/c++/7.4.0/bits/stl_uninitialized.h 288 _ForwardIterator __result, allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_vector.h 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);
usr/include/c++/7.4.0/ext/alloc_traits.h 117 { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
usr/include/c++/7.4.0/ext/new_allocator.h 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)...); }
140 destroy(_Up* __p) { __p->~_Up(); }
usr/include/c++/7.4.0/initializer_list 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;
usr/include/c++/7.4.0/tuple 56 struct __is_empty_non_tuple : is_empty<_Tp> { };
125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
159 static constexpr _Head&
162 static constexpr const _Head&
165 _Head _M_head_impl;
186 : public _Tuple_impl<_Idx + 1, _Tail...>,
187 private _Head_base<_Idx, _Head>
191 typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
192 typedef _Head_base<_Idx, _Head> _Base;
194 static constexpr _Head&
197 static constexpr const _Head&
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
230 constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
235 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
235 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
242 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
248 const _Head& __head, const _Tail&... __tail)
248 const _Head& __head, const _Tail&... __tail)
344 : private _Head_base<_Idx, _Head>
348 typedef _Head_base<_Idx, _Head> _Base;
350 static constexpr _Head&
353 static constexpr const _Head&
360 constexpr _Tuple_impl(const _Head& __head)
365 constexpr _Tuple_impl(_UHead&& __head)
376 constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
380 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
390 const _Head& __head)
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
497 return __and_<__not_<is_same<tuple<_Elements...>,
501 __not_<is_convertible<_SrcTuple, _Elements...>>,
502 __not_<is_constructible<_Elements..., _SrcTuple>>
508 return __not_<is_same<tuple<_Elements...>,
556 class tuple : public _Tuple_impl<0, _Elements...>
558 typedef _Tuple_impl<0, _Elements...> _Inherited;
598 _Elements...>;
608 constexpr tuple(const _Elements&... __elements)
619 explicit constexpr tuple(const _Elements&... __elements)
628 _Elements...>;
636 _Elements...>;
646 constexpr tuple(_UElements&&... __elements)
668 _Elements...>;
730 const _Elements&... __elements)
741 const _Elements&... __elements)
907 class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
907 class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
909 typedef _Tuple_impl<0, _T1, _T2> _Inherited;
909 typedef _Tuple_impl<0, _T1, _T2> _Inherited;
939 _TC<is_same<_Dummy, void>::value, _T1, _T2>;
939 _TC<is_same<_Dummy, void>::value, _T1, _T2>;
947 constexpr tuple(const _T1& __a1, const _T2& __a2)
947 constexpr tuple(const _T1& __a1, const _T2& __a2)
956 explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
956 explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
961 using _TMC = _TC<true, _T1, _T2>;
961 using _TMC = _TC<true, _T1, _T2>;
971 constexpr tuple(_U1&& __a1, _U2&& __a2)
971 constexpr tuple(_U1&& __a1, _U2&& __a2)
995 constexpr tuple(const tuple<_U1, _U2>& __in)
995 constexpr tuple(const tuple<_U1, _U2>& __in)
1013 constexpr tuple(tuple<_U1, _U2>&& __in)
1013 constexpr tuple(tuple<_U1, _U2>&& __in)
1066 tuple(allocator_arg_t __tag, const _Alloc& __a)
1078 const _T1& __a1, const _T2& __a2)
1078 const _T1& __a1, const _T2& __a2)
1090 const _T1& __a1, const _T2& __a2)
1090 const _T1& __a1, const _T2& __a2)
1280 : tuple_element<__i - 1, tuple<_Tail...> > { };
1288 typedef _Head type;
1302 constexpr _Head&
1303 __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1303 __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1307 constexpr const _Head&
1308 __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1308 __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1309 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1309 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1314 get(tuple<_Elements...>& __t) noexcept
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1320 get(const tuple<_Elements...>& __t) noexcept
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1326 get(tuple<_Elements...>&& __t) noexcept
usr/include/c++/7.4.0/type_traits 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>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1358 : public __is_nt_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>>
1526 static void __test_aux(_To1);
1538 typedef decltype(__test<_From, _To>(0)) type;
1538 typedef decltype(__test<_From, _To>(0)) type;
1545 : public __is_convertible_helper<_From, _To>::type
1545 : public __is_convertible_helper<_From, _To>::type
1554 { typedef _Tp type; };
1558 { 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; };
2104 { typedef typename remove_cv<_Up>::type __type; };
2118 typedef typename remove_reference<_Tp>::type __remove_type;
2131 typedef _Tp __type;
2144 typename decay<_Tp>::type>::__type __type;
2171 { typedef _Iffalse type; };
utils/unittest/googlemock/include/gmock/gmock-generated-matchers.h 580 typename internal::DecayArray<T1>::type> >
581 ElementsAre(const T1& e1) {
583 typename internal::DecayArray<T1>::type> Args;
805 typename internal::DecayArray<T1>::type,
806 typename internal::DecayArray<T2>::type> >
807 UnorderedElementsAre(const T1& e1, const T2& e2) {
807 UnorderedElementsAre(const T1& e1, const T2& e2) {
809 typename internal::DecayArray<T1>::type,
810 typename internal::DecayArray<T2>::type> Args;
utils/unittest/googlemock/include/gmock/gmock-matchers.h 206 bool operator()(const A& a, const B& b) const { return a == b; }
206 bool operator()(const A& a, const B& b) const { return a == b; }
519 static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
536 internal::ImplicitlyConvertible<M, Matcher<T> >::value>());
540 static Matcher<T> CastImpl(const M& value, BooleanConstant<false>) {
547 static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
612 inline Matcher<T> MatcherCast(const M& matcher) {
613 return internal::MatcherCastImpl<T, M>::Cast(matcher);
629 static inline Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
630 return internal::MatcherCastImpl<T, M>::Cast(polymorphic_matcher_or_value);
667 inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher) {
897 explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
907 explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
921 Rhs rhs_;
924 Rhs rhs_;
929 class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
929 class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
931 explicit EqMatcher(const Rhs& rhs)
1809 bool operator()(const T& x) const {
1824 return MatcherCast<const T&>(matcher_).Matches(x);
3013 PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)
3094 PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)
3105 const FirstMatcher first_matcher_;
3454 Matcher<Target> operator()(const Arg& a) const {
3760 inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
3760 inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
4350 inline internal::PairMatcher<FirstMatcher, SecondMatcher>
4351 Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
utils/unittest/googlemock/include/gmock/internal/gmock-internal-utils.h 355 template <typename T> struct DecayArray { typedef T type; }; // NOLINT
utils/unittest/googletest/include/gtest/gtest-printers.h 223 void DefaultPrintNonContainerTo(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);
677 void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
681 UniversalPrinter<T1>::Print(value.first, 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);
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h 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}; }
utils/unittest/googletest/include/gtest/internal/gtest-internal.h 830 struct AddReference { typedef T& type; }; // NOLINT
863 static typename AddReference<From>::type MakeFrom();