Type.cpp revision 199482
1//===--- Type.cpp - Type representation and manipulation ------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements type-related functionality. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/Type.h" 16#include "clang/AST/DeclCXX.h" 17#include "clang/AST/DeclObjC.h" 18#include "clang/AST/DeclTemplate.h" 19#include "clang/AST/Expr.h" 20#include "clang/AST/PrettyPrinter.h" 21#include "llvm/ADT/StringExtras.h" 22#include "llvm/Support/raw_ostream.h" 23using namespace clang; 24 25bool QualType::isConstant(QualType T, ASTContext &Ctx) { 26 if (T.isConstQualified()) 27 return true; 28 29 if (const ArrayType *AT = Ctx.getAsArrayType(T)) 30 return AT->getElementType().isConstant(Ctx); 31 32 return false; 33} 34 35void Type::Destroy(ASTContext& C) { 36 this->~Type(); 37 C.Deallocate(this); 38} 39 40void VariableArrayType::Destroy(ASTContext& C) { 41 if (SizeExpr) 42 SizeExpr->Destroy(C); 43 this->~VariableArrayType(); 44 C.Deallocate(this); 45} 46 47void DependentSizedArrayType::Destroy(ASTContext& C) { 48 // FIXME: Resource contention like in ConstantArrayWithExprType ? 49 // May crash, depending on platform or a particular build. 50 // SizeExpr->Destroy(C); 51 this->~DependentSizedArrayType(); 52 C.Deallocate(this); 53} 54 55void DependentSizedArrayType::Profile(llvm::FoldingSetNodeID &ID, 56 ASTContext &Context, 57 QualType ET, 58 ArraySizeModifier SizeMod, 59 unsigned TypeQuals, 60 Expr *E) { 61 ID.AddPointer(ET.getAsOpaquePtr()); 62 ID.AddInteger(SizeMod); 63 ID.AddInteger(TypeQuals); 64 E->Profile(ID, Context, true); 65} 66 67void 68DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID, 69 ASTContext &Context, 70 QualType ElementType, Expr *SizeExpr) { 71 ID.AddPointer(ElementType.getAsOpaquePtr()); 72 SizeExpr->Profile(ID, Context, true); 73} 74 75void DependentSizedExtVectorType::Destroy(ASTContext& C) { 76 // FIXME: Deallocate size expression, once we're cloning properly. 77// if (SizeExpr) 78// SizeExpr->Destroy(C); 79 this->~DependentSizedExtVectorType(); 80 C.Deallocate(this); 81} 82 83/// getArrayElementTypeNoTypeQual - If this is an array type, return the 84/// element type of the array, potentially with type qualifiers missing. 85/// This method should never be used when type qualifiers are meaningful. 86const Type *Type::getArrayElementTypeNoTypeQual() const { 87 // If this is directly an array type, return it. 88 if (const ArrayType *ATy = dyn_cast<ArrayType>(this)) 89 return ATy->getElementType().getTypePtr(); 90 91 // If the canonical form of this type isn't the right kind, reject it. 92 if (!isa<ArrayType>(CanonicalType)) 93 return 0; 94 95 // If this is a typedef for an array type, strip the typedef off without 96 // losing all typedef information. 97 return cast<ArrayType>(getUnqualifiedDesugaredType()) 98 ->getElementType().getTypePtr(); 99} 100 101/// \brief Retrieve the unqualified variant of the given type, removing as 102/// little sugar as possible. 103/// 104/// This routine looks through various kinds of sugar to find the 105/// least-desuraged type that is unqualified. For example, given: 106/// 107/// \code 108/// typedef int Integer; 109/// typedef const Integer CInteger; 110/// typedef CInteger DifferenceType; 111/// \endcode 112/// 113/// Executing \c getUnqualifiedTypeSlow() on the type \c DifferenceType will 114/// desugar until we hit the type \c Integer, which has no qualifiers on it. 115QualType QualType::getUnqualifiedTypeSlow() const { 116 QualType Cur = *this; 117 while (true) { 118 if (!Cur.hasQualifiers()) 119 return Cur; 120 121 const Type *CurTy = Cur.getTypePtr(); 122 switch (CurTy->getTypeClass()) { 123#define ABSTRACT_TYPE(Class, Parent) 124#define TYPE(Class, Parent) \ 125 case Type::Class: { \ 126 const Class##Type *Ty = cast<Class##Type>(CurTy); \ 127 if (!Ty->isSugared()) \ 128 return Cur.getLocalUnqualifiedType(); \ 129 Cur = Ty->desugar(); \ 130 break; \ 131 } 132#include "clang/AST/TypeNodes.def" 133 } 134 } 135 136 return Cur.getUnqualifiedType(); 137} 138 139/// getDesugaredType - Return the specified type with any "sugar" removed from 140/// the type. This takes off typedefs, typeof's etc. If the outer level of 141/// the type is already concrete, it returns it unmodified. This is similar 142/// to getting the canonical type, but it doesn't remove *all* typedefs. For 143/// example, it returns "T*" as "T*", (not as "int*"), because the pointer is 144/// concrete. 145QualType QualType::getDesugaredType(QualType T) { 146 QualifierCollector Qs; 147 148 QualType Cur = T; 149 while (true) { 150 const Type *CurTy = Qs.strip(Cur); 151 switch (CurTy->getTypeClass()) { 152#define ABSTRACT_TYPE(Class, Parent) 153#define TYPE(Class, Parent) \ 154 case Type::Class: { \ 155 const Class##Type *Ty = cast<Class##Type>(CurTy); \ 156 if (!Ty->isSugared()) \ 157 return Qs.apply(Cur); \ 158 Cur = Ty->desugar(); \ 159 break; \ 160 } 161#include "clang/AST/TypeNodes.def" 162 } 163 } 164} 165 166/// getUnqualifiedDesugaredType - Pull any qualifiers and syntactic 167/// sugar off the given type. This should produce an object of the 168/// same dynamic type as the canonical type. 169const Type *Type::getUnqualifiedDesugaredType() const { 170 const Type *Cur = this; 171 172 while (true) { 173 switch (Cur->getTypeClass()) { 174#define ABSTRACT_TYPE(Class, Parent) 175#define TYPE(Class, Parent) \ 176 case Class: { \ 177 const Class##Type *Ty = cast<Class##Type>(Cur); \ 178 if (!Ty->isSugared()) return Cur; \ 179 Cur = Ty->desugar().getTypePtr(); \ 180 break; \ 181 } 182#include "clang/AST/TypeNodes.def" 183 } 184 } 185} 186 187/// isVoidType - Helper method to determine if this is the 'void' type. 188bool Type::isVoidType() const { 189 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 190 return BT->getKind() == BuiltinType::Void; 191 return false; 192} 193 194bool Type::isObjectType() const { 195 if (isa<FunctionType>(CanonicalType) || isa<ReferenceType>(CanonicalType) || 196 isa<IncompleteArrayType>(CanonicalType) || isVoidType()) 197 return false; 198 return true; 199} 200 201bool Type::isDerivedType() const { 202 switch (CanonicalType->getTypeClass()) { 203 case Pointer: 204 case VariableArray: 205 case ConstantArray: 206 case IncompleteArray: 207 case FunctionProto: 208 case FunctionNoProto: 209 case LValueReference: 210 case RValueReference: 211 case Record: 212 return true; 213 default: 214 return false; 215 } 216} 217 218bool Type::isClassType() const { 219 if (const RecordType *RT = getAs<RecordType>()) 220 return RT->getDecl()->isClass(); 221 return false; 222} 223bool Type::isStructureType() const { 224 if (const RecordType *RT = getAs<RecordType>()) 225 return RT->getDecl()->isStruct(); 226 return false; 227} 228bool Type::isVoidPointerType() const { 229 if (const PointerType *PT = getAs<PointerType>()) 230 return PT->getPointeeType()->isVoidType(); 231 return false; 232} 233 234bool Type::isUnionType() const { 235 if (const RecordType *RT = getAs<RecordType>()) 236 return RT->getDecl()->isUnion(); 237 return false; 238} 239 240bool Type::isComplexType() const { 241 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 242 return CT->getElementType()->isFloatingType(); 243 return false; 244} 245 246bool Type::isComplexIntegerType() const { 247 // Check for GCC complex integer extension. 248 return getAsComplexIntegerType(); 249} 250 251const ComplexType *Type::getAsComplexIntegerType() const { 252 if (const ComplexType *Complex = getAs<ComplexType>()) 253 if (Complex->getElementType()->isIntegerType()) 254 return Complex; 255 return 0; 256} 257 258QualType Type::getPointeeType() const { 259 if (const PointerType *PT = getAs<PointerType>()) 260 return PT->getPointeeType(); 261 if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) 262 return OPT->getPointeeType(); 263 if (const BlockPointerType *BPT = getAs<BlockPointerType>()) 264 return BPT->getPointeeType(); 265 if (const ReferenceType *RT = getAs<ReferenceType>()) 266 return RT->getPointeeType(); 267 return QualType(); 268} 269 270/// isVariablyModifiedType (C99 6.7.5p3) - Return true for variable length 271/// array types and types that contain variable array types in their 272/// declarator 273bool Type::isVariablyModifiedType() const { 274 // A VLA is a variably modified type. 275 if (isVariableArrayType()) 276 return true; 277 278 // An array can contain a variably modified type 279 if (const Type *T = getArrayElementTypeNoTypeQual()) 280 return T->isVariablyModifiedType(); 281 282 // A pointer can point to a variably modified type. 283 // Also, C++ references and member pointers can point to a variably modified 284 // type, where VLAs appear as an extension to C++, and should be treated 285 // correctly. 286 if (const PointerType *PT = getAs<PointerType>()) 287 return PT->getPointeeType()->isVariablyModifiedType(); 288 if (const ReferenceType *RT = getAs<ReferenceType>()) 289 return RT->getPointeeType()->isVariablyModifiedType(); 290 if (const MemberPointerType *PT = getAs<MemberPointerType>()) 291 return PT->getPointeeType()->isVariablyModifiedType(); 292 293 // A function can return a variably modified type 294 // This one isn't completely obvious, but it follows from the 295 // definition in C99 6.7.5p3. Because of this rule, it's 296 // illegal to declare a function returning a variably modified type. 297 if (const FunctionType *FT = getAs<FunctionType>()) 298 return FT->getResultType()->isVariablyModifiedType(); 299 300 return false; 301} 302 303const RecordType *Type::getAsStructureType() const { 304 // If this is directly a structure type, return it. 305 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 306 if (RT->getDecl()->isStruct()) 307 return RT; 308 } 309 310 // If the canonical form of this type isn't the right kind, reject it. 311 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 312 if (!RT->getDecl()->isStruct()) 313 return 0; 314 315 // If this is a typedef for a structure type, strip the typedef off without 316 // losing all typedef information. 317 return cast<RecordType>(getUnqualifiedDesugaredType()); 318 } 319 return 0; 320} 321 322const RecordType *Type::getAsUnionType() const { 323 // If this is directly a union type, return it. 324 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 325 if (RT->getDecl()->isUnion()) 326 return RT; 327 } 328 329 // If the canonical form of this type isn't the right kind, reject it. 330 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 331 if (!RT->getDecl()->isUnion()) 332 return 0; 333 334 // If this is a typedef for a union type, strip the typedef off without 335 // losing all typedef information. 336 return cast<RecordType>(getUnqualifiedDesugaredType()); 337 } 338 339 return 0; 340} 341 342const ObjCInterfaceType *Type::getAsObjCQualifiedInterfaceType() const { 343 // There is no sugar for ObjCInterfaceType's, just return the canonical 344 // type pointer if it is the right class. There is no typedef information to 345 // return and these cannot be Address-space qualified. 346 if (const ObjCInterfaceType *OIT = getAs<ObjCInterfaceType>()) 347 if (OIT->getNumProtocols()) 348 return OIT; 349 return 0; 350} 351 352bool Type::isObjCQualifiedInterfaceType() const { 353 return getAsObjCQualifiedInterfaceType() != 0; 354} 355 356const ObjCObjectPointerType *Type::getAsObjCQualifiedIdType() const { 357 // There is no sugar for ObjCQualifiedIdType's, just return the canonical 358 // type pointer if it is the right class. 359 if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) { 360 if (OPT->isObjCQualifiedIdType()) 361 return OPT; 362 } 363 return 0; 364} 365 366const ObjCObjectPointerType *Type::getAsObjCInterfacePointerType() const { 367 if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) { 368 if (OPT->getInterfaceType()) 369 return OPT; 370 } 371 return 0; 372} 373 374const CXXRecordDecl *Type::getCXXRecordDeclForPointerType() const { 375 if (const PointerType *PT = getAs<PointerType>()) 376 if (const RecordType *RT = PT->getPointeeType()->getAs<RecordType>()) 377 return dyn_cast<CXXRecordDecl>(RT->getDecl()); 378 return 0; 379} 380 381bool Type::isIntegerType() const { 382 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 383 return BT->getKind() >= BuiltinType::Bool && 384 BT->getKind() <= BuiltinType::Int128; 385 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 386 // Incomplete enum types are not treated as integer types. 387 // FIXME: In C++, enum types are never integer types. 388 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 389 return true; 390 if (isa<FixedWidthIntType>(CanonicalType)) 391 return true; 392 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 393 return VT->getElementType()->isIntegerType(); 394 return false; 395} 396 397bool Type::isIntegralType() const { 398 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 399 return BT->getKind() >= BuiltinType::Bool && 400 BT->getKind() <= BuiltinType::LongLong; 401 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 402 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 403 return true; // Complete enum types are integral. 404 // FIXME: In C++, enum types are never integral. 405 if (isa<FixedWidthIntType>(CanonicalType)) 406 return true; 407 return false; 408} 409 410bool Type::isEnumeralType() const { 411 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 412 return TT->getDecl()->isEnum(); 413 return false; 414} 415 416bool Type::isBooleanType() const { 417 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 418 return BT->getKind() == BuiltinType::Bool; 419 return false; 420} 421 422bool Type::isCharType() const { 423 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 424 return BT->getKind() == BuiltinType::Char_U || 425 BT->getKind() == BuiltinType::UChar || 426 BT->getKind() == BuiltinType::Char_S || 427 BT->getKind() == BuiltinType::SChar; 428 return false; 429} 430 431bool Type::isWideCharType() const { 432 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 433 return BT->getKind() == BuiltinType::WChar; 434 return false; 435} 436 437/// isSignedIntegerType - Return true if this is an integer type that is 438/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], 439/// an enum decl which has a signed representation, or a vector of signed 440/// integer element type. 441bool Type::isSignedIntegerType() const { 442 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 443 return BT->getKind() >= BuiltinType::Char_S && 444 BT->getKind() <= BuiltinType::LongLong; 445 } 446 447 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 448 return ET->getDecl()->getIntegerType()->isSignedIntegerType(); 449 450 if (const FixedWidthIntType *FWIT = 451 dyn_cast<FixedWidthIntType>(CanonicalType)) 452 return FWIT->isSigned(); 453 454 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 455 return VT->getElementType()->isSignedIntegerType(); 456 return false; 457} 458 459/// isUnsignedIntegerType - Return true if this is an integer type that is 460/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum 461/// decl which has an unsigned representation, or a vector of unsigned integer 462/// element type. 463bool Type::isUnsignedIntegerType() const { 464 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 465 return BT->getKind() >= BuiltinType::Bool && 466 BT->getKind() <= BuiltinType::UInt128; 467 } 468 469 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 470 return ET->getDecl()->getIntegerType()->isUnsignedIntegerType(); 471 472 if (const FixedWidthIntType *FWIT = 473 dyn_cast<FixedWidthIntType>(CanonicalType)) 474 return !FWIT->isSigned(); 475 476 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 477 return VT->getElementType()->isUnsignedIntegerType(); 478 return false; 479} 480 481bool Type::isFloatingType() const { 482 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 483 return BT->getKind() >= BuiltinType::Float && 484 BT->getKind() <= BuiltinType::LongDouble; 485 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 486 return CT->getElementType()->isFloatingType(); 487 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 488 return VT->getElementType()->isFloatingType(); 489 return false; 490} 491 492bool Type::isRealFloatingType() const { 493 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 494 return BT->isFloatingPoint(); 495 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 496 return VT->getElementType()->isRealFloatingType(); 497 return false; 498} 499 500bool Type::isRealType() const { 501 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 502 return BT->getKind() >= BuiltinType::Bool && 503 BT->getKind() <= BuiltinType::LongDouble; 504 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 505 return TT->getDecl()->isEnum() && TT->getDecl()->isDefinition(); 506 if (isa<FixedWidthIntType>(CanonicalType)) 507 return true; 508 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 509 return VT->getElementType()->isRealType(); 510 return false; 511} 512 513bool Type::isArithmeticType() const { 514 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 515 return BT->getKind() >= BuiltinType::Bool && 516 BT->getKind() <= BuiltinType::LongDouble; 517 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 518 // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2). 519 // If a body isn't seen by the time we get here, return false. 520 return ET->getDecl()->isDefinition(); 521 if (isa<FixedWidthIntType>(CanonicalType)) 522 return true; 523 return isa<ComplexType>(CanonicalType) || isa<VectorType>(CanonicalType); 524} 525 526bool Type::isScalarType() const { 527 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 528 return BT->getKind() != BuiltinType::Void; 529 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) { 530 // Enums are scalar types, but only if they are defined. Incomplete enums 531 // are not treated as scalar types. 532 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 533 return true; 534 return false; 535 } 536 if (isa<FixedWidthIntType>(CanonicalType)) 537 return true; 538 return isa<PointerType>(CanonicalType) || 539 isa<BlockPointerType>(CanonicalType) || 540 isa<MemberPointerType>(CanonicalType) || 541 isa<ComplexType>(CanonicalType) || 542 isa<ObjCObjectPointerType>(CanonicalType); 543} 544 545/// \brief Determines whether the type is a C++ aggregate type or C 546/// aggregate or union type. 547/// 548/// An aggregate type is an array or a class type (struct, union, or 549/// class) that has no user-declared constructors, no private or 550/// protected non-static data members, no base classes, and no virtual 551/// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type 552/// subsumes the notion of C aggregates (C99 6.2.5p21) because it also 553/// includes union types. 554bool Type::isAggregateType() const { 555 if (const RecordType *Record = dyn_cast<RecordType>(CanonicalType)) { 556 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl())) 557 return ClassDecl->isAggregate(); 558 559 return true; 560 } 561 562 return isa<ArrayType>(CanonicalType); 563} 564 565/// isConstantSizeType - Return true if this is not a variable sized type, 566/// according to the rules of C99 6.7.5p3. It is not legal to call this on 567/// incomplete types or dependent types. 568bool Type::isConstantSizeType() const { 569 assert(!isIncompleteType() && "This doesn't make sense for incomplete types"); 570 assert(!isDependentType() && "This doesn't make sense for dependent types"); 571 // The VAT must have a size, as it is known to be complete. 572 return !isa<VariableArrayType>(CanonicalType); 573} 574 575/// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1) 576/// - a type that can describe objects, but which lacks information needed to 577/// determine its size. 578bool Type::isIncompleteType() const { 579 switch (CanonicalType->getTypeClass()) { 580 default: return false; 581 case Builtin: 582 // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never 583 // be completed. 584 return isVoidType(); 585 case Record: 586 case Enum: 587 // A tagged type (struct/union/enum/class) is incomplete if the decl is a 588 // forward declaration, but not a full definition (C99 6.2.5p22). 589 return !cast<TagType>(CanonicalType)->getDecl()->isDefinition(); 590 case ConstantArray: 591 // An array is incomplete if its element type is incomplete 592 // (C++ [dcl.array]p1). 593 // We don't handle variable arrays (they're not allowed in C++) or 594 // dependent-sized arrays (dependent types are never treated as incomplete). 595 return cast<ArrayType>(CanonicalType)->getElementType()->isIncompleteType(); 596 case IncompleteArray: 597 // An array of unknown size is an incomplete type (C99 6.2.5p22). 598 return true; 599 case ObjCInterface: 600 // ObjC interfaces are incomplete if they are @class, not @interface. 601 return cast<ObjCInterfaceType>(this)->getDecl()->isForwardDecl(); 602 } 603} 604 605/// isPODType - Return true if this is a plain-old-data type (C++ 3.9p10) 606bool Type::isPODType() const { 607 // The compiler shouldn't query this for incomplete types, but the user might. 608 // We return false for that case. 609 if (isIncompleteType()) 610 return false; 611 612 switch (CanonicalType->getTypeClass()) { 613 // Everything not explicitly mentioned is not POD. 614 default: return false; 615 case VariableArray: 616 case ConstantArray: 617 // IncompleteArray is caught by isIncompleteType() above. 618 return cast<ArrayType>(CanonicalType)->getElementType()->isPODType(); 619 620 case Builtin: 621 case Complex: 622 case Pointer: 623 case MemberPointer: 624 case Vector: 625 case ExtVector: 626 case ObjCObjectPointer: 627 return true; 628 629 case Enum: 630 return true; 631 632 case Record: 633 if (CXXRecordDecl *ClassDecl 634 = dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl())) 635 return ClassDecl->isPOD(); 636 637 // C struct/union is POD. 638 return true; 639 } 640} 641 642bool Type::isPromotableIntegerType() const { 643 if (const BuiltinType *BT = getAs<BuiltinType>()) 644 switch (BT->getKind()) { 645 case BuiltinType::Bool: 646 case BuiltinType::Char_S: 647 case BuiltinType::Char_U: 648 case BuiltinType::SChar: 649 case BuiltinType::UChar: 650 case BuiltinType::Short: 651 case BuiltinType::UShort: 652 return true; 653 default: 654 return false; 655 } 656 return false; 657} 658 659bool Type::isNullPtrType() const { 660 if (const BuiltinType *BT = getAs<BuiltinType>()) 661 return BT->getKind() == BuiltinType::NullPtr; 662 return false; 663} 664 665bool Type::isSpecifierType() const { 666 // Note that this intentionally does not use the canonical type. 667 switch (getTypeClass()) { 668 case Builtin: 669 case Record: 670 case Enum: 671 case Typedef: 672 case Complex: 673 case TypeOfExpr: 674 case TypeOf: 675 case TemplateTypeParm: 676 case SubstTemplateTypeParm: 677 case TemplateSpecialization: 678 case QualifiedName: 679 case Typename: 680 case ObjCInterface: 681 case ObjCObjectPointer: 682 return true; 683 default: 684 return false; 685 } 686} 687 688const char *Type::getTypeClassName() const { 689 switch (TC) { 690 default: assert(0 && "Type class not in TypeNodes.def!"); 691#define ABSTRACT_TYPE(Derived, Base) 692#define TYPE(Derived, Base) case Derived: return #Derived; 693#include "clang/AST/TypeNodes.def" 694 } 695} 696 697const char *BuiltinType::getName(const LangOptions &LO) const { 698 switch (getKind()) { 699 default: assert(0 && "Unknown builtin type!"); 700 case Void: return "void"; 701 case Bool: return LO.Bool ? "bool" : "_Bool"; 702 case Char_S: return "char"; 703 case Char_U: return "char"; 704 case SChar: return "signed char"; 705 case Short: return "short"; 706 case Int: return "int"; 707 case Long: return "long"; 708 case LongLong: return "long long"; 709 case Int128: return "__int128_t"; 710 case UChar: return "unsigned char"; 711 case UShort: return "unsigned short"; 712 case UInt: return "unsigned int"; 713 case ULong: return "unsigned long"; 714 case ULongLong: return "unsigned long long"; 715 case UInt128: return "__uint128_t"; 716 case Float: return "float"; 717 case Double: return "double"; 718 case LongDouble: return "long double"; 719 case WChar: return "wchar_t"; 720 case Char16: return "char16_t"; 721 case Char32: return "char32_t"; 722 case NullPtr: return "nullptr_t"; 723 case Overload: return "<overloaded function type>"; 724 case Dependent: return "<dependent type>"; 725 case UndeducedAuto: return "auto"; 726 case ObjCId: return "id"; 727 case ObjCClass: return "Class"; 728 } 729} 730 731void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result, 732 arg_type_iterator ArgTys, 733 unsigned NumArgs, bool isVariadic, 734 unsigned TypeQuals, bool hasExceptionSpec, 735 bool anyExceptionSpec, unsigned NumExceptions, 736 exception_iterator Exs, bool NoReturn) { 737 ID.AddPointer(Result.getAsOpaquePtr()); 738 for (unsigned i = 0; i != NumArgs; ++i) 739 ID.AddPointer(ArgTys[i].getAsOpaquePtr()); 740 ID.AddInteger(isVariadic); 741 ID.AddInteger(TypeQuals); 742 ID.AddInteger(hasExceptionSpec); 743 if (hasExceptionSpec) { 744 ID.AddInteger(anyExceptionSpec); 745 for (unsigned i = 0; i != NumExceptions; ++i) 746 ID.AddPointer(Exs[i].getAsOpaquePtr()); 747 } 748 ID.AddInteger(NoReturn); 749} 750 751void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID) { 752 Profile(ID, getResultType(), arg_type_begin(), NumArgs, isVariadic(), 753 getTypeQuals(), hasExceptionSpec(), hasAnyExceptionSpec(), 754 getNumExceptions(), exception_begin(), getNoReturnAttr()); 755} 756 757void ObjCObjectPointerType::Profile(llvm::FoldingSetNodeID &ID, 758 QualType OIT, ObjCProtocolDecl **protocols, 759 unsigned NumProtocols) { 760 ID.AddPointer(OIT.getAsOpaquePtr()); 761 for (unsigned i = 0; i != NumProtocols; i++) 762 ID.AddPointer(protocols[i]); 763} 764 765void ObjCObjectPointerType::Profile(llvm::FoldingSetNodeID &ID) { 766 if (getNumProtocols()) 767 Profile(ID, getPointeeType(), &Protocols[0], getNumProtocols()); 768 else 769 Profile(ID, getPointeeType(), 0, 0); 770} 771 772/// LookThroughTypedefs - Return the ultimate type this typedef corresponds to 773/// potentially looking through *all* consequtive typedefs. This returns the 774/// sum of the type qualifiers, so if you have: 775/// typedef const int A; 776/// typedef volatile A B; 777/// looking through the typedefs for B will give you "const volatile A". 778/// 779QualType TypedefType::LookThroughTypedefs() const { 780 // Usually, there is only a single level of typedefs, be fast in that case. 781 QualType FirstType = getDecl()->getUnderlyingType(); 782 if (!isa<TypedefType>(FirstType)) 783 return FirstType; 784 785 // Otherwise, do the fully general loop. 786 QualifierCollector Qs; 787 788 QualType CurType; 789 const TypedefType *TDT = this; 790 do { 791 CurType = TDT->getDecl()->getUnderlyingType(); 792 TDT = dyn_cast<TypedefType>(Qs.strip(CurType)); 793 } while (TDT); 794 795 return Qs.apply(CurType); 796} 797 798QualType TypedefType::desugar() const { 799 return getDecl()->getUnderlyingType(); 800} 801 802TypeOfExprType::TypeOfExprType(Expr *E, QualType can) 803 : Type(TypeOfExpr, can, E->isTypeDependent()), TOExpr(E) { 804} 805 806QualType TypeOfExprType::desugar() const { 807 return getUnderlyingExpr()->getType(); 808} 809 810void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID, 811 ASTContext &Context, Expr *E) { 812 E->Profile(ID, Context, true); 813} 814 815DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can) 816 : Type(Decltype, can, E->isTypeDependent()), E(E), 817 UnderlyingType(underlyingType) { 818} 819 820DependentDecltypeType::DependentDecltypeType(ASTContext &Context, Expr *E) 821 : DecltypeType(E, Context.DependentTy), Context(Context) { } 822 823void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID, 824 ASTContext &Context, Expr *E) { 825 E->Profile(ID, Context, true); 826} 827 828TagType::TagType(TypeClass TC, TagDecl *D, QualType can) 829 : Type(TC, can, D->isDependentType()), decl(D, 0) {} 830 831bool RecordType::classof(const TagType *TT) { 832 return isa<RecordDecl>(TT->getDecl()); 833} 834 835bool EnumType::classof(const TagType *TT) { 836 return isa<EnumDecl>(TT->getDecl()); 837} 838 839static bool isDependent(const TemplateArgument &Arg) { 840 switch (Arg.getKind()) { 841 case TemplateArgument::Null: 842 assert(false && "Should not have a NULL template argument"); 843 return false; 844 845 case TemplateArgument::Type: 846 return Arg.getAsType()->isDependentType(); 847 848 case TemplateArgument::Template: 849 return Arg.getAsTemplate().isDependent(); 850 851 case TemplateArgument::Declaration: 852 case TemplateArgument::Integral: 853 // Never dependent 854 return false; 855 856 case TemplateArgument::Expression: 857 return (Arg.getAsExpr()->isTypeDependent() || 858 Arg.getAsExpr()->isValueDependent()); 859 860 case TemplateArgument::Pack: 861 assert(0 && "FIXME: Implement!"); 862 return false; 863 } 864 865 return false; 866} 867 868bool TemplateSpecializationType:: 869anyDependentTemplateArguments(const TemplateArgumentLoc *Args, unsigned N) { 870 for (unsigned i = 0; i != N; ++i) 871 if (isDependent(Args[i].getArgument())) 872 return true; 873 return false; 874} 875 876bool TemplateSpecializationType:: 877anyDependentTemplateArguments(const TemplateArgument *Args, unsigned N) { 878 for (unsigned i = 0; i != N; ++i) 879 if (isDependent(Args[i])) 880 return true; 881 return false; 882} 883 884TemplateSpecializationType:: 885TemplateSpecializationType(ASTContext &Context, TemplateName T, 886 const TemplateArgument *Args, 887 unsigned NumArgs, QualType Canon) 888 : Type(TemplateSpecialization, 889 Canon.isNull()? QualType(this, 0) : Canon, 890 T.isDependent() || anyDependentTemplateArguments(Args, NumArgs)), 891 Context(Context), 892 Template(T), NumArgs(NumArgs) { 893 assert((!Canon.isNull() || 894 T.isDependent() || anyDependentTemplateArguments(Args, NumArgs)) && 895 "No canonical type for non-dependent class template specialization"); 896 897 TemplateArgument *TemplateArgs 898 = reinterpret_cast<TemplateArgument *>(this + 1); 899 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) 900 new (&TemplateArgs[Arg]) TemplateArgument(Args[Arg]); 901} 902 903void TemplateSpecializationType::Destroy(ASTContext& C) { 904 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) { 905 // FIXME: Not all expressions get cloned, so we can't yet perform 906 // this destruction. 907 // if (Expr *E = getArg(Arg).getAsExpr()) 908 // E->Destroy(C); 909 } 910} 911 912TemplateSpecializationType::iterator 913TemplateSpecializationType::end() const { 914 return begin() + getNumArgs(); 915} 916 917const TemplateArgument & 918TemplateSpecializationType::getArg(unsigned Idx) const { 919 assert(Idx < getNumArgs() && "Template argument out of range"); 920 return getArgs()[Idx]; 921} 922 923void 924TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID, 925 TemplateName T, 926 const TemplateArgument *Args, 927 unsigned NumArgs, 928 ASTContext &Context) { 929 T.Profile(ID); 930 for (unsigned Idx = 0; Idx < NumArgs; ++Idx) 931 Args[Idx].Profile(ID, Context); 932} 933 934QualType QualifierCollector::apply(QualType QT) const { 935 if (!hasNonFastQualifiers()) 936 return QT.withFastQualifiers(getFastQualifiers()); 937 938 assert(Context && "extended qualifiers but no context!"); 939 return Context->getQualifiedType(QT, *this); 940} 941 942QualType QualifierCollector::apply(const Type *T) const { 943 if (!hasNonFastQualifiers()) 944 return QualType(T, getFastQualifiers()); 945 946 assert(Context && "extended qualifiers but no context!"); 947 return Context->getQualifiedType(T, *this); 948} 949 950void ObjCInterfaceType::Profile(llvm::FoldingSetNodeID &ID, 951 const ObjCInterfaceDecl *Decl, 952 ObjCProtocolDecl **protocols, 953 unsigned NumProtocols) { 954 ID.AddPointer(Decl); 955 for (unsigned i = 0; i != NumProtocols; i++) 956 ID.AddPointer(protocols[i]); 957} 958 959void ObjCInterfaceType::Profile(llvm::FoldingSetNodeID &ID) { 960 if (getNumProtocols()) 961 Profile(ID, getDecl(), &Protocols[0], getNumProtocols()); 962 else 963 Profile(ID, getDecl(), 0, 0); 964} 965