|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
tools/clang/include/clang/Sema/Template.h 189 class DeducedTemplateArgument : public TemplateArgument {
Declarations
tools/clang/include/clang/AST/TemplateName.h 40 class TemplateArgument;
tools/clang/include/clang/AST/Type.h 118 class TemplateArgument;
tools/clang/include/clang/Sema/Sema.h 176 class TemplateArgument;
tools/lldb/include/lldb/Core/ClangForward.h 109 class TemplateArgument;
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) {
164 T *Buff = A.template Allocate<T>(Length);
164 T *Buff = A.template Allocate<T>(Length);
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 {
456 ArrayRef<T> makeArrayRef(const T *data, size_t length) {
456 ArrayRef<T> makeArrayRef(const T *data, size_t length) {
462 ArrayRef<T> makeArrayRef(const T *begin, const T *end) {
462 ArrayRef<T> makeArrayRef(const T *begin, const T *end) {
462 ArrayRef<T> makeArrayRef(const T *begin, const T *end) {
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/STLExtras.h 80 typename std::add_const<T>::type>::type;
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,
286 T1 *I, T1 *E, T2 *Dest,
286 T1 *I, T1 *E, T2 *Dest,
287 typename std::enable_if<std::is_same<typename std::remove_const<T1>::type,
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() {
375 T Result = ::std::move(this->back());
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) {
606 T *OldEnd = this->end();
621 T *OldEnd = this->end();
627 for (T *J = I; NumOverwritten > 0; --NumOverwritten) {
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;
25 AlignerImpl<Ts...> rest;
30 T t;
35 char arr[sizeof(T)];
36 SizerImpl<Ts...> rest;
39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
50 llvm::detail::SizerImpl<T, Ts...>)];
50 llvm::detail::SizerImpl<T, Ts...>)];
include/llvm/Support/Alignment.h 103 return Constant<std::alignment_of<T>::value>();
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) {
include/llvm/Support/TrailingObjects.h 77 enum { Alignment = alignof(First) };
134 : public TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, NextTy,
137 typedef TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, NextTy, MoreTys...>
141 static const bool value = alignof(PrevTy) < alignof(NextTy);
161 static const NextTy *
163 TrailingObjectsBase::OverloadToken<NextTy>) {
171 alignAddr(Ptr, Align::Of<NextTy>()));
176 static NextTy *
178 TrailingObjectsBase::OverloadToken<NextTy>) {
185 return reinterpret_cast<NextTy *>(alignAddr(Ptr, Align::Of<NextTy>()));
197 (requiresRealignment() ? llvm::alignTo<alignof(NextTy)>(SizeSoFar)
199 sizeof(NextTy) * Count1,
231 TrailingTys...>::Alignment,
232 BaseTy, TrailingObjects<BaseTy, TrailingTys...>,
233 BaseTy, TrailingTys...> {
241 trailing_objects_internal::AlignmentCalcHelper<TrailingTys...>::Alignment,
242 BaseTy, TrailingObjects<BaseTy, TrailingTys...>, BaseTy, TrailingTys...>
242 BaseTy, TrailingObjects<BaseTy, TrailingTys...>, BaseTy, TrailingTys...>
302 template <typename T> const T *getTrailingObjects() const {
314 template <typename T> T *getTrailingObjects() {
332 TrailingTys, size_t>::type... Counts) {
342 std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>::type
342 std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>::type
344 TrailingTys, size_t>::type... Counts) {
include/llvm/Support/type_traits.h 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 688 template <typename T> T *Allocate(size_t Num = 1) const {
689 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
689 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
1436 const TemplateArgument &ArgPack);
1444 ArrayRef<TemplateArgument> Args,
1449 ArrayRef<TemplateArgument> Args) const;
1479 const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args) const;
1481 TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl);
1487 SmallVectorImpl<TemplateArgument> &Args);
2010 const TemplateArgument &ArgPack) const;
2442 TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg)
2442 TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg)
tools/clang/include/clang/AST/ASTNodeTraverser.h 159 void Visit(const TemplateArgument &A, SourceRange R = {},
222 else if (const auto *T = N.get<TemplateArgument>())
222 else if (const auto *T = N.get<TemplateArgument>())
331 for (const auto &Arg : *T)
634 for (const auto &A : Node->getPartialArguments())
643 void VisitExpressionTemplateArgument(const TemplateArgument &TA) {
646 void VisitPackTemplateArgument(const TemplateArgument &TA) {
647 for (const auto &TArg : TA.pack_elements())
tools/clang/include/clang/AST/ASTTypeTraits.h 65 return ASTNodeKind(KindToKindId<T>::Id);
234 static DynTypedNode create(const T &Node) {
235 return BaseConverter<T>::create(Node);
251 const T *get() const {
252 return BaseConverter<T>::get(NodeKind, Storage.buffer);
259 const T &getUnchecked() const {
260 return BaseConverter<T>::getUnchecked(NodeKind, Storage.buffer);
434 static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
435 if (ASTNodeKind::getFromNodeKind<T>().isSame(NodeKind))
439 static const T &getUnchecked(ASTNodeKind NodeKind, const char Storage[]) {
443 static DynTypedNode create(const T &Node) {
445 Result.NodeKind = ASTNodeKind::getFromNodeKind<T>();
446 new (Result.Storage.buffer) T(Node);
461 llvm::AlignedCharArrayUnion<const void *, TemplateArgument,
496 TemplateArgument, void> : public ValueConverter<TemplateArgument> {};
tools/clang/include/clang/AST/DeclTemplate.h 225 : private llvm::TrailingObjects<TemplateArgumentList, TemplateArgument> {
227 const TemplateArgument *Arguments;
235 TemplateArgumentList(ArrayRef<TemplateArgument> Args);
250 ArrayRef<TemplateArgument> Args);
256 explicit TemplateArgumentList(OnStackType, ArrayRef<TemplateArgument> Args)
269 const TemplateArgument &get(unsigned Idx) const {
275 const TemplateArgument &operator[](unsigned Idx) const { return get(Idx); }
278 ArrayRef<TemplateArgument> asArray() const {
287 const TemplateArgument *data() const { return Arguments; }
596 Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
599 for (const TemplateArgument &TemplateArg : TemplateArgs)
762 static ArrayRef<TemplateArgument> getTemplateArgs(EntryType *D) {
798 ArrayRef<TemplateArgument> Args, void *&InsertPos);
954 static ArrayRef<TemplateArgument>
979 TemplateArgument *InjectedArgs = nullptr;
1028 FunctionDecl *findSpecialization(ArrayRef<TemplateArgument> Args,
1087 ArrayRef<TemplateArgument> getInjectedTemplateArgs();
1692 ArrayRef<TemplateArgument> Args,
1705 ArrayRef<TemplateArgument> Args,
1889 Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
1892 for (const TemplateArgument &TemplateArg : TemplateArgs)
1927 ArrayRef<TemplateArgument> Args,
1946 ArrayRef<TemplateArgument> Args,
2140 findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2183 findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
2546 ArrayRef<TemplateArgument> Args);
2559 ArrayRef<TemplateArgument> Args);
2731 ArrayRef<TemplateArgument> TemplateArgs,
2734 for (const TemplateArgument &TemplateArg : TemplateArgs)
2767 StorageClass S, ArrayRef<TemplateArgument> Args,
2785 TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args,
2960 findSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
3001 findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
tools/clang/include/clang/AST/ExprCXX.h 4093 private llvm::TrailingObjects<SizeOfPackExpr, TemplateArgument> {
4126 Optional<unsigned> Length, ArrayRef<TemplateArgument> PartialArgs)
4135 auto *Args = getTrailingObjects<TemplateArgument>();
4135 auto *Args = getTrailingObjects<TemplateArgument>();
4148 ArrayRef<TemplateArgument> PartialArgs = None);
4184 ArrayRef<TemplateArgument> getPartialArguments() const {
4186 const auto *Args = getTrailingObjects<TemplateArgument>();
4186 const auto *Args = getTrailingObjects<TemplateArgument>();
4278 const TemplateArgument *Arguments;
4294 const TemplateArgument &ArgPack);
4304 TemplateArgument getArgumentPack() const;
4851 TemplateArgument> {
4890 ArrayRef<TemplateArgument> ConvertedArgs,
4902 ArrayRef<TemplateArgument> ConvertedArgs, Optional<bool> IsSatisfied);
4919 ArrayRef<TemplateArgument> getTemplateArguments() const {
4920 return ArrayRef<TemplateArgument>(getTrailingObjects<TemplateArgument>(),
4930 ArrayRef<TemplateArgument> Converted);
tools/clang/include/clang/AST/JSONNodeDumper.h 195 void Visit(const TemplateArgument &TA, SourceRange R = {},
310 void VisitNullTemplateArgument(const TemplateArgument &TA);
311 void VisitTypeTemplateArgument(const TemplateArgument &TA);
312 void VisitDeclarationTemplateArgument(const TemplateArgument &TA);
313 void VisitNullPtrTemplateArgument(const TemplateArgument &TA);
314 void VisitIntegralTemplateArgument(const TemplateArgument &TA);
315 void VisitTemplateTemplateArgument(const TemplateArgument &TA);
316 void VisitTemplateExpansionTemplateArgument(const TemplateArgument &TA);
317 void VisitExpressionTemplateArgument(const TemplateArgument &TA);
318 void VisitPackTemplateArgument(const TemplateArgument &TA);
tools/clang/include/clang/AST/ODRHash.h 86 void AddTemplateArgument(TemplateArgument TA);
tools/clang/include/clang/AST/RecursiveASTVisitor.h 262 bool TraverseTemplateArgument(const TemplateArgument &Arg);
276 bool TraverseTemplateArguments(const TemplateArgument *Args,
822 const TemplateArgument &Arg) {
824 case TemplateArgument::Null:
825 case TemplateArgument::Declaration:
826 case TemplateArgument::Integral:
827 case TemplateArgument::NullPtr:
830 case TemplateArgument::Type:
833 case TemplateArgument::Template:
834 case TemplateArgument::TemplateExpansion:
838 case TemplateArgument::Expression:
841 case TemplateArgument::Pack:
854 const TemplateArgument &Arg = ArgLoc.getArgument();
857 case TemplateArgument::Null:
858 case TemplateArgument::Declaration:
859 case TemplateArgument::Integral:
860 case TemplateArgument::NullPtr:
863 case TemplateArgument::Type: {
871 case TemplateArgument::Template:
872 case TemplateArgument::TemplateExpansion:
879 case TemplateArgument::Expression:
882 case TemplateArgument::Pack:
892 const TemplateArgument *Args, unsigned NumArgs) {
tools/clang/include/clang/AST/TemplateBase.h 120 const TemplateArgument *Args;
165 TemplateArgument(const TemplateArgument &Other, QualType Type) {
218 explicit TemplateArgument(ArrayRef<TemplateArgument> Args) {
226 static TemplateArgument getEmptyPack() { return TemplateArgument(None); }
230 static TemplateArgument CreatePackCopy(ASTContext &Context,
231 ArrayRef<TemplateArgument> Args);
335 using pack_iterator = const TemplateArgument *;
353 ArrayRef<TemplateArgument> pack_elements() const {
365 ArrayRef<TemplateArgument> getPackAsArray() const {
372 bool structurallyEquals(const TemplateArgument &Other) const;
376 TemplateArgument getPackExpansionPattern() const;
450 TemplateArgument Argument;
456 TemplateArgumentLoc(const TemplateArgument &Argument,
460 TemplateArgumentLoc(const TemplateArgument &Argument, TypeSourceInfo *TInfo)
465 TemplateArgumentLoc(const TemplateArgument &Argument, Expr *E)
476 TemplateArgumentLoc(const TemplateArgument &Argument,
488 if (Argument.getKind() == TemplateArgument::Template ||
489 Argument.getKind() == TemplateArgument::TemplateExpansion)
498 const TemplateArgument &getArgument() const {
532 if (Argument.getKind() != TemplateArgument::Template &&
533 Argument.getKind() != TemplateArgument::TemplateExpansion)
539 if (Argument.getKind() != TemplateArgument::Template &&
540 Argument.getKind() != TemplateArgument::TemplateExpansion)
546 if (Argument.getKind() != TemplateArgument::TemplateExpansion)
681 const TemplateArgument &Arg);
693 inline const TemplateArgument &
699 inline const TemplateArgument &
tools/clang/include/clang/AST/TemplateName.h 134 const TemplateArgument *Arguments;
139 const TemplateArgument *Arguments)
150 TemplateArgument getArgumentPack() const;
157 const TemplateArgument &ArgPack);
tools/clang/include/clang/AST/TextNodeDumper.h 160 void Visit(const TemplateArgument &TA, SourceRange R,
215 void VisitNullTemplateArgument(const TemplateArgument &TA);
216 void VisitTypeTemplateArgument(const TemplateArgument &TA);
217 void VisitDeclarationTemplateArgument(const TemplateArgument &TA);
218 void VisitNullPtrTemplateArgument(const TemplateArgument &TA);
219 void VisitIntegralTemplateArgument(const TemplateArgument &TA);
220 void VisitTemplateTemplateArgument(const TemplateArgument &TA);
221 void VisitTemplateExpansionTemplateArgument(const TemplateArgument &TA);
222 void VisitExpressionTemplateArgument(const TemplateArgument &TA);
223 void VisitPackTemplateArgument(const TemplateArgument &TA);
tools/clang/include/clang/AST/Type.h 4741 const TemplateArgument *Arguments;
4745 const TemplateArgument &ArgPack);
4762 TemplateArgument getArgumentPack() const;
4767 const TemplateArgument &ArgPack);
4932 ArrayRef<TemplateArgument> Args,
4974 using iterator = const TemplateArgument *;
4983 const TemplateArgument *getArgs() const {
4994 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
4996 ArrayRef<TemplateArgument> template_arguments() const {
5015 ArrayRef<TemplateArgument> Args,
5026 ArrayRef<TemplateArgument> Args,
5354 ArrayRef<TemplateArgument> Args,
5357 const TemplateArgument *getArgBuffer() const {
5361 TemplateArgument *getArgBuffer() {
5370 const TemplateArgument *getArgs() const {
5379 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5381 ArrayRef<TemplateArgument> template_arguments() const {
5385 using iterator = const TemplateArgument *;
5402 ArrayRef<TemplateArgument> Args);
tools/clang/include/clang/AST/TypeLoc.h 1668 const TemplateArgument *Args,
tools/clang/include/clang/ASTMatchers/ASTMatchers.h 110 const T *getNodeAs(StringRef ID) const {
111 return MyBoundNodes.getNodeAs<T>(ID);
492 extern const internal::VariadicAllOfMatcher<TemplateArgument> templateArgument;
686 ArrayRef<TemplateArgument> List =
894 ArrayRef<TemplateArgument> List =
931 if (Node.getKind() != TemplateArgument::Type)
949 if (Node.getKind() != TemplateArgument::Template)
969 if (Node.getKind() == TemplateArgument::Declaration)
987 if (Node.getKind() == TemplateArgument::Expression)
1004 return Node.getKind() == TemplateArgument::Integral;
1019 if (Node.getKind() != TemplateArgument::Integral)
1040 if (Node.getKind() != TemplateArgument::Integral)
tools/clang/include/clang/ASTMatchers/ASTMatchersInternal.h 160 const T *getNodeAs(StringRef ID) const {
165 return It->second.get<T>();
302 virtual bool matches(const T &Node,
309 return matches(DynNode.getUnchecked<T>(), Finder, Builder);
345 DynTypedMatcher(MatcherInterface<T> *Implementation)
346 : SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()),
436 return canConvertTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
445 template <typename T> Matcher<T> convertTo() const {
447 return unconditionalConvertTo<T>();
454 template <typename T> Matcher<T> unconditionalConvertTo() const;
499 explicit Matcher(MatcherInterface<T> *Implementation)
520 std::is_same<T, QualType>::value &&
534 bool matches(const T &Node,
581 return Other.dynCastTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
1202 operator Matcher<T>() const {
1243 operator Matcher<T>() const {
1245 ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
1246 .template unconditionalConvertTo<T>();
1255 class BindableMatcher : public Matcher<T> {
1257 explicit BindableMatcher(const Matcher<T> &M) : Matcher<T>(M) {}
1258 explicit BindableMatcher(MatcherInterface<T> *Implementation)
1265 Matcher<T> bind(StringRef ID) const {
1268 ->template unconditionalConvertTo<T>();
1370 inline Matcher<T> DynTypedMatcher::unconditionalConvertTo() const {
1376 BindableMatcher<T> makeAllOfComposite(
1377 ArrayRef<const Matcher<T> *> InnerMatchers) {
1388 using PI = llvm::pointee_iterator<const Matcher<T> *const *>;
1395 ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1397 .template unconditionalConvertTo<T>());
1575 : public VariadicFunction<BindableMatcher<T>, Matcher<T>,
1575 : public VariadicFunction<BindableMatcher<T>, Matcher<T>,
1576 makeAllOfComposite<T>> {
1739 inline ArrayRef<TemplateArgument>
1744 inline ArrayRef<TemplateArgument>
1749 inline ArrayRef<TemplateArgument>
tools/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h 199 ast_matchers::internal::Matcher<T> getTypedMatcher() const {
202 ->template convertTo<T>();
227 : MatcherOps(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()) {}
228 typedef ast_matchers::internal::Matcher<T> MatcherT;
232 return DynTypedMatcher(Matcher.convertTo<T>());
tools/clang/include/clang/Sema/Sema.h 1385 const SemaDiagnosticBuilder &Diag, const T &Value) {
6769 TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,
6855 ArrayRef<TemplateArgument> Args);
6907 SmallVectorImpl<TemplateArgument>
6933 SmallVectorImpl<TemplateArgument> &Converted,
6965 SmallVectorImpl<TemplateArgument> &Converted,
6970 SmallVectorImpl<TemplateArgument> &Converted);
6976 TemplateArgument &Converted,
6982 BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
6986 BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
7091 const TemplateArgument *Args,
7258 void collectUnexpandedParameterPacks(TemplateArgument Arg,
7440 Optional<unsigned> getFullyPackExpandedSize(TemplateArgument Arg);
7778 const TemplateArgument *TemplateArgs;
7790 ArrayRef<TemplateArgument> template_arguments() const {
7946 ArrayRef<TemplateArgument> TemplateArgs,
7953 ArrayRef<TemplateArgument> TemplateArgs,
7962 ArrayRef<TemplateArgument> TemplateArgs,
7971 ArrayRef<TemplateArgument> TemplateArgs,
7980 ArrayRef<TemplateArgument> TemplateArgs,
7988 ArrayRef<TemplateArgument> TemplateArgs,
7996 ArrayRef<TemplateArgument> TemplateArgs,
8004 ArrayRef<TemplateArgument> TemplateArgs,
8012 ArrayRef<TemplateArgument> TemplateArgs,
8021 ArrayRef<TemplateArgument> TemplateArgs,
8057 ArrayRef<TemplateArgument> TemplateArgs = None,
8465 SmallVectorImpl<TemplateArgument> &Converted,
tools/clang/include/clang/Sema/Template.h 66 using ArgList = ArrayRef<TemplateArgument>;
99 const TemplateArgument &operator()(unsigned Depth, unsigned Index) const {
123 TemplateArgument Arg) {
189 class DeducedTemplateArgument : public TemplateArgument {
197 DeducedTemplateArgument(const TemplateArgument &Arg,
282 const TemplateArgument *ArgsInPartiallySubstitutedPack;
397 const TemplateArgument *ExplicitArgs,
413 getPartiallySubstitutedPack(const TemplateArgument **ExplicitArgs = nullptr,
548 ArrayRef<TemplateArgument> Converted,
tools/clang/include/clang/Sema/TemplateDeduction.h 194 TemplateArgument FirstArg;
208 TemplateArgument SecondArg;
255 const TemplateArgument *getFirstArg();
259 const TemplateArgument *getSecondArg();
tools/clang/include/clang/Serialization/ASTReader.h 1779 GetTemplateArgumentLocInfo(ModuleFile &F, TemplateArgument::ArgKind Kind,
2156 TemplateArgument ReadTemplateArgument(ModuleFile &F, const RecordData &Record,
2166 void ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
2487 getTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind) {
2583 TemplateArgument readTemplateArgument(bool Canonicalize = false) {
2593 void readTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
tools/clang/include/clang/Serialization/ASTWriter.h 898 void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
932 void AddTemplateArgument(const TemplateArgument &Arg);
tools/clang/lib/AST/ASTContext.cpp 4086 const TemplateArgument &ArgPack) {
4088 for (const auto &P : ArgPack.pack_elements()) {
4178 SmallVector<TemplateArgument, 4> ArgVec;
4187 static bool hasAnyPackExpansions(ArrayRef<TemplateArgument> Args) {
4188 for (const TemplateArgument &Arg : Args)
4198 ArrayRef<TemplateArgument> Args,
4225 sizeof(TemplateArgument) * Args.size() +
4237 TemplateName Template, ArrayRef<TemplateArgument> Args) const {
4247 SmallVector<TemplateArgument, 4> CanonArgs;
4250 for (const TemplateArgument &Arg : Args)
4266 sizeof(TemplateArgument) * NumArgs),
4378 SmallVector<TemplateArgument, 16> ArgCopy;
4389 ArrayRef<TemplateArgument> Args) const {
4410 SmallVector<TemplateArgument, 16> CanonArgs(NumArgs);
4428 sizeof(TemplateArgument) * NumArgs),
4437 TemplateArgument ASTContext::getInjectedTemplateArg(NamedDecl *Param) {
4438 TemplateArgument Arg;
4464 Arg = TemplateArgument::CreatePackCopy(*this, Arg);
4471 SmallVectorImpl<TemplateArgument> &Args) {
5421 TemplateArgument canonArgPack
5436 TemplateArgument
5437 ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
5439 case TemplateArgument::Null:
5442 case TemplateArgument::Expression:
5445 case TemplateArgument::Declaration: {
5450 case TemplateArgument::NullPtr:
5454 case TemplateArgument::Template:
5457 case TemplateArgument::TemplateExpansion:
5462 case TemplateArgument::Integral:
5465 case TemplateArgument::Type:
5468 case TemplateArgument::Pack: {
5472 auto *CanonArgs = new (*this) TemplateArgument[Arg.pack_size()];
5472 auto *CanonArgs = new (*this) TemplateArgument[Arg.pack_size()];
5474 for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
7855 const TemplateArgument &ArgPack) const {
tools/clang/lib/AST/ASTDiagnostic.cpp 113 SmallVector<TemplateArgument, 4> Args;
115 const TemplateArgument &Arg = TST->getArg(I);
116 if (Arg.getKind() == TemplateArgument::Type)
913 typedef const TemplateArgument& reference;
914 typedef const TemplateArgument* pointer;
929 TemplateArgument::pack_iterator CurrentTA;
932 TemplateArgument::pack_iterator EndTA;
943 TemplateArgument TA = TST->getArg(0);
944 if (TA.getKind() != TemplateArgument::Pack) return;
988 TemplateArgument TA = TST->getArg(Index);
989 if (TA.getKind() != TemplateArgument::Pack)
1171 case TemplateArgument::Integral:
1176 case TemplateArgument::Declaration: {
1185 case TemplateArgument::NullPtr:
1188 case TemplateArgument::Expression:
1197 const TemplateArgument& TA = Iter.getDesugaredTA();
1201 case TemplateArgument::Integral:
1206 case TemplateArgument::Declaration: {
1215 case TemplateArgument::NullPtr:
1218 case TemplateArgument::Expression:
tools/clang/lib/AST/ASTImporter.cpp 403 const TemplateArgument *FromArgs, unsigned NumFromArgs,
404 SmallVectorImpl<TemplateArgument> &ToArgs);
405 Expected<TemplateArgument>
406 ImportTemplateArgument(const TemplateArgument &From);
417 using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
735 Expected<TemplateArgument>
736 ASTNodeImporter::import(const TemplateArgument &From) {
738 case TemplateArgument::Null:
741 case TemplateArgument::Type: {
748 case TemplateArgument::Integral: {
755 case TemplateArgument::Declaration: {
765 case TemplateArgument::NullPtr: {
772 case TemplateArgument::Template: {
780 case TemplateArgument::TemplateExpansion: {
790 case TemplateArgument::Expression:
796 case TemplateArgument::Pack: {
797 SmallVector<TemplateArgument, 2> ToPack;
814 Expected<TemplateArgument> ArgOrErr = import(TALoc.getArgument());
817 TemplateArgument Arg = *ArgOrErr;
822 if (Arg.getKind() == TemplateArgument::Expression) {
827 } else if (Arg.getKind() == TemplateArgument::Type) {
1405 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1462 SmallVector<TemplateArgument, 2> ToPack;
1952 const TemplateArgument *FromArgs, unsigned NumFromArgs,
1953 SmallVectorImpl<TemplateArgument> &ToArgs) {
1965 Expected<TemplateArgument>
1966 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
5163 SmallVector<TemplateArgument, 2> TemplateArgs;
5442 SmallVector<TemplateArgument, 2> TemplateArgs;
7041 SmallVector<TemplateArgument, 8> ToPartialArguments;
tools/clang/lib/AST/ASTStructuralEquivalence.cpp 102 const TemplateArgument &Arg1,
103 const TemplateArgument &Arg2);
308 const TemplateArgument &Arg1,
309 const TemplateArgument &Arg2) {
314 case TemplateArgument::Null:
317 case TemplateArgument::Type:
320 case TemplateArgument::Integral:
328 case TemplateArgument::Declaration:
331 case TemplateArgument::NullPtr:
334 case TemplateArgument::Template:
338 case TemplateArgument::TemplateExpansion:
343 case TemplateArgument::Expression:
347 case TemplateArgument::Pack:
tools/clang/lib/AST/ASTTypeTraits.cpp 129 if (const TemplateArgument *TA = get<TemplateArgument>())
129 if (const TemplateArgument *TA = get<TemplateArgument>())
tools/clang/lib/AST/Comment.cpp 179 if (MaybeFunction.getArgument().getKind() != TemplateArgument::Type)
tools/clang/lib/AST/Decl.cpp 318 LinkageComputer::getLVForTemplateArgumentList(ArrayRef<TemplateArgument> Args,
322 for (const TemplateArgument &Arg : Args) {
324 case TemplateArgument::Null:
325 case TemplateArgument::Integral:
326 case TemplateArgument::Expression:
329 case TemplateArgument::Type:
333 case TemplateArgument::Declaration: {
340 case TemplateArgument::NullPtr:
344 case TemplateArgument::Template:
345 case TemplateArgument::TemplateExpansion:
351 case TemplateArgument::Pack:
tools/clang/lib/AST/DeclPrinter.cpp 1090 const TemplateArgument &A = Args[I];
1094 if (A.getKind() == TemplateArgument::Type)
1100 if (A.getKind() == TemplateArgument::Template) {
1109 if (A.getKind() == TemplateArgument::Expression) {
tools/clang/lib/AST/DeclTemplate.cpp 237 llvm::FoldingSetVector<EntryType> &Specs, ArrayRef<TemplateArgument> Args,
313 FunctionTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
324 ArrayRef<TemplateArgument> FunctionTemplateDecl::getInjectedTemplateArgs() {
329 SmallVector<TemplateArgument, 16> TemplateArgs;
332 new (Context) TemplateArgument[TemplateArgs.size()];
419 ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
430 ClassTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
500 SmallVector<TemplateArgument, 16> TemplateArgs;
707 TemplateArgumentList::TemplateArgumentList(ArrayRef<TemplateArgument> Args)
708 : Arguments(getTrailingObjects<TemplateArgument>()),
711 getTrailingObjects<TemplateArgument>());
716 ArrayRef<TemplateArgument> Args) {
717 void *Mem = Context.Allocate(totalSizeToAlloc<TemplateArgument>(Args.size()));
746 ArrayRef<TemplateArgument> Args,
767 ArrayRef<TemplateArgument> Args,
881 ArrayRef<TemplateArgument> Args,
899 ArrayRef<TemplateArgument> Args,
1036 VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
1047 VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
1096 TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args)
1112 TypeSourceInfo *TInfo, StorageClass S, ArrayRef<TemplateArgument> Args) {
1163 StorageClass S, ArrayRef<TemplateArgument> Args,
1179 StorageClass S, ArrayRef<TemplateArgument> Args,
tools/clang/lib/AST/ExprCXX.cpp 1600 ArrayRef<TemplateArgument> PartialArgs) {
1602 Context.Allocate(totalSizeToAlloc<TemplateArgument>(PartialArgs.size()));
1610 Context.Allocate(totalSizeToAlloc<TemplateArgument>(NumPartialArgs));
1619 const TemplateArgument &ArgPack)
1625 TemplateArgument SubstNonTypeTemplateParmPackExpr::getArgumentPack() const {
1758 ArrayRef<TemplateArgument> ConvertedArgs, Optional<bool> IsSatisfied)
1780 ArrayRef<TemplateArgument> Converted) {
1785 getTrailingObjects<TemplateArgument>());
1815 ArrayRef<TemplateArgument> ConvertedArgs,
1817 void *Buffer = C.Allocate(totalSizeToAlloc<TemplateArgument>(
1828 void *Buffer = C.Allocate(totalSizeToAlloc<TemplateArgument>(
tools/clang/lib/AST/ExprConstant.cpp 1023 TAL[0].getKind() == TemplateArgument::Type)
tools/clang/lib/AST/ItaniumMangle.cpp 468 const TemplateArgument *TemplateArgs,
498 const TemplateArgument *TemplateArgs,
551 void mangleTemplateArgs(const TemplateArgument *TemplateArgs,
554 void mangleTemplateArg(TemplateArgument A);
937 const TemplateArgument *TemplateArgs,
1534 const TemplateArgument *TemplateArgs,
4319 for (const auto &A : SPE->getPartialArguments())
4525 void CXXNameMangler::mangleTemplateArgs(const TemplateArgument *TemplateArgs,
4534 void CXXNameMangler::mangleTemplateArg(TemplateArgument A) {
4543 case TemplateArgument::Null:
4546 case TemplateArgument::Type:
4549 case TemplateArgument::Template:
4553 case TemplateArgument::TemplateExpansion:
4558 case TemplateArgument::Expression: {
4578 case TemplateArgument::Integral:
4581 case TemplateArgument::Declaration: {
4604 case TemplateArgument::NullPtr: {
4611 case TemplateArgument::Pack: {
4614 for (const auto &P : A.pack_elements())
tools/clang/lib/AST/JSONNodeDumper.cpp 142 void JSONNodeDumper::Visit(const TemplateArgument &TA, SourceRange R,
1451 void JSONNodeDumper::VisitNullTemplateArgument(const TemplateArgument &TA) {
1454 void JSONNodeDumper::VisitTypeTemplateArgument(const TemplateArgument &TA) {
1458 const TemplateArgument &TA) {
1461 void JSONNodeDumper::VisitNullPtrTemplateArgument(const TemplateArgument &TA) {
1464 void JSONNodeDumper::VisitIntegralTemplateArgument(const TemplateArgument &TA) {
1467 void JSONNodeDumper::VisitTemplateTemplateArgument(const TemplateArgument &TA) {
1472 const TemplateArgument &TA) {
1477 const TemplateArgument &TA) {
1480 void JSONNodeDumper::VisitPackTemplateArgument(const TemplateArgument &TA) {
tools/clang/lib/AST/Linkage.h 105 LinkageInfo getLVForTemplateArgumentList(ArrayRef<TemplateArgument> Args,
tools/clang/lib/AST/MicrosoftMangle.cpp 384 void mangleTemplateArg(const TemplateDecl *TD, const TemplateArgument &TA,
1424 const TemplateArgument &TA = TemplateArgs[i];
1427 if (i > 0 && TA.getKind() == TemplateArgument::Pack &&
1428 TemplateArgs[i - 1].getKind() == TemplateArgument::Pack)
1436 const TemplateArgument &TA,
1448 case TemplateArgument::Null:
1450 case TemplateArgument::TemplateExpansion:
1452 case TemplateArgument::Type: {
1457 case TemplateArgument::Declaration: {
1478 case TemplateArgument::Integral:
1482 case TemplateArgument::NullPtr: {
1511 case TemplateArgument::Expression:
1514 case TemplateArgument::Pack: {
1515 ArrayRef<TemplateArgument> TemplateArgs = TA.getPackAsArray();
1530 for (const TemplateArgument &PA : TemplateArgs)
1535 case TemplateArgument::Template: {
tools/clang/lib/AST/ODRHash.cpp 157 void ODRHash::AddTemplateArgument(TemplateArgument TA) {
162 case TemplateArgument::Null:
164 case TemplateArgument::Type:
167 case TemplateArgument::Declaration:
170 case TemplateArgument::NullPtr:
171 case TemplateArgument::Integral:
173 case TemplateArgument::Template:
174 case TemplateArgument::TemplateExpansion:
177 case TemplateArgument::Expression:
180 case TemplateArgument::Pack:
182 for (auto SubTA : TA.pack_elements()) {
273 void AddTemplateArgument(TemplateArgument TA) {
539 for (const TemplateArgument &TA : SpecializationArgs->asArray()) {
644 for (const TemplateArgument &TA : List.asArray())
1006 for (const auto &TA : T->template_arguments()) {
1071 for (const auto &TA : T->template_arguments()) {
tools/clang/lib/AST/QualTypeNames.cpp 91 TemplateArgument &Arg,
98 if (Arg.getKind() == TemplateArgument::Template) {
104 } else if (Arg.getKind() == TemplateArgument::Type) {
127 SmallVector<TemplateArgument, 4> FQArgs;
132 TemplateArgument Arg(*I);
159 SmallVector<TemplateArgument, 4> FQArgs;
163 TemplateArgument Arg(TemplateArgs[I]);
tools/clang/lib/AST/StmtPrinter.cpp 1798 const TemplateArgument &Pack = Args->get(0);
1799 for (const auto &P : Pack.pack_elements()) {
tools/clang/lib/AST/StmtProfile.cpp 73 void VisitTemplateArgument(const TemplateArgument &Arg);
1864 for (const auto &TA : Args)
2031 void StmtProfiler::VisitTemplateArgument(const TemplateArgument &Arg) {
2035 case TemplateArgument::Null:
2038 case TemplateArgument::Type:
2042 case TemplateArgument::Template:
2043 case TemplateArgument::TemplateExpansion:
2047 case TemplateArgument::Declaration:
2051 case TemplateArgument::NullPtr:
2055 case TemplateArgument::Integral:
2060 case TemplateArgument::Expression:
2064 case TemplateArgument::Pack:
2065 for (const auto &P : Arg.pack_elements())
tools/clang/lib/AST/TemplateBase.cpp 52 static void printIntegral(const TemplateArgument &TemplArg,
105 TemplateArgument
107 ArrayRef<TemplateArgument> Args) {
146 for (const auto &P : pack_elements())
185 for (const auto &P : pack_elements())
242 for (const auto &P : pack_elements())
262 case TemplateArgument::Null:
263 case TemplateArgument::Type:
264 case TemplateArgument::Template:
265 case TemplateArgument::TemplateExpansion:
266 case TemplateArgument::Pack:
269 case TemplateArgument::Integral:
272 case TemplateArgument::Expression:
275 case TemplateArgument::Declaration:
278 case TemplateArgument::NullPtr:
338 bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const {
368 TemplateArgument TemplateArgument::getPackExpansionPattern() const {
443 for (const auto &P : pack_elements()) {
471 case TemplateArgument::Expression:
474 case TemplateArgument::Declaration:
477 case TemplateArgument::NullPtr:
480 case TemplateArgument::Type:
486 case TemplateArgument::Template:
492 case TemplateArgument::TemplateExpansion:
498 case TemplateArgument::Integral:
501 case TemplateArgument::Pack:
502 case TemplateArgument::Null:
510 const TemplateArgument &Arg) {
512 case TemplateArgument::Null:
517 case TemplateArgument::Type:
520 case TemplateArgument::Declaration:
523 case TemplateArgument::NullPtr:
526 case TemplateArgument::Integral:
529 case TemplateArgument::Template:
532 case TemplateArgument::TemplateExpansion:
535 case TemplateArgument::Expression: {
548 case TemplateArgument::Pack: {
tools/clang/lib/AST/TemplateName.cpp 33 TemplateArgument
57 const TemplateArgument &ArgPack) {
tools/clang/lib/AST/TextNodeDumper.cpp 99 void TextNodeDumper::Visit(const TemplateArgument &TA, SourceRange R,
584 void TextNodeDumper::VisitNullTemplateArgument(const TemplateArgument &) {
588 void TextNodeDumper::VisitTypeTemplateArgument(const TemplateArgument &TA) {
594 const TemplateArgument &TA) {
599 void TextNodeDumper::VisitNullPtrTemplateArgument(const TemplateArgument &) {
603 void TextNodeDumper::VisitIntegralTemplateArgument(const TemplateArgument &TA) {
607 void TextNodeDumper::VisitTemplateTemplateArgument(const TemplateArgument &TA) {
613 const TemplateArgument &TA) {
618 void TextNodeDumper::VisitExpressionTemplateArgument(const TemplateArgument &) {
622 void TextNodeDumper::VisitPackTemplateArgument(const TemplateArgument &) {
tools/clang/lib/AST/Type.cpp 2703 ArrayRef<TemplateArgument> Args,
2712 TemplateArgument *ArgBuffer = getArgBuffer();
2713 for (const TemplateArgument &Arg : Args) {
2717 new (ArgBuffer++) TemplateArgument(Arg);
2727 ArrayRef<TemplateArgument> Args) {
2731 for (const TemplateArgument &Arg : Args)
3390 const TemplateArgument &ArgPack)
3396 TemplateArgument SubstTemplateTypeParmPackType::getArgumentPack() const {
3406 const TemplateArgument &ArgPack) {
3409 for (const auto &P : ArgPack.pack_elements())
3437 ArrayRef<TemplateArgument> Args,
3455 auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1);
3456 for (const TemplateArgument &Arg : Args) {
3467 if (Arg.getKind() == TemplateArgument::Type &&
3472 new (TemplateArgs++) TemplateArgument(Arg);
3477 auto *Begin = reinterpret_cast<TemplateArgument *>(this + 1);
3485 ArrayRef<TemplateArgument> Args,
3488 for (const TemplateArgument &Arg : Args)
tools/clang/lib/AST/TypeLoc.cpp 526 const TemplateArgument *Args,
531 case TemplateArgument::Null:
534 case TemplateArgument::Integral:
535 case TemplateArgument::Declaration:
536 case TemplateArgument::NullPtr:
540 case TemplateArgument::Expression:
544 case TemplateArgument::Type:
550 case TemplateArgument::Template:
551 case TemplateArgument::TemplateExpansion: {
561 Args[i].getKind() == TemplateArgument::Template ? SourceLocation()
566 case TemplateArgument::Pack:
tools/clang/lib/AST/TypePrinter.cpp 1206 ArrayRef<TemplateArgument> Args;
1658 const TemplateArgument &getArgument(const TemplateArgument &A) { return A; }
1658 const TemplateArgument &getArgument(const TemplateArgument &A) { return A; }
1660 static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) {
1664 static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP,
1671 const TemplateArgument::ArgKind &Kind = A.getArgument().getKind();
1672 if (Kind == TemplateArgument::ArgKind::Type)
1678 static void printTo(raw_ostream &OS, ArrayRef<TA> Args,
1686 for (const auto &Arg : Args) {
1690 const TemplateArgument &Argument = getArgument(Arg);
1691 if (Argument.getKind() == TemplateArgument::Pack) {
1732 ArrayRef<TemplateArgument> Args,
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp 584 const internal::VariadicAllOfMatcher<TemplateArgument> templateArgument;
tools/clang/lib/ASTMatchers/Dynamic/Marshallers.h 75 return Value.isMatcher() && Value.getMatcher().hasTypedMatcher<T>();
78 static ast_matchers::internal::Matcher<T> get(const VariantValue &Value) {
79 return Value.getMatcher().getTypedMatcher<T>();
83 return ArgKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
361 RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
368 RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
tools/clang/lib/Analysis/PathDiagnostic.cpp 873 const ArrayRef<TemplateArgument> TAList,
879 const TemplateArgument &TArg,
882 if (TArg.getKind() == TemplateArgument::ArgKind::Pack) {
890 const ArrayRef<TemplateArgument> TAList,
tools/clang/lib/CodeGen/CGDebugInfo.cpp 1746 ArrayRef<TemplateArgument> TAList,
1750 const TemplateArgument &TA = TAList[i];
1755 case TemplateArgument::Type: {
1760 case TemplateArgument::Integral: {
1766 case TemplateArgument::Declaration: {
1804 case TemplateArgument::NullPtr: {
1823 case TemplateArgument::Template:
1828 case TemplateArgument::Pack:
1833 case TemplateArgument::Expression: {
1845 case TemplateArgument::TemplateExpansion:
1846 case TemplateArgument::Null:
tools/clang/lib/CodeGen/CGDebugInfo.h 251 ArrayRef<TemplateArgument> TAList,
tools/clang/lib/Index/IndexDecl.cpp 59 case TemplateArgument::Expression:
62 case TemplateArgument::Type:
65 case TemplateArgument::Template:
66 case TemplateArgument::TemplateExpansion:
tools/clang/lib/Index/USRGeneration.cpp 166 void VisitTemplateArgument(const TemplateArgument &Arg);
942 void USRGenerator::VisitTemplateArgument(const TemplateArgument &Arg) {
944 case TemplateArgument::Null:
947 case TemplateArgument::Declaration:
951 case TemplateArgument::NullPtr:
954 case TemplateArgument::TemplateExpansion:
957 case TemplateArgument::Template:
961 case TemplateArgument::Expression:
965 case TemplateArgument::Pack:
967 for (const auto &P : Arg.pack_elements())
971 case TemplateArgument::Type:
975 case TemplateArgument::Integral:
tools/clang/lib/Sema/SemaChecking.cpp 9261 const auto& TA = ArgList->get(0);
9262 if (TA.getKind() != TemplateArgument::Type) return;
tools/clang/lib/Sema/SemaCodeComplete.cpp 4271 const TemplateArgument &Argument = Specialization->getArg(0);
4272 if (Argument.getKind() != TemplateArgument::Type)
tools/clang/lib/Sema/SemaDeclCXX.cpp 1018 TemplateArgument Arg(S.Context, S.Context.MakeIntValue(I, T), T);
5643 if (TAL.getArgument().getKind() == TemplateArgument::Type)
9656 const TemplateArgument *Arguments = nullptr;
tools/clang/lib/Sema/SemaExpr.cpp 1747 TemplateArgument TypeArg(CharTy);
1753 TemplateArgument Arg(Context, Value, CharTy);
3499 TemplateArgument Arg(Context, Value, Context.CharTy);
16972 bool TraverseTemplateArgument(const TemplateArgument &Arg);
16977 const TemplateArgument &Arg) {
16982 if (Arg.getKind() == TemplateArgument::Declaration) {
16985 } else if (Arg.getKind() == TemplateArgument::Expression) {
tools/clang/lib/Sema/SemaExprCXX.cpp 613 for (const TemplateArgument &TA : TAL.asArray()) {
615 if (TA.getKind() == TemplateArgument::Type)
617 else if (TA.getKind() == TemplateArgument::Declaration)
tools/clang/lib/Sema/SemaLookup.cpp 2668 const TemplateArgument &Arg) {
2672 case TemplateArgument::Null:
2675 case TemplateArgument::Type:
2682 case TemplateArgument::Template:
2683 case TemplateArgument::TemplateExpansion: {
2699 case TemplateArgument::Declaration:
2700 case TemplateArgument::Integral:
2701 case TemplateArgument::Expression:
2702 case TemplateArgument::NullPtr:
2707 case TemplateArgument::Pack:
2708 for (const auto &P : Arg.pack_elements())
tools/clang/lib/Sema/SemaOverload.cpp 580 TemplateArgument FirstArg;
581 TemplateArgument SecondArg;
780 const TemplateArgument *DeductionFailureInfo::getFirstArg() {
810 const TemplateArgument *DeductionFailureInfo::getSecondArg() {
10432 TemplateArgument FirstTA = *DeductionFailure.getFirstArg();
10433 TemplateArgument SecondTA = *DeductionFailure.getSecondArg();
10434 if (FirstTA.getKind() == TemplateArgument::Template &&
10435 SecondTA.getKind() == TemplateArgument::Template) {
tools/clang/lib/Sema/SemaTemplate.cpp 885 TemplateArgument TArg;
1230 TemplateArgument Converted;
1762 SmallVector<TemplateArgument, 16> SubstArgs;
2991 const SmallVectorImpl<TemplateArgument> &Converted,
3010 TemplateArgument NumArgsArg = Converted[2];
3026 TemplateArgument TA(Context, I, ArgTy);
3044 TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
3228 SmallVector<TemplateArgument, 4> Converted;
3272 == TemplateArgument::Expression) {
3648 const TemplateArgument &Arg, unsigned Depth, unsigned Index) {
3650 case TemplateArgument::Null:
3651 case TemplateArgument::NullPtr:
3652 case TemplateArgument::Integral:
3653 case TemplateArgument::Declaration:
3654 case TemplateArgument::Pack:
3655 case TemplateArgument::TemplateExpansion:
3658 case TemplateArgument::Type: {
3666 case TemplateArgument::Expression: {
3675 case TemplateArgument::Template:
3685 ArrayRef<TemplateArgument> Args) {
3692 TemplateArgument Arg = Args[I];
3697 if (Arg.getKind() != TemplateArgument::Pack || Arg.pack_size() != 1 ||
3873 SmallVector<TemplateArgument, 4> Converted;
4042 SmallVector<TemplateArgument, 4> Converted;
4230 llvm::SmallVector<TemplateArgument, 4> Converted;
4239 for (TemplateArgument &Arg : Converted) {
4484 SmallVectorImpl<TemplateArgument> &Converted) {
4485 const TemplateArgument &Arg = AL.getArgument();
4491 case TemplateArgument::Type:
4498 case TemplateArgument::Template:
4499 case TemplateArgument::TemplateExpansion: {
4507 case TemplateArgument::Expression: {
4624 SmallVectorImpl<TemplateArgument> &Converted) {
4733 SmallVectorImpl<TemplateArgument> &Converted,
4774 SmallVectorImpl<TemplateArgument>
4899 SmallVectorImpl<TemplateArgument> &Converted,
4952 case TemplateArgument::Null:
4955 case TemplateArgument::Expression: {
4956 TemplateArgument Result;
4970 TemplateArgument TA(Res.get());
4978 case TemplateArgument::Declaration:
4979 case TemplateArgument::Integral:
4980 case TemplateArgument::NullPtr:
4986 case TemplateArgument::Template:
4987 case TemplateArgument::TemplateExpansion:
5013 if (Arg.getArgument().getKind() == TemplateArgument::TemplateExpansion){
5019 TemplateArgument Result;
5037 case TemplateArgument::Type: {
5058 case TemplateArgument::Pack:
5098 if (Arg.getArgument().getKind() == TemplateArgument::Type) {
5106 case TemplateArgument::Null:
5109 case TemplateArgument::Template:
5110 case TemplateArgument::TemplateExpansion:
5117 case TemplateArgument::Expression:
5118 case TemplateArgument::Type:
5125 case TemplateArgument::Declaration:
5127 case TemplateArgument::Integral:
5129 case TemplateArgument::NullPtr:
5132 case TemplateArgument::Pack:
5208 SmallVectorImpl<TemplateArgument> &Converted,
5230 SmallVector<TemplateArgument, 2> ArgumentPack;
5243 TemplateArgument::CreatePackCopy(Context, ArgumentPack));
5323 TemplateArgument::CreatePackCopy(Context, ArgumentPack));
5341 TemplateArgument::CreatePackCopy(Context, ArgumentPack));
5921 TemplateArgument &Converted) {
6207 TemplateArgument &Converted) {
6955 if (Arg.getKind() == TemplateArgument::NullPtr) {
7553 const TemplateArgument *Args, unsigned NumArgs, bool IsDefaultArgument) {
7555 if (Args[I].getKind() == TemplateArgument::Pack) {
7564 if (Args[I].getKind() != TemplateArgument::Expression)
7650 unsigned NumExplicit, ArrayRef<TemplateArgument> TemplateArgs) {
7795 SmallVector<TemplateArgument, 4> Converted;
9041 SmallVector<TemplateArgument, 4> Converted;
9952 != TemplateArgument::Expression)
10285 const TemplateArgument *Args,
tools/clang/lib/Sema/SemaTemplateDeduction.cpp 136 const TemplateArgument &Param,
137 TemplateArgument Arg,
155 ArrayRef<TemplateArgument> Params,
156 ArrayRef<TemplateArgument> Args,
162 const TemplateArgument &TemplateArg,
237 case TemplateArgument::Null:
240 case TemplateArgument::Type:
242 if (Y.getKind() == TemplateArgument::Type &&
254 case TemplateArgument::Integral:
258 if (Y.getKind() == TemplateArgument::Expression ||
259 Y.getKind() == TemplateArgument::Declaration ||
260 (Y.getKind() == TemplateArgument::Integral &&
267 case TemplateArgument::Template:
268 if (Y.getKind() == TemplateArgument::Template &&
275 case TemplateArgument::TemplateExpansion:
276 if (Y.getKind() == TemplateArgument::TemplateExpansion &&
284 case TemplateArgument::Expression: {
285 if (Y.getKind() != TemplateArgument::Expression)
299 case TemplateArgument::Declaration:
304 if (Y.getKind() == TemplateArgument::Expression)
310 if (Y.getKind() == TemplateArgument::Integral) {
319 if (Y.getKind() == TemplateArgument::Declaration &&
326 case TemplateArgument::NullPtr:
329 if (Y.getKind() == TemplateArgument::Expression)
334 if (Y.getKind() == TemplateArgument::Integral)
338 if (Y.getKind() == TemplateArgument::NullPtr)
344 case TemplateArgument::Pack: {
345 if (Y.getKind() != TemplateArgument::Pack ||
349 llvm::SmallVector<TemplateArgument, 8> NewPack;
350 for (TemplateArgument::pack_iterator XA = X.pack_begin(),
354 TemplateArgument Merged = checkDeducedTemplateArguments(
363 TemplateArgument::CreatePackCopy(Context, NewPack),
473 TemplateArgument New(D, T);
685 TemplateDeductionInfo &Info, TemplateArgument Pattern)
718 unsigned addPacks(TemplateArgument Pattern) {
760 const TemplateArgument *PartialPackArgs = nullptr;
891 NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack());
893 TemplateArgument *ArgumentPack =
894 new (S.Context) TemplateArgument[Pack.New.size()];
2119 const TemplateArgument &Param,
2120 TemplateArgument Arg,
2130 case TemplateArgument::Null:
2133 case TemplateArgument::Type:
2134 if (Arg.getKind() == TemplateArgument::Type)
2143 case TemplateArgument::Template:
2144 if (Arg.getKind() == TemplateArgument::Template)
2152 case TemplateArgument::TemplateExpansion:
2155 case TemplateArgument::Declaration:
2156 if (Arg.getKind() == TemplateArgument::Declaration &&
2164 case TemplateArgument::NullPtr:
2165 if (Arg.getKind() == TemplateArgument::NullPtr &&
2173 case TemplateArgument::Integral:
2174 if (Arg.getKind() == TemplateArgument::Integral) {
2183 if (Arg.getKind() == TemplateArgument::Expression) {
2193 case TemplateArgument::Expression:
2196 if (Arg.getKind() == TemplateArgument::Integral)
2202 if (Arg.getKind() == TemplateArgument::NullPtr)
2206 if (Arg.getKind() == TemplateArgument::Expression)
2209 if (Arg.getKind() == TemplateArgument::Declaration)
2223 case TemplateArgument::Pack:
2238 static bool hasTemplateArgumentForDeduction(ArrayRef<TemplateArgument> &Args,
2243 const TemplateArgument &Arg = Args[ArgIdx];
2244 if (Arg.getKind() != TemplateArgument::Pack)
2255 static bool hasPackExpansionBeforeEnd(ArrayRef<TemplateArgument> Args) {
2257 for (const auto &A : Args) {
2261 if (A.getKind() == TemplateArgument::Pack)
2275 ArrayRef<TemplateArgument> Params,
2276 ArrayRef<TemplateArgument> Args,
2327 TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern();
2370 TemplateArgument X,
2371 const TemplateArgument &Y,
2382 case TemplateArgument::Null:
2385 case TemplateArgument::Type:
2389 case TemplateArgument::Declaration:
2392 case TemplateArgument::NullPtr:
2395 case TemplateArgument::Template:
2396 case TemplateArgument::TemplateExpansion:
2402 case TemplateArgument::Integral:
2405 case TemplateArgument::Expression: {
2412 case TemplateArgument::Pack:
2416 for (TemplateArgument::pack_iterator XP = X.pack_begin(),
2443 Sema::getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,
2446 case TemplateArgument::Null:
2449 case TemplateArgument::Type:
2453 case TemplateArgument::Declaration: {
2461 case TemplateArgument::NullPtr: {
2470 case TemplateArgument::Integral: {
2476 case TemplateArgument::Template:
2477 case TemplateArgument::TemplateExpansion: {
2486 if (Arg.getKind() == TemplateArgument::Template)
2494 case TemplateArgument::Expression:
2497 case TemplateArgument::Pack:
2512 SmallVectorImpl<TemplateArgument> &Output) {
2531 if (Arg.getKind() == TemplateArgument::Pack) {
2534 SmallVector<TemplateArgument, 2> PackedArgsBuilder;
2535 for (const auto &P : Arg.pack_elements()) {
2587 TemplateArgument::CreatePackCopy(S.Context, PackedArgsBuilder));
2601 TemplateDeductionInfo &Info, SmallVectorImpl<TemplateArgument> &Builder,
2731 SmallVector<TemplateArgument, 4> Builder;
2770 SmallVector<TemplateArgument, 4> ConvertedInstArgs;
2777 TemplateArgument InstArg = ConvertedInstArgs.data()[I];
2810 SmallVector<TemplateArgument, 4> Builder;
2818 TemplateArgument InstArg = Builder[I];
2865 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
2906 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
2996 SmallVector<TemplateArgument, 4> Builder;
3001 SmallVector<TemplateArgument, 4> DeducedArgs;
3036 const TemplateArgument &Arg = Builder.back();
3037 if (Arg.getKind() == TemplateArgument::Pack) {
3148 const TemplateArgument &Arg = ExplicitArgumentList->get(I);
3324 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
3336 SmallVector<TemplateArgument, 4> Builder;
4539 Deduced[0].getKind() != TemplateArgument::Null)
4555 if (Deduced[0].getKind() != TemplateArgument::Type)
5085 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
5173 SmallVector<TemplateArgument, 8> PrimaryArgs;
5211 SmallVector<TemplateArgument, 8> AArgs;
5218 SmallVector<TemplateArgument, 4> PArgs;
5227 TemplateArgument Arg = PArgs[I];
5228 if (Arg.getKind() == TemplateArgument::Pack) {
5623 const TemplateArgument &TemplateArg,
5628 case TemplateArgument::Null:
5629 case TemplateArgument::Integral:
5630 case TemplateArgument::Declaration:
5633 case TemplateArgument::NullPtr:
5638 case TemplateArgument::Type:
5643 case TemplateArgument::Template:
5644 case TemplateArgument::TemplateExpansion:
5650 case TemplateArgument::Expression:
5655 case TemplateArgument::Pack:
5656 for (const auto &P : TemplateArg.pack_elements())
tools/clang/lib/Sema/SemaTemplateInstantiate.cpp 223 Decl *Entity, NamedDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
271 TemplateDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
282 ArrayRef<TemplateArgument> TemplateArgs,
296 ArrayRef<TemplateArgument> TemplateArgs,
307 ArrayRef<TemplateArgument> TemplateArgs,
318 ArrayRef<TemplateArgument> TemplateArgs,
328 ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
337 NonTypeTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
347 TemplateTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
357 NamedDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
367 ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
843 TemplateArgument ForgetPartiallySubstitutedPack() {
844 TemplateArgument Result;
860 void RememberPartiallySubstitutedPack(TemplateArgument Arg) {
1035 static TemplateArgument
1036 getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg) {
1059 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
1100 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getIndex());
1198 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
1229 TemplateArgument Arg = SubstPack->getArgumentPack();
1258 TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition());
1265 if (Arg.getKind() == TemplateArgument::Pack) {
1328 if (arg.getKind() == TemplateArgument::Expression) {
1333 } else if (arg.getKind() == TemplateArgument::Declaration ||
1334 arg.getKind() == TemplateArgument::NullPtr) {
1336 if (arg.getKind() == TemplateArgument::Declaration) {
1390 TemplateArgument Arg = E->getArgumentPack();
1540 TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex());
1604 TemplateArgument Arg = TL.getTypePtr()->getArgumentPack();
3088 const TemplateArgument *ExplicitArgs,
3101 const TemplateArgument **ExplicitArgs,
tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp 1770 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
1904 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
2076 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
2211 ArrayRef<TemplateArgument> Innermost = TemplateArgs.getInnermost();
3277 SmallVector<TemplateArgument, 4> Converted;
3401 SmallVector<TemplateArgument, 4> Converted;
3427 ArrayRef<TemplateArgument> Converted,
3587 SmallVector<TemplateArgument, 4> Converted;
3714 SmallVector<TemplateArgument, 4> Converted;
4409 SmallVectorImpl<TemplateArgument> &Converted,
5445 for (TemplateArgument Arg : TemplateArgs.getInnermost().take_front(
5447 ArrayRef<TemplateArgument> Unpacked(Arg);
5448 if (Arg.getKind() == TemplateArgument::Pack)
5450 for (TemplateArgument UnpackedArg : Unpacked)
tools/clang/lib/Sema/SemaTemplateVariadic.cpp 206 bool TraverseTemplateArgument(const TemplateArgument &Arg) {
491 void Sema::collectUnexpandedParameterPacks(TemplateArgument Arg,
1028 const TemplateArgument &Argument = OrigLoc.getArgument();
1031 case TemplateArgument::Type: {
1056 case TemplateArgument::Expression: {
1065 case TemplateArgument::TemplateExpansion:
1072 case TemplateArgument::Declaration:
1073 case TemplateArgument::NullPtr:
1074 case TemplateArgument::Template:
1075 case TemplateArgument::Integral:
1076 case TemplateArgument::Pack:
1077 case TemplateArgument::Null:
1084 Optional<unsigned> Sema::getFullyPackExpandedSize(TemplateArgument Arg) {
1092 TemplateArgument Pack;
1094 case TemplateArgument::Type:
1101 case TemplateArgument::Expression:
1114 case TemplateArgument::Template:
1122 case TemplateArgument::Declaration:
1123 case TemplateArgument::NullPtr:
1124 case TemplateArgument::TemplateExpansion:
1125 case TemplateArgument::Integral:
1126 case TemplateArgument::Pack:
1127 case TemplateArgument::Null:
1132 for (TemplateArgument Elem : Pack.pack_elements()) {
tools/clang/lib/Sema/TreeTransform.h 101 TemplateArgument Old;
273 TemplateArgument ForgetPartiallySubstitutedPack() {
282 void RememberPartiallySubstitutedPack(TemplateArgument Arg) { }
595 void InventTemplateArgumentLoc(const TemplateArgument &Arg,
1213 const TemplateArgument &ArgPack) {
3267 case TemplateArgument::Expression: {
3277 case TemplateArgument::Template:
3285 case TemplateArgument::Null:
3286 case TemplateArgument::Integral:
3287 case TemplateArgument::Declaration:
3288 case TemplateArgument::Pack:
3289 case TemplateArgument::TemplateExpansion:
3290 case TemplateArgument::NullPtr:
3293 case TemplateArgument::Type:
3934 const TemplateArgument &Arg,
3938 case TemplateArgument::Null:
3942 case TemplateArgument::Type:
3948 case TemplateArgument::Template:
3949 case TemplateArgument::TemplateExpansion: {
3957 if (Arg.getKind() == TemplateArgument::Template)
3969 case TemplateArgument::Expression:
3973 case TemplateArgument::Declaration:
3974 case TemplateArgument::Integral:
3975 case TemplateArgument::Pack:
3976 case TemplateArgument::NullPtr:
3986 const TemplateArgument &Arg = Input.getArgument();
3988 case TemplateArgument::Null:
3989 case TemplateArgument::Integral:
3990 case TemplateArgument::Pack:
3991 case TemplateArgument::Declaration:
3992 case TemplateArgument::NullPtr:
3995 case TemplateArgument::Type: {
4007 case TemplateArgument::Template: {
4028 case TemplateArgument::TemplateExpansion:
4031 case TemplateArgument::Expression: {
4123 if (In.getArgument().getKind() == TemplateArgument::Pack) {
4130 TemplateArgument::pack_iterator>
11992 ArrayRef<TemplateArgument> PackArgs;
11993 TemplateArgument ArgStorage;
12046 for (const TemplateArgument &Arg : PackArgs) {
12094 Derived, const TemplateArgument*> PackLocIterator;
12103 SmallVector<TemplateArgument, 8> Args;
tools/clang/lib/Serialization/ASTReader.cpp 6738 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
6791 SmallVector<TemplateArgument, 8> Args;
6820 SmallVector<TemplateArgument, 8> Args;
7538 TemplateArgument::ArgKind Kind,
7542 case TemplateArgument::Expression:
7544 case TemplateArgument::Type:
7546 case TemplateArgument::Template: {
7553 case TemplateArgument::TemplateExpansion: {
7561 case TemplateArgument::Null:
7562 case TemplateArgument::Integral:
7563 case TemplateArgument::Declaration:
7564 case TemplateArgument::NullPtr:
7565 case TemplateArgument::Pack:
7575 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
7577 if (Arg.getKind() == TemplateArgument::Expression) {
9270 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
9271 if (ArgPack.getKind() != TemplateArgument::Pack)
9281 TemplateArgument ASTReader::ReadTemplateArgument(ModuleFile &F,
9291 TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
9295 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
9297 case TemplateArgument::Null:
9299 case TemplateArgument::Type:
9301 case TemplateArgument::Declaration: {
9305 case TemplateArgument::NullPtr:
9307 case TemplateArgument::Integral: {
9312 case TemplateArgument::Template:
9314 case TemplateArgument::TemplateExpansion: {
9321 case TemplateArgument::Expression:
9323 case TemplateArgument::Pack: {
9325 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
9325 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
9358 ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
11210 llvm::SmallVector<const TemplateArgument *, 8> ExpandedList;
11211 for (const TemplateArgument &TA : TAL->asArray()) {
11212 if (TA.getKind() != TemplateArgument::Pack) {
11216 for (const TemplateArgument &PackTA : TA.getPackAsArray()) {
11222 llvm::SmallVector<const TemplateArgument *, 8> FirstExpandedList =
11224 llvm::SmallVector<const TemplateArgument *, 8> SecondExpandedList =
11245 const TemplateArgument &FirstTA = *FirstExpandedList[i],
11641 TemplateArgument FirstTA =
11643 TemplateArgument SecondTA =
tools/clang/lib/Serialization/ASTReaderDecl.cpp 909 SmallVector<TemplateArgument, 8> TemplArgs;
2102 SmallVector<TemplateArgument, 8> TemplArgs;
2116 SmallVector<TemplateArgument, 8> TemplArgs;
2215 SmallVector<TemplateArgument, 8> TemplArgs;
2239 SmallVector<TemplateArgument, 8> TemplArgs;
4395 SmallVector<TemplateArgument, 8> TemplArgs;
tools/clang/lib/Serialization/ASTReaderStmt.cpp 748 llvm::SmallVector<TemplateArgument, 4> Args;
1861 for (auto *I = E->getTrailingObjects<TemplateArgument>(),
1861 for (auto *I = E->getTrailingObjects<TemplateArgument>(),
1864 new (I) TemplateArgument(Record.readTemplateArgument());
1882 TemplateArgument ArgPack = Record.readTemplateArgument();
1883 if (ArgPack.getKind() != TemplateArgument::Pack)
tools/clang/lib/Serialization/ASTWriter.cpp 433 for (const auto &ArgI : *T)
502 for (const auto &I : *T)
5577 TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg) {
5579 case TemplateArgument::Expression:
5582 case TemplateArgument::Type:
5585 case TemplateArgument::Template:
5589 case TemplateArgument::TemplateExpansion:
5594 case TemplateArgument::Null:
5595 case TemplateArgument::Integral:
5596 case TemplateArgument::Declaration:
5597 case TemplateArgument::NullPtr:
5598 case TemplateArgument::Pack:
5607 if (Arg.getArgument().getKind() == TemplateArgument::Expression) {
6028 void ASTRecordWriter::AddTemplateArgument(const TemplateArgument &Arg) {
6031 case TemplateArgument::Null:
6033 case TemplateArgument::Type:
6036 case TemplateArgument::Declaration:
6040 case TemplateArgument::NullPtr:
6043 case TemplateArgument::Integral:
6047 case TemplateArgument::Template:
6050 case TemplateArgument::TemplateExpansion:
6057 case TemplateArgument::Expression:
6060 case TemplateArgument::Pack:
6062 for (const auto &P : Arg.pack_elements())
tools/clang/lib/Serialization/ASTWriterStmt.cpp 394 ArrayRef<TemplateArgument> TemplateArgs = E->getTemplateArguments();
402 for (const TemplateArgument &Arg : TemplateArgs)
1799 for (const auto &TA : E->getPartialArguments())
tools/clang/tools/extra/clang-tidy/boost/UseToStringCheck.cpp 46 Result.Nodes.getNodeAs<TemplateArgument>("char_type")->getAsType();
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp 123 const auto &SizeArg = TemplateArgs[1];
124 if (SizeArg.getKind() != TemplateArgument::Integral)
tools/clang/tools/extra/clang-tidy/misc/UniqueptrResetReleaseCheck.cpp 50 auto DeleterArgument = Class->getTemplateArgs()[1];
51 if (DeleterArgument.getKind() != TemplateArgument::Type)
tools/clang/tools/extra/clang-tidy/misc/UnusedUsingDeclsCheck.cpp 27 ArrayRef<TemplateArgument> TemplateArgs =
31 for (const auto &Arg : TemplateArgs) {
130 if (const auto *Used = Result.Nodes.getNodeAs<TemplateArgument>("used")) {
130 if (const auto *Used = Result.Nodes.getNodeAs<TemplateArgument>("used")) {
131 if (Used->getKind() == TemplateArgument::Template) {
134 } else if (Used->getKind() == TemplateArgument::Type) {
137 } else if (Used->getKind() == TemplateArgument::Declaration) {
tools/clang/tools/extra/clang-tidy/modernize/UseTransparentFunctorsCheck.cpp 92 const auto *Functor = Result.Nodes.getNodeAs<TemplateArgument>("Functor");
92 const auto *Functor = Result.Nodes.getNodeAs<TemplateArgument>("Functor");
104 const TemplateArgument &Arg = FunctorParentType->getArg(ArgNum);
105 if (Arg.getKind() != TemplateArgument::Type)
tools/clang/tools/extra/clangd/FindTarget.cpp 612 case TemplateArgument::Template:
613 case TemplateArgument::TemplateExpansion:
622 case TemplateArgument::Declaration:
624 case TemplateArgument::Integral:
625 case TemplateArgument::Null:
626 case TemplateArgument::NullPtr:
628 case TemplateArgument::Pack:
629 case TemplateArgument::Type:
630 case TemplateArgument::Expression:
tools/clang/tools/extra/clangd/unittests/ParsedASTTests.cpp 59 for (const auto Arg : Args->asArray()) {
tools/clang/tools/extra/modularize/Modularize.cpp 562 bool TraverseTemplateArgument(const TemplateArgument &Arg) { return true; }
566 bool TraverseTemplateArguments(const TemplateArgument *Args,
753 bool TraverseTemplateArgument(const TemplateArgument &Arg) { return true; }
757 bool TraverseTemplateArguments(const TemplateArgument *Args,
tools/clang/tools/libclang/CIndex.cpp 1464 case TemplateArgument::Null:
1465 case TemplateArgument::Integral:
1466 case TemplateArgument::Pack:
1469 case TemplateArgument::Type:
1474 case TemplateArgument::Declaration:
1479 case TemplateArgument::NullPtr:
1484 case TemplateArgument::Expression:
1489 case TemplateArgument::Template:
1490 case TemplateArgument::TemplateExpansion:
tools/clang/tools/libclang/CXCursor.cpp 1268 CXCursor C, unsigned I, TemplateArgument *TA) {
1295 TemplateArgument TA;
1301 case TemplateArgument::Null: return CXTemplateArgumentKind_Null;
1302 case TemplateArgument::Type: return CXTemplateArgumentKind_Type;
1303 case TemplateArgument::Declaration:
1305 case TemplateArgument::NullPtr: return CXTemplateArgumentKind_NullPtr;
1306 case TemplateArgument::Integral: return CXTemplateArgumentKind_Integral;
1307 case TemplateArgument::Template: return CXTemplateArgumentKind_Template;
1308 case TemplateArgument::TemplateExpansion:
1310 case TemplateArgument::Expression: return CXTemplateArgumentKind_Expression;
1311 case TemplateArgument::Pack: return CXTemplateArgumentKind_Pack;
1318 TemplateArgument TA;
1324 if (TA.getKind() != TemplateArgument::Type) {
1332 TemplateArgument TA;
1339 if (TA.getKind() != TemplateArgument::Integral) {
1349 TemplateArgument TA;
1356 if (TA.getKind() != TemplateArgument::Integral) {
tools/clang/tools/libclang/CXType.cpp 176 static Optional<ArrayRef<TemplateArgument>>
192 static Optional<QualType> TemplateArgumentToQualType(const TemplateArgument &A) {
193 if (A.getKind() == TemplateArgument::Type)
199 FindTemplateArgumentTypeAt(ArrayRef<TemplateArgument> TA, unsigned index) {
201 for (const auto &A : TA) {
202 if (A.getKind() == TemplateArgument::Pack) {
1124 static unsigned GetTemplateArgumentArraySize(ArrayRef<TemplateArgument> TA) {
1126 for (const auto &Arg : TA)
1127 if (Arg.getKind() == TemplateArgument::Pack)
tools/clang/unittests/AST/ASTTraverserTest.cpp 58 void Visit(const TemplateArgument &A, SourceRange R = {},
63 template <typename... T> void Visit(T...) {}
75 template <typename... NodeType> std::string dumpASTString(NodeType &&... N) {
83 Dumper.Visit(std::forward<NodeType &&>(N)...);
97 static void withDynNode(T Node, const std::string &DumpString) {
111 void verifyWithDynNode(T Node, const std::string &DumpString) {
114 Verifier<T>::withDynNode(Node, DumpString);
219 TemplateArgument TA = Templ->getTemplateArgs()[0];
tools/clang/unittests/AST/ASTTypeTraitsTest.cpp 25 return ASTNodeKind::getFromNodeKind<T>();
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/TemplateArgumentLocTraverser.cpp 21 const TemplateArgument &Arg = ArgLoc.getArgument();
tools/lldb/include/lldb/Symbol/ClangASTContext.h 278 llvm::SmallVector<clang::TemplateArgument, 2> args;
tools/lldb/source/Symbol/ClangASTContext.cpp 1423 bool IsValueParam(const clang::TemplateArgument &argument) {
1424 return argument.getKind() == TemplateArgument::Integral;
1613 llvm::SmallVector<clang::TemplateArgument, 2> args(
1619 args[args.size() - 1] = TemplateArgument::CreatePackCopy(
7751 case clang::TemplateArgument::Null:
7754 case clang::TemplateArgument::NullPtr:
7757 case clang::TemplateArgument::Type:
7760 case clang::TemplateArgument::Declaration:
7763 case clang::TemplateArgument::Integral:
7766 case clang::TemplateArgument::Template:
7769 case clang::TemplateArgument::TemplateExpansion:
7772 case clang::TemplateArgument::Expression:
7775 case clang::TemplateArgument::Pack:
7789 const clang::TemplateArgument &template_arg =
7791 if (template_arg.getKind() != clang::TemplateArgument::Type)
7805 const clang::TemplateArgument &template_arg =
7807 if (template_arg.getKind() != clang::TemplateArgument::Integral)
tools/lldb/source/Symbol/CxxModuleHandler.cpp 154 static bool templateArgsAreSupported(ArrayRef<TemplateArgument> a) {
155 for (const TemplateArgument &arg : a) {
157 case TemplateArgument::Type:
158 case TemplateArgument::Integral:
224 llvm::SmallVector<TemplateArgument, 4> imported_args;
227 for (const TemplateArgument &arg : foreign_args.asArray()) {
229 case TemplateArgument::Type: {
238 case TemplateArgument::Integral: {
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*;
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
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)...); }
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
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_uninitialized.h 144 const _Tp& __x)
182 const _Tp& __x)
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;
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/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
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>
1286 : public is_assignable<_Tp&, const _Tp&>
1286 : public is_assignable<_Tp&, const _Tp&>
1292 : public __is_copy_assignable_impl<_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;
1580 { typedef _Tp const type; };
1629 { typedef _Tp type; };
1633 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1664 : public __add_rvalue_reference_helper<_Tp>
1955 { typedef _Tp type; };
2171 { typedef _Iffalse type; };