Type.cpp revision 198893
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/// getDesugaredType - Return the specified type with any "sugar" removed from 102/// the type. This takes off typedefs, typeof's etc. If the outer level of 103/// the type is already concrete, it returns it unmodified. This is similar 104/// to getting the canonical type, but it doesn't remove *all* typedefs. For 105/// example, it returns "T*" as "T*", (not as "int*"), because the pointer is 106/// concrete. 107QualType QualType::getDesugaredType(QualType T) { 108 QualifierCollector Qs; 109 110 QualType Cur = T; 111 while (true) { 112 const Type *CurTy = Qs.strip(Cur); 113 switch (CurTy->getTypeClass()) { 114#define ABSTRACT_TYPE(Class, Parent) 115#define TYPE(Class, Parent) \ 116 case Type::Class: { \ 117 const Class##Type *Ty = cast<Class##Type>(CurTy); \ 118 if (!Ty->isSugared()) \ 119 return Qs.apply(Cur); \ 120 Cur = Ty->desugar(); \ 121 break; \ 122 } 123#include "clang/AST/TypeNodes.def" 124 } 125 } 126} 127 128/// getUnqualifiedDesugaredType - Pull any qualifiers and syntactic 129/// sugar off the given type. This should produce an object of the 130/// same dynamic type as the canonical type. 131const Type *Type::getUnqualifiedDesugaredType() const { 132 const Type *Cur = this; 133 134 while (true) { 135 switch (Cur->getTypeClass()) { 136#define ABSTRACT_TYPE(Class, Parent) 137#define TYPE(Class, Parent) \ 138 case Class: { \ 139 const Class##Type *Ty = cast<Class##Type>(Cur); \ 140 if (!Ty->isSugared()) return Cur; \ 141 Cur = Ty->desugar().getTypePtr(); \ 142 break; \ 143 } 144#include "clang/AST/TypeNodes.def" 145 } 146 } 147} 148 149/// isVoidType - Helper method to determine if this is the 'void' type. 150bool Type::isVoidType() const { 151 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 152 return BT->getKind() == BuiltinType::Void; 153 return false; 154} 155 156bool Type::isObjectType() const { 157 if (isa<FunctionType>(CanonicalType) || isa<ReferenceType>(CanonicalType) || 158 isa<IncompleteArrayType>(CanonicalType) || isVoidType()) 159 return false; 160 return true; 161} 162 163bool Type::isDerivedType() const { 164 switch (CanonicalType->getTypeClass()) { 165 case Pointer: 166 case VariableArray: 167 case ConstantArray: 168 case IncompleteArray: 169 case FunctionProto: 170 case FunctionNoProto: 171 case LValueReference: 172 case RValueReference: 173 case Record: 174 return true; 175 default: 176 return false; 177 } 178} 179 180bool Type::isClassType() const { 181 if (const RecordType *RT = getAs<RecordType>()) 182 return RT->getDecl()->isClass(); 183 return false; 184} 185bool Type::isStructureType() const { 186 if (const RecordType *RT = getAs<RecordType>()) 187 return RT->getDecl()->isStruct(); 188 return false; 189} 190bool Type::isVoidPointerType() const { 191 if (const PointerType *PT = getAs<PointerType>()) 192 return PT->getPointeeType()->isVoidType(); 193 return false; 194} 195 196bool Type::isUnionType() const { 197 if (const RecordType *RT = getAs<RecordType>()) 198 return RT->getDecl()->isUnion(); 199 return false; 200} 201 202bool Type::isComplexType() const { 203 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 204 return CT->getElementType()->isFloatingType(); 205 return false; 206} 207 208bool Type::isComplexIntegerType() const { 209 // Check for GCC complex integer extension. 210 return getAsComplexIntegerType(); 211} 212 213const ComplexType *Type::getAsComplexIntegerType() const { 214 if (const ComplexType *Complex = getAs<ComplexType>()) 215 if (Complex->getElementType()->isIntegerType()) 216 return Complex; 217 return 0; 218} 219 220QualType Type::getPointeeType() const { 221 if (const PointerType *PT = getAs<PointerType>()) 222 return PT->getPointeeType(); 223 if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) 224 return OPT->getPointeeType(); 225 if (const BlockPointerType *BPT = getAs<BlockPointerType>()) 226 return BPT->getPointeeType(); 227 if (const ReferenceType *RT = getAs<ReferenceType>()) 228 return RT->getPointeeType(); 229 return QualType(); 230} 231 232/// isVariablyModifiedType (C99 6.7.5p3) - Return true for variable length 233/// array types and types that contain variable array types in their 234/// declarator 235bool Type::isVariablyModifiedType() const { 236 // A VLA is a variably modified type. 237 if (isVariableArrayType()) 238 return true; 239 240 // An array can contain a variably modified type 241 if (const Type *T = getArrayElementTypeNoTypeQual()) 242 return T->isVariablyModifiedType(); 243 244 // A pointer can point to a variably modified type. 245 // Also, C++ references and member pointers can point to a variably modified 246 // type, where VLAs appear as an extension to C++, and should be treated 247 // correctly. 248 if (const PointerType *PT = getAs<PointerType>()) 249 return PT->getPointeeType()->isVariablyModifiedType(); 250 if (const ReferenceType *RT = getAs<ReferenceType>()) 251 return RT->getPointeeType()->isVariablyModifiedType(); 252 if (const MemberPointerType *PT = getAs<MemberPointerType>()) 253 return PT->getPointeeType()->isVariablyModifiedType(); 254 255 // A function can return a variably modified type 256 // This one isn't completely obvious, but it follows from the 257 // definition in C99 6.7.5p3. Because of this rule, it's 258 // illegal to declare a function returning a variably modified type. 259 if (const FunctionType *FT = getAs<FunctionType>()) 260 return FT->getResultType()->isVariablyModifiedType(); 261 262 return false; 263} 264 265const RecordType *Type::getAsStructureType() const { 266 // If this is directly a structure type, return it. 267 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 268 if (RT->getDecl()->isStruct()) 269 return RT; 270 } 271 272 // If the canonical form of this type isn't the right kind, reject it. 273 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 274 if (!RT->getDecl()->isStruct()) 275 return 0; 276 277 // If this is a typedef for a structure type, strip the typedef off without 278 // losing all typedef information. 279 return cast<RecordType>(getUnqualifiedDesugaredType()); 280 } 281 return 0; 282} 283 284const RecordType *Type::getAsUnionType() const { 285 // If this is directly a union type, return it. 286 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 287 if (RT->getDecl()->isUnion()) 288 return RT; 289 } 290 291 // If the canonical form of this type isn't the right kind, reject it. 292 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 293 if (!RT->getDecl()->isUnion()) 294 return 0; 295 296 // If this is a typedef for a union type, strip the typedef off without 297 // losing all typedef information. 298 return cast<RecordType>(getUnqualifiedDesugaredType()); 299 } 300 301 return 0; 302} 303 304const ObjCInterfaceType *Type::getAsObjCQualifiedInterfaceType() const { 305 // There is no sugar for ObjCInterfaceType's, just return the canonical 306 // type pointer if it is the right class. There is no typedef information to 307 // return and these cannot be Address-space qualified. 308 if (const ObjCInterfaceType *OIT = getAs<ObjCInterfaceType>()) 309 if (OIT->getNumProtocols()) 310 return OIT; 311 return 0; 312} 313 314bool Type::isObjCQualifiedInterfaceType() const { 315 return getAsObjCQualifiedInterfaceType() != 0; 316} 317 318const ObjCObjectPointerType *Type::getAsObjCQualifiedIdType() const { 319 // There is no sugar for ObjCQualifiedIdType's, just return the canonical 320 // type pointer if it is the right class. 321 if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) { 322 if (OPT->isObjCQualifiedIdType()) 323 return OPT; 324 } 325 return 0; 326} 327 328const ObjCObjectPointerType *Type::getAsObjCInterfacePointerType() const { 329 if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) { 330 if (OPT->getInterfaceType()) 331 return OPT; 332 } 333 return 0; 334} 335 336const CXXRecordDecl *Type::getCXXRecordDeclForPointerType() const { 337 if (const PointerType *PT = getAs<PointerType>()) 338 if (const RecordType *RT = PT->getPointeeType()->getAs<RecordType>()) 339 return dyn_cast<CXXRecordDecl>(RT->getDecl()); 340 return 0; 341} 342 343bool Type::isIntegerType() const { 344 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 345 return BT->getKind() >= BuiltinType::Bool && 346 BT->getKind() <= BuiltinType::Int128; 347 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 348 // Incomplete enum types are not treated as integer types. 349 // FIXME: In C++, enum types are never integer types. 350 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 351 return true; 352 if (isa<FixedWidthIntType>(CanonicalType)) 353 return true; 354 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 355 return VT->getElementType()->isIntegerType(); 356 return false; 357} 358 359bool Type::isIntegralType() const { 360 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 361 return BT->getKind() >= BuiltinType::Bool && 362 BT->getKind() <= BuiltinType::LongLong; 363 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 364 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 365 return true; // Complete enum types are integral. 366 // FIXME: In C++, enum types are never integral. 367 if (isa<FixedWidthIntType>(CanonicalType)) 368 return true; 369 return false; 370} 371 372bool Type::isEnumeralType() const { 373 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 374 return TT->getDecl()->isEnum(); 375 return false; 376} 377 378bool Type::isBooleanType() const { 379 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 380 return BT->getKind() == BuiltinType::Bool; 381 return false; 382} 383 384bool Type::isCharType() const { 385 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 386 return BT->getKind() == BuiltinType::Char_U || 387 BT->getKind() == BuiltinType::UChar || 388 BT->getKind() == BuiltinType::Char_S || 389 BT->getKind() == BuiltinType::SChar; 390 return false; 391} 392 393bool Type::isWideCharType() const { 394 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 395 return BT->getKind() == BuiltinType::WChar; 396 return false; 397} 398 399/// isSignedIntegerType - Return true if this is an integer type that is 400/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], 401/// an enum decl which has a signed representation, or a vector of signed 402/// integer element type. 403bool Type::isSignedIntegerType() const { 404 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 405 return BT->getKind() >= BuiltinType::Char_S && 406 BT->getKind() <= BuiltinType::LongLong; 407 } 408 409 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 410 return ET->getDecl()->getIntegerType()->isSignedIntegerType(); 411 412 if (const FixedWidthIntType *FWIT = 413 dyn_cast<FixedWidthIntType>(CanonicalType)) 414 return FWIT->isSigned(); 415 416 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 417 return VT->getElementType()->isSignedIntegerType(); 418 return false; 419} 420 421/// isUnsignedIntegerType - Return true if this is an integer type that is 422/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum 423/// decl which has an unsigned representation, or a vector of unsigned integer 424/// element type. 425bool Type::isUnsignedIntegerType() const { 426 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 427 return BT->getKind() >= BuiltinType::Bool && 428 BT->getKind() <= BuiltinType::ULongLong; 429 } 430 431 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 432 return ET->getDecl()->getIntegerType()->isUnsignedIntegerType(); 433 434 if (const FixedWidthIntType *FWIT = 435 dyn_cast<FixedWidthIntType>(CanonicalType)) 436 return !FWIT->isSigned(); 437 438 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 439 return VT->getElementType()->isUnsignedIntegerType(); 440 return false; 441} 442 443bool Type::isFloatingType() const { 444 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 445 return BT->getKind() >= BuiltinType::Float && 446 BT->getKind() <= BuiltinType::LongDouble; 447 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 448 return CT->getElementType()->isFloatingType(); 449 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 450 return VT->getElementType()->isFloatingType(); 451 return false; 452} 453 454bool Type::isRealFloatingType() const { 455 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 456 return BT->getKind() >= BuiltinType::Float && 457 BT->getKind() <= BuiltinType::LongDouble; 458 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 459 return VT->getElementType()->isRealFloatingType(); 460 return false; 461} 462 463bool Type::isRealType() const { 464 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 465 return BT->getKind() >= BuiltinType::Bool && 466 BT->getKind() <= BuiltinType::LongDouble; 467 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 468 return TT->getDecl()->isEnum() && TT->getDecl()->isDefinition(); 469 if (isa<FixedWidthIntType>(CanonicalType)) 470 return true; 471 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 472 return VT->getElementType()->isRealType(); 473 return false; 474} 475 476bool Type::isArithmeticType() const { 477 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 478 return BT->getKind() >= BuiltinType::Bool && 479 BT->getKind() <= BuiltinType::LongDouble; 480 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 481 // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2). 482 // If a body isn't seen by the time we get here, return false. 483 return ET->getDecl()->isDefinition(); 484 if (isa<FixedWidthIntType>(CanonicalType)) 485 return true; 486 return isa<ComplexType>(CanonicalType) || isa<VectorType>(CanonicalType); 487} 488 489bool Type::isScalarType() const { 490 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 491 return BT->getKind() != BuiltinType::Void; 492 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) { 493 // Enums are scalar types, but only if they are defined. Incomplete enums 494 // are not treated as scalar types. 495 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 496 return true; 497 return false; 498 } 499 if (isa<FixedWidthIntType>(CanonicalType)) 500 return true; 501 return isa<PointerType>(CanonicalType) || 502 isa<BlockPointerType>(CanonicalType) || 503 isa<MemberPointerType>(CanonicalType) || 504 isa<ComplexType>(CanonicalType) || 505 isa<ObjCObjectPointerType>(CanonicalType); 506} 507 508/// \brief Determines whether the type is a C++ aggregate type or C 509/// aggregate or union type. 510/// 511/// An aggregate type is an array or a class type (struct, union, or 512/// class) that has no user-declared constructors, no private or 513/// protected non-static data members, no base classes, and no virtual 514/// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type 515/// subsumes the notion of C aggregates (C99 6.2.5p21) because it also 516/// includes union types. 517bool Type::isAggregateType() const { 518 if (const RecordType *Record = dyn_cast<RecordType>(CanonicalType)) { 519 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl())) 520 return ClassDecl->isAggregate(); 521 522 return true; 523 } 524 525 return isa<ArrayType>(CanonicalType); 526} 527 528/// isConstantSizeType - Return true if this is not a variable sized type, 529/// according to the rules of C99 6.7.5p3. It is not legal to call this on 530/// incomplete types or dependent types. 531bool Type::isConstantSizeType() const { 532 assert(!isIncompleteType() && "This doesn't make sense for incomplete types"); 533 assert(!isDependentType() && "This doesn't make sense for dependent types"); 534 // The VAT must have a size, as it is known to be complete. 535 return !isa<VariableArrayType>(CanonicalType); 536} 537 538/// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1) 539/// - a type that can describe objects, but which lacks information needed to 540/// determine its size. 541bool Type::isIncompleteType() const { 542 switch (CanonicalType->getTypeClass()) { 543 default: return false; 544 case Builtin: 545 // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never 546 // be completed. 547 return isVoidType(); 548 case Record: 549 case Enum: 550 // A tagged type (struct/union/enum/class) is incomplete if the decl is a 551 // forward declaration, but not a full definition (C99 6.2.5p22). 552 return !cast<TagType>(CanonicalType)->getDecl()->isDefinition(); 553 case IncompleteArray: 554 // An array of unknown size is an incomplete type (C99 6.2.5p22). 555 return true; 556 case ObjCInterface: 557 // ObjC interfaces are incomplete if they are @class, not @interface. 558 return cast<ObjCInterfaceType>(this)->getDecl()->isForwardDecl(); 559 } 560} 561 562/// isPODType - Return true if this is a plain-old-data type (C++ 3.9p10) 563bool Type::isPODType() const { 564 // The compiler shouldn't query this for incomplete types, but the user might. 565 // We return false for that case. 566 if (isIncompleteType()) 567 return false; 568 569 switch (CanonicalType->getTypeClass()) { 570 // Everything not explicitly mentioned is not POD. 571 default: return false; 572 case VariableArray: 573 case ConstantArray: 574 // IncompleteArray is caught by isIncompleteType() above. 575 return cast<ArrayType>(CanonicalType)->getElementType()->isPODType(); 576 577 case Builtin: 578 case Complex: 579 case Pointer: 580 case MemberPointer: 581 case Vector: 582 case ExtVector: 583 case ObjCObjectPointer: 584 return true; 585 586 case Enum: 587 return true; 588 589 case Record: 590 if (CXXRecordDecl *ClassDecl 591 = dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl())) 592 return ClassDecl->isPOD(); 593 594 // C struct/union is POD. 595 return true; 596 } 597} 598 599bool Type::isPromotableIntegerType() const { 600 if (const BuiltinType *BT = getAs<BuiltinType>()) 601 switch (BT->getKind()) { 602 case BuiltinType::Bool: 603 case BuiltinType::Char_S: 604 case BuiltinType::Char_U: 605 case BuiltinType::SChar: 606 case BuiltinType::UChar: 607 case BuiltinType::Short: 608 case BuiltinType::UShort: 609 return true; 610 default: 611 return false; 612 } 613 return false; 614} 615 616bool Type::isNullPtrType() const { 617 if (const BuiltinType *BT = getAs<BuiltinType>()) 618 return BT->getKind() == BuiltinType::NullPtr; 619 return false; 620} 621 622bool Type::isSpecifierType() const { 623 // Note that this intentionally does not use the canonical type. 624 switch (getTypeClass()) { 625 case Builtin: 626 case Record: 627 case Enum: 628 case Typedef: 629 case Complex: 630 case TypeOfExpr: 631 case TypeOf: 632 case TemplateTypeParm: 633 case SubstTemplateTypeParm: 634 case TemplateSpecialization: 635 case QualifiedName: 636 case Typename: 637 case ObjCInterface: 638 case ObjCObjectPointer: 639 return true; 640 default: 641 return false; 642 } 643} 644 645const char *Type::getTypeClassName() const { 646 switch (TC) { 647 default: assert(0 && "Type class not in TypeNodes.def!"); 648#define ABSTRACT_TYPE(Derived, Base) 649#define TYPE(Derived, Base) case Derived: return #Derived; 650#include "clang/AST/TypeNodes.def" 651 } 652} 653 654const char *BuiltinType::getName(const LangOptions &LO) const { 655 switch (getKind()) { 656 default: assert(0 && "Unknown builtin type!"); 657 case Void: return "void"; 658 case Bool: return LO.Bool ? "bool" : "_Bool"; 659 case Char_S: return "char"; 660 case Char_U: return "char"; 661 case SChar: return "signed char"; 662 case Short: return "short"; 663 case Int: return "int"; 664 case Long: return "long"; 665 case LongLong: return "long long"; 666 case Int128: return "__int128_t"; 667 case UChar: return "unsigned char"; 668 case UShort: return "unsigned short"; 669 case UInt: return "unsigned int"; 670 case ULong: return "unsigned long"; 671 case ULongLong: return "unsigned long long"; 672 case UInt128: return "__uint128_t"; 673 case Float: return "float"; 674 case Double: return "double"; 675 case LongDouble: return "long double"; 676 case WChar: return "wchar_t"; 677 case Char16: return "char16_t"; 678 case Char32: return "char32_t"; 679 case NullPtr: return "nullptr_t"; 680 case Overload: return "<overloaded function type>"; 681 case Dependent: return "<dependent type>"; 682 case UndeducedAuto: return "auto"; 683 case ObjCId: return "id"; 684 case ObjCClass: return "Class"; 685 } 686} 687 688void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result, 689 arg_type_iterator ArgTys, 690 unsigned NumArgs, bool isVariadic, 691 unsigned TypeQuals, bool hasExceptionSpec, 692 bool anyExceptionSpec, unsigned NumExceptions, 693 exception_iterator Exs, bool NoReturn) { 694 ID.AddPointer(Result.getAsOpaquePtr()); 695 for (unsigned i = 0; i != NumArgs; ++i) 696 ID.AddPointer(ArgTys[i].getAsOpaquePtr()); 697 ID.AddInteger(isVariadic); 698 ID.AddInteger(TypeQuals); 699 ID.AddInteger(hasExceptionSpec); 700 if (hasExceptionSpec) { 701 ID.AddInteger(anyExceptionSpec); 702 for (unsigned i = 0; i != NumExceptions; ++i) 703 ID.AddPointer(Exs[i].getAsOpaquePtr()); 704 } 705 ID.AddInteger(NoReturn); 706} 707 708void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID) { 709 Profile(ID, getResultType(), arg_type_begin(), NumArgs, isVariadic(), 710 getTypeQuals(), hasExceptionSpec(), hasAnyExceptionSpec(), 711 getNumExceptions(), exception_begin(), getNoReturnAttr()); 712} 713 714void ObjCObjectPointerType::Profile(llvm::FoldingSetNodeID &ID, 715 QualType OIT, ObjCProtocolDecl **protocols, 716 unsigned NumProtocols) { 717 ID.AddPointer(OIT.getAsOpaquePtr()); 718 for (unsigned i = 0; i != NumProtocols; i++) 719 ID.AddPointer(protocols[i]); 720} 721 722void ObjCObjectPointerType::Profile(llvm::FoldingSetNodeID &ID) { 723 if (getNumProtocols()) 724 Profile(ID, getPointeeType(), &Protocols[0], getNumProtocols()); 725 else 726 Profile(ID, getPointeeType(), 0, 0); 727} 728 729/// LookThroughTypedefs - Return the ultimate type this typedef corresponds to 730/// potentially looking through *all* consequtive typedefs. This returns the 731/// sum of the type qualifiers, so if you have: 732/// typedef const int A; 733/// typedef volatile A B; 734/// looking through the typedefs for B will give you "const volatile A". 735/// 736QualType TypedefType::LookThroughTypedefs() const { 737 // Usually, there is only a single level of typedefs, be fast in that case. 738 QualType FirstType = getDecl()->getUnderlyingType(); 739 if (!isa<TypedefType>(FirstType)) 740 return FirstType; 741 742 // Otherwise, do the fully general loop. 743 QualifierCollector Qs; 744 745 QualType CurType; 746 const TypedefType *TDT = this; 747 do { 748 CurType = TDT->getDecl()->getUnderlyingType(); 749 TDT = dyn_cast<TypedefType>(Qs.strip(CurType)); 750 } while (TDT); 751 752 return Qs.apply(CurType); 753} 754 755QualType TypedefType::desugar() const { 756 return getDecl()->getUnderlyingType(); 757} 758 759TypeOfExprType::TypeOfExprType(Expr *E, QualType can) 760 : Type(TypeOfExpr, can, E->isTypeDependent()), TOExpr(E) { 761} 762 763QualType TypeOfExprType::desugar() const { 764 return getUnderlyingExpr()->getType(); 765} 766 767void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID, 768 ASTContext &Context, Expr *E) { 769 E->Profile(ID, Context, true); 770} 771 772DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can) 773 : Type(Decltype, can, E->isTypeDependent()), E(E), 774 UnderlyingType(underlyingType) { 775} 776 777DependentDecltypeType::DependentDecltypeType(ASTContext &Context, Expr *E) 778 : DecltypeType(E, Context.DependentTy), Context(Context) { } 779 780void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID, 781 ASTContext &Context, Expr *E) { 782 E->Profile(ID, Context, true); 783} 784 785TagType::TagType(TypeClass TC, TagDecl *D, QualType can) 786 : Type(TC, can, D->isDependentType()), decl(D, 0) {} 787 788bool RecordType::classof(const TagType *TT) { 789 return isa<RecordDecl>(TT->getDecl()); 790} 791 792bool EnumType::classof(const TagType *TT) { 793 return isa<EnumDecl>(TT->getDecl()); 794} 795 796static bool isDependent(const TemplateArgument &Arg) { 797 switch (Arg.getKind()) { 798 case TemplateArgument::Null: 799 assert(false && "Should not have a NULL template argument"); 800 return false; 801 802 case TemplateArgument::Type: 803 return Arg.getAsType()->isDependentType(); 804 805 case TemplateArgument::Declaration: 806 case TemplateArgument::Integral: 807 // Never dependent 808 return false; 809 810 case TemplateArgument::Expression: 811 return (Arg.getAsExpr()->isTypeDependent() || 812 Arg.getAsExpr()->isValueDependent()); 813 814 case TemplateArgument::Pack: 815 assert(0 && "FIXME: Implement!"); 816 return false; 817 } 818 819 return false; 820} 821 822bool TemplateSpecializationType:: 823anyDependentTemplateArguments(const TemplateArgumentLoc *Args, unsigned N) { 824 for (unsigned i = 0; i != N; ++i) 825 if (isDependent(Args[i].getArgument())) 826 return true; 827 return false; 828} 829 830bool TemplateSpecializationType:: 831anyDependentTemplateArguments(const TemplateArgument *Args, unsigned N) { 832 for (unsigned i = 0; i != N; ++i) 833 if (isDependent(Args[i])) 834 return true; 835 return false; 836} 837 838TemplateSpecializationType:: 839TemplateSpecializationType(ASTContext &Context, TemplateName T, 840 const TemplateArgument *Args, 841 unsigned NumArgs, QualType Canon) 842 : Type(TemplateSpecialization, 843 Canon.isNull()? QualType(this, 0) : Canon, 844 T.isDependent() || anyDependentTemplateArguments(Args, NumArgs)), 845 Context(Context), 846 Template(T), NumArgs(NumArgs) { 847 assert((!Canon.isNull() || 848 T.isDependent() || anyDependentTemplateArguments(Args, NumArgs)) && 849 "No canonical type for non-dependent class template specialization"); 850 851 TemplateArgument *TemplateArgs 852 = reinterpret_cast<TemplateArgument *>(this + 1); 853 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) 854 new (&TemplateArgs[Arg]) TemplateArgument(Args[Arg]); 855} 856 857void TemplateSpecializationType::Destroy(ASTContext& C) { 858 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) { 859 // FIXME: Not all expressions get cloned, so we can't yet perform 860 // this destruction. 861 // if (Expr *E = getArg(Arg).getAsExpr()) 862 // E->Destroy(C); 863 } 864} 865 866TemplateSpecializationType::iterator 867TemplateSpecializationType::end() const { 868 return begin() + getNumArgs(); 869} 870 871const TemplateArgument & 872TemplateSpecializationType::getArg(unsigned Idx) const { 873 assert(Idx < getNumArgs() && "Template argument out of range"); 874 return getArgs()[Idx]; 875} 876 877void 878TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID, 879 TemplateName T, 880 const TemplateArgument *Args, 881 unsigned NumArgs, 882 ASTContext &Context) { 883 T.Profile(ID); 884 for (unsigned Idx = 0; Idx < NumArgs; ++Idx) 885 Args[Idx].Profile(ID, Context); 886} 887 888QualType QualifierCollector::apply(QualType QT) const { 889 if (!hasNonFastQualifiers()) 890 return QT.withFastQualifiers(getFastQualifiers()); 891 892 assert(Context && "extended qualifiers but no context!"); 893 return Context->getQualifiedType(QT, *this); 894} 895 896QualType QualifierCollector::apply(const Type *T) const { 897 if (!hasNonFastQualifiers()) 898 return QualType(T, getFastQualifiers()); 899 900 assert(Context && "extended qualifiers but no context!"); 901 return Context->getQualifiedType(T, *this); 902} 903 904 905//===----------------------------------------------------------------------===// 906// Type Printing 907//===----------------------------------------------------------------------===// 908 909void QualType::dump(const char *msg) const { 910 std::string R = "identifier"; 911 LangOptions LO; 912 getAsStringInternal(R, PrintingPolicy(LO)); 913 if (msg) 914 fprintf(stderr, "%s: %s\n", msg, R.c_str()); 915 else 916 fprintf(stderr, "%s\n", R.c_str()); 917} 918void QualType::dump() const { 919 dump(""); 920} 921 922void Type::dump() const { 923 std::string S = "identifier"; 924 LangOptions LO; 925 getAsStringInternal(S, PrintingPolicy(LO)); 926 fprintf(stderr, "%s\n", S.c_str()); 927} 928 929 930 931static void AppendTypeQualList(std::string &S, unsigned TypeQuals) { 932 if (TypeQuals & Qualifiers::Const) { 933 if (!S.empty()) S += ' '; 934 S += "const"; 935 } 936 if (TypeQuals & Qualifiers::Volatile) { 937 if (!S.empty()) S += ' '; 938 S += "volatile"; 939 } 940 if (TypeQuals & Qualifiers::Restrict) { 941 if (!S.empty()) S += ' '; 942 S += "restrict"; 943 } 944} 945 946std::string Qualifiers::getAsString() const { 947 LangOptions LO; 948 return getAsString(PrintingPolicy(LO)); 949} 950 951// Appends qualifiers to the given string, separated by spaces. Will 952// prefix a space if the string is non-empty. Will not append a final 953// space. 954void Qualifiers::getAsStringInternal(std::string &S, 955 const PrintingPolicy&) const { 956 AppendTypeQualList(S, getCVRQualifiers()); 957 if (unsigned AddressSpace = getAddressSpace()) { 958 if (!S.empty()) S += ' '; 959 S += "__attribute__((address_space("; 960 S += llvm::utostr_32(AddressSpace); 961 S += ")))"; 962 } 963 if (Qualifiers::GC GCAttrType = getObjCGCAttr()) { 964 if (!S.empty()) S += ' '; 965 S += "__attribute__((objc_gc("; 966 if (GCAttrType == Qualifiers::Weak) 967 S += "weak"; 968 else 969 S += "strong"; 970 S += ")))"; 971 } 972} 973 974std::string QualType::getAsString() const { 975 std::string S; 976 LangOptions LO; 977 getAsStringInternal(S, PrintingPolicy(LO)); 978 return S; 979} 980 981void 982QualType::getAsStringInternal(std::string &S, 983 const PrintingPolicy &Policy) const { 984 if (isNull()) { 985 S += "NULL TYPE"; 986 return; 987 } 988 989 if (Policy.SuppressSpecifiers && getTypePtr()->isSpecifierType()) 990 return; 991 992 // Print qualifiers as appropriate. 993 Qualifiers Quals = getQualifiers(); 994 if (!Quals.empty()) { 995 std::string TQS; 996 Quals.getAsStringInternal(TQS, Policy); 997 998 if (!S.empty()) { 999 TQS += ' '; 1000 TQS += S; 1001 } 1002 std::swap(S, TQS); 1003 } 1004 1005 getTypePtr()->getAsStringInternal(S, Policy); 1006} 1007 1008void BuiltinType::getAsStringInternal(std::string &S, 1009 const PrintingPolicy &Policy) const { 1010 if (S.empty()) { 1011 S = getName(Policy.LangOpts); 1012 } else { 1013 // Prefix the basic type, e.g. 'int X'. 1014 S = ' ' + S; 1015 S = getName(Policy.LangOpts) + S; 1016 } 1017} 1018 1019void FixedWidthIntType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1020 // FIXME: Once we get bitwidth attribute, write as 1021 // "int __attribute__((bitwidth(x)))". 1022 std::string prefix = "__clang_fixedwidth"; 1023 prefix += llvm::utostr_32(Width); 1024 prefix += (char)(Signed ? 'S' : 'U'); 1025 if (S.empty()) { 1026 S = prefix; 1027 } else { 1028 // Prefix the basic type, e.g. 'int X'. 1029 S = prefix + S; 1030 } 1031} 1032 1033 1034void ComplexType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1035 ElementType->getAsStringInternal(S, Policy); 1036 S = "_Complex " + S; 1037} 1038 1039void PointerType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1040 S = '*' + S; 1041 1042 // Handle things like 'int (*A)[4];' correctly. 1043 // FIXME: this should include vectors, but vectors use attributes I guess. 1044 if (isa<ArrayType>(getPointeeType())) 1045 S = '(' + S + ')'; 1046 1047 getPointeeType().getAsStringInternal(S, Policy); 1048} 1049 1050void BlockPointerType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1051 S = '^' + S; 1052 PointeeType.getAsStringInternal(S, Policy); 1053} 1054 1055void LValueReferenceType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1056 S = '&' + S; 1057 1058 // Handle things like 'int (&A)[4];' correctly. 1059 // FIXME: this should include vectors, but vectors use attributes I guess. 1060 if (isa<ArrayType>(getPointeeTypeAsWritten())) 1061 S = '(' + S + ')'; 1062 1063 getPointeeTypeAsWritten().getAsStringInternal(S, Policy); 1064} 1065 1066void RValueReferenceType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1067 S = "&&" + S; 1068 1069 // Handle things like 'int (&&A)[4];' correctly. 1070 // FIXME: this should include vectors, but vectors use attributes I guess. 1071 if (isa<ArrayType>(getPointeeTypeAsWritten())) 1072 S = '(' + S + ')'; 1073 1074 getPointeeTypeAsWritten().getAsStringInternal(S, Policy); 1075} 1076 1077void MemberPointerType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1078 std::string C; 1079 Class->getAsStringInternal(C, Policy); 1080 C += "::*"; 1081 S = C + S; 1082 1083 // Handle things like 'int (Cls::*A)[4];' correctly. 1084 // FIXME: this should include vectors, but vectors use attributes I guess. 1085 if (isa<ArrayType>(getPointeeType())) 1086 S = '(' + S + ')'; 1087 1088 getPointeeType().getAsStringInternal(S, Policy); 1089} 1090 1091void ConstantArrayType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1092 S += '['; 1093 S += llvm::utostr(getSize().getZExtValue()); 1094 S += ']'; 1095 1096 getElementType().getAsStringInternal(S, Policy); 1097} 1098 1099void IncompleteArrayType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1100 S += "[]"; 1101 1102 getElementType().getAsStringInternal(S, Policy); 1103} 1104 1105void VariableArrayType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1106 S += '['; 1107 1108 if (getIndexTypeQualifiers().hasQualifiers()) { 1109 AppendTypeQualList(S, getIndexTypeCVRQualifiers()); 1110 S += ' '; 1111 } 1112 1113 if (getSizeModifier() == Static) 1114 S += "static"; 1115 else if (getSizeModifier() == Star) 1116 S += '*'; 1117 1118 if (getSizeExpr()) { 1119 std::string SStr; 1120 llvm::raw_string_ostream s(SStr); 1121 getSizeExpr()->printPretty(s, 0, Policy); 1122 S += s.str(); 1123 } 1124 S += ']'; 1125 1126 getElementType().getAsStringInternal(S, Policy); 1127} 1128 1129void DependentSizedArrayType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1130 S += '['; 1131 1132 if (getIndexTypeQualifiers().hasQualifiers()) { 1133 AppendTypeQualList(S, getIndexTypeCVRQualifiers()); 1134 S += ' '; 1135 } 1136 1137 if (getSizeModifier() == Static) 1138 S += "static"; 1139 else if (getSizeModifier() == Star) 1140 S += '*'; 1141 1142 if (getSizeExpr()) { 1143 std::string SStr; 1144 llvm::raw_string_ostream s(SStr); 1145 getSizeExpr()->printPretty(s, 0, Policy); 1146 S += s.str(); 1147 } 1148 S += ']'; 1149 1150 getElementType().getAsStringInternal(S, Policy); 1151} 1152 1153void DependentSizedExtVectorType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1154 getElementType().getAsStringInternal(S, Policy); 1155 1156 S += " __attribute__((ext_vector_type("; 1157 if (getSizeExpr()) { 1158 std::string SStr; 1159 llvm::raw_string_ostream s(SStr); 1160 getSizeExpr()->printPretty(s, 0, Policy); 1161 S += s.str(); 1162 } 1163 S += ")))"; 1164} 1165 1166void VectorType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1167 // FIXME: We prefer to print the size directly here, but have no way 1168 // to get the size of the type. 1169 S += " __attribute__((__vector_size__("; 1170 S += llvm::utostr_32(NumElements); // convert back to bytes. 1171 S += " * sizeof(" + ElementType.getAsString() + "))))"; 1172 ElementType.getAsStringInternal(S, Policy); 1173} 1174 1175void ExtVectorType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1176 S += " __attribute__((ext_vector_type("; 1177 S += llvm::utostr_32(NumElements); 1178 S += ")))"; 1179 ElementType.getAsStringInternal(S, Policy); 1180} 1181 1182void TypeOfExprType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1183 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(e) X'. 1184 InnerString = ' ' + InnerString; 1185 std::string Str; 1186 llvm::raw_string_ostream s(Str); 1187 getUnderlyingExpr()->printPretty(s, 0, Policy); 1188 InnerString = "typeof " + s.str() + InnerString; 1189} 1190 1191void TypeOfType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1192 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(t) X'. 1193 InnerString = ' ' + InnerString; 1194 std::string Tmp; 1195 getUnderlyingType().getAsStringInternal(Tmp, Policy); 1196 InnerString = "typeof(" + Tmp + ")" + InnerString; 1197} 1198 1199void DecltypeType::getAsStringInternal(std::string &InnerString, 1200 const PrintingPolicy &Policy) const { 1201 if (!InnerString.empty()) // Prefix the basic type, e.g. 'decltype(t) X'. 1202 InnerString = ' ' + InnerString; 1203 std::string Str; 1204 llvm::raw_string_ostream s(Str); 1205 getUnderlyingExpr()->printPretty(s, 0, Policy); 1206 InnerString = "decltype(" + s.str() + ")" + InnerString; 1207} 1208 1209void FunctionNoProtoType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1210 // If needed for precedence reasons, wrap the inner part in grouping parens. 1211 if (!S.empty()) 1212 S = "(" + S + ")"; 1213 1214 S += "()"; 1215 if (getNoReturnAttr()) 1216 S += " __attribute__((noreturn))"; 1217 getResultType().getAsStringInternal(S, Policy); 1218} 1219 1220void FunctionProtoType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1221 // If needed for precedence reasons, wrap the inner part in grouping parens. 1222 if (!S.empty()) 1223 S = "(" + S + ")"; 1224 1225 S += "("; 1226 std::string Tmp; 1227 PrintingPolicy ParamPolicy(Policy); 1228 ParamPolicy.SuppressSpecifiers = false; 1229 for (unsigned i = 0, e = getNumArgs(); i != e; ++i) { 1230 if (i) S += ", "; 1231 getArgType(i).getAsStringInternal(Tmp, ParamPolicy); 1232 S += Tmp; 1233 Tmp.clear(); 1234 } 1235 1236 if (isVariadic()) { 1237 if (getNumArgs()) 1238 S += ", "; 1239 S += "..."; 1240 } else if (getNumArgs() == 0 && !Policy.LangOpts.CPlusPlus) { 1241 // Do not emit int() if we have a proto, emit 'int(void)'. 1242 S += "void"; 1243 } 1244 1245 S += ")"; 1246 if (getNoReturnAttr()) 1247 S += " __attribute__((noreturn))"; 1248 getResultType().getAsStringInternal(S, Policy); 1249} 1250 1251 1252void TypedefType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1253 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1254 InnerString = ' ' + InnerString; 1255 InnerString = getDecl()->getIdentifier()->getName().str() + InnerString; 1256} 1257 1258void TemplateTypeParmType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1259 if (!InnerString.empty()) // Prefix the basic type, e.g. 'parmname X'. 1260 InnerString = ' ' + InnerString; 1261 1262 if (!Name) 1263 InnerString = "type-parameter-" + llvm::utostr_32(Depth) + '-' + 1264 llvm::utostr_32(Index) + InnerString; 1265 else 1266 InnerString = Name->getName().str() + InnerString; 1267} 1268 1269void SubstTemplateTypeParmType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1270 getReplacementType().getAsStringInternal(InnerString, Policy); 1271} 1272 1273static void PrintTemplateArgument(std::string &Buffer, 1274 const TemplateArgument &Arg, 1275 const PrintingPolicy &Policy) { 1276 switch (Arg.getKind()) { 1277 case TemplateArgument::Null: 1278 assert(false && "Null template argument"); 1279 break; 1280 1281 case TemplateArgument::Type: 1282 Arg.getAsType().getAsStringInternal(Buffer, Policy); 1283 break; 1284 1285 case TemplateArgument::Declaration: 1286 Buffer = cast<NamedDecl>(Arg.getAsDecl())->getNameAsString(); 1287 break; 1288 1289 case TemplateArgument::Integral: 1290 Buffer = Arg.getAsIntegral()->toString(10, true); 1291 break; 1292 1293 case TemplateArgument::Expression: { 1294 llvm::raw_string_ostream s(Buffer); 1295 Arg.getAsExpr()->printPretty(s, 0, Policy); 1296 break; 1297 } 1298 1299 case TemplateArgument::Pack: 1300 assert(0 && "FIXME: Implement!"); 1301 break; 1302 } 1303} 1304 1305std::string 1306TemplateSpecializationType::PrintTemplateArgumentList( 1307 const TemplateArgument *Args, 1308 unsigned NumArgs, 1309 const PrintingPolicy &Policy) { 1310 std::string SpecString; 1311 SpecString += '<'; 1312 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) { 1313 if (Arg) 1314 SpecString += ", "; 1315 1316 // Print the argument into a string. 1317 std::string ArgString; 1318 PrintTemplateArgument(ArgString, Args[Arg], Policy); 1319 1320 // If this is the first argument and its string representation 1321 // begins with the global scope specifier ('::foo'), add a space 1322 // to avoid printing the diagraph '<:'. 1323 if (!Arg && !ArgString.empty() && ArgString[0] == ':') 1324 SpecString += ' '; 1325 1326 SpecString += ArgString; 1327 } 1328 1329 // If the last character of our string is '>', add another space to 1330 // keep the two '>''s separate tokens. We don't *have* to do this in 1331 // C++0x, but it's still good hygiene. 1332 if (SpecString[SpecString.size() - 1] == '>') 1333 SpecString += ' '; 1334 1335 SpecString += '>'; 1336 1337 return SpecString; 1338} 1339 1340// Sadly, repeat all that with TemplateArgLoc. 1341std::string TemplateSpecializationType:: 1342PrintTemplateArgumentList(const TemplateArgumentLoc *Args, unsigned NumArgs, 1343 const PrintingPolicy &Policy) { 1344 std::string SpecString; 1345 SpecString += '<'; 1346 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) { 1347 if (Arg) 1348 SpecString += ", "; 1349 1350 // Print the argument into a string. 1351 std::string ArgString; 1352 PrintTemplateArgument(ArgString, Args[Arg].getArgument(), Policy); 1353 1354 // If this is the first argument and its string representation 1355 // begins with the global scope specifier ('::foo'), add a space 1356 // to avoid printing the diagraph '<:'. 1357 if (!Arg && !ArgString.empty() && ArgString[0] == ':') 1358 SpecString += ' '; 1359 1360 SpecString += ArgString; 1361 } 1362 1363 // If the last character of our string is '>', add another space to 1364 // keep the two '>''s separate tokens. We don't *have* to do this in 1365 // C++0x, but it's still good hygiene. 1366 if (SpecString[SpecString.size() - 1] == '>') 1367 SpecString += ' '; 1368 1369 SpecString += '>'; 1370 1371 return SpecString; 1372} 1373 1374void 1375TemplateSpecializationType:: 1376getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1377 std::string SpecString; 1378 1379 { 1380 llvm::raw_string_ostream OS(SpecString); 1381 Template.print(OS, Policy); 1382 } 1383 1384 SpecString += PrintTemplateArgumentList(getArgs(), getNumArgs(), Policy); 1385 if (InnerString.empty()) 1386 InnerString.swap(SpecString); 1387 else 1388 InnerString = SpecString + ' ' + InnerString; 1389} 1390 1391void QualifiedNameType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1392 std::string MyString; 1393 1394 { 1395 llvm::raw_string_ostream OS(MyString); 1396 NNS->print(OS, Policy); 1397 } 1398 1399 std::string TypeStr; 1400 PrintingPolicy InnerPolicy(Policy); 1401 InnerPolicy.SuppressTagKind = true; 1402 InnerPolicy.SuppressScope = true; 1403 NamedType.getAsStringInternal(TypeStr, InnerPolicy); 1404 1405 MyString += TypeStr; 1406 if (InnerString.empty()) 1407 InnerString.swap(MyString); 1408 else 1409 InnerString = MyString + ' ' + InnerString; 1410} 1411 1412void TypenameType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1413 std::string MyString; 1414 1415 { 1416 llvm::raw_string_ostream OS(MyString); 1417 OS << "typename "; 1418 NNS->print(OS, Policy); 1419 1420 if (const IdentifierInfo *Ident = getIdentifier()) 1421 OS << Ident->getName(); 1422 else if (const TemplateSpecializationType *Spec = getTemplateId()) { 1423 Spec->getTemplateName().print(OS, Policy, true); 1424 OS << TemplateSpecializationType::PrintTemplateArgumentList( 1425 Spec->getArgs(), 1426 Spec->getNumArgs(), 1427 Policy); 1428 } 1429 } 1430 1431 if (InnerString.empty()) 1432 InnerString.swap(MyString); 1433 else 1434 InnerString = MyString + ' ' + InnerString; 1435} 1436 1437void ObjCInterfaceType::Profile(llvm::FoldingSetNodeID &ID, 1438 const ObjCInterfaceDecl *Decl, 1439 ObjCProtocolDecl **protocols, 1440 unsigned NumProtocols) { 1441 ID.AddPointer(Decl); 1442 for (unsigned i = 0; i != NumProtocols; i++) 1443 ID.AddPointer(protocols[i]); 1444} 1445 1446void ObjCInterfaceType::Profile(llvm::FoldingSetNodeID &ID) { 1447 if (getNumProtocols()) 1448 Profile(ID, getDecl(), &Protocols[0], getNumProtocols()); 1449 else 1450 Profile(ID, getDecl(), 0, 0); 1451} 1452 1453void ObjCInterfaceType::getAsStringInternal(std::string &InnerString, 1454 const PrintingPolicy &Policy) const { 1455 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1456 InnerString = ' ' + InnerString; 1457 1458 std::string ObjCQIString = getDecl()->getNameAsString(); 1459 if (getNumProtocols()) { 1460 ObjCQIString += '<'; 1461 bool isFirst = true; 1462 for (qual_iterator I = qual_begin(), E = qual_end(); I != E; ++I) { 1463 if (isFirst) 1464 isFirst = false; 1465 else 1466 ObjCQIString += ','; 1467 ObjCQIString += (*I)->getNameAsString(); 1468 } 1469 ObjCQIString += '>'; 1470 } 1471 InnerString = ObjCQIString + InnerString; 1472} 1473 1474void ObjCObjectPointerType::getAsStringInternal(std::string &InnerString, 1475 const PrintingPolicy &Policy) const { 1476 std::string ObjCQIString; 1477 1478 if (isObjCIdType() || isObjCQualifiedIdType()) 1479 ObjCQIString = "id"; 1480 else if (isObjCClassType() || isObjCQualifiedClassType()) 1481 ObjCQIString = "Class"; 1482 else 1483 ObjCQIString = getInterfaceDecl()->getNameAsString(); 1484 1485 if (!qual_empty()) { 1486 ObjCQIString += '<'; 1487 for (qual_iterator I = qual_begin(), E = qual_end(); I != E; ++I) { 1488 ObjCQIString += (*I)->getNameAsString(); 1489 if (I+1 != E) 1490 ObjCQIString += ','; 1491 } 1492 ObjCQIString += '>'; 1493 } 1494 1495 PointeeType.getQualifiers().getAsStringInternal(ObjCQIString, Policy); 1496 1497 if (!isObjCIdType() && !isObjCQualifiedIdType()) 1498 ObjCQIString += " *"; // Don't forget the implicit pointer. 1499 else if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1500 InnerString = ' ' + InnerString; 1501 1502 InnerString = ObjCQIString + InnerString; 1503} 1504 1505void ElaboratedType::getAsStringInternal(std::string &InnerString, 1506 const PrintingPolicy &Policy) const { 1507 std::string TypeStr; 1508 PrintingPolicy InnerPolicy(Policy); 1509 InnerPolicy.SuppressTagKind = true; 1510 UnderlyingType.getAsStringInternal(InnerString, InnerPolicy); 1511 1512 InnerString = std::string(getNameForTagKind(getTagKind())) + ' ' + InnerString; 1513} 1514 1515void TagType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1516 if (Policy.SuppressTag) 1517 return; 1518 1519 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1520 InnerString = ' ' + InnerString; 1521 1522 const char *Kind = Policy.SuppressTagKind? 0 : getDecl()->getKindName(); 1523 const char *ID; 1524 if (const IdentifierInfo *II = getDecl()->getIdentifier()) 1525 ID = II->getNameStart(); 1526 else if (TypedefDecl *Typedef = getDecl()->getTypedefForAnonDecl()) { 1527 Kind = 0; 1528 assert(Typedef->getIdentifier() && "Typedef without identifier?"); 1529 ID = Typedef->getIdentifier()->getNameStart(); 1530 } else 1531 ID = "<anonymous>"; 1532 1533 // If this is a class template specialization, print the template 1534 // arguments. 1535 if (ClassTemplateSpecializationDecl *Spec 1536 = dyn_cast<ClassTemplateSpecializationDecl>(getDecl())) { 1537 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1538 std::string TemplateArgsStr 1539 = TemplateSpecializationType::PrintTemplateArgumentList( 1540 TemplateArgs.getFlatArgumentList(), 1541 TemplateArgs.flat_size(), 1542 Policy); 1543 InnerString = TemplateArgsStr + InnerString; 1544 } 1545 1546 if (!Policy.SuppressScope) { 1547 // Compute the full nested-name-specifier for this type. In C, 1548 // this will always be empty. 1549 std::string ContextStr; 1550 for (DeclContext *DC = getDecl()->getDeclContext(); 1551 !DC->isTranslationUnit(); DC = DC->getParent()) { 1552 std::string MyPart; 1553 if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(DC)) { 1554 if (NS->getIdentifier()) 1555 MyPart = NS->getNameAsString(); 1556 } else if (ClassTemplateSpecializationDecl *Spec 1557 = dyn_cast<ClassTemplateSpecializationDecl>(DC)) { 1558 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1559 std::string TemplateArgsStr 1560 = TemplateSpecializationType::PrintTemplateArgumentList( 1561 TemplateArgs.getFlatArgumentList(), 1562 TemplateArgs.flat_size(), 1563 Policy); 1564 MyPart = Spec->getIdentifier()->getName().str() + TemplateArgsStr; 1565 } else if (TagDecl *Tag = dyn_cast<TagDecl>(DC)) { 1566 if (TypedefDecl *Typedef = Tag->getTypedefForAnonDecl()) 1567 MyPart = Typedef->getIdentifier()->getName(); 1568 else if (Tag->getIdentifier()) 1569 MyPart = Tag->getIdentifier()->getName(); 1570 } 1571 1572 if (!MyPart.empty()) 1573 ContextStr = MyPart + "::" + ContextStr; 1574 } 1575 1576 if (Kind) 1577 InnerString = std::string(Kind) + ' ' + ContextStr + ID + InnerString; 1578 else 1579 InnerString = ContextStr + ID + InnerString; 1580 } else 1581 InnerString = ID + InnerString; 1582} 1583