|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
tools/clang/include/clang/AST/LocInfoType.h 28 class LocInfoType : public Type {
tools/clang/include/clang/AST/Type.h 2436 class BuiltinType : public Type {
2525 class ComplexType : public Type, public llvm::FoldingSetNode {
2555 class ParenType : public Type, public llvm::FoldingSetNode {
2585 class PointerType : public Type, public llvm::FoldingSetNode {
2633 class AdjustedType : public Type, public llvm::FoldingSetNode {
2687 class BlockPointerType : public Type, public llvm::FoldingSetNode {
2721 class ReferenceType : public Type, public llvm::FoldingSetNode {
2804 class MemberPointerType : public Type, public llvm::FoldingSetNode {
2860 class ArrayType : public Type, public llvm::FoldingSetNode {
3124 class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
3166 class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
3206 class VectorType : public Type, public llvm::FoldingSetNode {
3283 class DependentVectorType : public Type, public llvm::FoldingSetNode {
3393 class FunctionType : public Type {
4160 class UnresolvedUsingType : public Type {
4190 class TypedefType : public Type {
4216 class MacroQualifiedType : public Type {
4250 class TypeOfExprType : public Type {
4293 class TypeOfType : public Type {
4320 class DecltypeType : public Type {
4363 class UnaryTransformType : public Type {
4421 class TagType : public Type {
4499 class AttributedType : public Type, public llvm::FoldingSetNode {
4596 class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4677 class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4733 class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
4783 class DeducedType : public Type {
4917 class alignas(8) TemplateSpecializationType
5054 class InjectedClassNameType : public Type {
5154 class TypeWithKeyword : public Type {
5431 class PackExpansionType : public Type, public llvm::FoldingSetNode {
5540 class ObjCTypeParamType : public Type,
5614 class ObjCObjectType : public Type,
5870 class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
6044 class AtomicType : public Type, public llvm::FoldingSetNode {
6078 class PipeType : public Type, public llvm::FoldingSetNode {
Declarations
tools/clang/include/clang/AST/APValue.h 33 class Type;
tools/clang/include/clang/AST/ASTFwd.h 25 class Type;
tools/clang/include/clang/AST/MangleNumberingContext.h 26 class Type;
tools/clang/include/clang/AST/NestedNameSpecifier.h 35 class Type;
tools/clang/include/clang/AST/Type.h 62 class Type;
tools/clang/lib/CodeGen/CodeGenTBAA.h 29 class Type;
tools/clang/lib/CodeGen/CodeGenTypes.h 46 class Type;
tools/lldb/include/lldb/Core/ClangForward.h 116 class Type;
References
include/llvm/Support/Casting.h 57 static inline bool doit(const From &Val) {
66 static inline bool doit(const From &) { return true; }
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
106 return isa_impl<To, From>::doit(*Val);
122 return isa_impl_wrap<To, SimpleFrom,
132 return isa_impl_cl<To,FromTy>::doit(Val);
142 return isa_impl_wrap<X, const Y,
176 using ret_type = const To *; // Constant pointer arg case, return const Ty*
198 using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
218 static typename cast_retty<To, From>::ret_type doit(From &Val) {
219 return cast_convert_val<To, SimpleFrom,
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
248 typename cast_retty<X, const Y>::ret_type>::type
252 X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
258 return cast_convert_val<X, Y,
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
306 cast_or_null(Y *Val) {
337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
367 dyn_cast_or_null(Y *Val) {
include/llvm/Support/PointerLikeTypeTraits.h 91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
tools/clang/include/clang/AST/APValue.h 38 const Type *T;
42 explicit TypeInfoLValue(const Type *T);
44 const Type *getType() const { return T; }
tools/clang/include/clang/AST/ASTContext.h 179 mutable SmallVector<Type *, 0> Types;
253 using TypeInfoMap = llvm::DenseMap<const Type *, struct TypeInfo>;
259 using UnadjustedAlignMap = llvm::DenseMap<const Type *, unsigned>;
1103 const SmallVectorImpl<Type *>& getTypes() const { return Types; }
1128 QualType getExtQualType(const Type *Base, Qualifiers Quals) const;
1272 TargetInfo::OpenCLTypeKind getOpenCLTypeKind(const Type *T) const;
1275 LangAS getOpenCLTypeAddrSpace(const Type *T) const;
1308 QualType getMemberPointerType(QualType T, const Type *Cls) const;
1951 const Type *Ptr = Qc.strip(T);
1956 QualType getQualifiedType(const Type *T, Qualifiers Qs) const {
2043 TypeInfo getTypeInfoImpl(const Type *T) const;
2081 TypeInfo getTypeInfo(const Type *T) const;
2089 uint64_t getTypeSize(const Type *T) const { return getTypeInfo(T).Width; }
2105 CharUnits getTypeSizeInChars(const Type *T) const;
2113 Optional<CharUnits> getTypeSizeInCharsIfKnown(const Type *Ty) const {
2120 unsigned getTypeAlign(const Type *T) const { return getTypeInfo(T).Align; }
2130 unsigned getTypeUnadjustedAlign(const Type *T) const;
2140 CharUnits getTypeAlignInChars(const Type *T) const;
2146 CharUnits getTypeUnadjustedAlignInChars(const Type *T) const;
2152 std::pair<CharUnits, CharUnits> getTypeInfoInChars(const Type *T) const;
2157 bool isAlignmentRequired(const Type *T) const;
2165 unsigned getPreferredTypeAlign(const Type *T) const;
2293 const Type *getCanonicalType(const Type *T) const {
2293 const Type *getCanonicalType(const Type *T) const {
2308 bool hasSameType(const Type *T1, const Type *T2) const {
2308 bool hasSameType(const Type *T1, const Type *T2) const {
2563 unsigned getIntegerRank(const Type *T) const;
tools/clang/include/clang/AST/ASTImporter.h 248 llvm::DenseMap<const Type *, const Type *> ImportedTypes;
248 llvm::DenseMap<const Type *, const Type *> ImportedTypes;
tools/clang/include/clang/AST/ASTNodeTraverser.h 131 void Visit(const Type *T) {
216 else if (const auto *T = N.get<Type>())
216 else if (const auto *T = N.get<Type>())
tools/clang/include/clang/AST/ASTTypeTraits.h 65 return ASTNodeKind(KindToKindId<T>::Id);
72 static ASTNodeKind getFromNode(const Type &T);
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);
394 static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
395 if (ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind))
399 static const T &getUnchecked(ASTNodeKind NodeKind, const char Storage[]) {
401 return *cast<T>(static_cast<const BaseT *>(
404 static DynTypedNode create(const BaseT &Node) {
479 : public DynCastPtrConverter<T, Type> {};
479 : public DynCastPtrConverter<T, Type> {};
tools/clang/include/clang/AST/CanonicalType.h 76 CanQual(const CanQual<U> &Other,
77 typename std::enable_if<std::is_base_of<T, U>::value, int>::type = 0);
77 typename std::enable_if<std::is_base_of<T, U>::value, int>::type = 0);
83 const T *getTypePtr() const { return cast<T>(Stored.getTypePtr()); }
83 const T *getTypePtr() const { return cast<T>(Stored.getTypePtr()); }
87 const T *getTypePtrOrNull() const {
120 template<typename U> CanProxy<U> getAs() const;
126 CanProxy<T> operator->() const;
157 CanQual<T> getUnqualifiedType() const;
167 bool isMoreQualifiedThan(CanQual<T> Other) const {
173 bool isAtLeastAsQualifiedAs(CanQual<T> Other) const {
179 CanQual<Type> getNonReferenceType() const;
185 static CanQual<T> getFromOpaquePtr(void *Ptr);
192 static CanQual<T> CreateUnsafe(QualType Other);
202 inline bool operator==(CanQual<T> x, CanQual<U> y) {
202 inline bool operator==(CanQual<T> x, CanQual<U> y) {
207 inline bool operator!=(CanQual<T> x, CanQual<U> y) {
207 inline bool operator!=(CanQual<T> x, CanQual<U> y) {
212 using CanQualType = CanQual<Type>;
241 CanQual<T> Stored;
245 const T *getTypePtr() const { return Stored.getTypePtr(); }
254 operator const T*() const { return this->Stored.getTypePtrOrNull(); }
321 const CanProxyAdaptor<T> *operator->() const {
337 struct CanProxyAdaptor : CanProxyBase<T> {};
347 class CanProxy : public CanProxyAdaptor<T> {
353 CanProxy(CanQual<T> Stored) { this->Stored = Stored; }
356 operator CanQual<T>() const { return this->Stored; }
368 using SimpleType = const T *;
370 static SimpleType getSimplifiedValue(::clang::CanQual<T> Val) {
378 static void *getAsVoidPointer(clang::CanQual<T> P) {
382 static clang::CanQual<T> getFromVoidPointer(void *P) {
407 CanProxy<Type>, CanQualType> {
413 CanProxy<Type> operator->() const;
619 return CanQual<T>::CreateUnsafe(Stored.getLocalUnqualifiedType());
623 inline CanQual<Type> CanQual<T>::getNonReferenceType() const {
632 CanQual<T> Result;
644 CanQual<T> Result;
652 static_assert(!TypeIsArrayType<T>::value,
658 if (isa<U>(Stored.getTypePtr()))
659 return CanQual<U>::CreateUnsafe(Stored);
680 CanProxy<Type> CanTypeIterator<InputIterator>::operator->() const {
681 return CanProxy<Type>(*this);
tools/clang/include/clang/AST/Decl.h 2957 mutable const Type *TypeForDecl = nullptr;
2974 const Type *getTypeForDecl() const { return TypeForDecl; }
2975 void setTypeForDecl(const Type *TD) { TypeForDecl = TD; }
3420 llvm::PointerUnion<const Type *, TypeSourceInfo *> IntegerType;
3559 if (const Type *T = IntegerType.dyn_cast<const Type*>())
3559 if (const Type *T = IntegerType.dyn_cast<const Type*>())
tools/clang/include/clang/AST/DeclCXX.h 2256 const Type *getBaseClass() const;
tools/clang/include/clang/AST/DeclObjC.h 1177 mutable const Type *TypeForDecl = nullptr;
1918 const Type *getTypeForDecl() const { return TypeForDecl; }
1919 void setTypeForDecl(const Type *TD) const { TypeForDecl = TD; }
tools/clang/include/clang/AST/DeclarationName.h 43 using CanQualType = CanQual<Type>;
tools/clang/include/clang/AST/Expr.h 1006 static ResultStorageKind getStorageKind(const Type *T,
tools/clang/include/clang/AST/ExprObjC.h 645 llvm::PointerUnion3<Stmt *, const Type *, ObjCInterfaceDecl *> Receiver;
768 return QualType(Receiver.get<const Type*>(), 0);
776 bool isSuperReceiver() const { return Receiver.is<const Type*>(); }
tools/clang/include/clang/AST/JSONNodeDumper.h 190 void Visit(const Type *T);
tools/clang/include/clang/AST/LocInfoType.h 28 class LocInfoType : public Type {
32 LocInfo = Type::TypeLast + 1
53 static bool classof(const Type *T) {
tools/clang/include/clang/AST/NestedNameSpecifier.h 140 bool Template, const Type *T);
194 const Type *getAsType() const {
tools/clang/include/clang/AST/ODRHash.h 79 void AddType(const Type *T);
tools/clang/include/clang/AST/RecursiveASTVisitor.h 438 bool WalkUpFromType(Type *T) { return getDerived().VisitType(T); }
439 bool VisitType(Type *T) { return true; }
tools/clang/include/clang/AST/TextNodeDumper.h 165 void Visit(const Type *T);
tools/clang/include/clang/AST/Type.h 77 static inline void *getAsVoidPointer(::clang::Type *P) { return P; }
79 static inline ::clang::Type *getFromVoidPointer(void *P) {
125 using CanQualType = CanQual<Type>;
584 const Type *Ty = nullptr;
590 SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}
595 std::pair<const Type *,Qualifiers> asPair() const {
647 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
654 const Type *getTypePtrUnsafe() const {
655 return Value.getPointer().get<const Type*>();
667 QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
677 const Type *getTypePtr() const;
679 const Type *getTypePtrOrNull() const;
696 const Type &operator*() const {
700 const Type *operator->() const {
983 static std::string getAsString(const Type *ty, Qualifiers qs,
999 static void print(const Type *ty, Qualifiers qs,
1012 static void getAsStringInternal(const Type *ty, Qualifiers qs,
1266 using SimpleType = const ::clang::Type *;
1305 const Type *const BaseType;
1310 ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
1345 ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
1368 const Type *getBaseType() const { return BaseType; }
1376 const Type *BaseType,
1825 Type *this_() { return this; }
1846 Type(const Type &) = delete;
1847 Type(Type &&) = delete;
1848 Type &operator=(const Type &) = delete;
1848 Type &operator=(const Type &) = delete;
1849 Type &operator=(Type &&) = delete;
1849 Type &operator=(Type &&) = delete;
2269 const Type *getBaseElementTypeUnsafe() const;
2274 const Type *getArrayElementTypeNoTypeQual() const;
2279 const Type *getPointeeOrArrayElementType() const;
2287 const Type *getUnqualifiedDesugaredType() const;
2436 class BuiltinType : public Type {
2520 static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2525 class ComplexType : public Type, public llvm::FoldingSetNode {
2551 static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2555 class ParenType : public Type, public llvm::FoldingSetNode {
2581 static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2585 class PointerType : public Type, public llvm::FoldingSetNode {
2627 static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2633 class AdjustedType : public Type, public llvm::FoldingSetNode {
2664 static bool classof(const Type *T) {
2681 static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2687 class BlockPointerType : public Type, public llvm::FoldingSetNode {
2715 static bool classof(const Type *T) {
2721 class ReferenceType : public Type, public llvm::FoldingSetNode {
2761 static bool classof(const Type *T) {
2780 static bool classof(const Type *T) {
2796 static bool classof(const Type *T) {
2804 class MemberPointerType : public Type, public llvm::FoldingSetNode {
2811 const Type *Class;
2813 MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
2838 const Type *getClass() const { return Class; }
2849 const Type *Class) {
2854 static bool classof(const Type *T) {
2860 class ArrayType : public Type, public llvm::FoldingSetNode {
2895 static bool classof(const Type *T) {
2958 static bool classof(const Type *T) {
2979 static bool classof(const Type *T) {
3042 static bool classof(const Type *T) {
3099 static bool classof(const Type *T) {
3124 class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
3144 static bool classof(const Type *T) {
3166 class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
3188 static bool classof(const Type *T) {
3206 class VectorType : public Type, public llvm::FoldingSetNode {
3269 static bool classof(const Type *T) {
3283 class DependentVectorType : public Type, public llvm::FoldingSetNode {
3306 static bool classof(const Type *T) {
3386 static bool classof(const Type *T) {
3393 class FunctionType : public Type {
3680 static bool classof(const Type *T) {
3713 static bool classof(const Type *T) {
4144 static bool classof(const Type *T) {
4160 class UnresolvedUsingType : public Type {
4176 static bool classof(const Type *T) {
4190 class TypedefType : public Type {
4211 static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4216 class MacroQualifiedType : public Type {
4244 static bool classof(const Type *T) {
4250 class TypeOfExprType : public Type {
4267 static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4293 class TypeOfType : public Type {
4316 static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4320 class DecltypeType : public Type {
4339 static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4363 class UnaryTransformType : public Type {
4393 static bool classof(const Type *T) {
4421 class TagType : public Type {
4437 static bool classof(const Type *T) {
4465 static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4484 static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4499 class AttributedType : public Type, public llvm::FoldingSetNode {
4591 static bool classof(const Type *T) {
4596 class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4665 static bool classof(const Type *T) {
4677 class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4716 static bool classof(const Type *T) {
4733 class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
4769 static bool classof(const Type *T) {
4783 class DeducedType : public Type {
4816 static bool classof(const Type *T) {
4855 static bool classof(const Type *T) {
4892 static bool classof(const Type *T) {
4918 : public Type,
5018 static bool classof(const Type *T) {
5054 class InjectedClassNameType : public Type {
5101 static bool classof(const Type *T) {
5154 class TypeWithKeyword : public Type {
5194 static CannotCastToThisType classof(const Type *);
5273 static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; }
5332 static bool classof(const Type *T) {
5404 static bool classof(const Type *T) {
5431 class PackExpansionType : public Type, public llvm::FoldingSetNode {
5477 static bool classof(const Type *T) {
5540 class ObjCTypeParamType : public Type,
5574 static bool classof(const Type *T) {
5614 class ObjCObjectType : public Type,
5757 static bool classof(const Type *T) {
5832 static bool classof(const Type *T) {
5870 class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
6039 static bool classof(const Type *T) {
6044 class AtomicType : public Type, public llvm::FoldingSetNode {
6072 static bool classof(const Type *T) {
6078 class PipeType : public Type, public llvm::FoldingSetNode {
6107 static bool classof(const Type *T) {
6122 const Type *strip(QualType type) {
6136 QualType apply(const ASTContext &Context, const Type* T) const;
6148 inline const Type *QualType::getTypePtr() const {
6152 inline const Type *QualType::getTypePtrOrNull() const {
6200 const Type *T = getTypePtr();
6291 inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
6798 inline const Type *Type::getBaseElementTypeUnsafe() const {
6799 const Type *type = this;
6805 inline const Type *Type::getPointeeOrArrayElementType() const {
6806 const Type *type = this;
6858 template <typename T> const T *Type::getAs() const {
6859 static_assert(!TypeIsArrayType<T>::value,
6863 if (const auto *Ty = dyn_cast<T>(this))
6863 if (const auto *Ty = dyn_cast<T>(this))
6867 if (!isa<T>(CanonicalType))
6872 return cast<T>(getUnqualifiedDesugaredType());
6888 const Type *Ty = this;
tools/clang/include/clang/AST/TypeLoc.h 67 TypeLoc(const Type *ty, void *opaqueData)
134 const Type *getTypePtr() const {
250 UnqualTypeLoc(const Type *Ty, void *Data) : TypeLoc(Ty, Data) {}
252 const Type *getTypePtr() const {
369 static bool classofType(const Type *Ty) {
405 const TypeClass *getTypePtr() const {
406 return cast<TypeClass>(Base::getTypePtr());
485 static bool classofType(const Type *Ty) {
511 Type,
1279 const Type *getClass() const {
tools/clang/include/clang/AST/TypeVisitor.h 68 RetTy Visit(const Type *T) {
87 RetTy VisitType(const Type*) { return RetTy(); }
tools/clang/include/clang/ASTMatchers/ASTMatchFinder.h 266 const NodeT *
269 if (const NodeT *Node = N.getNodeAs<NodeT>(BoundTo))
269 if (const NodeT *Node = N.getNodeAs<NodeT>(BoundTo))
tools/clang/include/clang/ASTMatchers/ASTMatchers.h 110 const T *getNodeAs(StringRef ID) const {
111 return MyBoundNodes.getNodeAs<T>(ID);
2419 extern const internal::VariadicAllOfMatcher<Type> type;
5351 using AstTypeMatcher = internal::VariadicDynCastAllOfMatcher<Type, NodeType>;
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)
506 Matcher(const Matcher<From> &Other,
507 typename std::enable_if<std::is_base_of<From, T>::value &&
508 !std::is_same<From, T>::value>::type * = nullptr)
518 Matcher(const Matcher<TypeT> &Other,
520 std::is_same<T, QualType>::value &&
521 std::is_same<TypeT, Type>::value>::type* = nullptr)
521 std::is_same<TypeT, Type>::value>::type* = nullptr)
522 : Implementation(new TypeToQualType<TypeT>(Other)) {}
528 Matcher<To> dynCastTo() const {
529 static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
534 bool matches(const T &Node,
561 TypeToQualType(const Matcher<TypeT> &InnerMatcher)
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) {
609 ast_type_traits::ASTNodeKind::getFromNodeKind<Type>())) {
611 return unconditionalConvertTo<Type>();
776 bool matchesSpecialized(const Type &Node, ASTMatchFinder *Finder,
780 const Type *EffectiveType = &Node;
922 std::is_same<T, Decl>::value ||
923 std::is_same<T, Stmt>::value ||
924 std::is_same<T, QualType>::value ||
925 std::is_same<T, Type>::value ||
925 std::is_same<T, Type>::value ||
926 std::is_same<T, TypeLoc>::value ||
927 std::is_same<T, NestedNameSpecifier>::value ||
928 std::is_same<T, NestedNameSpecifierLoc>::value ||
929 std::is_same<T, CXXCtorInitializer>::value;
1067 using head = T1;
1073 using tail = TypeList<Ts...>;
1084 std::is_base_of<typename AnyTypeList::head, T>::value ||
1085 TypeListContainsSuperOf<typename AnyTypeList::tail, T>::value;
1097 Type, TypeLoc, CXXCtorInitializer>;
1141 explicit Adaptor(const Matcher<T> &InnerMatcher)
1146 template <typename To> operator Matcher<To>() const {
1151 const Matcher<T> InnerMatcher;
1155 static Adaptor<T> create(const Matcher<T> &InnerMatcher) {
1155 static Adaptor<T> create(const Matcher<T> &InnerMatcher) {
1160 Adaptor<T> operator()(const Matcher<T> &InnerMatcher) const {
1160 Adaptor<T> operator()(const Matcher<T> &InnerMatcher) const {
1202 operator Matcher<T>() const {
1203 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
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>();
1287 explicit HasMatcher(const Matcher<ChildT> &ChildMatcher)
1305 static_assert(IsBaseType<ChildT>::value,
1309 explicit ForEachMatcher(const Matcher<ChildT> &ChildMatcher)
1335 template <typename T> operator Matcher<T>() const {
1337 Op, ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1338 getMatchers<T>(std::index_sequence_for<Ps...>()))
1339 .template unconditionalConvertTo<T>();
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>());
1407 BindableMatcher<T> makeDynCastAllOfComposite(
1410 makeAllOfComposite(InnerMatchers).template dynCastTo<T>());
1419 static_assert(IsBaseType<DescendantT>::value,
1423 explicit HasDescendantMatcher(const Matcher<DescendantT> &DescendantMatcher)
1481 static_assert(IsBaseType<DescendantT>::value,
1486 const Matcher<DescendantT> &DescendantMatcher)
1557 : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>,
1558 makeDynCastAllOfComposite<SourceT, TargetT>> {
1575 : public VariadicFunction<BindableMatcher<T>, Matcher<T>,
1575 : public VariadicFunction<BindableMatcher<T>, Matcher<T>,
1576 makeAllOfComposite<T>> {
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 9180 llvm::DenseMap<const Type*, std::set<std::string>> OpenCLTypeExtMap;
11610 void DiscardMisalignedMemberAddress(const Type *T, Expr *E);
tools/clang/include/clang/Serialization/ASTReader.h 882 llvm::DenseMap<const Type *, std::set<std::string>> OpenCLTypeExtMap;
tools/clang/include/clang/Tooling/Refactoring/RecursiveSymbolVisitor.h 101 if (const Type *TP = Loc.getTypePtr()) {
102 if (TP->getTypeClass() == clang::Type::Record)
tools/clang/lib/AST/APValue.cpp 25 TypeInfoLValue::TypeInfoLValue(const Type *T)
37 alignof(Type),
tools/clang/lib/AST/ASTContext.cpp 986 Type *T = Types[i];
1736 ASTContext::getTypeInfoInChars(const Type *T) const {
1749 bool ASTContext::isAlignmentRequired(const Type *T) const {
1781 TypeInfo ASTContext::getTypeInfo(const Type *T) const {
1798 TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
1815 case Type::FunctionNoProto:
1816 case Type::FunctionProto:
1822 case Type::IncompleteArray:
1823 case Type::VariableArray:
1828 case Type::ConstantArray: {
1842 case Type::ExtVector:
1843 case Type::Vector: {
1861 case Type::Builtin:
2052 case Type::ObjCObjectPointer:
2056 case Type::BlockPointer:
2061 case Type::LValueReference:
2062 case Type::RValueReference:
2069 case Type::Pointer:
2074 case Type::MemberPointer: {
2081 case Type::Complex: {
2089 case Type::ObjCObject:
2091 case Type::Adjusted:
2092 case Type::Decayed:
2094 case Type::ObjCInterface: {
2101 case Type::Record:
2102 case Type::Enum: {
2131 case Type::SubstTemplateTypeParm:
2135 case Type::Auto:
2136 case Type::DeducedTemplateSpecialization: {
2143 case Type::Paren:
2146 case Type::MacroQualified:
2150 case Type::ObjCTypeParam:
2153 case Type::Typedef: {
2170 case Type::Elaborated:
2173 case Type::Attributed:
2177 case Type::Atomic: {
2203 case Type::Pipe:
2213 unsigned ASTContext::getTypeUnadjustedAlign(const Type *T) const {
2260 CharUnits ASTContext::getTypeSizeInChars(const Type *T) const {
2269 CharUnits ASTContext::getTypeAlignInChars(const Type *T) const {
2279 CharUnits ASTContext::getTypeUnadjustedAlignInChars(const Type *T) const {
2287 unsigned ASTContext::getPreferredTypeAlign(const Type *T) const {
2714 ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const {
2752 const Type *TypeNode = Quals.strip(T);
2767 const Type *TypeNode = Quals.strip(T);
2801 const Type *TypeNode = Quals.strip(T);
2985 AdjustedType(Type::Adjusted, Orig, New, Canonical);
3137 QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const {
3230 const Type *ty = split.Ty;
3239 case Type::Builtin:
3240 case Type::Complex:
3241 case Type::Vector:
3242 case Type::DependentVector:
3243 case Type::ExtVector:
3244 case Type::DependentSizedExtVector:
3245 case Type::DependentAddressSpace:
3246 case Type::ObjCObject:
3247 case Type::ObjCInterface:
3248 case Type::ObjCObjectPointer:
3249 case Type::Record:
3250 case Type::Enum:
3251 case Type::UnresolvedUsing:
3252 case Type::TypeOfExpr:
3253 case Type::TypeOf:
3254 case Type::Decltype:
3255 case Type::UnaryTransform:
3256 case Type::DependentName:
3257 case Type::InjectedClassName:
3258 case Type::TemplateSpecialization:
3259 case Type::DependentTemplateSpecialization:
3260 case Type::TemplateTypeParm:
3261 case Type::SubstTemplateTypeParmPack:
3262 case Type::Auto:
3263 case Type::DeducedTemplateSpecialization:
3264 case Type::PackExpansion:
3269 case Type::FunctionNoProto:
3270 case Type::FunctionProto:
3271 case Type::BlockPointer:
3272 case Type::MemberPointer:
3273 case Type::Pipe:
3280 case Type::Pointer:
3285 case Type::LValueReference: {
3293 case Type::RValueReference: {
3300 case Type::Atomic: {
3306 case Type::ConstantArray: {
3317 case Type::DependentSizedArray: {
3329 case Type::IncompleteArray: {
3341 case Type::VariableArray: {
3499 VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind);
3569 VectorType::Profile(ID, vecType, NumElts, Type::ExtVector,
3961 Type *newType =
3989 Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using);
4008 TypedefType(Type::Typedef, Decl, Canonical);
5156 const Type *Ty = T.getTypePtr();
5755 unsigned ASTContext::getIntegerRank(const Type *T) const {
5906 static const Type *getIntegerTypeForEnum(const EnumType *ET) {
5918 const Type *LHSC = getCanonicalType(LHS).getTypePtr();
5919 const Type *RHSC = getCanonicalType(RHS).getTypePtr();
6148 TargetInfo::OpenCLTypeKind ASTContext::getOpenCLTypeKind(const Type *T) const {
6184 LangAS ASTContext::getOpenCLTypeAddrSpace(const Type *T) const {
6806 case Type::Builtin:
6807 case Type::Enum:
6816 case Type::Complex: {
6824 case Type::Atomic: {
6833 case Type::Pointer:
6834 case Type::LValueReference:
6835 case Type::RValueReference: {
6906 case Type::ConstantArray:
6907 case Type::IncompleteArray:
6908 case Type::VariableArray: {
6939 case Type::FunctionNoProto:
6940 case Type::FunctionProto:
6944 case Type::Record: {
6991 case Type::BlockPointer: {
7014 case Type::ObjCObject: {
7029 case Type::ObjCInterface: {
7055 case Type::ObjCObjectPointer: {
7108 case Type::MemberPointer:
7111 case Type::Vector:
7112 case Type::ExtVector:
7120 case Type::Auto:
7121 case Type::DeducedTemplateSpecialization:
7124 case Type::Pipe:
8902 Type::TypeClass LHSClass = LHSCan->getTypeClass();
8903 Type::TypeClass RHSClass = RHSCan->getTypeClass();
8907 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
8907 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
8908 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
8908 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
8911 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
8911 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
8912 LHSClass = Type::ConstantArray;
8913 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
8913 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
8914 RHSClass = Type::ConstantArray;
8917 if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
8917 if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
8918 if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
8918 if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
8921 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
8921 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
8922 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
8922 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
8955 case Type::Auto:
8956 case Type::DeducedTemplateSpecialization:
8957 case Type::LValueReference:
8958 case Type::RValueReference:
8959 case Type::MemberPointer:
8962 case Type::ObjCInterface:
8963 case Type::IncompleteArray:
8964 case Type::VariableArray:
8965 case Type::FunctionProto:
8966 case Type::ExtVector:
8969 case Type::Pointer:
8988 case Type::BlockPointer:
9021 case Type::Atomic:
9040 case Type::ConstantArray:
9122 case Type::FunctionNoProto:
9124 case Type::Record:
9125 case Type::Enum:
9127 case Type::Builtin:
9130 case Type::Complex:
9133 case Type::Vector:
9139 case Type::ObjCObject: {
9148 case Type::ObjCObjectPointer:
9160 case Type::Pipe:
tools/clang/lib/AST/ASTDiagnostic.cpp 32 const Type *Ty = QC.strip(QT);
tools/clang/lib/AST/ASTImporter.cpp 308 ExpectedType VisitType(const Type *T);
964 ExpectedType ASTNodeImporter::VisitType(const Type *T) {
1557 const Type *LeafT =
7871 const Type *FromTy = FromT.getTypePtr();
7874 llvm::DenseMap<const Type *, const Type *>::iterator Pos
7874 llvm::DenseMap<const Type *, const Type *>::iterator Pos
8794 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
8794 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
tools/clang/lib/AST/ASTStructuralEquivalence.cpp 453 Type::TypeClass TC = T1->getTypeClass();
458 if (T1->getTypeClass() == Type::FunctionProto &&
459 T2->getTypeClass() == Type::FunctionNoProto)
460 TC = Type::FunctionNoProto;
461 else if (T1->getTypeClass() == Type::FunctionNoProto &&
462 T2->getTypeClass() == Type::FunctionProto)
463 TC = Type::FunctionNoProto;
469 case Type::Builtin:
475 case Type::Complex:
482 case Type::Adjusted:
483 case Type::Decayed:
490 case Type::Pointer:
497 case Type::BlockPointer:
504 case Type::LValueReference:
505 case Type::RValueReference: {
518 case Type::MemberPointer: {
530 case Type::ConstantArray: {
541 case Type::IncompleteArray:
547 case Type::VariableArray: {
560 case Type::DependentSizedArray: {
573 case Type::DependentAddressSpace: {
586 case Type::DependentSizedExtVector: {
598 case Type::DependentVector: {
612 case Type::Vector:
613 case Type::ExtVector: {
626 case Type::FunctionProto: {
655 case Type::FunctionNoProto: {
667 case Type::UnresolvedUsing:
674 case Type::Attributed:
685 case Type::Paren:
691 case Type::MacroQualified:
698 case Type::Typedef:
704 case Type::TypeOfExpr:
711 case Type::TypeOf:
718 case Type::UnaryTransform:
725 case Type::Decltype:
732 case Type::Auto:
738 case Type::DeducedTemplateSpecialization: {
750 case Type::Record:
751 case Type::Enum:
757 case Type::TemplateTypeParm: {
771 case Type::SubstTemplateTypeParm: {
784 case Type::SubstTemplateTypeParmPack: {
797 case Type::TemplateSpecialization: {
813 case Type::Elaborated: {
828 case Type::InjectedClassName: {
838 case Type::DependentName: {
851 case Type::DependentTemplateSpecialization: {
870 case Type::PackExpansion:
877 case Type::ObjCInterface: {
886 case Type::ObjCTypeParam: {
902 case Type::ObjCObject: {
918 case Type::ObjCObjectPointer: {
927 case Type::Atomic:
933 case Type::Pipe:
tools/clang/lib/AST/ASTTypeTraits.cpp 102 ASTNodeKind ASTNodeKind::getFromNode(const Type &T) {
148 else if (const Type *T = get<Type>())
148 else if (const Type *T = get<Type>())
159 else if (const Type *T = get<Type>())
159 else if (const Type *T = get<Type>())
tools/clang/lib/AST/Decl.cpp 238 LinkageInfo LinkageComputer::getLVForType(const Type &T,
1872 const Type* T = QT.getTypePtr();
1876 case Type::Pointer:
1879 case Type::BlockPointer:
1882 case Type::MemberPointer:
1885 case Type::LValueReference:
1886 case Type::RValueReference:
1889 case Type::PackExpansion:
1892 case Type::Paren:
1893 case Type::ConstantArray:
1894 case Type::DependentSizedArray:
1895 case Type::IncompleteArray:
1896 case Type::VariableArray:
1897 case Type::FunctionProto:
1898 case Type::FunctionNoProto:
4068 if (const Type *T = getTypeForDecl()) {
tools/clang/lib/AST/DeclCXX.cpp 2400 const Type *CXXCtorInitializer::getBaseClass() const {
tools/clang/lib/AST/Expr.cpp 260 ConstantExpr::getStorageKind(const Type *T, const ASTContext &Context) {
tools/clang/lib/AST/ExprCXX.cpp 1577 const Type *T = getQualifier()->getAsType();
tools/clang/lib/AST/ExprConstant.cpp 6475 Optional<APValue> visit(const Type *Ty, CharUnits Offset) {
8720 const Type *FinalTy = E->getType()->castAs<MemberPointerType>()->getClass();
9966 case Type::Auto:
9967 case Type::DeducedTemplateSpecialization:
9970 case Type::Builtin:
10039 case Type::Enum:
10042 case Type::Pointer:
10043 case Type::ConstantArray:
10044 case Type::VariableArray:
10045 case Type::IncompleteArray:
10046 case Type::FunctionNoProto:
10047 case Type::FunctionProto:
10050 case Type::MemberPointer:
10055 case Type::Complex:
10058 case Type::Record:
10062 case Type::Atomic:
10067 case Type::BlockPointer:
10068 case Type::Vector:
10069 case Type::ExtVector:
10070 case Type::ObjCObject:
10071 case Type::ObjCInterface:
10072 case Type::ObjCObjectPointer:
10073 case Type::Pipe:
10078 case Type::LValueReference:
10079 case Type::RValueReference:
tools/clang/lib/AST/Interp/Program.cpp 296 Descriptor *Program::createDescriptor(const DeclTy &D, const Type *Ty,
353 const Type *InnerTy = AT->getValueType().getTypePtr();
tools/clang/lib/AST/Interp/Program.h 109 Descriptor *createDescriptor(const DeclTy &D, const Type *Ty,
tools/clang/lib/AST/ItaniumMangle.cpp 1170 const Type *type = qualifier->getAsType();
1972 case Type::Builtin:
1973 case Type::Complex:
1974 case Type::Adjusted:
1975 case Type::Decayed:
1976 case Type::Pointer:
1977 case Type::BlockPointer:
1978 case Type::LValueReference:
1979 case Type::RValueReference:
1980 case Type::MemberPointer:
1981 case Type::ConstantArray:
1982 case Type::IncompleteArray:
1983 case Type::VariableArray:
1984 case Type::DependentSizedArray:
1985 case Type::DependentAddressSpace:
1986 case Type::DependentVector:
1987 case Type::DependentSizedExtVector:
1988 case Type::Vector:
1989 case Type::ExtVector:
1990 case Type::FunctionProto:
1991 case Type::FunctionNoProto:
1992 case Type::Paren:
1993 case Type::Attributed:
1994 case Type::Auto:
1995 case Type::DeducedTemplateSpecialization:
1996 case Type::PackExpansion:
1997 case Type::ObjCObject:
1998 case Type::ObjCInterface:
1999 case Type::ObjCObjectPointer:
2000 case Type::ObjCTypeParam:
2001 case Type::Atomic:
2002 case Type::Pipe:
2003 case Type::MacroQualified:
2006 case Type::SubstTemplateTypeParmPack:
2018 case Type::TypeOfExpr:
2019 case Type::TypeOf:
2020 case Type::Decltype:
2021 case Type::TemplateTypeParm:
2022 case Type::UnaryTransform:
2023 case Type::SubstTemplateTypeParm:
2036 case Type::Typedef:
2040 case Type::UnresolvedUsing:
2045 case Type::Enum:
2046 case Type::Record:
2050 case Type::TemplateSpecialization: {
2095 case Type::InjectedClassName:
2100 case Type::DependentName:
2104 case Type::DependentTemplateSpecialization: {
2112 case Type::Elaborated:
2388 static bool isTypeSubstitutable(Qualifiers Quals, const Type *Ty,
2461 const Type *ty = split.Ty;
tools/clang/lib/AST/JSONNodeDumper.cpp 67 void JSONNodeDumper::Visit(const Type *T) {
tools/clang/lib/AST/Linkage.h 137 LinkageInfo getLVForType(const Type &T, LVComputationKind computation);
149 LinkageInfo computeTypeLinkageInfo(const Type *T);
156 LinkageInfo getTypeLinkageAndVisibility(const Type *T);
tools/clang/lib/AST/MicrosoftCXXABI.cpp 30 llvm::DenseMap<const Type *, unsigned> ManglingNumbers;
45 const Type *Ty = nullptr;
tools/clang/lib/AST/MicrosoftMangle.cpp 1932 const Type *ty = T.getTypePtr();
2672 const Type *ty = T.getTypePtr();
2677 case Type::Vector: {
tools/clang/lib/AST/NestedNameSpecifier.cpp 105 bool Template, const Type *T) {
316 const Type *T = getAsType();
tools/clang/lib/AST/ODRHash.cpp 679 void AddType(const Type *T) {
706 static const Type *RemoveTypedef(const Type *T) {
706 static const Type *RemoveTypedef(const Type *T) {
748 void Visit(const Type *T) {
754 void VisitType(const Type *T) {}
1107 void ODRHash::AddType(const Type *T) {
tools/clang/lib/AST/QualTypeNames.cpp 116 static const Type *getFullyQualifiedTemplateType(const ASTContext &Ctx,
117 const Type *TypePtr,
239 const Type *Type = Scope->getAsType();
317 const ASTContext &Ctx, const Type *TypePtr,
452 const Type *TypePtr = getFullyQualifiedTemplateType(
tools/clang/lib/AST/StmtIterator.cpp 25 static inline const VariableArrayType *FindVA(const Type* t) {
tools/clang/lib/AST/TemplateBase.cpp 54 const Type *T = TemplArg.getIntegralType().getTypePtr();
tools/clang/lib/AST/TextNodeDumper.cpp 168 void TextNodeDumper::Visit(const Type *T) {
tools/clang/lib/AST/Type.cpp 73 const Type* ty = getTypePtr();
81 else if (ty->getTypeClass() == Type::Typedef)
301 const Type *Type::getArrayElementTypeNoTypeQual() const {
373 const Type *CurTy = Qs.strip(Cur);
396 const Type *lastTypeWithQuals = split.Ty;
438 template<typename T> static const T *getAsSugar(const Type *Cur) {
471 const Type *Type::getUnqualifiedDesugaredType() const {
472 const Type *Cur = this;
1706 const Type *Cur = this;
1718 public TypeVisitor<GetContainedDeducedTypeVisitor, Type*> {
1727 Type *Visit(QualType T) {
1734 Type *VisitDeducedType(const DeducedType *AT) {
1740 Type *VisitElaboratedType(const ElaboratedType *T) {
1744 Type *VisitPointerType(const PointerType *T) {
1748 Type *VisitBlockPointerType(const BlockPointerType *T) {
1752 Type *VisitReferenceType(const ReferenceType *T) {
1756 Type *VisitMemberPointerType(const MemberPointerType *T) {
1760 Type *VisitArrayType(const ArrayType *T) {
1764 Type *VisitDependentSizedExtVectorType(
1769 Type *VisitVectorType(const VectorType *T) {
1773 Type *VisitFunctionProtoType(const FunctionProtoType *T) {
1779 Type *VisitFunctionType(const FunctionType *T) {
1783 Type *VisitParenType(const ParenType *T) {
1787 Type *VisitAttributedType(const AttributedType *T) {
1791 Type *VisitMacroQualifiedType(const MacroQualifiedType *T) {
1795 Type *VisitAdjustedType(const AdjustedType *T) {
1799 Type *VisitPackExpansionType(const PackExpansionType *T) {
2050 Type::ScalarTypeKind Type::getScalarTypeKind() const {
2053 const Type *T = CanonicalType.getTypePtr();
2153 const Type *ClassTy = MPTy->getClass();
2212 case Type::VariableArray:
2213 case Type::ConstantArray:
2217 case Type::ObjCObjectPointer:
2218 case Type::BlockPointer:
2219 case Type::Builtin:
2220 case Type::Complex:
2221 case Type::Pointer:
2222 case Type::MemberPointer:
2223 case Type::Vector:
2224 case Type::ExtVector:
2227 case Type::Enum:
2230 case Type::Record:
2398 const Type *BaseTy = getBaseElementTypeUnsafe();
2455 const Type *BaseTy = getBaseElementTypeUnsafe();
2484 const Type *ty = getTypePtr();
2494 const Type *BaseTy = ty->getBaseElementTypeUnsafe();
3501 QualifierCollector::apply(const ASTContext &Context, const Type *T) const {
3565 static CachedProperties computeCachedProperties(const Type *T);
3578 static CachedProperties get(const Type *T) {
3584 static void ensure(const Type *T) {
3591 const Type *CT = T->getCanonicalTypeInternal().getTypePtr();
3620 static CachedProperties computeCachedProperties(const Type *T) {
3636 case Type::Auto:
3637 case Type::DeducedTemplateSpecialization:
3642 case Type::Builtin:
3648 case Type::Record:
3649 case Type::Enum: {
3666 case Type::Complex:
3668 case Type::Pointer:
3670 case Type::BlockPointer:
3672 case Type::LValueReference:
3673 case Type::RValueReference:
3675 case Type::MemberPointer: {
3680 case Type::ConstantArray:
3681 case Type::IncompleteArray:
3682 case Type::VariableArray:
3684 case Type::Vector:
3685 case Type::ExtVector:
3687 case Type::FunctionNoProto:
3689 case Type::FunctionProto: {
3696 case Type::ObjCInterface: {
3700 case Type::ObjCObject:
3702 case Type::ObjCObjectPointer:
3704 case Type::Atomic:
3706 case Type::Pipe:
3724 LinkageInfo LinkageComputer::computeTypeLinkageInfo(const Type *T) {
3739 case Type::Builtin:
3742 case Type::Auto:
3743 case Type::DeducedTemplateSpecialization:
3746 case Type::Record:
3747 case Type::Enum:
3750 case Type::Complex:
3752 case Type::Pointer:
3754 case Type::BlockPointer:
3756 case Type::LValueReference:
3757 case Type::RValueReference:
3759 case Type::MemberPointer: {
3765 case Type::ConstantArray:
3766 case Type::IncompleteArray:
3767 case Type::VariableArray:
3769 case Type::Vector:
3770 case Type::ExtVector:
3772 case Type::FunctionNoProto:
3774 case Type::FunctionProto: {
3781 case Type::ObjCInterface:
3783 case Type::ObjCObject:
3785 case Type::ObjCObjectPointer:
3788 case Type::Atomic:
3790 case Type::Pipe:
3807 LinkageInfo LinkageComputer::getTypeLinkageAndVisibility(const Type *T) {
3846 case Type::Pointer:
3847 case Type::BlockPointer:
3848 case Type::MemberPointer:
3849 case Type::ObjCObjectPointer:
3853 case Type::UnresolvedUsing:
3854 case Type::TypeOfExpr:
3855 case Type::TypeOf:
3856 case Type::Decltype:
3857 case Type::UnaryTransform:
3858 case Type::TemplateTypeParm:
3859 case Type::SubstTemplateTypeParmPack:
3860 case Type::DependentName:
3861 case Type::DependentTemplateSpecialization:
3862 case Type::Auto:
3868 case Type::TemplateSpecialization:
3877 case Type::Builtin:
3922 case Type::Complex:
3923 case Type::LValueReference:
3924 case Type::RValueReference:
3925 case Type::ConstantArray:
3926 case Type::IncompleteArray:
3927 case Type::VariableArray:
3928 case Type::DependentSizedArray:
3929 case Type::DependentVector:
3930 case Type::DependentSizedExtVector:
3931 case Type::Vector:
3932 case Type::ExtVector:
3933 case Type::DependentAddressSpace:
3934 case Type::FunctionProto:
3935 case Type::FunctionNoProto:
3936 case Type::Record:
3937 case Type::DeducedTemplateSpecialization:
3938 case Type::Enum:
3939 case Type::InjectedClassName:
3940 case Type::PackExpansion:
3941 case Type::ObjCObject:
3942 case Type::ObjCInterface:
3943 case Type::Atomic:
3944 case Type::Pipe:
4019 const Type *canon = getCanonicalTypeInternal().getTypePtr();
4035 const Type *cur = this;
4074 const Type *type = this;
tools/clang/lib/AST/TypePrinter.cpp 111 void print(const Type *ty, Qualifiers qs, raw_ostream &OS,
115 static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier);
131 void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS);
132 void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS);
176 void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS,
190 bool TypePrinter::canPrefixQualifiers(const Type *T,
199 Type::TypeClass TC = T->getTypeClass();
206 case Type::Auto:
207 case Type::Builtin:
208 case Type::Complex:
209 case Type::UnresolvedUsing:
210 case Type::Typedef:
211 case Type::TypeOfExpr:
212 case Type::TypeOf:
213 case Type::Decltype:
214 case Type::UnaryTransform:
215 case Type::Record:
216 case Type::Enum:
217 case Type::Elaborated:
218 case Type::TemplateTypeParm:
219 case Type::SubstTemplateTypeParmPack:
220 case Type::DeducedTemplateSpecialization:
221 case Type::TemplateSpecialization:
222 case Type::InjectedClassName:
223 case Type::DependentName:
224 case Type::DependentTemplateSpecialization:
225 case Type::ObjCObject:
226 case Type::ObjCTypeParam:
227 case Type::ObjCInterface:
228 case Type::Atomic:
229 case Type::Pipe:
233 case Type::ObjCObjectPointer:
238 case Type::ConstantArray:
239 case Type::IncompleteArray:
240 case Type::VariableArray:
241 case Type::DependentSizedArray:
245 case Type::Adjusted:
246 case Type::Decayed:
247 case Type::Pointer:
248 case Type::BlockPointer:
249 case Type::LValueReference:
250 case Type::RValueReference:
251 case Type::MemberPointer:
252 case Type::DependentAddressSpace:
253 case Type::DependentVector:
254 case Type::DependentSizedExtVector:
255 case Type::Vector:
256 case Type::ExtVector:
257 case Type::FunctionProto:
258 case Type::FunctionNoProto:
259 case Type::Paren:
260 case Type::PackExpansion:
261 case Type::SubstTemplateTypeParm:
262 case Type::MacroQualified:
266 case Type::Attributed: {
291 void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) {
344 void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) {
1873 std::string QualType::getAsString(const Type *ty, Qualifiers qs,
1886 void QualType::print(const Type *ty, Qualifiers qs,
1901 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
tools/clang/lib/ASTMatchers/ASTMatchFinder.cpp 254 bool match(const T &Node) {
370 const Type *TypeNode = DeclNode->getUnderlyingType().getTypePtr();
371 const Type *CanonicalType = // root of the typedef tree
490 } else if (auto *N = Node.get<Type>()) {
505 template <typename T> void match(const T &Node) {
608 void matchDispatch(const Type *Node) {
759 bool typeHasMatchingAlias(const Type *TypeNode,
762 const Type *const CanonicalType =
816 llvm::DenseMap<const Type*, std::set<const TypedefNameDecl*> > TypeAliases;
829 getAsCXXRecordDeclOrPrimaryTemplate(const Type *TypeNode) {
859 const Type *TypeNode = It.getType().getTypePtr();
900 const Type *TypeNode = ClassDecl->getTypeForDecl();
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp 250 auto TypeKind = ast_type_traits::ASTNodeKind::getFromNodeKind<Type>();
591 const internal::VariadicAllOfMatcher<Type> type;
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>());
466 ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
778 ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT>
tools/clang/lib/ASTMatchers/Dynamic/Registry.cpp 561 ASTNodeKind::getFromNodeKind<Type>(),
tools/clang/lib/Analysis/CFG.cpp 1329 static const VariableArrayType *FindVA(const Type *t) {
5541 const Type *T = FD->getType()->getBaseElementTypeUnsafe();
tools/clang/lib/Analysis/LiveVariables.cpp 224 const Type *ty = Ty.getTypePtr();
tools/clang/lib/CodeGen/ABIInfo.h 99 virtual bool isHomogeneousAggregateSmallEnough(const Type *Base,
102 bool isHomogeneousAggregate(QualType Ty, const Type *&Base,
tools/clang/lib/CodeGen/Address.h 108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGCXX.cpp 281 const Type *QTy = Qual->getAsType();
tools/clang/lib/CodeGen/CGCall.cpp 282 CanQualType FT = GetFormalType(MD).getAs<Type>();
tools/clang/lib/CodeGen/CGClass.cpp 541 const Type *BaseType = BaseInit->getBaseClass();
1249 const Type *BaseType = BaseInit->getBaseClass();
tools/clang/lib/CodeGen/CGDebugInfo.cpp 52 static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx) {
833 const Type *T = Qc.strip(Ty);
1001 const Type *Ty,
2860 case Type::TemplateSpecialization: {
2867 case Type::TypeOfExpr:
2870 case Type::TypeOf:
2873 case Type::Decltype:
2876 case Type::UnaryTransform:
2879 case Type::Attributed:
2882 case Type::Elaborated:
2885 case Type::Paren:
2888 case Type::MacroQualified:
2891 case Type::SubstTemplateTypeParm:
2894 case Type::Auto:
2895 case Type::DeducedTemplateSpecialization: {
2901 case Type::Adjusted:
2902 case Type::Decayed:
3013 case Type::ExtVector:
3014 case Type::Vector:
3016 case Type::ObjCObjectPointer:
3018 case Type::ObjCObject:
3020 case Type::ObjCTypeParam:
3022 case Type::ObjCInterface:
3024 case Type::Builtin:
3026 case Type::Complex:
3028 case Type::Pointer:
3030 case Type::BlockPointer:
3032 case Type::Typedef:
3034 case Type::Record:
3036 case Type::Enum:
3038 case Type::FunctionProto:
3039 case Type::FunctionNoProto:
3041 case Type::ConstantArray:
3042 case Type::VariableArray:
3043 case Type::IncompleteArray:
3046 case Type::LValueReference:
3048 case Type::RValueReference:
3051 case Type::MemberPointer:
3054 case Type::Atomic:
3057 case Type::Pipe:
3060 case Type::TemplateSpecialization:
3063 case Type::Auto:
3064 case Type::Attributed:
3065 case Type::Adjusted:
3066 case Type::Decayed:
3067 case Type::DeducedTemplateSpecialization:
3068 case Type::Elaborated:
3069 case Type::Paren:
3070 case Type::MacroQualified:
3071 case Type::SubstTemplateTypeParm:
3072 case Type::TypeOfExpr:
3073 case Type::TypeOf:
3074 case Type::Decltype:
3075 case Type::UnaryTransform:
3076 case Type::PackExpansion:
tools/clang/lib/CodeGen/CGDebugInfo.h 216 llvm::DIType *CreatePointerLikeType(llvm::dwarf::Tag Tag, const Type *Ty,
tools/clang/lib/CodeGen/CGOpenCLRuntime.cpp 33 llvm::Type *CGOpenCLRuntime::convertOpenCLSpecificType(const Type *T) {
89 llvm::PointerType *CGOpenCLRuntime::getSamplerType(const Type *T) {
tools/clang/lib/CodeGen/CGOpenCLRuntime.h 65 virtual llvm::Type *convertOpenCLSpecificType(const Type *T);
69 llvm::PointerType *getSamplerType(const Type *T);
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 4448 const Type *NonQualTy = QC.strip(ArgType);
4487 const Type *NonQualTy = QC.strip(NativeParamType);
tools/clang/lib/CodeGen/CodeGenFunction.cpp 200 case Type::Auto:
201 case Type::DeducedTemplateSpecialization:
205 case Type::Builtin:
206 case Type::Pointer:
207 case Type::BlockPointer:
208 case Type::LValueReference:
209 case Type::RValueReference:
210 case Type::MemberPointer:
211 case Type::Vector:
212 case Type::ExtVector:
213 case Type::FunctionProto:
214 case Type::FunctionNoProto:
215 case Type::Enum:
216 case Type::ObjCObjectPointer:
217 case Type::Pipe:
221 case Type::Complex:
225 case Type::ConstantArray:
226 case Type::IncompleteArray:
227 case Type::VariableArray:
228 case Type::Record:
229 case Type::ObjCObject:
230 case Type::ObjCInterface:
234 case Type::Atomic:
1866 const Type *ty = type.getTypePtr();
1878 case Type::Builtin:
1879 case Type::Complex:
1880 case Type::Vector:
1881 case Type::ExtVector:
1882 case Type::Record:
1883 case Type::Enum:
1884 case Type::Elaborated:
1885 case Type::TemplateSpecialization:
1886 case Type::ObjCTypeParam:
1887 case Type::ObjCObject:
1888 case Type::ObjCInterface:
1889 case Type::ObjCObjectPointer:
1892 case Type::Adjusted:
1896 case Type::Decayed:
1900 case Type::Pointer:
1904 case Type::BlockPointer:
1908 case Type::LValueReference:
1909 case Type::RValueReference:
1913 case Type::MemberPointer:
1917 case Type::ConstantArray:
1918 case Type::IncompleteArray:
1923 case Type::VariableArray: {
1961 case Type::FunctionProto:
1962 case Type::FunctionNoProto:
1966 case Type::Paren:
1967 case Type::TypeOf:
1968 case Type::UnaryTransform:
1969 case Type::Attributed:
1970 case Type::SubstTemplateTypeParm:
1971 case Type::PackExpansion:
1972 case Type::MacroQualified:
1977 case Type::Typedef:
1978 case Type::Decltype:
1979 case Type::Auto:
1980 case Type::DeducedTemplateSpecialization:
1984 case Type::TypeOfExpr:
1989 case Type::Atomic:
1993 case Type::Pipe:
tools/clang/lib/CodeGen/CodeGenTBAA.cpp 114 llvm::MDNode *CodeGenTBAA::getTypeInfoHelper(const Type *Ty) {
206 const Type *Ty = Context.getCanonicalType(QTy).getTypePtr();
283 const Type *Ty = Context.getCanonicalType(QTy).getTypePtr();
296 llvm::MDNode *CodeGenTBAA::getBaseTypeInfoHelper(const Type *Ty) {
347 const Type *Ty = Context.getCanonicalType(QTy).getTypePtr();
tools/clang/lib/CodeGen/CodeGenTBAA.h 129 llvm::DenseMap<const Type *, llvm::MDNode *> MetadataCache;
131 llvm::DenseMap<const Type *, llvm::MDNode *> BaseTypeMetadataCache;
137 llvm::DenseMap<const Type *, llvm::MDNode *> StructMetadataCache;
164 llvm::MDNode *getTypeInfoHelper(const Type *Ty);
168 llvm::MDNode *getBaseTypeInfoHelper(const Type *Ty);
tools/clang/lib/CodeGen/CodeGenTypes.cpp 101 bool CodeGenTypes::isRecordLayoutComplete(const Type *Ty) const {
102 llvm::DenseMap<const Type*, llvm::StructType *>::const_iterator I =
123 const Type *Key = CGT.getContext().getTagDeclType(RD).getTypePtr();
282 const Type *Ty = T.getTypePtr();
313 const Type *Ty = QFT.getTypePtr();
384 const Type *Ty = T.getTypePtr();
391 llvm::DenseMap<const Type *, llvm::Type *>::iterator TCI = TypeCache.find(Ty);
399 case Type::Record: // Handled above.
408 case Type::Builtin: {
540 case Type::Auto:
541 case Type::DeducedTemplateSpecialization:
543 case Type::Complex: {
548 case Type::LValueReference:
549 case Type::RValueReference: {
557 case Type::Pointer: {
568 case Type::VariableArray: {
577 case Type::IncompleteArray: {
591 case Type::ConstantArray: {
605 case Type::ExtVector:
606 case Type::Vector: {
612 case Type::FunctionNoProto:
613 case Type::FunctionProto:
616 case Type::ObjCObject:
620 case Type::ObjCInterface: {
631 case Type::ObjCObjectPointer: {
641 case Type::Enum: {
652 case Type::BlockPointer: {
662 case Type::MemberPointer: {
673 case Type::Atomic: {
691 case Type::Pipe: {
715 const Type *Key = Context.getTagDeclType(RD).getTypePtr();
777 const Type *Key = Context.getTagDeclType(RD).getTypePtr();
tools/clang/lib/CodeGen/CodeGenTypes.h 47 typedef CanQual<Type> CanQualType;
78 llvm::DenseMap<const Type*, CGRecordLayout *> CGRecordLayouts;
81 llvm::DenseMap<const Type*, llvm::StructType *> RecordDeclTypes;
90 llvm::SmallPtrSet<const Type*, 4> RecordsBeingLaidOut;
102 llvm::DenseMap<const Type *, llvm::Type *> TypeCache;
104 llvm::SmallSet<const Type *, 8> RecordsWithOpaqueMemberPointers;
305 bool isRecordLayoutComplete(const Type *Ty) const;
309 bool isRecordBeingLaidOut(const Type *Ty) const {
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 2773 void BuildVTablePointer(const Type *Ty);
3147 void ItaniumRTTIBuilder::BuildVTablePointer(const Type *Ty) {
3169 case Type::LValueReference:
3170 case Type::RValueReference:
3173 case Type::Auto:
3174 case Type::DeducedTemplateSpecialization:
3177 case Type::Pipe:
3180 case Type::Builtin:
3182 case Type::Vector:
3183 case Type::ExtVector:
3184 case Type::Complex:
3185 case Type::Atomic:
3187 case Type::BlockPointer:
3192 case Type::ConstantArray:
3193 case Type::IncompleteArray:
3194 case Type::VariableArray:
3199 case Type::FunctionNoProto:
3200 case Type::FunctionProto:
3205 case Type::Enum:
3210 case Type::Record: {
3225 case Type::ObjCObject:
3238 case Type::ObjCInterface:
3246 case Type::ObjCObjectPointer:
3247 case Type::Pointer:
3252 case Type::MemberPointer:
3382 BuildVTablePointer(cast<Type>(Ty));
3416 case Type::Builtin:
3417 case Type::Vector:
3418 case Type::ExtVector:
3419 case Type::Complex:
3420 case Type::BlockPointer:
3425 case Type::LValueReference:
3426 case Type::RValueReference:
3429 case Type::Auto:
3430 case Type::DeducedTemplateSpecialization:
3433 case Type::Pipe:
3436 case Type::ConstantArray:
3437 case Type::IncompleteArray:
3438 case Type::VariableArray:
3443 case Type::FunctionNoProto:
3444 case Type::FunctionProto:
3449 case Type::Enum:
3454 case Type::Record: {
3470 case Type::ObjCObject:
3471 case Type::ObjCInterface:
3475 case Type::ObjCObjectPointer:
3479 case Type::Pointer:
3483 case Type::MemberPointer:
3487 case Type::Atomic:
3553 const Type *T = OT->getBaseType().getTypePtr();
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 2735 const Type *SrcRecTy = Ctx.getTypeDeclType(SrcRD).getTypePtr();
tools/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp 67 static bool CanRepresent(const Type *Ty) {
tools/clang/lib/CodeGen/TargetInfo.cpp 215 bool ABIInfo::isHomogeneousAggregateSmallEnough(const Type *Base,
539 static const Type *isSingleElementStruct(QualType T, ASTContext &Context) {
548 const Type *Found = nullptr;
806 if (const Type *SeltTy = isSingleElementStruct(Ty, getContext()))
825 if (const Type *SeltTy = isSingleElementStruct(RetTy, getContext()))
1029 bool isHomogeneousAggregateSmallEnough(const Type *Ty,
1384 const Type *Base = nullptr;
1443 if (const Type *SeltTy = isSingleElementStruct(RetTy, getContext()))
1539 const Type *T = isSingleElementStruct(Ty, getContext());
1652 const Type *Base = nullptr;
1756 const Type *Base = nullptr;
1773 const Type *Base = nullptr;
2255 bool isHomogeneousAggregateSmallEnough(const Type *Ty,
2999 if (const Type *InnerTy = isSingleElementStruct(Ty, getContext()))
3917 const Type *Base = nullptr;
3954 const Type *Base = nullptr;
4166 const Type *AlignTy = nullptr;
4167 if (const Type *EltType = isSingleElementStruct(Ty, getContext())) {
4394 bool IsQPXVectorTy(const Type *Ty) const {
4433 bool isHomogeneousAggregateSmallEnough(const Type *Ty,
4449 const Type *T = isSingleElementStruct(I.type, getContext());
4556 const Type *AlignAsType = nullptr;
4557 const Type *EltType = isSingleElementStruct(Ty, getContext());
4567 const Type *Base = nullptr;
4597 bool ABIInfo::isHomogeneousAggregate(QualType Ty, const Type *&Base,
4674 const Type *TyPtr = Ty.getTypePtr();
4718 const Type *Base, uint64_t Members) const {
4758 const Type *Base = nullptr;
4824 const Type *Base = nullptr;
4997 bool isHomogeneousAggregateSmallEnough(const Type *Ty,
5168 const Type *Base = nullptr;
5225 const Type *Base = nullptr;
5294 bool AArch64ABIInfo::isHomogeneousAggregateSmallEnough(const Type *Base,
5427 const Type *Base = nullptr;
5570 const Type *Base = nullptr;
5644 ABIArgInfo classifyHomogeneousAggregate(QualType Ty, const Type *Base,
5651 bool isHomogeneousAggregateSmallEnough(const Type *Ty,
5842 const Type *Base,
5910 const Type *Base = nullptr;
5918 const Type *Base = nullptr;
6140 const Type *Base = nullptr;
6270 bool ARMABIInfo::isHomogeneousAggregateSmallEnough(const Type *Base,
6301 const Type *Base = nullptr;
7685 bool isHomogeneousAggregateSmallEnough(const Type *Base,
7706 const Type *Base, uint64_t Members) const {
7777 if (const Type *SeltTy = isSingleElementStruct(RetTy, getContext()))
7816 if (const Type *SeltTy = isSingleElementStruct(Ty, getContext()))
7844 if (const Type *SeltTy = isSingleElementStruct(Ty, getContext()))
tools/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp 2273 const Type* TypePtr = QT->getAs<Type>();
2273 const Type* TypePtr = QT->getAs<Type>();
2279 TypePtr = QT->getAs<Type>();
4727 const Type* TypePtr = QT->getAs<Type>();
4727 const Type* TypePtr = QT->getAs<Type>();
tools/clang/lib/Frontend/Rewrite/RewriteObjC.cpp 2185 const Type* TypePtr = QT->getAs<Type>();
2185 const Type* TypePtr = QT->getAs<Type>();
2191 TypePtr = QT->getAs<Type>();
3896 const Type* TypePtr = QT->getAs<Type>();
3896 const Type* TypePtr = QT->getAs<Type>();
tools/clang/lib/Index/IndexBody.cpp 154 const Expr *E, const Type *T, const DeclarationNameInfo &NameInfo,
tools/clang/lib/Index/IndexTypeSourceInfo.cpp 176 const Type *T = NNS->getAsType();
tools/clang/lib/Index/USRGeneration.cpp 65 llvm::DenseMap<const Type *, unsigned> TypeSubstitutions;
769 llvm::DenseMap<const Type *, unsigned>::iterator Substitution
tools/clang/lib/Parse/ParseExpr.cpp 1755 const Type* BaseType = Base->getType().getTypePtrOrNull();
tools/clang/lib/Sema/Sema.cpp 562 case Type::STK_Bool: return CK_NoOp;
563 case Type::STK_CPointer: return CK_PointerToBoolean;
564 case Type::STK_BlockPointer: return CK_PointerToBoolean;
565 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
566 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
567 case Type::STK_Integral: return CK_IntegralToBoolean;
568 case Type::STK_Floating: return CK_FloatingToBoolean;
569 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
570 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
571 case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
tools/clang/lib/Sema/SemaCXXScopeSpec.cpp 32 const Type *Ty = T->getCanonicalTypeInternal().getTypePtr();
87 const Type *NNSType = NNS->getAsType();
tools/clang/lib/Sema/SemaCast.cpp 2369 const Type *DestPtr, *SrcPtr;
tools/clang/lib/Sema/SemaChecking.cpp 5692 const Type *Arg1Ty = Arg1->getType().getCanonicalType().getTypePtr();
5695 const Type *Arg2Ty = Arg2->getType().getCanonicalType().getTypePtr();
9346 const Type *Ty = T->getBaseElementTypeUnsafe();
10078 static IntRange forValueOfCanonicalType(ASTContext &C, const Type *T) {
10123 static IntRange forTargetOfCanonicalType(ASTContext &C, const Type *T) {
11263 const Type *Target = S.Context.getCanonicalType(Ex->getType()).getTypePtr();
11264 const Type *Source =
11271 const Type *BoolCandidateType = ToBool ? Target : Source;
11548 const Type *Source = S.Context.getCanonicalType(E->getType()).getTypePtr();
11549 const Type *Target = S.Context.getCanonicalType(T).getTypePtr();
13242 const Type *EffectiveType =
13251 const Type *BaseType = ArrayTy->getElementType().getTypePtr();
14344 const Type::TypeClass TC1 = T1->getTypeClass();
14345 const Type::TypeClass TC2 = T2->getTypeClass();
14350 if (TC1 == Type::Enum) {
14354 } else if (TC1 == Type::Record) {
14647 void Sema::DiscardMisalignedMemberAddress(const Type *T, Expr *E) {
tools/clang/lib/Sema/SemaCodeComplete.cpp 813 case Type::Builtin:
834 case Type::Complex:
837 case Type::Pointer:
840 case Type::BlockPointer:
843 case Type::LValueReference:
844 case Type::RValueReference:
847 case Type::ConstantArray:
848 case Type::IncompleteArray:
849 case Type::VariableArray:
850 case Type::DependentSizedArray:
853 case Type::DependentSizedExtVector:
854 case Type::Vector:
855 case Type::ExtVector:
858 case Type::FunctionProto:
859 case Type::FunctionNoProto:
862 case Type::Record:
865 case Type::Enum:
868 case Type::ObjCObject:
869 case Type::ObjCInterface:
870 case Type::ObjCObjectPointer:
1503 case Type::ObjCObject:
1504 case Type::ObjCInterface:
1505 case Type::ObjCObjectPointer:
1508 case Type::Builtin:
tools/clang/lib/Sema/SemaCoroutine.cpp 379 Type const *T = RetType.getTypePtr();
tools/clang/lib/Sema/SemaDecl.cpp 259 cast<Type>(Context.getRecordType(RD)));
646 const Type *Ty = SS->getScopeRep()->getAsType();
1767 const auto *Ty = VD->getType().getTypePtr();
5745 const Type *Ty = Qs.strip(T);
8361 const Type *UnderlyingTy = PT->getPointeeOrArrayElementType();
8375 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
8479 const Type *FieldRecTy = FieldTy->getPointeeOrArrayElementType();
9461 llvm::SmallPtrSet<const Type *, 16> ValidTypes;
14762 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
14826 ED->setIntegerType(QualType(EnumUnderlying.get<const Type *>(), 0));
15188 else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>())
15188 else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>())
15445 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0));
16445 const Type *FDTy = FD->getType().getTypePtr();
tools/clang/lib/Sema/SemaDeclAttr.cpp 547 const auto &Ty = *BS->getType();
3435 const Type *CalleeType =
3444 const Type *CalleeFnType =
4392 const Type *ExistingDerefType = OAttr->getDerefTypeLoc()
4409 const Type *ExistingDerefType = PAttr->getDerefTypeLoc()
6295 const Type *DeclTy = PDecl->getType().getCanonicalType().getTypePtr();
8407 const Type *TyPtr = Ty.getTypePtr();
tools/clang/lib/Sema/SemaDeclCXX.cpp 3071 const Type *T = FD.getType()->getBaseElementTypeUnsafe();
3662 FieldDecl *Field, const Type *BaseClass) {
5249 const Type *BaseClass = Init->getBaseClass();
10667 const Type *SourceType = UD->getQualifier()->getAsType();
12048 const Type *E = T->getBaseElementTypeUnsafe();
12175 const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
tools/clang/lib/Sema/SemaDeclObjC.cpp 3127 const Type *left, const Type *right);
3127 const Type *left, const Type *right);
3131 const Type *left =
3133 const Type *right =
3171 Type::ScalarTypeKind leftSK = left->getScalarTypeKind();
3172 Type::ScalarTypeKind rightSK = right->getScalarTypeKind();
3173 if (leftSK == Type::STK_Bool) leftSK = Type::STK_Integral;
3173 if (leftSK == Type::STK_Bool) leftSK = Type::STK_Integral;
3174 if (rightSK == Type::STK_Bool) rightSK = Type::STK_Integral;
3174 if (rightSK == Type::STK_Bool) rightSK = Type::STK_Integral;
3175 if (leftSK == Type::STK_CPointer || leftSK == Type::STK_BlockPointer)
3175 if (leftSK == Type::STK_CPointer || leftSK == Type::STK_BlockPointer)
3176 leftSK = Type::STK_ObjCObjectPointer;
3177 if (rightSK == Type::STK_CPointer || rightSK == Type::STK_BlockPointer)
3177 if (rightSK == Type::STK_CPointer || rightSK == Type::STK_BlockPointer)
3178 rightSK = Type::STK_ObjCObjectPointer;
3188 const Type *lt, const Type *rt) {
3188 const Type *lt, const Type *rt) {
tools/clang/lib/Sema/SemaExpr.cpp 2053 const Type *Ty = Corrected.getCorrectionSpecifier()->getAsType();
4046 const Type *Ty = T.getTypePtr();
4057 case Type::Builtin:
4058 case Type::Complex:
4059 case Type::Vector:
4060 case Type::ExtVector:
4061 case Type::Record:
4062 case Type::Enum:
4063 case Type::Elaborated:
4064 case Type::TemplateSpecialization:
4065 case Type::ObjCObject:
4066 case Type::ObjCInterface:
4067 case Type::ObjCObjectPointer:
4068 case Type::ObjCTypeParam:
4069 case Type::Pipe:
4071 case Type::Adjusted:
4074 case Type::Decayed:
4077 case Type::Pointer:
4080 case Type::BlockPointer:
4083 case Type::LValueReference:
4084 case Type::RValueReference:
4087 case Type::MemberPointer:
4090 case Type::ConstantArray:
4091 case Type::IncompleteArray:
4095 case Type::VariableArray: {
4109 case Type::FunctionProto:
4110 case Type::FunctionNoProto:
4113 case Type::Paren:
4114 case Type::TypeOf:
4115 case Type::UnaryTransform:
4116 case Type::Attributed:
4117 case Type::SubstTemplateTypeParm:
4118 case Type::PackExpansion:
4119 case Type::MacroQualified:
4123 case Type::Typedef:
4126 case Type::Decltype:
4129 case Type::Auto:
4130 case Type::DeducedTemplateSpecialization:
4133 case Type::TypeOfExpr:
4136 case Type::Atomic:
6280 switch (Type::ScalarTypeKind SrcKind = SrcTy->getScalarTypeKind()) {
6281 case Type::STK_MemberPointer:
6284 case Type::STK_CPointer:
6285 case Type::STK_BlockPointer:
6286 case Type::STK_ObjCObjectPointer:
6288 case Type::STK_CPointer: {
6297 case Type::STK_BlockPointer:
6298 return (SrcKind == Type::STK_BlockPointer
6300 case Type::STK_ObjCObjectPointer:
6301 if (SrcKind == Type::STK_ObjCObjectPointer)
6303 if (SrcKind == Type::STK_CPointer)
6307 case Type::STK_Bool:
6309 case Type::STK_Integral:
6311 case Type::STK_Floating:
6312 case Type::STK_FloatingComplex:
6313 case Type::STK_IntegralComplex:
6314 case Type::STK_MemberPointer:
6315 case Type::STK_FixedPoint:
6320 case Type::STK_FixedPoint:
6322 case Type::STK_FixedPoint:
6324 case Type::STK_Bool:
6326 case Type::STK_Integral:
6328 case Type::STK_Floating:
6329 case Type::STK_IntegralComplex:
6330 case Type::STK_FloatingComplex:
6335 case Type::STK_CPointer:
6336 case Type::STK_ObjCObjectPointer:
6337 case Type::STK_BlockPointer:
6338 case Type::STK_MemberPointer:
6343 case Type::STK_Bool: // casting from bool is like casting from an integer
6344 case Type::STK_Integral:
6346 case Type::STK_CPointer:
6347 case Type::STK_ObjCObjectPointer:
6348 case Type::STK_BlockPointer:
6353 case Type::STK_Bool:
6355 case Type::STK_Integral:
6357 case Type::STK_Floating:
6359 case Type::STK_IntegralComplex:
6364 case Type::STK_FloatingComplex:
6369 case Type::STK_MemberPointer:
6371 case Type::STK_FixedPoint:
6376 case Type::STK_Floating:
6378 case Type::STK_Floating:
6380 case Type::STK_Bool:
6382 case Type::STK_Integral:
6384 case Type::STK_FloatingComplex:
6389 case Type::STK_IntegralComplex:
6394 case Type::STK_CPointer:
6395 case Type::STK_ObjCObjectPointer:
6396 case Type::STK_BlockPointer:
6398 case Type::STK_MemberPointer:
6400 case Type::STK_FixedPoint:
6408 case Type::STK_FloatingComplex:
6410 case Type::STK_FloatingComplex:
6412 case Type::STK_IntegralComplex:
6414 case Type::STK_Floating: {
6421 case Type::STK_Bool:
6423 case Type::STK_Integral:
6428 case Type::STK_CPointer:
6429 case Type::STK_ObjCObjectPointer:
6430 case Type::STK_BlockPointer:
6432 case Type::STK_MemberPointer:
6434 case Type::STK_FixedPoint:
6442 case Type::STK_IntegralComplex:
6444 case Type::STK_FloatingComplex:
6446 case Type::STK_IntegralComplex:
6448 case Type::STK_Integral: {
6455 case Type::STK_Bool:
6457 case Type::STK_Floating:
6462 case Type::STK_CPointer:
6463 case Type::STK_ObjCObjectPointer:
6464 case Type::STK_BlockPointer:
6466 case Type::STK_MemberPointer:
6468 case Type::STK_FixedPoint:
7902 const Type *lhptee, *rhptee;
tools/clang/lib/Sema/SemaExprCXX.cpp 595 const Type *Ty = QT.getTypePtr();
6192 SmallVector<std::pair<const Type *, const Type *>, 4> MemberOfClass;
6192 SmallVector<std::pair<const Type *, const Type *>, 4> MemberOfClass;
6465 const Type *T = Context.getCanonicalType(E->getType().getTypePtr());
6469 case Type::Record:
6472 case Type::ConstantArray:
6473 case Type::IncompleteArray:
6474 case Type::VariableArray:
6475 case Type::DependentSizedArray:
tools/clang/lib/Sema/SemaExprObjC.cpp 4213 const Type *DT = castType.getTypePtr();
tools/clang/lib/Sema/SemaFixItUtils.cpp 168 const Type &T, SourceLocation Loc, const Sema &S) {
tools/clang/lib/Sema/SemaLambda.cpp 1571 const Type *BaseT = T->getBaseElementTypeUnsafe();
tools/clang/lib/Sema/SemaLookup.cpp 2821 SmallVector<const Type *, 16> Queue;
2822 const Type *T = Ty->getCanonicalTypeInternal().getTypePtr();
2842 case Type::Pointer:
2845 case Type::ConstantArray:
2846 case Type::IncompleteArray:
2847 case Type::VariableArray:
2853 case Type::Builtin:
2861 case Type::Record: {
2872 case Type::Enum: {
2888 case Type::FunctionProto: {
2895 case Type::FunctionNoProto: {
2910 case Type::MemberPointer: {
2922 case Type::BlockPointer:
2928 case Type::LValueReference:
2929 case Type::RValueReference:
2934 case Type::Vector:
2935 case Type::ExtVector:
2936 case Type::Complex:
2940 case Type::Auto:
2941 case Type::DeducedTemplateSpecialization:
2947 case Type::ObjCObject:
2948 case Type::ObjCInterface:
2949 case Type::ObjCObjectPointer:
2955 case Type::Atomic:
2958 case Type::Pipe:
4297 if (const Type *T = NNS->getAsType())
4298 SSIsTemplate = T->getTypeClass() == Type::TemplateSpecialization;
4305 const auto *TI = Types[I];
4400 const Type *NSType = NSI.NameSpecifier->getAsType();
tools/clang/lib/Sema/SemaOpenMP.cpp 4800 const Type *Ty = QTy.getTypePtrOrNull();
5025 const Type *ClassType =
13777 const auto *Ty = Type.getTypePtrOrNull();
14057 const Type *Ty = QType.getTypePtrOrNull();
tools/clang/lib/Sema/SemaOverload.cpp 1491 Type::TypeClass TyClass = CanTo->getTypeClass();
1493 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1493 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1494 if (TyClass == Type::Pointer) {
1497 } else if (TyClass == Type::BlockPointer) {
1500 } else if (TyClass == Type::MemberPointer) {
1514 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1514 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1686 const Type *ClassType
2215 BuildSimilarlyQualifiedPointerType(const Type *FromPtr,
4304 const Type *FromPointeeType1 = FromMemPointer1->getClass();
4305 const Type *ToPointeeType1 = ToMemPointer1->getClass();
4306 const Type *FromPointeeType2 = FromMemPointer2->getClass();
4307 const Type *ToPointeeType2 = ToMemPointer2->getClass();
7722 const Type *ClassTy = PointerTy->getClass();
tools/clang/lib/Sema/SemaStmtAsm.cpp 420 const Type *Ty = Exprs[i]->getType().getTypePtr();
497 const Type *Ty = Exprs[ConstraintIdx]->getType().getTypePtr();
776 if (const Type *PT = getCurrentThisType().getTypePtrOrNull())
tools/clang/lib/Sema/SemaTemplate.cpp 2564 if (const Type *CurType = NNS->getAsType()) {
8916 if (const Type *T = NNS->getAsType())
tools/clang/lib/Sema/SemaTemplateDeduction.cpp 612 case Type::TypeOfExpr:
613 case Type::TypeOf:
614 case Type::DependentName:
615 case Type::Decltype:
616 case Type::UnresolvedUsing:
617 case Type::TemplateTypeParm:
620 case Type::ConstantArray:
621 case Type::IncompleteArray:
622 case Type::VariableArray:
623 case Type::DependentSizedArray:
1491 case Type::TemplateTypeParm:
1492 case Type::SubstTemplateTypeParmPack:
1497 case Type::Builtin:
1498 case Type::VariableArray:
1499 case Type::Vector:
1500 case Type::FunctionNoProto:
1501 case Type::Record:
1502 case Type::Enum:
1503 case Type::ObjCObject:
1504 case Type::ObjCInterface:
1505 case Type::ObjCObjectPointer:
1517 case Type::Complex:
1527 case Type::Atomic:
1537 case Type::Pointer: {
1556 case Type::LValueReference: {
1568 case Type::RValueReference: {
1581 case Type::IncompleteArray: {
1595 case Type::ConstantArray: {
1614 case Type::DependentSizedArray: {
1663 case Type::FunctionProto: {
1736 case Type::InjectedClassName:
1750 case Type::TemplateSpecialization: {
1860 case Type::MemberPointer: {
1895 case Type::BlockPointer: {
1911 case Type::ExtVector: {
1941 case Type::DependentVector: {
1992 case Type::DependentSizedExtVector: {
2048 case Type::DependentAddressSpace: {
2098 case Type::TypeOfExpr:
2099 case Type::TypeOf:
2100 case Type::DependentName:
2101 case Type::UnresolvedUsing:
2102 case Type::Decltype:
2103 case Type::UnaryTransform:
2104 case Type::Auto:
2105 case Type::DeducedTemplateSpecialization:
2106 case Type::DependentTemplateSpecialization:
2107 case Type::PackExpansion:
2108 case Type::Pipe:
5359 case Type::Pointer:
5367 case Type::BlockPointer:
5375 case Type::LValueReference:
5376 case Type::RValueReference:
5384 case Type::MemberPointer: {
5393 case Type::DependentSizedArray:
5400 case Type::ConstantArray:
5401 case Type::IncompleteArray:
5407 case Type::Vector:
5408 case Type::ExtVector:
5414 case Type::DependentVector: {
5422 case Type::DependentSizedExtVector: {
5432 case Type::DependentAddressSpace: {
5443 case Type::FunctionProto: {
5470 case Type::TemplateTypeParm: {
5477 case Type::SubstTemplateTypeParmPack: {
5488 case Type::InjectedClassName:
5492 case Type::TemplateSpecialization: {
5512 case Type::Complex:
5519 case Type::Atomic:
5526 case Type::DependentName:
5533 case Type::DependentTemplateSpecialization: {
5558 case Type::TypeOf:
5565 case Type::TypeOfExpr:
5572 case Type::Decltype:
5579 case Type::UnaryTransform:
5586 case Type::PackExpansion:
5592 case Type::Auto:
5593 case Type::DeducedTemplateSpecialization:
5600 case Type::Builtin:
5601 case Type::VariableArray:
5602 case Type::FunctionNoProto:
5603 case Type::Record:
5604 case Type::Enum:
5605 case Type::ObjCInterface:
5606 case Type::ObjCObject:
5607 case Type::ObjCObjectPointer:
5608 case Type::UnresolvedUsing:
5609 case Type::Pipe:
tools/clang/lib/Sema/SemaType.cpp 5631 const Type* ClsTy = TL.getClass();
6149 const Type *prevTy = nullptr;
6337 const Type *Ty = T.getTypePtr();
6360 const Type *DTy = Ty->getUnqualifiedDesugaredType();
6398 QualType wrap(ASTContext &C, const Type *Old, unsigned I) {
6622 const Type *pointeeType;
tools/clang/lib/Serialization/ASTReader.cpp 6749 const Type *T = nullptr;
6751 if (const Type *Existing = DI->getTypeForDecl()) {
9491 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
tools/clang/lib/Serialization/ASTWriter.cpp 4337 const llvm::DenseMap<const Type *, std::set<std::string>> &OpenCLTypeExtMap =
tools/clang/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp 62 const Type *ElemType = Last->getType()->getArrayElementTypeNoTypeQual();
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp 285 if (const Type *NewTy = getBetterObjCType(CE, C)) {
tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp 637 const Type *ArgTy = Arg->getType().getTypePtr();
tools/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp 501 const Type *Tp = ConversionDec->getConversionType().getTypePtrOrNull();
tools/clang/lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp 109 while (const Type *T = Ty.getTypePtr()) {
tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp 35 inline bool isPointerSize(const Type *T) {
48 const Type *TP = T.getTypePtr();
54 if (const Type *TElem = PointeeT->getArrayElementTypeNoTypeQual())
62 if (const Type *TElem = TP->getArrayElementTypeNoTypeQual())
tools/clang/lib/StaticAnalyzer/Core/MemRegion.cpp 864 const Type *GT = GQT.getTypePtrOrNull();
tools/clang/lib/StaticAnalyzer/Core/SValBuilder.cpp 280 const Type *T = D->getTypeForDecl();
tools/clang/tools/extra/clang-change-namespace/ChangeNamespace.cpp 584 const Type *SpecifierType =
tools/clang/tools/extra/clang-tidy/bugprone/CopyConstructorInitCheck.cpp 52 const Type *BaseType = Init->getBaseClass();
tools/clang/tools/extra/clang-tidy/bugprone/ForwardDeclarationNamespaceCheck.h 51 llvm::SmallPtrSet<const Type *, 16> FriendTypes;
tools/clang/tools/extra/clang-tidy/bugprone/ForwardingReferenceOverloadCheck.cpp 33 const Type *BaseType = Node.getTypePtr();
47 if (const auto *Qualifier = Elaborated->getQualifier()->getAsType()) {
tools/clang/tools/extra/clang-tidy/bugprone/ParentVirtualCallCheck.cpp 52 const Type *TypePtr = ActualMemberDecl->getThisType().getTypePtr();
112 const auto *CastToTypePtr = Result.Nodes.getNodeAs<Type>("castToType");
112 const auto *CastToTypePtr = Result.Nodes.getNodeAs<Type>("castToType");
tools/clang/tools/extra/clang-tidy/bugprone/SizeofExpressionCheck.cpp 51 CharUnits getSizeOfType(const ASTContext &Ctx, const Type *Ty) {
283 const auto *NumTy = Result.Nodes.getNodeAs<Type>("num-type");
283 const auto *NumTy = Result.Nodes.getNodeAs<Type>("num-type");
284 const auto *DenomTy = Result.Nodes.getNodeAs<Type>("denom-type");
284 const auto *DenomTy = Result.Nodes.getNodeAs<Type>("denom-type");
285 const auto *ElementTy = Result.Nodes.getNodeAs<Type>("elem-type");
285 const auto *ElementTy = Result.Nodes.getNodeAs<Type>("elem-type");
286 const auto *PointedTy = Result.Nodes.getNodeAs<Type>("elem-ptr-type");
286 const auto *PointedTy = Result.Nodes.getNodeAs<Type>("elem-ptr-type");
320 const auto *LPtrTy = Result.Nodes.getNodeAs<Type>("left-ptr-type");
320 const auto *LPtrTy = Result.Nodes.getNodeAs<Type>("left-ptr-type");
321 const auto *RPtrTy = Result.Nodes.getNodeAs<Type>("right-ptr-type");
321 const auto *RPtrTy = Result.Nodes.getNodeAs<Type>("right-ptr-type");
322 const auto *SizeofArgTy = Result.Nodes.getNodeAs<Type>("sizeof-arg-type");
322 const auto *SizeofArgTy = Result.Nodes.getNodeAs<Type>("sizeof-arg-type");
330 const auto *LPtrTy = Result.Nodes.getNodeAs<Type>("left-ptr-type");
330 const auto *LPtrTy = Result.Nodes.getNodeAs<Type>("left-ptr-type");
331 const auto *RPtrTy = Result.Nodes.getNodeAs<Type>("right-ptr-type");
331 const auto *RPtrTy = Result.Nodes.getNodeAs<Type>("right-ptr-type");
332 const auto *SizeofArgTy = Result.Nodes.getNodeAs<Type>("sizeof-arg-type");
332 const auto *SizeofArgTy = Result.Nodes.getNodeAs<Type>("sizeof-arg-type");
tools/clang/tools/extra/clang-tidy/bugprone/UseAfterMoveCheck.cpp 209 const Type *TheType = VD->getType().getNonReferenceType().getTypePtrOrNull();
tools/clang/tools/extra/clang-tidy/misc/UniqueptrResetReleaseCheck.cpp 44 const Type *getDeleterForUniquePtr(const MatchFinder::MatchResult &Result,
57 const Type *LeftDeleterType = getDeleterForUniquePtr(Result, "left_class");
58 const Type *RightDeleterType = getDeleterForUniquePtr(Result, "right_class");
tools/clang/tools/extra/clang-tidy/modernize/AvoidCArraysCheck.cpp 24 const clang::Type *TypeNode = Node.getTypePtr();
tools/clang/tools/extra/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp 22 case Type::STK_CPointer:
23 case Type::STK_BlockPointer:
24 case Type::STK_ObjCObjectPointer:
25 case Type::STK_MemberPointer:
28 case Type::STK_Bool:
31 case Type::STK_Integral:
49 case Type::STK_Floating:
58 case Type::STK_FloatingComplex:
59 case Type::STK_IntegralComplex:
63 case Type::STK_FixedPoint:
tools/clang/tools/extra/clang-tidy/modernize/UseEqualsDefaultCheck.cpp 37 static std::set<const Type *> getAllDirectBases(const CXXRecordDecl *Record) {
38 std::set<const Type *> Result;
41 const auto *BaseType = Base.getTypeSourceInfo()->getType().getTypePtr();
73 for (const auto *Base : BasesToInit) {
139 for (const auto *Base : BasesToInit) {
tools/clang/tools/extra/clang-tidy/modernize/UseNoexceptCheck.cpp 75 ->getAs<Type>()
tools/clang/tools/extra/clang-tidy/modernize/UseNullptrCheck.cpp 27 const Type *DesugaredType = Node.getUnqualifiedDesugaredType();
tools/clang/tools/extra/clang-tidy/mpi/BufferDerefCheck.cpp 36 SmallVector<const Type *, 1> BufferTypes;
53 const Type *ArgType = ArgExpr->IgnoreImpCasts()->getType().getTypePtr();
82 void BufferDerefCheck::checkBuffers(ArrayRef<const Type *> BufferTypes,
86 const Type *BufferType = BufferTypes[i];
tools/clang/tools/extra/clang-tidy/mpi/BufferDerefCheck.h 40 void checkBuffers(ArrayRef<const Type *> BufferTypes,
tools/clang/tools/extra/clang-tidy/mpi/TypeMismatchCheck.cpp 234 static const Type *argumentType(const CallExpr *const CE, const size_t idx) {
254 SmallVector<const Type *, 1> BufferTypes;
272 const Type *ArgType = argumentType(CE, BufferIdx);
301 void TypeMismatchCheck::checkArguments(ArrayRef<const Type *> BufferTypes,
308 const Type *const BT = BufferTypes[i];
tools/clang/tools/extra/clang-tidy/mpi/TypeMismatchCheck.h 41 void checkArguments(ArrayRef<const Type *> BufferTypes,
tools/clang/tools/extra/clang-tidy/readability/IdentifierNamingCheck.cpp 815 if (const auto *TypePtr = Value->getType().getTypePtrOrNull()) {
tools/clang/tools/extra/clang-tidy/readability/IsolateDeclarationCheck.cpp 60 static int countIndirections(const Type *T, int Indirections = 0) {
81 static bool typeIsMemberPointer(const Type *T) {
tools/clang/tools/extra/clang-tidy/readability/NonConstParameterCheck.cpp 77 const Type *ParType = Par->getType().getTypePtr();
tools/clang/tools/extra/clang-tidy/readability/RedundantSmartptrGetCheck.cpp 119 const Type *OpArrowType =
120 Result.Nodes.getNodeAs<Type>("op->Type")->getUnqualifiedDesugaredType();
121 const Type *OpStarType =
122 Result.Nodes.getNodeAs<Type>("op*Type")->getUnqualifiedDesugaredType();
123 const Type *GetType =
124 Result.Nodes.getNodeAs<Type>("getType")->getUnqualifiedDesugaredType();
tools/clang/tools/extra/clang-tidy/utils/ExceptionAnalyzer.cpp 16 const Type *ExceptionType) {
49 static bool isBaseOf(const Type *DerivedType, const Type *BaseType) {
49 static bool isBaseOf(const Type *DerivedType, const Type *BaseType) {
59 bool ExceptionAnalyzer::ExceptionInfo::filterByCatch(const Type *BaseClass) {
60 llvm::SmallVector<const Type *, 8> TypesToDelete;
61 for (const Type *T : ThrownExceptions) {
66 for (const Type *T : TypesToDelete)
76 llvm::SmallVector<const Type *, 8> TypesToDelete;
79 for (const Type *T : ThrownExceptions) {
89 for (const Type *T : TypesToDelete)
145 const auto *ThrownType =
171 const auto *CaughtType =
tools/clang/tools/extra/clang-tidy/utils/ExceptionAnalyzer.h 42 using Throwables = llvm::SmallSet<const Type *, 2>;
65 void registerException(const Type *ExceptionType);
83 bool filterByCatch(const Type *BaseClass);
tools/clang/tools/extra/clangd/ExpectedTypes.cpp 22 static const Type *toEquivClass(ASTContext &Ctx, QualType T) {
72 const Type *C = toEquivClass(Ctx, T);
tools/clang/tools/extra/clangd/IncludeFixer.cpp 80 if (const Type *T = QT.getTypePtrOrNull())
117 std::vector<Fix> IncludeFixer::fixIncompleteType(const Type &T) const {
tools/clang/tools/extra/clangd/IncludeFixer.h 53 std::vector<Fix> fixIncompleteType(const Type &T) const;
tools/clang/tools/extra/clangd/SemanticHighlighting.cpp 38 llvm::Optional<HighlightingKind> kindForType(const Type *TP);
91 llvm::Optional<HighlightingKind> kindForType(const Type *TP) {
tools/clang/tools/extra/clangd/XRefs.cpp 1190 const Type *Type = Base.getType().getTypePtr();
tools/clang/tools/extra/clangd/refactor/tweaks/DumpAST.cpp 53 return N.get<Decl>() || N.get<Stmt>() || N.get<Type>();
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractVariable.cpp 370 if (const Type *ExprType = E->getType().getTypePtrOrNull())
tools/clang/tools/libclang/CIndex.cpp 1343 const Type *T = NNS->getAsType();
tools/clang/tools/libclang/CIndexCodeCompletion.cpp 641 const Type *type = baseType.getTypePtrOrNull();
tools/clang/tools/libclang/CXType.cpp 85 const Type *TP = T.getTypePtrOrNull();
91 case Type::Builtin:
444 const Type *TP = T.getTypePtrOrNull();
451 case Type::Pointer:
454 case Type::BlockPointer:
457 case Type::LValueReference:
458 case Type::RValueReference:
461 case Type::ObjCObjectPointer:
464 case Type::MemberPointer:
467 case Type::Auto:
468 case Type::DeducedTemplateSpecialization:
485 const Type *TP = T.getTypePtrOrNull();
494 case Type::Typedef:
497 case Type::ObjCObject:
500 case Type::ObjCInterface:
503 case Type::Record:
504 case Type::Enum:
507 case Type::TemplateSpecialization:
515 case Type::Auto:
516 case Type::DeducedTemplateSpecialization:
522 case Type::InjectedClassName:
528 case Type::Elaborated:
792 const Type *TP = T.getTypePtrOrNull();
796 case Type::ConstantArray:
799 case Type::IncompleteArray:
802 case Type::VariableArray:
805 case Type::DependentSizedArray:
808 case Type::Vector:
811 case Type::ExtVector:
814 case Type::Complex:
827 const Type *TP = T.getTypePtrOrNull();
831 case Type::ConstantArray:
834 case Type::Vector:
837 case Type::ExtVector:
850 const Type *TP = T.getTypePtrOrNull();
854 case Type::ConstantArray:
857 case Type::IncompleteArray:
860 case Type::VariableArray:
863 case Type::DependentSizedArray:
876 const Type *TP = T.getTypePtrOrNull();
880 case Type::ConstantArray:
920 const Type *TP = T.getTypePtrOrNull();
922 if (TP && TP->getTypeClass() == Type::MemberPointer) {
1286 const Type *TP = T.getTypePtrOrNull();
1288 if (TP && TP->getTypeClass() == Type::Elaborated)
tools/clang/unittests/AST/ASTImporterTest.cpp 849 const internal::VariadicDynCastAllOfMatcher<Type,
2962 const internal::VariadicDynCastAllOfMatcher<Type, DependentNameType>
tools/clang/unittests/AST/ASTTraverserTest.cpp 38 void Visit(const Type *T) { OS << T->getTypeClassName() << "Type"; }
tools/clang/unittests/AST/ASTTypeTraitsTest.cpp 25 return ASTNodeKind::getFromNodeKind<T>();
tools/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp 1542 const T *Node = Nodes->getNodeAs<T>("");
1542 const T *Node = Nodes->getNodeAs<T>("");
1564 bool verify(const BoundNodes &Nodes, ASTContext &Context, const Type *Node) {
1567 const T *TypedNode = cast<T>(Node);
1567 const T *TypedNode = cast<T>(Node);
1569 return selectFirst<T>(
tools/clang/unittests/ASTMatchers/ASTMatchersTest.h 421 if (Nodes->getNodeAs<T>(Id)) {
tools/clang/unittests/ASTMatchers/Dynamic/RegistryTest.cpp 285 Matcher<Type> M = constructMatcher(
288 constructMatcher("isInteger"))).getTypedMatcher<Type>();
295 .getTypedMatcher<Type>();
tools/clang/unittests/CodeGen/CodeGenExternalTest.cpp 190 const clang::Type *clangTy = rd->getCanonicalDecl()->getTypeForDecl();
tools/lldb/source/Plugins/ExpressionParser/Clang/ASTDumper.cpp 62 ASTDumper::ASTDumper(const clang::Type *type) {
tools/lldb/source/Plugins/ExpressionParser/Clang/ASTDumper.h 24 ASTDumper(const clang::Type *type);
tools/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp 300 const clang::Type *expr_type = expr_qual_type.getTypePtr();
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp 504 const clang::Type *complete_clang_type =
1699 const clang::Type *origin_base_type = bi->getType().getTypePtr();
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp 1005 const clang::Type *interface_type = self_interface->getTypeForDecl();
1633 if (const clang::Type *parser_type = parser_opaque_type.getTypePtr()) {
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp 275 const clang::Type *pointer_type = pointer_qual_type.getTypePtr();
tools/lldb/source/Symbol/ClangASTContext.cpp 2516 const clang::Type *clang_type = tag_qual_type.getTypePtr();
2561 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2563 case clang::Type::ObjCInterface:
2566 case clang::Type::ObjCObjectPointer:
2570 case clang::Type::Record:
2572 case clang::Type::Enum:
2574 case clang::Type::Typedef:
2578 case clang::Type::Auto:
2581 case clang::Type::Elaborated:
2584 case clang::Type::Paren:
2597 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2599 case clang::Type::ConstantArray:
2600 case clang::Type::IncompleteArray:
2601 case clang::Type::VariableArray: {
2609 case clang::Type::Record: {
2640 case clang::Type::Enum: {
2667 case clang::Type::ObjCObject:
2668 case clang::Type::ObjCInterface: {
2698 case clang::Type::Typedef:
2704 case clang::Type::Auto:
2709 case clang::Type::Elaborated:
2714 case clang::Type::Paren:
2719 case clang::Type::Attributed:
2753 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2755 case clang::Type::IncompleteArray:
2756 case clang::Type::VariableArray:
2757 case clang::Type::ConstantArray:
2758 case clang::Type::ExtVector:
2759 case clang::Type::Vector:
2760 case clang::Type::Record:
2761 case clang::Type::ObjCObject:
2762 case clang::Type::ObjCInterface:
2764 case clang::Type::Auto:
2768 case clang::Type::Elaborated:
2772 case clang::Type::Typedef:
2777 case clang::Type::Paren:
2790 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2792 case clang::Type::Record: {
2802 case clang::Type::Auto:
2806 case clang::Type::Elaborated:
2810 case clang::Type::Typedef:
2815 case clang::Type::Paren:
2830 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2835 case clang::Type::ConstantArray:
2849 case clang::Type::IncompleteArray:
2861 case clang::Type::VariableArray:
2873 case clang::Type::DependentSizedArray:
2885 case clang::Type::Typedef:
2891 case clang::Type::Auto:
2896 case clang::Type::Elaborated:
2901 case clang::Type::Paren:
2919 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2921 case clang::Type::Vector: {
2933 case clang::Type::ExtVector: {
3027 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3031 case clang::Type::Typedef:
3037 case clang::Type::Auto:
3042 case clang::Type::Elaborated:
3047 case clang::Type::Paren:
3051 case clang::Type::LValueReference:
3052 case clang::Type::RValueReference: {
3072 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3074 case clang::Type::Record:
3141 case clang::Type::Typedef:
3148 case clang::Type::Auto:
3154 case clang::Type::Elaborated:
3199 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3203 case clang::Type::Typedef:
3208 case clang::Type::Auto:
3212 case clang::Type::Elaborated:
3216 case clang::Type::Paren:
3220 case clang::Type::LValueReference:
3221 case clang::Type::RValueReference: {
3251 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3255 case clang::Type::Typedef:
3261 case clang::Type::Auto:
3266 case clang::Type::Elaborated:
3271 case clang::Type::Paren:
3276 case clang::Type::LValueReference:
3277 case clang::Type::RValueReference: {
3329 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3331 case clang::Type::Builtin:
3340 case clang::Type::ObjCObjectPointer:
3347 case clang::Type::BlockPointer:
3354 case clang::Type::Pointer:
3361 case clang::Type::MemberPointer:
3368 case clang::Type::Typedef:
3374 case clang::Type::Auto:
3379 case clang::Type::Elaborated:
3384 case clang::Type::Paren:
3401 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3403 case clang::Type::Builtin:
3412 case clang::Type::ObjCObjectPointer:
3418 case clang::Type::BlockPointer:
3425 case clang::Type::Pointer:
3432 case clang::Type::MemberPointer:
3439 case clang::Type::LValueReference:
3446 case clang::Type::RValueReference:
3453 case clang::Type::Typedef:
3459 case clang::Type::Auto:
3464 case clang::Type::Elaborated:
3470 case clang::Type::Paren:
3488 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3491 case clang::Type::LValueReference:
3500 case clang::Type::RValueReference:
3509 case clang::Type::Typedef:
3515 case clang::Type::Auto:
3520 case clang::Type::Elaborated:
3525 case clang::Type::Paren:
3626 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3627 return (type_class == clang::Type::Record);
3634 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3635 return (type_class == clang::Type::Enum);
3641 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3643 case clang::Type::Record:
3672 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3674 case clang::Type::Builtin:
3684 case clang::Type::ObjCObjectPointer:
3704 case clang::Type::Pointer:
3710 case clang::Type::LValueReference:
3711 case clang::Type::RValueReference:
3717 case clang::Type::Typedef:
3725 case clang::Type::Auto:
3732 case clang::Type::Elaborated:
3739 case clang::Type::Paren:
3751 const clang::Type::TypeClass pointee_type_class =
3754 case clang::Type::Builtin:
3767 case clang::Type::Record:
3802 case clang::Type::ObjCObject:
3803 case clang::Type::ObjCInterface:
3832 return GetQualType(type)->getTypeClass() == clang::Type::Typedef;
3954 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3956 case clang::Type::Attributed:
3961 case clang::Type::Builtin: {
4018 case clang::Type::BlockPointer:
4024 case clang::Type::Complex: {
4039 case clang::Type::ConstantArray:
4040 case clang::Type::DependentSizedArray:
4041 case clang::Type::IncompleteArray:
4042 case clang::Type::VariableArray:
4050 case clang::Type::DependentName:
4052 case clang::Type::DependentSizedExtVector:
4054 case clang::Type::DependentTemplateSpecialization:
4056 case clang::Type::Decltype:
4062 case clang::Type::Enum:
4071 case clang::Type::Auto:
4076 case clang::Type::Elaborated:
4081 case clang::Type::Paren:
4087 case clang::Type::FunctionProto:
4089 case clang::Type::FunctionNoProto:
4091 case clang::Type::InjectedClassName:
4094 case clang::Type::LValueReference:
4095 case clang::Type::RValueReference:
4103 case clang::Type::MemberPointer:
4106 case clang::Type::ObjCObjectPointer:
4113 case clang::Type::ObjCObject:
4115 case clang::Type::ObjCInterface:
4118 case clang::Type::Pointer:
4124 case clang::Type::Record:
4130 case clang::Type::SubstTemplateTypeParm:
4132 case clang::Type::TemplateTypeParm:
4134 case clang::Type::TemplateSpecialization:
4137 case clang::Type::Typedef:
4144 case clang::Type::TypeOfExpr:
4150 case clang::Type::TypeOf:
4155 case clang::Type::UnresolvedUsing:
4158 case clang::Type::ExtVector:
4159 case clang::Type::Vector: {
4208 case clang::Type::Builtin:
4251 case clang::Type::Typedef:
4270 case clang::Type::UnaryTransform:
4272 case clang::Type::FunctionNoProto:
4274 case clang::Type::FunctionProto:
4276 case clang::Type::IncompleteArray:
4278 case clang::Type::VariableArray:
4280 case clang::Type::ConstantArray:
4282 case clang::Type::DependentSizedArray:
4284 case clang::Type::DependentSizedExtVector:
4286 case clang::Type::DependentVector:
4288 case clang::Type::ExtVector:
4290 case clang::Type::Vector:
4292 case clang::Type::Builtin:
4294 case clang::Type::ObjCObjectPointer:
4296 case clang::Type::BlockPointer:
4298 case clang::Type::Pointer:
4300 case clang::Type::LValueReference:
4302 case clang::Type::RValueReference:
4304 case clang::Type::MemberPointer:
4306 case clang::Type::Complex:
4311 case clang::Type::ObjCObject:
4313 case clang::Type::ObjCInterface:
4315 case clang::Type::Record: {
4326 case clang::Type::Enum:
4328 case clang::Type::Typedef:
4330 case clang::Type::UnresolvedUsing:
4332 case clang::Type::Paren:
4337 case clang::Type::Auto:
4342 case clang::Type::Elaborated:
4348 case clang::Type::Attributed:
4350 case clang::Type::TemplateTypeParm:
4352 case clang::Type::SubstTemplateTypeParm:
4354 case clang::Type::SubstTemplateTypeParmPack:
4356 case clang::Type::InjectedClassName:
4358 case clang::Type::DependentName:
4360 case clang::Type::DependentTemplateSpecialization:
4362 case clang::Type::PackExpansion:
4365 case clang::Type::TypeOfExpr:
4371 case clang::Type::TypeOf:
4376 case clang::Type::Decltype:
4381 case clang::Type::TemplateSpecialization:
4383 case clang::Type::DeducedTemplateSpecialization:
4385 case clang::Type::Atomic:
4387 case clang::Type::Pipe:
4391 case clang::Type::Decayed:
4393 case clang::Type::Adjusted:
4395 case clang::Type::ObjCTypeParam:
4398 case clang::Type::DependentAddressSpace:
4400 case clang::Type::MacroQualified:
4421 const clang::Type *array_eletype =
4537 case clang::Type::Record:
4551 case clang::Type::ObjCObjectPointer: {
4569 case clang::Type::ObjCObject:
4570 case clang::Type::ObjCInterface:
4584 case clang::Type::Typedef:
4591 case clang::Type::Auto:
4597 case clang::Type::Elaborated:
4603 case clang::Type::Paren:
4626 case clang::Type::Record:
4661 case clang::Type::ObjCObjectPointer: {
4693 case clang::Type::ObjCObject:
4694 case clang::Type::ObjCInterface:
4723 case clang::Type::Typedef:
4730 case clang::Type::Auto:
4736 case clang::Type::Elaborated:
4743 case clang::Type::Paren:
4813 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4815 case clang::Type::ObjCObject:
4816 case clang::Type::ObjCInterface:
4959 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4961 case clang::Type::Record:
4968 case clang::Type::ObjCInterface:
4969 case clang::Type::ObjCObject: {
5037 case clang::Type::UnaryTransform:
5040 case clang::Type::FunctionNoProto:
5041 case clang::Type::FunctionProto:
5044 case clang::Type::IncompleteArray:
5045 case clang::Type::VariableArray:
5048 case clang::Type::ConstantArray:
5051 case clang::Type::DependentVector:
5052 case clang::Type::ExtVector:
5053 case clang::Type::Vector:
5057 case clang::Type::Builtin:
5211 case clang::Type::ObjCObjectPointer:
5212 case clang::Type::BlockPointer:
5213 case clang::Type::Pointer:
5214 case clang::Type::LValueReference:
5215 case clang::Type::RValueReference:
5216 case clang::Type::MemberPointer:
5218 case clang::Type::Complex: {
5236 case clang::Type::ObjCInterface:
5238 case clang::Type::Record:
5240 case clang::Type::Enum:
5242 case clang::Type::Typedef:
5249 case clang::Type::Auto:
5255 case clang::Type::Elaborated:
5261 case clang::Type::Paren:
5266 case clang::Type::TypeOfExpr:
5272 case clang::Type::TypeOf:
5277 case clang::Type::Decltype:
5282 case clang::Type::DependentSizedArray:
5283 case clang::Type::DependentSizedExtVector:
5284 case clang::Type::UnresolvedUsing:
5285 case clang::Type::Attributed:
5286 case clang::Type::TemplateTypeParm:
5287 case clang::Type::SubstTemplateTypeParm:
5288 case clang::Type::SubstTemplateTypeParmPack:
5289 case clang::Type::InjectedClassName:
5290 case clang::Type::DependentName:
5291 case clang::Type::DependentTemplateSpecialization:
5292 case clang::Type::PackExpansion:
5293 case clang::Type::ObjCObject:
5295 case clang::Type::TemplateSpecialization:
5296 case clang::Type::DeducedTemplateSpecialization:
5297 case clang::Type::Atomic:
5298 case clang::Type::Adjusted:
5299 case clang::Type::Pipe:
5303 case clang::Type::Decayed:
5305 case clang::Type::ObjCTypeParam:
5308 case clang::Type::DependentAddressSpace:
5310 case clang::Type::MacroQualified:
5324 case clang::Type::UnaryTransform:
5327 case clang::Type::FunctionNoProto:
5328 case clang::Type::FunctionProto:
5331 case clang::Type::IncompleteArray:
5332 case clang::Type::VariableArray:
5335 case clang::Type::ConstantArray:
5338 case clang::Type::DependentVector:
5339 case clang::Type::ExtVector:
5340 case clang::Type::Vector:
5343 case clang::Type::Builtin:
5393 case clang::Type::ObjCObjectPointer:
5395 case clang::Type::BlockPointer:
5397 case clang::Type::Pointer:
5399 case clang::Type::LValueReference:
5400 case clang::Type::RValueReference:
5402 case clang::Type::MemberPointer:
5404 case clang::Type::Complex: {
5410 case clang::Type::ObjCInterface:
5412 case clang::Type::Record:
5414 case clang::Type::Enum:
5416 case clang::Type::Typedef:
5422 case clang::Type::Auto:
5427 case clang::Type::Paren:
5432 case clang::Type::Elaborated:
5437 case clang::Type::TypeOfExpr:
5443 case clang::Type::TypeOf:
5448 case clang::Type::Decltype:
5453 case clang::Type::DependentSizedArray:
5454 case clang::Type::DependentSizedExtVector:
5455 case clang::Type::UnresolvedUsing:
5456 case clang::Type::Attributed:
5457 case clang::Type::TemplateTypeParm:
5458 case clang::Type::SubstTemplateTypeParm:
5459 case clang::Type::SubstTemplateTypeParmPack:
5460 case clang::Type::InjectedClassName:
5461 case clang::Type::DependentName:
5462 case clang::Type::DependentTemplateSpecialization:
5463 case clang::Type::PackExpansion:
5464 case clang::Type::ObjCObject:
5466 case clang::Type::TemplateSpecialization:
5467 case clang::Type::DeducedTemplateSpecialization:
5468 case clang::Type::Atomic:
5469 case clang::Type::Adjusted:
5470 case clang::Type::Pipe:
5474 case clang::Type::Decayed:
5476 case clang::Type::ObjCTypeParam:
5479 case clang::Type::DependentAddressSpace:
5481 case clang::Type::MacroQualified:
5521 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5523 case clang::Type::Builtin:
5535 case clang::Type::Complex:
5537 case clang::Type::Record:
5580 case clang::Type::ObjCObject:
5581 case clang::Type::ObjCInterface:
5608 case clang::Type::ObjCObjectPointer: {
5622 case clang::Type::Vector:
5623 case clang::Type::ExtVector:
5628 case clang::Type::ConstantArray:
5633 case clang::Type::IncompleteArray:
5642 case clang::Type::Pointer: {
5657 case clang::Type::LValueReference:
5658 case clang::Type::RValueReference: {
5672 case clang::Type::Typedef:
5680 case clang::Type::Auto:
5687 case clang::Type::Elaborated:
5695 case clang::Type::Paren:
5716 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5717 if (type_class == clang::Type::Builtin) {
5818 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5820 case clang::Type::Record:
5839 case clang::Type::Typedef:
5847 case clang::Type::Auto:
5854 case clang::Type::Elaborated:
5861 case clang::Type::Paren:
5869 case clang::Type::ObjCObjectPointer: {
5886 case clang::Type::ObjCObject:
5887 case clang::Type::ObjCInterface:
5968 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5970 case clang::Type::Record:
6018 case clang::Type::ObjCObjectPointer: {
6038 case clang::Type::ObjCObject:
6039 case clang::Type::ObjCInterface:
6055 case clang::Type::Typedef:
6063 case clang::Type::Auto:
6070 case clang::Type::Elaborated:
6077 case clang::Type::Paren:
6094 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6096 case clang::Type::Record:
6105 case clang::Type::ObjCObjectPointer:
6109 case clang::Type::ObjCObject:
6122 case clang::Type::ObjCInterface:
6136 case clang::Type::Typedef:
6143 case clang::Type::Auto:
6149 case clang::Type::Elaborated:
6155 case clang::Type::Paren:
6169 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6171 case clang::Type::Record:
6180 case clang::Type::Typedef:
6187 case clang::Type::Auto:
6193 case clang::Type::Elaborated:
6200 case clang::Type::Paren:
6214 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6216 case clang::Type::Record:
6254 case clang::Type::ObjCObjectPointer:
6257 case clang::Type::ObjCObject:
6279 case clang::Type::ObjCInterface:
6303 case clang::Type::Typedef:
6310 case clang::Type::Auto:
6316 case clang::Type::Elaborated:
6323 case clang::Type::Paren:
6337 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6339 case clang::Type::Record:
6371 case clang::Type::Typedef:
6378 case clang::Type::Auto:
6384 case clang::Type::Elaborated:
6391 case clang::Type::Paren:
6412 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6414 case clang::Type::Builtin:
6479 case clang::Type::Complex:
6481 case clang::Type::Pointer:
6483 case clang::Type::BlockPointer:
6486 case clang::Type::LValueReference:
6488 case clang::Type::RValueReference:
6490 case clang::Type::MemberPointer:
6492 case clang::Type::ConstantArray:
6494 case clang::Type::IncompleteArray:
6496 case clang::Type::VariableArray:
6498 case clang::Type::DependentSizedArray:
6500 case clang::Type::DependentSizedExtVector:
6502 case clang::Type::Vector:
6504 case clang::Type::ExtVector:
6506 case clang::Type::FunctionProto:
6508 case clang::Type::FunctionNoProto:
6510 case clang::Type::UnresolvedUsing:
6512 case clang::Type::Paren:
6515 case clang::Type::Typedef:
6519 case clang::Type::Auto:
6522 case clang::Type::Elaborated:
6525 case clang::Type::TypeOfExpr:
6529 case clang::Type::TypeOf:
6532 case clang::Type::Decltype:
6535 case clang::Type::Record:
6537 case clang::Type::Enum:
6539 case clang::Type::TemplateTypeParm:
6541 case clang::Type::SubstTemplateTypeParm:
6543 case clang::Type::TemplateSpecialization:
6545 case clang::Type::InjectedClassName:
6547 case clang::Type::DependentName:
6549 case clang::Type::DependentTemplateSpecialization:
6551 case clang::Type::ObjCObject:
6553 case clang::Type::ObjCInterface:
6555 case clang::Type::ObjCObjectPointer:
6579 const clang::Type::TypeClass parent_type_class =
6590 case clang::Type::Builtin:
6608 case clang::Type::Record:
6725 case clang::Type::ObjCObject:
6726 case clang::Type::ObjCInterface:
6851 case clang::Type::ObjCObjectPointer:
6886 case clang::Type::Vector:
6887 case clang::Type::ExtVector:
6910 case clang::Type::ConstantArray:
6911 case clang::Type::IncompleteArray:
6930 case clang::Type::Pointer: {
6969 case clang::Type::LValueReference:
6970 case clang::Type::RValueReference:
7006 case clang::Type::Typedef: {
7019 case clang::Type::Auto: {
7031 case clang::Type::Elaborated: {
7043 case clang::Type::Paren: {
7154 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
7156 case clang::Type::Record:
7248 case clang::Type::ObjCObject:
7249 case clang::Type::ObjCInterface:
7307 case clang::Type::ObjCObjectPointer: {
7316 case clang::Type::ConstantArray: {
7356 case clang::Type::LValueReference:
7357 case clang::Type::RValueReference: {
7369 case clang::Type::Pointer: {
7378 case clang::Type::Typedef:
7386 case clang::Type::Auto:
7393 case clang::Type::Elaborated:
7400 case clang::Type::Paren:
7425 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
7428 case clang::Type::Record:
7478 case clang::Type::ObjCObject:
7479 case clang::Type::ObjCInterface:
7519 case clang::Type::ObjCObjectPointer: {
7528 case clang::Type::ConstantArray: {
7568 case clang::Type::LValueReference:
7569 case clang::Type::RValueReference: {
7581 case clang::Type::Pointer: {
7610 case clang::Type::Auto:
7616 case clang::Type::Elaborated:
7622 case clang::Type::Paren:
7628 case clang::Type::Typedef:
7648 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
7650 case clang::Type::Record:
7664 case clang::Type::Typedef:
7671 case clang::Type::Auto:
7677 case clang::Type::Elaborated:
7683 case clang::Type::Paren:
7703 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
7705 case clang::Type::Record: {
7716 case clang::Type::Typedef:
7722 case clang::Type::Auto:
7727 case clang::Type::Elaborated:
7733 case clang::Type::Paren:
8626 const clang::Type *method_type(method_qual_type.getTypePtr());
8697 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
8699 case clang::Type::Record: {
8708 case clang::Type::Enum: {
8718 case clang::Type::ObjCObject:
8719 case clang::Type::ObjCInterface: {
8735 case clang::Type::Typedef:
8742 case clang::Type::Auto:
8748 case clang::Type::Elaborated:
8754 case clang::Type::Paren:
8879 const clang::Type *clang_type = enum_qual_type.getTypePtr();
8923 const clang::Type *clang_type = enum_qual_type.getTypePtr();
9016 case clang::Type::Record:
9167 case clang::Type::Enum:
9191 case clang::Type::ConstantArray: {
9197 const clang::Type *canonical_type =
9265 case clang::Type::Typedef: {
9293 case clang::Type::Auto: {
9319 case clang::Type::Elaborated: {
9345 case clang::Type::Paren: {
9475 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
9477 if (type_class == clang::Type::Elaborated) {
9484 case clang::Type::Typedef: {
9509 case clang::Type::Enum:
9649 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
9651 case clang::Type::ObjCObject:
9652 case clang::Type::ObjCInterface: {
9668 case clang::Type::Typedef: {
9682 case clang::Type::Auto:
9689 case clang::Type::Elaborated:
9696 case clang::Type::Paren:
9703 case clang::Type::Record: {
9746 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
9748 case clang::Type::Record: {
9755 case clang::Type::Enum: {
9763 case clang::Type::ObjCObject:
9764 case clang::Type::ObjCInterface: {
9778 case clang::Type::Typedef:
9786 case clang::Type::Auto:
9793 case clang::Type::Elaborated:
9800 case clang::Type::Paren:
tools/lldb/source/Symbol/ClangASTImporter.cpp 414 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
416 case clang::Type::Record: {
425 case clang::Type::Enum: {
434 case clang::Type::ObjCObject:
435 case clang::Type::ObjCInterface: {
450 case clang::Type::Typedef:
457 case clang::Type::Auto:
463 case clang::Type::Elaborated:
469 case clang::Type::Paren:
490 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
492 case clang::Type::Record: {
501 case clang::Type::Enum: {
510 case clang::Type::ObjCObject:
511 case clang::Type::ObjCInterface: {
526 case clang::Type::Typedef:
533 case clang::Type::Auto:
539 case clang::Type::Elaborated:
545 case clang::Type::Paren:
tools/lldb/unittests/Symbol/TestClangASTContext.cpp 186 const clang::Type *type_ptr = qtype.getTypePtr();
usr/include/c++/7.4.0/type_traits 1558 { typedef _Tp type; };
1983 { typedef _Up type; };