lib/Sema/SemaType.cpp

   1 //===--- SemaType.cpp - Semantic Analysis for Types -----------------------===//
   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 semantic analysis.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "Sema.h"
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/DeclObjC.h"
  17 #include "clang/AST/DeclTemplate.h"
  18 #include "clang/AST/Expr.h"
  19 #include "clang/Parse/DeclSpec.h"
  20 using namespace clang;
  21
  22 /// \brief Perform adjustment on the parameter type of a function.
  23 ///
  24 /// This routine adjusts the given parameter type @p T to the actual
  25 /// parameter type used by semantic analysis (C99 6.7.5.3p[7,8],
  26 /// C++ [dcl.fct]p3). The adjusted parameter type is returned.
  27 QualType Sema::adjustParameterType(QualType T) {
  28   // C99 6.7.5.3p7:
  29   if (T->isArrayType()) {
  30     // C99 6.7.5.3p7:
  31     //   A declaration of a parameter as "array of type" shall be
  32     //   adjusted to "qualified pointer to type", where the type
  33     //   qualifiers (if any) are those specified within the [ and ] of
  34     //   the array type derivation.
  35     return Context.getArrayDecayedType(T);
  36   } else if (T->isFunctionType())
  37     // C99 6.7.5.3p8:
  38     //   A declaration of a parameter as "function returning type"
  39     //   shall be adjusted to "pointer to function returning type", as
  40     //   in 6.3.2.1.
  41     return Context.getPointerType(T);
  42
  43   return T;
  44 }
  45
  46 /// \brief Convert the specified declspec to the appropriate type
  47 /// object.
  48 /// \param DS  the declaration specifiers
  49 /// \param DeclLoc The location of the declarator identifier or invalid if none.
  50 /// \returns The type described by the declaration specifiers.  This function
  51 /// never returns null.
  52 QualType Sema::ConvertDeclSpecToType(const DeclSpec &DS,
  53                                      SourceLocation DeclLoc,
  54                                      bool &isInvalid) {
  55   // FIXME: Should move the logic from DeclSpec::Finish to here for validity
  56   // checking.
  57   QualType Result;
  58
  59   switch (DS.getTypeSpecType()) {
  60   case DeclSpec::TST_void:
  61     Result = Context.VoidTy;
  62     break;
  63   case DeclSpec::TST_char:
  64     if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified)
  65       Result = Context.CharTy;
  66     else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed)
  67       Result = Context.SignedCharTy;
  68     else {
  69       assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
  70              "Unknown TSS value");
  71       Result = Context.UnsignedCharTy;
  72     }
  73     break;
  74   case DeclSpec::TST_wchar:
  75     if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified)
  76       Result = Context.WCharTy;
  77     else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) {
  78       Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
  79         << DS.getSpecifierName(DS.getTypeSpecType());
  80       Result = Context.getSignedWCharType();
  81     } else {
  82       assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
  83         "Unknown TSS value");
  84       Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
  85         << DS.getSpecifierName(DS.getTypeSpecType());
  86       Result = Context.getUnsignedWCharType();
  87     }
  88     break;
  89   case DeclSpec::TST_unspecified:
  90     // "<proto1,proto2>" is an objc qualified ID with a missing id.
  91     if (DeclSpec::ProtocolQualifierListTy PQ = DS.getProtocolQualifiers()) {
  92       Result = Context.getObjCQualifiedIdType((ObjCProtocolDecl**)PQ,
  93                                               DS.getNumProtocolQualifiers());
  94       break;
  95     }
  96
  97     // Unspecified typespec defaults to int in C90.  However, the C90 grammar
  98     // [C90 6.5] only allows a decl-spec if there was *some* type-specifier,
  99     // type-qualifier, or storage-class-specifier.  If not, emit an extwarn.
 100     // Note that the one exception to this is function definitions, which are
 101     // allowed to be completely missing a declspec.  This is handled in the
 102     // parser already though by it pretending to have seen an 'int' in this
 103     // case.
 104     if (getLangOptions().ImplicitInt) {
 105       // In C89 mode, we only warn if there is a completely missing declspec
 106       // when one is not allowed.
 107       if (DS.isEmpty()) {
 108         if (DeclLoc.isInvalid())
 109           DeclLoc = DS.getSourceRange().getBegin();
 110         Diag(DeclLoc, diag::warn_missing_declspec)
 111           << DS.getSourceRange()
 112         << CodeModificationHint::CreateInsertion(DS.getSourceRange().getBegin(),
 113                                                  "int");
 114       }
 115     } else if (!DS.hasTypeSpecifier()) {
 116       // C99 and C++ require a type specifier.  For example, C99 6.7.2p2 says:
 117       // "At least one type specifier shall be given in the declaration
 118       // specifiers in each declaration, and in the specifier-qualifier list in
 119       // each struct declaration and type name."
 120       // FIXME: Does Microsoft really have the implicit int extension in C++?
 121       if (DeclLoc.isInvalid())
 122         DeclLoc = DS.getSourceRange().getBegin();
 123
 124       if (getLangOptions().CPlusPlus && !getLangOptions().Microsoft)
 125         Diag(DeclLoc, diag::err_missing_type_specifier)
 126           << DS.getSourceRange();
 127       else
 128         Diag(DeclLoc, diag::warn_missing_type_specifier)
 129           << DS.getSourceRange();
 130
 131       // FIXME: If we could guarantee that the result would be well-formed, it
 132       // would be useful to have a code insertion hint here. However, after
 133       // emitting this warning/error, we often emit other errors.
 134     }
 135
 136     // FALL THROUGH.
 137   case DeclSpec::TST_int: {
 138     if (DS.getTypeSpecSign() != DeclSpec::TSS_unsigned) {
 139       switch (DS.getTypeSpecWidth()) {
 140       case DeclSpec::TSW_unspecified: Result = Context.IntTy; break;
 141       case DeclSpec::TSW_short:       Result = Context.ShortTy; break;
 142       case DeclSpec::TSW_long:        Result = Context.LongTy; break;
 143       case DeclSpec::TSW_longlong:    Result = Context.LongLongTy; break;
 144       }
 145     } else {
 146       switch (DS.getTypeSpecWidth()) {
 147       case DeclSpec::TSW_unspecified: Result = Context.UnsignedIntTy; break;
 148       case DeclSpec::TSW_short:       Result = Context.UnsignedShortTy; break;
 149       case DeclSpec::TSW_long:        Result = Context.UnsignedLongTy; break;
 150       case DeclSpec::TSW_longlong:    Result =Context.UnsignedLongLongTy; break;
 151       }
 152     }
 153     break;
 154   }
 155   case DeclSpec::TST_float: Result = Context.FloatTy; break;
 156   case DeclSpec::TST_double:
 157     if (DS.getTypeSpecWidth() == DeclSpec::TSW_long)
 158       Result = Context.LongDoubleTy;
 159     else
 160       Result = Context.DoubleTy;
 161     break;
 162   case DeclSpec::TST_bool: Result = Context.BoolTy; break; // _Bool or bool
 163   case DeclSpec::TST_decimal32:    // _Decimal32
 164   case DeclSpec::TST_decimal64:    // _Decimal64
 165   case DeclSpec::TST_decimal128:   // _Decimal128
 166     Diag(DS.getTypeSpecTypeLoc(), diag::err_decimal_unsupported);
 167     Result = Context.IntTy;
 168     isInvalid = true;
 169     break;
 170   case DeclSpec::TST_class:
 171   case DeclSpec::TST_enum:
 172   case DeclSpec::TST_union:
 173   case DeclSpec::TST_struct: {
 174     Decl *D = static_cast<Decl *>(DS.getTypeRep());
 175     assert(D && "Didn't get a decl for a class/enum/union/struct?");
 176     assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
 177            DS.getTypeSpecSign() == 0 &&
 178            "Can't handle qualifiers on typedef names yet!");
 179     // TypeQuals handled by caller.
 180     Result = Context.getTypeDeclType(cast<TypeDecl>(D));
 181
 182     if (D->isInvalidDecl())
 183       isInvalid = true;
 184     break;
 185   }
 186   case DeclSpec::TST_typename: {
 187     assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
 188            DS.getTypeSpecSign() == 0 &&
 189            "Can't handle qualifiers on typedef names yet!");
 190     Result = QualType::getFromOpaquePtr(DS.getTypeRep());
 191
 192     if (DeclSpec::ProtocolQualifierListTy PQ = DS.getProtocolQualifiers()) {
 193       // FIXME: Adding a TST_objcInterface clause doesn't seem ideal, so we have
 194       // this "hack" for now...
 195       if (const ObjCInterfaceType *Interface = Result->getAsObjCInterfaceType())
 196         Result = Context.getObjCQualifiedInterfaceType(Interface->getDecl(),
 197                                                        (ObjCProtocolDecl**)PQ,
 198                                                DS.getNumProtocolQualifiers());
 199       else if (Result == Context.getObjCIdType())
 200         // id<protocol-list>
 201         Result = Context.getObjCQualifiedIdType((ObjCProtocolDecl**)PQ,
 202                                                 DS.getNumProtocolQualifiers());
 203       else if (Result == Context.getObjCClassType()) {
 204         if (DeclLoc.isInvalid())
 205           DeclLoc = DS.getSourceRange().getBegin();
 206         // Class<protocol-list>
 207         Diag(DeclLoc, diag::err_qualified_class_unsupported)
 208           << DS.getSourceRange();
 209       } else {
 210         if (DeclLoc.isInvalid())
 211           DeclLoc = DS.getSourceRange().getBegin();
 212         Diag(DeclLoc, diag::err_invalid_protocol_qualifiers)
 213           << DS.getSourceRange();
 214         isInvalid = true;
 215       }
 216     }
 217
 218     // If this is a reference to an invalid typedef, propagate the invalidity.
 219     if (TypedefType *TDT = dyn_cast<TypedefType>(Result))
 220       if (TDT->getDecl()->isInvalidDecl())
 221         isInvalid = true;
 222
 223     // TypeQuals handled by caller.
 224     break;
 225   }
 226   case DeclSpec::TST_typeofType:
 227     Result = QualType::getFromOpaquePtr(DS.getTypeRep());
 228     assert(!Result.isNull() && "Didn't get a type for typeof?");
 229     // TypeQuals handled by caller.
 230     Result = Context.getTypeOfType(Result);
 231     break;
 232   case DeclSpec::TST_typeofExpr: {
 233     Expr *E = static_cast<Expr *>(DS.getTypeRep());
 234     assert(E && "Didn't get an expression for typeof?");
 235     // TypeQuals handled by caller.
 236     Result = Context.getTypeOfExprType(E);
 237     break;
 238   }
 239   case DeclSpec::TST_error:
 240     Result = Context.IntTy;
 241     isInvalid = true;
 242     break;
 243   }
 244
 245   // Handle complex types.
 246   if (DS.getTypeSpecComplex() == DeclSpec::TSC_complex) {
 247     if (getLangOptions().Freestanding)
 248       Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex);
 249     Result = Context.getComplexType(Result);
 250   }
 251
 252   assert(DS.getTypeSpecComplex() != DeclSpec::TSC_imaginary &&
 253          "FIXME: imaginary types not supported yet!");
 254
 255   // See if there are any attributes on the declspec that apply to the type (as
 256   // opposed to the decl).
 257   if (const AttributeList *AL = DS.getAttributes())
 258     ProcessTypeAttributeList(Result, AL);
 259
 260   // Apply const/volatile/restrict qualifiers to T.
 261   if (unsigned TypeQuals = DS.getTypeQualifiers()) {
 262
 263     // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
 264     // or incomplete types shall not be restrict-qualified."  C++ also allows
 265     // restrict-qualified references.
 266     if (TypeQuals & QualType::Restrict) {
 267       if (Result->isPointerType() || Result->isReferenceType()) {
 268         QualType EltTy = Result->isPointerType() ?
 269           Result->getAsPointerType()->getPointeeType() :
 270           Result->getAsReferenceType()->getPointeeType();
 271
 272         // If we have a pointer or reference, the pointee must have an object
 273         // incomplete type.
 274         if (!EltTy->isIncompleteOrObjectType()) {
 275           Diag(DS.getRestrictSpecLoc(),
 276                diag::err_typecheck_invalid_restrict_invalid_pointee)
 277             << EltTy << DS.getSourceRange();
 278           TypeQuals &= ~QualType::Restrict; // Remove the restrict qualifier.
 279         }
 280       } else {
 281         Diag(DS.getRestrictSpecLoc(),
 282              diag::err_typecheck_invalid_restrict_not_pointer)
 283           << Result << DS.getSourceRange();
 284         TypeQuals &= ~QualType::Restrict; // Remove the restrict qualifier.
 285       }
 286     }
 287
 288     // Warn about CV qualifiers on functions: C99 6.7.3p8: "If the specification
 289     // of a function type includes any type qualifiers, the behavior is
 290     // undefined."
 291     if (Result->isFunctionType() && TypeQuals) {
 292       // Get some location to point at, either the C or V location.
 293       SourceLocation Loc;
 294       if (TypeQuals & QualType::Const)
 295         Loc = DS.getConstSpecLoc();
 296       else {
 297         assert((TypeQuals & QualType::Volatile) &&
 298                "Has CV quals but not C or V?");
 299         Loc = DS.getVolatileSpecLoc();
 300       }
 301       Diag(Loc, diag::warn_typecheck_function_qualifiers)
 302         << Result << DS.getSourceRange();
 303     }
 304
 305     // C++ [dcl.ref]p1:
 306     //   Cv-qualified references are ill-formed except when the
 307     //   cv-qualifiers are introduced through the use of a typedef
 308     //   (7.1.3) or of a template type argument (14.3), in which
 309     //   case the cv-qualifiers are ignored.
 310     // FIXME: Shouldn't we be checking SCS_typedef here?
 311     if (DS.getTypeSpecType() == DeclSpec::TST_typename &&
 312         TypeQuals && Result->isReferenceType()) {
 313       TypeQuals &= ~QualType::Const;
 314       TypeQuals &= ~QualType::Volatile;
 315     }
 316
 317     Result = Result.getQualifiedType(TypeQuals);
 318   }
 319   return Result;
 320 }
 321
 322 static std::string getPrintableNameForEntity(DeclarationName Entity) {
 323   if (Entity)
 324     return Entity.getAsString();
 325
 326   return "type name";
 327 }
 328
 329 /// \brief Build a pointer type.
 330 ///
 331 /// \param T The type to which we'll be building a pointer.
 332 ///
 333 /// \param Quals The cvr-qualifiers to be applied to the pointer type.
 334 ///
 335 /// \param Loc The location of the entity whose type involves this
 336 /// pointer type or, if there is no such entity, the location of the
 337 /// type that will have pointer type.
 338 ///
 339 /// \param Entity The name of the entity that involves the pointer
 340 /// type, if known.
 341 ///
 342 /// \returns A suitable pointer type, if there are no
 343 /// errors. Otherwise, returns a NULL type.
 344 QualType Sema::BuildPointerType(QualType T, unsigned Quals,
 345                                 SourceLocation Loc, DeclarationName Entity) {
 346   if (T->isReferenceType()) {
 347     // C++ 8.3.2p4: There shall be no ... pointers to references ...
 348     Diag(Loc, diag::err_illegal_decl_pointer_to_reference)
 349       << getPrintableNameForEntity(Entity);
 350     return QualType();
 351   }
 352
 353   // Enforce C99 6.7.3p2: "Types other than pointer types derived from
 354   // object or incomplete types shall not be restrict-qualified."
 355   if ((Quals & QualType::Restrict) && !T->isIncompleteOrObjectType()) {
 356     Diag(Loc, diag::err_typecheck_invalid_restrict_invalid_pointee)
 357       << T;
 358     Quals &= ~QualType::Restrict;
 359   }
 360
 361   // Build the pointer type.
 362   return Context.getPointerType(T).getQualifiedType(Quals);
 363 }
 364
 365 /// \brief Build a reference type.
 366 ///
 367 /// \param T The type to which we'll be building a reference.
 368 ///
 369 /// \param Quals The cvr-qualifiers to be applied to the reference type.
 370 ///
 371 /// \param Loc The location of the entity whose type involves this
 372 /// reference type or, if there is no such entity, the location of the
 373 /// type that will have reference type.
 374 ///
 375 /// \param Entity The name of the entity that involves the reference
 376 /// type, if known.
 377 ///
 378 /// \returns A suitable reference type, if there are no
 379 /// errors. Otherwise, returns a NULL type.
 380 QualType Sema::BuildReferenceType(QualType T, bool LValueRef, unsigned Quals,
 381                                   SourceLocation Loc, DeclarationName Entity) {
 382   if (LValueRef) {
 383     if (const RValueReferenceType *R = T->getAsRValueReferenceType()) {
 384       // C++0x [dcl.typedef]p9: If a typedef TD names a type that is a
 385       //   reference to a type T, and attempt to create the type "lvalue
 386       //   reference to cv TD" creates the type "lvalue reference to T".
 387       // We use the qualifiers (restrict or none) of the original reference,
 388       // not the new ones. This is consistent with GCC.
 389       return Context.getLValueReferenceType(R->getPointeeType()).
 390                getQualifiedType(T.getCVRQualifiers());
 391     }
 392   }
 393   if (T->isReferenceType()) {
 394     // C++ [dcl.ref]p4: There shall be no references to references.
 395     //
 396     // According to C++ DR 106, references to references are only
 397     // diagnosed when they are written directly (e.g., "int & &"),
 398     // but not when they happen via a typedef:
 399     //
 400     //   typedef int& intref;
 401     //   typedef intref& intref2;
 402     //
 403     // Parser::ParserDeclaratorInternal diagnoses the case where
 404     // references are written directly; here, we handle the
 405     // collapsing of references-to-references as described in C++
 406     // DR 106 and amended by C++ DR 540.
 407     return T;
 408   }
 409
 410   // C++ [dcl.ref]p1:
 411   //   A declarator that specifies the type “reference to cv void”
 412   //   is ill-formed.
 413   if (T->isVoidType()) {
 414     Diag(Loc, diag::err_reference_to_void);
 415     return QualType();
 416   }
 417
 418   // Enforce C99 6.7.3p2: "Types other than pointer types derived from
 419   // object or incomplete types shall not be restrict-qualified."
 420   if ((Quals & QualType::Restrict) && !T->isIncompleteOrObjectType()) {
 421     Diag(Loc, diag::err_typecheck_invalid_restrict_invalid_pointee)
 422       << T;
 423     Quals &= ~QualType::Restrict;
 424   }
 425
 426   // C++ [dcl.ref]p1:
 427   //   [...] Cv-qualified references are ill-formed except when the
 428   //   cv-qualifiers are introduced through the use of a typedef
 429   //   (7.1.3) or of a template type argument (14.3), in which case
 430   //   the cv-qualifiers are ignored.
 431   //
 432   // We diagnose extraneous cv-qualifiers for the non-typedef,
 433   // non-template type argument case within the parser. Here, we just
 434   // ignore any extraneous cv-qualifiers.
 435   Quals &= ~QualType::Const;
 436   Quals &= ~QualType::Volatile;
 437
 438   // Handle restrict on references.
 439   if (LValueRef)
 440     return Context.getLValueReferenceType(T).getQualifiedType(Quals);
 441   return Context.getRValueReferenceType(T).getQualifiedType(Quals);
 442 }
 443
 444 /// \brief Build an array type.
 445 ///
 446 /// \param T The type of each element in the array.
 447 ///
 448 /// \param ASM C99 array size modifier (e.g., '*', 'static').
 449 ///
 450 /// \param ArraySize Expression describing the size of the array.
 451 ///
 452 /// \param Quals The cvr-qualifiers to be applied to the array's
 453 /// element type.
 454 ///
 455 /// \param Loc The location of the entity whose type involves this
 456 /// array type or, if there is no such entity, the location of the
 457 /// type that will have array type.
 458 ///
 459 /// \param Entity The name of the entity that involves the array
 460 /// type, if known.
 461 ///
 462 /// \returns A suitable array type, if there are no errors. Otherwise,
 463 /// returns a NULL type.
 464 QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
 465                               Expr *ArraySize, unsigned Quals,
 466                               SourceLocation Loc, DeclarationName Entity) {
 467   // C99 6.7.5.2p1: If the element type is an incomplete or function type,
 468   // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]())
 469   if (RequireCompleteType(Loc, T,
 470                              diag::err_illegal_decl_array_incomplete_type))
 471     return QualType();
 472
 473   if (T->isFunctionType()) {
 474     Diag(Loc, diag::err_illegal_decl_array_of_functions)
 475       << getPrintableNameForEntity(Entity);
 476     return QualType();
 477   }
 478
 479   // C++ 8.3.2p4: There shall be no ... arrays of references ...
 480   if (T->isReferenceType()) {
 481     Diag(Loc, diag::err_illegal_decl_array_of_references)
 482       << getPrintableNameForEntity(Entity);
 483     return QualType();
 484   }
 485
 486   if (const RecordType *EltTy = T->getAsRecordType()) {
 487     // If the element type is a struct or union that contains a variadic
 488     // array, accept it as a GNU extension: C99 6.7.2.1p2.
 489     if (EltTy->getDecl()->hasFlexibleArrayMember())
 490       Diag(Loc, diag::ext_flexible_array_in_array) << T;
 491   } else if (T->isObjCInterfaceType()) {
 492     Diag(Loc, diag::err_objc_array_of_interfaces) << T;
 493     return QualType();
 494   }
 495
 496   // C99 6.7.5.2p1: The size expression shall have integer type.
 497   if (ArraySize && !ArraySize->isTypeDependent() &&
 498       !ArraySize->getType()->isIntegerType()) {
 499     Diag(ArraySize->getLocStart(), diag::err_array_size_non_int)
 500       << ArraySize->getType() << ArraySize->getSourceRange();
 501     ArraySize->Destroy(Context);
 502     return QualType();
 503   }
 504   llvm::APSInt ConstVal(32);
 505   if (!ArraySize) {
 506     if (ASM == ArrayType::Star)
 507       T = Context.getVariableArrayType(T, 0, ASM, Quals);
 508     else
 509       T = Context.getIncompleteArrayType(T, ASM, Quals);
 510   } else if (ArraySize->isValueDependent()) {
 511     T = Context.getDependentSizedArrayType(T, ArraySize, ASM, Quals);
 512   } else if (!ArraySize->isIntegerConstantExpr(ConstVal, Context) ||
 513              (!T->isDependentType() && !T->isConstantSizeType())) {
 514     // Per C99, a variable array is an array with either a non-constant
 515     // size or an element type that has a non-constant-size
 516     T = Context.getVariableArrayType(T, ArraySize, ASM, Quals);
 517   } else {
 518     // C99 6.7.5.2p1: If the expression is a constant expression, it shall
 519     // have a value greater than zero.
 520     if (ConstVal.isSigned()) {
 521       if (ConstVal.isNegative()) {
 522         Diag(ArraySize->getLocStart(),
 523              diag::err_typecheck_negative_array_size)
 524           << ArraySize->getSourceRange();
 525         return QualType();
 526       } else if (ConstVal == 0) {
 527         // GCC accepts zero sized static arrays.
 528         Diag(ArraySize->getLocStart(), diag::ext_typecheck_zero_array_size)
 529           << ArraySize->getSourceRange();
 530       }
 531     }
 532     T = Context.getConstantArrayType(T, ConstVal, ASM, Quals);
 533   }
 534   // If this is not C99, extwarn about VLA's and C99 array size modifiers.
 535   if (!getLangOptions().C99) {
 536     if (ArraySize && !ArraySize->isTypeDependent() &&
 537         !ArraySize->isValueDependent() &&
 538         !ArraySize->isIntegerConstantExpr(Context))
 539       Diag(Loc, diag::ext_vla);
 540     else if (ASM != ArrayType::Normal || Quals != 0)
 541       Diag(Loc, diag::ext_c99_array_usage);
 542   }
 543
 544   return T;
 545 }
 546
 547 /// \brief Build a function type.
 548 ///
 549 /// This routine checks the function type according to C++ rules and
 550 /// under the assumption that the result type and parameter types have
 551 /// just been instantiated from a template. It therefore duplicates
 552 /// some of the behavior of GetTypeForDeclarator, but in a much
 553 /// simpler form that is only suitable for this narrow use case.
 554 ///
 555 /// \param T The return type of the function.
 556 ///
 557 /// \param ParamTypes The parameter types of the function. This array
 558 /// will be modified to account for adjustments to the types of the
 559 /// function parameters.
 560 ///
 561 /// \param NumParamTypes The number of parameter types in ParamTypes.
 562 ///
 563 /// \param Variadic Whether this is a variadic function type.
 564 ///
 565 /// \param Quals The cvr-qualifiers to be applied to the function type.
 566 ///
 567 /// \param Loc The location of the entity whose type involves this
 568 /// function type or, if there is no such entity, the location of the
 569 /// type that will have function type.
 570 ///
 571 /// \param Entity The name of the entity that involves the function
 572 /// type, if known.
 573 ///
 574 /// \returns A suitable function type, if there are no
 575 /// errors. Otherwise, returns a NULL type.
 576 QualType Sema::BuildFunctionType(QualType T,
 577                                  QualType *ParamTypes,
 578                                  unsigned NumParamTypes,
 579                                  bool Variadic, unsigned Quals,
 580                                  SourceLocation Loc, DeclarationName Entity) {
 581   if (T->isArrayType() || T->isFunctionType()) {
 582     Diag(Loc, diag::err_func_returning_array_function) << T;
 583     return QualType();
 584   }
 585
 586   bool Invalid = false;
 587   for (unsigned Idx = 0; Idx < NumParamTypes; ++Idx) {
 588     QualType ParamType = adjustParameterType(ParamTypes[Idx]);
 589     if (ParamType->isVoidType()) {
 590       Diag(Loc, diag::err_param_with_void_type);
 591       Invalid = true;
 592     }
 593
 594     ParamTypes[Idx] = ParamType;
 595   }
 596
 597   if (Invalid)
 598     return QualType();
 599
 600   return Context.getFunctionType(T, ParamTypes, NumParamTypes, Variadic,
 601                                  Quals);
 602 }
 603
 604 /// GetTypeForDeclarator - Convert the type for the specified
 605 /// declarator to Type instances. Skip the outermost Skip type
 606 /// objects.
 607 ///
 608 /// If OwnedDecl is non-NULL, and this declarator's decl-specifier-seq
 609 /// owns the declaration of a type (e.g., the definition of a struct
 610 /// type), then *OwnedDecl will receive the owned declaration.
 611 QualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip,
 612                                     TagDecl **OwnedDecl) {
 613   bool OmittedReturnType = false;
 614
 615   if (D.getContext() == Declarator::BlockLiteralContext
 616       && Skip == 0
 617       && !D.getDeclSpec().hasTypeSpecifier()
 618       && (D.getNumTypeObjects() == 0
 619           || (D.getNumTypeObjects() == 1
 620               && D.getTypeObject(0).Kind == DeclaratorChunk::Function)))
 621     OmittedReturnType = true;
 622
 623   // long long is a C99 feature.
 624   if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x &&
 625       D.getDeclSpec().getTypeSpecWidth() == DeclSpec::TSW_longlong)
 626     Diag(D.getDeclSpec().getTypeSpecWidthLoc(), diag::ext_longlong);
 627
 628   // Determine the type of the declarator. Not all forms of declarator
 629   // have a type.
 630   QualType T;
 631   switch (D.getKind()) {
 632   case Declarator::DK_Abstract:
 633   case Declarator::DK_Normal:
 634   case Declarator::DK_Operator: {
 635     const DeclSpec &DS = D.getDeclSpec();
 636     if (OmittedReturnType) {
 637       // We default to a dependent type initially.  Can be modified by
 638       // the first return statement.
 639       T = Context.DependentTy;
 640     } else {
 641       bool isInvalid = false;
 642       T = ConvertDeclSpecToType(DS, D.getIdentifierLoc(), isInvalid);
 643       if (isInvalid)
 644         D.setInvalidType(true);
 645       else if (OwnedDecl && DS.isTypeSpecOwned())
 646         *OwnedDecl = cast<TagDecl>((Decl *)DS.getTypeRep());
 647     }
 648     break;
 649   }
 650
 651   case Declarator::DK_Constructor:
 652   case Declarator::DK_Destructor:
 653   case Declarator::DK_Conversion:
 654     // Constructors and destructors don't have return types. Use
 655     // "void" instead. Conversion operators will check their return
 656     // types separately.
 657     T = Context.VoidTy;
 658     break;
 659   }
 660
 661   // The name we're declaring, if any.
 662   DeclarationName Name;
 663   if (D.getIdentifier())
 664     Name = D.getIdentifier();
 665
 666   // Walk the DeclTypeInfo, building the recursive type as we go.
 667   // DeclTypeInfos are ordered from the identifier out, which is
 668   // opposite of what we want :).
 669   for (unsigned i = Skip, e = D.getNumTypeObjects(); i != e; ++i) {
 670     DeclaratorChunk &DeclType = D.getTypeObject(e-i-1+Skip);
 671     switch (DeclType.Kind) {
 672     default: assert(0 && "Unknown decltype!");
 673     case DeclaratorChunk::BlockPointer:
 674       // If blocks are disabled, emit an error.
 675       if (!LangOpts.Blocks)
 676         Diag(DeclType.Loc, diag::err_blocks_disable);
 677
 678       if (!T.getTypePtr()->isFunctionType())
 679         Diag(D.getIdentifierLoc(), diag::err_nonfunction_block_type);
 680       else
 681         T = (Context.getBlockPointerType(T)
 682              .getQualifiedType(DeclType.Cls.TypeQuals));
 683       break;
 684     case DeclaratorChunk::Pointer:
 685       // Verify that we're not building a pointer to pointer to function with
 686       // exception specification.
 687       if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) {
 688         Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
 689         D.setInvalidType(true);
 690         // Build the type anyway.
 691       }
 692       T = BuildPointerType(T, DeclType.Ptr.TypeQuals, DeclType.Loc, Name);
 693       break;
 694     case DeclaratorChunk::Reference:
 695       // Verify that we're not building a reference to pointer to function with
 696       // exception specification.
 697       if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) {
 698         Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
 699         D.setInvalidType(true);
 700         // Build the type anyway.
 701       }
 702       T = BuildReferenceType(T, DeclType.Ref.LValueRef,
 703                              DeclType.Ref.HasRestrict ? QualType::Restrict : 0,
 704                              DeclType.Loc, Name);
 705       break;
 706     case DeclaratorChunk::Array: {
 707       // Verify that we're not building an array of pointers to function with
 708       // exception specification.
 709       if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) {
 710         Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
 711         D.setInvalidType(true);
 712         // Build the type anyway.
 713       }
 714       DeclaratorChunk::ArrayTypeInfo &ATI = DeclType.Arr;
 715       Expr *ArraySize = static_cast<Expr*>(ATI.NumElts);
 716       ArrayType::ArraySizeModifier ASM;
 717       if (ATI.isStar)
 718         ASM = ArrayType::Star;
 719       else if (ATI.hasStatic)
 720         ASM = ArrayType::Static;
 721       else
 722         ASM = ArrayType::Normal;
 723       if (ASM == ArrayType::Star &&
 724           D.getContext() != Declarator::PrototypeContext) {
 725         // FIXME: This check isn't quite right: it allows star in prototypes
 726         // for function definitions, and disallows some edge cases detailed
 727         // in http://gcc.gnu.org/ml/gcc-patches/2009-02/msg00133.html
 728         Diag(DeclType.Loc, diag::err_array_star_outside_prototype);
 729         ASM = ArrayType::Normal;
 730         D.setInvalidType(true);
 731       }
 732       T = BuildArrayType(T, ASM, ArraySize, ATI.TypeQuals, DeclType.Loc, Name);
 733       break;
 734     }
 735     case DeclaratorChunk::Function: {
 736       // If the function declarator has a prototype (i.e. it is not () and
 737       // does not have a K&R-style identifier list), then the arguments are part
 738       // of the type, otherwise the argument list is ().
 739       const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
 740
 741       // C99 6.7.5.3p1: The return type may not be a function or array type.
 742       if (T->isArrayType() || T->isFunctionType()) {
 743         Diag(DeclType.Loc, diag::err_func_returning_array_function) << T;
 744         T = Context.IntTy;
 745         D.setInvalidType(true);
 746       }
 747
 748       if (getLangOptions().CPlusPlus && D.getDeclSpec().isTypeSpecOwned()) {
 749         // C++ [dcl.fct]p6:
 750         //   Types shall not be defined in return or parameter types.
 751         TagDecl *Tag = cast<TagDecl>((Decl *)D.getDeclSpec().getTypeRep());
 752         if (Tag->isDefinition())
 753           Diag(Tag->getLocation(), diag::err_type_defined_in_result_type)
 754             << Context.getTypeDeclType(Tag);
 755       }
 756
 757       // Exception specs are not allowed in typedefs. Complain, but add it
 758       // anyway.
 759       if (FTI.hasExceptionSpec &&
 760           D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
 761         Diag(FTI.getThrowLoc(), diag::err_exception_spec_in_typedef);
 762
 763       if (FTI.NumArgs == 0) {
 764         if (getLangOptions().CPlusPlus) {
 765           // C++ 8.3.5p2: If the parameter-declaration-clause is empty, the
 766           // function takes no arguments.
 767           llvm::SmallVector<QualType, 4> Exceptions;
 768           Exceptions.reserve(FTI.NumExceptions);
 769           for(unsigned ei = 0, ee = FTI.NumExceptions; ei != ee; ++ei) {
 770             QualType ET = QualType::getFromOpaquePtr(FTI.Exceptions[ei].Ty);
 771             // Check that the type is valid for an exception spec, and drop it
 772             // if not.
 773             if (!CheckSpecifiedExceptionType(ET, FTI.Exceptions[ei].Range))
 774               Exceptions.push_back(ET);
 775           }
 776           T = Context.getFunctionType(T, NULL, 0, FTI.isVariadic, FTI.TypeQuals,
 777                                       FTI.hasExceptionSpec,
 778                                       FTI.hasAnyExceptionSpec,
 779                                       Exceptions.size(), Exceptions.data());
 780         } else if (FTI.isVariadic) {
 781           // We allow a zero-parameter variadic function in C if the
 782           // function is marked with the "overloadable"
 783           // attribute. Scan for this attribute now.
 784           bool Overloadable = false;
 785           for (const AttributeList *Attrs = D.getAttributes();
 786                Attrs; Attrs = Attrs->getNext()) {
 787             if (Attrs->getKind() == AttributeList::AT_overloadable) {
 788               Overloadable = true;
 789               break;
 790             }
 791           }
 792
 793           if (!Overloadable)
 794             Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_arg);
 795           T = Context.getFunctionType(T, NULL, 0, FTI.isVariadic, 0);
 796         } else {
 797           // Simple void foo(), where the incoming T is the result type.
 798           T = Context.getFunctionNoProtoType(T);
 799         }
 800       } else if (FTI.ArgInfo[0].Param == 0) {
 801         // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function definition.
 802         Diag(FTI.ArgInfo[0].IdentLoc, diag::err_ident_list_in_fn_declaration);
 803       } else {
 804         // Otherwise, we have a function with an argument list that is
 805         // potentially variadic.
 806         llvm::SmallVector<QualType, 16> ArgTys;
 807
 808         for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
 809           ParmVarDecl *Param =
 810             cast<ParmVarDecl>(FTI.ArgInfo[i].Param.getAs<Decl>());
 811           QualType ArgTy = Param->getType();
 812           assert(!ArgTy.isNull() && "Couldn't parse type?");
 813
 814           // Adjust the parameter type.
 815           assert((ArgTy == adjustParameterType(ArgTy)) && "Unadjusted type?");
 816
 817           // Look for 'void'.  void is allowed only as a single argument to a
 818           // function with no other parameters (C99 6.7.5.3p10).  We record
 819           // int(void) as a FunctionProtoType with an empty argument list.
 820           if (ArgTy->isVoidType()) {
 821             // If this is something like 'float(int, void)', reject it.  'void'
 822             // is an incomplete type (C99 6.2.5p19) and function decls cannot
 823             // have arguments of incomplete type.
 824             if (FTI.NumArgs != 1 || FTI.isVariadic) {
 825               Diag(DeclType.Loc, diag::err_void_only_param);
 826               ArgTy = Context.IntTy;
 827               Param->setType(ArgTy);
 828             } else if (FTI.ArgInfo[i].Ident) {
 829               // Reject, but continue to parse 'int(void abc)'.
 830               Diag(FTI.ArgInfo[i].IdentLoc,
 831                    diag::err_param_with_void_type);
 832               ArgTy = Context.IntTy;
 833               Param->setType(ArgTy);
 834             } else {
 835               // Reject, but continue to parse 'float(const void)'.
 836               if (ArgTy.getCVRQualifiers())
 837                 Diag(DeclType.Loc, diag::err_void_param_qualified);
 838
 839               // Do not add 'void' to the ArgTys list.
 840               break;
 841             }
 842           } else if (!FTI.hasPrototype) {
 843             if (ArgTy->isPromotableIntegerType()) {
 844               ArgTy = Context.IntTy;
 845             } else if (const BuiltinType* BTy = ArgTy->getAsBuiltinType()) {
 846               if (BTy->getKind() == BuiltinType::Float)
 847                 ArgTy = Context.DoubleTy;
 848             }
 849           }
 850
 851           ArgTys.push_back(ArgTy);
 852         }
 853
 854         llvm::SmallVector<QualType, 4> Exceptions;
 855         Exceptions.reserve(FTI.NumExceptions);
 856         for(unsigned ei = 0, ee = FTI.NumExceptions; ei != ee; ++ei) {
 857           QualType ET = QualType::getFromOpaquePtr(FTI.Exceptions[ei].Ty);
 858           // Check that the type is valid for an exception spec, and drop it if
 859           // not.
 860           if (!CheckSpecifiedExceptionType(ET, FTI.Exceptions[ei].Range))
 861             Exceptions.push_back(ET);
 862         }
 863
 864         T = Context.getFunctionType(T, ArgTys.data(), ArgTys.size(),
 865                                     FTI.isVariadic, FTI.TypeQuals,
 866                                     FTI.hasExceptionSpec,
 867                                     FTI.hasAnyExceptionSpec,
 868                                     Exceptions.size(), Exceptions.data());
 869       }
 870       break;
 871     }
 872     case DeclaratorChunk::MemberPointer:
 873       // Verify that we're not building a pointer to pointer to function with
 874       // exception specification.
 875       if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) {
 876         Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
 877         D.setInvalidType(true);
 878         // Build the type anyway.
 879       }
 880       // The scope spec must refer to a class, or be dependent.
 881       DeclContext *DC = computeDeclContext(DeclType.Mem.Scope());
 882       QualType ClsType;
 883       // FIXME: Extend for dependent types when it's actually supported.
 884       // See ActOnCXXNestedNameSpecifier.
 885       if (CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(DC)) {
 886         ClsType = Context.getTagDeclType(RD);
 887       } else {
 888         if (DC) {
 889           Diag(DeclType.Mem.Scope().getBeginLoc(),
 890                diag::err_illegal_decl_mempointer_in_nonclass)
 891             << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name")
 892             << DeclType.Mem.Scope().getRange();
 893         }
 894         D.setInvalidType(true);
 895         ClsType = Context.IntTy;
 896       }
 897
 898       // C++ 8.3.3p3: A pointer to member shall not pointer to ... a member
 899       //   with reference type, or "cv void."
 900       if (T->isReferenceType()) {
 901         Diag(DeclType.Loc, diag::err_illegal_decl_pointer_to_reference)
 902           << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name");
 903         D.setInvalidType(true);
 904         T = Context.IntTy;
 905       }
 906       if (T->isVoidType()) {
 907         Diag(DeclType.Loc, diag::err_illegal_decl_mempointer_to_void)
 908           << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name");
 909         T = Context.IntTy;
 910       }
 911
 912       // Enforce C99 6.7.3p2: "Types other than pointer types derived from
 913       // object or incomplete types shall not be restrict-qualified."
 914       if ((DeclType.Mem.TypeQuals & QualType::Restrict) &&
 915           !T->isIncompleteOrObjectType()) {
 916         Diag(DeclType.Loc, diag::err_typecheck_invalid_restrict_invalid_pointee)
 917           << T;
 918         DeclType.Mem.TypeQuals &= ~QualType::Restrict;
 919       }
 920
 921       T = Context.getMemberPointerType(T, ClsType.getTypePtr()).
 922                     getQualifiedType(DeclType.Mem.TypeQuals);
 923
 924       break;
 925     }
 926
 927     if (T.isNull()) {
 928       D.setInvalidType(true);
 929       T = Context.IntTy;
 930     }
 931
 932     // See if there are any attributes on this declarator chunk.
 933     if (const AttributeList *AL = DeclType.getAttrs())
 934       ProcessTypeAttributeList(T, AL);
 935   }
 936
 937   if (getLangOptions().CPlusPlus && T->isFunctionType()) {
 938     const FunctionProtoType *FnTy = T->getAsFunctionProtoType();
 939     assert(FnTy && "Why oh why is there not a FunctionProtoType here ?");
 940
 941     // C++ 8.3.5p4: A cv-qualifier-seq shall only be part of the function type
 942     // for a nonstatic member function, the function type to which a pointer
 943     // to member refers, or the top-level function type of a function typedef
 944     // declaration.
 945     if (FnTy->getTypeQuals() != 0 &&
 946         D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
 947         ((D.getContext() != Declarator::MemberContext &&
 948           (!D.getCXXScopeSpec().isSet() ||
 949            !computeDeclContext(D.getCXXScopeSpec())->isRecord())) ||
 950          D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static)) {
 951       if (D.isFunctionDeclarator())
 952         Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_function_type);
 953       else
 954         Diag(D.getIdentifierLoc(),
 955              diag::err_invalid_qualified_typedef_function_type_use);
 956
 957       // Strip the cv-quals from the type.
 958       T = Context.getFunctionType(FnTy->getResultType(), FnTy->arg_type_begin(),
 959                                   FnTy->getNumArgs(), FnTy->isVariadic(), 0);
 960     }
 961   }
 962
 963   // If there were any type attributes applied to the decl itself (not the
 964   // type, apply the type attribute to the type!)
 965   if (const AttributeList *Attrs = D.getAttributes())
 966     ProcessTypeAttributeList(T, Attrs);
 967
 968   return T;
 969 }
 970
 971 /// CheckSpecifiedExceptionType - Check if the given type is valid in an
 972 /// exception specification. Incomplete types, or pointers to incomplete types
 973 /// other than void are not allowed.
 974 bool Sema::CheckSpecifiedExceptionType(QualType T, const SourceRange &Range) {
 975   // FIXME: This may not correctly work with the fix for core issue 437,
 976   // where a class's own type is considered complete within its body.
 977
 978   // C++ 15.4p2: A type denoted in an exception-specification shall not denote
 979   //   an incomplete type.
 980   if (T->isIncompleteType())
 981     return Diag(Range.getBegin(), diag::err_incomplete_in_exception_spec)
 982       << Range << T << /*direct*/0;
 983
 984   // C++ 15.4p2: A type denoted in an exception-specification shall not denote
 985   //   an incomplete type a pointer or reference to an incomplete type, other
 986   //   than (cv) void*.
 987   int kind;
 988   if (const PointerType* IT = T->getAsPointerType()) {
 989     T = IT->getPointeeType();
 990     kind = 1;
 991   } else if (const ReferenceType* IT = T->getAsReferenceType()) {
 992     T = IT->getPointeeType();
 993     kind = 2;
 994   } else
 995     return false;
 996
 997   if (T->isIncompleteType() && !T->isVoidType())
 998     return Diag(Range.getBegin(), diag::err_incomplete_in_exception_spec)
 999       << Range << T << /*indirect*/kind;
1000
1001   return false;
1002 }
1003
1004 /// CheckDistantExceptionSpec - Check if the given type is a pointer or pointer
1005 /// to member to a function with an exception specification. This means that
1006 /// it is invalid to add another level of indirection.
1007 bool Sema::CheckDistantExceptionSpec(QualType T) {
1008   if (const PointerType *PT = T->getAsPointerType())
1009     T = PT->getPointeeType();
1010   else if (const MemberPointerType *PT = T->getAsMemberPointerType())
1011     T = PT->getPointeeType();
1012   else
1013     return false;
1014
1015   const FunctionProtoType *FnT = T->getAsFunctionProtoType();
1016   if (!FnT)
1017     return false;
1018
1019   return FnT->hasExceptionSpec();
1020 }
1021
1022 /// ObjCGetTypeForMethodDefinition - Builds the type for a method definition
1023 /// declarator
1024 QualType Sema::ObjCGetTypeForMethodDefinition(DeclPtrTy D) {
1025   ObjCMethodDecl *MDecl = cast<ObjCMethodDecl>(D.getAs<Decl>());
1026   QualType T = MDecl->getResultType();
1027   llvm::SmallVector<QualType, 16> ArgTys;
1028
1029   // Add the first two invisible argument types for self and _cmd.
1030   if (MDecl->isInstanceMethod()) {
1031     QualType selfTy = Context.getObjCInterfaceType(MDecl->getClassInterface());
1032     selfTy = Context.getPointerType(selfTy);
1033     ArgTys.push_back(selfTy);
1034   } else
1035     ArgTys.push_back(Context.getObjCIdType());
1036   ArgTys.push_back(Context.getObjCSelType());
1037
1038   for (ObjCMethodDecl::param_iterator PI = MDecl->param_begin(),
1039        E = MDecl->param_end(); PI != E; ++PI) {
1040     QualType ArgTy = (*PI)->getType();
1041     assert(!ArgTy.isNull() && "Couldn't parse type?");
1042     ArgTy = adjustParameterType(ArgTy);
1043     ArgTys.push_back(ArgTy);
1044   }
1045   T = Context.getFunctionType(T, &ArgTys[0], ArgTys.size(),
1046                               MDecl->isVariadic(), 0);
1047   return T;
1048 }
1049
1050 /// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types  that
1051 /// may be similar (C++ 4.4), replaces T1 and T2 with the type that
1052 /// they point to and return true. If T1 and T2 aren't pointer types
1053 /// or pointer-to-member types, or if they are not similar at this
1054 /// level, returns false and leaves T1 and T2 unchanged. Top-level
1055 /// qualifiers on T1 and T2 are ignored. This function will typically
1056 /// be called in a loop that successively "unwraps" pointer and
1057 /// pointer-to-member types to compare them at each level.
1058 bool Sema::UnwrapSimilarPointerTypes(QualType& T1, QualType& T2) {
1059   const PointerType *T1PtrType = T1->getAsPointerType(),
1060                     *T2PtrType = T2->getAsPointerType();
1061   if (T1PtrType && T2PtrType) {
1062     T1 = T1PtrType->getPointeeType();
1063     T2 = T2PtrType->getPointeeType();
1064     return true;
1065   }
1066
1067   const MemberPointerType *T1MPType = T1->getAsMemberPointerType(),
1068                           *T2MPType = T2->getAsMemberPointerType();
1069   if (T1MPType && T2MPType &&
1070       Context.getCanonicalType(T1MPType->getClass()) ==
1071       Context.getCanonicalType(T2MPType->getClass())) {
1072     T1 = T1MPType->getPointeeType();
1073     T2 = T2MPType->getPointeeType();
1074     return true;
1075   }
1076   return false;
1077 }
1078
1079 Sema::TypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) {
1080   // C99 6.7.6: Type names have no identifier.  This is already validated by
1081   // the parser.
1082   assert(D.getIdentifier() == 0 && "Type name should have no identifier!");
1083
1084   TagDecl *OwnedTag = 0;
1085   QualType T = GetTypeForDeclarator(D, S, /*Skip=*/0, &OwnedTag);
1086   if (D.isInvalidType())
1087     return true;
1088
1089   if (getLangOptions().CPlusPlus) {
1090     // Check that there are no default arguments (C++ only).
1091     CheckExtraCXXDefaultArguments(D);
1092
1093     // C++0x [dcl.type]p3:
1094     //   A type-specifier-seq shall not define a class or enumeration
1095     //   unless it appears in the type-id of an alias-declaration
1096     //   (7.1.3).
1097     if (OwnedTag && OwnedTag->isDefinition())
1098       Diag(OwnedTag->getLocation(), diag::err_type_defined_in_type_specifier)
1099         << Context.getTypeDeclType(OwnedTag);
1100   }
1101
1102   return T.getAsOpaquePtr();
1103 }
1104
1105
1106
1107 //===----------------------------------------------------------------------===//
1108 // Type Attribute Processing
1109 //===----------------------------------------------------------------------===//
1110
1111 /// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the
1112 /// specified type.  The attribute contains 1 argument, the id of the address
1113 /// space for the type.
1114 static void HandleAddressSpaceTypeAttribute(QualType &Type,
1115                                             const AttributeList &Attr, Sema &S){
1116   // If this type is already address space qualified, reject it.
1117   // Clause 6.7.3 - Type qualifiers: "No type shall be qualified by qualifiers
1118   // for two or more different address spaces."
1119   if (Type.getAddressSpace()) {
1120     S.Diag(Attr.getLoc(), diag::err_attribute_address_multiple_qualifiers);
1121     return;
1122   }
1123
1124   // Check the attribute arguments.
1125   if (Attr.getNumArgs() != 1) {
1126     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1127     return;
1128   }
1129   Expr *ASArgExpr = static_cast<Expr *>(Attr.getArg(0));
1130   llvm::APSInt addrSpace(32);
1131   if (!ASArgExpr->isIntegerConstantExpr(addrSpace, S.Context)) {
1132     S.Diag(Attr.getLoc(), diag::err_attribute_address_space_not_int)
1133       << ASArgExpr->getSourceRange();
1134     return;
1135   }
1136
1137   unsigned ASIdx = static_cast<unsigned>(addrSpace.getZExtValue());
1138   Type = S.Context.getAddrSpaceQualType(Type, ASIdx);
1139 }
1140
1141 /// HandleObjCGCTypeAttribute - Process an objc's gc attribute on the
1142 /// specified type.  The attribute contains 1 argument, weak or strong.
1143 static void HandleObjCGCTypeAttribute(QualType &Type,
1144                                       const AttributeList &Attr, Sema &S) {
1145   if (Type.getObjCGCAttr() != QualType::GCNone) {
1146     S.Diag(Attr.getLoc(), diag::err_attribute_multiple_objc_gc);
1147     return;
1148   }
1149
1150   // Check the attribute arguments.
1151   if (!Attr.getParameterName()) {
1152     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1153       << "objc_gc" << 1;
1154     return;
1155   }
1156   QualType::GCAttrTypes GCAttr;
1157   if (Attr.getNumArgs() != 0) {
1158     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1159     return;
1160   }
1161   if (Attr.getParameterName()->isStr("weak"))
1162     GCAttr = QualType::Weak;
1163   else if (Attr.getParameterName()->isStr("strong"))
1164     GCAttr = QualType::Strong;
1165   else {
1166     S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
1167       << "objc_gc" << Attr.getParameterName();
1168     return;
1169   }
1170
1171   Type = S.Context.getObjCGCQualType(Type, GCAttr);
1172 }
1173
1174 void Sema::ProcessTypeAttributeList(QualType &Result, const AttributeList *AL) {
1175   // Scan through and apply attributes to this type where it makes sense.  Some
1176   // attributes (such as __address_space__, __vector_size__, etc) apply to the
1177   // type, but others can be present in the type specifiers even though they
1178   // apply to the decl.  Here we apply type attributes and ignore the rest.
1179   for (; AL; AL = AL->getNext()) {
1180     // If this is an attribute we can handle, do so now, otherwise, add it to
1181     // the LeftOverAttrs list for rechaining.
1182     switch (AL->getKind()) {
1183     default: break;
1184     case AttributeList::AT_address_space:
1185       HandleAddressSpaceTypeAttribute(Result, *AL, *this);
1186       break;
1187     case AttributeList::AT_objc_gc:
1188       HandleObjCGCTypeAttribute(Result, *AL, *this);
1189       break;
1190     }
1191   }
1192 }
1193
1194 /// @brief Ensure that the type T is a complete type.
1195 ///
1196 /// This routine checks whether the type @p T is complete in any
1197 /// context where a complete type is required. If @p T is a complete
1198 /// type, returns false. If @p T is a class template specialization,
1199 /// this routine then attempts to perform class template
1200 /// instantiation. If instantiation fails, or if @p T is incomplete
1201 /// and cannot be completed, issues the diagnostic @p diag (giving it
1202 /// the type @p T) and returns true.
1203 ///
1204 /// @param Loc  The location in the source that the incomplete type
1205 /// diagnostic should refer to.
1206 ///
1207 /// @param T  The type that this routine is examining for completeness.
1208 ///
1209 /// @param diag The diagnostic value (e.g.,
1210 /// @c diag::err_typecheck_decl_incomplete_type) that will be used
1211 /// for the error message if @p T is incomplete.
1212 ///
1213 /// @param Range1  An optional range in the source code that will be a
1214 /// part of the "incomplete type" error message.
1215 ///
1216 /// @param Range2  An optional range in the source code that will be a
1217 /// part of the "incomplete type" error message.
1218 ///
1219 /// @param PrintType If non-NULL, the type that should be printed
1220 /// instead of @p T. This parameter should be used when the type that
1221 /// we're checking for incompleteness isn't the type that should be
1222 /// displayed to the user, e.g., when T is a type and PrintType is a
1223 /// pointer to T.
1224 ///
1225 /// @returns @c true if @p T is incomplete and a diagnostic was emitted,
1226 /// @c false otherwise.
1227 bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, unsigned diag,
1228                                SourceRange Range1, SourceRange Range2,
1229                                QualType PrintType) {
1230   // FIXME: Add this assertion to help us flush out problems with
1231   // checking for dependent types and type-dependent expressions.
1232   //
1233   //  assert(!T->isDependentType() &&
1234   //         "Can't ask whether a dependent type is complete");
1235
1236   // If we have a complete type, we're done.
1237   if (!T->isIncompleteType())
1238     return false;
1239
1240   // If we have a class template specialization or a class member of a
1241   // class template specialization, try to instantiate it.
1242   if (const RecordType *Record = T->getAsRecordType()) {
1243     if (ClassTemplateSpecializationDecl *ClassTemplateSpec
1244           = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
1245       if (ClassTemplateSpec->getSpecializationKind() == TSK_Undeclared) {
1246         // Update the class template specialization's location to
1247         // refer to the point of instantiation.
1248         if (Loc.isValid())
1249           ClassTemplateSpec->setLocation(Loc);
1250         return InstantiateClassTemplateSpecialization(ClassTemplateSpec,
1251                                              /*ExplicitInstantiation=*/false);
1252       }
1253     } else if (CXXRecordDecl *Rec
1254                  = dyn_cast<CXXRecordDecl>(Record->getDecl())) {
1255       if (CXXRecordDecl *Pattern = Rec->getInstantiatedFromMemberClass()) {
1256         // Find the class template specialization that surrounds this
1257         // member class.
1258         ClassTemplateSpecializationDecl *Spec = 0;
1259         for (DeclContext *Parent = Rec->getDeclContext();
1260              Parent && !Spec; Parent = Parent->getParent())
1261           Spec = dyn_cast<ClassTemplateSpecializationDecl>(Parent);
1262         assert(Spec && "Not a member of a class template specialization?");
1263         return InstantiateClass(Loc, Rec, Pattern, Spec->getTemplateArgs(),
1264                                 /*ExplicitInstantiation=*/false);
1265       }
1266     }
1267   }
1268
1269   if (PrintType.isNull())
1270     PrintType = T;
1271
1272   // We have an incomplete type. Produce a diagnostic.
1273   Diag(Loc, diag) << PrintType << Range1 << Range2;
1274
1275   // If the type was a forward declaration of a class/struct/union
1276   // type, produce
1277   const TagType *Tag = 0;
1278   if (const RecordType *Record = T->getAsRecordType())
1279     Tag = Record;
1280   else if (const EnumType *Enum = T->getAsEnumType())
1281     Tag = Enum;
1282
1283   if (Tag && !Tag->getDecl()->isInvalidDecl())
1284     Diag(Tag->getDecl()->getLocation(),
1285          Tag->isBeingDefined() ? diag::note_type_being_defined
1286                                : diag::note_forward_declaration)
1287         << QualType(Tag, 0);
1288
1289   return true;
1290 }
1291
1292 /// \brief Retrieve a version of the type 'T' that is qualified by the
1293 /// nested-name-specifier contained in SS.
1294 QualType Sema::getQualifiedNameType(const CXXScopeSpec &SS, QualType T) {
1295   if (!SS.isSet() || SS.isInvalid() || T.isNull())
1296     return T;
1297
1298   NestedNameSpecifier *NNS
1299     = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
1300   return Context.getQualifiedNameType(NNS, T);
1301 }