|
|
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 {
468 ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) {
468 ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) {
474 ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) {
474 ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) {
include/llvm/ADT/DenseMap.h 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; }
65 using key_type = KeyT;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
78 if (shouldReverseIterate<KeyT>())
145 size_type count(const_arg_type_t<KeyT> Val) const {
272 bool erase(const KeyT &Val) {
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();
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
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>()) {
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>,
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/Optional.h 144 T value;
172 T &getValue() LLVM_LVALUE_FUNCTION noexcept {
176 T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
181 T &&getValue() && noexcept {
197 ::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) && {
include/llvm/ADT/SmallVector.h 75 AlignedCharArrayUnion<T> FirstEl;
114 using value_type = T;
115 using iterator = T *;
116 using const_iterator = const T *;
121 using reference = T &;
122 using const_reference = const T &;
123 using pointer = T *;
124 using const_pointer = const T *;
259 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
264 static void destroy_range(T *, T *) {}
264 static void destroy_range(T *, T *) {}
286 T1 *I, T1 *E, T2 *Dest,
288 T2>::value>::type * = nullptr) {
294 memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
299 void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
302 void push_back(const T &Elt) {
305 memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
316 using SuperClass = SmallVectorTemplateBase<T>;
357 void resize(size_type N, const T &NV) {
374 LLVM_NODISCARD T pop_back_val() {
397 void append(size_type NumInputs, const T &Elt) {
405 void append(std::initializer_list<T> IL) {
412 void assign(size_type NumElts, const T &Elt) {
429 void assign(std::initializer_list<T> IL) {
467 iterator insert(iterator I, T &&Elt) {
497 iterator insert(iterator I, const T &Elt) {
526 iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
637 void insert(iterator I, std::initializer_list<T> IL) {
820 AlignedCharArrayUnion<T> InlineElts[N];
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
846 explicit SmallVector(size_t Size, const T &Value = T())
865 SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
884 SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
include/llvm/Support/AlignOf.h 24 T t;
30 T t;
35 char arr[sizeof(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
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) {
include/llvm/Support/PointerLikeTypeTraits.h 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 };
include/llvm/Support/type_traits.h 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/include/clang/AST/ASTContext.h 592 using DynTypedNode = ast_type_traits::DynTypedNode;
594 llvm::AlignedCharArrayUnion<ast_type_traits::DynTypedNode,
607 const ast_type_traits::DynTypedNode *begin() const {
614 const ast_type_traits::DynTypedNode *end() const {
664 template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node) {
665 return getParents(ast_type_traits::DynTypedNode::create(Node));
668 DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node);
tools/clang/include/clang/AST/ASTNodeTraverser.h 208 void Visit(const ast_type_traits::DynTypedNode &N) {
tools/clang/include/clang/AST/ASTTypeTraits.h 234 static DynTypedNode create(const T &Node) {
292 bool operator<(const DynTypedNode &Other) const {
322 bool operator==(const DynTypedNode &Other) const {
342 bool operator!=(const DynTypedNode &Other) const {
349 static inline DynTypedNode getEmptyKey() {
350 DynTypedNode Node;
354 static inline DynTypedNode getTombstoneKey() {
355 DynTypedNode Node;
359 static unsigned getHashValue(const DynTypedNode &Val) {
377 static bool isEqual(const DynTypedNode &LHS, const DynTypedNode &RHS) {
377 static bool isEqual(const DynTypedNode &LHS, const DynTypedNode &RHS) {
404 static DynTypedNode create(const BaseT &Node) {
405 DynTypedNode Result;
424 static DynTypedNode create(const T &Node) {
425 DynTypedNode Result;
443 static DynTypedNode create(const T &Node) {
444 DynTypedNode Result;
536 : clang::ast_type_traits::DynTypedNode::DenseMapInfo {};
tools/clang/include/clang/ASTMatchers/ASTMatchFinder.h 184 template <typename T> void match(const T &Node, ASTContext &Context) {
185 match(clang::ast_type_traits::DynTypedNode::create(Node), Context);
187 void match(const clang::ast_type_traits::DynTypedNode &Node,
299 return match(Matcher, ast_type_traits::DynTypedNode::create(Node), Context);
tools/clang/include/clang/ASTMatchers/ASTMatchers.h 4349 Predicate.Node = ast_type_traits::DynTypedNode::create(Node);
6469 llvm::SmallVector<ast_type_traits::DynTypedNode, 8> Stack(Parents.begin(),
6472 const auto &CurNode = Stack.back();
6484 for(const auto &Parent: Finder->getASTContext().getParents(CurNode))
tools/clang/include/clang/ASTMatchers/ASTMatchersInternal.h 151 void addNode(StringRef ID, const ast_type_traits::DynTypedNode& DynNode) {
168 ast_type_traits::DynTypedNode getNode(StringRef ID) const {
187 std::map<std::string, ast_type_traits::DynTypedNode, std::less<>>;
226 void setBinding(StringRef Id, const ast_type_traits::DynTypedNode &DynNode) {
283 virtual bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
306 bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
391 bool matches(const ast_type_traits::DynTypedNode &DynNode,
398 bool matchesNoKindCheck(const ast_type_traits::DynTypedNode &DynNode,
537 return Implementation.matches(ast_type_traits::DynTypedNode::create(Node),
569 ast_type_traits::DynTypedNode::create(*Node), Finder, Builder);
913 ast_type_traits::DynTypedNode::create(*Node), Finder, Builder);
994 bool matchesChildOf(const T &Node, const DynTypedMatcher &Matcher,
1004 return matchesChildOf(ast_type_traits::DynTypedNode::create(Node),
1009 bool matchesDescendantOf(const T &Node,
1020 return matchesDescendantOf(ast_type_traits::DynTypedNode::create(Node),
1026 bool matchesAncestorOf(const T &Node,
1035 return matchesAncestorOf(ast_type_traits::DynTypedNode::create(Node),
1042 virtual bool matchesChildOf(const ast_type_traits::DynTypedNode &Node,
1048 virtual bool matchesDescendantOf(const ast_type_traits::DynTypedNode &Node,
1053 virtual bool matchesAncestorOf(const ast_type_traits::DynTypedNode &Node,
1597 static ast_type_traits::DynTypedNode
1599 return ast_type_traits::DynTypedNode::create(*Loc.getNestedNameSpecifier());
1617 ast_type_traits::DynTypedNode::create(Node.getType()), Finder, Builder);
1638 ast_type_traits::DynTypedNode::create(NextNode), Finder, Builder);
1662 ast_type_traits::DynTypedNode::create(NextNode), Finder, Builder);
1762 ast_type_traits::DynTypedNode Node;
tools/clang/include/clang/Tooling/ASTDiff/ASTDiff.h 40 ast_type_traits::DynTypedNode ASTNode;
tools/clang/include/clang/Tooling/ASTDiff/ASTDiffInternal.h 18 using DynTypedNode = ast_type_traits::DynTypedNode;
tools/clang/include/clang/Tooling/Refactoring/ASTSelection.h 50 ast_type_traits::DynTypedNode Node;
54 SelectedASTNode(const ast_type_traits::DynTypedNode &Node,
tools/clang/include/clang/Tooling/Transformer/SourceCode.h 32 CharSourceRange getExtendedRange(const T &Node, tok::TokenKind Next,
tools/clang/lib/AST/ASTContext.cpp 891 using ParentVector = llvm::SmallVector<ast_type_traits::DynTypedNode, 2>;
899 ast_type_traits::DynTypedNode *, ParentVector *>>;
904 ast_type_traits::DynTypedNode,
906 ast_type_traits::DynTypedNode *, ParentVector *>>;
912 static ast_type_traits::DynTypedNode
915 return ast_type_traits::DynTypedNode::create(*D);
917 return ast_type_traits::DynTypedNode::create(*S);
918 return *U.get<ast_type_traits::DynTypedNode *>();
922 static ASTContext::DynTypedNodeList getDynNodeFromMap(const NodeTy &Node,
938 if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
939 delete Entry.second.get<ast_type_traits::DynTypedNode *>();
945 if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
946 delete Entry.second.get<ast_type_traits::DynTypedNode *>();
953 DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node) {
10388 static ast_type_traits::DynTypedNode createDynTypedNode(const T &Node) {
10389 return ast_type_traits::DynTypedNode::create(*Node);
10392 ast_type_traits::DynTypedNode createDynTypedNode(const TypeLoc &Node) {
10393 return ast_type_traits::DynTypedNode::create(Node);
10396 ast_type_traits::DynTypedNode
10398 return ast_type_traits::DynTypedNode::create(Node);
10426 bool TraverseNode(T Node, MapNodeTy MapNode, BaseTraverseFn BaseTraverse,
10448 NodeOrVector = new ast_type_traits::DynTypedNode(ParentStack.back());
10454 .template dyn_cast<ast_type_traits::DynTypedNode *>();
10490 TypeLocNode, ast_type_traits::DynTypedNode::create(TypeLocNode),
10497 NNSLocNode, ast_type_traits::DynTypedNode::create(NNSLocNode),
10503 llvm::SmallVector<ast_type_traits::DynTypedNode, 16> ParentStack;
10511 ASTContext::getParents(const ast_type_traits::DynTypedNode &Node) {
tools/clang/lib/ASTMatchers/ASTMatchFinder.cpp 60 ast_type_traits::DynTypedNode Node;
104 bool findMatch(const ast_type_traits::DynTypedNode &DynNode) {
260 if (Matcher->matches(ast_type_traits::DynTypedNode::create(Node), Finder,
268 if (Matcher->matches(ast_type_traits::DynTypedNode::create(Node), Finder,
392 bool memoizedMatchesRecursively(const ast_type_traits::DynTypedNode &Node,
427 bool matchesRecursively(const ast_type_traits::DynTypedNode &Node,
448 bool matchesChildOf(const ast_type_traits::DynTypedNode &Node,
459 bool matchesDescendantOf(const ast_type_traits::DynTypedNode &Node,
470 bool matchesAncestorOf(const ast_type_traits::DynTypedNode &Node,
484 void match(const ast_type_traits::DynTypedNode &Node) {
505 template <typename T> void match(const T &Node) {
562 void matchWithFilter(const ast_type_traits::DynTypedNode &DynNode) {
602 return matchWithFilter(ast_type_traits::DynTypedNode::create(*Node));
605 return matchWithFilter(ast_type_traits::DynTypedNode::create(*Node));
643 const ast_type_traits::DynTypedNode &Node, const DynTypedMatcher &Matcher,
674 bool matchesAncestorOfRecursively(const ast_type_traits::DynTypedNode &Node,
701 const ast_type_traits::DynTypedNode Parent = Parents[0];
716 std::deque<ast_type_traits::DynTypedNode> Queue(Parents.begin(),
725 for (const auto &Parent :
1084 void MatchFinder::match(const clang::ast_type_traits::DynTypedNode &Node,
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp 52 bool NotUnaryOperator(const ast_type_traits::DynTypedNode &DynNode,
56 bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
61 bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
66 bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
82 const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder,
91 bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
107 bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
131 bool dynMatches(const ast_type_traits::DynTypedNode &, ASTMatchFinder *,
211 bool DynTypedMatcher::matches(const ast_type_traits::DynTypedNode &DynNode,
226 const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder,
262 bool NotUnaryOperator(const ast_type_traits::DynTypedNode &DynNode,
282 bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
296 bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
313 bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
tools/clang/lib/Tooling/ASTDiff/ASTDiff.cpp 389 const auto &P = Parents[0];
tools/clang/lib/Tooling/Refactoring/ASTSelection.cpp 50 SelectedASTNode(DynTypedNode::create(*Context.getTranslationUnitDecl()),
98 SelectedASTNode(DynTypedNode::create(*D), SelectionKind));
126 SelectedASTNode(DynTypedNode::create(*S), SelectionKind));
425 const DynTypedNode &Node = Parent.get().Node;
443 const DynTypedNode &Node = Parent.get().Node;
tools/clang/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp 430 ast_type_traits::DynTypedNode::create(TargetLoc)),
464 const Decl *getClosestAncestorDecl(const ASTNodeType &Node) {
tools/clang/lib/Tooling/Transformer/RangeSelector.cpp 55 static Expected<DynTypedNode> getNode(const ast_matchers::BoundNodes &Nodes,
131 Expected<DynTypedNode> Node = getNode(Result.Nodes, ID);
143 Expected<DynTypedNode> Node = getNode(Result.Nodes, ID);
176 Expected<DynTypedNode> Node = getNode(Result.Nodes, ID);
188 Expected<DynTypedNode> N = getNode(Result.Nodes, ID);
191 auto &Node = *N;
238 Expected<DynTypedNode> N = getNode(Result.Nodes, ID);
tools/clang/lib/Tooling/Transformer/Stencil.cpp 34 static llvm::Expected<DynTypedNode>
tools/clang/tools/extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp 262 for (const auto &Node : Ctx->getParents(*E)) {
tools/clang/tools/extra/clang-tidy/modernize/UseNullptrCheck.cpp 278 ast_type_traits::DynTypedNode ContainingAncestor;
280 ast_type_traits::DynTypedNode::create<Stmt>(*CE), MacroLoc,
408 bool findContainingAncestor(ast_type_traits::DynTypedNode Start,
410 ast_type_traits::DynTypedNode &Result) {
426 for (const auto &Parent : Parents) {
432 const ast_type_traits::DynTypedNode &Parent = Parents[0];
tools/clang/tools/extra/clang-tidy/readability/ImplicitBoolConversionCheck.cpp 225 for (const auto &N : Context.getParents(*Q.front())) {
tools/clang/tools/extra/clang-tidy/readability/MagicNumbersCheck.cpp 27 const DynTypedNode &Node) {
tools/clang/tools/extra/clang-tidy/readability/RedundantDeclarationCheck.cpp 53 for (const auto &Parent : Result.Context->getParents(*Prev))
tools/clang/tools/extra/clang-tidy/utils/ExprSequence.cpp 33 SmallVector<ast_type_traits::DynTypedNode, 1> NodesToProcess(Parents.begin(),
37 ast_type_traits::DynTypedNode Node = NodesToProcess.back();
tools/clang/tools/extra/clangd/FindTarget.cpp 44 nodeToString(const ast_type_traits::DynTypedNode &N) {
432 explicitReferenceTargets(DynTypedNode::create(*D),
540 explicitReferenceTargets(DynTypedNode::create(L.getType()),
547 explicitReferenceTargets(DynTypedNode::create(L.getType()),
555 explicitReferenceTargets(DynTypedNode::create(L.getType()))};
561 explicitReferenceTargets(DynTypedNode::create(L.getType()))};
590 visitNode(DynTypedNode::create(TTL));
603 visitNode(DynTypedNode::create(*E));
620 DynTypedNode::create(A.getArgument()));
637 visitNode(DynTypedNode::create(*D));
645 visitNode(DynTypedNode::create(L));
653 visitNode(DynTypedNode::create(*Init));
679 explicitReferenceTargets(DynTypedNode::create(
697 void visitNode(DynTypedNode N) {
702 void reportReference(const ReferenceLoc &Ref, DynTypedNode N) {
tools/clang/tools/extra/clangd/FindTarget.h 79 targetDecl(const ast_type_traits::DynTypedNode &, DeclRelationSet Mask);
116 allTargetDecls(const ast_type_traits::DynTypedNode &);
tools/clang/tools/extra/clangd/Selection.cpp 125 void printNodeKind(llvm::raw_ostream &OS, const DynTypedNode &N) {
139 std::string printNodeToString(const DynTypedNode &N, const PrintingPolicy &PP) {
220 auto N = DynTypedNode::create(*X);
220 auto N = DynTypedNode::create(*X);
270 Nodes.back().ASTNode = DynTypedNode::create(*AST.getTranslationUnitDecl());
282 auto N = DynTypedNode::create(*Node);
282 auto N = DynTypedNode::create(*Node);
285 push(DynTypedNode::create(*Node));
318 bool canSafelySkipNode(const DynTypedNode &N) {
336 void push(DynTypedNode Node) {
369 SourceRange earlySourceRange(const DynTypedNode &N) {
tools/clang/tools/extra/clangd/Selection.h 101 ast_type_traits::DynTypedNode ASTNode;
tools/clang/tools/extra/clangd/refactor/tweaks/DefineInline.cpp 86 const ast_type_traits::DynTypedNode &AstNode = SelNode->ASTNode;
tools/clang/tools/extra/clangd/refactor/tweaks/DumpAST.cpp 50 static bool dumpable(const ast_type_traits::DynTypedNode &N) {
56 llvm::Optional<ast_type_traits::DynTypedNode> Node;
tools/clang/unittests/AST/ASTTraverserTest.cpp 75 template <typename... NodeType> std::string dumpASTString(NodeType &&... N) {
83 Dumper.Visit(std::forward<NodeType &&>(N)...);
tools/clang/unittests/AST/ASTTypeTraitsTest.cpp 127 RangeVerifier<DynTypedNode> Verifier;
133 RangeVerifier<DynTypedNode> Verifier;
139 RangeVerifier<DynTypedNode> Verifier;
145 RangeVerifier<DynTypedNode> Verifier;
177 DynTypedNode Node = DynTypedNode::create(Q);
177 DynTypedNode Node = DynTypedNode::create(Q);
tools/clang/unittests/AST/MatchVerifier.h 62 const NodeType &Node) {}
216 class RangeVerifier : public MatchVerifier<NodeType> {
228 const NodeType &Node) override {
250 virtual SourceRange getRange(const NodeType &Node) {
259 class DumpVerifier : public MatchVerifier<ast_type_traits::DynTypedNode> {
267 const ast_type_traits::DynTypedNode &Node) override {
286 class PrintVerifier : public MatchVerifier<ast_type_traits::DynTypedNode> {
294 const ast_type_traits::DynTypedNode &Node) override {
tools/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp 2292 for (const auto &Parent : Context->getParents(*Node)) {
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&&
83 constexpr _Tp&&
98 move(_Tp&& __t) noexcept
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/ptr_traits.h 126 typedef _Tp* pointer;
128 typedef _Tp element_type;
141 pointer_to(__make_not_void<element_type>& __r) noexcept
141 pointer_to(__make_not_void<element_type>& __r) noexcept
usr/include/c++/7.4.0/bits/stl_algo.h 3900 const _Tp& __val)
usr/include/c++/7.4.0/bits/stl_construct.h 74 _Construct(_T1* __p, _Args&&... __args)
74 _Construct(_T1* __p, _Args&&... __args)
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
204 allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_deque.h 120 using __iter = _Deque_iterator<_Tp, _CvTp&, __ptr_to<_CvTp>>;
122 typedef __iter<_Tp> iterator;
123 typedef __iter<const _Tp> const_iterator;
124 typedef __ptr_to<_Tp> _Elt_pointer;
129 { return __deque_buf_size(sizeof(_Tp)); }
132 typedef _Tp value_type;
267 operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
268 const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT
274 operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
275 const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT
464 rebind<_Tp>::other _Tp_alloc_type;
487 typedef _Deque_iterator<_Tp, _Tp&, _Ptr> iterator;
487 typedef _Deque_iterator<_Tp, _Tp&, _Ptr> iterator;
488 typedef _Deque_iterator<_Tp, const _Tp&, _Ptr_const> const_iterator;
488 typedef _Deque_iterator<_Tp, const _Tp&, _Ptr_const> const_iterator;
602 return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp)));
609 _Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp)));
684 const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
715 % __deque_buf_size(sizeof(_Tp)));
831 class deque : protected _Deque_base<_Tp, _Alloc>
842 typedef _Deque_base<_Tp, _Alloc> _Base;
848 typedef _Tp value_type;
863 { return __deque_buf_size(sizeof(_Tp)); }
1980 void _M_push_back_aux(_Args&&... __args);
2069 const std::allocator<_Tp>&)
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_map.h 103 typedef _Tp mapped_type;
104 typedef std::pair<const _Key, _Tp> value_type;
1378 operator<(const map<_K1, _T1, _C1, _A1>&,
1379 const map<_K1, _T1, _C1, _A1>&);
usr/include/c++/7.4.0/bits/stl_pair.h 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>;
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)
332 explicit pair(const _T1& __x, _U2&& __y)
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&>,
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
454 operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
454 operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
usr/include/c++/7.4.0/bits/stl_uninitialized.h 144 const _Tp& __x)
182 const _Tp& __x)
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*
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;
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)
248 const _Head& __head, const _Tail&... __tail)
248 const _Head& __head, const _Tail&... __tail)
262 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
268 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
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)
767 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
771 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
1288 typedef _Head type;
1302 constexpr _Head&
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
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>
1246 : public is_nothrow_constructible<_Tp, _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>>
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; };
1637 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1664 : public __add_rvalue_reference_helper<_Tp>
1955 { typedef _Tp 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;
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);
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)
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); }
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 140 static void PrintValue(const T& value, ::std::ostream* os) {
205 ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
206 TypeWithoutFormatter<T,
207 (internal::IsAProtocolMessage<T>::value ? kProtobuf :
208 internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
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);
699 static void Print(const T& value, ::std::ostream* os) {
853 void UniversalPrint(const T& value, ::std::ostream* os) {
856 typedef T T1;
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h 29 static const T& printable(const T& V) { return V; }
29 static const T& printable(const T& V) { return V; }
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);
utils/unittest/googletest/include/gtest/internal/gtest-internal.h 830 struct AddReference { typedef T& type; }; // NOLINT
863 static typename AddReference<From>::type MakeFrom();