Type.cpp revision f82b4e85b1219295cad4b5851b035575bc293010 
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
342ObjCInterfaceType::ObjCInterfaceType(ASTContext &Ctx, QualType Canonical,
343                                     ObjCInterfaceDecl *D,
344                                     ObjCProtocolDecl **Protos, unsigned NumP) :
345  Type(ObjCInterface, Canonical, /*Dependent=*/false),
346  Decl(D), Protocols(0), NumProtocols(NumP)
347{
348  if (NumProtocols) {
349    Protocols = new (Ctx) ObjCProtocolDecl*[NumProtocols];
350    memcpy(Protocols, Protos, NumProtocols * sizeof(*Protocols));
351  }
352}
353
354void ObjCInterfaceType::Destroy(ASTContext& C) {
355  if (Protocols)
356    C.Deallocate(Protocols);
357  this->~ObjCInterfaceType();
358  C.Deallocate(this);
359}
360
361const ObjCInterfaceType *Type::getAsObjCQualifiedInterfaceType() const {
362  // There is no sugar for ObjCInterfaceType's, just return the canonical
363  // type pointer if it is the right class.  There is no typedef information to
364  // return and these cannot be Address-space qualified.
365  if (const ObjCInterfaceType *OIT = getAs<ObjCInterfaceType>())
366    if (OIT->getNumProtocols())
367      return OIT;
368  return 0;
369}
370
371bool Type::isObjCQualifiedInterfaceType() const {
372  return getAsObjCQualifiedInterfaceType() != 0;
373}
374
375ObjCObjectPointerType::ObjCObjectPointerType(ASTContext &Ctx,
376                                             QualType Canonical, QualType T,
377                                             ObjCProtocolDecl **Protos,
378                                             unsigned NumP) :
379  Type(ObjCObjectPointer, Canonical, /*Dependent=*/false),
380  PointeeType(T), Protocols(NULL), NumProtocols(NumP)
381{
382  if (NumProtocols) {
383    Protocols = new (Ctx) ObjCProtocolDecl*[NumProtocols];
384    memcpy(Protocols, Protos, NumProtocols * sizeof(*Protocols));
385  }
386}
387
388void ObjCObjectPointerType::Destroy(ASTContext& C) {
389  if (Protocols)
390    C.Deallocate(Protocols);
391  this->~ObjCObjectPointerType();
392  C.Deallocate(this);
393}
394
395const ObjCObjectPointerType *Type::getAsObjCQualifiedIdType() const {
396  // There is no sugar for ObjCQualifiedIdType's, just return the canonical
397  // type pointer if it is the right class.
398  if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) {
399    if (OPT->isObjCQualifiedIdType())
400      return OPT;
401  }
402  return 0;
403}
404
405const ObjCObjectPointerType *Type::getAsObjCInterfacePointerType() const {
406  if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) {
407    if (OPT->getInterfaceType())
408      return OPT;
409  }
410  return 0;
411}
412
413const CXXRecordDecl *Type::getCXXRecordDeclForPointerType() const {
414  if (const PointerType *PT = getAs<PointerType>())
415    if (const RecordType *RT = PT->getPointeeType()->getAs<RecordType>())
416      return dyn_cast<CXXRecordDecl>(RT->getDecl());
417  return 0;
418}
419
420bool Type::isIntegerType() const {
421  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
422    return BT->getKind() >= BuiltinType::Bool &&
423           BT->getKind() <= BuiltinType::Int128;
424  if (const TagType *TT = dyn_cast<TagType>(CanonicalType))
425    // Incomplete enum types are not treated as integer types.
426    // FIXME: In C++, enum types are never integer types.
427    if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition())
428      return true;
429  if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
430    return VT->getElementType()->isIntegerType();
431  return false;
432}
433
434bool Type::isIntegralType() const {
435  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
436    return BT->getKind() >= BuiltinType::Bool &&
437    BT->getKind() <= BuiltinType::Int128;
438  if (const TagType *TT = dyn_cast<TagType>(CanonicalType))
439    if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition())
440      return true;  // Complete enum types are integral.
441                    // FIXME: In C++, enum types are never integral.
442  return false;
443}
444
445bool Type::isEnumeralType() const {
446  if (const TagType *TT = dyn_cast<TagType>(CanonicalType))
447    return TT->getDecl()->isEnum();
448  return false;
449}
450
451bool Type::isBooleanType() const {
452  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
453    return BT->getKind() == BuiltinType::Bool;
454  return false;
455}
456
457bool Type::isCharType() const {
458  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
459    return BT->getKind() == BuiltinType::Char_U ||
460           BT->getKind() == BuiltinType::UChar ||
461           BT->getKind() == BuiltinType::Char_S ||
462           BT->getKind() == BuiltinType::SChar;
463  return false;
464}
465
466bool Type::isWideCharType() const {
467  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
468    return BT->getKind() == BuiltinType::WChar;
469  return false;
470}
471
472/// \brief Determine whether this type is any of the built-in character
473/// types.
474bool Type::isAnyCharacterType() const {
475  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
476    return (BT->getKind() >= BuiltinType::Char_U &&
477            BT->getKind() <= BuiltinType::Char32) ||
478           (BT->getKind() >= BuiltinType::Char_S &&
479            BT->getKind() <= BuiltinType::WChar);
480
481  return false;
482}
483
484/// isSignedIntegerType - Return true if this is an integer type that is
485/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
486/// an enum decl which has a signed representation, or a vector of signed
487/// integer element type.
488bool Type::isSignedIntegerType() const {
489  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
490    return BT->getKind() >= BuiltinType::Char_S &&
491           BT->getKind() <= BuiltinType::Int128;
492  }
493
494  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
495    return ET->getDecl()->getIntegerType()->isSignedIntegerType();
496
497  if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
498    return VT->getElementType()->isSignedIntegerType();
499  return false;
500}
501
502/// isUnsignedIntegerType - Return true if this is an integer type that is
503/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum
504/// decl which has an unsigned representation, or a vector of unsigned integer
505/// element type.
506bool Type::isUnsignedIntegerType() const {
507  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) {
508    return BT->getKind() >= BuiltinType::Bool &&
509           BT->getKind() <= BuiltinType::UInt128;
510  }
511
512  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
513    return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
514
515  if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
516    return VT->getElementType()->isUnsignedIntegerType();
517  return false;
518}
519
520bool Type::isFloatingType() const {
521  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
522    return BT->getKind() >= BuiltinType::Float &&
523           BT->getKind() <= BuiltinType::LongDouble;
524  if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType))
525    return CT->getElementType()->isFloatingType();
526  if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
527    return VT->getElementType()->isFloatingType();
528  return false;
529}
530
531bool Type::isRealFloatingType() const {
532  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
533    return BT->isFloatingPoint();
534  if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
535    return VT->getElementType()->isRealFloatingType();
536  return false;
537}
538
539bool Type::isRealType() const {
540  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
541    return BT->getKind() >= BuiltinType::Bool &&
542           BT->getKind() <= BuiltinType::LongDouble;
543  if (const TagType *TT = dyn_cast<TagType>(CanonicalType))
544    return TT->getDecl()->isEnum() && TT->getDecl()->isDefinition();
545  if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
546    return VT->getElementType()->isRealType();
547  return false;
548}
549
550bool Type::isArithmeticType() const {
551  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
552    return BT->getKind() >= BuiltinType::Bool &&
553           BT->getKind() <= BuiltinType::LongDouble;
554  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
555    // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2).
556    // If a body isn't seen by the time we get here, return false.
557    return ET->getDecl()->isDefinition();
558  return isa<ComplexType>(CanonicalType) || isa<VectorType>(CanonicalType);
559}
560
561bool Type::isScalarType() const {
562  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
563    return BT->getKind() != BuiltinType::Void;
564  if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) {
565    // Enums are scalar types, but only if they are defined.  Incomplete enums
566    // are not treated as scalar types.
567    if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition())
568      return true;
569    return false;
570  }
571  return isa<PointerType>(CanonicalType) ||
572         isa<BlockPointerType>(CanonicalType) ||
573         isa<MemberPointerType>(CanonicalType) ||
574         isa<ComplexType>(CanonicalType) ||
575         isa<ObjCObjectPointerType>(CanonicalType);
576}
577
578/// \brief Determines whether the type is a C++ aggregate type or C
579/// aggregate or union type.
580///
581/// An aggregate type is an array or a class type (struct, union, or
582/// class) that has no user-declared constructors, no private or
583/// protected non-static data members, no base classes, and no virtual
584/// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type
585/// subsumes the notion of C aggregates (C99 6.2.5p21) because it also
586/// includes union types.
587bool Type::isAggregateType() const {
588  if (const RecordType *Record = dyn_cast<RecordType>(CanonicalType)) {
589    if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl()))
590      return ClassDecl->isAggregate();
591
592    return true;
593  }
594
595  return isa<ArrayType>(CanonicalType);
596}
597
598/// isConstantSizeType - Return true if this is not a variable sized type,
599/// according to the rules of C99 6.7.5p3.  It is not legal to call this on
600/// incomplete types or dependent types.
601bool Type::isConstantSizeType() const {
602  assert(!isIncompleteType() && "This doesn't make sense for incomplete types");
603  assert(!isDependentType() && "This doesn't make sense for dependent types");
604  // The VAT must have a size, as it is known to be complete.
605  return !isa<VariableArrayType>(CanonicalType);
606}
607
608/// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1)
609/// - a type that can describe objects, but which lacks information needed to
610/// determine its size.
611bool Type::isIncompleteType() const {
612  switch (CanonicalType->getTypeClass()) {
613  default: return false;
614  case Builtin:
615    // Void is the only incomplete builtin type.  Per C99 6.2.5p19, it can never
616    // be completed.
617    return isVoidType();
618  case Record:
619  case Enum:
620    // A tagged type (struct/union/enum/class) is incomplete if the decl is a
621    // forward declaration, but not a full definition (C99 6.2.5p22).
622    return !cast<TagType>(CanonicalType)->getDecl()->isDefinition();
623  case ConstantArray:
624    // An array is incomplete if its element type is incomplete
625    // (C++ [dcl.array]p1).
626    // We don't handle variable arrays (they're not allowed in C++) or
627    // dependent-sized arrays (dependent types are never treated as incomplete).
628    return cast<ArrayType>(CanonicalType)->getElementType()->isIncompleteType();
629  case IncompleteArray:
630    // An array of unknown size is an incomplete type (C99 6.2.5p22).
631    return true;
632  case ObjCInterface:
633    // ObjC interfaces are incomplete if they are @class, not @interface.
634    return cast<ObjCInterfaceType>(this)->getDecl()->isForwardDecl();
635  }
636}
637
638/// isPODType - Return true if this is a plain-old-data type (C++ 3.9p10)
639bool Type::isPODType() const {
640  // The compiler shouldn't query this for incomplete types, but the user might.
641  // We return false for that case.
642  if (isIncompleteType())
643    return false;
644
645  switch (CanonicalType->getTypeClass()) {
646    // Everything not explicitly mentioned is not POD.
647  default: return false;
648  case VariableArray:
649  case ConstantArray:
650    // IncompleteArray is caught by isIncompleteType() above.
651    return cast<ArrayType>(CanonicalType)->getElementType()->isPODType();
652
653  case Builtin:
654  case Complex:
655  case Pointer:
656  case MemberPointer:
657  case Vector:
658  case ExtVector:
659  case ObjCObjectPointer:
660    return true;
661
662  case Enum:
663    return true;
664
665  case Record:
666    if (CXXRecordDecl *ClassDecl
667          = dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl()))
668      return ClassDecl->isPOD();
669
670    // C struct/union is POD.
671    return true;
672  }
673}
674
675bool Type::isLiteralType() const {
676  if (isIncompleteType())
677    return false;
678
679  // C++0x [basic.types]p10:
680  //   A type is a literal type if it is:
681  switch (CanonicalType->getTypeClass()) {
682    // We're whitelisting
683  default: return false;
684
685    //   -- a scalar type
686  case Builtin:
687  case Complex:
688  case Pointer:
689  case MemberPointer:
690  case Vector:
691  case ExtVector:
692  case ObjCObjectPointer:
693  case Enum:
694    return true;
695
696    //   -- a class type with ...
697  case Record:
698    // FIXME: Do the tests
699    return false;
700
701    //   -- an array of literal type
702    // Extension: variable arrays cannot be literal types, since they're
703    // runtime-sized.
704  case ConstantArray:
705    return cast<ArrayType>(CanonicalType)->getElementType()->isLiteralType();
706  }
707}
708
709bool Type::isPromotableIntegerType() const {
710  if (const BuiltinType *BT = getAs<BuiltinType>())
711    switch (BT->getKind()) {
712    case BuiltinType::Bool:
713    case BuiltinType::Char_S:
714    case BuiltinType::Char_U:
715    case BuiltinType::SChar:
716    case BuiltinType::UChar:
717    case BuiltinType::Short:
718    case BuiltinType::UShort:
719      return true;
720    default:
721      return false;
722    }
723
724  // Enumerated types are promotable to their compatible integer types
725  // (C99 6.3.1.1) a.k.a. its underlying type (C++ [conv.prom]p2).
726  if (const EnumType *ET = getAs<EnumType>()){
727    if (this->isDependentType() || ET->getDecl()->getPromotionType().isNull())
728      return false;
729
730    const BuiltinType *BT
731      = ET->getDecl()->getPromotionType()->getAs<BuiltinType>();
732    return BT->getKind() == BuiltinType::Int
733           || BT->getKind() == BuiltinType::UInt;
734  }
735
736  return false;
737}
738
739bool Type::isNullPtrType() const {
740  if (const BuiltinType *BT = getAs<BuiltinType>())
741    return BT->getKind() == BuiltinType::NullPtr;
742  return false;
743}
744
745bool Type::isSpecifierType() const {
746  // Note that this intentionally does not use the canonical type.
747  switch (getTypeClass()) {
748  case Builtin:
749  case Record:
750  case Enum:
751  case Typedef:
752  case Complex:
753  case TypeOfExpr:
754  case TypeOf:
755  case TemplateTypeParm:
756  case SubstTemplateTypeParm:
757  case TemplateSpecialization:
758  case QualifiedName:
759  case Typename:
760  case ObjCInterface:
761  case ObjCObjectPointer:
762  case Elaborated:
763    return true;
764  default:
765    return false;
766  }
767}
768
769const char *Type::getTypeClassName() const {
770  switch (TC) {
771  default: assert(0 && "Type class not in TypeNodes.def!");
772#define ABSTRACT_TYPE(Derived, Base)
773#define TYPE(Derived, Base) case Derived: return #Derived;
774#include "clang/AST/TypeNodes.def"
775  }
776}
777
778const char *BuiltinType::getName(const LangOptions &LO) const {
779  switch (getKind()) {
780  default: assert(0 && "Unknown builtin type!");
781  case Void:              return "void";
782  case Bool:              return LO.Bool ? "bool" : "_Bool";
783  case Char_S:            return "char";
784  case Char_U:            return "char";
785  case SChar:             return "signed char";
786  case Short:             return "short";
787  case Int:               return "int";
788  case Long:              return "long";
789  case LongLong:          return "long long";
790  case Int128:            return "__int128_t";
791  case UChar:             return "unsigned char";
792  case UShort:            return "unsigned short";
793  case UInt:              return "unsigned int";
794  case ULong:             return "unsigned long";
795  case ULongLong:         return "unsigned long long";
796  case UInt128:           return "__uint128_t";
797  case Float:             return "float";
798  case Double:            return "double";
799  case LongDouble:        return "long double";
800  case WChar:             return "wchar_t";
801  case Char16:            return "char16_t";
802  case Char32:            return "char32_t";
803  case NullPtr:           return "nullptr_t";
804  case Overload:          return "<overloaded function type>";
805  case Dependent:         return "<dependent type>";
806  case UndeducedAuto:     return "auto";
807  case ObjCId:            return "id";
808  case ObjCClass:         return "Class";
809  case ObjCSel:         return "SEL";
810  }
811}
812
813void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
814                                arg_type_iterator ArgTys,
815                                unsigned NumArgs, bool isVariadic,
816                                unsigned TypeQuals, bool hasExceptionSpec,
817                                bool anyExceptionSpec, unsigned NumExceptions,
818                                exception_iterator Exs, bool NoReturn,
819                                CallingConv CallConv) {
820  ID.AddPointer(Result.getAsOpaquePtr());
821  for (unsigned i = 0; i != NumArgs; ++i)
822    ID.AddPointer(ArgTys[i].getAsOpaquePtr());
823  ID.AddInteger(isVariadic);
824  ID.AddInteger(TypeQuals);
825  ID.AddInteger(hasExceptionSpec);
826  if (hasExceptionSpec) {
827    ID.AddInteger(anyExceptionSpec);
828    for (unsigned i = 0; i != NumExceptions; ++i)
829      ID.AddPointer(Exs[i].getAsOpaquePtr());
830  }
831  ID.AddInteger(NoReturn);
832  ID.AddInteger(CallConv);
833}
834
835void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID) {
836  Profile(ID, getResultType(), arg_type_begin(), NumArgs, isVariadic(),
837          getTypeQuals(), hasExceptionSpec(), hasAnyExceptionSpec(),
838          getNumExceptions(), exception_begin(), getNoReturnAttr(),
839          getCallConv());
840}
841
842void ObjCObjectPointerType::Profile(llvm::FoldingSetNodeID &ID,
843                                    QualType OIT, ObjCProtocolDecl **protocols,
844                                    unsigned NumProtocols) {
845  ID.AddPointer(OIT.getAsOpaquePtr());
846  for (unsigned i = 0; i != NumProtocols; i++)
847    ID.AddPointer(protocols[i]);
848}
849
850void ObjCObjectPointerType::Profile(llvm::FoldingSetNodeID &ID) {
851  if (getNumProtocols())
852    Profile(ID, getPointeeType(), &Protocols[0], getNumProtocols());
853  else
854    Profile(ID, getPointeeType(), 0, 0);
855}
856
857/// LookThroughTypedefs - Return the ultimate type this typedef corresponds to
858/// potentially looking through *all* consequtive typedefs.  This returns the
859/// sum of the type qualifiers, so if you have:
860///   typedef const int A;
861///   typedef volatile A B;
862/// looking through the typedefs for B will give you "const volatile A".
863///
864QualType TypedefType::LookThroughTypedefs() const {
865  // Usually, there is only a single level of typedefs, be fast in that case.
866  QualType FirstType = getDecl()->getUnderlyingType();
867  if (!isa<TypedefType>(FirstType))
868    return FirstType;
869
870  // Otherwise, do the fully general loop.
871  QualifierCollector Qs;
872
873  QualType CurType;
874  const TypedefType *TDT = this;
875  do {
876    CurType = TDT->getDecl()->getUnderlyingType();
877    TDT = dyn_cast<TypedefType>(Qs.strip(CurType));
878  } while (TDT);
879
880  return Qs.apply(CurType);
881}
882
883QualType TypedefType::desugar() const {
884  return getDecl()->getUnderlyingType();
885}
886
887TypeOfExprType::TypeOfExprType(Expr *E, QualType can)
888  : Type(TypeOfExpr, can, E->isTypeDependent()), TOExpr(E) {
889}
890
891QualType TypeOfExprType::desugar() const {
892  return getUnderlyingExpr()->getType();
893}
894
895void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID,
896                                      ASTContext &Context, Expr *E) {
897  E->Profile(ID, Context, true);
898}
899
900DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can)
901  : Type(Decltype, can, E->isTypeDependent()), E(E),
902  UnderlyingType(underlyingType) {
903}
904
905DependentDecltypeType::DependentDecltypeType(ASTContext &Context, Expr *E)
906  : DecltypeType(E, Context.DependentTy), Context(Context) { }
907
908void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID,
909                                    ASTContext &Context, Expr *E) {
910  E->Profile(ID, Context, true);
911}
912
913TagType::TagType(TypeClass TC, TagDecl *D, QualType can)
914  : Type(TC, can, D->isDependentType()), decl(D, 0) {}
915
916bool RecordType::classof(const TagType *TT) {
917  return isa<RecordDecl>(TT->getDecl());
918}
919
920bool EnumType::classof(const TagType *TT) {
921  return isa<EnumDecl>(TT->getDecl());
922}
923
924static bool isDependent(const TemplateArgument &Arg) {
925  switch (Arg.getKind()) {
926  case TemplateArgument::Null:
927    assert(false && "Should not have a NULL template argument");
928    return false;
929
930  case TemplateArgument::Type:
931    return Arg.getAsType()->isDependentType();
932
933  case TemplateArgument::Template:
934    return Arg.getAsTemplate().isDependent();
935
936  case TemplateArgument::Declaration:
937  case TemplateArgument::Integral:
938    // Never dependent
939    return false;
940
941  case TemplateArgument::Expression:
942    return (Arg.getAsExpr()->isTypeDependent() ||
943            Arg.getAsExpr()->isValueDependent());
944
945  case TemplateArgument::Pack:
946    assert(0 && "FIXME: Implement!");
947    return false;
948  }
949
950  return false;
951}
952
953bool TemplateSpecializationType::
954anyDependentTemplateArguments(const TemplateArgumentListInfo &Args) {
955  return anyDependentTemplateArguments(Args.getArgumentArray(), Args.size());
956}
957
958bool TemplateSpecializationType::
959anyDependentTemplateArguments(const TemplateArgumentLoc *Args, unsigned N) {
960  for (unsigned i = 0; i != N; ++i)
961    if (isDependent(Args[i].getArgument()))
962      return true;
963  return false;
964}
965
966bool TemplateSpecializationType::
967anyDependentTemplateArguments(const TemplateArgument *Args, unsigned N) {
968  for (unsigned i = 0; i != N; ++i)
969    if (isDependent(Args[i]))
970      return true;
971  return false;
972}
973
974TemplateSpecializationType::
975TemplateSpecializationType(ASTContext &Context, TemplateName T,
976                           const TemplateArgument *Args,
977                           unsigned NumArgs, QualType Canon)
978  : Type(TemplateSpecialization,
979         Canon.isNull()? QualType(this, 0) : Canon,
980         T.isDependent() || anyDependentTemplateArguments(Args, NumArgs)),
981    Context(Context),
982    Template(T), NumArgs(NumArgs) {
983  assert((!Canon.isNull() ||
984          T.isDependent() || anyDependentTemplateArguments(Args, NumArgs)) &&
985         "No canonical type for non-dependent class template specialization");
986
987  TemplateArgument *TemplateArgs
988    = reinterpret_cast<TemplateArgument *>(this + 1);
989  for (unsigned Arg = 0; Arg < NumArgs; ++Arg)
990    new (&TemplateArgs[Arg]) TemplateArgument(Args[Arg]);
991}
992
993void TemplateSpecializationType::Destroy(ASTContext& C) {
994  for (unsigned Arg = 0; Arg < NumArgs; ++Arg) {
995    // FIXME: Not all expressions get cloned, so we can't yet perform
996    // this destruction.
997    //    if (Expr *E = getArg(Arg).getAsExpr())
998    //      E->Destroy(C);
999  }
1000}
1001
1002TemplateSpecializationType::iterator
1003TemplateSpecializationType::end() const {
1004  return begin() + getNumArgs();
1005}
1006
1007const TemplateArgument &
1008TemplateSpecializationType::getArg(unsigned Idx) const {
1009  assert(Idx < getNumArgs() && "Template argument out of range");
1010  return getArgs()[Idx];
1011}
1012
1013void
1014TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
1015                                    TemplateName T,
1016                                    const TemplateArgument *Args,
1017                                    unsigned NumArgs,
1018                                    ASTContext &Context) {
1019  T.Profile(ID);
1020  for (unsigned Idx = 0; Idx < NumArgs; ++Idx)
1021    Args[Idx].Profile(ID, Context);
1022}
1023
1024QualType QualifierCollector::apply(QualType QT) const {
1025  if (!hasNonFastQualifiers())
1026    return QT.withFastQualifiers(getFastQualifiers());
1027
1028  assert(Context && "extended qualifiers but no context!");
1029  return Context->getQualifiedType(QT, *this);
1030}
1031
1032QualType QualifierCollector::apply(const Type *T) const {
1033  if (!hasNonFastQualifiers())
1034    return QualType(T, getFastQualifiers());
1035
1036  assert(Context && "extended qualifiers but no context!");
1037  return Context->getQualifiedType(T, *this);
1038}
1039
1040void ObjCInterfaceType::Profile(llvm::FoldingSetNodeID &ID,
1041                                         const ObjCInterfaceDecl *Decl,
1042                                         ObjCProtocolDecl **protocols,
1043                                         unsigned NumProtocols) {
1044  ID.AddPointer(Decl);
1045  for (unsigned i = 0; i != NumProtocols; i++)
1046    ID.AddPointer(protocols[i]);
1047}
1048
1049void ObjCInterfaceType::Profile(llvm::FoldingSetNodeID &ID) {
1050  if (getNumProtocols())
1051    Profile(ID, getDecl(), &Protocols[0], getNumProtocols());
1052  else
1053    Profile(ID, getDecl(), 0, 0);
1054}
1055
1056Linkage Type::getLinkage() const {
1057  // C++ [basic.link]p8:
1058  //   Names not covered by these rules have no linkage.
1059  if (this != CanonicalType.getTypePtr())
1060    return CanonicalType->getLinkage();
1061
1062  return NoLinkage;
1063}
1064
1065Linkage BuiltinType::getLinkage() const {
1066  // C++ [basic.link]p8:
1067  //   A type is said to have linkage if and only if:
1068  //     - it is a fundamental type (3.9.1); or
1069  return ExternalLinkage;
1070}
1071
1072Linkage TagType::getLinkage() const {
1073  // C++ [basic.link]p8:
1074  //     - it is a class or enumeration type that is named (or has a name for
1075  //       linkage purposes (7.1.3)) and the name has linkage; or
1076  //     -  it is a specialization of a class template (14); or
1077  return getDecl()->getLinkage();
1078}
1079
1080// C++ [basic.link]p8:
1081//   - it is a compound type (3.9.2) other than a class or enumeration,
1082//     compounded exclusively from types that have linkage; or
1083Linkage ComplexType::getLinkage() const {
1084  return ElementType->getLinkage();
1085}
1086
1087Linkage PointerType::getLinkage() const {
1088  return PointeeType->getLinkage();
1089}
1090
1091Linkage BlockPointerType::getLinkage() const {
1092  return PointeeType->getLinkage();
1093}
1094
1095Linkage ReferenceType::getLinkage() const {
1096  return PointeeType->getLinkage();
1097}
1098
1099Linkage MemberPointerType::getLinkage() const {
1100  return minLinkage(Class->getLinkage(), PointeeType->getLinkage());
1101}
1102
1103Linkage ArrayType::getLinkage() const {
1104  return ElementType->getLinkage();
1105}
1106
1107Linkage VectorType::getLinkage() const {
1108  return ElementType->getLinkage();
1109}
1110
1111Linkage FunctionNoProtoType::getLinkage() const {
1112  return getResultType()->getLinkage();
1113}
1114
1115Linkage FunctionProtoType::getLinkage() const {
1116  Linkage L = getResultType()->getLinkage();
1117  for (arg_type_iterator A = arg_type_begin(), AEnd = arg_type_end();
1118       A != AEnd; ++A)
1119    L = minLinkage(L, (*A)->getLinkage());
1120
1121  return L;
1122}
1123
1124Linkage ObjCInterfaceType::getLinkage() const {
1125  return ExternalLinkage;
1126}
1127
1128Linkage ObjCObjectPointerType::getLinkage() const {
1129  return ExternalLinkage;
1130}
1131