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/CXXInheritance.h"
  17 #include "clang/AST/DeclObjC.h"
  18 #include "clang/AST/DeclTemplate.h"
  19 #include "clang/AST/TypeLoc.h"
  20 #include "clang/AST/TypeLocVisitor.h"
  21 #include "clang/AST/Expr.h"
  22 #include "clang/Basic/PartialDiagnostic.h"
  23 #include "clang/Parse/DeclSpec.h"
  24 #include "llvm/ADT/SmallPtrSet.h"
  25 #include "llvm/Support/ErrorHandling.h"
  26 using namespace clang;
  27
  28 /// \brief Perform adjustment on the parameter type of a function.
  29 ///
  30 /// This routine adjusts the given parameter type @p T to the actual
  31 /// parameter type used by semantic analysis (C99 6.7.5.3p[7,8],
  32 /// C++ [dcl.fct]p3). The adjusted parameter type is returned.
  33 QualType Sema::adjustParameterType(QualType T) {
  34   // C99 6.7.5.3p7:
  35   //   A declaration of a parameter as "array of type" shall be
  36   //   adjusted to "qualified pointer to type", where the type
  37   //   qualifiers (if any) are those specified within the [ and ] of
  38   //   the array type derivation.
  39   if (T->isArrayType())
  40     return Context.getArrayDecayedType(T);
  41
  42   // C99 6.7.5.3p8:
  43   //   A declaration of a parameter as "function returning type"
  44   //   shall be adjusted to "pointer to function returning type", as
  45   //   in 6.3.2.1.
  46   if (T->isFunctionType())
  47     return Context.getPointerType(T);
  48
  49   return T;
  50 }
  51
  52
  53
  54 /// isOmittedBlockReturnType - Return true if this declarator is missing a
  55 /// return type because this is a omitted return type on a block literal.
  56 static bool isOmittedBlockReturnType(const Declarator &D) {
  57   if (D.getContext() != Declarator::BlockLiteralContext ||
  58       D.getDeclSpec().hasTypeSpecifier())
  59     return false;
  60
  61   if (D.getNumTypeObjects() == 0)
  62     return true;   // ^{ ... }
  63
  64   if (D.getNumTypeObjects() == 1 &&
  65       D.getTypeObject(0).Kind == DeclaratorChunk::Function)
  66     return true;   // ^(int X, float Y) { ... }
  67
  68   return false;
  69 }
  70
  71 /// \brief Convert the specified declspec to the appropriate type
  72 /// object.
  73 /// \param D  the declarator containing the declaration specifier.
  74 /// \returns The type described by the declaration specifiers.  This function
  75 /// never returns null.
  76 static QualType ConvertDeclSpecToType(Declarator &TheDeclarator, Sema &TheSema){
  77   // FIXME: Should move the logic from DeclSpec::Finish to here for validity
  78   // checking.
  79   const DeclSpec &DS = TheDeclarator.getDeclSpec();
  80   SourceLocation DeclLoc = TheDeclarator.getIdentifierLoc();
  81   if (DeclLoc.isInvalid())
  82     DeclLoc = DS.getSourceRange().getBegin();
  83
  84   ASTContext &Context = TheSema.Context;
  85
  86   QualType Result;
  87   switch (DS.getTypeSpecType()) {
  88   case DeclSpec::TST_void:
  89     Result = Context.VoidTy;
  90     break;
  91   case DeclSpec::TST_char:
  92     if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified)
  93       Result = Context.CharTy;
  94     else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed)
  95       Result = Context.SignedCharTy;
  96     else {
  97       assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
  98              "Unknown TSS value");
  99       Result = Context.UnsignedCharTy;
 100     }
 101     break;
 102   case DeclSpec::TST_wchar:
 103     if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified)
 104       Result = Context.WCharTy;
 105     else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) {
 106       TheSema.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
 107         << DS.getSpecifierName(DS.getTypeSpecType());
 108       Result = Context.getSignedWCharType();
 109     } else {
 110       assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
 111         "Unknown TSS value");
 112       TheSema.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
 113         << DS.getSpecifierName(DS.getTypeSpecType());
 114       Result = Context.getUnsignedWCharType();
 115     }
 116     break;
 117   case DeclSpec::TST_char16:
 118       assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
 119         "Unknown TSS value");
 120       Result = Context.Char16Ty;
 121     break;
 122   case DeclSpec::TST_char32:
 123       assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
 124         "Unknown TSS value");
 125       Result = Context.Char32Ty;
 126     break;
 127   case DeclSpec::TST_unspecified:
 128     // "<proto1,proto2>" is an objc qualified ID with a missing id.
 129     if (DeclSpec::ProtocolQualifierListTy PQ = DS.getProtocolQualifiers()) {
 130       Result = Context.getObjCObjectPointerType(Context.ObjCBuiltinIdTy,
 131                                                 (ObjCProtocolDecl**)PQ,
 132                                                 DS.getNumProtocolQualifiers());
 133       break;
 134     }
 135
 136     // If this is a missing declspec in a block literal return context, then it
 137     // is inferred from the return statements inside the block.
 138     if (isOmittedBlockReturnType(TheDeclarator)) {
 139       Result = Context.DependentTy;
 140       break;
 141     }
 142
 143     // Unspecified typespec defaults to int in C90.  However, the C90 grammar
 144     // [C90 6.5] only allows a decl-spec if there was *some* type-specifier,
 145     // type-qualifier, or storage-class-specifier.  If not, emit an extwarn.
 146     // Note that the one exception to this is function definitions, which are
 147     // allowed to be completely missing a declspec.  This is handled in the
 148     // parser already though by it pretending to have seen an 'int' in this
 149     // case.
 150     if (TheSema.getLangOptions().ImplicitInt) {
 151       // In C89 mode, we only warn if there is a completely missing declspec
 152       // when one is not allowed.
 153       if (DS.isEmpty()) {
 154         TheSema.Diag(DeclLoc, diag::ext_missing_declspec)
 155           << DS.getSourceRange()
 156         << CodeModificationHint::CreateInsertion(DS.getSourceRange().getBegin(),
 157                                                  "int");
 158       }
 159     } else if (!DS.hasTypeSpecifier()) {
 160       // C99 and C++ require a type specifier.  For example, C99 6.7.2p2 says:
 161       // "At least one type specifier shall be given in the declaration
 162       // specifiers in each declaration, and in the specifier-qualifier list in
 163       // each struct declaration and type name."
 164       // FIXME: Does Microsoft really have the implicit int extension in C++?
 165       if (TheSema.getLangOptions().CPlusPlus &&
 166           !TheSema.getLangOptions().Microsoft) {
 167         TheSema.Diag(DeclLoc, diag::err_missing_type_specifier)
 168           << DS.getSourceRange();
 169
 170         // When this occurs in C++ code, often something is very broken with the
 171         // value being declared, poison it as invalid so we don't get chains of
 172         // errors.
 173         TheDeclarator.setInvalidType(true);
 174       } else {
 175         TheSema.Diag(DeclLoc, diag::ext_missing_type_specifier)
 176           << DS.getSourceRange();
 177       }
 178     }
 179
 180     // FALL THROUGH.
 181   case DeclSpec::TST_int: {
 182     if (DS.getTypeSpecSign() != DeclSpec::TSS_unsigned) {
 183       switch (DS.getTypeSpecWidth()) {
 184       case DeclSpec::TSW_unspecified: Result = Context.IntTy; break;
 185       case DeclSpec::TSW_short:       Result = Context.ShortTy; break;
 186       case DeclSpec::TSW_long:        Result = Context.LongTy; break;
 187       case DeclSpec::TSW_longlong:
 188         Result = Context.LongLongTy;
 189
 190         // long long is a C99 feature.
 191         if (!TheSema.getLangOptions().C99 &&
 192             !TheSema.getLangOptions().CPlusPlus0x)
 193           TheSema.Diag(DS.getTypeSpecWidthLoc(), diag::ext_longlong);
 194         break;
 195       }
 196     } else {
 197       switch (DS.getTypeSpecWidth()) {
 198       case DeclSpec::TSW_unspecified: Result = Context.UnsignedIntTy; break;
 199       case DeclSpec::TSW_short:       Result = Context.UnsignedShortTy; break;
 200       case DeclSpec::TSW_long:        Result = Context.UnsignedLongTy; break;
 201       case DeclSpec::TSW_longlong:
 202         Result = Context.UnsignedLongLongTy;
 203
 204         // long long is a C99 feature.
 205         if (!TheSema.getLangOptions().C99 &&
 206             !TheSema.getLangOptions().CPlusPlus0x)
 207           TheSema.Diag(DS.getTypeSpecWidthLoc(), diag::ext_longlong);
 208         break;
 209       }
 210     }
 211     break;
 212   }
 213   case DeclSpec::TST_float: Result = Context.FloatTy; break;
 214   case DeclSpec::TST_double:
 215     if (DS.getTypeSpecWidth() == DeclSpec::TSW_long)
 216       Result = Context.LongDoubleTy;
 217     else
 218       Result = Context.DoubleTy;
 219     break;
 220   case DeclSpec::TST_bool: Result = Context.BoolTy; break; // _Bool or bool
 221   case DeclSpec::TST_decimal32:    // _Decimal32
 222   case DeclSpec::TST_decimal64:    // _Decimal64
 223   case DeclSpec::TST_decimal128:   // _Decimal128
 224     TheSema.Diag(DS.getTypeSpecTypeLoc(), diag::err_decimal_unsupported);
 225     Result = Context.IntTy;
 226     TheDeclarator.setInvalidType(true);
 227     break;
 228   case DeclSpec::TST_class:
 229   case DeclSpec::TST_enum:
 230   case DeclSpec::TST_union:
 231   case DeclSpec::TST_struct: {
 232     TypeDecl *D
 233       = dyn_cast_or_null<TypeDecl>(static_cast<Decl *>(DS.getTypeRep()));
 234     if (!D) {
 235       // This can happen in C++ with ambiguous lookups.
 236       Result = Context.IntTy;
 237       TheDeclarator.setInvalidType(true);
 238       break;
 239     }
 240
 241     // If the type is deprecated or unavailable, diagnose it.
 242     TheSema.DiagnoseUseOfDecl(D, DS.getTypeSpecTypeLoc());
 243
 244     assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
 245            DS.getTypeSpecSign() == 0 && "No qualifiers on tag names!");
 246
 247     // TypeQuals handled by caller.
 248     Result = Context.getTypeDeclType(D);
 249
 250     // In C++, make an ElaboratedType.
 251     if (TheSema.getLangOptions().CPlusPlus) {
 252       TagDecl::TagKind Tag
 253         = TagDecl::getTagKindForTypeSpec(DS.getTypeSpecType());
 254       Result = Context.getElaboratedType(Result, Tag);
 255     }
 256
 257     if (D->isInvalidDecl())
 258       TheDeclarator.setInvalidType(true);
 259     break;
 260   }
 261   case DeclSpec::TST_typename: {
 262     assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
 263            DS.getTypeSpecSign() == 0 &&
 264            "Can't handle qualifiers on typedef names yet!");
 265     Result = TheSema.GetTypeFromParser(DS.getTypeRep());
 266
 267     if (DeclSpec::ProtocolQualifierListTy PQ = DS.getProtocolQualifiers()) {
 268       if (const ObjCInterfaceType *
 269             Interface = Result->getAs<ObjCInterfaceType>()) {
 270         // It would be nice if protocol qualifiers were only stored with the
 271         // ObjCObjectPointerType. Unfortunately, this isn't possible due
 272         // to the following typedef idiom (which is uncommon, but allowed):
 273         //
 274         // typedef Foo<P> T;
 275         // static void func() {
 276         //   Foo<P> *yy;
 277         //   T *zz;
 278         // }
 279         Result = Context.getObjCInterfaceType(Interface->getDecl(),
 280                                               (ObjCProtocolDecl**)PQ,
 281                                               DS.getNumProtocolQualifiers());
 282       } else if (Result->isObjCIdType())
 283         // id<protocol-list>
 284         Result = Context.getObjCObjectPointerType(Context.ObjCBuiltinIdTy,
 285                         (ObjCProtocolDecl**)PQ, DS.getNumProtocolQualifiers());
 286       else if (Result->isObjCClassType()) {
 287         // Class<protocol-list>
 288         Result = Context.getObjCObjectPointerType(Context.ObjCBuiltinClassTy,
 289                         (ObjCProtocolDecl**)PQ, DS.getNumProtocolQualifiers());
 290       } else {
 291         TheSema.Diag(DeclLoc, diag::err_invalid_protocol_qualifiers)
 292           << DS.getSourceRange();
 293         TheDeclarator.setInvalidType(true);
 294       }
 295     }
 296
 297     // TypeQuals handled by caller.
 298     break;
 299   }
 300   case DeclSpec::TST_typeofType:
 301     // FIXME: Preserve type source info.
 302     Result = TheSema.GetTypeFromParser(DS.getTypeRep());
 303     assert(!Result.isNull() && "Didn't get a type for typeof?");
 304     // TypeQuals handled by caller.
 305     Result = Context.getTypeOfType(Result);
 306     break;
 307   case DeclSpec::TST_typeofExpr: {
 308     Expr *E = static_cast<Expr *>(DS.getTypeRep());
 309     assert(E && "Didn't get an expression for typeof?");
 310     // TypeQuals handled by caller.
 311     Result = TheSema.BuildTypeofExprType(E);
 312     if (Result.isNull()) {
 313       Result = Context.IntTy;
 314       TheDeclarator.setInvalidType(true);
 315     }
 316     break;
 317   }
 318   case DeclSpec::TST_decltype: {
 319     Expr *E = static_cast<Expr *>(DS.getTypeRep());
 320     assert(E && "Didn't get an expression for decltype?");
 321     // TypeQuals handled by caller.
 322     Result = TheSema.BuildDecltypeType(E);
 323     if (Result.isNull()) {
 324       Result = Context.IntTy;
 325       TheDeclarator.setInvalidType(true);
 326     }
 327     break;
 328   }
 329   case DeclSpec::TST_auto: {
 330     // TypeQuals handled by caller.
 331     Result = Context.UndeducedAutoTy;
 332     break;
 333   }
 334
 335   case DeclSpec::TST_error:
 336     Result = Context.IntTy;
 337     TheDeclarator.setInvalidType(true);
 338     break;
 339   }
 340
 341   // Handle complex types.
 342   if (DS.getTypeSpecComplex() == DeclSpec::TSC_complex) {
 343     if (TheSema.getLangOptions().Freestanding)
 344       TheSema.Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex);
 345     Result = Context.getComplexType(Result);
 346   }
 347
 348   assert(DS.getTypeSpecComplex() != DeclSpec::TSC_imaginary &&
 349          "FIXME: imaginary types not supported yet!");
 350
 351   // See if there are any attributes on the declspec that apply to the type (as
 352   // opposed to the decl).
 353   if (const AttributeList *AL = DS.getAttributes())
 354     TheSema.ProcessTypeAttributeList(Result, AL);
 355
 356   // Apply const/volatile/restrict qualifiers to T.
 357   if (unsigned TypeQuals = DS.getTypeQualifiers()) {
 358
 359     // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
 360     // or incomplete types shall not be restrict-qualified."  C++ also allows
 361     // restrict-qualified references.
 362     if (TypeQuals & DeclSpec::TQ_restrict) {
 363       if (Result->isAnyPointerType() || Result->isReferenceType()) {
 364         QualType EltTy;
 365         if (Result->isObjCObjectPointerType())
 366           EltTy = Result;
 367         else
 368           EltTy = Result->isPointerType() ?
 369                     Result->getAs<PointerType>()->getPointeeType() :
 370                     Result->getAs<ReferenceType>()->getPointeeType();
 371
 372         // If we have a pointer or reference, the pointee must have an object
 373         // incomplete type.
 374         if (!EltTy->isIncompleteOrObjectType()) {
 375           TheSema.Diag(DS.getRestrictSpecLoc(),
 376                diag::err_typecheck_invalid_restrict_invalid_pointee)
 377             << EltTy << DS.getSourceRange();
 378           TypeQuals &= ~DeclSpec::TQ_restrict; // Remove the restrict qualifier.
 379         }
 380       } else {
 381         TheSema.Diag(DS.getRestrictSpecLoc(),
 382              diag::err_typecheck_invalid_restrict_not_pointer)
 383           << Result << DS.getSourceRange();
 384         TypeQuals &= ~DeclSpec::TQ_restrict; // Remove the restrict qualifier.
 385       }
 386     }
 387
 388     // Warn about CV qualifiers on functions: C99 6.7.3p8: "If the specification
 389     // of a function type includes any type qualifiers, the behavior is
 390     // undefined."
 391     if (Result->isFunctionType() && TypeQuals) {
 392       // Get some location to point at, either the C or V location.
 393       SourceLocation Loc;
 394       if (TypeQuals & DeclSpec::TQ_const)
 395         Loc = DS.getConstSpecLoc();
 396       else if (TypeQuals & DeclSpec::TQ_volatile)
 397         Loc = DS.getVolatileSpecLoc();
 398       else {
 399         assert((TypeQuals & DeclSpec::TQ_restrict) &&
 400                "Has CVR quals but not C, V, or R?");
 401         Loc = DS.getRestrictSpecLoc();
 402       }
 403       TheSema.Diag(Loc, diag::warn_typecheck_function_qualifiers)
 404         << Result << DS.getSourceRange();
 405     }
 406
 407     // C++ [dcl.ref]p1:
 408     //   Cv-qualified references are ill-formed except when the
 409     //   cv-qualifiers are introduced through the use of a typedef
 410     //   (7.1.3) or of a template type argument (14.3), in which
 411     //   case the cv-qualifiers are ignored.
 412     // FIXME: Shouldn't we be checking SCS_typedef here?
 413     if (DS.getTypeSpecType() == DeclSpec::TST_typename &&
 414         TypeQuals && Result->isReferenceType()) {
 415       TypeQuals &= ~DeclSpec::TQ_const;
 416       TypeQuals &= ~DeclSpec::TQ_volatile;
 417     }
 418
 419     Qualifiers Quals = Qualifiers::fromCVRMask(TypeQuals);
 420     Result = Context.getQualifiedType(Result, Quals);
 421   }
 422
 423   return Result;
 424 }
 425
 426 static std::string getPrintableNameForEntity(DeclarationName Entity) {
 427   if (Entity)
 428     return Entity.getAsString();
 429
 430   return "type name";
 431 }
 432
 433 /// \brief Build a pointer type.
 434 ///
 435 /// \param T The type to which we'll be building a pointer.
 436 ///
 437 /// \param Quals The cvr-qualifiers to be applied to the pointer type.
 438 ///
 439 /// \param Loc The location of the entity whose type involves this
 440 /// pointer type or, if there is no such entity, the location of the
 441 /// type that will have pointer type.
 442 ///
 443 /// \param Entity The name of the entity that involves the pointer
 444 /// type, if known.
 445 ///
 446 /// \returns A suitable pointer type, if there are no
 447 /// errors. Otherwise, returns a NULL type.
 448 QualType Sema::BuildPointerType(QualType T, unsigned Quals,
 449                                 SourceLocation Loc, DeclarationName Entity) {
 450   if (T->isReferenceType()) {
 451     // C++ 8.3.2p4: There shall be no ... pointers to references ...
 452     Diag(Loc, diag::err_illegal_decl_pointer_to_reference)
 453       << getPrintableNameForEntity(Entity) << T;
 454     return QualType();
 455   }
 456
 457   Qualifiers Qs = Qualifiers::fromCVRMask(Quals);
 458
 459   // Enforce C99 6.7.3p2: "Types other than pointer types derived from
 460   // object or incomplete types shall not be restrict-qualified."
 461   if (Qs.hasRestrict() && !T->isIncompleteOrObjectType()) {
 462     Diag(Loc, diag::err_typecheck_invalid_restrict_invalid_pointee)
 463       << T;
 464     Qs.removeRestrict();
 465   }
 466
 467   // Build the pointer type.
 468   return Context.getQualifiedType(Context.getPointerType(T), Qs);
 469 }
 470
 471 /// \brief Build a reference type.
 472 ///
 473 /// \param T The type to which we'll be building a reference.
 474 ///
 475 /// \param CVR The cvr-qualifiers to be applied to the reference type.
 476 ///
 477 /// \param Loc The location of the entity whose type involves this
 478 /// reference type or, if there is no such entity, the location of the
 479 /// type that will have reference type.
 480 ///
 481 /// \param Entity The name of the entity that involves the reference
 482 /// type, if known.
 483 ///
 484 /// \returns A suitable reference type, if there are no
 485 /// errors. Otherwise, returns a NULL type.
 486 QualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue,
 487                                   unsigned CVR, SourceLocation Loc,
 488                                   DeclarationName Entity) {
 489   Qualifiers Quals = Qualifiers::fromCVRMask(CVR);
 490
 491   bool LValueRef = SpelledAsLValue || T->getAs<LValueReferenceType>();
 492
 493   // C++0x [dcl.typedef]p9: If a typedef TD names a type that is a
 494   //   reference to a type T, and attempt to create the type "lvalue
 495   //   reference to cv TD" creates the type "lvalue reference to T".
 496   // We use the qualifiers (restrict or none) of the original reference,
 497   // not the new ones. This is consistent with GCC.
 498
 499   // C++ [dcl.ref]p4: There shall be no references to references.
 500   //
 501   // According to C++ DR 106, references to references are only
 502   // diagnosed when they are written directly (e.g., "int & &"),
 503   // but not when they happen via a typedef:
 504   //
 505   //   typedef int& intref;
 506   //   typedef intref& intref2;
 507   //
 508   // Parser::ParseDeclaratorInternal diagnoses the case where
 509   // references are written directly; here, we handle the
 510   // collapsing of references-to-references as described in C++
 511   // DR 106 and amended by C++ DR 540.
 512
 513   // C++ [dcl.ref]p1:
 514   //   A declarator that specifies the type "reference to cv void"
 515   //   is ill-formed.
 516   if (T->isVoidType()) {
 517     Diag(Loc, diag::err_reference_to_void);
 518     return QualType();
 519   }
 520
 521   // Enforce C99 6.7.3p2: "Types other than pointer types derived from
 522   // object or incomplete types shall not be restrict-qualified."
 523   if (Quals.hasRestrict() && !T->isIncompleteOrObjectType()) {
 524     Diag(Loc, diag::err_typecheck_invalid_restrict_invalid_pointee)
 525       << T;
 526     Quals.removeRestrict();
 527   }
 528
 529   // C++ [dcl.ref]p1:
 530   //   [...] Cv-qualified references are ill-formed except when the
 531   //   cv-qualifiers are introduced through the use of a typedef
 532   //   (7.1.3) or of a template type argument (14.3), in which case
 533   //   the cv-qualifiers are ignored.
 534   //
 535   // We diagnose extraneous cv-qualifiers for the non-typedef,
 536   // non-template type argument case within the parser. Here, we just
 537   // ignore any extraneous cv-qualifiers.
 538   Quals.removeConst();
 539   Quals.removeVolatile();
 540
 541   // Handle restrict on references.
 542   if (LValueRef)
 543     return Context.getQualifiedType(
 544                Context.getLValueReferenceType(T, SpelledAsLValue), Quals);
 545   return Context.getQualifiedType(Context.getRValueReferenceType(T), Quals);
 546 }
 547
 548 /// \brief Build an array type.
 549 ///
 550 /// \param T The type of each element in the array.
 551 ///
 552 /// \param ASM C99 array size modifier (e.g., '*', 'static').
 553 ///
 554 /// \param ArraySize Expression describing the size of the array.
 555 ///
 556 /// \param Quals The cvr-qualifiers to be applied to the array's
 557 /// element type.
 558 ///
 559 /// \param Loc The location of the entity whose type involves this
 560 /// array type or, if there is no such entity, the location of the
 561 /// type that will have array type.
 562 ///
 563 /// \param Entity The name of the entity that involves the array
 564 /// type, if known.
 565 ///
 566 /// \returns A suitable array type, if there are no errors. Otherwise,
 567 /// returns a NULL type.
 568 QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
 569                               Expr *ArraySize, unsigned Quals,
 570                               SourceRange Brackets, DeclarationName Entity) {
 571
 572   SourceLocation Loc = Brackets.getBegin();
 573   // C99 6.7.5.2p1: If the element type is an incomplete or function type,
 574   // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]())
 575   // Not in C++, though. There we only dislike void.
 576   if (getLangOptions().CPlusPlus) {
 577     if (T->isVoidType()) {
 578       Diag(Loc, diag::err_illegal_decl_array_incomplete_type) << T;
 579       return QualType();
 580     }
 581   } else {
 582     if (RequireCompleteType(Loc, T,
 583                             diag::err_illegal_decl_array_incomplete_type))
 584       return QualType();
 585   }
 586
 587   if (T->isFunctionType()) {
 588     Diag(Loc, diag::err_illegal_decl_array_of_functions)
 589       << getPrintableNameForEntity(Entity) << T;
 590     return QualType();
 591   }
 592
 593   // C++ 8.3.2p4: There shall be no ... arrays of references ...
 594   if (T->isReferenceType()) {
 595     Diag(Loc, diag::err_illegal_decl_array_of_references)
 596       << getPrintableNameForEntity(Entity) << T;
 597     return QualType();
 598   }
 599
 600   if (Context.getCanonicalType(T) == Context.UndeducedAutoTy) {
 601     Diag(Loc,  diag::err_illegal_decl_array_of_auto)
 602       << getPrintableNameForEntity(Entity);
 603     return QualType();
 604   }
 605
 606   if (const RecordType *EltTy = T->getAs<RecordType>()) {
 607     // If the element type is a struct or union that contains a variadic
 608     // array, accept it as a GNU extension: C99 6.7.2.1p2.
 609     if (EltTy->getDecl()->hasFlexibleArrayMember())
 610       Diag(Loc, diag::ext_flexible_array_in_array) << T;
 611   } else if (T->isObjCInterfaceType()) {
 612     Diag(Loc, diag::err_objc_array_of_interfaces) << T;
 613     return QualType();
 614   }
 615
 616   // C99 6.7.5.2p1: The size expression shall have integer type.
 617   if (ArraySize && !ArraySize->isTypeDependent() &&
 618       !ArraySize->getType()->isIntegerType()) {
 619     Diag(ArraySize->getLocStart(), diag::err_array_size_non_int)
 620       << ArraySize->getType() << ArraySize->getSourceRange();
 621     ArraySize->Destroy(Context);
 622     return QualType();
 623   }
 624   llvm::APSInt ConstVal(32);
 625   if (!ArraySize) {
 626     if (ASM == ArrayType::Star)
 627       T = Context.getVariableArrayType(T, 0, ASM, Quals, Brackets);
 628     else
 629       T = Context.getIncompleteArrayType(T, ASM, Quals);
 630   } else if (ArraySize->isValueDependent()) {
 631     T = Context.getDependentSizedArrayType(T, ArraySize, ASM, Quals, Brackets);
 632   } else if (!ArraySize->isIntegerConstantExpr(ConstVal, Context) ||
 633              (!T->isDependentType() && !T->isIncompleteType() &&
 634               !T->isConstantSizeType())) {
 635     // Per C99, a variable array is an array with either a non-constant
 636     // size or an element type that has a non-constant-size
 637     T = Context.getVariableArrayType(T, ArraySize, ASM, Quals, Brackets);
 638   } else {
 639     // C99 6.7.5.2p1: If the expression is a constant expression, it shall
 640     // have a value greater than zero.
 641     if (ConstVal.isSigned() && ConstVal.isNegative()) {
 642       Diag(ArraySize->getLocStart(),
 643            diag::err_typecheck_negative_array_size)
 644         << ArraySize->getSourceRange();
 645       return QualType();
 646     }
 647     if (ConstVal == 0) {
 648       // GCC accepts zero sized static arrays.
 649       Diag(ArraySize->getLocStart(), diag::ext_typecheck_zero_array_size)
 650         << ArraySize->getSourceRange();
 651     }
 652     T = Context.getConstantArrayType(T, ConstVal, ASM, Quals);
 653   }
 654   // If this is not C99, extwarn about VLA's and C99 array size modifiers.
 655   if (!getLangOptions().C99) {
 656     if (ArraySize && !ArraySize->isTypeDependent() &&
 657         !ArraySize->isValueDependent() &&
 658         !ArraySize->isIntegerConstantExpr(Context))
 659       Diag(Loc, getLangOptions().CPlusPlus? diag::err_vla_cxx : diag::ext_vla);
 660     else if (ASM != ArrayType::Normal || Quals != 0)
 661       Diag(Loc,
 662            getLangOptions().CPlusPlus? diag::err_c99_array_usage_cxx
 663                                      : diag::ext_c99_array_usage);
 664   }
 665
 666   return T;
 667 }
 668
 669 /// \brief Build an ext-vector type.
 670 ///
 671 /// Run the required checks for the extended vector type.
 672 QualType Sema::BuildExtVectorType(QualType T, ExprArg ArraySize,
 673                                   SourceLocation AttrLoc) {
 674
 675   Expr *Arg = (Expr *)ArraySize.get();
 676
 677   // unlike gcc's vector_size attribute, we do not allow vectors to be defined
 678   // in conjunction with complex types (pointers, arrays, functions, etc.).
 679   if (!T->isDependentType() &&
 680       !T->isIntegerType() && !T->isRealFloatingType()) {
 681     Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << T;
 682     return QualType();
 683   }
 684
 685   if (!Arg->isTypeDependent() && !Arg->isValueDependent()) {
 686     llvm::APSInt vecSize(32);
 687     if (!Arg->isIntegerConstantExpr(vecSize, Context)) {
 688       Diag(AttrLoc, diag::err_attribute_argument_not_int)
 689       << "ext_vector_type" << Arg->getSourceRange();
 690       return QualType();
 691     }
 692
 693     // unlike gcc's vector_size attribute, the size is specified as the
 694     // number of elements, not the number of bytes.
 695     unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue());
 696
 697     if (vectorSize == 0) {
 698       Diag(AttrLoc, diag::err_attribute_zero_size)
 699       << Arg->getSourceRange();
 700       return QualType();
 701     }
 702
 703     if (!T->isDependentType())
 704       return Context.getExtVectorType(T, vectorSize);
 705   }
 706
 707   return Context.getDependentSizedExtVectorType(T, ArraySize.takeAs<Expr>(),
 708                                                 AttrLoc);
 709 }
 710
 711 /// \brief Build a function type.
 712 ///
 713 /// This routine checks the function type according to C++ rules and
 714 /// under the assumption that the result type and parameter types have
 715 /// just been instantiated from a template. It therefore duplicates
 716 /// some of the behavior of GetTypeForDeclarator, but in a much
 717 /// simpler form that is only suitable for this narrow use case.
 718 ///
 719 /// \param T The return type of the function.
 720 ///
 721 /// \param ParamTypes The parameter types of the function. This array
 722 /// will be modified to account for adjustments to the types of the
 723 /// function parameters.
 724 ///
 725 /// \param NumParamTypes The number of parameter types in ParamTypes.
 726 ///
 727 /// \param Variadic Whether this is a variadic function type.
 728 ///
 729 /// \param Quals The cvr-qualifiers to be applied to the function type.
 730 ///
 731 /// \param Loc The location of the entity whose type involves this
 732 /// function type or, if there is no such entity, the location of the
 733 /// type that will have function type.
 734 ///
 735 /// \param Entity The name of the entity that involves the function
 736 /// type, if known.
 737 ///
 738 /// \returns A suitable function type, if there are no
 739 /// errors. Otherwise, returns a NULL type.
 740 QualType Sema::BuildFunctionType(QualType T,
 741                                  QualType *ParamTypes,
 742                                  unsigned NumParamTypes,
 743                                  bool Variadic, unsigned Quals,
 744                                  SourceLocation Loc, DeclarationName Entity) {
 745   if (T->isArrayType() || T->isFunctionType()) {
 746     Diag(Loc, diag::err_func_returning_array_function) << T;
 747     return QualType();
 748   }
 749
 750   bool Invalid = false;
 751   for (unsigned Idx = 0; Idx < NumParamTypes; ++Idx) {
 752     QualType ParamType = adjustParameterType(ParamTypes[Idx]);
 753     if (ParamType->isVoidType()) {
 754       Diag(Loc, diag::err_param_with_void_type);
 755       Invalid = true;
 756     }
 757
 758     ParamTypes[Idx] = ParamType;
 759   }
 760
 761   if (Invalid)
 762     return QualType();
 763
 764   return Context.getFunctionType(T, ParamTypes, NumParamTypes, Variadic,
 765                                  Quals);
 766 }
 767
 768 /// \brief Build a member pointer type \c T Class::*.
 769 ///
 770 /// \param T the type to which the member pointer refers.
 771 /// \param Class the class type into which the member pointer points.
 772 /// \param CVR Qualifiers applied to the member pointer type
 773 /// \param Loc the location where this type begins
 774 /// \param Entity the name of the entity that will have this member pointer type
 775 ///
 776 /// \returns a member pointer type, if successful, or a NULL type if there was
 777 /// an error.
 778 QualType Sema::BuildMemberPointerType(QualType T, QualType Class,
 779                                       unsigned CVR, SourceLocation Loc,
 780                                       DeclarationName Entity) {
 781   Qualifiers Quals = Qualifiers::fromCVRMask(CVR);
 782
 783   // Verify that we're not building a pointer to pointer to function with
 784   // exception specification.
 785   if (CheckDistantExceptionSpec(T)) {
 786     Diag(Loc, diag::err_distant_exception_spec);
 787
 788     // FIXME: If we're doing this as part of template instantiation,
 789     // we should return immediately.
 790
 791     // Build the type anyway, but use the canonical type so that the
 792     // exception specifiers are stripped off.
 793     T = Context.getCanonicalType(T);
 794   }
 795
 796   // C++ 8.3.3p3: A pointer to member shall not pointer to ... a member
 797   //   with reference type, or "cv void."
 798   if (T->isReferenceType()) {
 799     Diag(Loc, diag::err_illegal_decl_mempointer_to_reference)
 800       << (Entity? Entity.getAsString() : "type name") << T;
 801     return QualType();
 802   }
 803
 804   if (T->isVoidType()) {
 805     Diag(Loc, diag::err_illegal_decl_mempointer_to_void)
 806       << (Entity? Entity.getAsString() : "type name");
 807     return QualType();
 808   }
 809
 810   // Enforce C99 6.7.3p2: "Types other than pointer types derived from
 811   // object or incomplete types shall not be restrict-qualified."
 812   if (Quals.hasRestrict() && !T->isIncompleteOrObjectType()) {
 813     Diag(Loc, diag::err_typecheck_invalid_restrict_invalid_pointee)
 814       << T;
 815
 816     // FIXME: If we're doing this as part of template instantiation,
 817     // we should return immediately.
 818     Quals.removeRestrict();
 819   }
 820
 821   if (!Class->isDependentType() && !Class->isRecordType()) {
 822     Diag(Loc, diag::err_mempointer_in_nonclass_type) << Class;
 823     return QualType();
 824   }
 825
 826   return Context.getQualifiedType(
 827            Context.getMemberPointerType(T, Class.getTypePtr()), Quals);
 828 }
 829
 830 /// \brief Build a block pointer type.
 831 ///
 832 /// \param T The type to which we'll be building a block pointer.
 833 ///
 834 /// \param CVR The cvr-qualifiers to be applied to the block pointer type.
 835 ///
 836 /// \param Loc The location of the entity whose type involves this
 837 /// block pointer type or, if there is no such entity, the location of the
 838 /// type that will have block pointer type.
 839 ///
 840 /// \param Entity The name of the entity that involves the block pointer
 841 /// type, if known.
 842 ///
 843 /// \returns A suitable block pointer type, if there are no
 844 /// errors. Otherwise, returns a NULL type.
 845 QualType Sema::BuildBlockPointerType(QualType T, unsigned CVR,
 846                                      SourceLocation Loc,
 847                                      DeclarationName Entity) {
 848   if (!T->isFunctionType()) {
 849     Diag(Loc, diag::err_nonfunction_block_type);
 850     return QualType();
 851   }
 852
 853   Qualifiers Quals = Qualifiers::fromCVRMask(CVR);
 854   return Context.getQualifiedType(Context.getBlockPointerType(T), Quals);
 855 }
 856
 857 QualType Sema::GetTypeFromParser(TypeTy *Ty, TypeSourceInfo **TInfo) {
 858   QualType QT = QualType::getFromOpaquePtr(Ty);
 859   if (QT.isNull()) {
 860     if (TInfo) *TInfo = 0;
 861     return QualType();
 862   }
 863
 864   TypeSourceInfo *DI = 0;
 865   if (LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
 866     QT = LIT->getType();
 867     DI = LIT->getTypeSourceInfo();
 868   }
 869
 870   if (TInfo) *TInfo = DI;
 871   return QT;
 872 }
 873
 874 /// GetTypeForDeclarator - Convert the type for the specified
 875 /// declarator to Type instances.
 876 ///
 877 /// If OwnedDecl is non-NULL, and this declarator's decl-specifier-seq
 878 /// owns the declaration of a type (e.g., the definition of a struct
 879 /// type), then *OwnedDecl will receive the owned declaration.
 880 QualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S,
 881                                     TypeSourceInfo **TInfo,
 882                                     TagDecl **OwnedDecl) {
 883   // Determine the type of the declarator. Not all forms of declarator
 884   // have a type.
 885   QualType T;
 886
 887   switch (D.getName().getKind()) {
 888   case UnqualifiedId::IK_Identifier:
 889   case UnqualifiedId::IK_OperatorFunctionId:
 890   case UnqualifiedId::IK_LiteralOperatorId:
 891   case UnqualifiedId::IK_TemplateId:
 892     T = ConvertDeclSpecToType(D, *this);
 893
 894     if (!D.isInvalidType() && OwnedDecl && D.getDeclSpec().isTypeSpecOwned())
 895       *OwnedDecl = cast<TagDecl>((Decl *)D.getDeclSpec().getTypeRep());
 896     break;
 897
 898   case UnqualifiedId::IK_ConstructorName:
 899   case UnqualifiedId::IK_DestructorName:
 900   case UnqualifiedId::IK_ConversionFunctionId:
 901     // Constructors and destructors don't have return types. Use
 902     // "void" instead. Conversion operators will check their return
 903     // types separately.
 904     T = Context.VoidTy;
 905     break;
 906   }
 907
 908   if (T.isNull())
 909     return T;
 910
 911   if (T == Context.UndeducedAutoTy) {
 912     int Error = -1;
 913
 914     switch (D.getContext()) {
 915     case Declarator::KNRTypeListContext:
 916       assert(0 && "K&R type lists aren't allowed in C++");
 917       break;
 918     case Declarator::PrototypeContext:
 919       Error = 0; // Function prototype
 920       break;
 921     case Declarator::MemberContext:
 922       switch (cast<TagDecl>(CurContext)->getTagKind()) {
 923       case TagDecl::TK_enum: assert(0 && "unhandled tag kind"); break;
 924       case TagDecl::TK_struct: Error = 1; /* Struct member */ break;
 925       case TagDecl::TK_union:  Error = 2; /* Union member */ break;
 926       case TagDecl::TK_class:  Error = 3; /* Class member */ break;
 927       }
 928       break;
 929     case Declarator::CXXCatchContext:
 930       Error = 4; // Exception declaration
 931       break;
 932     case Declarator::TemplateParamContext:
 933       Error = 5; // Template parameter
 934       break;
 935     case Declarator::BlockLiteralContext:
 936       Error = 6;  // Block literal
 937       break;
 938     case Declarator::FileContext:
 939     case Declarator::BlockContext:
 940     case Declarator::ForContext:
 941     case Declarator::ConditionContext:
 942     case Declarator::TypeNameContext:
 943       break;
 944     }
 945
 946     if (Error != -1) {
 947       Diag(D.getDeclSpec().getTypeSpecTypeLoc(), diag::err_auto_not_allowed)
 948         << Error;
 949       T = Context.IntTy;
 950       D.setInvalidType(true);
 951     }
 952   }
 953
 954   // The name we're declaring, if any.
 955   DeclarationName Name;
 956   if (D.getIdentifier())
 957     Name = D.getIdentifier();
 958
 959   // Walk the DeclTypeInfo, building the recursive type as we go.
 960   // DeclTypeInfos are ordered from the identifier out, which is
 961   // opposite of what we want :).
 962   for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
 963     DeclaratorChunk &DeclType = D.getTypeObject(e-i-1);
 964     switch (DeclType.Kind) {
 965     default: assert(0 && "Unknown decltype!");
 966     case DeclaratorChunk::BlockPointer:
 967       // If blocks are disabled, emit an error.
 968       if (!LangOpts.Blocks)
 969         Diag(DeclType.Loc, diag::err_blocks_disable);
 970
 971       T = BuildBlockPointerType(T, DeclType.Cls.TypeQuals, D.getIdentifierLoc(),
 972                                 Name);
 973       break;
 974     case DeclaratorChunk::Pointer:
 975       // Verify that we're not building a pointer to pointer to function with
 976       // exception specification.
 977       if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) {
 978         Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
 979         D.setInvalidType(true);
 980         // Build the type anyway.
 981       }
 982       if (getLangOptions().ObjC1 && T->isObjCInterfaceType()) {
 983         const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>();
 984         T = Context.getObjCObjectPointerType(T,
 985                                          (ObjCProtocolDecl **)OIT->qual_begin(),
 986                                          OIT->getNumProtocols());
 987         break;
 988       }
 989       T = BuildPointerType(T, DeclType.Ptr.TypeQuals, DeclType.Loc, Name);
 990       break;
 991     case DeclaratorChunk::Reference: {
 992       Qualifiers Quals;
 993       if (DeclType.Ref.HasRestrict) Quals.addRestrict();
 994
 995       // Verify that we're not building a reference to pointer to function with
 996       // exception specification.
 997       if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) {
 998         Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
 999         D.setInvalidType(true);
1000         // Build the type anyway.
1001       }
1002       T = BuildReferenceType(T, DeclType.Ref.LValueRef, Quals,
1003                              DeclType.Loc, Name);
1004       break;
1005     }
1006     case DeclaratorChunk::Array: {
1007       // Verify that we're not building an array of pointers to function with
1008       // exception specification.
1009       if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) {
1010         Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
1011         D.setInvalidType(true);
1012         // Build the type anyway.
1013       }
1014       DeclaratorChunk::ArrayTypeInfo &ATI = DeclType.Arr;
1015       Expr *ArraySize = static_cast<Expr*>(ATI.NumElts);
1016       ArrayType::ArraySizeModifier ASM;
1017       if (ATI.isStar)
1018         ASM = ArrayType::Star;
1019       else if (ATI.hasStatic)
1020         ASM = ArrayType::Static;
1021       else
1022         ASM = ArrayType::Normal;
1023       if (ASM == ArrayType::Star &&
1024           D.getContext() != Declarator::PrototypeContext) {
1025         // FIXME: This check isn't quite right: it allows star in prototypes
1026         // for function definitions, and disallows some edge cases detailed
1027         // in http://gcc.gnu.org/ml/gcc-patches/2009-02/msg00133.html
1028         Diag(DeclType.Loc, diag::err_array_star_outside_prototype);
1029         ASM = ArrayType::Normal;
1030         D.setInvalidType(true);
1031       }
1032       T = BuildArrayType(T, ASM, ArraySize,
1033                          Qualifiers::fromCVRMask(ATI.TypeQuals),
1034                          SourceRange(DeclType.Loc, DeclType.EndLoc), Name);
1035       break;
1036     }
1037     case DeclaratorChunk::Function: {
1038       // If the function declarator has a prototype (i.e. it is not () and
1039       // does not have a K&R-style identifier list), then the arguments are part
1040       // of the type, otherwise the argument list is ().
1041       const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
1042
1043       // C99 6.7.5.3p1: The return type may not be a function or array type.
1044       if (T->isArrayType() || T->isFunctionType()) {
1045         Diag(DeclType.Loc, diag::err_func_returning_array_function) << T;
1046         T = Context.IntTy;
1047         D.setInvalidType(true);
1048       }
1049
1050       if (getLangOptions().CPlusPlus && D.getDeclSpec().isTypeSpecOwned()) {
1051         // C++ [dcl.fct]p6:
1052         //   Types shall not be defined in return or parameter types.
1053         TagDecl *Tag = cast<TagDecl>((Decl *)D.getDeclSpec().getTypeRep());
1054         if (Tag->isDefinition())
1055           Diag(Tag->getLocation(), diag::err_type_defined_in_result_type)
1056             << Context.getTypeDeclType(Tag);
1057       }
1058
1059       // Exception specs are not allowed in typedefs. Complain, but add it
1060       // anyway.
1061       if (FTI.hasExceptionSpec &&
1062           D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
1063         Diag(FTI.getThrowLoc(), diag::err_exception_spec_in_typedef);
1064
1065       if (FTI.NumArgs == 0) {
1066         if (getLangOptions().CPlusPlus) {
1067           // C++ 8.3.5p2: If the parameter-declaration-clause is empty, the
1068           // function takes no arguments.
1069           llvm::SmallVector<QualType, 4> Exceptions;
1070           Exceptions.reserve(FTI.NumExceptions);
1071           for (unsigned ei = 0, ee = FTI.NumExceptions; ei != ee; ++ei) {
1072             // FIXME: Preserve type source info.
1073             QualType ET = GetTypeFromParser(FTI.Exceptions[ei].Ty);
1074             // Check that the type is valid for an exception spec, and drop it
1075             // if not.
1076             if (!CheckSpecifiedExceptionType(ET, FTI.Exceptions[ei].Range))
1077               Exceptions.push_back(ET);
1078           }
1079           T = Context.getFunctionType(T, NULL, 0, FTI.isVariadic, FTI.TypeQuals,
1080                                       FTI.hasExceptionSpec,
1081                                       FTI.hasAnyExceptionSpec,
1082                                       Exceptions.size(), Exceptions.data());
1083         } else if (FTI.isVariadic) {
1084           // We allow a zero-parameter variadic function in C if the
1085           // function is marked with the "overloadable"
1086           // attribute. Scan for this attribute now.
1087           bool Overloadable = false;
1088           for (const AttributeList *Attrs = D.getAttributes();
1089                Attrs; Attrs = Attrs->getNext()) {
1090             if (Attrs->getKind() == AttributeList::AT_overloadable) {
1091               Overloadable = true;
1092               break;
1093             }
1094           }
1095
1096           if (!Overloadable)
1097             Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_arg);
1098           T = Context.getFunctionType(T, NULL, 0, FTI.isVariadic, 0);
1099         } else {
1100           // Simple void foo(), where the incoming T is the result type.
1101           T = Context.getFunctionNoProtoType(T);
1102         }
1103       } else if (FTI.ArgInfo[0].Param == 0) {
1104         // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function definition.
1105         Diag(FTI.ArgInfo[0].IdentLoc, diag::err_ident_list_in_fn_declaration);
1106         D.setInvalidType(true);
1107       } else {
1108         // Otherwise, we have a function with an argument list that is
1109         // potentially variadic.
1110         llvm::SmallVector<QualType, 16> ArgTys;
1111
1112         for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
1113           ParmVarDecl *Param =
1114             cast<ParmVarDecl>(FTI.ArgInfo[i].Param.getAs<Decl>());
1115           QualType ArgTy = Param->getType();
1116           assert(!ArgTy.isNull() && "Couldn't parse type?");
1117
1118           // Adjust the parameter type.
1119           assert((ArgTy == adjustParameterType(ArgTy)) && "Unadjusted type?");
1120
1121           // Look for 'void'.  void is allowed only as a single argument to a
1122           // function with no other parameters (C99 6.7.5.3p10).  We record
1123           // int(void) as a FunctionProtoType with an empty argument list.
1124           if (ArgTy->isVoidType()) {
1125             // If this is something like 'float(int, void)', reject it.  'void'
1126             // is an incomplete type (C99 6.2.5p19) and function decls cannot
1127             // have arguments of incomplete type.
1128             if (FTI.NumArgs != 1 || FTI.isVariadic) {
1129               Diag(DeclType.Loc, diag::err_void_only_param);
1130               ArgTy = Context.IntTy;
1131               Param->setType(ArgTy);
1132             } else if (FTI.ArgInfo[i].Ident) {
1133               // Reject, but continue to parse 'int(void abc)'.
1134               Diag(FTI.ArgInfo[i].IdentLoc,
1135                    diag::err_param_with_void_type);
1136               ArgTy = Context.IntTy;
1137               Param->setType(ArgTy);
1138             } else {
1139               // Reject, but continue to parse 'float(const void)'.
1140               if (ArgTy.hasQualifiers())
1141                 Diag(DeclType.Loc, diag::err_void_param_qualified);
1142
1143               // Do not add 'void' to the ArgTys list.
1144               break;
1145             }
1146           } else if (!FTI.hasPrototype) {
1147             if (ArgTy->isPromotableIntegerType()) {
1148               ArgTy = Context.getPromotedIntegerType(ArgTy);
1149             } else if (const BuiltinType* BTy = ArgTy->getAs<BuiltinType>()) {
1150               if (BTy->getKind() == BuiltinType::Float)
1151                 ArgTy = Context.DoubleTy;
1152             }
1153           }
1154
1155           ArgTys.push_back(ArgTy);
1156         }
1157
1158         llvm::SmallVector<QualType, 4> Exceptions;
1159         Exceptions.reserve(FTI.NumExceptions);
1160         for (unsigned ei = 0, ee = FTI.NumExceptions; ei != ee; ++ei) {
1161           // FIXME: Preserve type source info.
1162           QualType ET = GetTypeFromParser(FTI.Exceptions[ei].Ty);
1163           // Check that the type is valid for an exception spec, and drop it if
1164           // not.
1165           if (!CheckSpecifiedExceptionType(ET, FTI.Exceptions[ei].Range))
1166             Exceptions.push_back(ET);
1167         }
1168
1169         T = Context.getFunctionType(T, ArgTys.data(), ArgTys.size(),
1170                                     FTI.isVariadic, FTI.TypeQuals,
1171                                     FTI.hasExceptionSpec,
1172                                     FTI.hasAnyExceptionSpec,
1173                                     Exceptions.size(), Exceptions.data());
1174       }
1175       break;
1176     }
1177     case DeclaratorChunk::MemberPointer:
1178       // Verify that we're not building a pointer to pointer to function with
1179       // exception specification.
1180       if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) {
1181         Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
1182         D.setInvalidType(true);
1183         // Build the type anyway.
1184       }
1185       // The scope spec must refer to a class, or be dependent.
1186       QualType ClsType;
1187       if (isDependentScopeSpecifier(DeclType.Mem.Scope())
1188             || dyn_cast_or_null<CXXRecordDecl>(
1189                                    computeDeclContext(DeclType.Mem.Scope()))) {
1190         NestedNameSpecifier *NNS
1191           = (NestedNameSpecifier *)DeclType.Mem.Scope().getScopeRep();
1192         NestedNameSpecifier *NNSPrefix = NNS->getPrefix();
1193         switch (NNS->getKind()) {
1194         case NestedNameSpecifier::Identifier:
1195           ClsType = Context.getTypenameType(NNSPrefix, NNS->getAsIdentifier());
1196           break;
1197
1198         case NestedNameSpecifier::Namespace:
1199         case NestedNameSpecifier::Global:
1200           llvm_unreachable("Nested-name-specifier must name a type");
1201           break;
1202
1203         case NestedNameSpecifier::TypeSpec:
1204         case NestedNameSpecifier::TypeSpecWithTemplate:
1205           ClsType = QualType(NNS->getAsType(), 0);
1206           if (NNSPrefix)
1207             ClsType = Context.getQualifiedNameType(NNSPrefix, ClsType);
1208           break;
1209         }
1210       } else {
1211         Diag(DeclType.Mem.Scope().getBeginLoc(),
1212              diag::err_illegal_decl_mempointer_in_nonclass)
1213           << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name")
1214           << DeclType.Mem.Scope().getRange();
1215         D.setInvalidType(true);
1216       }
1217
1218       if (!ClsType.isNull())
1219         T = BuildMemberPointerType(T, ClsType, DeclType.Mem.TypeQuals,
1220                                    DeclType.Loc, D.getIdentifier());
1221       if (T.isNull()) {
1222         T = Context.IntTy;
1223         D.setInvalidType(true);
1224       }
1225       break;
1226     }
1227
1228     if (T.isNull()) {
1229       D.setInvalidType(true);
1230       T = Context.IntTy;
1231     }
1232
1233     // See if there are any attributes on this declarator chunk.
1234     if (const AttributeList *AL = DeclType.getAttrs())
1235       ProcessTypeAttributeList(T, AL);
1236   }
1237
1238   if (getLangOptions().CPlusPlus && T->isFunctionType()) {
1239     const FunctionProtoType *FnTy = T->getAs<FunctionProtoType>();
1240     assert(FnTy && "Why oh why is there not a FunctionProtoType here?");
1241
1242     // C++ 8.3.5p4: A cv-qualifier-seq shall only be part of the function type
1243     // for a nonstatic member function, the function type to which a pointer
1244     // to member refers, or the top-level function type of a function typedef
1245     // declaration.
1246     if (FnTy->getTypeQuals() != 0 &&
1247         D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
1248         ((D.getContext() != Declarator::MemberContext &&
1249           (!D.getCXXScopeSpec().isSet() ||
1250            !computeDeclContext(D.getCXXScopeSpec(), /*FIXME:*/true)
1251               ->isRecord())) ||
1252          D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static)) {
1253       if (D.isFunctionDeclarator())
1254         Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_function_type);
1255       else
1256         Diag(D.getIdentifierLoc(),
1257              diag::err_invalid_qualified_typedef_function_type_use);
1258
1259       // Strip the cv-quals from the type.
1260       T = Context.getFunctionType(FnTy->getResultType(), FnTy->arg_type_begin(),
1261                                   FnTy->getNumArgs(), FnTy->isVariadic(), 0);
1262     }
1263   }
1264
1265   // If there were any type attributes applied to the decl itself (not the
1266   // type, apply the type attribute to the type!)
1267   if (const AttributeList *Attrs = D.getAttributes())
1268     ProcessTypeAttributeList(T, Attrs);
1269
1270   if (TInfo) {
1271     if (D.isInvalidType())
1272       *TInfo = 0;
1273     else
1274       *TInfo = GetTypeSourceInfoForDeclarator(D, T);
1275   }
1276
1277   return T;
1278 }
1279
1280 namespace {
1281   class TypeSpecLocFiller : public TypeLocVisitor<TypeSpecLocFiller> {
1282     const DeclSpec &DS;
1283
1284   public:
1285     TypeSpecLocFiller(const DeclSpec &DS) : DS(DS) {}
1286
1287     void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
1288       Visit(TL.getUnqualifiedLoc());
1289     }
1290     void VisitTypedefTypeLoc(TypedefTypeLoc TL) {
1291       TL.setNameLoc(DS.getTypeSpecTypeLoc());
1292     }
1293     void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
1294       TL.setNameLoc(DS.getTypeSpecTypeLoc());
1295
1296       if (DS.getProtocolQualifiers()) {
1297         assert(TL.getNumProtocols() > 0);
1298         assert(TL.getNumProtocols() == DS.getNumProtocolQualifiers());
1299         TL.setLAngleLoc(DS.getProtocolLAngleLoc());
1300         TL.setRAngleLoc(DS.getSourceRange().getEnd());
1301         for (unsigned i = 0, e = DS.getNumProtocolQualifiers(); i != e; ++i)
1302           TL.setProtocolLoc(i, DS.getProtocolLocs()[i]);
1303       } else {
1304         assert(TL.getNumProtocols() == 0);
1305         TL.setLAngleLoc(SourceLocation());
1306         TL.setRAngleLoc(SourceLocation());
1307       }
1308     }
1309     void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
1310       assert(TL.getNumProtocols() == DS.getNumProtocolQualifiers());
1311
1312       TL.setStarLoc(SourceLocation());
1313
1314       if (DS.getProtocolQualifiers()) {
1315         assert(TL.getNumProtocols() > 0);
1316         assert(TL.getNumProtocols() == DS.getNumProtocolQualifiers());
1317         TL.setHasProtocolsAsWritten(true);
1318         TL.setLAngleLoc(DS.getProtocolLAngleLoc());
1319         TL.setRAngleLoc(DS.getSourceRange().getEnd());
1320         for (unsigned i = 0, e = DS.getNumProtocolQualifiers(); i != e; ++i)
1321           TL.setProtocolLoc(i, DS.getProtocolLocs()[i]);
1322
1323       } else {
1324         assert(TL.getNumProtocols() == 0);
1325         TL.setHasProtocolsAsWritten(false);
1326         TL.setLAngleLoc(SourceLocation());
1327         TL.setRAngleLoc(SourceLocation());
1328       }
1329
1330       // This might not have been written with an inner type.
1331       if (DS.getTypeSpecType() == DeclSpec::TST_unspecified) {
1332         TL.setHasBaseTypeAsWritten(false);
1333         TL.getBaseTypeLoc().initialize(SourceLocation());
1334       } else {
1335         TL.setHasBaseTypeAsWritten(true);
1336         Visit(TL.getBaseTypeLoc());
1337       }
1338     }
1339     void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
1340       TypeSourceInfo *TInfo = 0;
1341       Sema::GetTypeFromParser(DS.getTypeRep(), &TInfo);
1342
1343       // If we got no declarator info from previous Sema routines,
1344       // just fill with the typespec loc.
1345       if (!TInfo) {
1346         TL.initialize(DS.getTypeSpecTypeLoc());
1347         return;
1348       }
1349
1350       TemplateSpecializationTypeLoc OldTL =
1351         cast<TemplateSpecializationTypeLoc>(TInfo->getTypeLoc());
1352       TL.copy(OldTL);
1353     }
1354     void VisitTypeLoc(TypeLoc TL) {
1355       // FIXME: add other typespec types and change this to an assert.
1356       TL.initialize(DS.getTypeSpecTypeLoc());
1357     }
1358   };
1359
1360   class DeclaratorLocFiller : public TypeLocVisitor<DeclaratorLocFiller> {
1361     const DeclaratorChunk &Chunk;
1362
1363   public:
1364     DeclaratorLocFiller(const DeclaratorChunk &Chunk) : Chunk(Chunk) {}
1365
1366     void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
1367       llvm_unreachable("qualified type locs not expected here!");
1368     }
1369
1370     void VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
1371       assert(Chunk.Kind == DeclaratorChunk::BlockPointer);
1372       TL.setCaretLoc(Chunk.Loc);
1373     }
1374     void VisitPointerTypeLoc(PointerTypeLoc TL) {
1375       assert(Chunk.Kind == DeclaratorChunk::Pointer);
1376       TL.setStarLoc(Chunk.Loc);
1377     }
1378     void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
1379       assert(Chunk.Kind == DeclaratorChunk::Pointer);
1380       TL.setStarLoc(Chunk.Loc);
1381       TL.setHasBaseTypeAsWritten(true);
1382       TL.setHasProtocolsAsWritten(false);
1383       TL.setLAngleLoc(SourceLocation());
1384       TL.setRAngleLoc(SourceLocation());
1385     }
1386     void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
1387       assert(Chunk.Kind == DeclaratorChunk::MemberPointer);
1388       TL.setStarLoc(Chunk.Loc);
1389       // FIXME: nested name specifier
1390     }
1391     void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
1392       assert(Chunk.Kind == DeclaratorChunk::Reference);
1393       // 'Amp' is misleading: this might have been originally
1394       /// spelled with AmpAmp.
1395       TL.setAmpLoc(Chunk.Loc);
1396     }
1397     void VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
1398       assert(Chunk.Kind == DeclaratorChunk::Reference);
1399       assert(!Chunk.Ref.LValueRef);
1400       TL.setAmpAmpLoc(Chunk.Loc);
1401     }
1402     void VisitArrayTypeLoc(ArrayTypeLoc TL) {
1403       assert(Chunk.Kind == DeclaratorChunk::Array);
1404       TL.setLBracketLoc(Chunk.Loc);
1405       TL.setRBracketLoc(Chunk.EndLoc);
1406       TL.setSizeExpr(static_cast<Expr*>(Chunk.Arr.NumElts));
1407     }
1408     void VisitFunctionTypeLoc(FunctionTypeLoc TL) {
1409       assert(Chunk.Kind == DeclaratorChunk::Function);
1410       TL.setLParenLoc(Chunk.Loc);
1411       TL.setRParenLoc(Chunk.EndLoc);
1412
1413       const DeclaratorChunk::FunctionTypeInfo &FTI = Chunk.Fun;
1414       for (unsigned i = 0, e = TL.getNumArgs(), tpi = 0; i != e; ++i) {
1415         ParmVarDecl *Param = FTI.ArgInfo[i].Param.getAs<ParmVarDecl>();
1416         TL.setArg(tpi++, Param);
1417       }
1418       // FIXME: exception specs
1419     }
1420
1421     void VisitTypeLoc(TypeLoc TL) {
1422       llvm_unreachable("unsupported TypeLoc kind in declarator!");
1423     }
1424   };
1425 }
1426
1427 /// \brief Create and instantiate a TypeSourceInfo with type source information.
1428 ///
1429 /// \param T QualType referring to the type as written in source code.
1430 TypeSourceInfo *
1431 Sema::GetTypeSourceInfoForDeclarator(Declarator &D, QualType T) {
1432   TypeSourceInfo *TInfo = Context.CreateTypeSourceInfo(T);
1433   UnqualTypeLoc CurrTL = TInfo->getTypeLoc().getUnqualifiedLoc();
1434
1435   for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
1436     DeclaratorLocFiller(D.getTypeObject(i)).Visit(CurrTL);
1437     CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc();
1438   }
1439
1440   TypeSpecLocFiller(D.getDeclSpec()).Visit(CurrTL);
1441
1442   return TInfo;
1443 }
1444
1445 /// \brief Create a LocInfoType to hold the given QualType and TypeSourceInfo.
1446 QualType Sema::CreateLocInfoType(QualType T, TypeSourceInfo *TInfo) {
1447   // FIXME: LocInfoTypes are "transient", only needed for passing to/from Parser
1448   // and Sema during declaration parsing. Try deallocating/caching them when
1449   // it's appropriate, instead of allocating them and keeping them around.
1450   LocInfoType *LocT = (LocInfoType*)BumpAlloc.Allocate(sizeof(LocInfoType), 8);
1451   new (LocT) LocInfoType(T, TInfo);
1452   assert(LocT->getTypeClass() != T->getTypeClass() &&
1453          "LocInfoType's TypeClass conflicts with an existing Type class");
1454   return QualType(LocT, 0);
1455 }
1456
1457 void LocInfoType::getAsStringInternal(std::string &Str,
1458                                       const PrintingPolicy &Policy) const {
1459   assert(false && "LocInfoType leaked into the type system; an opaque TypeTy*"
1460          " was used directly instead of getting the QualType through"
1461          " GetTypeFromParser");
1462 }
1463
1464 /// ObjCGetTypeForMethodDefinition - Builds the type for a method definition
1465 /// declarator
1466 QualType Sema::ObjCGetTypeForMethodDefinition(DeclPtrTy D) {
1467   ObjCMethodDecl *MDecl = cast<ObjCMethodDecl>(D.getAs<Decl>());
1468   QualType T = MDecl->getResultType();
1469   llvm::SmallVector<QualType, 16> ArgTys;
1470
1471   // Add the first two invisible argument types for self and _cmd.
1472   if (MDecl->isInstanceMethod()) {
1473     QualType selfTy = Context.getObjCInterfaceType(MDecl->getClassInterface());
1474     selfTy = Context.getPointerType(selfTy);
1475     ArgTys.push_back(selfTy);
1476   } else
1477     ArgTys.push_back(Context.getObjCIdType());
1478   ArgTys.push_back(Context.getObjCSelType());
1479
1480   for (ObjCMethodDecl::param_iterator PI = MDecl->param_begin(),
1481        E = MDecl->param_end(); PI != E; ++PI) {
1482     QualType ArgTy = (*PI)->getType();
1483     assert(!ArgTy.isNull() && "Couldn't parse type?");
1484     ArgTy = adjustParameterType(ArgTy);
1485     ArgTys.push_back(ArgTy);
1486   }
1487   T = Context.getFunctionType(T, &ArgTys[0], ArgTys.size(),
1488                               MDecl->isVariadic(), 0);
1489   return T;
1490 }
1491
1492 /// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types  that
1493 /// may be similar (C++ 4.4), replaces T1 and T2 with the type that
1494 /// they point to and return true. If T1 and T2 aren't pointer types
1495 /// or pointer-to-member types, or if they are not similar at this
1496 /// level, returns false and leaves T1 and T2 unchanged. Top-level
1497 /// qualifiers on T1 and T2 are ignored. This function will typically
1498 /// be called in a loop that successively "unwraps" pointer and
1499 /// pointer-to-member types to compare them at each level.
1500 bool Sema::UnwrapSimilarPointerTypes(QualType& T1, QualType& T2) {
1501   const PointerType *T1PtrType = T1->getAs<PointerType>(),
1502                     *T2PtrType = T2->getAs<PointerType>();
1503   if (T1PtrType && T2PtrType) {
1504     T1 = T1PtrType->getPointeeType();
1505     T2 = T2PtrType->getPointeeType();
1506     return true;
1507   }
1508
1509   const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(),
1510                           *T2MPType = T2->getAs<MemberPointerType>();
1511   if (T1MPType && T2MPType &&
1512       Context.getCanonicalType(T1MPType->getClass()) ==
1513       Context.getCanonicalType(T2MPType->getClass())) {
1514     T1 = T1MPType->getPointeeType();
1515     T2 = T2MPType->getPointeeType();
1516     return true;
1517   }
1518   return false;
1519 }
1520
1521 Sema::TypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) {
1522   // C99 6.7.6: Type names have no identifier.  This is already validated by
1523   // the parser.
1524   assert(D.getIdentifier() == 0 && "Type name should have no identifier!");
1525
1526   TypeSourceInfo *TInfo = 0;
1527   TagDecl *OwnedTag = 0;
1528   QualType T = GetTypeForDeclarator(D, S, &TInfo, &OwnedTag);
1529   if (D.isInvalidType())
1530     return true;
1531
1532   if (getLangOptions().CPlusPlus) {
1533     // Check that there are no default arguments (C++ only).
1534     CheckExtraCXXDefaultArguments(D);
1535
1536     // C++0x [dcl.type]p3:
1537     //   A type-specifier-seq shall not define a class or enumeration
1538     //   unless it appears in the type-id of an alias-declaration
1539     //   (7.1.3).
1540     if (OwnedTag && OwnedTag->isDefinition())
1541       Diag(OwnedTag->getLocation(), diag::err_type_defined_in_type_specifier)
1542         << Context.getTypeDeclType(OwnedTag);
1543   }
1544
1545   if (TInfo)
1546     T = CreateLocInfoType(T, TInfo);
1547
1548   return T.getAsOpaquePtr();
1549 }
1550
1551
1552
1553 //===----------------------------------------------------------------------===//
1554 // Type Attribute Processing
1555 //===----------------------------------------------------------------------===//
1556
1557 /// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the
1558 /// specified type.  The attribute contains 1 argument, the id of the address
1559 /// space for the type.
1560 static void HandleAddressSpaceTypeAttribute(QualType &Type,
1561                                             const AttributeList &Attr, Sema &S){
1562
1563   // If this type is already address space qualified, reject it.
1564   // Clause 6.7.3 - Type qualifiers: "No type shall be qualified by qualifiers
1565   // for two or more different address spaces."
1566   if (Type.getAddressSpace()) {
1567     S.Diag(Attr.getLoc(), diag::err_attribute_address_multiple_qualifiers);
1568     return;
1569   }
1570
1571   // Check the attribute arguments.
1572   if (Attr.getNumArgs() != 1) {
1573     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1574     return;
1575   }
1576   Expr *ASArgExpr = static_cast<Expr *>(Attr.getArg(0));
1577   llvm::APSInt addrSpace(32);
1578   if (!ASArgExpr->isIntegerConstantExpr(addrSpace, S.Context)) {
1579     S.Diag(Attr.getLoc(), diag::err_attribute_address_space_not_int)
1580       << ASArgExpr->getSourceRange();
1581     return;
1582   }
1583
1584   // Bounds checking.
1585   if (addrSpace.isSigned()) {
1586     if (addrSpace.isNegative()) {
1587       S.Diag(Attr.getLoc(), diag::err_attribute_address_space_negative)
1588         << ASArgExpr->getSourceRange();
1589       return;
1590     }
1591     addrSpace.setIsSigned(false);
1592   }
1593   llvm::APSInt max(addrSpace.getBitWidth());
1594   max = Qualifiers::MaxAddressSpace;
1595   if (addrSpace > max) {
1596     S.Diag(Attr.getLoc(), diag::err_attribute_address_space_too_high)
1597       << Qualifiers::MaxAddressSpace << ASArgExpr->getSourceRange();
1598     return;
1599   }
1600
1601   unsigned ASIdx = static_cast<unsigned>(addrSpace.getZExtValue());
1602   Type = S.Context.getAddrSpaceQualType(Type, ASIdx);
1603 }
1604
1605 /// HandleObjCGCTypeAttribute - Process an objc's gc attribute on the
1606 /// specified type.  The attribute contains 1 argument, weak or strong.
1607 static void HandleObjCGCTypeAttribute(QualType &Type,
1608                                       const AttributeList &Attr, Sema &S) {
1609   if (Type.getObjCGCAttr() != Qualifiers::GCNone) {
1610     S.Diag(Attr.getLoc(), diag::err_attribute_multiple_objc_gc);
1611     return;
1612   }
1613
1614   // Check the attribute arguments.
1615   if (!Attr.getParameterName()) {
1616     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1617       << "objc_gc" << 1;
1618     return;
1619   }
1620   Qualifiers::GC GCAttr;
1621   if (Attr.getNumArgs() != 0) {
1622     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1623     return;
1624   }
1625   if (Attr.getParameterName()->isStr("weak"))
1626     GCAttr = Qualifiers::Weak;
1627   else if (Attr.getParameterName()->isStr("strong"))
1628     GCAttr = Qualifiers::Strong;
1629   else {
1630     S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
1631       << "objc_gc" << Attr.getParameterName();
1632     return;
1633   }
1634
1635   Type = S.Context.getObjCGCQualType(Type, GCAttr);
1636 }
1637
1638 /// HandleNoReturnTypeAttribute - Process the noreturn attribute on the
1639 /// specified type.  The attribute contains 0 arguments.
1640 static void HandleNoReturnTypeAttribute(QualType &Type,
1641                                         const AttributeList &Attr, Sema &S) {
1642   if (Attr.getNumArgs() != 0)
1643     return;
1644
1645   // We only apply this to a pointer to function or a pointer to block.
1646   if (!Type->isFunctionPointerType()
1647       && !Type->isBlockPointerType()
1648       && !Type->isFunctionType())
1649     return;
1650
1651   Type = S.Context.getNoReturnType(Type);
1652 }
1653
1654 /// HandleVectorSizeAttribute - this attribute is only applicable to integral
1655 /// and float scalars, although arrays, pointers, and function return values are
1656 /// allowed in conjunction with this construct. Aggregates with this attribute
1657 /// are invalid, even if they are of the same size as a corresponding scalar.
1658 /// The raw attribute should contain precisely 1 argument, the vector size for
1659 /// the variable, measured in bytes. If curType and rawAttr are well formed,
1660 /// this routine will return a new vector type.
1661 static void HandleVectorSizeAttr(QualType& CurType, const AttributeList &Attr, Sema &S) {
1662   // Check the attribute arugments.
1663   if (Attr.getNumArgs() != 1) {
1664     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1665     return;
1666   }
1667   Expr *sizeExpr = static_cast<Expr *>(Attr.getArg(0));
1668   llvm::APSInt vecSize(32);
1669   if (!sizeExpr->isIntegerConstantExpr(vecSize, S.Context)) {
1670     S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1671       << "vector_size" << sizeExpr->getSourceRange();
1672     return;
1673   }
1674   // the base type must be integer or float, and can't already be a vector.
1675   if (CurType->isVectorType() ||
1676       (!CurType->isIntegerType() && !CurType->isRealFloatingType())) {
1677     S.Diag(Attr.getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
1678     return;
1679   }
1680   unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType));
1681   // vecSize is specified in bytes - convert to bits.
1682   unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue() * 8);
1683
1684   // the vector size needs to be an integral multiple of the type size.
1685   if (vectorSize % typeSize) {
1686     S.Diag(Attr.getLoc(), diag::err_attribute_invalid_size)
1687       << sizeExpr->getSourceRange();
1688     return;
1689   }
1690   if (vectorSize == 0) {
1691     S.Diag(Attr.getLoc(), diag::err_attribute_zero_size)
1692       << sizeExpr->getSourceRange();
1693     return;
1694   }
1695
1696   // Success! Instantiate the vector type, the number of elements is > 0, and
1697   // not required to be a power of 2, unlike GCC.
1698   CurType = S.Context.getVectorType(CurType, vectorSize/typeSize);
1699 }
1700
1701 void Sema::ProcessTypeAttributeList(QualType &Result, const AttributeList *AL) {
1702   // Scan through and apply attributes to this type where it makes sense.  Some
1703   // attributes (such as __address_space__, __vector_size__, etc) apply to the
1704   // type, but others can be present in the type specifiers even though they
1705   // apply to the decl.  Here we apply type attributes and ignore the rest.
1706   for (; AL; AL = AL->getNext()) {
1707     // If this is an attribute we can handle, do so now, otherwise, add it to
1708     // the LeftOverAttrs list for rechaining.
1709     switch (AL->getKind()) {
1710     default: break;
1711     case AttributeList::AT_address_space:
1712       HandleAddressSpaceTypeAttribute(Result, *AL, *this);
1713       break;
1714     case AttributeList::AT_objc_gc:
1715       HandleObjCGCTypeAttribute(Result, *AL, *this);
1716       break;
1717     case AttributeList::AT_noreturn:
1718       HandleNoReturnTypeAttribute(Result, *AL, *this);
1719       break;
1720     case AttributeList::AT_vector_size:
1721       HandleVectorSizeAttr(Result, *AL, *this);
1722       break;
1723     }
1724   }
1725 }
1726
1727 /// @brief Ensure that the type T is a complete type.
1728 ///
1729 /// This routine checks whether the type @p T is complete in any
1730 /// context where a complete type is required. If @p T is a complete
1731 /// type, returns false. If @p T is a class template specialization,
1732 /// this routine then attempts to perform class template
1733 /// instantiation. If instantiation fails, or if @p T is incomplete
1734 /// and cannot be completed, issues the diagnostic @p diag (giving it
1735 /// the type @p T) and returns true.
1736 ///
1737 /// @param Loc  The location in the source that the incomplete type
1738 /// diagnostic should refer to.
1739 ///
1740 /// @param T  The type that this routine is examining for completeness.
1741 ///
1742 /// @param PD The partial diagnostic that will be printed out if T is not a
1743 /// complete type.
1744 ///
1745 /// @returns @c true if @p T is incomplete and a diagnostic was emitted,
1746 /// @c false otherwise.
1747 bool Sema::RequireCompleteType(SourceLocation Loc, QualType T,
1748                                const PartialDiagnostic &PD,
1749                                std::pair<SourceLocation,
1750                                          PartialDiagnostic> Note) {
1751   unsigned diag = PD.getDiagID();
1752
1753   // FIXME: Add this assertion to make sure we always get instantiation points.
1754   //  assert(!Loc.isInvalid() && "Invalid location in RequireCompleteType");
1755   // FIXME: Add this assertion to help us flush out problems with
1756   // checking for dependent types and type-dependent expressions.
1757   //
1758   //  assert(!T->isDependentType() &&
1759   //         "Can't ask whether a dependent type is complete");
1760
1761   // If we have a complete type, we're done.
1762   if (!T->isIncompleteType())
1763     return false;
1764
1765   // If we have a class template specialization or a class member of a
1766   // class template specialization, or an array with known size of such,
1767   // try to instantiate it.
1768   QualType MaybeTemplate = T;
1769   if (const ConstantArrayType *Array = Context.getAsConstantArrayType(T))
1770     MaybeTemplate = Array->getElementType();
1771   if (const RecordType *Record = MaybeTemplate->getAs<RecordType>()) {
1772     if (ClassTemplateSpecializationDecl *ClassTemplateSpec
1773           = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
1774       if (ClassTemplateSpec->getSpecializationKind() == TSK_Undeclared)
1775         return InstantiateClassTemplateSpecialization(Loc, ClassTemplateSpec,
1776                                                       TSK_ImplicitInstantiation,
1777                                                       /*Complain=*/diag != 0);
1778     } else if (CXXRecordDecl *Rec
1779                  = dyn_cast<CXXRecordDecl>(Record->getDecl())) {
1780       if (CXXRecordDecl *Pattern = Rec->getInstantiatedFromMemberClass()) {
1781         MemberSpecializationInfo *MSInfo = Rec->getMemberSpecializationInfo();
1782         assert(MSInfo && "Missing member specialization information?");
1783         // This record was instantiated from a class within a template.
1784         if (MSInfo->getTemplateSpecializationKind()
1785                                                != TSK_ExplicitSpecialization)
1786           return InstantiateClass(Loc, Rec, Pattern,
1787                                   getTemplateInstantiationArgs(Rec),
1788                                   TSK_ImplicitInstantiation,
1789                                   /*Complain=*/diag != 0);
1790       }
1791     }
1792   }
1793
1794   if (diag == 0)
1795     return true;
1796
1797   // We have an incomplete type. Produce a diagnostic.
1798   Diag(Loc, PD) << T;
1799
1800   // If we have a note, produce it.
1801   if (!Note.first.isInvalid())
1802     Diag(Note.first, Note.second);
1803
1804   // If the type was a forward declaration of a class/struct/union
1805   // type, produce
1806   const TagType *Tag = 0;
1807   if (const RecordType *Record = T->getAs<RecordType>())
1808     Tag = Record;
1809   else if (const EnumType *Enum = T->getAs<EnumType>())
1810     Tag = Enum;
1811
1812   if (Tag && !Tag->getDecl()->isInvalidDecl())
1813     Diag(Tag->getDecl()->getLocation(),
1814          Tag->isBeingDefined() ? diag::note_type_being_defined
1815                                : diag::note_forward_declaration)
1816         << QualType(Tag, 0);
1817
1818   return true;
1819 }
1820
1821 /// \brief Retrieve a version of the type 'T' that is qualified by the
1822 /// nested-name-specifier contained in SS.
1823 QualType Sema::getQualifiedNameType(const CXXScopeSpec &SS, QualType T) {
1824   if (!SS.isSet() || SS.isInvalid() || T.isNull())
1825     return T;
1826
1827   NestedNameSpecifier *NNS
1828     = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
1829   return Context.getQualifiedNameType(NNS, T);
1830 }
1831
1832 QualType Sema::BuildTypeofExprType(Expr *E) {
1833   if (E->getType() == Context.OverloadTy) {
1834     // C++ [temp.arg.explicit]p3 allows us to resolve a template-id to a
1835     // function template specialization wherever deduction cannot occur.
1836     if (FunctionDecl *Specialization
1837         = ResolveSingleFunctionTemplateSpecialization(E)) {
1838       E = FixOverloadedFunctionReference(E, Specialization);
1839       if (!E)
1840         return QualType();
1841     } else {
1842       Diag(E->getLocStart(),
1843            diag::err_cannot_determine_declared_type_of_overloaded_function)
1844         << false << E->getSourceRange();
1845       return QualType();
1846     }
1847   }
1848
1849   return Context.getTypeOfExprType(E);
1850 }
1851
1852 QualType Sema::BuildDecltypeType(Expr *E) {
1853   if (E->getType() == Context.OverloadTy) {
1854     // C++ [temp.arg.explicit]p3 allows us to resolve a template-id to a
1855     // function template specialization wherever deduction cannot occur.
1856     if (FunctionDecl *Specialization
1857           = ResolveSingleFunctionTemplateSpecialization(E)) {
1858       E = FixOverloadedFunctionReference(E, Specialization);
1859       if (!E)
1860         return QualType();
1861     } else {
1862       Diag(E->getLocStart(),
1863            diag::err_cannot_determine_declared_type_of_overloaded_function)
1864         << true << E->getSourceRange();
1865       return QualType();
1866     }
1867   }
1868
1869   return Context.getDecltypeType(E);
1870 }