lib/Sema/SemaExpr.cpp

   1 //===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
   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 semantic analysis for expressions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "Sema.h"
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/DeclObjC.h"
  17 #include "clang/AST/ExprCXX.h"
  18 #include "clang/AST/ExprObjC.h"
  19 #include "clang/AST/DeclTemplate.h"
  20 #include "clang/Lex/Preprocessor.h"
  21 #include "clang/Lex/LiteralSupport.h"
  22 #include "clang/Basic/SourceManager.h"
  23 #include "clang/Basic/TargetInfo.h"
  24 #include "clang/Parse/DeclSpec.h"
  25 #include "clang/Parse/Designator.h"
  26 #include "clang/Parse/Scope.h"
  27 using namespace clang;
  28
  29 /// \brief Determine whether the use of this declaration is valid, and
  30 /// emit any corresponding diagnostics.
  31 ///
  32 /// This routine diagnoses various problems with referencing
  33 /// declarations that can occur when using a declaration. For example,
  34 /// it might warn if a deprecated or unavailable declaration is being
  35 /// used, or produce an error (and return true) if a C++0x deleted
  36 /// function is being used.
  37 ///
  38 /// \returns true if there was an error (this declaration cannot be
  39 /// referenced), false otherwise.
  40 bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc) {
  41   // See if the decl is deprecated.
  42   if (D->getAttr<DeprecatedAttr>(Context)) {
  43     // Implementing deprecated stuff requires referencing deprecated
  44     // stuff. Don't warn if we are implementing a deprecated
  45     // construct.
  46     bool isSilenced = false;
  47
  48     if (NamedDecl *ND = getCurFunctionOrMethodDecl()) {
  49       // If this reference happens *in* a deprecated function or method, don't
  50       // warn.
  51       isSilenced = ND->getAttr<DeprecatedAttr>(Context);
  52
  53       // If this is an Objective-C method implementation, check to see if the
  54       // method was deprecated on the declaration, not the definition.
  55       if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(ND)) {
  56         // The semantic decl context of a ObjCMethodDecl is the
  57         // ObjCImplementationDecl.
  58         if (ObjCImplementationDecl *Impl
  59               = dyn_cast<ObjCImplementationDecl>(MD->getParent())) {
  60
  61           MD = Impl->getClassInterface()->getMethod(Context,
  62                                                     MD->getSelector(),
  63                                                     MD->isInstanceMethod());
  64           isSilenced |= MD && MD->getAttr<DeprecatedAttr>(Context);
  65         }
  66       }
  67     }
  68
  69     if (!isSilenced)
  70       Diag(Loc, diag::warn_deprecated) << D->getDeclName();
  71   }
  72
  73   // See if this is a deleted function.
  74   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
  75     if (FD->isDeleted()) {
  76       Diag(Loc, diag::err_deleted_function_use);
  77       Diag(D->getLocation(), diag::note_unavailable_here) << true;
  78       return true;
  79     }
  80   }
  81
  82   // See if the decl is unavailable
  83   if (D->getAttr<UnavailableAttr>(Context)) {
  84     Diag(Loc, diag::warn_unavailable) << D->getDeclName();
  85     Diag(D->getLocation(), diag::note_unavailable_here) << 0;
  86   }
  87
  88   return false;
  89 }
  90
  91 /// DiagnoseSentinelCalls - This routine checks on method dispatch calls
  92 /// (and other functions in future), which have been declared with sentinel
  93 /// attribute. It warns if call does not have the sentinel argument.
  94 ///
  95 void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
  96                                  Expr **Args, unsigned NumArgs)
  97 {
  98   const SentinelAttr *attr = D->getAttr<SentinelAttr>(Context);
  99   if (!attr)
 100     return;
 101   int sentinelPos = attr->getSentinel();
 102   int nullPos = attr->getNullPos();
 103
 104   // FIXME. ObjCMethodDecl and FunctionDecl need be derived from the same common
 105   // base class. Then we won't be needing two versions of the same code.
 106   unsigned int i = 0;
 107   bool warnNotEnoughArgs = false;
 108   int isMethod = 0;
 109   if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
 110     // skip over named parameters.
 111     ObjCMethodDecl::param_iterator P, E = MD->param_end();
 112     for (P = MD->param_begin(); (P != E && i < NumArgs); ++P) {
 113       if (nullPos)
 114         --nullPos;
 115       else
 116         ++i;
 117     }
 118     warnNotEnoughArgs = (P != E || i >= NumArgs);
 119     isMethod = 1;
 120   }
 121   else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 122     // skip over named parameters.
 123     ObjCMethodDecl::param_iterator P, E = FD->param_end();
 124     for (P = FD->param_begin(); (P != E && i < NumArgs); ++P) {
 125       if (nullPos)
 126         --nullPos;
 127       else
 128         ++i;
 129     }
 130     warnNotEnoughArgs = (P != E || i >= NumArgs);
 131   }
 132   else if (VarDecl *V = dyn_cast<VarDecl>(D)) {
 133     // block or function pointer call.
 134     QualType Ty = V->getType();
 135     if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
 136       const FunctionType *FT = Ty->isFunctionPointerType()
 137       ? Ty->getAsPointerType()->getPointeeType()->getAsFunctionType()
 138       : Ty->getAsBlockPointerType()->getPointeeType()->getAsFunctionType();
 139       if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT)) {
 140         unsigned NumArgsInProto = Proto->getNumArgs();
 141         unsigned k;
 142         for (k = 0; (k != NumArgsInProto && i < NumArgs); k++) {
 143           if (nullPos)
 144             --nullPos;
 145           else
 146             ++i;
 147         }
 148         warnNotEnoughArgs = (k != NumArgsInProto || i >= NumArgs);
 149       }
 150       if (Ty->isBlockPointerType())
 151         isMethod = 2;
 152     }
 153     else
 154       return;
 155   }
 156   else
 157     return;
 158
 159   if (warnNotEnoughArgs) {
 160     Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
 161     Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
 162     return;
 163   }
 164   int sentinel = i;
 165   while (sentinelPos > 0 && i < NumArgs-1) {
 166     --sentinelPos;
 167     ++i;
 168   }
 169   if (sentinelPos > 0) {
 170     Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
 171     Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
 172     return;
 173   }
 174   while (i < NumArgs-1) {
 175     ++i;
 176     ++sentinel;
 177   }
 178   Expr *sentinelExpr = Args[sentinel];
 179   if (sentinelExpr && (!sentinelExpr->getType()->isPointerType() ||
 180                        !sentinelExpr->isNullPointerConstant(Context))) {
 181     Diag(Loc, diag::warn_missing_sentinel) << isMethod;
 182     Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
 183   }
 184   return;
 185 }
 186
 187 SourceRange Sema::getExprRange(ExprTy *E) const {
 188   Expr *Ex = (Expr *)E;
 189   return Ex? Ex->getSourceRange() : SourceRange();
 190 }
 191
 192 //===----------------------------------------------------------------------===//
 193 //  Standard Promotions and Conversions
 194 //===----------------------------------------------------------------------===//
 195
 196 /// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
 197 void Sema::DefaultFunctionArrayConversion(Expr *&E) {
 198   QualType Ty = E->getType();
 199   assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type");
 200
 201   if (Ty->isFunctionType())
 202     ImpCastExprToType(E, Context.getPointerType(Ty));
 203   else if (Ty->isArrayType()) {
 204     // In C90 mode, arrays only promote to pointers if the array expression is
 205     // an lvalue.  The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
 206     // type 'array of type' is converted to an expression that has type 'pointer
 207     // to type'...".  In C99 this was changed to: C99 6.3.2.1p3: "an expression
 208     // that has type 'array of type' ...".  The relevant change is "an lvalue"
 209     // (C90) to "an expression" (C99).
 210     //
 211     // C++ 4.2p1:
 212     // An lvalue or rvalue of type "array of N T" or "array of unknown bound of
 213     // T" can be converted to an rvalue of type "pointer to T".
 214     //
 215     if (getLangOptions().C99 || getLangOptions().CPlusPlus ||
 216         E->isLvalue(Context) == Expr::LV_Valid)
 217       ImpCastExprToType(E, Context.getArrayDecayedType(Ty));
 218   }
 219 }
 220
 221 /// \brief Whether this is a promotable bitfield reference according
 222 /// to C99 6.3.1.1p2, bullet 2.
 223 ///
 224 /// \returns the type this bit-field will promote to, or NULL if no
 225 /// promotion occurs.
 226 static QualType isPromotableBitField(Expr *E, ASTContext &Context) {
 227   FieldDecl *Field = E->getBitField();
 228   if (!Field)
 229     return QualType();
 230
 231   const BuiltinType *BT = Field->getType()->getAsBuiltinType();
 232   if (!BT)
 233     return QualType();
 234
 235   if (BT->getKind() != BuiltinType::Bool &&
 236       BT->getKind() != BuiltinType::Int &&
 237       BT->getKind() != BuiltinType::UInt)
 238     return QualType();
 239
 240   llvm::APSInt BitWidthAP;
 241   if (!Field->getBitWidth()->isIntegerConstantExpr(BitWidthAP, Context))
 242     return QualType();
 243
 244   uint64_t BitWidth = BitWidthAP.getZExtValue();
 245   uint64_t IntSize = Context.getTypeSize(Context.IntTy);
 246   if (BitWidth < IntSize ||
 247       (Field->getType()->isSignedIntegerType() && BitWidth == IntSize))
 248     return Context.IntTy;
 249
 250   if (BitWidth == IntSize && Field->getType()->isUnsignedIntegerType())
 251     return Context.UnsignedIntTy;
 252
 253   return QualType();
 254 }
 255
 256 /// UsualUnaryConversions - Performs various conversions that are common to most
 257 /// operators (C99 6.3). The conversions of array and function types are
 258 /// sometimes surpressed. For example, the array->pointer conversion doesn't
 259 /// apply if the array is an argument to the sizeof or address (&) operators.
 260 /// In these instances, this routine should *not* be called.
 261 Expr *Sema::UsualUnaryConversions(Expr *&Expr) {
 262   QualType Ty = Expr->getType();
 263   assert(!Ty.isNull() && "UsualUnaryConversions - missing type");
 264
 265   // C99 6.3.1.1p2:
 266   //
 267   //   The following may be used in an expression wherever an int or
 268   //   unsigned int may be used:
 269   //     - an object or expression with an integer type whose integer
 270   //       conversion rank is less than or equal to the rank of int
 271   //       and unsigned int.
 272   //     - A bit-field of type _Bool, int, signed int, or unsigned int.
 273   //
 274   //   If an int can represent all values of the original type, the
 275   //   value is converted to an int; otherwise, it is converted to an
 276   //   unsigned int. These are called the integer promotions. All
 277   //   other types are unchanged by the integer promotions.
 278   if (Ty->isPromotableIntegerType()) {
 279     ImpCastExprToType(Expr, Context.IntTy);
 280     return Expr;
 281   } else {
 282     QualType T = isPromotableBitField(Expr, Context);
 283     if (!T.isNull()) {
 284       ImpCastExprToType(Expr, T);
 285       return Expr;
 286     }
 287   }
 288
 289   DefaultFunctionArrayConversion(Expr);
 290   return Expr;
 291 }
 292
 293 /// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
 294 /// do not have a prototype. Arguments that have type float are promoted to
 295 /// double. All other argument types are converted by UsualUnaryConversions().
 296 void Sema::DefaultArgumentPromotion(Expr *&Expr) {
 297   QualType Ty = Expr->getType();
 298   assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");
 299
 300   // If this is a 'float' (CVR qualified or typedef) promote to double.
 301   if (const BuiltinType *BT = Ty->getAsBuiltinType())
 302     if (BT->getKind() == BuiltinType::Float)
 303       return ImpCastExprToType(Expr, Context.DoubleTy);
 304
 305   UsualUnaryConversions(Expr);
 306 }
 307
 308 /// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
 309 /// will warn if the resulting type is not a POD type, and rejects ObjC
 310 /// interfaces passed by value.  This returns true if the argument type is
 311 /// completely illegal.
 312 bool Sema::DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT) {
 313   DefaultArgumentPromotion(Expr);
 314
 315   if (Expr->getType()->isObjCInterfaceType()) {
 316     Diag(Expr->getLocStart(),
 317          diag::err_cannot_pass_objc_interface_to_vararg)
 318       << Expr->getType() << CT;
 319     return true;
 320   }
 321
 322   if (!Expr->getType()->isPODType())
 323     Diag(Expr->getLocStart(), diag::warn_cannot_pass_non_pod_arg_to_vararg)
 324       << Expr->getType() << CT;
 325
 326   return false;
 327 }
 328
 329
 330 /// UsualArithmeticConversions - Performs various conversions that are common to
 331 /// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
 332 /// routine returns the first non-arithmetic type found. The client is
 333 /// responsible for emitting appropriate error diagnostics.
 334 /// FIXME: verify the conversion rules for "complex int" are consistent with
 335 /// GCC.
 336 QualType Sema::UsualArithmeticConversions(Expr *&lhsExpr, Expr *&rhsExpr,
 337                                           bool isCompAssign) {
 338   if (!isCompAssign)
 339     UsualUnaryConversions(lhsExpr);
 340
 341   UsualUnaryConversions(rhsExpr);
 342
 343   // For conversion purposes, we ignore any qualifiers.
 344   // For example, "const float" and "float" are equivalent.
 345   QualType lhs =
 346     Context.getCanonicalType(lhsExpr->getType()).getUnqualifiedType();
 347   QualType rhs =
 348     Context.getCanonicalType(rhsExpr->getType()).getUnqualifiedType();
 349
 350   // If both types are identical, no conversion is needed.
 351   if (lhs == rhs)
 352     return lhs;
 353
 354   // If either side is a non-arithmetic type (e.g. a pointer), we are done.
 355   // The caller can deal with this (e.g. pointer + int).
 356   if (!lhs->isArithmeticType() || !rhs->isArithmeticType())
 357     return lhs;
 358
 359   // Perform bitfield promotions.
 360   QualType LHSBitfieldPromoteTy = isPromotableBitField(lhsExpr, Context);
 361   if (!LHSBitfieldPromoteTy.isNull())
 362     lhs = LHSBitfieldPromoteTy;
 363   QualType RHSBitfieldPromoteTy = isPromotableBitField(rhsExpr, Context);
 364   if (!RHSBitfieldPromoteTy.isNull())
 365     rhs = RHSBitfieldPromoteTy;
 366
 367   QualType destType = UsualArithmeticConversionsType(lhs, rhs);
 368   if (!isCompAssign)
 369     ImpCastExprToType(lhsExpr, destType);
 370   ImpCastExprToType(rhsExpr, destType);
 371   return destType;
 372 }
 373
 374 QualType Sema::UsualArithmeticConversionsType(QualType lhs, QualType rhs) {
 375   // Perform the usual unary conversions. We do this early so that
 376   // integral promotions to "int" can allow us to exit early, in the
 377   // lhs == rhs check. Also, for conversion purposes, we ignore any
 378   // qualifiers.  For example, "const float" and "float" are
 379   // equivalent.
 380   if (lhs->isPromotableIntegerType())
 381     lhs = Context.IntTy;
 382   else
 383     lhs = lhs.getUnqualifiedType();
 384   if (rhs->isPromotableIntegerType())
 385     rhs = Context.IntTy;
 386   else
 387     rhs = rhs.getUnqualifiedType();
 388
 389   // If both types are identical, no conversion is needed.
 390   if (lhs == rhs)
 391     return lhs;
 392
 393   // If either side is a non-arithmetic type (e.g. a pointer), we are done.
 394   // The caller can deal with this (e.g. pointer + int).
 395   if (!lhs->isArithmeticType() || !rhs->isArithmeticType())
 396     return lhs;
 397
 398   // At this point, we have two different arithmetic types.
 399
 400   // Handle complex types first (C99 6.3.1.8p1).
 401   if (lhs->isComplexType() || rhs->isComplexType()) {
 402     // if we have an integer operand, the result is the complex type.
 403     if (rhs->isIntegerType() || rhs->isComplexIntegerType()) {
 404       // convert the rhs to the lhs complex type.
 405       return lhs;
 406     }
 407     if (lhs->isIntegerType() || lhs->isComplexIntegerType()) {
 408       // convert the lhs to the rhs complex type.
 409       return rhs;
 410     }
 411     // This handles complex/complex, complex/float, or float/complex.
 412     // When both operands are complex, the shorter operand is converted to the
 413     // type of the longer, and that is the type of the result. This corresponds
 414     // to what is done when combining two real floating-point operands.
 415     // The fun begins when size promotion occur across type domains.
 416     // From H&S 6.3.4: When one operand is complex and the other is a real
 417     // floating-point type, the less precise type is converted, within it's
 418     // real or complex domain, to the precision of the other type. For example,
 419     // when combining a "long double" with a "double _Complex", the
 420     // "double _Complex" is promoted to "long double _Complex".
 421     int result = Context.getFloatingTypeOrder(lhs, rhs);
 422
 423     if (result > 0) { // The left side is bigger, convert rhs.
 424       rhs = Context.getFloatingTypeOfSizeWithinDomain(lhs, rhs);
 425     } else if (result < 0) { // The right side is bigger, convert lhs.
 426       lhs = Context.getFloatingTypeOfSizeWithinDomain(rhs, lhs);
 427     }
 428     // At this point, lhs and rhs have the same rank/size. Now, make sure the
 429     // domains match. This is a requirement for our implementation, C99
 430     // does not require this promotion.
 431     if (lhs != rhs) { // Domains don't match, we have complex/float mix.
 432       if (lhs->isRealFloatingType()) { // handle "double, _Complex double".
 433         return rhs;
 434       } else { // handle "_Complex double, double".
 435         return lhs;
 436       }
 437     }
 438     return lhs; // The domain/size match exactly.
 439   }
 440   // Now handle "real" floating types (i.e. float, double, long double).
 441   if (lhs->isRealFloatingType() || rhs->isRealFloatingType()) {
 442     // if we have an integer operand, the result is the real floating type.
 443     if (rhs->isIntegerType()) {
 444       // convert rhs to the lhs floating point type.
 445       return lhs;
 446     }
 447     if (rhs->isComplexIntegerType()) {
 448       // convert rhs to the complex floating point type.
 449       return Context.getComplexType(lhs);
 450     }
 451     if (lhs->isIntegerType()) {
 452       // convert lhs to the rhs floating point type.
 453       return rhs;
 454     }
 455     if (lhs->isComplexIntegerType()) {
 456       // convert lhs to the complex floating point type.
 457       return Context.getComplexType(rhs);
 458     }
 459     // We have two real floating types, float/complex combos were handled above.
 460     // Convert the smaller operand to the bigger result.
 461     int result = Context.getFloatingTypeOrder(lhs, rhs);
 462     if (result > 0) // convert the rhs
 463       return lhs;
 464     assert(result < 0 && "illegal float comparison");
 465     return rhs;   // convert the lhs
 466   }
 467   if (lhs->isComplexIntegerType() || rhs->isComplexIntegerType()) {
 468     // Handle GCC complex int extension.
 469     const ComplexType *lhsComplexInt = lhs->getAsComplexIntegerType();
 470     const ComplexType *rhsComplexInt = rhs->getAsComplexIntegerType();
 471
 472     if (lhsComplexInt && rhsComplexInt) {
 473       if (Context.getIntegerTypeOrder(lhsComplexInt->getElementType(),
 474                                       rhsComplexInt->getElementType()) >= 0)
 475         return lhs; // convert the rhs
 476       return rhs;
 477     } else if (lhsComplexInt && rhs->isIntegerType()) {
 478       // convert the rhs to the lhs complex type.
 479       return lhs;
 480     } else if (rhsComplexInt && lhs->isIntegerType()) {
 481       // convert the lhs to the rhs complex type.
 482       return rhs;
 483     }
 484   }
 485   // Finally, we have two differing integer types.
 486   // The rules for this case are in C99 6.3.1.8
 487   int compare = Context.getIntegerTypeOrder(lhs, rhs);
 488   bool lhsSigned = lhs->isSignedIntegerType(),
 489        rhsSigned = rhs->isSignedIntegerType();
 490   QualType destType;
 491   if (lhsSigned == rhsSigned) {
 492     // Same signedness; use the higher-ranked type
 493     destType = compare >= 0 ? lhs : rhs;
 494   } else if (compare != (lhsSigned ? 1 : -1)) {
 495     // The unsigned type has greater than or equal rank to the
 496     // signed type, so use the unsigned type
 497     destType = lhsSigned ? rhs : lhs;
 498   } else if (Context.getIntWidth(lhs) != Context.getIntWidth(rhs)) {
 499     // The two types are different widths; if we are here, that
 500     // means the signed type is larger than the unsigned type, so
 501     // use the signed type.
 502     destType = lhsSigned ? lhs : rhs;
 503   } else {
 504     // The signed type is higher-ranked than the unsigned type,
 505     // but isn't actually any bigger (like unsigned int and long
 506     // on most 32-bit systems).  Use the unsigned type corresponding
 507     // to the signed type.
 508     destType = Context.getCorrespondingUnsignedType(lhsSigned ? lhs : rhs);
 509   }
 510   return destType;
 511 }
 512
 513 //===----------------------------------------------------------------------===//
 514 //  Semantic Analysis for various Expression Types
 515 //===----------------------------------------------------------------------===//
 516
 517
 518 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
 519 /// fragments (e.g. "foo" "bar" L"baz").  The result string has to handle string
 520 /// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
 521 /// multiple tokens.  However, the common case is that StringToks points to one
 522 /// string.
 523 ///
 524 Action::OwningExprResult
 525 Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks) {
 526   assert(NumStringToks && "Must have at least one string!");
 527
 528   StringLiteralParser Literal(StringToks, NumStringToks, PP);
 529   if (Literal.hadError)
 530     return ExprError();
 531
 532   llvm::SmallVector<SourceLocation, 4> StringTokLocs;
 533   for (unsigned i = 0; i != NumStringToks; ++i)
 534     StringTokLocs.push_back(StringToks[i].getLocation());
 535
 536   QualType StrTy = Context.CharTy;
 537   if (Literal.AnyWide) StrTy = Context.getWCharType();
 538   if (Literal.Pascal) StrTy = Context.UnsignedCharTy;
 539
 540   // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
 541   if (getLangOptions().CPlusPlus)
 542     StrTy.addConst();
 543
 544   // Get an array type for the string, according to C99 6.4.5.  This includes
 545   // the nul terminator character as well as the string length for pascal
 546   // strings.
 547   StrTy = Context.getConstantArrayType(StrTy,
 548                                  llvm::APInt(32, Literal.GetNumStringChars()+1),
 549                                        ArrayType::Normal, 0);
 550
 551   // Pass &StringTokLocs[0], StringTokLocs.size() to factory!
 552   return Owned(StringLiteral::Create(Context, Literal.GetString(),
 553                                      Literal.GetStringLength(),
 554                                      Literal.AnyWide, StrTy,
 555                                      &StringTokLocs[0],
 556                                      StringTokLocs.size()));
 557 }
 558
 559 /// ShouldSnapshotBlockValueReference - Return true if a reference inside of
 560 /// CurBlock to VD should cause it to be snapshotted (as we do for auto
 561 /// variables defined outside the block) or false if this is not needed (e.g.
 562 /// for values inside the block or for globals).
 563 ///
 564 /// This also keeps the 'hasBlockDeclRefExprs' in the BlockSemaInfo records
 565 /// up-to-date.
 566 ///
 567 static bool ShouldSnapshotBlockValueReference(BlockSemaInfo *CurBlock,
 568                                               ValueDecl *VD) {
 569   // If the value is defined inside the block, we couldn't snapshot it even if
 570   // we wanted to.
 571   if (CurBlock->TheDecl == VD->getDeclContext())
 572     return false;
 573
 574   // If this is an enum constant or function, it is constant, don't snapshot.
 575   if (isa<EnumConstantDecl>(VD) || isa<FunctionDecl>(VD))
 576     return false;
 577
 578   // If this is a reference to an extern, static, or global variable, no need to
 579   // snapshot it.
 580   // FIXME: What about 'const' variables in C++?
 581   if (const VarDecl *Var = dyn_cast<VarDecl>(VD))
 582     if (!Var->hasLocalStorage())
 583       return false;
 584
 585   // Blocks that have these can't be constant.
 586   CurBlock->hasBlockDeclRefExprs = true;
 587
 588   // If we have nested blocks, the decl may be declared in an outer block (in
 589   // which case that outer block doesn't get "hasBlockDeclRefExprs") or it may
 590   // be defined outside all of the current blocks (in which case the blocks do
 591   // all get the bit).  Walk the nesting chain.
 592   for (BlockSemaInfo *NextBlock = CurBlock->PrevBlockInfo; NextBlock;
 593        NextBlock = NextBlock->PrevBlockInfo) {
 594     // If we found the defining block for the variable, don't mark the block as
 595     // having a reference outside it.
 596     if (NextBlock->TheDecl == VD->getDeclContext())
 597       break;
 598
 599     // Otherwise, the DeclRef from the inner block causes the outer one to need
 600     // a snapshot as well.
 601     NextBlock->hasBlockDeclRefExprs = true;
 602   }
 603
 604   return true;
 605 }
 606
 607
 608
 609 /// ActOnIdentifierExpr - The parser read an identifier in expression context,
 610 /// validate it per-C99 6.5.1.  HasTrailingLParen indicates whether this
 611 /// identifier is used in a function call context.
 612 /// SS is only used for a C++ qualified-id (foo::bar) to indicate the
 613 /// class or namespace that the identifier must be a member of.
 614 Sema::OwningExprResult Sema::ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
 615                                                  IdentifierInfo &II,
 616                                                  bool HasTrailingLParen,
 617                                                  const CXXScopeSpec *SS,
 618                                                  bool isAddressOfOperand) {
 619   return ActOnDeclarationNameExpr(S, Loc, &II, HasTrailingLParen, SS,
 620                                   isAddressOfOperand);
 621 }
 622
 623 /// BuildDeclRefExpr - Build either a DeclRefExpr or a
 624 /// QualifiedDeclRefExpr based on whether or not SS is a
 625 /// nested-name-specifier.
 626 DeclRefExpr *
 627 Sema::BuildDeclRefExpr(NamedDecl *D, QualType Ty, SourceLocation Loc,
 628                        bool TypeDependent, bool ValueDependent,
 629                        const CXXScopeSpec *SS) {
 630   MarkDeclarationReferenced(Loc, D);
 631   if (SS && !SS->isEmpty()) {
 632     return new (Context) QualifiedDeclRefExpr(D, Ty, Loc, TypeDependent,
 633                                               ValueDependent, SS->getRange(),
 634                   static_cast<NestedNameSpecifier *>(SS->getScopeRep()));
 635   } else
 636     return new (Context) DeclRefExpr(D, Ty, Loc, TypeDependent, ValueDependent);
 637 }
 638
 639 /// getObjectForAnonymousRecordDecl - Retrieve the (unnamed) field or
 640 /// variable corresponding to the anonymous union or struct whose type
 641 /// is Record.
 642 static Decl *getObjectForAnonymousRecordDecl(ASTContext &Context,
 643                                              RecordDecl *Record) {
 644   assert(Record->isAnonymousStructOrUnion() &&
 645          "Record must be an anonymous struct or union!");
 646
 647   // FIXME: Once Decls are directly linked together, this will be an O(1)
 648   // operation rather than a slow walk through DeclContext's vector (which
 649   // itself will be eliminated). DeclGroups might make this even better.
 650   DeclContext *Ctx = Record->getDeclContext();
 651   for (DeclContext::decl_iterator D = Ctx->decls_begin(Context),
 652                                DEnd = Ctx->decls_end(Context);
 653        D != DEnd; ++D) {
 654     if (*D == Record) {
 655       // The object for the anonymous struct/union directly
 656       // follows its type in the list of declarations.
 657       ++D;
 658       assert(D != DEnd && "Missing object for anonymous record");
 659       assert(!cast<NamedDecl>(*D)->getDeclName() && "Decl should be unnamed");
 660       return *D;
 661     }
 662   }
 663
 664   assert(false && "Missing object for anonymous record");
 665   return 0;
 666 }
 667
 668 /// \brief Given a field that represents a member of an anonymous
 669 /// struct/union, build the path from that field's context to the
 670 /// actual member.
 671 ///
 672 /// Construct the sequence of field member references we'll have to
 673 /// perform to get to the field in the anonymous union/struct. The
 674 /// list of members is built from the field outward, so traverse it
 675 /// backwards to go from an object in the current context to the field
 676 /// we found.
 677 ///
 678 /// \returns The variable from which the field access should begin,
 679 /// for an anonymous struct/union that is not a member of another
 680 /// class. Otherwise, returns NULL.
 681 VarDecl *Sema::BuildAnonymousStructUnionMemberPath(FieldDecl *Field,
 682                                    llvm::SmallVectorImpl<FieldDecl *> &Path) {
 683   assert(Field->getDeclContext()->isRecord() &&
 684          cast<RecordDecl>(Field->getDeclContext())->isAnonymousStructOrUnion()
 685          && "Field must be stored inside an anonymous struct or union");
 686
 687   Path.push_back(Field);
 688   VarDecl *BaseObject = 0;
 689   DeclContext *Ctx = Field->getDeclContext();
 690   do {
 691     RecordDecl *Record = cast<RecordDecl>(Ctx);
 692     Decl *AnonObject = getObjectForAnonymousRecordDecl(Context, Record);
 693     if (FieldDecl *AnonField = dyn_cast<FieldDecl>(AnonObject))
 694       Path.push_back(AnonField);
 695     else {
 696       BaseObject = cast<VarDecl>(AnonObject);
 697       break;
 698     }
 699     Ctx = Ctx->getParent();
 700   } while (Ctx->isRecord() &&
 701            cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion());
 702
 703   return BaseObject;
 704 }
 705
 706 Sema::OwningExprResult
 707 Sema::BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
 708                                                FieldDecl *Field,
 709                                                Expr *BaseObjectExpr,
 710                                                SourceLocation OpLoc) {
 711   llvm::SmallVector<FieldDecl *, 4> AnonFields;
 712   VarDecl *BaseObject = BuildAnonymousStructUnionMemberPath(Field,
 713                                                             AnonFields);
 714
 715   // Build the expression that refers to the base object, from
 716   // which we will build a sequence of member references to each
 717   // of the anonymous union objects and, eventually, the field we
 718   // found via name lookup.
 719   bool BaseObjectIsPointer = false;
 720   unsigned ExtraQuals = 0;
 721   if (BaseObject) {
 722     // BaseObject is an anonymous struct/union variable (and is,
 723     // therefore, not part of another non-anonymous record).
 724     if (BaseObjectExpr) BaseObjectExpr->Destroy(Context);
 725     MarkDeclarationReferenced(Loc, BaseObject);
 726     BaseObjectExpr = new (Context) DeclRefExpr(BaseObject,BaseObject->getType(),
 727                                                SourceLocation());
 728     ExtraQuals
 729       = Context.getCanonicalType(BaseObject->getType()).getCVRQualifiers();
 730   } else if (BaseObjectExpr) {
 731     // The caller provided the base object expression. Determine
 732     // whether its a pointer and whether it adds any qualifiers to the
 733     // anonymous struct/union fields we're looking into.
 734     QualType ObjectType = BaseObjectExpr->getType();
 735     if (const PointerType *ObjectPtr = ObjectType->getAsPointerType()) {
 736       BaseObjectIsPointer = true;
 737       ObjectType = ObjectPtr->getPointeeType();
 738     }
 739     ExtraQuals = Context.getCanonicalType(ObjectType).getCVRQualifiers();
 740   } else {
 741     // We've found a member of an anonymous struct/union that is
 742     // inside a non-anonymous struct/union, so in a well-formed
 743     // program our base object expression is "this".
 744     if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
 745       if (!MD->isStatic()) {
 746         QualType AnonFieldType
 747           = Context.getTagDeclType(
 748                      cast<RecordDecl>(AnonFields.back()->getDeclContext()));
 749         QualType ThisType = Context.getTagDeclType(MD->getParent());
 750         if ((Context.getCanonicalType(AnonFieldType)
 751                == Context.getCanonicalType(ThisType)) ||
 752             IsDerivedFrom(ThisType, AnonFieldType)) {
 753           // Our base object expression is "this".
 754           BaseObjectExpr = new (Context) CXXThisExpr(SourceLocation(),
 755                                                      MD->getThisType(Context));
 756           BaseObjectIsPointer = true;
 757         }
 758       } else {
 759         return ExprError(Diag(Loc,diag::err_invalid_member_use_in_static_method)
 760           << Field->getDeclName());
 761       }
 762       ExtraQuals = MD->getTypeQualifiers();
 763     }
 764
 765     if (!BaseObjectExpr)
 766       return ExprError(Diag(Loc, diag::err_invalid_non_static_member_use)
 767         << Field->getDeclName());
 768   }
 769
 770   // Build the implicit member references to the field of the
 771   // anonymous struct/union.
 772   Expr *Result = BaseObjectExpr;
 773   for (llvm::SmallVector<FieldDecl *, 4>::reverse_iterator
 774          FI = AnonFields.rbegin(), FIEnd = AnonFields.rend();
 775        FI != FIEnd; ++FI) {
 776     QualType MemberType = (*FI)->getType();
 777     if (!(*FI)->isMutable()) {
 778       unsigned combinedQualifiers
 779         = MemberType.getCVRQualifiers() | ExtraQuals;
 780       MemberType = MemberType.getQualifiedType(combinedQualifiers);
 781     }
 782     MarkDeclarationReferenced(Loc, *FI);
 783     Result = new (Context) MemberExpr(Result, BaseObjectIsPointer, *FI,
 784                                       OpLoc, MemberType);
 785     BaseObjectIsPointer = false;
 786     ExtraQuals = Context.getCanonicalType(MemberType).getCVRQualifiers();
 787   }
 788
 789   return Owned(Result);
 790 }
 791
 792 /// ActOnDeclarationNameExpr - The parser has read some kind of name
 793 /// (e.g., a C++ id-expression (C++ [expr.prim]p1)). This routine
 794 /// performs lookup on that name and returns an expression that refers
 795 /// to that name. This routine isn't directly called from the parser,
 796 /// because the parser doesn't know about DeclarationName. Rather,
 797 /// this routine is called by ActOnIdentifierExpr,
 798 /// ActOnOperatorFunctionIdExpr, and ActOnConversionFunctionExpr,
 799 /// which form the DeclarationName from the corresponding syntactic
 800 /// forms.
 801 ///
 802 /// HasTrailingLParen indicates whether this identifier is used in a
 803 /// function call context.  LookupCtx is only used for a C++
 804 /// qualified-id (foo::bar) to indicate the class or namespace that
 805 /// the identifier must be a member of.
 806 ///
 807 /// isAddressOfOperand means that this expression is the direct operand
 808 /// of an address-of operator. This matters because this is the only
 809 /// situation where a qualified name referencing a non-static member may
 810 /// appear outside a member function of this class.
 811 Sema::OwningExprResult
 812 Sema::ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc,
 813                                DeclarationName Name, bool HasTrailingLParen,
 814                                const CXXScopeSpec *SS,
 815                                bool isAddressOfOperand) {
 816   // Could be enum-constant, value decl, instance variable, etc.
 817   if (SS && SS->isInvalid())
 818     return ExprError();
 819
 820   // C++ [temp.dep.expr]p3:
 821   //   An id-expression is type-dependent if it contains:
 822   //     -- a nested-name-specifier that contains a class-name that
 823   //        names a dependent type.
 824   // FIXME: Member of the current instantiation.
 825   if (SS && isDependentScopeSpecifier(*SS)) {
 826     return Owned(new (Context) UnresolvedDeclRefExpr(Name, Context.DependentTy,
 827                                                      Loc, SS->getRange(),
 828                 static_cast<NestedNameSpecifier *>(SS->getScopeRep())));
 829   }
 830
 831   LookupResult Lookup = LookupParsedName(S, SS, Name, LookupOrdinaryName,
 832                                          false, true, Loc);
 833
 834   if (Lookup.isAmbiguous()) {
 835     DiagnoseAmbiguousLookup(Lookup, Name, Loc,
 836                             SS && SS->isSet() ? SS->getRange()
 837                                               : SourceRange());
 838     return ExprError();
 839   }
 840
 841   NamedDecl *D = Lookup.getAsDecl();
 842
 843   // If this reference is in an Objective-C method, then ivar lookup happens as
 844   // well.
 845   IdentifierInfo *II = Name.getAsIdentifierInfo();
 846   if (II && getCurMethodDecl()) {
 847     // There are two cases to handle here.  1) scoped lookup could have failed,
 848     // in which case we should look for an ivar.  2) scoped lookup could have
 849     // found a decl, but that decl is outside the current instance method (i.e.
 850     // a global variable).  In these two cases, we do a lookup for an ivar with
 851     // this name, if the lookup sucedes, we replace it our current decl.
 852     if (D == 0 || D->isDefinedOutsideFunctionOrMethod()) {
 853       ObjCInterfaceDecl *IFace = getCurMethodDecl()->getClassInterface();
 854       ObjCInterfaceDecl *ClassDeclared;
 855       if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(Context, II,
 856                                                            ClassDeclared)) {
 857         // Check if referencing a field with __attribute__((deprecated)).
 858         if (DiagnoseUseOfDecl(IV, Loc))
 859           return ExprError();
 860
 861         // If we're referencing an invalid decl, just return this as a silent
 862         // error node.  The error diagnostic was already emitted on the decl.
 863         if (IV->isInvalidDecl())
 864           return ExprError();
 865
 866         bool IsClsMethod = getCurMethodDecl()->isClassMethod();
 867         // If a class method attemps to use a free standing ivar, this is
 868         // an error.
 869         if (IsClsMethod && D && !D->isDefinedOutsideFunctionOrMethod())
 870            return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method)
 871                            << IV->getDeclName());
 872         // If a class method uses a global variable, even if an ivar with
 873         // same name exists, use the global.
 874         if (!IsClsMethod) {
 875           if (IV->getAccessControl() == ObjCIvarDecl::Private &&
 876               ClassDeclared != IFace)
 877            Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName();
 878           // FIXME: This should use a new expr for a direct reference, don't
 879           // turn this into Self->ivar, just return a BareIVarExpr or something.
 880           IdentifierInfo &II = Context.Idents.get("self");
 881           OwningExprResult SelfExpr = ActOnIdentifierExpr(S, Loc, II, false);
 882           MarkDeclarationReferenced(Loc, IV);
 883           return Owned(new (Context)
 884                        ObjCIvarRefExpr(IV, IV->getType(), Loc,
 885                                        SelfExpr.takeAs<Expr>(), true, true));
 886         }
 887       }
 888     }
 889     else if (getCurMethodDecl()->isInstanceMethod()) {
 890       // We should warn if a local variable hides an ivar.
 891       ObjCInterfaceDecl *IFace = getCurMethodDecl()->getClassInterface();
 892       ObjCInterfaceDecl *ClassDeclared;
 893       if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(Context, II,
 894                                                            ClassDeclared)) {
 895         if (IV->getAccessControl() != ObjCIvarDecl::Private ||
 896             IFace == ClassDeclared)
 897           Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
 898       }
 899     }
 900     // Needed to implement property "super.method" notation.
 901     if (D == 0 && II->isStr("super")) {
 902       QualType T;
 903
 904       if (getCurMethodDecl()->isInstanceMethod())
 905         T = Context.getPointerType(Context.getObjCInterfaceType(
 906                                    getCurMethodDecl()->getClassInterface()));
 907       else
 908         T = Context.getObjCClassType();
 909       return Owned(new (Context) ObjCSuperExpr(Loc, T));
 910     }
 911   }
 912
 913   // Determine whether this name might be a candidate for
 914   // argument-dependent lookup.
 915   bool ADL = getLangOptions().CPlusPlus && (!SS || !SS->isSet()) &&
 916              HasTrailingLParen;
 917
 918   if (ADL && D == 0) {
 919     // We've seen something of the form
 920     //
 921     //   identifier(
 922     //
 923     // and we did not find any entity by the name
 924     // "identifier". However, this identifier is still subject to
 925     // argument-dependent lookup, so keep track of the name.
 926     return Owned(new (Context) UnresolvedFunctionNameExpr(Name,
 927                                                           Context.OverloadTy,
 928                                                           Loc));
 929   }
 930
 931   if (D == 0) {
 932     // Otherwise, this could be an implicitly declared function reference (legal
 933     // in C90, extension in C99).
 934     if (HasTrailingLParen && II &&
 935         !getLangOptions().CPlusPlus) // Not in C++.
 936       D = ImplicitlyDefineFunction(Loc, *II, S);
 937     else {
 938       // If this name wasn't predeclared and if this is not a function call,
 939       // diagnose the problem.
 940       if (SS && !SS->isEmpty())
 941         return ExprError(Diag(Loc, diag::err_typecheck_no_member)
 942           << Name << SS->getRange());
 943       else if (Name.getNameKind() == DeclarationName::CXXOperatorName ||
 944                Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
 945         return ExprError(Diag(Loc, diag::err_undeclared_use)
 946           << Name.getAsString());
 947       else
 948         return ExprError(Diag(Loc, diag::err_undeclared_var_use) << Name);
 949     }
 950   }
 951
 952   // If this is an expression of the form &Class::member, don't build an
 953   // implicit member ref, because we want a pointer to the member in general,
 954   // not any specific instance's member.
 955   if (isAddressOfOperand && SS && !SS->isEmpty() && !HasTrailingLParen) {
 956     DeclContext *DC = computeDeclContext(*SS);
 957     if (D && isa<CXXRecordDecl>(DC)) {
 958       QualType DType;
 959       if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
 960         DType = FD->getType().getNonReferenceType();
 961       } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
 962         DType = Method->getType();
 963       } else if (isa<OverloadedFunctionDecl>(D)) {
 964         DType = Context.OverloadTy;
 965       }
 966       // Could be an inner type. That's diagnosed below, so ignore it here.
 967       if (!DType.isNull()) {
 968         // The pointer is type- and value-dependent if it points into something
 969         // dependent.
 970         bool Dependent = DC->isDependentContext();
 971         return Owned(BuildDeclRefExpr(D, DType, Loc, Dependent, Dependent, SS));
 972       }
 973     }
 974   }
 975
 976   // We may have found a field within an anonymous union or struct
 977   // (C++ [class.union]).
 978   if (FieldDecl *FD = dyn_cast<FieldDecl>(D))
 979     if (cast<RecordDecl>(FD->getDeclContext())->isAnonymousStructOrUnion())
 980       return BuildAnonymousStructUnionMemberReference(Loc, FD);
 981
 982   if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
 983     if (!MD->isStatic()) {
 984       // C++ [class.mfct.nonstatic]p2:
 985       //   [...] if name lookup (3.4.1) resolves the name in the
 986       //   id-expression to a nonstatic nontype member of class X or of
 987       //   a base class of X, the id-expression is transformed into a
 988       //   class member access expression (5.2.5) using (*this) (9.3.2)
 989       //   as the postfix-expression to the left of the '.' operator.
 990       DeclContext *Ctx = 0;
 991       QualType MemberType;
 992       if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
 993         Ctx = FD->getDeclContext();
 994         MemberType = FD->getType();
 995
 996         if (const ReferenceType *RefType = MemberType->getAsReferenceType())
 997           MemberType = RefType->getPointeeType();
 998         else if (!FD->isMutable()) {
 999           unsigned combinedQualifiers
1000             = MemberType.getCVRQualifiers() | MD->getTypeQualifiers();
1001           MemberType = MemberType.getQualifiedType(combinedQualifiers);
1002         }
1003       } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
1004         if (!Method->isStatic()) {
1005           Ctx = Method->getParent();
1006           MemberType = Method->getType();
1007         }
1008       } else if (OverloadedFunctionDecl *Ovl
1009                    = dyn_cast<OverloadedFunctionDecl>(D)) {
1010         for (OverloadedFunctionDecl::function_iterator
1011                Func = Ovl->function_begin(),
1012                FuncEnd = Ovl->function_end();
1013              Func != FuncEnd; ++Func) {
1014           if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(*Func))
1015             if (!DMethod->isStatic()) {
1016               Ctx = Ovl->getDeclContext();
1017               MemberType = Context.OverloadTy;
1018               break;
1019             }
1020         }
1021       }
1022
1023       if (Ctx && Ctx->isRecord()) {
1024         QualType CtxType = Context.getTagDeclType(cast<CXXRecordDecl>(Ctx));
1025         QualType ThisType = Context.getTagDeclType(MD->getParent());
1026         if ((Context.getCanonicalType(CtxType)
1027                == Context.getCanonicalType(ThisType)) ||
1028             IsDerivedFrom(ThisType, CtxType)) {
1029           // Build the implicit member access expression.
1030           Expr *This = new (Context) CXXThisExpr(SourceLocation(),
1031                                                  MD->getThisType(Context));
1032           MarkDeclarationReferenced(Loc, D);
1033           return Owned(new (Context) MemberExpr(This, true, D,
1034                                                 Loc, MemberType));
1035         }
1036       }
1037     }
1038   }
1039
1040   if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
1041     if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
1042       if (MD->isStatic())
1043         // "invalid use of member 'x' in static member function"
1044         return ExprError(Diag(Loc,diag::err_invalid_member_use_in_static_method)
1045           << FD->getDeclName());
1046     }
1047
1048     // Any other ways we could have found the field in a well-formed
1049     // program would have been turned into implicit member expressions
1050     // above.
1051     return ExprError(Diag(Loc, diag::err_invalid_non_static_member_use)
1052       << FD->getDeclName());
1053   }
1054
1055   if (isa<TypedefDecl>(D))
1056     return ExprError(Diag(Loc, diag::err_unexpected_typedef) << Name);
1057   if (isa<ObjCInterfaceDecl>(D))
1058     return ExprError(Diag(Loc, diag::err_unexpected_interface) << Name);
1059   if (isa<NamespaceDecl>(D))
1060     return ExprError(Diag(Loc, diag::err_unexpected_namespace) << Name);
1061
1062   // Make the DeclRefExpr or BlockDeclRefExpr for the decl.
1063   if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D))
1064     return Owned(BuildDeclRefExpr(Ovl, Context.OverloadTy, Loc,
1065                                   false, false, SS));
1066   else if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
1067     return Owned(BuildDeclRefExpr(Template, Context.OverloadTy, Loc,
1068                                   false, false, SS));
1069   ValueDecl *VD = cast<ValueDecl>(D);
1070
1071   // Check whether this declaration can be used. Note that we suppress
1072   // this check when we're going to perform argument-dependent lookup
1073   // on this function name, because this might not be the function
1074   // that overload resolution actually selects.
1075   if (!(ADL && isa<FunctionDecl>(VD)) && DiagnoseUseOfDecl(VD, Loc))
1076     return ExprError();
1077
1078   if (VarDecl *Var = dyn_cast<VarDecl>(VD)) {
1079     // Warn about constructs like:
1080     //   if (void *X = foo()) { ... } else { X }.
1081     // In the else block, the pointer is always false.
1082
1083     // FIXME: In a template instantiation, we don't have scope
1084     // information to check this property.
1085     if (Var->isDeclaredInCondition() && Var->getType()->isScalarType()) {
1086       Scope *CheckS = S;
1087       while (CheckS) {
1088         if (CheckS->isWithinElse() &&
1089             CheckS->getControlParent()->isDeclScope(DeclPtrTy::make(Var))) {
1090           if (Var->getType()->isBooleanType())
1091             ExprError(Diag(Loc, diag::warn_value_always_false)
1092               << Var->getDeclName());
1093           else
1094             ExprError(Diag(Loc, diag::warn_value_always_zero)
1095               << Var->getDeclName());
1096           break;
1097         }
1098
1099         // Move up one more control parent to check again.
1100         CheckS = CheckS->getControlParent();
1101         if (CheckS)
1102           CheckS = CheckS->getParent();
1103       }
1104     }
1105   } else if (FunctionDecl *Func = dyn_cast<FunctionDecl>(VD)) {
1106     if (!getLangOptions().CPlusPlus && !Func->hasPrototype()) {
1107       // C99 DR 316 says that, if a function type comes from a
1108       // function definition (without a prototype), that type is only
1109       // used for checking compatibility. Therefore, when referencing
1110       // the function, we pretend that we don't have the full function
1111       // type.
1112       QualType T = Func->getType();
1113       QualType NoProtoType = T;
1114       if (const FunctionProtoType *Proto = T->getAsFunctionProtoType())
1115         NoProtoType = Context.getFunctionNoProtoType(Proto->getResultType());
1116       return Owned(BuildDeclRefExpr(VD, NoProtoType, Loc, false, false, SS));
1117     }
1118   }
1119
1120   // Only create DeclRefExpr's for valid Decl's.
1121   if (VD->isInvalidDecl())
1122     return ExprError();
1123
1124   // If the identifier reference is inside a block, and it refers to a value
1125   // that is outside the block, create a BlockDeclRefExpr instead of a
1126   // DeclRefExpr.  This ensures the value is treated as a copy-in snapshot when
1127   // the block is formed.
1128   //
1129   // We do not do this for things like enum constants, global variables, etc,
1130   // as they do not get snapshotted.
1131   //
1132   if (CurBlock && ShouldSnapshotBlockValueReference(CurBlock, VD)) {
1133     MarkDeclarationReferenced(Loc, VD);
1134     QualType ExprTy = VD->getType().getNonReferenceType();
1135     // The BlocksAttr indicates the variable is bound by-reference.
1136     if (VD->getAttr<BlocksAttr>(Context))
1137       return Owned(new (Context) BlockDeclRefExpr(VD, ExprTy, Loc, true));
1138     // This is to record that a 'const' was actually synthesize and added.
1139     bool constAdded = !ExprTy.isConstQualified();
1140     // Variable will be bound by-copy, make it const within the closure.
1141
1142     ExprTy.addConst();
1143     return Owned(new (Context) BlockDeclRefExpr(VD, ExprTy, Loc, false,
1144                                                 constAdded));
1145   }
1146   // If this reference is not in a block or if the referenced variable is
1147   // within the block, create a normal DeclRefExpr.
1148
1149   bool TypeDependent = false;
1150   bool ValueDependent = false;
1151   if (getLangOptions().CPlusPlus) {
1152     // C++ [temp.dep.expr]p3:
1153     //   An id-expression is type-dependent if it contains:
1154     //     - an identifier that was declared with a dependent type,
1155     if (VD->getType()->isDependentType())
1156       TypeDependent = true;
1157     //     - FIXME: a template-id that is dependent,
1158     //     - a conversion-function-id that specifies a dependent type,
1159     else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName &&
1160              Name.getCXXNameType()->isDependentType())
1161       TypeDependent = true;
1162     //     - a nested-name-specifier that contains a class-name that
1163     //       names a dependent type.
1164     else if (SS && !SS->isEmpty()) {
1165       for (DeclContext *DC = computeDeclContext(*SS);
1166            DC; DC = DC->getParent()) {
1167         // FIXME: could stop early at namespace scope.
1168         if (DC->isRecord()) {
1169           CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
1170           if (Context.getTypeDeclType(Record)->isDependentType()) {
1171             TypeDependent = true;
1172             break;
1173           }
1174         }
1175       }
1176     }
1177
1178     // C++ [temp.dep.constexpr]p2:
1179     //
1180     //   An identifier is value-dependent if it is:
1181     //     - a name declared with a dependent type,
1182     if (TypeDependent)
1183       ValueDependent = true;
1184     //     - the name of a non-type template parameter,
1185     else if (isa<NonTypeTemplateParmDecl>(VD))
1186       ValueDependent = true;
1187     //    - a constant with integral or enumeration type and is
1188     //      initialized with an expression that is value-dependent
1189     else if (const VarDecl *Dcl = dyn_cast<VarDecl>(VD)) {
1190       if (Dcl->getType().getCVRQualifiers() == QualType::Const &&
1191           Dcl->getInit()) {
1192         ValueDependent = Dcl->getInit()->isValueDependent();
1193       }
1194     }
1195   }
1196
1197   return Owned(BuildDeclRefExpr(VD, VD->getType().getNonReferenceType(), Loc,
1198                                 TypeDependent, ValueDependent, SS));
1199 }
1200
1201 Sema::OwningExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc,
1202                                                  tok::TokenKind Kind) {
1203   PredefinedExpr::IdentType IT;
1204
1205   switch (Kind) {
1206   default: assert(0 && "Unknown simple primary expr!");
1207   case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
1208   case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
1209   case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
1210   }
1211
1212   // Pre-defined identifiers are of type char[x], where x is the length of the
1213   // string.
1214   unsigned Length;
1215   if (FunctionDecl *FD = getCurFunctionDecl())
1216     Length = FD->getIdentifier()->getLength();
1217   else if (ObjCMethodDecl *MD = getCurMethodDecl())
1218     Length = MD->getSynthesizedMethodSize();
1219   else {
1220     Diag(Loc, diag::ext_predef_outside_function);
1221     // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
1222     Length = IT == PredefinedExpr::PrettyFunction ? strlen("top level") : 0;
1223   }
1224
1225
1226   llvm::APInt LengthI(32, Length + 1);
1227   QualType ResTy = Context.CharTy.getQualifiedType(QualType::Const);
1228   ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0);
1229   return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT));
1230 }
1231
1232 Sema::OwningExprResult Sema::ActOnCharacterConstant(const Token &Tok) {
1233   llvm::SmallString<16> CharBuffer;
1234   CharBuffer.resize(Tok.getLength());
1235   const char *ThisTokBegin = &CharBuffer[0];
1236   unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin);
1237
1238   CharLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength,
1239                             Tok.getLocation(), PP);
1240   if (Literal.hadError())
1241     return ExprError();
1242
1243   QualType type = getLangOptions().CPlusPlus ? Context.CharTy : Context.IntTy;
1244
1245   return Owned(new (Context) CharacterLiteral(Literal.getValue(),
1246                                               Literal.isWide(),
1247                                               type, Tok.getLocation()));
1248 }
1249
1250 Action::OwningExprResult Sema::ActOnNumericConstant(const Token &Tok) {
1251   // Fast path for a single digit (which is quite common).  A single digit
1252   // cannot have a trigraph, escaped newline, radix prefix, or type suffix.
1253   if (Tok.getLength() == 1) {
1254     const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok);
1255     unsigned IntSize = Context.Target.getIntWidth();
1256     return Owned(new (Context) IntegerLiteral(llvm::APInt(IntSize, Val-'0'),
1257                     Context.IntTy, Tok.getLocation()));
1258   }
1259
1260   llvm::SmallString<512> IntegerBuffer;
1261   // Add padding so that NumericLiteralParser can overread by one character.
1262   IntegerBuffer.resize(Tok.getLength()+1);
1263   const char *ThisTokBegin = &IntegerBuffer[0];
1264
1265   // Get the spelling of the token, which eliminates trigraphs, etc.
1266   unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin);
1267
1268   NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength,
1269                                Tok.getLocation(), PP);
1270   if (Literal.hadError)
1271     return ExprError();
1272
1273   Expr *Res;
1274
1275   if (Literal.isFloatingLiteral()) {
1276     QualType Ty;
1277     if (Literal.isFloat)
1278       Ty = Context.FloatTy;
1279     else if (!Literal.isLong)
1280       Ty = Context.DoubleTy;
1281     else
1282       Ty = Context.LongDoubleTy;
1283
1284     const llvm::fltSemantics &Format = Context.getFloatTypeSemantics(Ty);
1285
1286     // isExact will be set by GetFloatValue().
1287     bool isExact = false;
1288     Res = new (Context) FloatingLiteral(Literal.GetFloatValue(Format, &isExact),
1289                                         &isExact, Ty, Tok.getLocation());
1290
1291   } else if (!Literal.isIntegerLiteral()) {
1292     return ExprError();
1293   } else {
1294     QualType Ty;
1295
1296     // long long is a C99 feature.
1297     if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x &&
1298         Literal.isLongLong)
1299       Diag(Tok.getLocation(), diag::ext_longlong);
1300
1301     // Get the value in the widest-possible width.
1302     llvm::APInt ResultVal(Context.Target.getIntMaxTWidth(), 0);
1303
1304     if (Literal.GetIntegerValue(ResultVal)) {
1305       // If this value didn't fit into uintmax_t, warn and force to ull.
1306       Diag(Tok.getLocation(), diag::warn_integer_too_large);
1307       Ty = Context.UnsignedLongLongTy;
1308       assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
1309              "long long is not intmax_t?");
1310     } else {
1311       // If this value fits into a ULL, try to figure out what else it fits into
1312       // according to the rules of C99 6.4.4.1p5.
1313
1314       // Octal, Hexadecimal, and integers with a U suffix are allowed to
1315       // be an unsigned int.
1316       bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
1317
1318       // Check from smallest to largest, picking the smallest type we can.
1319       unsigned Width = 0;
1320       if (!Literal.isLong && !Literal.isLongLong) {
1321         // Are int/unsigned possibilities?
1322         unsigned IntSize = Context.Target.getIntWidth();
1323
1324         // Does it fit in a unsigned int?
1325         if (ResultVal.isIntN(IntSize)) {
1326           // Does it fit in a signed int?
1327           if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
1328             Ty = Context.IntTy;
1329           else if (AllowUnsigned)
1330             Ty = Context.UnsignedIntTy;
1331           Width = IntSize;
1332         }
1333       }
1334
1335       // Are long/unsigned long possibilities?
1336       if (Ty.isNull() && !Literal.isLongLong) {
1337         unsigned LongSize = Context.Target.getLongWidth();
1338
1339         // Does it fit in a unsigned long?
1340         if (ResultVal.isIntN(LongSize)) {
1341           // Does it fit in a signed long?
1342           if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
1343             Ty = Context.LongTy;
1344           else if (AllowUnsigned)
1345             Ty = Context.UnsignedLongTy;
1346           Width = LongSize;
1347         }
1348       }
1349
1350       // Finally, check long long if needed.
1351       if (Ty.isNull()) {
1352         unsigned LongLongSize = Context.Target.getLongLongWidth();
1353
1354         // Does it fit in a unsigned long long?
1355         if (ResultVal.isIntN(LongLongSize)) {
1356           // Does it fit in a signed long long?
1357           if (!Literal.isUnsigned && ResultVal[LongLongSize-1] == 0)
1358             Ty = Context.LongLongTy;
1359           else if (AllowUnsigned)
1360             Ty = Context.UnsignedLongLongTy;
1361           Width = LongLongSize;
1362         }
1363       }
1364
1365       // If we still couldn't decide a type, we probably have something that
1366       // does not fit in a signed long long, but has no U suffix.
1367       if (Ty.isNull()) {
1368         Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed);
1369         Ty = Context.UnsignedLongLongTy;
1370         Width = Context.Target.getLongLongWidth();
1371       }
1372
1373       if (ResultVal.getBitWidth() != Width)
1374         ResultVal.trunc(Width);
1375     }
1376     Res = new (Context) IntegerLiteral(ResultVal, Ty, Tok.getLocation());
1377   }
1378
1379   // If this is an imaginary literal, create the ImaginaryLiteral wrapper.
1380   if (Literal.isImaginary)
1381     Res = new (Context) ImaginaryLiteral(Res,
1382                                         Context.getComplexType(Res->getType()));
1383
1384   return Owned(Res);
1385 }
1386
1387 Action::OwningExprResult Sema::ActOnParenExpr(SourceLocation L,
1388                                               SourceLocation R, ExprArg Val) {
1389   Expr *E = Val.takeAs<Expr>();
1390   assert((E != 0) && "ActOnParenExpr() missing expr");
1391   return Owned(new (Context) ParenExpr(L, R, E));
1392 }
1393
1394 /// The UsualUnaryConversions() function is *not* called by this routine.
1395 /// See C99 6.3.2.1p[2-4] for more details.
1396 bool Sema::CheckSizeOfAlignOfOperand(QualType exprType,
1397                                      SourceLocation OpLoc,
1398                                      const SourceRange &ExprRange,
1399                                      bool isSizeof) {
1400   if (exprType->isDependentType())
1401     return false;
1402
1403   // C99 6.5.3.4p1:
1404   if (isa<FunctionType>(exprType)) {
1405     // alignof(function) is allowed as an extension.
1406     if (isSizeof)
1407       Diag(OpLoc, diag::ext_sizeof_function_type) << ExprRange;
1408     return false;
1409   }
1410
1411   // Allow sizeof(void)/alignof(void) as an extension.
1412   if (exprType->isVoidType()) {
1413     Diag(OpLoc, diag::ext_sizeof_void_type)
1414       << (isSizeof ? "sizeof" : "__alignof") << ExprRange;
1415     return false;
1416   }
1417
1418   if (RequireCompleteType(OpLoc, exprType,
1419                           isSizeof ? diag::err_sizeof_incomplete_type :
1420                           diag::err_alignof_incomplete_type,
1421                           ExprRange))
1422     return true;
1423
1424   // Reject sizeof(interface) and sizeof(interface<proto>) in 64-bit mode.
1425   if (LangOpts.ObjCNonFragileABI && exprType->isObjCInterfaceType()) {
1426     Diag(OpLoc, diag::err_sizeof_nonfragile_interface)
1427       << exprType << isSizeof << ExprRange;
1428     return true;
1429   }
1430
1431   return false;
1432 }
1433
1434 bool Sema::CheckAlignOfExpr(Expr *E, SourceLocation OpLoc,
1435                             const SourceRange &ExprRange) {
1436   E = E->IgnoreParens();
1437
1438   // alignof decl is always ok.
1439   if (isa<DeclRefExpr>(E))
1440     return false;
1441
1442   // Cannot know anything else if the expression is dependent.
1443   if (E->isTypeDependent())
1444     return false;
1445
1446   if (E->getBitField()) {
1447     Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 1 << ExprRange;
1448     return true;
1449   }
1450
1451   // Alignment of a field access is always okay, so long as it isn't a
1452   // bit-field.
1453   if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
1454     if (dyn_cast<FieldDecl>(ME->getMemberDecl()))
1455       return false;
1456
1457   return CheckSizeOfAlignOfOperand(E->getType(), OpLoc, ExprRange, false);
1458 }
1459
1460 /// \brief Build a sizeof or alignof expression given a type operand.
1461 Action::OwningExprResult
1462 Sema::CreateSizeOfAlignOfExpr(QualType T, SourceLocation OpLoc,
1463                               bool isSizeOf, SourceRange R) {
1464   if (T.isNull())
1465     return ExprError();
1466
1467   if (!T->isDependentType() &&
1468       CheckSizeOfAlignOfOperand(T, OpLoc, R, isSizeOf))
1469     return ExprError();
1470
1471   // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
1472   return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, T,
1473                                                Context.getSizeType(), OpLoc,
1474                                                R.getEnd()));
1475 }
1476
1477 /// \brief Build a sizeof or alignof expression given an expression
1478 /// operand.
1479 Action::OwningExprResult
1480 Sema::CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
1481                               bool isSizeOf, SourceRange R) {
1482   // Verify that the operand is valid.
1483   bool isInvalid = false;
1484   if (E->isTypeDependent()) {
1485     // Delay type-checking for type-dependent expressions.
1486   } else if (!isSizeOf) {
1487     isInvalid = CheckAlignOfExpr(E, OpLoc, R);
1488   } else if (E->getBitField()) {  // C99 6.5.3.4p1.
1489     Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 0;
1490     isInvalid = true;
1491   } else {
1492     isInvalid = CheckSizeOfAlignOfOperand(E->getType(), OpLoc, R, true);
1493   }
1494
1495   if (isInvalid)
1496     return ExprError();
1497
1498   // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
1499   return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, E,
1500                                                Context.getSizeType(), OpLoc,
1501                                                R.getEnd()));
1502 }
1503
1504 /// ActOnSizeOfAlignOfExpr - Handle @c sizeof(type) and @c sizeof @c expr and
1505 /// the same for @c alignof and @c __alignof
1506 /// Note that the ArgRange is invalid if isType is false.
1507 Action::OwningExprResult
1508 Sema::ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
1509                              void *TyOrEx, const SourceRange &ArgRange) {
1510   // If error parsing type, ignore.
1511   if (TyOrEx == 0) return ExprError();
1512
1513   if (isType) {
1514     QualType ArgTy = QualType::getFromOpaquePtr(TyOrEx);
1515     return CreateSizeOfAlignOfExpr(ArgTy, OpLoc, isSizeof, ArgRange);
1516   }
1517
1518   // Get the end location.
1519   Expr *ArgEx = (Expr *)TyOrEx;
1520   Action::OwningExprResult Result
1521     = CreateSizeOfAlignOfExpr(ArgEx, OpLoc, isSizeof, ArgEx->getSourceRange());
1522
1523   if (Result.isInvalid())
1524     DeleteExpr(ArgEx);
1525
1526   return move(Result);
1527 }
1528
1529 QualType Sema::CheckRealImagOperand(Expr *&V, SourceLocation Loc, bool isReal) {
1530   if (V->isTypeDependent())
1531     return Context.DependentTy;
1532
1533   // These operators return the element type of a complex type.
1534   if (const ComplexType *CT = V->getType()->getAsComplexType())
1535     return CT->getElementType();
1536
1537   // Otherwise they pass through real integer and floating point types here.
1538   if (V->getType()->isArithmeticType())
1539     return V->getType();
1540
1541   // Reject anything else.
1542   Diag(Loc, diag::err_realimag_invalid_type) << V->getType()
1543     << (isReal ? "__real" : "__imag");
1544   return QualType();
1545 }
1546
1547
1548
1549 Action::OwningExprResult
1550 Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
1551                           tok::TokenKind Kind, ExprArg Input) {
1552   Expr *Arg = (Expr *)Input.get();
1553
1554   UnaryOperator::Opcode Opc;
1555   switch (Kind) {
1556   default: assert(0 && "Unknown unary op!");
1557   case tok::plusplus:   Opc = UnaryOperator::PostInc; break;
1558   case tok::minusminus: Opc = UnaryOperator::PostDec; break;
1559   }
1560
1561   if (getLangOptions().CPlusPlus &&
1562       (Arg->getType()->isRecordType() || Arg->getType()->isEnumeralType())) {
1563     // Which overloaded operator?
1564     OverloadedOperatorKind OverOp =
1565       (Opc == UnaryOperator::PostInc)? OO_PlusPlus : OO_MinusMinus;
1566
1567     // C++ [over.inc]p1:
1568     //
1569     //     [...] If the function is a member function with one
1570     //     parameter (which shall be of type int) or a non-member
1571     //     function with two parameters (the second of which shall be
1572     //     of type int), it defines the postfix increment operator ++
1573     //     for objects of that type. When the postfix increment is
1574     //     called as a result of using the ++ operator, the int
1575     //     argument will have value zero.
1576     Expr *Args[2] = {
1577       Arg,
1578       new (Context) IntegerLiteral(llvm::APInt(Context.Target.getIntWidth(), 0,
1579                           /*isSigned=*/true), Context.IntTy, SourceLocation())
1580     };
1581
1582     // Build the candidate set for overloading
1583     OverloadCandidateSet CandidateSet;
1584     AddOperatorCandidates(OverOp, S, OpLoc, Args, 2, CandidateSet);
1585
1586     // Perform overload resolution.
1587     OverloadCandidateSet::iterator Best;
1588     switch (BestViableFunction(CandidateSet, OpLoc, Best)) {
1589     case OR_Success: {
1590       // We found a built-in operator or an overloaded operator.
1591       FunctionDecl *FnDecl = Best->Function;
1592
1593       if (FnDecl) {
1594         // We matched an overloaded operator. Build a call to that
1595         // operator.
1596
1597         // Convert the arguments.
1598         if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
1599           if (PerformObjectArgumentInitialization(Arg, Method))
1600             return ExprError();
1601         } else {
1602           // Convert the arguments.
1603           if (PerformCopyInitialization(Arg,
1604                                         FnDecl->getParamDecl(0)->getType(),
1605                                         "passing"))
1606             return ExprError();
1607         }
1608
1609         // Determine the result type
1610         QualType ResultTy
1611           = FnDecl->getType()->getAsFunctionType()->getResultType();
1612         ResultTy = ResultTy.getNonReferenceType();
1613
1614         // Build the actual expression node.
1615         Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(),
1616                                                  SourceLocation());
1617         UsualUnaryConversions(FnExpr);
1618
1619         Input.release();
1620         Args[0] = Arg;
1621         return Owned(new (Context) CXXOperatorCallExpr(Context, OverOp, FnExpr,
1622                                                        Args, 2, ResultTy,
1623                                                        OpLoc));
1624       } else {
1625         // We matched a built-in operator. Convert the arguments, then
1626         // break out so that we will build the appropriate built-in
1627         // operator node.
1628         if (PerformCopyInitialization(Arg, Best->BuiltinTypes.ParamTypes[0],
1629                                       "passing"))
1630           return ExprError();
1631
1632         break;
1633       }
1634     }
1635
1636     case OR_No_Viable_Function:
1637       // No viable function; fall through to handling this as a
1638       // built-in operator, which will produce an error message for us.
1639       break;
1640
1641     case OR_Ambiguous:
1642       Diag(OpLoc,  diag::err_ovl_ambiguous_oper)
1643           << UnaryOperator::getOpcodeStr(Opc)
1644           << Arg->getSourceRange();
1645       PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1646       return ExprError();
1647
1648     case OR_Deleted:
1649       Diag(OpLoc, diag::err_ovl_deleted_oper)
1650         << Best->Function->isDeleted()
1651         << UnaryOperator::getOpcodeStr(Opc)
1652         << Arg->getSourceRange();
1653       PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1654       return ExprError();
1655     }
1656
1657     // Either we found no viable overloaded operator or we matched a
1658     // built-in operator. In either case, fall through to trying to
1659     // build a built-in operation.
1660   }
1661
1662   QualType result = CheckIncrementDecrementOperand(Arg, OpLoc,
1663                                                  Opc == UnaryOperator::PostInc);
1664   if (result.isNull())
1665     return ExprError();
1666   Input.release();
1667   return Owned(new (Context) UnaryOperator(Arg, Opc, result, OpLoc));
1668 }
1669
1670 Action::OwningExprResult
1671 Sema::ActOnArraySubscriptExpr(Scope *S, ExprArg Base, SourceLocation LLoc,
1672                               ExprArg Idx, SourceLocation RLoc) {
1673   Expr *LHSExp = static_cast<Expr*>(Base.get()),
1674        *RHSExp = static_cast<Expr*>(Idx.get());
1675
1676   if (getLangOptions().CPlusPlus &&
1677       (LHSExp->isTypeDependent() || RHSExp->isTypeDependent())) {
1678     Base.release();
1679     Idx.release();
1680     return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp,
1681                                                   Context.DependentTy, RLoc));
1682   }
1683
1684   if (getLangOptions().CPlusPlus &&
1685       (LHSExp->getType()->isRecordType() ||
1686        LHSExp->getType()->isEnumeralType() ||
1687        RHSExp->getType()->isRecordType() ||
1688        RHSExp->getType()->isEnumeralType())) {
1689     // Add the appropriate overloaded operators (C++ [over.match.oper])
1690     // to the candidate set.
1691     OverloadCandidateSet CandidateSet;
1692     Expr *Args[2] = { LHSExp, RHSExp };
1693     AddOperatorCandidates(OO_Subscript, S, LLoc, Args, 2, CandidateSet,
1694                           SourceRange(LLoc, RLoc));
1695
1696     // Perform overload resolution.
1697     OverloadCandidateSet::iterator Best;
1698     switch (BestViableFunction(CandidateSet, LLoc, Best)) {
1699     case OR_Success: {
1700       // We found a built-in operator or an overloaded operator.
1701       FunctionDecl *FnDecl = Best->Function;
1702
1703       if (FnDecl) {
1704         // We matched an overloaded operator. Build a call to that
1705         // operator.
1706
1707         // Convert the arguments.
1708         if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
1709           if (PerformObjectArgumentInitialization(LHSExp, Method) ||
1710               PerformCopyInitialization(RHSExp,
1711                                         FnDecl->getParamDecl(0)->getType(),
1712                                         "passing"))
1713             return ExprError();
1714         } else {
1715           // Convert the arguments.
1716           if (PerformCopyInitialization(LHSExp,
1717                                         FnDecl->getParamDecl(0)->getType(),
1718                                         "passing") ||
1719               PerformCopyInitialization(RHSExp,
1720                                         FnDecl->getParamDecl(1)->getType(),
1721                                         "passing"))
1722             return ExprError();
1723         }
1724
1725         // Determine the result type
1726         QualType ResultTy
1727           = FnDecl->getType()->getAsFunctionType()->getResultType();
1728         ResultTy = ResultTy.getNonReferenceType();
1729
1730         // Build the actual expression node.
1731         Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(),
1732                                                  SourceLocation());
1733         UsualUnaryConversions(FnExpr);
1734
1735         Base.release();
1736         Idx.release();
1737         Args[0] = LHSExp;
1738         Args[1] = RHSExp;
1739         return Owned(new (Context) CXXOperatorCallExpr(Context, OO_Subscript,
1740                                                        FnExpr, Args, 2,
1741                                                        ResultTy, LLoc));
1742       } else {
1743         // We matched a built-in operator. Convert the arguments, then
1744         // break out so that we will build the appropriate built-in
1745         // operator node.
1746         if (PerformCopyInitialization(LHSExp, Best->BuiltinTypes.ParamTypes[0],
1747                                       "passing") ||
1748             PerformCopyInitialization(RHSExp, Best->BuiltinTypes.ParamTypes[1],
1749                                       "passing"))
1750           return ExprError();
1751
1752         break;
1753       }
1754     }
1755
1756     case OR_No_Viable_Function:
1757       // No viable function; fall through to handling this as a
1758       // built-in operator, which will produce an error message for us.
1759       break;
1760
1761     case OR_Ambiguous:
1762       Diag(LLoc,  diag::err_ovl_ambiguous_oper)
1763           << "[]"
1764           << LHSExp->getSourceRange() << RHSExp->getSourceRange();
1765       PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1766       return ExprError();
1767
1768     case OR_Deleted:
1769       Diag(LLoc, diag::err_ovl_deleted_oper)
1770         << Best->Function->isDeleted()
1771         << "[]"
1772         << LHSExp->getSourceRange() << RHSExp->getSourceRange();
1773       PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1774       return ExprError();
1775     }
1776
1777     // Either we found no viable overloaded operator or we matched a
1778     // built-in operator. In either case, fall through to trying to
1779     // build a built-in operation.
1780   }
1781
1782   // Perform default conversions.
1783   DefaultFunctionArrayConversion(LHSExp);
1784   DefaultFunctionArrayConversion(RHSExp);
1785
1786   QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType();
1787
1788   // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
1789   // to the expression *((e1)+(e2)). This means the array "Base" may actually be
1790   // in the subscript position. As a result, we need to derive the array base
1791   // and index from the expression types.
1792   Expr *BaseExpr, *IndexExpr;
1793   QualType ResultType;
1794   if (LHSTy->isDependentType() || RHSTy->isDependentType()) {
1795     BaseExpr = LHSExp;
1796     IndexExpr = RHSExp;
1797     ResultType = Context.DependentTy;
1798   } else if (const PointerType *PTy = LHSTy->getAsPointerType()) {
1799     BaseExpr = LHSExp;
1800     IndexExpr = RHSExp;
1801     ResultType = PTy->getPointeeType();
1802   } else if (const PointerType *PTy = RHSTy->getAsPointerType()) {
1803      // Handle the uncommon case of "123[Ptr]".
1804     BaseExpr = RHSExp;
1805     IndexExpr = LHSExp;
1806     ResultType = PTy->getPointeeType();
1807   } else if (const VectorType *VTy = LHSTy->getAsVectorType()) {
1808     BaseExpr = LHSExp;    // vectors: V[123]
1809     IndexExpr = RHSExp;
1810
1811     // FIXME: need to deal with const...
1812     ResultType = VTy->getElementType();
1813   } else if (LHSTy->isArrayType()) {
1814     // If we see an array that wasn't promoted by
1815     // DefaultFunctionArrayConversion, it must be an array that
1816     // wasn't promoted because of the C90 rule that doesn't
1817     // allow promoting non-lvalue arrays.  Warn, then
1818     // force the promotion here.
1819     Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
1820         LHSExp->getSourceRange();
1821     ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy));
1822     LHSTy = LHSExp->getType();
1823
1824     BaseExpr = LHSExp;
1825     IndexExpr = RHSExp;
1826     ResultType = LHSTy->getAsPointerType()->getPointeeType();
1827   } else if (RHSTy->isArrayType()) {
1828     // Same as previous, except for 123[f().a] case
1829     Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
1830         RHSExp->getSourceRange();
1831     ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy));
1832     RHSTy = RHSExp->getType();
1833
1834     BaseExpr = RHSExp;
1835     IndexExpr = LHSExp;
1836     ResultType = RHSTy->getAsPointerType()->getPointeeType();
1837   } else {
1838     return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value)
1839        << LHSExp->getSourceRange() << RHSExp->getSourceRange());
1840   }
1841   // C99 6.5.2.1p1
1842   if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent())
1843     return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer)
1844                      << IndexExpr->getSourceRange());
1845
1846   // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
1847   // C++ [expr.sub]p1: The type "T" shall be a completely-defined object
1848   // type. Note that Functions are not objects, and that (in C99 parlance)
1849   // incomplete types are not object types.
1850   if (ResultType->isFunctionType()) {
1851     Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type)
1852       << ResultType << BaseExpr->getSourceRange();
1853     return ExprError();
1854   }
1855
1856   if (!ResultType->isDependentType() &&
1857       RequireCompleteType(LLoc, ResultType, diag::err_subscript_incomplete_type,
1858                           BaseExpr->getSourceRange()))
1859     return ExprError();
1860
1861   // Diagnose bad cases where we step over interface counts.
1862   if (ResultType->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
1863     Diag(LLoc, diag::err_subscript_nonfragile_interface)
1864       << ResultType << BaseExpr->getSourceRange();
1865     return ExprError();
1866   }
1867
1868   Base.release();
1869   Idx.release();
1870   return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp,
1871                                                 ResultType, RLoc));
1872 }
1873
1874 QualType Sema::
1875 CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
1876                         IdentifierInfo &CompName, SourceLocation CompLoc) {
1877   const ExtVectorType *vecType = baseType->getAsExtVectorType();
1878
1879   // The vector accessor can't exceed the number of elements.
1880   const char *compStr = CompName.getName();
1881
1882   // This flag determines whether or not the component is one of the four
1883   // special names that indicate a subset of exactly half the elements are
1884   // to be selected.
1885   bool HalvingSwizzle = false;
1886
1887   // This flag determines whether or not CompName has an 's' char prefix,
1888   // indicating that it is a string of hex values to be used as vector indices.
1889   bool HexSwizzle = *compStr == 's';
1890
1891   // Check that we've found one of the special components, or that the component
1892   // names must come from the same set.
1893   if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
1894       !strcmp(compStr, "even") || !strcmp(compStr, "odd")) {
1895     HalvingSwizzle = true;
1896   } else if (vecType->getPointAccessorIdx(*compStr) != -1) {
1897     do
1898       compStr++;
1899     while (*compStr && vecType->getPointAccessorIdx(*compStr) != -1);
1900   } else if (HexSwizzle || vecType->getNumericAccessorIdx(*compStr) != -1) {
1901     do
1902       compStr++;
1903     while (*compStr && vecType->getNumericAccessorIdx(*compStr) != -1);
1904   }
1905
1906   if (!HalvingSwizzle && *compStr) {
1907     // We didn't get to the end of the string. This means the component names
1908     // didn't come from the same set *or* we encountered an illegal name.
1909     Diag(OpLoc, diag::err_ext_vector_component_name_illegal)
1910       << std::string(compStr,compStr+1) << SourceRange(CompLoc);
1911     return QualType();
1912   }
1913
1914   // Ensure no component accessor exceeds the width of the vector type it
1915   // operates on.
1916   if (!HalvingSwizzle) {
1917     compStr = CompName.getName();
1918
1919     if (HexSwizzle)
1920       compStr++;
1921
1922     while (*compStr) {
1923       if (!vecType->isAccessorWithinNumElements(*compStr++)) {
1924         Diag(OpLoc, diag::err_ext_vector_component_exceeds_length)
1925           << baseType << SourceRange(CompLoc);
1926         return QualType();
1927       }
1928     }
1929   }
1930
1931   // If this is a halving swizzle, verify that the base type has an even
1932   // number of elements.
1933   if (HalvingSwizzle && (vecType->getNumElements() & 1U)) {
1934     Diag(OpLoc, diag::err_ext_vector_component_requires_even)
1935       << baseType << SourceRange(CompLoc);
1936     return QualType();
1937   }
1938
1939   // The component accessor looks fine - now we need to compute the actual type.
1940   // The vector type is implied by the component accessor. For example,
1941   // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc.
1942   // vec4.s0 is a float, vec4.s23 is a vec3, etc.
1943   // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2.
1944   unsigned CompSize = HalvingSwizzle ? vecType->getNumElements() / 2
1945                                      : CompName.getLength();
1946   if (HexSwizzle)
1947     CompSize--;
1948
1949   if (CompSize == 1)
1950     return vecType->getElementType();
1951
1952   QualType VT = Context.getExtVectorType(vecType->getElementType(), CompSize);
1953   // Now look up the TypeDefDecl from the vector type. Without this,
1954   // diagostics look bad. We want extended vector types to appear built-in.
1955   for (unsigned i = 0, E = ExtVectorDecls.size(); i != E; ++i) {
1956     if (ExtVectorDecls[i]->getUnderlyingType() == VT)
1957       return Context.getTypedefType(ExtVectorDecls[i]);
1958   }
1959   return VT; // should never get here (a typedef type should always be found).
1960 }
1961
1962 static Decl *FindGetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl,
1963                                                 IdentifierInfo &Member,
1964                                                 const Selector &Sel,
1965                                                 ASTContext &Context) {
1966
1967   if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(Context, &Member))
1968     return PD;
1969   if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Context, Sel))
1970     return OMD;
1971
1972   for (ObjCProtocolDecl::protocol_iterator I = PDecl->protocol_begin(),
1973        E = PDecl->protocol_end(); I != E; ++I) {
1974     if (Decl *D = FindGetterNameDeclFromProtocolList(*I, Member, Sel,
1975                                                      Context))
1976       return D;
1977   }
1978   return 0;
1979 }
1980
1981 static Decl *FindGetterNameDecl(const ObjCObjectPointerType *QIdTy,
1982                                 IdentifierInfo &Member,
1983                                 const Selector &Sel,
1984                                 ASTContext &Context) {
1985   // Check protocols on qualified interfaces.
1986   Decl *GDecl = 0;
1987   for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
1988        E = QIdTy->qual_end(); I != E; ++I) {
1989     if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Context, &Member)) {
1990       GDecl = PD;
1991       break;
1992     }
1993     // Also must look for a getter name which uses property syntax.
1994     if (ObjCMethodDecl *OMD = (*I)->getInstanceMethod(Context, Sel)) {
1995       GDecl = OMD;
1996       break;
1997     }
1998   }
1999   if (!GDecl) {
2000     for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
2001          E = QIdTy->qual_end(); I != E; ++I) {
2002       // Search in the protocol-qualifier list of current protocol.
2003       GDecl = FindGetterNameDeclFromProtocolList(*I, Member, Sel, Context);
2004       if (GDecl)
2005         return GDecl;
2006     }
2007   }
2008   return GDecl;
2009 }
2010
2011 /// FindMethodInNestedImplementations - Look up a method in current and
2012 /// all base class implementations.
2013 ///
2014 ObjCMethodDecl *Sema::FindMethodInNestedImplementations(
2015                                               const ObjCInterfaceDecl *IFace,
2016                                               const Selector &Sel) {
2017   ObjCMethodDecl *Method = 0;
2018   if (ObjCImplementationDecl *ImpDecl
2019         = LookupObjCImplementation(IFace->getIdentifier()))
2020     Method = ImpDecl->getInstanceMethod(Context, Sel);
2021
2022   if (!Method && IFace->getSuperClass())
2023     return FindMethodInNestedImplementations(IFace->getSuperClass(), Sel);
2024   return Method;
2025 }
2026
2027 Action::OwningExprResult
2028 Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc,
2029                                tok::TokenKind OpKind, SourceLocation MemberLoc,
2030                                IdentifierInfo &Member,
2031                                DeclPtrTy ObjCImpDecl) {
2032   Expr *BaseExpr = Base.takeAs<Expr>();
2033   assert(BaseExpr && "no record expression");
2034
2035   // Perform default conversions.
2036   DefaultFunctionArrayConversion(BaseExpr);
2037
2038   QualType BaseType = BaseExpr->getType();
2039   assert(!BaseType.isNull() && "no type for member expression");
2040
2041   // Get the type being accessed in BaseType.  If this is an arrow, the BaseExpr
2042   // must have pointer type, and the accessed type is the pointee.
2043   if (OpKind == tok::arrow) {
2044     if (BaseType->isDependentType())
2045       return Owned(new (Context) CXXUnresolvedMemberExpr(Context,
2046                                                          BaseExpr, true,
2047                                                          OpLoc,
2048                                                      DeclarationName(&Member),
2049                                                          MemberLoc));
2050     else if (const PointerType *PT = BaseType->getAsPointerType())
2051       BaseType = PT->getPointeeType();
2052     else if (getLangOptions().CPlusPlus && BaseType->isRecordType())
2053       return Owned(BuildOverloadedArrowExpr(S, BaseExpr, OpLoc,
2054                                             MemberLoc, Member));
2055     else
2056       return ExprError(Diag(MemberLoc,
2057                             diag::err_typecheck_member_reference_arrow)
2058         << BaseType << BaseExpr->getSourceRange());
2059   } else {
2060     if (BaseType->isDependentType()) {
2061       // Require that the base type isn't a pointer type
2062       // (so we'll report an error for)
2063       // T* t;
2064       // t.f;
2065       //
2066       // In Obj-C++, however, the above expression is valid, since it could be
2067       // accessing the 'f' property if T is an Obj-C interface. The extra check
2068       // allows this, while still reporting an error if T is a struct pointer.
2069       const PointerType *PT = BaseType->getAsPointerType();
2070
2071       if (!PT || (getLangOptions().ObjC1 &&
2072                   !PT->getPointeeType()->isRecordType()))
2073         return Owned(new (Context) CXXUnresolvedMemberExpr(Context,
2074                                                            BaseExpr, false,
2075                                                            OpLoc,
2076                                                      DeclarationName(&Member),
2077                                                            MemberLoc));
2078     }
2079   }
2080
2081   // Handle field access to simple records.  This also handles access to fields
2082   // of the ObjC 'id' struct.
2083   if (const RecordType *RTy = BaseType->getAsRecordType()) {
2084     RecordDecl *RDecl = RTy->getDecl();
2085     if (RequireCompleteType(OpLoc, BaseType,
2086                                diag::err_typecheck_incomplete_tag,
2087                                BaseExpr->getSourceRange()))
2088       return ExprError();
2089
2090     // The record definition is complete, now make sure the member is valid.
2091     // FIXME: Qualified name lookup for C++ is a bit more complicated than this.
2092     LookupResult Result
2093       = LookupQualifiedName(RDecl, DeclarationName(&Member),
2094                             LookupMemberName, false);
2095
2096     if (!Result)
2097       return ExprError(Diag(MemberLoc, diag::err_typecheck_no_member)
2098                << &Member << BaseExpr->getSourceRange());
2099     if (Result.isAmbiguous()) {
2100       DiagnoseAmbiguousLookup(Result, DeclarationName(&Member),
2101                               MemberLoc, BaseExpr->getSourceRange());
2102       return ExprError();
2103     }
2104
2105     NamedDecl *MemberDecl = Result;
2106
2107     // If the decl being referenced had an error, return an error for this
2108     // sub-expr without emitting another error, in order to avoid cascading
2109     // error cases.
2110     if (MemberDecl->isInvalidDecl())
2111       return ExprError();
2112
2113     // Check the use of this field
2114     if (DiagnoseUseOfDecl(MemberDecl, MemberLoc))
2115       return ExprError();
2116
2117     if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
2118       // We may have found a field within an anonymous union or struct
2119       // (C++ [class.union]).
2120       if (cast<RecordDecl>(FD->getDeclContext())->isAnonymousStructOrUnion())
2121         return BuildAnonymousStructUnionMemberReference(MemberLoc, FD,
2122                                                         BaseExpr, OpLoc);
2123
2124       // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
2125       // FIXME: Handle address space modifiers
2126       QualType MemberType = FD->getType();
2127       if (const ReferenceType *Ref = MemberType->getAsReferenceType())
2128         MemberType = Ref->getPointeeType();
2129       else {
2130         unsigned combinedQualifiers =
2131           MemberType.getCVRQualifiers() | BaseType.getCVRQualifiers();
2132         if (FD->isMutable())
2133           combinedQualifiers &= ~QualType::Const;
2134         MemberType = MemberType.getQualifiedType(combinedQualifiers);
2135       }
2136
2137       return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow, FD,
2138                                             MemberLoc, MemberType));
2139     }
2140
2141     if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl))
2142       return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow,
2143                                             Var, MemberLoc,
2144                                          Var->getType().getNonReferenceType()));
2145     if (FunctionDecl *MemberFn = dyn_cast<FunctionDecl>(MemberDecl))
2146       return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow,
2147                                             MemberFn, MemberLoc,
2148                                             MemberFn->getType()));
2149     if (OverloadedFunctionDecl *Ovl
2150           = dyn_cast<OverloadedFunctionDecl>(MemberDecl))
2151       return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow, Ovl,
2152                                             MemberLoc, Context.OverloadTy));
2153     if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl))
2154       return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow,
2155                                             Enum, MemberLoc, Enum->getType()));
2156     if (isa<TypeDecl>(MemberDecl))
2157       return ExprError(Diag(MemberLoc,diag::err_typecheck_member_reference_type)
2158         << DeclarationName(&Member) << int(OpKind == tok::arrow));
2159
2160     // We found a declaration kind that we didn't expect. This is a
2161     // generic error message that tells the user that she can't refer
2162     // to this member with '.' or '->'.
2163     return ExprError(Diag(MemberLoc,
2164                           diag::err_typecheck_member_reference_unknown)
2165       << DeclarationName(&Member) << int(OpKind == tok::arrow));
2166   }
2167
2168   // Handle access to Objective-C instance variables, such as "Obj->ivar" and
2169   // (*Obj).ivar.
2170   if (const ObjCInterfaceType *IFTy = BaseType->getAsObjCInterfaceType()) {
2171     ObjCInterfaceDecl *ClassDeclared;
2172     if (ObjCIvarDecl *IV = IFTy->getDecl()->lookupInstanceVariable(Context,
2173                                                                    &Member,
2174                                                              ClassDeclared)) {
2175       // If the decl being referenced had an error, return an error for this
2176       // sub-expr without emitting another error, in order to avoid cascading
2177       // error cases.
2178       if (IV->isInvalidDecl())
2179         return ExprError();
2180
2181       // Check whether we can reference this field.
2182       if (DiagnoseUseOfDecl(IV, MemberLoc))
2183         return ExprError();
2184       if (IV->getAccessControl() != ObjCIvarDecl::Public &&
2185           IV->getAccessControl() != ObjCIvarDecl::Package) {
2186         ObjCInterfaceDecl *ClassOfMethodDecl = 0;
2187         if (ObjCMethodDecl *MD = getCurMethodDecl())
2188           ClassOfMethodDecl =  MD->getClassInterface();
2189         else if (ObjCImpDecl && getCurFunctionDecl()) {
2190           // Case of a c-function declared inside an objc implementation.
2191           // FIXME: For a c-style function nested inside an objc implementation
2192           // class, there is no implementation context available, so we pass
2193           // down the context as argument to this routine. Ideally, this context
2194           // need be passed down in the AST node and somehow calculated from the
2195           // AST for a function decl.
2196           Decl *ImplDecl = ObjCImpDecl.getAs<Decl>();
2197           if (ObjCImplementationDecl *IMPD =
2198               dyn_cast<ObjCImplementationDecl>(ImplDecl))
2199             ClassOfMethodDecl = IMPD->getClassInterface();
2200           else if (ObjCCategoryImplDecl* CatImplClass =
2201                       dyn_cast<ObjCCategoryImplDecl>(ImplDecl))
2202             ClassOfMethodDecl = CatImplClass->getClassInterface();
2203         }
2204
2205         if (IV->getAccessControl() == ObjCIvarDecl::Private) {
2206           if (ClassDeclared != IFTy->getDecl() ||
2207               ClassOfMethodDecl != ClassDeclared)
2208             Diag(MemberLoc, diag::error_private_ivar_access) << IV->getDeclName();
2209         }
2210         // @protected
2211         else if (!IFTy->getDecl()->isSuperClassOf(ClassOfMethodDecl))
2212           Diag(MemberLoc, diag::error_protected_ivar_access) << IV->getDeclName();
2213       }
2214
2215       return Owned(new (Context) ObjCIvarRefExpr(IV, IV->getType(),
2216                                                  MemberLoc, BaseExpr,
2217                                                  OpKind == tok::arrow));
2218     }
2219     return ExprError(Diag(MemberLoc, diag::err_typecheck_member_reference_ivar)
2220                        << IFTy->getDecl()->getDeclName() << &Member
2221                        << BaseExpr->getSourceRange());
2222   }
2223
2224   // Handle Objective-C property access, which is "Obj.property" where Obj is a
2225   // pointer to a (potentially qualified) interface type.
2226   const PointerType *PTy;
2227   const ObjCInterfaceType *IFTy;
2228   if (OpKind == tok::period && (PTy = BaseType->getAsPointerType()) &&
2229       (IFTy = PTy->getPointeeType()->getAsObjCInterfaceType())) {
2230     ObjCInterfaceDecl *IFace = IFTy->getDecl();
2231
2232     // Search for a declared property first.
2233     if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(Context,
2234                                                               &Member)) {
2235       // Check whether we can reference this property.
2236       if (DiagnoseUseOfDecl(PD, MemberLoc))
2237         return ExprError();
2238       QualType ResTy = PD->getType();
2239       Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
2240       ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Context, Sel);
2241       if (DiagnosePropertyAccessorMismatch(PD, Getter, MemberLoc))
2242         ResTy = Getter->getResultType();
2243       return Owned(new (Context) ObjCPropertyRefExpr(PD, ResTy,
2244                                                      MemberLoc, BaseExpr));
2245     }
2246
2247     // Check protocols on qualified interfaces.
2248     for (ObjCInterfaceType::qual_iterator I = IFTy->qual_begin(),
2249          E = IFTy->qual_end(); I != E; ++I)
2250       if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Context,
2251                                                                &Member)) {
2252         // Check whether we can reference this property.
2253         if (DiagnoseUseOfDecl(PD, MemberLoc))
2254           return ExprError();
2255
2256         return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(),
2257                                                        MemberLoc, BaseExpr));
2258       }
2259
2260     // If that failed, look for an "implicit" property by seeing if the nullary
2261     // selector is implemented.
2262
2263     // FIXME: The logic for looking up nullary and unary selectors should be
2264     // shared with the code in ActOnInstanceMessage.
2265
2266     Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
2267     ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Context, Sel);
2268
2269     // If this reference is in an @implementation, check for 'private' methods.
2270     if (!Getter)
2271       Getter = FindMethodInNestedImplementations(IFace, Sel);
2272
2273     // Look through local category implementations associated with the class.
2274     if (!Getter) {
2275       for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Getter; i++) {
2276         if (ObjCCategoryImpls[i]->getClassInterface() == IFace)
2277           Getter = ObjCCategoryImpls[i]->getInstanceMethod(Context, Sel);
2278       }
2279     }
2280     if (Getter) {
2281       // Check if we can reference this property.
2282       if (DiagnoseUseOfDecl(Getter, MemberLoc))
2283         return ExprError();
2284     }
2285     // If we found a getter then this may be a valid dot-reference, we
2286     // will look for the matching setter, in case it is needed.
2287     Selector SetterSel =
2288       SelectorTable::constructSetterName(PP.getIdentifierTable(),
2289                                          PP.getSelectorTable(), &Member);
2290     ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(Context, SetterSel);
2291     if (!Setter) {
2292       // If this reference is in an @implementation, also check for 'private'
2293       // methods.
2294       Setter = FindMethodInNestedImplementations(IFace, SetterSel);
2295     }
2296     // Look through local category implementations associated with the class.
2297     if (!Setter) {
2298       for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Setter; i++) {
2299         if (ObjCCategoryImpls[i]->getClassInterface() == IFace)
2300           Setter = ObjCCategoryImpls[i]->getInstanceMethod(Context, SetterSel);
2301       }
2302     }
2303
2304     if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
2305       return ExprError();
2306
2307     if (Getter || Setter) {
2308       QualType PType;
2309
2310       if (Getter)
2311         PType = Getter->getResultType();
2312       else {
2313         for (ObjCMethodDecl::param_iterator PI = Setter->param_begin(),
2314              E = Setter->param_end(); PI != E; ++PI)
2315           PType = (*PI)->getType();
2316       }
2317       // FIXME: we must check that the setter has property type.
2318       return Owned(new (Context) ObjCKVCRefExpr(Getter, PType,
2319                                       Setter, MemberLoc, BaseExpr));
2320     }
2321     return ExprError(Diag(MemberLoc, diag::err_property_not_found)
2322       << &Member << BaseType);
2323   }
2324   // Handle properties on qualified "id" protocols.
2325   const ObjCObjectPointerType *QIdTy;
2326   if (OpKind == tok::period && (QIdTy = BaseType->getAsObjCQualifiedIdType())) {
2327     // Check protocols on qualified interfaces.
2328     Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
2329     if (Decl *PMDecl = FindGetterNameDecl(QIdTy, Member, Sel, Context)) {
2330       if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
2331         // Check the use of this declaration
2332         if (DiagnoseUseOfDecl(PD, MemberLoc))
2333           return ExprError();
2334
2335         return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(),
2336                                                        MemberLoc, BaseExpr));
2337       }
2338       if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) {
2339         // Check the use of this method.
2340         if (DiagnoseUseOfDecl(OMD, MemberLoc))
2341           return ExprError();
2342
2343         return Owned(new (Context) ObjCMessageExpr(BaseExpr, Sel,
2344                                                    OMD->getResultType(),
2345                                                    OMD, OpLoc, MemberLoc,
2346                                                    NULL, 0));
2347       }
2348     }
2349
2350     return ExprError(Diag(MemberLoc, diag::err_property_not_found)
2351                        << &Member << BaseType);
2352   }
2353   // Handle properties on ObjC 'Class' types.
2354   if (OpKind == tok::period && (BaseType == Context.getObjCClassType())) {
2355     // Also must look for a getter name which uses property syntax.
2356     Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
2357     if (ObjCMethodDecl *MD = getCurMethodDecl()) {
2358       ObjCInterfaceDecl *IFace = MD->getClassInterface();
2359       ObjCMethodDecl *Getter;
2360       // FIXME: need to also look locally in the implementation.
2361       if ((Getter = IFace->lookupClassMethod(Context, Sel))) {
2362         // Check the use of this method.
2363         if (DiagnoseUseOfDecl(Getter, MemberLoc))
2364           return ExprError();
2365       }
2366       // If we found a getter then this may be a valid dot-reference, we
2367       // will look for the matching setter, in case it is needed.
2368       Selector SetterSel =
2369         SelectorTable::constructSetterName(PP.getIdentifierTable(),
2370                                            PP.getSelectorTable(), &Member);
2371       ObjCMethodDecl *Setter = IFace->lookupClassMethod(Context, SetterSel);
2372       if (!Setter) {
2373         // If this reference is in an @implementation, also check for 'private'
2374         // methods.
2375         Setter = FindMethodInNestedImplementations(IFace, SetterSel);
2376       }
2377       // Look through local category implementations associated with the class.
2378       if (!Setter) {
2379         for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Setter; i++) {
2380           if (ObjCCategoryImpls[i]->getClassInterface() == IFace)
2381             Setter = ObjCCategoryImpls[i]->getClassMethod(Context, SetterSel);
2382         }
2383       }
2384
2385       if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
2386         return ExprError();
2387
2388       if (Getter || Setter) {
2389         QualType PType;
2390
2391         if (Getter)
2392           PType = Getter->getResultType();
2393         else {
2394           for (ObjCMethodDecl::param_iterator PI = Setter->param_begin(),
2395                E = Setter->param_end(); PI != E; ++PI)
2396             PType = (*PI)->getType();
2397         }
2398         // FIXME: we must check that the setter has property type.
2399         return Owned(new (Context) ObjCKVCRefExpr(Getter, PType,
2400                                         Setter, MemberLoc, BaseExpr));
2401       }
2402       return ExprError(Diag(MemberLoc, diag::err_property_not_found)
2403         << &Member << BaseType);
2404     }
2405   }
2406
2407   // Handle 'field access' to vectors, such as 'V.xx'.
2408   if (BaseType->isExtVectorType()) {
2409     QualType ret = CheckExtVectorComponent(BaseType, OpLoc, Member, MemberLoc);
2410     if (ret.isNull())
2411       return ExprError();
2412     return Owned(new (Context) ExtVectorElementExpr(ret, BaseExpr, Member,
2413                                                     MemberLoc));
2414   }
2415
2416   Diag(MemberLoc, diag::err_typecheck_member_reference_struct_union)
2417     << BaseType << BaseExpr->getSourceRange();
2418
2419   // If the user is trying to apply -> or . to a function or function
2420   // pointer, it's probably because they forgot parentheses to call
2421   // the function. Suggest the addition of those parentheses.
2422   if (BaseType == Context.OverloadTy ||
2423       BaseType->isFunctionType() ||
2424       (BaseType->isPointerType() &&
2425        BaseType->getAsPointerType()->isFunctionType())) {
2426     SourceLocation Loc = PP.getLocForEndOfToken(BaseExpr->getLocEnd());
2427     Diag(Loc, diag::note_member_reference_needs_call)
2428       << CodeModificationHint::CreateInsertion(Loc, "()");
2429   }
2430
2431   return ExprError();
2432 }
2433
2434 /// ConvertArgumentsForCall - Converts the arguments specified in
2435 /// Args/NumArgs to the parameter types of the function FDecl with
2436 /// function prototype Proto. Call is the call expression itself, and
2437 /// Fn is the function expression. For a C++ member function, this
2438 /// routine does not attempt to convert the object argument. Returns
2439 /// true if the call is ill-formed.
2440 bool
2441 Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
2442                               FunctionDecl *FDecl,
2443                               const FunctionProtoType *Proto,
2444                               Expr **Args, unsigned NumArgs,
2445                               SourceLocation RParenLoc) {
2446   // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
2447   // assignment, to the types of the corresponding parameter, ...
2448   unsigned NumArgsInProto = Proto->getNumArgs();
2449   unsigned NumArgsToCheck = NumArgs;
2450   bool Invalid = false;
2451
2452   // If too few arguments are available (and we don't have default
2453   // arguments for the remaining parameters), don't make the call.
2454   if (NumArgs < NumArgsInProto) {
2455     if (!FDecl || NumArgs < FDecl->getMinRequiredArguments())
2456       return Diag(RParenLoc, diag::err_typecheck_call_too_few_args)
2457         << Fn->getType()->isBlockPointerType() << Fn->getSourceRange();
2458     // Use default arguments for missing arguments
2459     NumArgsToCheck = NumArgsInProto;
2460     Call->setNumArgs(Context, NumArgsInProto);
2461   }
2462
2463   // If too many are passed and not variadic, error on the extras and drop
2464   // them.
2465   if (NumArgs > NumArgsInProto) {
2466     if (!Proto->isVariadic()) {
2467       Diag(Args[NumArgsInProto]->getLocStart(),
2468            diag::err_typecheck_call_too_many_args)
2469         << Fn->getType()->isBlockPointerType() << Fn->getSourceRange()
2470         << SourceRange(Args[NumArgsInProto]->getLocStart(),
2471                        Args[NumArgs-1]->getLocEnd());
2472       // This deletes the extra arguments.
2473       Call->setNumArgs(Context, NumArgsInProto);
2474       Invalid = true;
2475     }
2476     NumArgsToCheck = NumArgsInProto;
2477   }
2478
2479   // Continue to check argument types (even if we have too few/many args).
2480   for (unsigned i = 0; i != NumArgsToCheck; i++) {
2481     QualType ProtoArgType = Proto->getArgType(i);
2482
2483     Expr *Arg;
2484     if (i < NumArgs) {
2485       Arg = Args[i];
2486
2487       if (RequireCompleteType(Arg->getSourceRange().getBegin(),
2488                               ProtoArgType,
2489                               diag::err_call_incomplete_argument,
2490                               Arg->getSourceRange()))
2491         return true;
2492
2493       // Pass the argument.
2494       if (PerformCopyInitialization(Arg, ProtoArgType, "passing"))
2495         return true;
2496     } else {
2497       if (FDecl->getParamDecl(i)->hasUnparsedDefaultArg()) {
2498         Diag (Call->getSourceRange().getBegin(),
2499               diag::err_use_of_default_argument_to_function_declared_later) <<
2500         FDecl << cast<CXXRecordDecl>(FDecl->getDeclContext())->getDeclName();
2501         Diag(UnparsedDefaultArgLocs[FDecl->getParamDecl(i)],
2502               diag::note_default_argument_declared_here);
2503       } else {
2504         Expr *DefaultExpr = FDecl->getParamDecl(i)->getDefaultArg();
2505
2506         // If the default expression creates temporaries, we need to
2507         // push them to the current stack of expression temporaries so they'll
2508         // be properly destroyed.
2509         if (CXXExprWithTemporaries *E
2510               = dyn_cast_or_null<CXXExprWithTemporaries>(DefaultExpr)) {
2511           assert(!E->shouldDestroyTemporaries() &&
2512                  "Can't destroy temporaries in a default argument expr!");
2513           for (unsigned I = 0, N = E->getNumTemporaries(); I != N; ++I)
2514             ExprTemporaries.push_back(E->getTemporary(I));
2515         }
2516       }
2517
2518       // We already type-checked the argument, so we know it works.
2519       Arg = new (Context) CXXDefaultArgExpr(FDecl->getParamDecl(i));
2520     }
2521
2522     QualType ArgType = Arg->getType();
2523
2524     Call->setArg(i, Arg);
2525   }
2526
2527   // If this is a variadic call, handle args passed through "...".
2528   if (Proto->isVariadic()) {
2529     VariadicCallType CallType = VariadicFunction;
2530     if (Fn->getType()->isBlockPointerType())
2531       CallType = VariadicBlock; // Block
2532     else if (isa<MemberExpr>(Fn))
2533       CallType = VariadicMethod;
2534
2535     // Promote the arguments (C99 6.5.2.2p7).
2536     for (unsigned i = NumArgsInProto; i != NumArgs; i++) {
2537       Expr *Arg = Args[i];
2538       Invalid |= DefaultVariadicArgumentPromotion(Arg, CallType);
2539       Call->setArg(i, Arg);
2540     }
2541   }
2542
2543   return Invalid;
2544 }
2545
2546 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
2547 /// This provides the location of the left/right parens and a list of comma
2548 /// locations.
2549 Action::OwningExprResult
2550 Sema::ActOnCallExpr(Scope *S, ExprArg fn, SourceLocation LParenLoc,
2551                     MultiExprArg args,
2552                     SourceLocation *CommaLocs, SourceLocation RParenLoc) {
2553   unsigned NumArgs = args.size();
2554   Expr *Fn = fn.takeAs<Expr>();
2555   Expr **Args = reinterpret_cast<Expr**>(args.release());
2556   assert(Fn && "no function call expression");
2557   FunctionDecl *FDecl = NULL;
2558   NamedDecl *NDecl = NULL;
2559   DeclarationName UnqualifiedName;
2560
2561   if (getLangOptions().CPlusPlus) {
2562     // Determine whether this is a dependent call inside a C++ template,
2563     // in which case we won't do any semantic analysis now.
2564     // FIXME: Will need to cache the results of name lookup (including ADL) in
2565     // Fn.
2566     bool Dependent = false;
2567     if (Fn->isTypeDependent())
2568       Dependent = true;
2569     else if (Expr::hasAnyTypeDependentArguments(Args, NumArgs))
2570       Dependent = true;
2571
2572     if (Dependent)
2573       return Owned(new (Context) CallExpr(Context, Fn, Args, NumArgs,
2574                                           Context.DependentTy, RParenLoc));
2575
2576     // Determine whether this is a call to an object (C++ [over.call.object]).
2577     if (Fn->getType()->isRecordType())
2578       return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc, Args, NumArgs,
2579                                                 CommaLocs, RParenLoc));
2580
2581     // Determine whether this is a call to a member function.
2582     if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(Fn->IgnoreParens()))
2583       if (isa<OverloadedFunctionDecl>(MemExpr->getMemberDecl()) ||
2584           isa<CXXMethodDecl>(MemExpr->getMemberDecl()))
2585         return Owned(BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs,
2586                                                CommaLocs, RParenLoc));
2587   }
2588
2589   // If we're directly calling a function, get the appropriate declaration.
2590   DeclRefExpr *DRExpr = NULL;
2591   Expr *FnExpr = Fn;
2592   bool ADL = true;
2593   while (true) {
2594     if (ImplicitCastExpr *IcExpr = dyn_cast<ImplicitCastExpr>(FnExpr))
2595       FnExpr = IcExpr->getSubExpr();
2596     else if (ParenExpr *PExpr = dyn_cast<ParenExpr>(FnExpr)) {
2597       // Parentheses around a function disable ADL
2598       // (C++0x [basic.lookup.argdep]p1).
2599       ADL = false;
2600       FnExpr = PExpr->getSubExpr();
2601     } else if (isa<UnaryOperator>(FnExpr) &&
2602                cast<UnaryOperator>(FnExpr)->getOpcode()
2603                  == UnaryOperator::AddrOf) {
2604       FnExpr = cast<UnaryOperator>(FnExpr)->getSubExpr();
2605     } else if ((DRExpr = dyn_cast<DeclRefExpr>(FnExpr))) {
2606       // Qualified names disable ADL (C++0x [basic.lookup.argdep]p1).
2607       ADL &= !isa<QualifiedDeclRefExpr>(DRExpr);
2608       break;
2609     } else if (UnresolvedFunctionNameExpr *DepName
2610                  = dyn_cast<UnresolvedFunctionNameExpr>(FnExpr)) {
2611       UnqualifiedName = DepName->getName();
2612       break;
2613     } else {
2614       // Any kind of name that does not refer to a declaration (or
2615       // set of declarations) disables ADL (C++0x [basic.lookup.argdep]p3).
2616       ADL = false;
2617       break;
2618     }
2619   }
2620
2621   OverloadedFunctionDecl *Ovl = 0;
2622   if (DRExpr) {
2623     FDecl = dyn_cast<FunctionDecl>(DRExpr->getDecl());
2624     Ovl = dyn_cast<OverloadedFunctionDecl>(DRExpr->getDecl());
2625     NDecl = dyn_cast<NamedDecl>(DRExpr->getDecl());
2626   }
2627
2628   if (Ovl || (getLangOptions().CPlusPlus && (FDecl || UnqualifiedName))) {
2629     // We don't perform ADL for implicit declarations of builtins.
2630     if (FDecl && FDecl->getBuiltinID(Context) && FDecl->isImplicit())
2631       ADL = false;
2632
2633     // We don't perform ADL in C.
2634     if (!getLangOptions().CPlusPlus)
2635       ADL = false;
2636
2637     if (Ovl || ADL) {
2638       FDecl = ResolveOverloadedCallFn(Fn, DRExpr? DRExpr->getDecl() : 0,
2639                                       UnqualifiedName, LParenLoc, Args,
2640                                       NumArgs, CommaLocs, RParenLoc, ADL);
2641       if (!FDecl)
2642         return ExprError();
2643
2644       // Update Fn to refer to the actual function selected.
2645       Expr *NewFn = 0;
2646       if (QualifiedDeclRefExpr *QDRExpr
2647             = dyn_cast_or_null<QualifiedDeclRefExpr>(DRExpr))
2648         NewFn = new (Context) QualifiedDeclRefExpr(FDecl, FDecl->getType(),
2649                                                    QDRExpr->getLocation(),
2650                                                    false, false,
2651                                                  QDRExpr->getQualifierRange(),
2652                                                    QDRExpr->getQualifier());
2653       else
2654         NewFn = new (Context) DeclRefExpr(FDecl, FDecl->getType(),
2655                                           Fn->getSourceRange().getBegin());
2656       Fn->Destroy(Context);
2657       Fn = NewFn;
2658     }
2659   }
2660
2661   // Promote the function operand.
2662   UsualUnaryConversions(Fn);
2663
2664   // Make the call expr early, before semantic checks.  This guarantees cleanup
2665   // of arguments and function on error.
2666   ExprOwningPtr<CallExpr> TheCall(this, new (Context) CallExpr(Context, Fn,
2667                                                                Args, NumArgs,
2668                                                                Context.BoolTy,
2669                                                                RParenLoc));
2670
2671   const FunctionType *FuncT;
2672   if (!Fn->getType()->isBlockPointerType()) {
2673     // C99 6.5.2.2p1 - "The expression that denotes the called function shall
2674     // have type pointer to function".
2675     const PointerType *PT = Fn->getType()->getAsPointerType();
2676     if (PT == 0)
2677       return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
2678         << Fn->getType() << Fn->getSourceRange());
2679     FuncT = PT->getPointeeType()->getAsFunctionType();
2680   } else { // This is a block call.
2681     FuncT = Fn->getType()->getAsBlockPointerType()->getPointeeType()->
2682                 getAsFunctionType();
2683   }
2684   if (FuncT == 0)
2685     return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
2686       << Fn->getType() << Fn->getSourceRange());
2687
2688   // Check for a valid return type
2689   if (!FuncT->getResultType()->isVoidType() &&
2690       RequireCompleteType(Fn->getSourceRange().getBegin(),
2691                           FuncT->getResultType(),
2692                           diag::err_call_incomplete_return,
2693                           TheCall->getSourceRange()))
2694     return ExprError();
2695
2696   // We know the result type of the call, set it.
2697   TheCall->setType(FuncT->getResultType().getNonReferenceType());
2698
2699   if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) {
2700     if (ConvertArgumentsForCall(&*TheCall, Fn, FDecl, Proto, Args, NumArgs,
2701                                 RParenLoc))
2702       return ExprError();
2703   } else {
2704     assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!");
2705
2706     if (FDecl) {
2707       // Check if we have too few/too many template arguments, based
2708       // on our knowledge of the function definition.
2709       const FunctionDecl *Def = 0;
2710       if (FDecl->getBody(Context, Def) && NumArgs != Def->param_size()) {
2711         const FunctionProtoType *Proto =
2712             Def->getType()->getAsFunctionProtoType();
2713         if (!Proto || !(Proto->isVariadic() && NumArgs >= Def->param_size())) {
2714           Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
2715             << (NumArgs > Def->param_size()) << FDecl << Fn->getSourceRange();
2716         }
2717       }
2718     }
2719
2720     // Promote the arguments (C99 6.5.2.2p6).
2721     for (unsigned i = 0; i != NumArgs; i++) {
2722       Expr *Arg = Args[i];
2723       DefaultArgumentPromotion(Arg);
2724       if (RequireCompleteType(Arg->getSourceRange().getBegin(),
2725                               Arg->getType(),
2726                               diag::err_call_incomplete_argument,
2727                               Arg->getSourceRange()))
2728         return ExprError();
2729       TheCall->setArg(i, Arg);
2730     }
2731   }
2732
2733   if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
2734     if (!Method->isStatic())
2735       return ExprError(Diag(LParenLoc, diag::err_member_call_without_object)
2736         << Fn->getSourceRange());
2737
2738   // Check for sentinels
2739   if (NDecl)
2740     DiagnoseSentinelCalls(NDecl, LParenLoc, Args, NumArgs);
2741   // Do special checking on direct calls to functions.
2742   if (FDecl)
2743     return CheckFunctionCall(FDecl, TheCall.take());
2744   if (NDecl)
2745     return CheckBlockCall(NDecl, TheCall.take());
2746
2747   return Owned(TheCall.take());
2748 }
2749
2750 Action::OwningExprResult
2751 Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, TypeTy *Ty,
2752                            SourceLocation RParenLoc, ExprArg InitExpr) {
2753   assert((Ty != 0) && "ActOnCompoundLiteral(): missing type");
2754   QualType literalType = QualType::getFromOpaquePtr(Ty);
2755   // FIXME: put back this assert when initializers are worked out.
2756   //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression");
2757   Expr *literalExpr = static_cast<Expr*>(InitExpr.get());
2758
2759   if (literalType->isArrayType()) {
2760     if (literalType->isVariableArrayType())
2761       return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init)
2762         << SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd()));
2763   } else if (!literalType->isDependentType() &&
2764              RequireCompleteType(LParenLoc, literalType,
2765                                  diag::err_typecheck_decl_incomplete_type,
2766                 SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd())))
2767     return ExprError();
2768
2769   if (CheckInitializerTypes(literalExpr, literalType, LParenLoc,
2770                             DeclarationName(), /*FIXME:DirectInit=*/false))
2771     return ExprError();
2772
2773   bool isFileScope = getCurFunctionOrMethodDecl() == 0;
2774   if (isFileScope) { // 6.5.2.5p3
2775     if (CheckForConstantInitializer(literalExpr, literalType))
2776       return ExprError();
2777   }
2778   InitExpr.release();
2779   return Owned(new (Context) CompoundLiteralExpr(LParenLoc, literalType,
2780                                                  literalExpr, isFileScope));
2781 }
2782
2783 Action::OwningExprResult
2784 Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg initlist,
2785                     SourceLocation RBraceLoc) {
2786   unsigned NumInit = initlist.size();
2787   Expr **InitList = reinterpret_cast<Expr**>(initlist.release());
2788
2789   // Semantic analysis for initializers is done by ActOnDeclarator() and
2790   // CheckInitializer() - it requires knowledge of the object being intialized.
2791
2792   InitListExpr *E = new (Context) InitListExpr(LBraceLoc, InitList, NumInit,
2793                                                RBraceLoc);
2794   E->setType(Context.VoidTy); // FIXME: just a place holder for now.
2795   return Owned(E);
2796 }
2797
2798 /// CheckCastTypes - Check type constraints for casting between types.
2799 bool Sema::CheckCastTypes(SourceRange TyR, QualType castType, Expr *&castExpr) {
2800   UsualUnaryConversions(castExpr);
2801
2802   // C99 6.5.4p2: the cast type needs to be void or scalar and the expression
2803   // type needs to be scalar.
2804   if (castType->isVoidType()) {
2805     // Cast to void allows any expr type.
2806   } else if (castType->isDependentType() || castExpr->isTypeDependent()) {
2807     // We can't check any more until template instantiation time.
2808   } else if (!castType->isScalarType() && !castType->isVectorType()) {
2809     if (Context.getCanonicalType(castType).getUnqualifiedType() ==
2810         Context.getCanonicalType(castExpr->getType().getUnqualifiedType()) &&
2811         (castType->isStructureType() || castType->isUnionType())) {
2812       // GCC struct/union extension: allow cast to self.
2813       // FIXME: Check that the cast destination type is complete.
2814       Diag(TyR.getBegin(), diag::ext_typecheck_cast_nonscalar)
2815         << castType << castExpr->getSourceRange();
2816     } else if (castType->isUnionType()) {
2817       // GCC cast to union extension
2818       RecordDecl *RD = castType->getAsRecordType()->getDecl();
2819       RecordDecl::field_iterator Field, FieldEnd;
2820       for (Field = RD->field_begin(Context), FieldEnd = RD->field_end(Context);
2821            Field != FieldEnd; ++Field) {
2822         if (Context.getCanonicalType(Field->getType()).getUnqualifiedType() ==
2823             Context.getCanonicalType(castExpr->getType()).getUnqualifiedType()) {
2824           Diag(TyR.getBegin(), diag::ext_typecheck_cast_to_union)
2825             << castExpr->getSourceRange();
2826           break;
2827         }
2828       }
2829       if (Field == FieldEnd)
2830         return Diag(TyR.getBegin(), diag::err_typecheck_cast_to_union_no_type)
2831           << castExpr->getType() << castExpr->getSourceRange();
2832     } else {
2833       // Reject any other conversions to non-scalar types.
2834       return Diag(TyR.getBegin(), diag::err_typecheck_cond_expect_scalar)
2835         << castType << castExpr->getSourceRange();
2836     }
2837   } else if (!castExpr->getType()->isScalarType() &&
2838              !castExpr->getType()->isVectorType()) {
2839     return Diag(castExpr->getLocStart(),
2840                 diag::err_typecheck_expect_scalar_operand)
2841       << castExpr->getType() << castExpr->getSourceRange();
2842   } else if (castExpr->getType()->isVectorType()) {
2843     if (CheckVectorCast(TyR, castExpr->getType(), castType))
2844       return true;
2845   } else if (castType->isVectorType()) {
2846     if (CheckVectorCast(TyR, castType, castExpr->getType()))
2847       return true;
2848   } else if (getLangOptions().ObjC1 && isa<ObjCSuperExpr>(castExpr)) {
2849     return Diag(castExpr->getLocStart(), diag::err_illegal_super_cast) << TyR;
2850   } else if (!castType->isArithmeticType()) {
2851     QualType castExprType = castExpr->getType();
2852     if (!castExprType->isIntegralType() && castExprType->isArithmeticType())
2853       return Diag(castExpr->getLocStart(),
2854                   diag::err_cast_pointer_from_non_pointer_int)
2855         << castExprType << castExpr->getSourceRange();
2856   } else if (!castExpr->getType()->isArithmeticType()) {
2857     if (!castType->isIntegralType() && castType->isArithmeticType())
2858       return Diag(castExpr->getLocStart(),
2859                   diag::err_cast_pointer_to_non_pointer_int)
2860         << castType << castExpr->getSourceRange();
2861   }
2862   if (isa<ObjCSelectorExpr>(castExpr))
2863     return Diag(castExpr->getLocStart(), diag::err_cast_selector_expr);
2864   return false;
2865 }
2866
2867 bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty) {
2868   assert(VectorTy->isVectorType() && "Not a vector type!");
2869
2870   if (Ty->isVectorType() || Ty->isIntegerType()) {
2871     if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty))
2872       return Diag(R.getBegin(),
2873                   Ty->isVectorType() ?
2874                   diag::err_invalid_conversion_between_vectors :
2875                   diag::err_invalid_conversion_between_vector_and_integer)
2876         << VectorTy << Ty << R;
2877   } else
2878     return Diag(R.getBegin(),
2879                 diag::err_invalid_conversion_between_vector_and_scalar)
2880       << VectorTy << Ty << R;
2881
2882   return false;
2883 }
2884
2885 Action::OwningExprResult
2886 Sema::ActOnCastExpr(SourceLocation LParenLoc, TypeTy *Ty,
2887                     SourceLocation RParenLoc, ExprArg Op) {
2888   assert((Ty != 0) && (Op.get() != 0) &&
2889          "ActOnCastExpr(): missing type or expr");
2890
2891   Expr *castExpr = Op.takeAs<Expr>();
2892   QualType castType = QualType::getFromOpaquePtr(Ty);
2893
2894   if (CheckCastTypes(SourceRange(LParenLoc, RParenLoc), castType, castExpr))
2895     return ExprError();
2896   return Owned(new (Context) CStyleCastExpr(castType, castExpr, castType,
2897                                             LParenLoc, RParenLoc));
2898 }
2899
2900 /// Note that lhs is not null here, even if this is the gnu "x ?: y" extension.
2901 /// In that case, lhs = cond.
2902 /// C99 6.5.15
2903 QualType Sema::CheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS,
2904                                         SourceLocation QuestionLoc) {
2905   // C++ is sufficiently different to merit its own checker.
2906   if (getLangOptions().CPlusPlus)
2907     return CXXCheckConditionalOperands(Cond, LHS, RHS, QuestionLoc);
2908
2909   UsualUnaryConversions(Cond);
2910   UsualUnaryConversions(LHS);
2911   UsualUnaryConversions(RHS);
2912   QualType CondTy = Cond->getType();
2913   QualType LHSTy = LHS->getType();
2914   QualType RHSTy = RHS->getType();
2915
2916   // first, check the condition.
2917   if (!CondTy->isScalarType()) { // C99 6.5.15p2
2918     Diag(Cond->getLocStart(), diag::err_typecheck_cond_expect_scalar)
2919       << CondTy;
2920     return QualType();
2921   }
2922
2923   // Now check the two expressions.
2924
2925   // If both operands have arithmetic type, do the usual arithmetic conversions
2926   // to find a common type: C99 6.5.15p3,5.
2927   if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
2928     UsualArithmeticConversions(LHS, RHS);
2929     return LHS->getType();
2930   }
2931
2932   // If both operands are the same structure or union type, the result is that
2933   // type.
2934   if (const RecordType *LHSRT = LHSTy->getAsRecordType()) {    // C99 6.5.15p3
2935     if (const RecordType *RHSRT = RHSTy->getAsRecordType())
2936       if (LHSRT->getDecl() == RHSRT->getDecl())
2937         // "If both the operands have structure or union type, the result has
2938         // that type."  This implies that CV qualifiers are dropped.
2939         return LHSTy.getUnqualifiedType();
2940     // FIXME: Type of conditional expression must be complete in C mode.
2941   }
2942
2943   // C99 6.5.15p5: "If both operands have void type, the result has void type."
2944   // The following || allows only one side to be void (a GCC-ism).
2945   if (LHSTy->isVoidType() || RHSTy->isVoidType()) {
2946     if (!LHSTy->isVoidType())
2947       Diag(RHS->getLocStart(), diag::ext_typecheck_cond_one_void)
2948         << RHS->getSourceRange();
2949     if (!RHSTy->isVoidType())
2950       Diag(LHS->getLocStart(), diag::ext_typecheck_cond_one_void)
2951         << LHS->getSourceRange();
2952     ImpCastExprToType(LHS, Context.VoidTy);
2953     ImpCastExprToType(RHS, Context.VoidTy);
2954     return Context.VoidTy;
2955   }
2956   // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
2957   // the type of the other operand."
2958   if ((LHSTy->isPointerType() || LHSTy->isBlockPointerType() ||
2959        Context.isObjCObjectPointerType(LHSTy)) &&
2960       RHS->isNullPointerConstant(Context)) {
2961     ImpCastExprToType(RHS, LHSTy); // promote the null to a pointer.
2962     return LHSTy;
2963   }
2964   if ((RHSTy->isPointerType() || RHSTy->isBlockPointerType() ||
2965        Context.isObjCObjectPointerType(RHSTy)) &&
2966       LHS->isNullPointerConstant(Context)) {
2967     ImpCastExprToType(LHS, RHSTy); // promote the null to a pointer.
2968     return RHSTy;
2969   }
2970
2971   const PointerType *LHSPT = LHSTy->getAsPointerType();
2972   const PointerType *RHSPT = RHSTy->getAsPointerType();
2973   const BlockPointerType *LHSBPT = LHSTy->getAsBlockPointerType();
2974   const BlockPointerType *RHSBPT = RHSTy->getAsBlockPointerType();
2975
2976   // Handle the case where both operands are pointers before we handle null
2977   // pointer constants in case both operands are null pointer constants.
2978   if ((LHSPT || LHSBPT) && (RHSPT || RHSBPT)) { // C99 6.5.15p3,6
2979     // get the "pointed to" types
2980     QualType lhptee = (LHSPT ? LHSPT->getPointeeType()
2981                        : LHSBPT->getPointeeType());
2982       QualType rhptee = (RHSPT ? RHSPT->getPointeeType()
2983                          : RHSBPT->getPointeeType());
2984
2985     // ignore qualifiers on void (C99 6.5.15p3, clause 6)
2986     if (lhptee->isVoidType()
2987         && (RHSBPT || rhptee->isIncompleteOrObjectType())) {
2988       // Figure out necessary qualifiers (C99 6.5.15p6)
2989       QualType destPointee=lhptee.getQualifiedType(rhptee.getCVRQualifiers());
2990       QualType destType = Context.getPointerType(destPointee);
2991       ImpCastExprToType(LHS, destType); // add qualifiers if necessary
2992       ImpCastExprToType(RHS, destType); // promote to void*
2993       return destType;
2994     }
2995     if (rhptee->isVoidType()
2996         && (LHSBPT || lhptee->isIncompleteOrObjectType())) {
2997       QualType destPointee=rhptee.getQualifiedType(lhptee.getCVRQualifiers());
2998       QualType destType = Context.getPointerType(destPointee);
2999       ImpCastExprToType(LHS, destType); // add qualifiers if necessary
3000       ImpCastExprToType(RHS, destType); // promote to void*
3001       return destType;
3002     }
3003
3004     bool sameKind = (LHSPT && RHSPT) || (LHSBPT && RHSBPT);
3005     if (sameKind
3006         && Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
3007       // Two identical pointer types are always compatible.
3008       return LHSTy;
3009     }
3010
3011     QualType compositeType = LHSTy;
3012
3013     // If either type is an Objective-C object type then check
3014     // compatibility according to Objective-C.
3015     if (Context.isObjCObjectPointerType(LHSTy) ||
3016         Context.isObjCObjectPointerType(RHSTy)) {
3017       // If both operands are interfaces and either operand can be
3018       // assigned to the other, use that type as the composite
3019       // type. This allows
3020       //   xxx ? (A*) a : (B*) b
3021       // where B is a subclass of A.
3022       //
3023       // Additionally, as for assignment, if either type is 'id'
3024       // allow silent coercion. Finally, if the types are
3025       // incompatible then make sure to use 'id' as the composite
3026       // type so the result is acceptable for sending messages to.
3027
3028       // FIXME: Consider unifying with 'areComparableObjCPointerTypes'.
3029       // It could return the composite type.
3030       const ObjCInterfaceType* LHSIface = lhptee->getAsObjCInterfaceType();
3031       const ObjCInterfaceType* RHSIface = rhptee->getAsObjCInterfaceType();
3032       if (LHSIface && RHSIface &&
3033           Context.canAssignObjCInterfaces(LHSIface, RHSIface)) {
3034         compositeType = LHSTy;
3035       } else if (LHSIface && RHSIface &&
3036                  Context.canAssignObjCInterfaces(RHSIface, LHSIface)) {
3037         compositeType = RHSTy;
3038       } else if (Context.isObjCIdStructType(lhptee) ||
3039                  Context.isObjCIdStructType(rhptee)) {
3040         compositeType = Context.getObjCIdType();
3041       } else if (LHSBPT || RHSBPT) {
3042         if (!sameKind
3043             || !Context.typesAreCompatible(lhptee.getUnqualifiedType(),
3044                                            rhptee.getUnqualifiedType()))
3045           Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
3046             << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3047         return QualType();
3048       } else {
3049         Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
3050           << LHSTy << RHSTy
3051           << LHS->getSourceRange() << RHS->getSourceRange();
3052         QualType incompatTy = Context.getObjCIdType();
3053         ImpCastExprToType(LHS, incompatTy);
3054         ImpCastExprToType(RHS, incompatTy);
3055         return incompatTy;
3056       }
3057     } else if (!sameKind
3058                || !Context.typesAreCompatible(lhptee.getUnqualifiedType(),
3059                                               rhptee.getUnqualifiedType())) {
3060       Diag(QuestionLoc, diag::warn_typecheck_cond_incompatible_pointers)
3061         << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3062       // In this situation, we assume void* type. No especially good
3063       // reason, but this is what gcc does, and we do have to pick
3064       // to get a consistent AST.
3065       QualType incompatTy = Context.getPointerType(Context.VoidTy);
3066       ImpCastExprToType(LHS, incompatTy);
3067       ImpCastExprToType(RHS, incompatTy);
3068       return incompatTy;
3069     }
3070     // The pointer types are compatible.
3071     // C99 6.5.15p6: If both operands are pointers to compatible types *or* to
3072     // differently qualified versions of compatible types, the result type is
3073     // a pointer to an appropriately qualified version of the *composite*
3074     // type.
3075     // FIXME: Need to calculate the composite type.
3076     // FIXME: Need to add qualifiers
3077     ImpCastExprToType(LHS, compositeType);
3078     ImpCastExprToType(RHS, compositeType);
3079     return compositeType;
3080   }
3081
3082   // GCC compatibility: soften pointer/integer mismatch.
3083   if (RHSTy->isPointerType() && LHSTy->isIntegerType()) {
3084     Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch)
3085       << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3086     ImpCastExprToType(LHS, RHSTy); // promote the integer to a pointer.
3087     return RHSTy;
3088   }
3089   if (LHSTy->isPointerType() && RHSTy->isIntegerType()) {
3090     Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch)
3091       << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3092     ImpCastExprToType(RHS, LHSTy); // promote the integer to a pointer.
3093     return LHSTy;
3094   }
3095
3096   // Need to handle "id<xx>" explicitly. Unlike "id", whose canonical type
3097   // evaluates to "struct objc_object *" (and is handled above when comparing
3098   // id with statically typed objects).
3099   if (LHSTy->isObjCQualifiedIdType() || RHSTy->isObjCQualifiedIdType()) {
3100     // GCC allows qualified id and any Objective-C type to devolve to
3101     // id. Currently localizing to here until clear this should be
3102     // part of ObjCQualifiedIdTypesAreCompatible.
3103     if (ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true) ||
3104         (LHSTy->isObjCQualifiedIdType() &&
3105          Context.isObjCObjectPointerType(RHSTy)) ||
3106         (RHSTy->isObjCQualifiedIdType() &&
3107          Context.isObjCObjectPointerType(LHSTy))) {
3108       // FIXME: This is not the correct composite type. This only happens to
3109       // work because id can more or less be used anywhere, however this may
3110       // change the type of method sends.
3111
3112       // FIXME: gcc adds some type-checking of the arguments and emits
3113       // (confusing) incompatible comparison warnings in some
3114       // cases. Investigate.
3115       QualType compositeType = Context.getObjCIdType();
3116       ImpCastExprToType(LHS, compositeType);
3117       ImpCastExprToType(RHS, compositeType);
3118       return compositeType;
3119     }
3120   }
3121
3122   // Otherwise, the operands are not compatible.
3123   Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
3124     << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3125   return QualType();
3126 }
3127
3128 /// ActOnConditionalOp - Parse a ?: operation.  Note that 'LHS' may be null
3129 /// in the case of a the GNU conditional expr extension.
3130 Action::OwningExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
3131                                                   SourceLocation ColonLoc,
3132                                                   ExprArg Cond, ExprArg LHS,
3133                                                   ExprArg RHS) {
3134   Expr *CondExpr = (Expr *) Cond.get();
3135   Expr *LHSExpr = (Expr *) LHS.get(), *RHSExpr = (Expr *) RHS.get();
3136
3137   // If this is the gnu "x ?: y" extension, analyze the types as though the LHS
3138   // was the condition.
3139   bool isLHSNull = LHSExpr == 0;
3140   if (isLHSNull)
3141     LHSExpr = CondExpr;
3142
3143   QualType result = CheckConditionalOperands(CondExpr, LHSExpr,
3144                                              RHSExpr, QuestionLoc);
3145   if (result.isNull())
3146     return ExprError();
3147
3148   Cond.release();
3149   LHS.release();
3150   RHS.release();
3151   return Owned(new (Context) ConditionalOperator(CondExpr,
3152                                                  isLHSNull ? 0 : LHSExpr,
3153                                                  RHSExpr, result));
3154 }
3155
3156
3157 // CheckPointerTypesForAssignment - This is a very tricky routine (despite
3158 // being closely modeled after the C99 spec:-). The odd characteristic of this
3159 // routine is it effectively iqnores the qualifiers on the top level pointee.
3160 // This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
3161 // FIXME: add a couple examples in this comment.
3162 Sema::AssignConvertType
3163 Sema::CheckPointerTypesForAssignment(QualType lhsType, QualType rhsType) {
3164   QualType lhptee, rhptee;
3165
3166   // get the "pointed to" type (ignoring qualifiers at the top level)
3167   lhptee = lhsType->getAsPointerType()->getPointeeType();
3168   rhptee = rhsType->getAsPointerType()->getPointeeType();
3169
3170   // make sure we operate on the canonical type
3171   lhptee = Context.getCanonicalType(lhptee);
3172   rhptee = Context.getCanonicalType(rhptee);
3173
3174   AssignConvertType ConvTy = Compatible;
3175
3176   // C99 6.5.16.1p1: This following citation is common to constraints
3177   // 3 & 4 (below). ...and the type *pointed to* by the left has all the
3178   // qualifiers of the type *pointed to* by the right;
3179   // FIXME: Handle ExtQualType
3180   if (!lhptee.isAtLeastAsQualifiedAs(rhptee))
3181     ConvTy = CompatiblePointerDiscardsQualifiers;
3182
3183   // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or
3184   // incomplete type and the other is a pointer to a qualified or unqualified
3185   // version of void...
3186   if (lhptee->isVoidType()) {
3187     if (rhptee->isIncompleteOrObjectType())
3188       return ConvTy;
3189
3190     // As an extension, we allow cast to/from void* to function pointer.
3191     assert(rhptee->isFunctionType());
3192     return FunctionVoidPointer;
3193   }
3194
3195   if (rhptee->isVoidType()) {
3196     if (lhptee->isIncompleteOrObjectType())
3197       return ConvTy;
3198
3199     // As an extension, we allow cast to/from void* to function pointer.
3200     assert(lhptee->isFunctionType());
3201     return FunctionVoidPointer;
3202   }
3203   // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or
3204   // unqualified versions of compatible types, ...
3205   lhptee = lhptee.getUnqualifiedType();
3206   rhptee = rhptee.getUnqualifiedType();
3207   if (!Context.typesAreCompatible(lhptee, rhptee)) {
3208     // Check if the pointee types are compatible ignoring the sign.
3209     // We explicitly check for char so that we catch "char" vs
3210     // "unsigned char" on systems where "char" is unsigned.
3211     if (lhptee->isCharType()) {
3212       lhptee = Context.UnsignedCharTy;
3213     } else if (lhptee->isSignedIntegerType()) {
3214       lhptee = Context.getCorrespondingUnsignedType(lhptee);
3215     }
3216     if (rhptee->isCharType()) {
3217       rhptee = Context.UnsignedCharTy;
3218     } else if (rhptee->isSignedIntegerType()) {
3219       rhptee = Context.getCorrespondingUnsignedType(rhptee);
3220     }
3221     if (lhptee == rhptee) {
3222       // Types are compatible ignoring the sign. Qualifier incompatibility
3223       // takes priority over sign incompatibility because the sign
3224       // warning can be disabled.
3225       if (ConvTy != Compatible)
3226         return ConvTy;
3227       return IncompatiblePointerSign;
3228     }
3229     // General pointer incompatibility takes priority over qualifiers.
3230     return IncompatiblePointer;
3231   }
3232   return ConvTy;
3233 }
3234
3235 /// CheckBlockPointerTypesForAssignment - This routine determines whether two
3236 /// block pointer types are compatible or whether a block and normal pointer
3237 /// are compatible. It is more restrict than comparing two function pointer
3238 // types.
3239 Sema::AssignConvertType
3240 Sema::CheckBlockPointerTypesForAssignment(QualType lhsType,
3241                                           QualType rhsType) {
3242   QualType lhptee, rhptee;
3243
3244   // get the "pointed to" type (ignoring qualifiers at the top level)
3245   lhptee = lhsType->getAsBlockPointerType()->getPointeeType();
3246   rhptee = rhsType->getAsBlockPointerType()->getPointeeType();
3247
3248   // make sure we operate on the canonical type
3249   lhptee = Context.getCanonicalType(lhptee);
3250   rhptee = Context.getCanonicalType(rhptee);
3251
3252   AssignConvertType ConvTy = Compatible;
3253
3254   // For blocks we enforce that qualifiers are identical.
3255   if (lhptee.getCVRQualifiers() != rhptee.getCVRQualifiers())
3256     ConvTy = CompatiblePointerDiscardsQualifiers;
3257
3258   if (!Context.typesAreCompatible(lhptee, rhptee))
3259     return IncompatibleBlockPointer;
3260   return ConvTy;
3261 }
3262
3263 /// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
3264 /// has code to accommodate several GCC extensions when type checking
3265 /// pointers. Here are some objectionable examples that GCC considers warnings:
3266 ///
3267 ///  int a, *pint;
3268 ///  short *pshort;
3269 ///  struct foo *pfoo;
3270 ///
3271 ///  pint = pshort; // warning: assignment from incompatible pointer type
3272 ///  a = pint; // warning: assignment makes integer from pointer without a cast
3273 ///  pint = a; // warning: assignment makes pointer from integer without a cast
3274 ///  pint = pfoo; // warning: assignment from incompatible pointer type
3275 ///
3276 /// As a result, the code for dealing with pointers is more complex than the
3277 /// C99 spec dictates.
3278 ///
3279 Sema::AssignConvertType
3280 Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) {
3281   // Get canonical types.  We're not formatting these types, just comparing
3282   // them.
3283   lhsType = Context.getCanonicalType(lhsType).getUnqualifiedType();
3284   rhsType = Context.getCanonicalType(rhsType).getUnqualifiedType();
3285
3286   if (lhsType == rhsType)
3287     return Compatible; // Common case: fast path an exact match.
3288
3289   // If the left-hand side is a reference type, then we are in a
3290   // (rare!) case where we've allowed the use of references in C,
3291   // e.g., as a parameter type in a built-in function. In this case,
3292   // just make sure that the type referenced is compatible with the
3293   // right-hand side type. The caller is responsible for adjusting
3294   // lhsType so that the resulting expression does not have reference
3295   // type.
3296   if (const ReferenceType *lhsTypeRef = lhsType->getAsReferenceType()) {
3297     if (Context.typesAreCompatible(lhsTypeRef->getPointeeType(), rhsType))
3298       return Compatible;
3299     return Incompatible;
3300   }
3301
3302   if (lhsType->isObjCQualifiedIdType() || rhsType->isObjCQualifiedIdType()) {
3303     if (ObjCQualifiedIdTypesAreCompatible(lhsType, rhsType, false))
3304       return Compatible;
3305     // Relax integer conversions like we do for pointers below.
3306     if (rhsType->isIntegerType())
3307       return IntToPointer;
3308     if (lhsType->isIntegerType())
3309       return PointerToInt;
3310     return IncompatibleObjCQualifiedId;
3311   }
3312
3313   if (lhsType->isVectorType() || rhsType->isVectorType()) {
3314     // For ExtVector, allow vector splats; float -> <n x float>
3315     if (const ExtVectorType *LV = lhsType->getAsExtVectorType())
3316       if (LV->getElementType() == rhsType)
3317         return Compatible;
3318
3319     // If we are allowing lax vector conversions, and LHS and RHS are both
3320     // vectors, the total size only needs to be the same. This is a bitcast;
3321     // no bits are changed but the result type is different.
3322     if (getLangOptions().LaxVectorConversions &&
3323         lhsType->isVectorType() && rhsType->isVectorType()) {
3324       if (Context.getTypeSize(lhsType) == Context.getTypeSize(rhsType))
3325         return IncompatibleVectors;
3326     }
3327     return Incompatible;
3328   }
3329
3330   if (lhsType->isArithmeticType() && rhsType->isArithmeticType())
3331     return Compatible;
3332
3333   if (isa<PointerType>(lhsType)) {
3334     if (rhsType->isIntegerType())
3335       return IntToPointer;
3336
3337     if (isa<PointerType>(rhsType))
3338       return CheckPointerTypesForAssignment(lhsType, rhsType);
3339
3340     if (rhsType->getAsBlockPointerType()) {
3341       if (lhsType->getAsPointerType()->getPointeeType()->isVoidType())
3342         return Compatible;
3343
3344       // Treat block pointers as objects.
3345       if (getLangOptions().ObjC1 &&
3346           lhsType == Context.getCanonicalType(Context.getObjCIdType()))
3347         return Compatible;
3348     }
3349     return Incompatible;
3350   }
3351
3352   if (isa<BlockPointerType>(lhsType)) {
3353     if (rhsType->isIntegerType())
3354       return IntToBlockPointer;
3355
3356     // Treat block pointers as objects.
3357     if (getLangOptions().ObjC1 &&
3358         rhsType == Context.getCanonicalType(Context.getObjCIdType()))
3359       return Compatible;
3360
3361     if (rhsType->isBlockPointerType())
3362       return CheckBlockPointerTypesForAssignment(lhsType, rhsType);
3363
3364     if (const PointerType *RHSPT = rhsType->getAsPointerType()) {
3365       if (RHSPT->getPointeeType()->isVoidType())
3366         return Compatible;
3367     }
3368     return Incompatible;
3369   }
3370
3371   if (isa<PointerType>(rhsType)) {
3372     // C99 6.5.16.1p1: the left operand is _Bool and the right is a pointer.
3373     if (lhsType == Context.BoolTy)
3374       return Compatible;
3375
3376     if (lhsType->isIntegerType())
3377       return PointerToInt;
3378
3379     if (isa<PointerType>(lhsType))
3380       return CheckPointerTypesForAssignment(lhsType, rhsType);
3381
3382     if (isa<BlockPointerType>(lhsType) &&
3383         rhsType->getAsPointerType()->getPointeeType()->isVoidType())
3384       return Compatible;
3385     return Incompatible;
3386   }
3387
3388   if (isa<TagType>(lhsType) && isa<TagType>(rhsType)) {
3389     if (Context.typesAreCompatible(lhsType, rhsType))
3390       return Compatible;
3391   }
3392   return Incompatible;
3393 }
3394
3395 /// \brief Constructs a transparent union from an expression that is
3396 /// used to initialize the transparent union.
3397 static void ConstructTransparentUnion(ASTContext &C, Expr *&E,
3398                                       QualType UnionType, FieldDecl *Field) {
3399   // Build an initializer list that designates the appropriate member
3400   // of the transparent union.
3401   InitListExpr *Initializer = new (C) InitListExpr(SourceLocation(),
3402                                                    &E, 1,
3403                                                    SourceLocation());
3404   Initializer->setType(UnionType);
3405   Initializer->setInitializedFieldInUnion(Field);
3406
3407   // Build a compound literal constructing a value of the transparent
3408   // union type from this initializer list.
3409   E = new (C) CompoundLiteralExpr(SourceLocation(), UnionType, Initializer,
3410                                   false);
3411 }
3412
3413 Sema::AssignConvertType
3414 Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, Expr *&rExpr) {
3415   QualType FromType = rExpr->getType();
3416
3417   // If the ArgType is a Union type, we want to handle a potential
3418   // transparent_union GCC extension.
3419   const RecordType *UT = ArgType->getAsUnionType();
3420   if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>(Context))
3421     return Incompatible;
3422
3423   // The field to initialize within the transparent union.
3424   RecordDecl *UD = UT->getDecl();
3425   FieldDecl *InitField = 0;
3426   // It's compatible if the expression matches any of the fields.
3427   for (RecordDecl::field_iterator it = UD->field_begin(Context),
3428          itend = UD->field_end(Context);
3429        it != itend; ++it) {
3430     if (it->getType()->isPointerType()) {
3431       // If the transparent union contains a pointer type, we allow:
3432       // 1) void pointer
3433       // 2) null pointer constant
3434       if (FromType->isPointerType())
3435         if (FromType->getAsPointerType()->getPointeeType()->isVoidType()) {
3436           ImpCastExprToType(rExpr, it->getType());
3437           InitField = *it;
3438           break;
3439         }
3440
3441       if (rExpr->isNullPointerConstant(Context)) {
3442         ImpCastExprToType(rExpr, it->getType());
3443         InitField = *it;
3444         break;
3445       }
3446     }
3447
3448     if (CheckAssignmentConstraints(it->getType(), rExpr->getType())
3449           == Compatible) {
3450       InitField = *it;
3451       break;
3452     }
3453   }
3454
3455   if (!InitField)
3456     return Incompatible;
3457
3458   ConstructTransparentUnion(Context, rExpr, ArgType, InitField);
3459   return Compatible;
3460 }
3461
3462 Sema::AssignConvertType
3463 Sema::CheckSingleAssignmentConstraints(QualType lhsType, Expr *&rExpr) {
3464   if (getLangOptions().CPlusPlus) {
3465     if (!lhsType->isRecordType()) {
3466       // C++ 5.17p3: If the left operand is not of class type, the
3467       // expression is implicitly converted (C++ 4) to the
3468       // cv-unqualified type of the left operand.
3469       if (PerformImplicitConversion(rExpr, lhsType.getUnqualifiedType(),
3470                                     "assigning"))
3471         return Incompatible;
3472       return Compatible;
3473     }
3474
3475     // FIXME: Currently, we fall through and treat C++ classes like C
3476     // structures.
3477   }
3478
3479   // C99 6.5.16.1p1: the left operand is a pointer and the right is
3480   // a null pointer constant.
3481   if ((lhsType->isPointerType() ||
3482        lhsType->isObjCQualifiedIdType() ||
3483        lhsType->isBlockPointerType())
3484       && rExpr->isNullPointerConstant(Context)) {
3485     ImpCastExprToType(rExpr, lhsType);
3486     return Compatible;
3487   }
3488
3489   // This check seems unnatural, however it is necessary to ensure the proper
3490   // conversion of functions/arrays. If the conversion were done for all
3491   // DeclExpr's (created by ActOnIdentifierExpr), it would mess up the unary
3492   // expressions that surpress this implicit conversion (&, sizeof).
3493   //
3494   // Suppress this for references: C++ 8.5.3p5.
3495   if (!lhsType->isReferenceType())
3496     DefaultFunctionArrayConversion(rExpr);
3497
3498   Sema::AssignConvertType result =
3499     CheckAssignmentConstraints(lhsType, rExpr->getType());
3500
3501   // C99 6.5.16.1p2: The value of the right operand is converted to the
3502   // type of the assignment expression.
3503   // CheckAssignmentConstraints allows the left-hand side to be a reference,
3504   // so that we can use references in built-in functions even in C.
3505   // The getNonReferenceType() call makes sure that the resulting expression
3506   // does not have reference type.
3507   if (result != Incompatible && rExpr->getType() != lhsType)
3508     ImpCastExprToType(rExpr, lhsType.getNonReferenceType());
3509   return result;
3510 }
3511
3512 QualType Sema::InvalidOperands(SourceLocation Loc, Expr *&lex, Expr *&rex) {
3513   Diag(Loc, diag::err_typecheck_invalid_operands)
3514     << lex->getType() << rex->getType()
3515     << lex->getSourceRange() << rex->getSourceRange();
3516   return QualType();
3517 }
3518
3519 inline QualType Sema::CheckVectorOperands(SourceLocation Loc, Expr *&lex,
3520                                                               Expr *&rex) {
3521   // For conversion purposes, we ignore any qualifiers.
3522   // For example, "const float" and "float" are equivalent.
3523   QualType lhsType =
3524     Context.getCanonicalType(lex->getType()).getUnqualifiedType();
3525   QualType rhsType =
3526     Context.getCanonicalType(rex->getType()).getUnqualifiedType();
3527
3528   // If the vector types are identical, return.
3529   if (lhsType == rhsType)
3530     return lhsType;
3531
3532   // Handle the case of a vector & extvector type of the same size and element
3533   // type.  It would be nice if we only had one vector type someday.
3534   if (getLangOptions().LaxVectorConversions) {
3535     // FIXME: Should we warn here?
3536     if (const VectorType *LV = lhsType->getAsVectorType()) {
3537       if (const VectorType *RV = rhsType->getAsVectorType())
3538         if (LV->getElementType() == RV->getElementType() &&
3539             LV->getNumElements() == RV->getNumElements()) {
3540           return lhsType->isExtVectorType() ? lhsType : rhsType;
3541         }
3542     }
3543   }
3544
3545   // If the lhs is an extended vector and the rhs is a scalar of the same type
3546   // or a literal, promote the rhs to the vector type.
3547   if (const ExtVectorType *V = lhsType->getAsExtVectorType()) {
3548     QualType eltType = V->getElementType();
3549
3550     if ((eltType->getAsBuiltinType() == rhsType->getAsBuiltinType()) ||
3551         (eltType->isIntegerType() && isa<IntegerLiteral>(rex)) ||
3552         (eltType->isFloatingType() && isa<FloatingLiteral>(rex))) {
3553       ImpCastExprToType(rex, lhsType);
3554       return lhsType;
3555     }
3556   }
3557
3558   // If the rhs is an extended vector and the lhs is a scalar of the same type,
3559   // promote the lhs to the vector type.
3560   if (const ExtVectorType *V = rhsType->getAsExtVectorType()) {
3561     QualType eltType = V->getElementType();
3562
3563     if ((eltType->getAsBuiltinType() == lhsType->getAsBuiltinType()) ||
3564         (eltType->isIntegerType() && isa<IntegerLiteral>(lex)) ||
3565         (eltType->isFloatingType() && isa<FloatingLiteral>(lex))) {
3566       ImpCastExprToType(lex, rhsType);
3567       return rhsType;
3568     }
3569   }
3570
3571   // You cannot convert between vector values of different size.
3572   Diag(Loc, diag::err_typecheck_vector_not_convertable)
3573     << lex->getType() << rex->getType()
3574     << lex->getSourceRange() << rex->getSourceRange();
3575   return QualType();
3576 }
3577
3578 inline QualType Sema::CheckMultiplyDivideOperands(
3579   Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign)
3580 {
3581   if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
3582     return CheckVectorOperands(Loc, lex, rex);
3583
3584   QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
3585
3586   if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
3587     return compType;
3588   return InvalidOperands(Loc, lex, rex);
3589 }
3590
3591 inline QualType Sema::CheckRemainderOperands(
3592   Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign)
3593 {
3594   if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
3595     if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
3596       return CheckVectorOperands(Loc, lex, rex);
3597     return InvalidOperands(Loc, lex, rex);
3598   }
3599
3600   QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
3601
3602   if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
3603     return compType;
3604   return InvalidOperands(Loc, lex, rex);
3605 }
3606
3607 inline QualType Sema::CheckAdditionOperands( // C99 6.5.6
3608   Expr *&lex, Expr *&rex, SourceLocation Loc, QualType* CompLHSTy)
3609 {
3610   if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
3611     QualType compType = CheckVectorOperands(Loc, lex, rex);
3612     if (CompLHSTy) *CompLHSTy = compType;
3613     return compType;
3614   }
3615
3616   QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy);
3617
3618   // handle the common case first (both operands are arithmetic).
3619   if (lex->getType()->isArithmeticType() &&
3620       rex->getType()->isArithmeticType()) {
3621     if (CompLHSTy) *CompLHSTy = compType;
3622     return compType;
3623   }
3624
3625   // Put any potential pointer into PExp
3626   Expr* PExp = lex, *IExp = rex;
3627   if (IExp->getType()->isPointerType())
3628     std::swap(PExp, IExp);
3629
3630   if (const PointerType *PTy = PExp->getType()->getAsPointerType()) {
3631     if (IExp->getType()->isIntegerType()) {
3632       QualType PointeeTy = PTy->getPointeeType();
3633       // Check for arithmetic on pointers to incomplete types.
3634       if (PointeeTy->isVoidType()) {
3635         if (getLangOptions().CPlusPlus) {
3636           Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
3637             << lex->getSourceRange() << rex->getSourceRange();
3638           return QualType();
3639         }
3640
3641         // GNU extension: arithmetic on pointer to void
3642         Diag(Loc, diag::ext_gnu_void_ptr)
3643           << lex->getSourceRange() << rex->getSourceRange();
3644       } else if (PointeeTy->isFunctionType()) {
3645         if (getLangOptions().CPlusPlus) {
3646           Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
3647             << lex->getType() << lex->getSourceRange();
3648           return QualType();
3649         }
3650
3651         // GNU extension: arithmetic on pointer to function
3652         Diag(Loc, diag::ext_gnu_ptr_func_arith)
3653           << lex->getType() << lex->getSourceRange();
3654       } else if (!PTy->isDependentType() &&
3655                  RequireCompleteType(Loc, PointeeTy,
3656                                 diag::err_typecheck_arithmetic_incomplete_type,
3657                                      PExp->getSourceRange(), SourceRange(),
3658                                      PExp->getType()))
3659         return QualType();
3660
3661       // Diagnose bad cases where we step over interface counts.
3662       if (PointeeTy->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
3663         Diag(Loc, diag::err_arithmetic_nonfragile_interface)
3664           << PointeeTy << PExp->getSourceRange();
3665         return QualType();
3666       }
3667
3668       if (CompLHSTy) {
3669         QualType LHSTy = lex->getType();
3670         if (LHSTy->isPromotableIntegerType())
3671           LHSTy = Context.IntTy;
3672         else {
3673           QualType T = isPromotableBitField(lex, Context);
3674           if (!T.isNull())
3675             LHSTy = T;
3676         }
3677
3678         *CompLHSTy = LHSTy;
3679       }
3680       return PExp->getType();
3681     }
3682   }
3683
3684   return InvalidOperands(Loc, lex, rex);
3685 }
3686
3687 // C99 6.5.6
3688 QualType Sema::CheckSubtractionOperands(Expr *&lex, Expr *&rex,
3689                                         SourceLocation Loc, QualType* CompLHSTy) {
3690   if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
3691     QualType compType = CheckVectorOperands(Loc, lex, rex);
3692     if (CompLHSTy) *CompLHSTy = compType;
3693     return compType;
3694   }
3695
3696   QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy);
3697
3698   // Enforce type constraints: C99 6.5.6p3.
3699
3700   // Handle the common case first (both operands are arithmetic).
3701   if (lex->getType()->isArithmeticType()
3702       && rex->getType()->isArithmeticType()) {
3703     if (CompLHSTy) *CompLHSTy = compType;
3704     return compType;
3705   }
3706
3707   // Either ptr - int   or   ptr - ptr.
3708   if (const PointerType *LHSPTy = lex->getType()->getAsPointerType()) {
3709     QualType lpointee = LHSPTy->getPointeeType();
3710
3711     // The LHS must be an completely-defined object type.
3712
3713     bool ComplainAboutVoid = false;
3714     Expr *ComplainAboutFunc = 0;
3715     if (lpointee->isVoidType()) {
3716       if (getLangOptions().CPlusPlus) {
3717         Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
3718           << lex->getSourceRange() << rex->getSourceRange();
3719         return QualType();
3720       }
3721
3722       // GNU C extension: arithmetic on pointer to void
3723       ComplainAboutVoid = true;
3724     } else if (lpointee->isFunctionType()) {
3725       if (getLangOptions().CPlusPlus) {
3726         Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
3727           << lex->getType() << lex->getSourceRange();
3728         return QualType();
3729       }
3730
3731       // GNU C extension: arithmetic on pointer to function
3732       ComplainAboutFunc = lex;
3733     } else if (!lpointee->isDependentType() &&
3734                RequireCompleteType(Loc, lpointee,
3735                                    diag::err_typecheck_sub_ptr_object,
3736                                    lex->getSourceRange(),
3737                                    SourceRange(),
3738                                    lex->getType()))
3739       return QualType();
3740
3741     // Diagnose bad cases where we step over interface counts.
3742     if (lpointee->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
3743       Diag(Loc, diag::err_arithmetic_nonfragile_interface)
3744         << lpointee << lex->getSourceRange();
3745       return QualType();
3746     }
3747
3748     // The result type of a pointer-int computation is the pointer type.
3749     if (rex->getType()->isIntegerType()) {
3750       if (ComplainAboutVoid)
3751         Diag(Loc, diag::ext_gnu_void_ptr)
3752           << lex->getSourceRange() << rex->getSourceRange();
3753       if (ComplainAboutFunc)
3754         Diag(Loc, diag::ext_gnu_ptr_func_arith)
3755           << ComplainAboutFunc->getType()
3756           << ComplainAboutFunc->getSourceRange();
3757
3758       if (CompLHSTy) *CompLHSTy = lex->getType();
3759       return lex->getType();
3760     }
3761
3762     // Handle pointer-pointer subtractions.
3763     if (const PointerType *RHSPTy = rex->getType()->getAsPointerType()) {
3764       QualType rpointee = RHSPTy->getPointeeType();
3765
3766       // RHS must be a completely-type object type.
3767       // Handle the GNU void* extension.
3768       if (rpointee->isVoidType()) {
3769         if (getLangOptions().CPlusPlus) {
3770           Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
3771             << lex->getSourceRange() << rex->getSourceRange();
3772           return QualType();
3773         }
3774
3775         ComplainAboutVoid = true;
3776       } else if (rpointee->isFunctionType()) {
3777         if (getLangOptions().CPlusPlus) {
3778           Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
3779             << rex->getType() << rex->getSourceRange();
3780           return QualType();
3781         }
3782
3783         // GNU extension: arithmetic on pointer to function
3784         if (!ComplainAboutFunc)
3785           ComplainAboutFunc = rex;
3786       } else if (!rpointee->isDependentType() &&
3787                  RequireCompleteType(Loc, rpointee,
3788                                      diag::err_typecheck_sub_ptr_object,
3789                                      rex->getSourceRange(),
3790                                      SourceRange(),
3791                                      rex->getType()))
3792         return QualType();
3793
3794       if (getLangOptions().CPlusPlus) {
3795         // Pointee types must be the same: C++ [expr.add]
3796         if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) {
3797           Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
3798             << lex->getType() << rex->getType()
3799             << lex->getSourceRange() << rex->getSourceRange();
3800           return QualType();
3801         }
3802       } else {
3803         // Pointee types must be compatible C99 6.5.6p3
3804         if (!Context.typesAreCompatible(
3805                 Context.getCanonicalType(lpointee).getUnqualifiedType(),
3806                 Context.getCanonicalType(rpointee).getUnqualifiedType())) {
3807           Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
3808             << lex->getType() << rex->getType()
3809             << lex->getSourceRange() << rex->getSourceRange();
3810           return QualType();
3811         }
3812       }
3813
3814       if (ComplainAboutVoid)
3815         Diag(Loc, diag::ext_gnu_void_ptr)
3816           << lex->getSourceRange() << rex->getSourceRange();
3817       if (ComplainAboutFunc)
3818         Diag(Loc, diag::ext_gnu_ptr_func_arith)
3819           << ComplainAboutFunc->getType()
3820           << ComplainAboutFunc->getSourceRange();
3821
3822       if (CompLHSTy) *CompLHSTy = lex->getType();
3823       return Context.getPointerDiffType();
3824     }
3825   }
3826
3827   return InvalidOperands(Loc, lex, rex);
3828 }
3829
3830 // C99 6.5.7
3831 QualType Sema::CheckShiftOperands(Expr *&lex, Expr *&rex, SourceLocation Loc,
3832                                   bool isCompAssign) {
3833   // C99 6.5.7p2: Each of the operands shall have integer type.
3834   if (!lex->getType()->isIntegerType() || !rex->getType()->isIntegerType())
3835     return InvalidOperands(Loc, lex, rex);
3836
3837   // Shifts don't perform usual arithmetic conversions, they just do integer
3838   // promotions on each operand. C99 6.5.7p3
3839   QualType LHSTy;
3840   if (lex->getType()->isPromotableIntegerType())
3841     LHSTy = Context.IntTy;
3842   else {
3843     LHSTy = isPromotableBitField(lex, Context);
3844     if (LHSTy.isNull())
3845       LHSTy = lex->getType();
3846   }
3847   if (!isCompAssign)
3848     ImpCastExprToType(lex, LHSTy);
3849
3850   UsualUnaryConversions(rex);
3851
3852   // "The type of the result is that of the promoted left operand."
3853   return LHSTy;
3854 }
3855
3856 // C99 6.5.8, C++ [expr.rel]
3857 QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc,
3858                                     unsigned OpaqueOpc, bool isRelational) {
3859   BinaryOperator::Opcode Opc = (BinaryOperator::Opcode)OpaqueOpc;
3860
3861   if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
3862     return CheckVectorCompareOperands(lex, rex, Loc, isRelational);
3863
3864   // C99 6.5.8p3 / C99 6.5.9p4
3865   if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
3866     UsualArithmeticConversions(lex, rex);
3867   else {
3868     UsualUnaryConversions(lex);
3869     UsualUnaryConversions(rex);
3870   }
3871   QualType lType = lex->getType();
3872   QualType rType = rex->getType();
3873
3874   if (!lType->isFloatingType()
3875       && !(lType->isBlockPointerType() && isRelational)) {
3876     // For non-floating point types, check for self-comparisons of the form
3877     // x == x, x != x, x < x, etc.  These always evaluate to a constant, and
3878     // often indicate logic errors in the program.
3879     // NOTE: Don't warn about comparisons of enum constants. These can arise
3880     //  from macro expansions, and are usually quite deliberate.
3881     Expr *LHSStripped = lex->IgnoreParens();
3882     Expr *RHSStripped = rex->IgnoreParens();
3883     if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHSStripped))
3884       if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHSStripped))
3885         if (DRL->getDecl() == DRR->getDecl() &&
3886             !isa<EnumConstantDecl>(DRL->getDecl()))
3887           Diag(Loc, diag::warn_selfcomparison);
3888
3889     if (isa<CastExpr>(LHSStripped))
3890       LHSStripped = LHSStripped->IgnoreParenCasts();
3891     if (isa<CastExpr>(RHSStripped))
3892       RHSStripped = RHSStripped->IgnoreParenCasts();
3893
3894     // Warn about comparisons against a string constant (unless the other
3895     // operand is null), the user probably wants strcmp.
3896     Expr *literalString = 0;
3897     Expr *literalStringStripped = 0;
3898     if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
3899         !RHSStripped->isNullPointerConstant(Context)) {
3900       literalString = lex;
3901       literalStringStripped = LHSStripped;
3902     }
3903     else if ((isa<StringLiteral>(RHSStripped) ||
3904               isa<ObjCEncodeExpr>(RHSStripped)) &&
3905              !LHSStripped->isNullPointerConstant(Context)) {
3906       literalString = rex;
3907       literalStringStripped = RHSStripped;
3908     }
3909
3910     if (literalString) {
3911       std::string resultComparison;
3912       switch (Opc) {
3913       case BinaryOperator::LT: resultComparison = ") < 0"; break;
3914       case BinaryOperator::GT: resultComparison = ") > 0"; break;
3915       case BinaryOperator::LE: resultComparison = ") <= 0"; break;
3916       case BinaryOperator::GE: resultComparison = ") >= 0"; break;
3917       case BinaryOperator::EQ: resultComparison = ") == 0"; break;
3918       case BinaryOperator::NE: resultComparison = ") != 0"; break;
3919       default: assert(false && "Invalid comparison operator");
3920       }
3921       Diag(Loc, diag::warn_stringcompare)
3922         << isa<ObjCEncodeExpr>(literalStringStripped)
3923         << literalString->getSourceRange()
3924         << CodeModificationHint::CreateReplacement(SourceRange(Loc), ", ")
3925         << CodeModificationHint::CreateInsertion(lex->getLocStart(),
3926                                                  "strcmp(")
3927         << CodeModificationHint::CreateInsertion(
3928                                        PP.getLocForEndOfToken(rex->getLocEnd()),
3929                                        resultComparison);
3930     }
3931   }
3932
3933   // The result of comparisons is 'bool' in C++, 'int' in C.
3934   QualType ResultTy = getLangOptions().CPlusPlus? Context.BoolTy :Context.IntTy;
3935
3936   if (isRelational) {
3937     if (lType->isRealType() && rType->isRealType())
3938       return ResultTy;
3939   } else {
3940     // Check for comparisons of floating point operands using != and ==.
3941     if (lType->isFloatingType()) {
3942       assert(rType->isFloatingType());
3943       CheckFloatComparison(Loc,lex,rex);
3944     }
3945
3946     if (lType->isArithmeticType() && rType->isArithmeticType())
3947       return ResultTy;
3948   }
3949
3950   bool LHSIsNull = lex->isNullPointerConstant(Context);
3951   bool RHSIsNull = rex->isNullPointerConstant(Context);
3952
3953   // All of the following pointer related warnings are GCC extensions, except
3954   // when handling null pointer constants. One day, we can consider making them
3955   // errors (when -pedantic-errors is enabled).
3956   if (lType->isPointerType() && rType->isPointerType()) { // C99 6.5.8p2
3957     QualType LCanPointeeTy =
3958       Context.getCanonicalType(lType->getAsPointerType()->getPointeeType());
3959     QualType RCanPointeeTy =
3960       Context.getCanonicalType(rType->getAsPointerType()->getPointeeType());
3961
3962     // Simple check: if the pointee types are identical, we're done.
3963     if (LCanPointeeTy == RCanPointeeTy)
3964       return ResultTy;
3965
3966     if (getLangOptions().CPlusPlus) {
3967       // C++ [expr.rel]p2:
3968       //   [...] Pointer conversions (4.10) and qualification
3969       //   conversions (4.4) are performed on pointer operands (or on
3970       //   a pointer operand and a null pointer constant) to bring
3971       //   them to their composite pointer type. [...]
3972       //
3973       // C++ [expr.eq]p2 uses the same notion for (in)equality
3974       // comparisons of pointers.
3975       QualType T = FindCompositePointerType(lex, rex);
3976       if (T.isNull()) {
3977         Diag(Loc, diag::err_typecheck_comparison_of_distinct_pointers)
3978           << lType << rType << lex->getSourceRange() << rex->getSourceRange();
3979         return QualType();
3980       }
3981
3982       ImpCastExprToType(lex, T);
3983       ImpCastExprToType(rex, T);
3984       return ResultTy;
3985     }
3986
3987     if (!LHSIsNull && !RHSIsNull &&                       // C99 6.5.9p2
3988         !LCanPointeeTy->isVoidType() && !RCanPointeeTy->isVoidType() &&
3989         !Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
3990                                     RCanPointeeTy.getUnqualifiedType()) &&
3991         !Context.areComparableObjCPointerTypes(lType, rType)) {
3992       Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
3993         << lType << rType << lex->getSourceRange() << rex->getSourceRange();
3994     }
3995     ImpCastExprToType(rex, lType); // promote the pointer to pointer
3996     return ResultTy;
3997   }
3998   // C++ allows comparison of pointers with null pointer constants.
3999   if (getLangOptions().CPlusPlus) {
4000     if (lType->isPointerType() && RHSIsNull) {
4001       ImpCastExprToType(rex, lType);
4002       return ResultTy;
4003     }
4004     if (rType->isPointerType() && LHSIsNull) {
4005       ImpCastExprToType(lex, rType);
4006       return ResultTy;
4007     }
4008     // And comparison of nullptr_t with itself.
4009     if (lType->isNullPtrType() && rType->isNullPtrType())
4010       return ResultTy;
4011   }
4012   // Handle block pointer types.
4013   if (!isRelational && lType->isBlockPointerType() && rType->isBlockPointerType()) {
4014     QualType lpointee = lType->getAsBlockPointerType()->getPointeeType();
4015     QualType rpointee = rType->getAsBlockPointerType()->getPointeeType();
4016
4017     if (!LHSIsNull && !RHSIsNull &&
4018         !Context.typesAreCompatible(lpointee, rpointee)) {
4019       Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
4020         << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4021     }
4022     ImpCastExprToType(rex, lType); // promote the pointer to pointer
4023     return ResultTy;
4024   }
4025   // Allow block pointers to be compared with null pointer constants.
4026   if (!isRelational
4027       && ((lType->isBlockPointerType() && rType->isPointerType())
4028           || (lType->isPointerType() && rType->isBlockPointerType()))) {
4029     if (!LHSIsNull && !RHSIsNull) {
4030       if (!((rType->isPointerType() && rType->getAsPointerType()
4031              ->getPointeeType()->isVoidType())
4032             || (lType->isPointerType() && lType->getAsPointerType()
4033                 ->getPointeeType()->isVoidType())))
4034         Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
4035           << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4036     }
4037     ImpCastExprToType(rex, lType); // promote the pointer to pointer
4038     return ResultTy;
4039   }
4040
4041   if ((lType->isObjCQualifiedIdType() || rType->isObjCQualifiedIdType())) {
4042     if (lType->isPointerType() || rType->isPointerType()) {
4043       const PointerType *LPT = lType->getAsPointerType();
4044       const PointerType *RPT = rType->getAsPointerType();
4045       bool LPtrToVoid = LPT ?
4046         Context.getCanonicalType(LPT->getPointeeType())->isVoidType() : false;
4047       bool RPtrToVoid = RPT ?
4048         Context.getCanonicalType(RPT->getPointeeType())->isVoidType() : false;
4049
4050       if (!LPtrToVoid && !RPtrToVoid &&
4051           !Context.typesAreCompatible(lType, rType)) {
4052         Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
4053           << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4054         ImpCastExprToType(rex, lType);
4055         return ResultTy;
4056       }
4057       ImpCastExprToType(rex, lType);
4058       return ResultTy;
4059     }
4060     if (ObjCQualifiedIdTypesAreCompatible(lType, rType, true)) {
4061       ImpCastExprToType(rex, lType);
4062       return ResultTy;
4063     } else {
4064       if ((lType->isObjCQualifiedIdType() && rType->isObjCQualifiedIdType())) {
4065         Diag(Loc, diag::warn_incompatible_qualified_id_operands)
4066           << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4067         ImpCastExprToType(rex, lType);
4068         return ResultTy;
4069       }
4070     }
4071   }
4072   if ((lType->isPointerType() || lType->isObjCQualifiedIdType()) &&
4073        rType->isIntegerType()) {
4074     if (!RHSIsNull)
4075       Diag(Loc, diag::ext_typecheck_comparison_of_pointer_integer)
4076         << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4077     ImpCastExprToType(rex, lType); // promote the integer to pointer
4078     return ResultTy;
4079   }
4080   if (lType->isIntegerType() &&
4081       (rType->isPointerType() || rType->isObjCQualifiedIdType())) {
4082     if (!LHSIsNull)
4083       Diag(Loc, diag::ext_typecheck_comparison_of_pointer_integer)
4084         << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4085     ImpCastExprToType(lex, rType); // promote the integer to pointer
4086     return ResultTy;
4087   }
4088   // Handle block pointers.
4089   if (!isRelational && RHSIsNull
4090       && lType->isBlockPointerType() && rType->isIntegerType()) {
4091     ImpCastExprToType(rex, lType); // promote the integer to pointer
4092     return ResultTy;
4093   }
4094   if (!isRelational && LHSIsNull
4095       && lType->isIntegerType() && rType->isBlockPointerType()) {
4096     ImpCastExprToType(lex, rType); // promote the integer to pointer
4097     return ResultTy;
4098   }
4099   return InvalidOperands(Loc, lex, rex);
4100 }
4101
4102 /// CheckVectorCompareOperands - vector comparisons are a clang extension that
4103 /// operates on extended vector types.  Instead of producing an IntTy result,
4104 /// like a scalar comparison, a vector comparison produces a vector of integer
4105 /// types.
4106 QualType Sema::CheckVectorCompareOperands(Expr *&lex, Expr *&rex,
4107                                           SourceLocation Loc,
4108                                           bool isRelational) {
4109   // Check to make sure we're operating on vectors of the same type and width,
4110   // Allowing one side to be a scalar of element type.
4111   QualType vType = CheckVectorOperands(Loc, lex, rex);
4112   if (vType.isNull())
4113     return vType;
4114
4115   QualType lType = lex->getType();
4116   QualType rType = rex->getType();
4117
4118   // For non-floating point types, check for self-comparisons of the form
4119   // x == x, x != x, x < x, etc.  These always evaluate to a constant, and
4120   // often indicate logic errors in the program.
4121   if (!lType->isFloatingType()) {
4122     if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(lex->IgnoreParens()))
4123       if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(rex->IgnoreParens()))
4124         if (DRL->getDecl() == DRR->getDecl())
4125           Diag(Loc, diag::warn_selfcomparison);
4126   }
4127
4128   // Check for comparisons of floating point operands using != and ==.
4129   if (!isRelational && lType->isFloatingType()) {
4130     assert (rType->isFloatingType());
4131     CheckFloatComparison(Loc,lex,rex);
4132   }
4133
4134   // FIXME: Vector compare support in the LLVM backend is not fully reliable,
4135   // just reject all vector comparisons for now.
4136   if (1) {
4137     Diag(Loc, diag::err_typecheck_vector_comparison)
4138       << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4139     return QualType();
4140   }
4141
4142   // Return the type for the comparison, which is the same as vector type for
4143   // integer vectors, or an integer type of identical size and number of
4144   // elements for floating point vectors.
4145   if (lType->isIntegerType())
4146     return lType;
4147
4148   const VectorType *VTy = lType->getAsVectorType();
4149   unsigned TypeSize = Context.getTypeSize(VTy->getElementType());
4150   if (TypeSize == Context.getTypeSize(Context.IntTy))
4151     return Context.getExtVectorType(Context.IntTy, VTy->getNumElements());
4152   if (TypeSize == Context.getTypeSize(Context.LongTy))
4153     return Context.getExtVectorType(Context.LongTy, VTy->getNumElements());
4154
4155   assert(TypeSize == Context.getTypeSize(Context.LongLongTy) &&
4156          "Unhandled vector element size in vector compare");
4157   return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements());
4158 }
4159
4160 inline QualType Sema::CheckBitwiseOperands(
4161   Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign)
4162 {
4163   if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
4164     return CheckVectorOperands(Loc, lex, rex);
4165
4166   QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
4167
4168   if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
4169     return compType;
4170   return InvalidOperands(Loc, lex, rex);
4171 }
4172
4173 inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14]
4174   Expr *&lex, Expr *&rex, SourceLocation Loc)
4175 {
4176   UsualUnaryConversions(lex);
4177   UsualUnaryConversions(rex);
4178
4179   if (lex->getType()->isScalarType() && rex->getType()->isScalarType())
4180     return Context.IntTy;
4181   return InvalidOperands(Loc, lex, rex);
4182 }
4183
4184 /// IsReadonlyProperty - Verify that otherwise a valid l-value expression
4185 /// is a read-only property; return true if so. A readonly property expression
4186 /// depends on various declarations and thus must be treated specially.
4187 ///
4188 static bool IsReadonlyProperty(Expr *E, Sema &S)
4189 {
4190   if (E->getStmtClass() == Expr::ObjCPropertyRefExprClass) {
4191     const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(E);
4192     if (ObjCPropertyDecl *PDecl = PropExpr->getProperty()) {
4193       QualType BaseType = PropExpr->getBase()->getType();
4194       if (const PointerType *PTy = BaseType->getAsPointerType())
4195         if (const ObjCInterfaceType *IFTy =
4196             PTy->getPointeeType()->getAsObjCInterfaceType())
4197           if (ObjCInterfaceDecl *IFace = IFTy->getDecl())
4198             if (S.isPropertyReadonly(PDecl, IFace))
4199               return true;
4200     }
4201   }
4202   return false;
4203 }
4204
4205 /// CheckForModifiableLvalue - Verify that E is a modifiable lvalue.  If not,
4206 /// emit an error and return true.  If so, return false.
4207 static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
4208   SourceLocation OrigLoc = Loc;
4209   Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
4210                                                               &Loc);
4211   if (IsLV == Expr::MLV_Valid && IsReadonlyProperty(E, S))
4212     IsLV = Expr::MLV_ReadonlyProperty;
4213   if (IsLV == Expr::MLV_Valid)
4214     return false;
4215
4216   unsigned Diag = 0;
4217   bool NeedType = false;
4218   switch (IsLV) { // C99 6.5.16p2
4219   default: assert(0 && "Unknown result from isModifiableLvalue!");
4220   case Expr::MLV_ConstQualified: Diag = diag::err_typecheck_assign_const; break;
4221   case Expr::MLV_ArrayType:
4222     Diag = diag::err_typecheck_array_not_modifiable_lvalue;
4223     NeedType = true;
4224     break;
4225   case Expr::MLV_NotObjectType:
4226     Diag = diag::err_typecheck_non_object_not_modifiable_lvalue;
4227     NeedType = true;
4228     break;
4229   case Expr::MLV_LValueCast:
4230     Diag = diag::err_typecheck_lvalue_casts_not_supported;
4231     break;
4232   case Expr::MLV_InvalidExpression:
4233     Diag = diag::err_typecheck_expression_not_modifiable_lvalue;
4234     break;
4235   case Expr::MLV_IncompleteType:
4236   case Expr::MLV_IncompleteVoidType:
4237     return S.RequireCompleteType(Loc, E->getType(),
4238                       diag::err_typecheck_incomplete_type_not_modifiable_lvalue,
4239                                     E->getSourceRange());
4240   case Expr::MLV_DuplicateVectorComponents:
4241     Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
4242     break;
4243   case Expr::MLV_NotBlockQualified:
4244     Diag = diag::err_block_decl_ref_not_modifiable_lvalue;
4245     break;
4246   case Expr::MLV_ReadonlyProperty:
4247     Diag = diag::error_readonly_property_assignment;
4248     break;
4249   case Expr::MLV_NoSetterProperty:
4250     Diag = diag::error_nosetter_property_assignment;
4251     break;
4252   }
4253
4254   SourceRange Assign;
4255   if (Loc != OrigLoc)
4256     Assign = SourceRange(OrigLoc, OrigLoc);
4257   if (NeedType)
4258     S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign;
4259   else
4260     S.Diag(Loc, Diag) << E->getSourceRange() << Assign;
4261   return true;
4262 }
4263
4264
4265
4266 // C99 6.5.16.1
4267 QualType Sema::CheckAssignmentOperands(Expr *LHS, Expr *&RHS,
4268                                        SourceLocation Loc,
4269                                        QualType CompoundType) {
4270   // Verify that LHS is a modifiable lvalue, and emit error if not.
4271   if (CheckForModifiableLvalue(LHS, Loc, *this))
4272     return QualType();
4273
4274   QualType LHSType = LHS->getType();
4275   QualType RHSType = CompoundType.isNull() ? RHS->getType() : CompoundType;
4276
4277   AssignConvertType ConvTy;
4278   if (CompoundType.isNull()) {
4279     // Simple assignment "x = y".
4280     ConvTy = CheckSingleAssignmentConstraints(LHSType, RHS);
4281     // Special case of NSObject attributes on c-style pointer types.
4282     if (ConvTy == IncompatiblePointer &&
4283         ((Context.isObjCNSObjectType(LHSType) &&
4284           Context.isObjCObjectPointerType(RHSType)) ||
4285          (Context.isObjCNSObjectType(RHSType) &&
4286           Context.isObjCObjectPointerType(LHSType))))
4287       ConvTy = Compatible;
4288
4289     // If the RHS is a unary plus or minus, check to see if they = and + are
4290     // right next to each other.  If so, the user may have typo'd "x =+ 4"
4291     // instead of "x += 4".
4292     Expr *RHSCheck = RHS;
4293     if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck))
4294       RHSCheck = ICE->getSubExpr();
4295     if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
4296       if ((UO->getOpcode() == UnaryOperator::Plus ||
4297            UO->getOpcode() == UnaryOperator::Minus) &&
4298           Loc.isFileID() && UO->getOperatorLoc().isFileID() &&
4299           // Only if the two operators are exactly adjacent.
4300           Loc.getFileLocWithOffset(1) == UO->getOperatorLoc() &&
4301           // And there is a space or other character before the subexpr of the
4302           // unary +/-.  We don't want to warn on "x=-1".
4303           Loc.getFileLocWithOffset(2) != UO->getSubExpr()->getLocStart() &&
4304           UO->getSubExpr()->getLocStart().isFileID()) {
4305         Diag(Loc, diag::warn_not_compound_assign)
4306           << (UO->getOpcode() == UnaryOperator::Plus ? "+" : "-")
4307           << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
4308       }
4309     }
4310   } else {
4311     // Compound assignment "x += y"
4312     ConvTy = CheckAssignmentConstraints(LHSType, RHSType);
4313   }
4314
4315   if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
4316                                RHS, "assigning"))
4317     return QualType();
4318
4319   // C99 6.5.16p3: The type of an assignment expression is the type of the
4320   // left operand unless the left operand has qualified type, in which case
4321   // it is the unqualified version of the type of the left operand.
4322   // C99 6.5.16.1p2: In simple assignment, the value of the right operand
4323   // is converted to the type of the assignment expression (above).
4324   // C++ 5.17p1: the type of the assignment expression is that of its left
4325   // operand.
4326   return LHSType.getUnqualifiedType();
4327 }
4328
4329 // C99 6.5.17
4330 QualType Sema::CheckCommaOperands(Expr *LHS, Expr *&RHS, SourceLocation Loc) {
4331   // Comma performs lvalue conversion (C99 6.3.2.1), but not unary conversions.
4332   DefaultFunctionArrayConversion(RHS);
4333
4334   // FIXME: Check that RHS type is complete in C mode (it's legal for it to be
4335   // incomplete in C++).
4336
4337   return RHS->getType();
4338 }
4339
4340 /// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
4341 /// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
4342 QualType Sema::CheckIncrementDecrementOperand(Expr *Op, SourceLocation OpLoc,
4343                                               bool isInc) {
4344   if (Op->isTypeDependent())
4345     return Context.DependentTy;
4346
4347   QualType ResType = Op->getType();
4348   assert(!ResType.isNull() && "no type for increment/decrement expression");
4349
4350   if (getLangOptions().CPlusPlus && ResType->isBooleanType()) {
4351     // Decrement of bool is not allowed.
4352     if (!isInc) {
4353       Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange();
4354       return QualType();
4355     }
4356     // Increment of bool sets it to true, but is deprecated.
4357     Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange();
4358   } else if (ResType->isRealType()) {
4359     // OK!
4360   } else if (const PointerType *PT = ResType->getAsPointerType()) {
4361     // C99 6.5.2.4p2, 6.5.6p2
4362     if (PT->getPointeeType()->isVoidType()) {
4363       if (getLangOptions().CPlusPlus) {
4364         Diag(OpLoc, diag::err_typecheck_pointer_arith_void_type)
4365           << Op->getSourceRange();
4366         return QualType();
4367       }
4368
4369       // Pointer to void is a GNU extension in C.
4370       Diag(OpLoc, diag::ext_gnu_void_ptr) << Op->getSourceRange();
4371     } else if (PT->getPointeeType()->isFunctionType()) {
4372       if (getLangOptions().CPlusPlus) {
4373         Diag(OpLoc, diag::err_typecheck_pointer_arith_function_type)
4374           << Op->getType() << Op->getSourceRange();
4375         return QualType();
4376       }
4377
4378       Diag(OpLoc, diag::ext_gnu_ptr_func_arith)
4379         << ResType << Op->getSourceRange();
4380     } else if (RequireCompleteType(OpLoc, PT->getPointeeType(),
4381                                diag::err_typecheck_arithmetic_incomplete_type,
4382                                    Op->getSourceRange(), SourceRange(),
4383                                    ResType))
4384       return QualType();
4385   } else if (ResType->isComplexType()) {
4386     // C99 does not support ++/-- on complex types, we allow as an extension.
4387     Diag(OpLoc, diag::ext_integer_increment_complex)
4388       << ResType << Op->getSourceRange();
4389   } else {
4390     Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
4391       << ResType << Op->getSourceRange();
4392     return QualType();
4393   }
4394   // At this point, we know we have a real, complex or pointer type.
4395   // Now make sure the operand is a modifiable lvalue.
4396   if (CheckForModifiableLvalue(Op, OpLoc, *this))
4397     return QualType();
4398   return ResType;
4399 }
4400
4401 /// getPrimaryDecl - Helper function for CheckAddressOfOperand().
4402 /// This routine allows us to typecheck complex/recursive expressions
4403 /// where the declaration is needed for type checking. We only need to
4404 /// handle cases when the expression references a function designator
4405 /// or is an lvalue. Here are some examples:
4406 ///  - &(x) => x
4407 ///  - &*****f => f for f a function designator.
4408 ///  - &s.xx => s
4409 ///  - &s.zz[1].yy -> s, if zz is an array
4410 ///  - *(x + 1) -> x, if x is an array
4411 ///  - &"123"[2] -> 0
4412 ///  - & __real__ x -> x
4413 static NamedDecl *getPrimaryDecl(Expr *E) {
4414   switch (E->getStmtClass()) {
4415   case Stmt::DeclRefExprClass:
4416   case Stmt::QualifiedDeclRefExprClass:
4417     return cast<DeclRefExpr>(E)->getDecl();
4418   case Stmt::MemberExprClass:
4419     // If this is an arrow operator, the address is an offset from
4420     // the base's value, so the object the base refers to is
4421     // irrelevant.
4422     if (cast<MemberExpr>(E)->isArrow())
4423       return 0;
4424     // Otherwise, the expression refers to a part of the base
4425     return getPrimaryDecl(cast<MemberExpr>(E)->getBase());
4426   case Stmt::ArraySubscriptExprClass: {
4427     // FIXME: This code shouldn't be necessary!  We should catch the implicit
4428     // promotion of register arrays earlier.
4429     Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
4430     if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) {
4431       if (ICE->getSubExpr()->getType()->isArrayType())
4432         return getPrimaryDecl(ICE->getSubExpr());
4433     }
4434     return 0;
4435   }
4436   case Stmt::UnaryOperatorClass: {
4437     UnaryOperator *UO = cast<UnaryOperator>(E);
4438
4439     switch(UO->getOpcode()) {
4440     case UnaryOperator::Real:
4441     case UnaryOperator::Imag:
4442     case UnaryOperator::Extension:
4443       return getPrimaryDecl(UO->getSubExpr());
4444     default:
4445       return 0;
4446     }
4447   }
4448   case Stmt::ParenExprClass:
4449     return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr());
4450   case Stmt::ImplicitCastExprClass:
4451     // If the result of an implicit cast is an l-value, we care about
4452     // the sub-expression; otherwise, the result here doesn't matter.
4453     return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr());
4454   default:
4455     return 0;
4456   }
4457 }
4458
4459 /// CheckAddressOfOperand - The operand of & must be either a function
4460 /// designator or an lvalue designating an object. If it is an lvalue, the
4461 /// object cannot be declared with storage class register or be a bit field.
4462 /// Note: The usual conversions are *not* applied to the operand of the &
4463 /// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
4464 /// In C++, the operand might be an overloaded function name, in which case
4465 /// we allow the '&' but retain the overloaded-function type.
4466 QualType Sema::CheckAddressOfOperand(Expr *op, SourceLocation OpLoc) {
4467   // Make sure to ignore parentheses in subsequent checks
4468   op = op->IgnoreParens();
4469
4470   if (op->isTypeDependent())
4471     return Context.DependentTy;
4472
4473   if (getLangOptions().C99) {
4474     // Implement C99-only parts of addressof rules.
4475     if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
4476       if (uOp->getOpcode() == UnaryOperator::Deref)
4477         // Per C99 6.5.3.2, the address of a deref always returns a valid result
4478         // (assuming the deref expression is valid).
4479         return uOp->getSubExpr()->getType();
4480     }
4481     // Technically, there should be a check for array subscript
4482     // expressions here, but the result of one is always an lvalue anyway.
4483   }
4484   NamedDecl *dcl = getPrimaryDecl(op);
4485   Expr::isLvalueResult lval = op->isLvalue(Context);
4486
4487   if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
4488     // C99 6.5.3.2p1
4489     // The operand must be either an l-value or a function designator
4490     if (!op->getType()->isFunctionType()) {
4491       // FIXME: emit more specific diag...
4492       Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
4493         << op->getSourceRange();
4494       return QualType();
4495     }
4496   } else if (op->getBitField()) { // C99 6.5.3.2p1
4497     // The operand cannot be a bit-field
4498     Diag(OpLoc, diag::err_typecheck_address_of)
4499       << "bit-field" << op->getSourceRange();
4500         return QualType();
4501   } else if (isa<ExtVectorElementExpr>(op) || (isa<ArraySubscriptExpr>(op) &&
4502            cast<ArraySubscriptExpr>(op)->getBase()->getType()->isVectorType())){
4503     // The operand cannot be an element of a vector
4504     Diag(OpLoc, diag::err_typecheck_address_of)
4505       << "vector element" << op->getSourceRange();
4506     return QualType();
4507   } else if (dcl) { // C99 6.5.3.2p1
4508     // We have an lvalue with a decl. Make sure the decl is not declared
4509     // with the register storage-class specifier.
4510     if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
4511       if (vd->getStorageClass() == VarDecl::Register) {
4512         Diag(OpLoc, diag::err_typecheck_address_of)
4513           << "register variable" << op->getSourceRange();
4514         return QualType();
4515       }
4516     } else if (isa<OverloadedFunctionDecl>(dcl)) {
4517       return Context.OverloadTy;
4518     } else if (isa<FieldDecl>(dcl)) {
4519       // Okay: we can take the address of a field.
4520       // Could be a pointer to member, though, if there is an explicit
4521       // scope qualifier for the class.
4522       if (isa<QualifiedDeclRefExpr>(op)) {
4523         DeclContext *Ctx = dcl->getDeclContext();
4524         if (Ctx && Ctx->isRecord())
4525           return Context.getMemberPointerType(op->getType(),
4526                 Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr());
4527       }
4528     } else if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(dcl)) {
4529       // Okay: we can take the address of a function.
4530       // As above.
4531       if (isa<QualifiedDeclRefExpr>(op) && MD->isInstance())
4532         return Context.getMemberPointerType(op->getType(),
4533               Context.getTypeDeclType(MD->getParent()).getTypePtr());
4534     } else if (!isa<FunctionDecl>(dcl))
4535       assert(0 && "Unknown/unexpected decl type");
4536   }
4537
4538   if (lval == Expr::LV_IncompleteVoidType) {
4539     // Taking the address of a void variable is technically illegal, but we
4540     // allow it in cases which are otherwise valid.
4541     // Example: "extern void x; void* y = &x;".
4542     Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange();
4543   }
4544
4545   // If the operand has type "type", the result has type "pointer to type".
4546   return Context.getPointerType(op->getType());
4547 }
4548
4549 QualType Sema::CheckIndirectionOperand(Expr *Op, SourceLocation OpLoc) {
4550   if (Op->isTypeDependent())
4551     return Context.DependentTy;
4552
4553   UsualUnaryConversions(Op);
4554   QualType Ty = Op->getType();
4555
4556   // Note that per both C89 and C99, this is always legal, even if ptype is an
4557   // incomplete type or void.  It would be possible to warn about dereferencing
4558   // a void pointer, but it's completely well-defined, and such a warning is
4559   // unlikely to catch any mistakes.
4560   if (const PointerType *PT = Ty->getAsPointerType())
4561     return PT->getPointeeType();
4562
4563   Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
4564     << Ty << Op->getSourceRange();
4565   return QualType();
4566 }
4567
4568 static inline BinaryOperator::Opcode ConvertTokenKindToBinaryOpcode(
4569   tok::TokenKind Kind) {
4570   BinaryOperator::Opcode Opc;
4571   switch (Kind) {
4572   default: assert(0 && "Unknown binop!");
4573   case tok::periodstar:           Opc = BinaryOperator::PtrMemD; break;
4574   case tok::arrowstar:            Opc = BinaryOperator::PtrMemI; break;
4575   case tok::star:                 Opc = BinaryOperator::Mul; break;
4576   case tok::slash:                Opc = BinaryOperator::Div; break;
4577   case tok::percent:              Opc = BinaryOperator::Rem; break;
4578   case tok::plus:                 Opc = BinaryOperator::Add; break;
4579   case tok::minus:                Opc = BinaryOperator::Sub; break;
4580   case tok::lessless:             Opc = BinaryOperator::Shl; break;
4581   case tok::greatergreater:       Opc = BinaryOperator::Shr; break;
4582   case tok::lessequal:            Opc = BinaryOperator::LE; break;
4583   case tok::less:                 Opc = BinaryOperator::LT; break;
4584   case tok::greaterequal:         Opc = BinaryOperator::GE; break;
4585   case tok::greater:              Opc = BinaryOperator::GT; break;
4586   case tok::exclaimequal:         Opc = BinaryOperator::NE; break;
4587   case tok::equalequal:           Opc = BinaryOperator::EQ; break;
4588   case tok::amp:                  Opc = BinaryOperator::And; break;
4589   case tok::caret:                Opc = BinaryOperator::Xor; break;
4590   case tok::pipe:                 Opc = BinaryOperator::Or; break;
4591   case tok::ampamp:               Opc = BinaryOperator::LAnd; break;
4592   case tok::pipepipe:             Opc = BinaryOperator::LOr; break;
4593   case tok::equal:                Opc = BinaryOperator::Assign; break;
4594   case tok::starequal:            Opc = BinaryOperator::MulAssign; break;
4595   case tok::slashequal:           Opc = BinaryOperator::DivAssign; break;
4596   case tok::percentequal:         Opc = BinaryOperator::RemAssign; break;
4597   case tok::plusequal:            Opc = BinaryOperator::AddAssign; break;
4598   case tok::minusequal:           Opc = BinaryOperator::SubAssign; break;
4599   case tok::lesslessequal:        Opc = BinaryOperator::ShlAssign; break;
4600   case tok::greatergreaterequal:  Opc = BinaryOperator::ShrAssign; break;
4601   case tok::ampequal:             Opc = BinaryOperator::AndAssign; break;
4602   case tok::caretequal:           Opc = BinaryOperator::XorAssign; break;
4603   case tok::pipeequal:            Opc = BinaryOperator::OrAssign; break;
4604   case tok::comma:                Opc = BinaryOperator::Comma; break;
4605   }
4606   return Opc;
4607 }
4608
4609 static inline UnaryOperator::Opcode ConvertTokenKindToUnaryOpcode(
4610   tok::TokenKind Kind) {
4611   UnaryOperator::Opcode Opc;
4612   switch (Kind) {
4613   default: assert(0 && "Unknown unary op!");
4614   case tok::plusplus:     Opc = UnaryOperator::PreInc; break;
4615   case tok::minusminus:   Opc = UnaryOperator::PreDec; break;
4616   case tok::amp:          Opc = UnaryOperator::AddrOf; break;
4617   case tok::star:         Opc = UnaryOperator::Deref; break;
4618   case tok::plus:         Opc = UnaryOperator::Plus; break;
4619   case tok::minus:        Opc = UnaryOperator::Minus; break;
4620   case tok::tilde:        Opc = UnaryOperator::Not; break;
4621   case tok::exclaim:      Opc = UnaryOperator::LNot; break;
4622   case tok::kw___real:    Opc = UnaryOperator::Real; break;
4623   case tok::kw___imag:    Opc = UnaryOperator::Imag; break;
4624   case tok::kw___extension__: Opc = UnaryOperator::Extension; break;
4625   }
4626   return Opc;
4627 }
4628
4629 /// CreateBuiltinBinOp - Creates a new built-in binary operation with
4630 /// operator @p Opc at location @c TokLoc. This routine only supports
4631 /// built-in operations; ActOnBinOp handles overloaded operators.
4632 Action::OwningExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
4633                                                   unsigned Op,
4634                                                   Expr *lhs, Expr *rhs) {
4635   QualType ResultTy;     // Result type of the binary operator.
4636   BinaryOperator::Opcode Opc = (BinaryOperator::Opcode)Op;
4637   // The following two variables are used for compound assignment operators
4638   QualType CompLHSTy;    // Type of LHS after promotions for computation
4639   QualType CompResultTy; // Type of computation result
4640
4641   switch (Opc) {
4642   case BinaryOperator::Assign:
4643     ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, QualType());
4644     break;
4645   case BinaryOperator::PtrMemD:
4646   case BinaryOperator::PtrMemI:
4647     ResultTy = CheckPointerToMemberOperands(lhs, rhs, OpLoc,
4648                                             Opc == BinaryOperator::PtrMemI);
4649     break;
4650   case BinaryOperator::Mul:
4651   case BinaryOperator::Div:
4652     ResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc);
4653     break;
4654   case BinaryOperator::Rem:
4655     ResultTy = CheckRemainderOperands(lhs, rhs, OpLoc);
4656     break;
4657   case BinaryOperator::Add:
4658     ResultTy = CheckAdditionOperands(lhs, rhs, OpLoc);
4659     break;
4660   case BinaryOperator::Sub:
4661     ResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc);
4662     break;
4663   case BinaryOperator::Shl:
4664   case BinaryOperator::Shr:
4665     ResultTy = CheckShiftOperands(lhs, rhs, OpLoc);
4666     break;
4667   case BinaryOperator::LE:
4668   case BinaryOperator::LT:
4669   case BinaryOperator::GE:
4670   case BinaryOperator::GT:
4671     ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, true);
4672     break;
4673   case BinaryOperator::EQ:
4674   case BinaryOperator::NE:
4675     ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, false);
4676     break;
4677   case BinaryOperator::And:
4678   case BinaryOperator::Xor:
4679   case BinaryOperator::Or:
4680     ResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc);
4681     break;
4682   case BinaryOperator::LAnd:
4683   case BinaryOperator::LOr:
4684     ResultTy = CheckLogicalOperands(lhs, rhs, OpLoc);
4685     break;
4686   case BinaryOperator::MulAssign:
4687   case BinaryOperator::DivAssign:
4688     CompResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc, true);
4689     CompLHSTy = CompResultTy;
4690     if (!CompResultTy.isNull())
4691       ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4692     break;
4693   case BinaryOperator::RemAssign:
4694     CompResultTy = CheckRemainderOperands(lhs, rhs, OpLoc, true);
4695     CompLHSTy = CompResultTy;
4696     if (!CompResultTy.isNull())
4697       ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4698     break;
4699   case BinaryOperator::AddAssign:
4700     CompResultTy = CheckAdditionOperands(lhs, rhs, OpLoc, &CompLHSTy);
4701     if (!CompResultTy.isNull())
4702       ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4703     break;
4704   case BinaryOperator::SubAssign:
4705     CompResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc, &CompLHSTy);
4706     if (!CompResultTy.isNull())
4707       ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4708     break;
4709   case BinaryOperator::ShlAssign:
4710   case BinaryOperator::ShrAssign:
4711     CompResultTy = CheckShiftOperands(lhs, rhs, OpLoc, true);
4712     CompLHSTy = CompResultTy;
4713     if (!CompResultTy.isNull())
4714       ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4715     break;
4716   case BinaryOperator::AndAssign:
4717   case BinaryOperator::XorAssign:
4718   case BinaryOperator::OrAssign:
4719     CompResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc, true);
4720     CompLHSTy = CompResultTy;
4721     if (!CompResultTy.isNull())
4722       ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4723     break;
4724   case BinaryOperator::Comma:
4725     ResultTy = CheckCommaOperands(lhs, rhs, OpLoc);
4726     break;
4727   }
4728   if (ResultTy.isNull())
4729     return ExprError();
4730   if (CompResultTy.isNull())
4731     return Owned(new (Context) BinaryOperator(lhs, rhs, Opc, ResultTy, OpLoc));
4732   else
4733     return Owned(new (Context) CompoundAssignOperator(lhs, rhs, Opc, ResultTy,
4734                                                       CompLHSTy, CompResultTy,
4735                                                       OpLoc));
4736 }
4737
4738 // Binary Operators.  'Tok' is the token for the operator.
4739 Action::OwningExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
4740                                           tok::TokenKind Kind,
4741                                           ExprArg LHS, ExprArg RHS) {
4742   BinaryOperator::Opcode Opc = ConvertTokenKindToBinaryOpcode(Kind);
4743   Expr *lhs = LHS.takeAs<Expr>(), *rhs = RHS.takeAs<Expr>();
4744
4745   assert((lhs != 0) && "ActOnBinOp(): missing left expression");
4746   assert((rhs != 0) && "ActOnBinOp(): missing right expression");
4747
4748   if (getLangOptions().CPlusPlus &&
4749       (lhs->getType()->isOverloadableType() ||
4750        rhs->getType()->isOverloadableType())) {
4751     // Find all of the overloaded operators visible from this
4752     // point. We perform both an operator-name lookup from the local
4753     // scope and an argument-dependent lookup based on the types of
4754     // the arguments.
4755     FunctionSet Functions;
4756     OverloadedOperatorKind OverOp = BinaryOperator::getOverloadedOperator(Opc);
4757     if (OverOp != OO_None) {
4758       LookupOverloadedOperatorName(OverOp, S, lhs->getType(), rhs->getType(),
4759                                    Functions);
4760       Expr *Args[2] = { lhs, rhs };
4761       DeclarationName OpName
4762         = Context.DeclarationNames.getCXXOperatorName(OverOp);
4763       ArgumentDependentLookup(OpName, Args, 2, Functions);
4764     }
4765
4766     // Build the (potentially-overloaded, potentially-dependent)
4767     // binary operation.
4768     return CreateOverloadedBinOp(TokLoc, Opc, Functions, lhs, rhs);
4769   }
4770
4771   // Build a built-in binary operation.
4772   return CreateBuiltinBinOp(TokLoc, Opc, lhs, rhs);
4773 }
4774
4775 Action::OwningExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
4776                                                     unsigned OpcIn,
4777                                                     ExprArg InputArg) {
4778   UnaryOperator::Opcode Opc = static_cast<UnaryOperator::Opcode>(OpcIn);
4779
4780   // FIXME: Input is modified below, but InputArg is not updated appropriately.
4781   Expr *Input = (Expr *)InputArg.get();
4782   QualType resultType;
4783   switch (Opc) {
4784   case UnaryOperator::PostInc:
4785   case UnaryOperator::PostDec:
4786   case UnaryOperator::OffsetOf:
4787     assert(false && "Invalid unary operator");
4788     break;
4789
4790   case UnaryOperator::PreInc:
4791   case UnaryOperator::PreDec:
4792     resultType = CheckIncrementDecrementOperand(Input, OpLoc,
4793                                                 Opc == UnaryOperator::PreInc);
4794     break;
4795   case UnaryOperator::AddrOf:
4796     resultType = CheckAddressOfOperand(Input, OpLoc);
4797     break;
4798   case UnaryOperator::Deref:
4799     DefaultFunctionArrayConversion(Input);
4800     resultType = CheckIndirectionOperand(Input, OpLoc);
4801     break;
4802   case UnaryOperator::Plus:
4803   case UnaryOperator::Minus:
4804     UsualUnaryConversions(Input);
4805     resultType = Input->getType();
4806     if (resultType->isDependentType())
4807       break;
4808     if (resultType->isArithmeticType()) // C99 6.5.3.3p1
4809       break;
4810     else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6-7
4811              resultType->isEnumeralType())
4812       break;
4813     else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6
4814              Opc == UnaryOperator::Plus &&
4815              resultType->isPointerType())
4816       break;
4817
4818     return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
4819       << resultType << Input->getSourceRange());
4820   case UnaryOperator::Not: // bitwise complement
4821     UsualUnaryConversions(Input);
4822     resultType = Input->getType();
4823     if (resultType->isDependentType())
4824       break;
4825     // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.
4826     if (resultType->isComplexType() || resultType->isComplexIntegerType())
4827       // C99 does not support '~' for complex conjugation.
4828       Diag(OpLoc, diag::ext_integer_complement_complex)
4829         << resultType << Input->getSourceRange();
4830     else if (!resultType->isIntegerType())
4831       return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
4832         << resultType << Input->getSourceRange());
4833     break;
4834   case UnaryOperator::LNot: // logical negation
4835     // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5).
4836     DefaultFunctionArrayConversion(Input);
4837     resultType = Input->getType();
4838     if (resultType->isDependentType())
4839       break;
4840     if (!resultType->isScalarType()) // C99 6.5.3.3p1
4841       return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
4842         << resultType << Input->getSourceRange());
4843     // LNot always has type int. C99 6.5.3.3p5.
4844     // In C++, it's bool. C++ 5.3.1p8
4845     resultType = getLangOptions().CPlusPlus ? Context.BoolTy : Context.IntTy;
4846     break;
4847   case UnaryOperator::Real:
4848   case UnaryOperator::Imag:
4849     resultType = CheckRealImagOperand(Input, OpLoc, Opc == UnaryOperator::Real);
4850     break;
4851   case UnaryOperator::Extension:
4852     resultType = Input->getType();
4853     break;
4854   }
4855   if (resultType.isNull())
4856     return ExprError();
4857
4858   InputArg.release();
4859   return Owned(new (Context) UnaryOperator(Input, Opc, resultType, OpLoc));
4860 }
4861
4862 // Unary Operators.  'Tok' is the token for the operator.
4863 Action::OwningExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
4864                                             tok::TokenKind Op, ExprArg input) {
4865   Expr *Input = (Expr*)input.get();
4866   UnaryOperator::Opcode Opc = ConvertTokenKindToUnaryOpcode(Op);
4867
4868   if (getLangOptions().CPlusPlus && Input->getType()->isOverloadableType()) {
4869     // Find all of the overloaded operators visible from this
4870     // point. We perform both an operator-name lookup from the local
4871     // scope and an argument-dependent lookup based on the types of
4872     // the arguments.
4873     FunctionSet Functions;
4874     OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc);
4875     if (OverOp != OO_None) {
4876       LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(),
4877                                    Functions);
4878       DeclarationName OpName
4879         = Context.DeclarationNames.getCXXOperatorName(OverOp);
4880       ArgumentDependentLookup(OpName, &Input, 1, Functions);
4881     }
4882
4883     return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(input));
4884   }
4885
4886   return CreateBuiltinUnaryOp(OpLoc, Opc, move(input));
4887 }
4888
4889 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
4890 Sema::OwningExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc,
4891                                             SourceLocation LabLoc,
4892                                             IdentifierInfo *LabelII) {
4893   // Look up the record for this label identifier.
4894   LabelStmt *&LabelDecl = getLabelMap()[LabelII];
4895
4896   // If we haven't seen this label yet, create a forward reference. It
4897   // will be validated and/or cleaned up in ActOnFinishFunctionBody.
4898   if (LabelDecl == 0)
4899     LabelDecl = new (Context) LabelStmt(LabLoc, LabelII, 0);
4900
4901   // Create the AST node.  The address of a label always has type 'void*'.
4902   return Owned(new (Context) AddrLabelExpr(OpLoc, LabLoc, LabelDecl,
4903                                        Context.getPointerType(Context.VoidTy)));
4904 }
4905
4906 Sema::OwningExprResult
4907 Sema::ActOnStmtExpr(SourceLocation LPLoc, StmtArg substmt,
4908                     SourceLocation RPLoc) { // "({..})"
4909   Stmt *SubStmt = static_cast<Stmt*>(substmt.get());
4910   assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!");
4911   CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);
4912
4913   bool isFileScope = getCurFunctionOrMethodDecl() == 0;
4914   if (isFileScope)
4915     return ExprError(Diag(LPLoc, diag::err_stmtexpr_file_scope));
4916
4917   // FIXME: there are a variety of strange constraints to enforce here, for
4918   // example, it is not possible to goto into a stmt expression apparently.
4919   // More semantic analysis is needed.
4920
4921   // If there are sub stmts in the compound stmt, take the type of the last one
4922   // as the type of the stmtexpr.
4923   QualType Ty = Context.VoidTy;
4924
4925   if (!Compound->body_empty()) {
4926     Stmt *LastStmt = Compound->body_back();
4927     // If LastStmt is a label, skip down through into the body.
4928     while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt))
4929       LastStmt = Label->getSubStmt();
4930
4931     if (Expr *LastExpr = dyn_cast<Expr>(LastStmt))
4932       Ty = LastExpr->getType();
4933   }
4934
4935   // FIXME: Check that expression type is complete/non-abstract; statement
4936   // expressions are not lvalues.
4937
4938   substmt.release();
4939   return Owned(new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc));
4940 }
4941
4942 Sema::OwningExprResult Sema::ActOnBuiltinOffsetOf(Scope *S,
4943                                                   SourceLocation BuiltinLoc,
4944                                                   SourceLocation TypeLoc,
4945                                                   TypeTy *argty,
4946                                                   OffsetOfComponent *CompPtr,
4947                                                   unsigned NumComponents,
4948                                                   SourceLocation RPLoc) {
4949   // FIXME: This function leaks all expressions in the offset components on
4950   // error.
4951   QualType ArgTy = QualType::getFromOpaquePtr(argty);
4952   assert(!ArgTy.isNull() && "Missing type argument!");
4953
4954   bool Dependent = ArgTy->isDependentType();
4955
4956   // We must have at least one component that refers to the type, and the first
4957   // one is known to be a field designator.  Verify that the ArgTy represents
4958   // a struct/union/class.
4959   if (!Dependent && !ArgTy->isRecordType())
4960     return ExprError(Diag(TypeLoc, diag::err_offsetof_record_type) << ArgTy);
4961
4962   // FIXME: Type must be complete per C99 7.17p3 because a declaring a variable
4963   // with an incomplete type would be illegal.
4964
4965   // Otherwise, create a null pointer as the base, and iteratively process
4966   // the offsetof designators.
4967   QualType ArgTyPtr = Context.getPointerType(ArgTy);
4968   Expr* Res = new (Context) ImplicitValueInitExpr(ArgTyPtr);
4969   Res = new (Context) UnaryOperator(Res, UnaryOperator::Deref,
4970                                     ArgTy, SourceLocation());
4971
4972   // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a
4973   // GCC extension, diagnose them.
4974   // FIXME: This diagnostic isn't actually visible because the location is in
4975   // a system header!
4976   if (NumComponents != 1)
4977     Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator)
4978       << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd);
4979
4980   if (!Dependent) {
4981     bool DidWarnAboutNonPOD = false;
4982
4983     // FIXME: Dependent case loses a lot of information here. And probably
4984     // leaks like a sieve.
4985     for (unsigned i = 0; i != NumComponents; ++i) {
4986       const OffsetOfComponent &OC = CompPtr[i];
4987       if (OC.isBrackets) {
4988         // Offset of an array sub-field.  TODO: Should we allow vector elements?
4989         const ArrayType *AT = Context.getAsArrayType(Res->getType());
4990         if (!AT) {
4991           Res->Destroy(Context);
4992           return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type)
4993             << Res->getType());
4994         }
4995
4996         // FIXME: C++: Verify that operator[] isn't overloaded.
4997
4998         // Promote the array so it looks more like a normal array subscript
4999         // expression.
5000         DefaultFunctionArrayConversion(Res);
5001
5002         // C99 6.5.2.1p1
5003         Expr *Idx = static_cast<Expr*>(OC.U.E);
5004         // FIXME: Leaks Res
5005         if (!Idx->isTypeDependent() && !Idx->getType()->isIntegerType())
5006           return ExprError(Diag(Idx->getLocStart(),
5007                                 diag::err_typecheck_subscript_not_integer)
5008             << Idx->getSourceRange());
5009
5010         Res = new (Context) ArraySubscriptExpr(Res, Idx, AT->getElementType(),
5011                                                OC.LocEnd);
5012         continue;
5013       }
5014
5015       const RecordType *RC = Res->getType()->getAsRecordType();
5016       if (!RC) {
5017         Res->Destroy(Context);
5018         return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type)
5019           << Res->getType());
5020       }
5021
5022       // Get the decl corresponding to this.
5023       RecordDecl *RD = RC->getDecl();
5024       if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
5025         if (!CRD->isPOD() && !DidWarnAboutNonPOD) {
5026           ExprError(Diag(BuiltinLoc, diag::warn_offsetof_non_pod_type)
5027             << SourceRange(CompPtr[0].LocStart, OC.LocEnd)
5028             << Res->getType());
5029           DidWarnAboutNonPOD = true;
5030         }
5031       }
5032
5033       FieldDecl *MemberDecl
5034         = dyn_cast_or_null<FieldDecl>(LookupQualifiedName(RD, OC.U.IdentInfo,
5035                                                           LookupMemberName)
5036                                         .getAsDecl());
5037       // FIXME: Leaks Res
5038       if (!MemberDecl)
5039         return ExprError(Diag(BuiltinLoc, diag::err_typecheck_no_member)
5040          << OC.U.IdentInfo << SourceRange(OC.LocStart, OC.LocEnd));
5041
5042       // FIXME: C++: Verify that MemberDecl isn't a static field.
5043       // FIXME: Verify that MemberDecl isn't a bitfield.
5044       if (cast<RecordDecl>(MemberDecl->getDeclContext())->isAnonymousStructOrUnion()) {
5045         Res = BuildAnonymousStructUnionMemberReference(
5046             SourceLocation(), MemberDecl, Res, SourceLocation()).takeAs<Expr>();
5047       } else {
5048         // MemberDecl->getType() doesn't get the right qualifiers, but it
5049         // doesn't matter here.
5050         Res = new (Context) MemberExpr(Res, false, MemberDecl, OC.LocEnd,
5051                 MemberDecl->getType().getNonReferenceType());
5052       }
5053     }
5054   }
5055
5056   return Owned(new (Context) UnaryOperator(Res, UnaryOperator::OffsetOf,
5057                                            Context.getSizeType(), BuiltinLoc));
5058 }
5059
5060
5061 Sema::OwningExprResult Sema::ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
5062                                                       TypeTy *arg1,TypeTy *arg2,
5063                                                       SourceLocation RPLoc) {
5064   QualType argT1 = QualType::getFromOpaquePtr(arg1);
5065   QualType argT2 = QualType::getFromOpaquePtr(arg2);
5066
5067   assert((!argT1.isNull() && !argT2.isNull()) && "Missing type argument(s)");
5068
5069   if (getLangOptions().CPlusPlus) {
5070     Diag(BuiltinLoc, diag::err_types_compatible_p_in_cplusplus)
5071       << SourceRange(BuiltinLoc, RPLoc);
5072     return ExprError();
5073   }
5074
5075   return Owned(new (Context) TypesCompatibleExpr(Context.IntTy, BuiltinLoc,
5076                                                  argT1, argT2, RPLoc));
5077 }
5078
5079 Sema::OwningExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc,
5080                                              ExprArg cond,
5081                                              ExprArg expr1, ExprArg expr2,
5082                                              SourceLocation RPLoc) {
5083   Expr *CondExpr = static_cast<Expr*>(cond.get());
5084   Expr *LHSExpr = static_cast<Expr*>(expr1.get());
5085   Expr *RHSExpr = static_cast<Expr*>(expr2.get());
5086
5087   assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
5088
5089   QualType resType;
5090   if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) {
5091     resType = Context.DependentTy;
5092   } else {
5093     // The conditional expression is required to be a constant expression.
5094     llvm::APSInt condEval(32);
5095     SourceLocation ExpLoc;
5096     if (!CondExpr->isIntegerConstantExpr(condEval, Context, &ExpLoc))
5097       return ExprError(Diag(ExpLoc,
5098                        diag::err_typecheck_choose_expr_requires_constant)
5099         << CondExpr->getSourceRange());
5100
5101     // If the condition is > zero, then the AST type is the same as the LSHExpr.
5102     resType = condEval.getZExtValue() ? LHSExpr->getType() : RHSExpr->getType();
5103   }
5104
5105   cond.release(); expr1.release(); expr2.release();
5106   return Owned(new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr,
5107                                         resType, RPLoc));
5108 }
5109
5110 //===----------------------------------------------------------------------===//
5111 // Clang Extensions.
5112 //===----------------------------------------------------------------------===//
5113
5114 /// ActOnBlockStart - This callback is invoked when a block literal is started.
5115 void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *BlockScope) {
5116   // Analyze block parameters.
5117   BlockSemaInfo *BSI = new BlockSemaInfo();
5118
5119   // Add BSI to CurBlock.
5120   BSI->PrevBlockInfo = CurBlock;
5121   CurBlock = BSI;
5122
5123   BSI->ReturnType = QualType();
5124   BSI->TheScope = BlockScope;
5125   BSI->hasBlockDeclRefExprs = false;
5126   BSI->SavedFunctionNeedsScopeChecking = CurFunctionNeedsScopeChecking;
5127   CurFunctionNeedsScopeChecking = false;
5128
5129   BSI->TheDecl = BlockDecl::Create(Context, CurContext, CaretLoc);
5130   PushDeclContext(BlockScope, BSI->TheDecl);
5131 }
5132
5133 void Sema::ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope) {
5134   assert(ParamInfo.getIdentifier()==0 && "block-id should have no identifier!");
5135
5136   if (ParamInfo.getNumTypeObjects() == 0
5137       || ParamInfo.getTypeObject(0).Kind != DeclaratorChunk::Function) {
5138     ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
5139     QualType T = GetTypeForDeclarator(ParamInfo, CurScope);
5140
5141     if (T->isArrayType()) {
5142       Diag(ParamInfo.getSourceRange().getBegin(),
5143            diag::err_block_returns_array);
5144       return;
5145     }
5146
5147     // The parameter list is optional, if there was none, assume ().
5148     if (!T->isFunctionType())
5149       T = Context.getFunctionType(T, NULL, 0, 0, 0);
5150
5151     CurBlock->hasPrototype = true;
5152     CurBlock->isVariadic = false;
5153     // Check for a valid sentinel attribute on this block.
5154     if (CurBlock->TheDecl->getAttr<SentinelAttr>(Context)) {
5155       Diag(ParamInfo.getAttributes()->getLoc(),
5156            diag::warn_attribute_sentinel_not_variadic) << 1;
5157       // FIXME: remove the attribute.
5158     }
5159     QualType RetTy = T.getTypePtr()->getAsFunctionType()->getResultType();
5160
5161     // Do not allow returning a objc interface by-value.
5162     if (RetTy->isObjCInterfaceType()) {
5163       Diag(ParamInfo.getSourceRange().getBegin(),
5164            diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy;
5165       return;
5166     }
5167     return;
5168   }
5169
5170   // Analyze arguments to block.
5171   assert(ParamInfo.getTypeObject(0).Kind == DeclaratorChunk::Function &&
5172          "Not a function declarator!");
5173   DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getTypeObject(0).Fun;
5174
5175   CurBlock->hasPrototype = FTI.hasPrototype;
5176   CurBlock->isVariadic = true;
5177
5178   // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs function that takes
5179   // no arguments, not a function that takes a single void argument.
5180   if (FTI.hasPrototype &&
5181       FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
5182      (!FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType().getCVRQualifiers()&&
5183         FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType())) {
5184     // empty arg list, don't push any params.
5185     CurBlock->isVariadic = false;
5186   } else if (FTI.hasPrototype) {
5187     for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i)
5188       CurBlock->Params.push_back(FTI.ArgInfo[i].Param.getAs<ParmVarDecl>());
5189     CurBlock->isVariadic = FTI.isVariadic;
5190   }
5191   CurBlock->TheDecl->setParams(Context, CurBlock->Params.data(),
5192                                CurBlock->Params.size());
5193   CurBlock->TheDecl->setIsVariadic(CurBlock->isVariadic);
5194   ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
5195   for (BlockDecl::param_iterator AI = CurBlock->TheDecl->param_begin(),
5196        E = CurBlock->TheDecl->param_end(); AI != E; ++AI)
5197     // If this has an identifier, add it to the scope stack.
5198     if ((*AI)->getIdentifier())
5199       PushOnScopeChains(*AI, CurBlock->TheScope);
5200
5201   // Check for a valid sentinel attribute on this block.
5202   if (!CurBlock->isVariadic &&
5203       CurBlock->TheDecl->getAttr<SentinelAttr>(Context)) {
5204     Diag(ParamInfo.getAttributes()->getLoc(),
5205          diag::warn_attribute_sentinel_not_variadic) << 1;
5206     // FIXME: remove the attribute.
5207   }
5208
5209   // Analyze the return type.
5210   QualType T = GetTypeForDeclarator(ParamInfo, CurScope);
5211   QualType RetTy = T->getAsFunctionType()->getResultType();
5212
5213   // Do not allow returning a objc interface by-value.
5214   if (RetTy->isObjCInterfaceType()) {
5215     Diag(ParamInfo.getSourceRange().getBegin(),
5216          diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy;
5217   } else if (!RetTy->isDependentType())
5218     CurBlock->ReturnType = RetTy;
5219 }
5220
5221 /// ActOnBlockError - If there is an error parsing a block, this callback
5222 /// is invoked to pop the information about the block from the action impl.
5223 void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
5224   // Ensure that CurBlock is deleted.
5225   llvm::OwningPtr<BlockSemaInfo> CC(CurBlock);
5226
5227   CurFunctionNeedsScopeChecking = CurBlock->SavedFunctionNeedsScopeChecking;
5228
5229   // Pop off CurBlock, handle nested blocks.
5230   PopDeclContext();
5231   CurBlock = CurBlock->PrevBlockInfo;
5232   // FIXME: Delete the ParmVarDecl objects as well???
5233 }
5234
5235 /// ActOnBlockStmtExpr - This is called when the body of a block statement
5236 /// literal was successfully completed.  ^(int x){...}
5237 Sema::OwningExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
5238                                                 StmtArg body, Scope *CurScope) {
5239   // If blocks are disabled, emit an error.
5240   if (!LangOpts.Blocks)
5241     Diag(CaretLoc, diag::err_blocks_disable);
5242
5243   // Ensure that CurBlock is deleted.
5244   llvm::OwningPtr<BlockSemaInfo> BSI(CurBlock);
5245
5246   PopDeclContext();
5247
5248   // Pop off CurBlock, handle nested blocks.
5249   CurBlock = CurBlock->PrevBlockInfo;
5250
5251   QualType RetTy = Context.VoidTy;
5252   if (!BSI->ReturnType.isNull())
5253     RetTy = BSI->ReturnType;
5254
5255   llvm::SmallVector<QualType, 8> ArgTypes;
5256   for (unsigned i = 0, e = BSI->Params.size(); i != e; ++i)
5257     ArgTypes.push_back(BSI->Params[i]->getType());
5258
5259   QualType BlockTy;
5260   if (!BSI->hasPrototype)
5261     BlockTy = Context.getFunctionType(RetTy, 0, 0, false, 0);
5262   else
5263     BlockTy = Context.getFunctionType(RetTy, ArgTypes.data(), ArgTypes.size(),
5264                                       BSI->isVariadic, 0);
5265
5266   // FIXME: Check that return/parameter types are complete/non-abstract
5267   DiagnoseUnusedParameters(BSI->Params.begin(), BSI->Params.end());
5268   BlockTy = Context.getBlockPointerType(BlockTy);
5269
5270   // If needed, diagnose invalid gotos and switches in the block.
5271   if (CurFunctionNeedsScopeChecking)
5272     DiagnoseInvalidJumps(static_cast<CompoundStmt*>(body.get()));
5273   CurFunctionNeedsScopeChecking = BSI->SavedFunctionNeedsScopeChecking;
5274
5275   BSI->TheDecl->setBody(body.takeAs<CompoundStmt>());
5276   return Owned(new (Context) BlockExpr(BSI->TheDecl, BlockTy,
5277                                        BSI->hasBlockDeclRefExprs));
5278 }
5279
5280 Sema::OwningExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc,
5281                                         ExprArg expr, TypeTy *type,
5282                                         SourceLocation RPLoc) {
5283   QualType T = QualType::getFromOpaquePtr(type);
5284   Expr *E = static_cast<Expr*>(expr.get());
5285   Expr *OrigExpr = E;
5286
5287   InitBuiltinVaListType();
5288
5289   // Get the va_list type
5290   QualType VaListType = Context.getBuiltinVaListType();
5291   if (VaListType->isArrayType()) {
5292     // Deal with implicit array decay; for example, on x86-64,
5293     // va_list is an array, but it's supposed to decay to
5294     // a pointer for va_arg.
5295     VaListType = Context.getArrayDecayedType(VaListType);
5296     // Make sure the input expression also decays appropriately.
5297     UsualUnaryConversions(E);
5298   } else {
5299     // Otherwise, the va_list argument must be an l-value because
5300     // it is modified by va_arg.
5301     if (!E->isTypeDependent() &&
5302         CheckForModifiableLvalue(E, BuiltinLoc, *this))
5303       return ExprError();
5304   }
5305
5306   if (!E->isTypeDependent() &&
5307       !Context.hasSameType(VaListType, E->getType())) {
5308     return ExprError(Diag(E->getLocStart(),
5309                          diag::err_first_argument_to_va_arg_not_of_type_va_list)
5310       << OrigExpr->getType() << E->getSourceRange());
5311   }
5312
5313   // FIXME: Check that type is complete/non-abstract
5314   // FIXME: Warn if a non-POD type is passed in.
5315
5316   expr.release();
5317   return Owned(new (Context) VAArgExpr(BuiltinLoc, E, T.getNonReferenceType(),
5318                                        RPLoc));
5319 }
5320
5321 Sema::OwningExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) {
5322   // The type of __null will be int or long, depending on the size of
5323   // pointers on the target.
5324   QualType Ty;
5325   if (Context.Target.getPointerWidth(0) == Context.Target.getIntWidth())
5326     Ty = Context.IntTy;
5327   else
5328     Ty = Context.LongTy;
5329
5330   return Owned(new (Context) GNUNullExpr(Ty, TokenLoc));
5331 }
5332
5333 bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
5334                                     SourceLocation Loc,
5335                                     QualType DstType, QualType SrcType,
5336                                     Expr *SrcExpr, const char *Flavor) {
5337   // Decode the result (notice that AST's are still created for extensions).
5338   bool isInvalid = false;
5339   unsigned DiagKind;
5340   switch (ConvTy) {
5341   default: assert(0 && "Unknown conversion type");
5342   case Compatible: return false;
5343   case PointerToInt:
5344     DiagKind = diag::ext_typecheck_convert_pointer_int;
5345     break;
5346   case IntToPointer:
5347     DiagKind = diag::ext_typecheck_convert_int_pointer;
5348     break;
5349   case IncompatiblePointer:
5350     DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
5351     break;
5352   case IncompatiblePointerSign:
5353     DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
5354     break;
5355   case FunctionVoidPointer:
5356     DiagKind = diag::ext_typecheck_convert_pointer_void_func;
5357     break;
5358   case CompatiblePointerDiscardsQualifiers:
5359     // If the qualifiers lost were because we were applying the
5360     // (deprecated) C++ conversion from a string literal to a char*
5361     // (or wchar_t*), then there was no error (C++ 4.2p2).  FIXME:
5362     // Ideally, this check would be performed in
5363     // CheckPointerTypesForAssignment. However, that would require a
5364     // bit of refactoring (so that the second argument is an
5365     // expression, rather than a type), which should be done as part
5366     // of a larger effort to fix CheckPointerTypesForAssignment for
5367     // C++ semantics.
5368     if (getLangOptions().CPlusPlus &&
5369         IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
5370       return false;
5371     DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
5372     break;
5373   case IntToBlockPointer:
5374     DiagKind = diag::err_int_to_block_pointer;
5375     break;
5376   case IncompatibleBlockPointer:
5377     DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
5378     break;
5379   case IncompatibleObjCQualifiedId:
5380     // FIXME: Diagnose the problem in ObjCQualifiedIdTypesAreCompatible, since
5381     // it can give a more specific diagnostic.
5382     DiagKind = diag::warn_incompatible_qualified_id;
5383     break;
5384   case IncompatibleVectors:
5385     DiagKind = diag::warn_incompatible_vectors;
5386     break;
5387   case Incompatible:
5388     DiagKind = diag::err_typecheck_convert_incompatible;
5389     isInvalid = true;
5390     break;
5391   }
5392
5393   Diag(Loc, DiagKind) << DstType << SrcType << Flavor
5394     << SrcExpr->getSourceRange();
5395   return isInvalid;
5396 }
5397
5398 bool Sema::VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result){
5399   llvm::APSInt ICEResult;
5400   if (E->isIntegerConstantExpr(ICEResult, Context)) {
5401     if (Result)
5402       *Result = ICEResult;
5403     return false;
5404   }
5405
5406   Expr::EvalResult EvalResult;
5407
5408   if (!E->Evaluate(EvalResult, Context) || !EvalResult.Val.isInt() ||
5409       EvalResult.HasSideEffects) {
5410     Diag(E->getExprLoc(), diag::err_expr_not_ice) << E->getSourceRange();
5411
5412     if (EvalResult.Diag) {
5413       // We only show the note if it's not the usual "invalid subexpression"
5414       // or if it's actually in a subexpression.
5415       if (EvalResult.Diag != diag::note_invalid_subexpr_in_ice ||
5416           E->IgnoreParens() != EvalResult.DiagExpr->IgnoreParens())
5417         Diag(EvalResult.DiagLoc, EvalResult.Diag);
5418     }
5419
5420     return true;
5421   }
5422
5423   Diag(E->getExprLoc(), diag::ext_expr_not_ice) <<
5424     E->getSourceRange();
5425
5426   if (EvalResult.Diag &&
5427       Diags.getDiagnosticLevel(diag::ext_expr_not_ice) != Diagnostic::Ignored)
5428     Diag(EvalResult.DiagLoc, EvalResult.Diag);
5429
5430   if (Result)
5431     *Result = EvalResult.Val.getInt();
5432   return false;
5433 }
5434
5435
5436 /// \brief Note that the given declaration was referenced in the source code.
5437 ///
5438 /// This routine should be invoke whenever a given declaration is referenced
5439 /// in the source code, and where that reference occurred. If this declaration
5440 /// reference means that the the declaration is used (C++ [basic.def.odr]p2,
5441 /// C99 6.9p3), then the declaration will be marked as used.
5442 ///
5443 /// \param Loc the location where the declaration was referenced.
5444 ///
5445 /// \param D the declaration that has been referenced by the source code.
5446 void Sema::MarkDeclarationReferenced(SourceLocation Loc, Decl *D) {
5447   assert(D && "No declaration?");
5448
5449   // Mark a parameter declaration "used", regardless of whether we're in a
5450   // template or not.
5451   if (isa<ParmVarDecl>(D))
5452     D->setUsed(true);
5453
5454   // Do not mark anything as "used" within a dependent context; wait for
5455   // an instantiation.
5456   if (CurContext->isDependentContext())
5457     return;
5458
5459   // If we are in an unevaluated operand, don't mark any definitions as used.
5460   if (InUnevaluatedOperand)
5461     return;
5462
5463   // Note that this declaration has been used.
5464   if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
5465     // FIXME: implicit template instantiation
5466     // FIXME: keep track of references to static functions
5467     (void)Function;
5468     Function->setUsed(true);
5469     return;
5470   }
5471
5472   if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
5473     (void)Var;
5474     // FIXME: implicit template instantiation
5475     // FIXME: keep track of references to static data?
5476     D->setUsed(true);
5477   }
5478 }
5479