SemaExpr.cpp revision cf739927f9b00c801867f620b04b79e3259c311f
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 "clang/Sema/SemaInternal.h" 15#include "clang/Sema/Initialization.h" 16#include "clang/Sema/Lookup.h" 17#include "clang/Sema/AnalysisBasedWarnings.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/ASTMutationListener.h" 20#include "clang/AST/CXXInheritance.h" 21#include "clang/AST/DeclObjC.h" 22#include "clang/AST/DeclTemplate.h" 23#include "clang/AST/EvaluatedExprVisitor.h" 24#include "clang/AST/Expr.h" 25#include "clang/AST/ExprCXX.h" 26#include "clang/AST/ExprObjC.h" 27#include "clang/AST/RecursiveASTVisitor.h" 28#include "clang/AST/TypeLoc.h" 29#include "clang/Basic/PartialDiagnostic.h" 30#include "clang/Basic/SourceManager.h" 31#include "clang/Basic/TargetInfo.h" 32#include "clang/Lex/LiteralSupport.h" 33#include "clang/Lex/Preprocessor.h" 34#include "clang/Sema/DeclSpec.h" 35#include "clang/Sema/Designator.h" 36#include "clang/Sema/Scope.h" 37#include "clang/Sema/ScopeInfo.h" 38#include "clang/Sema/ParsedTemplate.h" 39#include "clang/Sema/Template.h" 40using namespace clang; 41using namespace sema; 42 43 44/// \brief Determine whether the use of this declaration is valid, and 45/// emit any corresponding diagnostics. 46/// 47/// This routine diagnoses various problems with referencing 48/// declarations that can occur when using a declaration. For example, 49/// it might warn if a deprecated or unavailable declaration is being 50/// used, or produce an error (and return true) if a C++0x deleted 51/// function is being used. 52/// 53/// If IgnoreDeprecated is set to true, this should not warn about deprecated 54/// decls. 55/// 56/// \returns true if there was an error (this declaration cannot be 57/// referenced), false otherwise. 58/// 59bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, 60 const ObjCInterfaceDecl *UnknownObjCClass) { 61 if (getLangOptions().CPlusPlus && isa<FunctionDecl>(D)) { 62 // If there were any diagnostics suppressed by template argument deduction, 63 // emit them now. 64 llvm::DenseMap<Decl *, llvm::SmallVector<PartialDiagnosticAt, 1> >::iterator 65 Pos = SuppressedDiagnostics.find(D->getCanonicalDecl()); 66 if (Pos != SuppressedDiagnostics.end()) { 67 llvm::SmallVectorImpl<PartialDiagnosticAt> &Suppressed = Pos->second; 68 for (unsigned I = 0, N = Suppressed.size(); I != N; ++I) 69 Diag(Suppressed[I].first, Suppressed[I].second); 70 71 // Clear out the list of suppressed diagnostics, so that we don't emit 72 // them again for this specialization. However, we don't obsolete this 73 // entry from the table, because we want to avoid ever emitting these 74 // diagnostics again. 75 Suppressed.clear(); 76 } 77 } 78 79 // See if this is an auto-typed variable whose initializer we are parsing. 80 if (ParsingInitForAutoVars.count(D)) { 81 Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer) 82 << D->getDeclName(); 83 return true; 84 } 85 86 // See if this is a deleted function. 87 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 88 if (FD->isDeleted()) { 89 Diag(Loc, diag::err_deleted_function_use); 90 Diag(D->getLocation(), diag::note_unavailable_here) << true; 91 return true; 92 } 93 } 94 95 // See if this declaration is unavailable or deprecated. 96 std::string Message; 97 switch (D->getAvailability(&Message)) { 98 case AR_Available: 99 case AR_NotYetIntroduced: 100 break; 101 102 case AR_Deprecated: 103 EmitDeprecationWarning(D, Message, Loc, UnknownObjCClass); 104 break; 105 106 case AR_Unavailable: 107 if (Message.empty()) { 108 if (!UnknownObjCClass) 109 Diag(Loc, diag::err_unavailable) << D->getDeclName(); 110 else 111 Diag(Loc, diag::warn_unavailable_fwdclass_message) 112 << D->getDeclName(); 113 } 114 else 115 Diag(Loc, diag::err_unavailable_message) 116 << D->getDeclName() << Message; 117 Diag(D->getLocation(), diag::note_unavailable_here) << 0; 118 break; 119 } 120 121 // Warn if this is used but marked unused. 122 if (D->hasAttr<UnusedAttr>()) 123 Diag(Loc, diag::warn_used_but_marked_unused) << D->getDeclName(); 124 125 return false; 126} 127 128/// \brief Retrieve the message suffix that should be added to a 129/// diagnostic complaining about the given function being deleted or 130/// unavailable. 131std::string Sema::getDeletedOrUnavailableSuffix(const FunctionDecl *FD) { 132 // FIXME: C++0x implicitly-deleted special member functions could be 133 // detected here so that we could improve diagnostics to say, e.g., 134 // "base class 'A' had a deleted copy constructor". 135 if (FD->isDeleted()) 136 return std::string(); 137 138 std::string Message; 139 if (FD->getAvailability(&Message)) 140 return ": " + Message; 141 142 return std::string(); 143} 144 145/// DiagnoseSentinelCalls - This routine checks on method dispatch calls 146/// (and other functions in future), which have been declared with sentinel 147/// attribute. It warns if call does not have the sentinel argument. 148/// 149void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, 150 Expr **Args, unsigned NumArgs) { 151 const SentinelAttr *attr = D->getAttr<SentinelAttr>(); 152 if (!attr) 153 return; 154 155 // FIXME: In C++0x, if any of the arguments are parameter pack 156 // expansions, we can't check for the sentinel now. 157 int sentinelPos = attr->getSentinel(); 158 int nullPos = attr->getNullPos(); 159 160 // FIXME. ObjCMethodDecl and FunctionDecl need be derived from the same common 161 // base class. Then we won't be needing two versions of the same code. 162 unsigned int i = 0; 163 bool warnNotEnoughArgs = false; 164 int isMethod = 0; 165 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 166 // skip over named parameters. 167 ObjCMethodDecl::param_iterator P, E = MD->param_end(); 168 for (P = MD->param_begin(); (P != E && i < NumArgs); ++P) { 169 if (nullPos) 170 --nullPos; 171 else 172 ++i; 173 } 174 warnNotEnoughArgs = (P != E || i >= NumArgs); 175 isMethod = 1; 176 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 177 // skip over named parameters. 178 ObjCMethodDecl::param_iterator P, E = FD->param_end(); 179 for (P = FD->param_begin(); (P != E && i < NumArgs); ++P) { 180 if (nullPos) 181 --nullPos; 182 else 183 ++i; 184 } 185 warnNotEnoughArgs = (P != E || i >= NumArgs); 186 } else if (VarDecl *V = dyn_cast<VarDecl>(D)) { 187 // block or function pointer call. 188 QualType Ty = V->getType(); 189 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) { 190 const FunctionType *FT = Ty->isFunctionPointerType() 191 ? Ty->getAs<PointerType>()->getPointeeType()->getAs<FunctionType>() 192 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>(); 193 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT)) { 194 unsigned NumArgsInProto = Proto->getNumArgs(); 195 unsigned k; 196 for (k = 0; (k != NumArgsInProto && i < NumArgs); k++) { 197 if (nullPos) 198 --nullPos; 199 else 200 ++i; 201 } 202 warnNotEnoughArgs = (k != NumArgsInProto || i >= NumArgs); 203 } 204 if (Ty->isBlockPointerType()) 205 isMethod = 2; 206 } else 207 return; 208 } else 209 return; 210 211 if (warnNotEnoughArgs) { 212 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName(); 213 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod; 214 return; 215 } 216 int sentinel = i; 217 while (sentinelPos > 0 && i < NumArgs-1) { 218 --sentinelPos; 219 ++i; 220 } 221 if (sentinelPos > 0) { 222 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName(); 223 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod; 224 return; 225 } 226 while (i < NumArgs-1) { 227 ++i; 228 ++sentinel; 229 } 230 Expr *sentinelExpr = Args[sentinel]; 231 if (!sentinelExpr) return; 232 if (sentinelExpr->isTypeDependent()) return; 233 if (sentinelExpr->isValueDependent()) return; 234 235 // nullptr_t is always treated as null. 236 if (sentinelExpr->getType()->isNullPtrType()) return; 237 238 if (sentinelExpr->getType()->isAnyPointerType() && 239 sentinelExpr->IgnoreParenCasts()->isNullPointerConstant(Context, 240 Expr::NPC_ValueDependentIsNull)) 241 return; 242 243 // Unfortunately, __null has type 'int'. 244 if (isa<GNUNullExpr>(sentinelExpr)) return; 245 246 Diag(Loc, diag::warn_missing_sentinel) << isMethod; 247 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod; 248} 249 250SourceRange Sema::getExprRange(ExprTy *E) const { 251 Expr *Ex = (Expr *)E; 252 return Ex? Ex->getSourceRange() : SourceRange(); 253} 254 255//===----------------------------------------------------------------------===// 256// Standard Promotions and Conversions 257//===----------------------------------------------------------------------===// 258 259/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4). 260ExprResult Sema::DefaultFunctionArrayConversion(Expr *E) { 261 QualType Ty = E->getType(); 262 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type"); 263 264 if (Ty->isFunctionType()) 265 E = ImpCastExprToType(E, Context.getPointerType(Ty), 266 CK_FunctionToPointerDecay).take(); 267 else if (Ty->isArrayType()) { 268 // In C90 mode, arrays only promote to pointers if the array expression is 269 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has 270 // type 'array of type' is converted to an expression that has type 'pointer 271 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression 272 // that has type 'array of type' ...". The relevant change is "an lvalue" 273 // (C90) to "an expression" (C99). 274 // 275 // C++ 4.2p1: 276 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of 277 // T" can be converted to an rvalue of type "pointer to T". 278 // 279 if (getLangOptions().C99 || getLangOptions().CPlusPlus || E->isLValue()) 280 E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty), 281 CK_ArrayToPointerDecay).take(); 282 } 283 return Owned(E); 284} 285 286static void CheckForNullPointerDereference(Sema &S, Expr *E) { 287 // Check to see if we are dereferencing a null pointer. If so, 288 // and if not volatile-qualified, this is undefined behavior that the 289 // optimizer will delete, so warn about it. People sometimes try to use this 290 // to get a deterministic trap and are surprised by clang's behavior. This 291 // only handles the pattern "*null", which is a very syntactic check. 292 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts())) 293 if (UO->getOpcode() == UO_Deref && 294 UO->getSubExpr()->IgnoreParenCasts()-> 295 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) && 296 !UO->getType().isVolatileQualified()) { 297 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 298 S.PDiag(diag::warn_indirection_through_null) 299 << UO->getSubExpr()->getSourceRange()); 300 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 301 S.PDiag(diag::note_indirection_through_null)); 302 } 303} 304 305ExprResult Sema::DefaultLvalueConversion(Expr *E) { 306 // C++ [conv.lval]p1: 307 // A glvalue of a non-function, non-array type T can be 308 // converted to a prvalue. 309 if (!E->isGLValue()) return Owned(E); 310 311 QualType T = E->getType(); 312 assert(!T.isNull() && "r-value conversion on typeless expression?"); 313 314 // Create a load out of an ObjCProperty l-value, if necessary. 315 if (E->getObjectKind() == OK_ObjCProperty) { 316 ExprResult Res = ConvertPropertyForRValue(E); 317 if (Res.isInvalid()) 318 return Owned(E); 319 E = Res.take(); 320 if (!E->isGLValue()) 321 return Owned(E); 322 } 323 324 // We don't want to throw lvalue-to-rvalue casts on top of 325 // expressions of certain types in C++. 326 if (getLangOptions().CPlusPlus && 327 (E->getType() == Context.OverloadTy || 328 T->isDependentType() || 329 T->isRecordType())) 330 return Owned(E); 331 332 // The C standard is actually really unclear on this point, and 333 // DR106 tells us what the result should be but not why. It's 334 // generally best to say that void types just doesn't undergo 335 // lvalue-to-rvalue at all. Note that expressions of unqualified 336 // 'void' type are never l-values, but qualified void can be. 337 if (T->isVoidType()) 338 return Owned(E); 339 340 CheckForNullPointerDereference(*this, E); 341 342 // C++ [conv.lval]p1: 343 // [...] If T is a non-class type, the type of the prvalue is the 344 // cv-unqualified version of T. Otherwise, the type of the 345 // rvalue is T. 346 // 347 // C99 6.3.2.1p2: 348 // If the lvalue has qualified type, the value has the unqualified 349 // version of the type of the lvalue; otherwise, the value has the 350 // type of the lvalue. 351 if (T.hasQualifiers()) 352 T = T.getUnqualifiedType(); 353 354 CheckArrayAccess(E); 355 356 return Owned(ImplicitCastExpr::Create(Context, T, CK_LValueToRValue, 357 E, 0, VK_RValue)); 358} 359 360ExprResult Sema::DefaultFunctionArrayLvalueConversion(Expr *E) { 361 ExprResult Res = DefaultFunctionArrayConversion(E); 362 if (Res.isInvalid()) 363 return ExprError(); 364 Res = DefaultLvalueConversion(Res.take()); 365 if (Res.isInvalid()) 366 return ExprError(); 367 return move(Res); 368} 369 370 371/// UsualUnaryConversions - Performs various conversions that are common to most 372/// operators (C99 6.3). The conversions of array and function types are 373/// sometimes suppressed. For example, the array->pointer conversion doesn't 374/// apply if the array is an argument to the sizeof or address (&) operators. 375/// In these instances, this routine should *not* be called. 376ExprResult Sema::UsualUnaryConversions(Expr *E) { 377 // First, convert to an r-value. 378 ExprResult Res = DefaultFunctionArrayLvalueConversion(E); 379 if (Res.isInvalid()) 380 return Owned(E); 381 E = Res.take(); 382 383 QualType Ty = E->getType(); 384 assert(!Ty.isNull() && "UsualUnaryConversions - missing type"); 385 386 // Try to perform integral promotions if the object has a theoretically 387 // promotable type. 388 if (Ty->isIntegralOrUnscopedEnumerationType()) { 389 // C99 6.3.1.1p2: 390 // 391 // The following may be used in an expression wherever an int or 392 // unsigned int may be used: 393 // - an object or expression with an integer type whose integer 394 // conversion rank is less than or equal to the rank of int 395 // and unsigned int. 396 // - A bit-field of type _Bool, int, signed int, or unsigned int. 397 // 398 // If an int can represent all values of the original type, the 399 // value is converted to an int; otherwise, it is converted to an 400 // unsigned int. These are called the integer promotions. All 401 // other types are unchanged by the integer promotions. 402 403 QualType PTy = Context.isPromotableBitField(E); 404 if (!PTy.isNull()) { 405 E = ImpCastExprToType(E, PTy, CK_IntegralCast).take(); 406 return Owned(E); 407 } 408 if (Ty->isPromotableIntegerType()) { 409 QualType PT = Context.getPromotedIntegerType(Ty); 410 E = ImpCastExprToType(E, PT, CK_IntegralCast).take(); 411 return Owned(E); 412 } 413 } 414 return Owned(E); 415} 416 417/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that 418/// do not have a prototype. Arguments that have type float are promoted to 419/// double. All other argument types are converted by UsualUnaryConversions(). 420ExprResult Sema::DefaultArgumentPromotion(Expr *E) { 421 QualType Ty = E->getType(); 422 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type"); 423 424 ExprResult Res = UsualUnaryConversions(E); 425 if (Res.isInvalid()) 426 return Owned(E); 427 E = Res.take(); 428 429 // If this is a 'float' (CVR qualified or typedef) promote to double. 430 if (Ty->isSpecificBuiltinType(BuiltinType::Float)) 431 E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).take(); 432 433 return Owned(E); 434} 435 436/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but 437/// will warn if the resulting type is not a POD type, and rejects ObjC 438/// interfaces passed by value. 439ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, 440 FunctionDecl *FDecl) { 441 ExprResult ExprRes = DefaultArgumentPromotion(E); 442 if (ExprRes.isInvalid()) 443 return ExprError(); 444 E = ExprRes.take(); 445 446 // __builtin_va_start takes the second argument as a "varargs" argument, but 447 // it doesn't actually do anything with it. It doesn't need to be non-pod 448 // etc. 449 if (FDecl && FDecl->getBuiltinID() == Builtin::BI__builtin_va_start) 450 return Owned(E); 451 452 // Don't allow one to pass an Objective-C interface to a vararg. 453 if (E->getType()->isObjCObjectType() && 454 DiagRuntimeBehavior(E->getLocStart(), 0, 455 PDiag(diag::err_cannot_pass_objc_interface_to_vararg) 456 << E->getType() << CT)) 457 return ExprError(); 458 459 if (!E->getType()->isPODType()) { 460 // C++0x [expr.call]p7: 461 // Passing a potentially-evaluated argument of class type (Clause 9) 462 // having a non-trivial copy constructor, a non-trivial move constructor, 463 // or a non-trivial destructor, with no corresponding parameter, 464 // is conditionally-supported with implementation-defined semantics. 465 bool TrivialEnough = false; 466 if (getLangOptions().CPlusPlus0x && !E->getType()->isDependentType()) { 467 if (CXXRecordDecl *Record = E->getType()->getAsCXXRecordDecl()) { 468 if (Record->hasTrivialCopyConstructor() && 469 Record->hasTrivialMoveConstructor() && 470 Record->hasTrivialDestructor()) 471 TrivialEnough = true; 472 } 473 } 474 475 if (TrivialEnough) { 476 // Nothing to diagnose. This is okay. 477 } else if (DiagRuntimeBehavior(E->getLocStart(), 0, 478 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg) 479 << getLangOptions().CPlusPlus0x << E->getType() 480 << CT)) { 481 // Turn this into a trap. 482 CXXScopeSpec SS; 483 UnqualifiedId Name; 484 Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"), 485 E->getLocStart()); 486 ExprResult TrapFn = ActOnIdExpression(TUScope, SS, Name, true, false); 487 if (TrapFn.isInvalid()) 488 return ExprError(); 489 490 ExprResult Call = ActOnCallExpr(TUScope, TrapFn.get(), E->getLocStart(), 491 MultiExprArg(), E->getLocEnd()); 492 if (Call.isInvalid()) 493 return ExprError(); 494 495 ExprResult Comma = ActOnBinOp(TUScope, E->getLocStart(), tok::comma, 496 Call.get(), E); 497 if (Comma.isInvalid()) 498 return ExprError(); 499 500 E = Comma.get(); 501 } 502 } 503 504 return Owned(E); 505} 506 507/// UsualArithmeticConversions - Performs various conversions that are common to 508/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this 509/// routine returns the first non-arithmetic type found. The client is 510/// responsible for emitting appropriate error diagnostics. 511/// FIXME: verify the conversion rules for "complex int" are consistent with 512/// GCC. 513QualType Sema::UsualArithmeticConversions(ExprResult &lhsExpr, ExprResult &rhsExpr, 514 bool isCompAssign) { 515 if (!isCompAssign) { 516 lhsExpr = UsualUnaryConversions(lhsExpr.take()); 517 if (lhsExpr.isInvalid()) 518 return QualType(); 519 } 520 521 rhsExpr = UsualUnaryConversions(rhsExpr.take()); 522 if (rhsExpr.isInvalid()) 523 return QualType(); 524 525 // For conversion purposes, we ignore any qualifiers. 526 // For example, "const float" and "float" are equivalent. 527 QualType lhs = 528 Context.getCanonicalType(lhsExpr.get()->getType()).getUnqualifiedType(); 529 QualType rhs = 530 Context.getCanonicalType(rhsExpr.get()->getType()).getUnqualifiedType(); 531 532 // If both types are identical, no conversion is needed. 533 if (lhs == rhs) 534 return lhs; 535 536 // If either side is a non-arithmetic type (e.g. a pointer), we are done. 537 // The caller can deal with this (e.g. pointer + int). 538 if (!lhs->isArithmeticType() || !rhs->isArithmeticType()) 539 return lhs; 540 541 // Apply unary and bitfield promotions to the LHS's type. 542 QualType lhs_unpromoted = lhs; 543 if (lhs->isPromotableIntegerType()) 544 lhs = Context.getPromotedIntegerType(lhs); 545 QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(lhsExpr.get()); 546 if (!LHSBitfieldPromoteTy.isNull()) 547 lhs = LHSBitfieldPromoteTy; 548 if (lhs != lhs_unpromoted && !isCompAssign) 549 lhsExpr = ImpCastExprToType(lhsExpr.take(), lhs, CK_IntegralCast); 550 551 // If both types are identical, no conversion is needed. 552 if (lhs == rhs) 553 return lhs; 554 555 // At this point, we have two different arithmetic types. 556 557 // Handle complex types first (C99 6.3.1.8p1). 558 bool LHSComplexFloat = lhs->isComplexType(); 559 bool RHSComplexFloat = rhs->isComplexType(); 560 if (LHSComplexFloat || RHSComplexFloat) { 561 // if we have an integer operand, the result is the complex type. 562 563 if (!RHSComplexFloat && !rhs->isRealFloatingType()) { 564 if (rhs->isIntegerType()) { 565 QualType fp = cast<ComplexType>(lhs)->getElementType(); 566 rhsExpr = ImpCastExprToType(rhsExpr.take(), fp, CK_IntegralToFloating); 567 rhsExpr = ImpCastExprToType(rhsExpr.take(), lhs, CK_FloatingRealToComplex); 568 } else { 569 assert(rhs->isComplexIntegerType()); 570 rhsExpr = ImpCastExprToType(rhsExpr.take(), lhs, CK_IntegralComplexToFloatingComplex); 571 } 572 return lhs; 573 } 574 575 if (!LHSComplexFloat && !lhs->isRealFloatingType()) { 576 if (!isCompAssign) { 577 // int -> float -> _Complex float 578 if (lhs->isIntegerType()) { 579 QualType fp = cast<ComplexType>(rhs)->getElementType(); 580 lhsExpr = ImpCastExprToType(lhsExpr.take(), fp, CK_IntegralToFloating); 581 lhsExpr = ImpCastExprToType(lhsExpr.take(), rhs, CK_FloatingRealToComplex); 582 } else { 583 assert(lhs->isComplexIntegerType()); 584 lhsExpr = ImpCastExprToType(lhsExpr.take(), rhs, CK_IntegralComplexToFloatingComplex); 585 } 586 } 587 return rhs; 588 } 589 590 // This handles complex/complex, complex/float, or float/complex. 591 // When both operands are complex, the shorter operand is converted to the 592 // type of the longer, and that is the type of the result. This corresponds 593 // to what is done when combining two real floating-point operands. 594 // The fun begins when size promotion occur across type domains. 595 // From H&S 6.3.4: When one operand is complex and the other is a real 596 // floating-point type, the less precise type is converted, within it's 597 // real or complex domain, to the precision of the other type. For example, 598 // when combining a "long double" with a "double _Complex", the 599 // "double _Complex" is promoted to "long double _Complex". 600 int order = Context.getFloatingTypeOrder(lhs, rhs); 601 602 // If both are complex, just cast to the more precise type. 603 if (LHSComplexFloat && RHSComplexFloat) { 604 if (order > 0) { 605 // _Complex float -> _Complex double 606 rhsExpr = ImpCastExprToType(rhsExpr.take(), lhs, CK_FloatingComplexCast); 607 return lhs; 608 609 } else if (order < 0) { 610 // _Complex float -> _Complex double 611 if (!isCompAssign) 612 lhsExpr = ImpCastExprToType(lhsExpr.take(), rhs, CK_FloatingComplexCast); 613 return rhs; 614 } 615 return lhs; 616 } 617 618 // If just the LHS is complex, the RHS needs to be converted, 619 // and the LHS might need to be promoted. 620 if (LHSComplexFloat) { 621 if (order > 0) { // LHS is wider 622 // float -> _Complex double 623 QualType fp = cast<ComplexType>(lhs)->getElementType(); 624 rhsExpr = ImpCastExprToType(rhsExpr.take(), fp, CK_FloatingCast); 625 rhsExpr = ImpCastExprToType(rhsExpr.take(), lhs, CK_FloatingRealToComplex); 626 return lhs; 627 } 628 629 // RHS is at least as wide. Find its corresponding complex type. 630 QualType result = (order == 0 ? lhs : Context.getComplexType(rhs)); 631 632 // double -> _Complex double 633 rhsExpr = ImpCastExprToType(rhsExpr.take(), result, CK_FloatingRealToComplex); 634 635 // _Complex float -> _Complex double 636 if (!isCompAssign && order < 0) 637 lhsExpr = ImpCastExprToType(lhsExpr.take(), result, CK_FloatingComplexCast); 638 639 return result; 640 } 641 642 // Just the RHS is complex, so the LHS needs to be converted 643 // and the RHS might need to be promoted. 644 assert(RHSComplexFloat); 645 646 if (order < 0) { // RHS is wider 647 // float -> _Complex double 648 if (!isCompAssign) { 649 QualType fp = cast<ComplexType>(rhs)->getElementType(); 650 lhsExpr = ImpCastExprToType(lhsExpr.take(), fp, CK_FloatingCast); 651 lhsExpr = ImpCastExprToType(lhsExpr.take(), rhs, CK_FloatingRealToComplex); 652 } 653 return rhs; 654 } 655 656 // LHS is at least as wide. Find its corresponding complex type. 657 QualType result = (order == 0 ? rhs : Context.getComplexType(lhs)); 658 659 // double -> _Complex double 660 if (!isCompAssign) 661 lhsExpr = ImpCastExprToType(lhsExpr.take(), result, CK_FloatingRealToComplex); 662 663 // _Complex float -> _Complex double 664 if (order > 0) 665 rhsExpr = ImpCastExprToType(rhsExpr.take(), result, CK_FloatingComplexCast); 666 667 return result; 668 } 669 670 // Now handle "real" floating types (i.e. float, double, long double). 671 bool LHSFloat = lhs->isRealFloatingType(); 672 bool RHSFloat = rhs->isRealFloatingType(); 673 if (LHSFloat || RHSFloat) { 674 // If we have two real floating types, convert the smaller operand 675 // to the bigger result. 676 if (LHSFloat && RHSFloat) { 677 int order = Context.getFloatingTypeOrder(lhs, rhs); 678 if (order > 0) { 679 rhsExpr = ImpCastExprToType(rhsExpr.take(), lhs, CK_FloatingCast); 680 return lhs; 681 } 682 683 assert(order < 0 && "illegal float comparison"); 684 if (!isCompAssign) 685 lhsExpr = ImpCastExprToType(lhsExpr.take(), rhs, CK_FloatingCast); 686 return rhs; 687 } 688 689 // If we have an integer operand, the result is the real floating type. 690 if (LHSFloat) { 691 if (rhs->isIntegerType()) { 692 // Convert rhs to the lhs floating point type. 693 rhsExpr = ImpCastExprToType(rhsExpr.take(), lhs, CK_IntegralToFloating); 694 return lhs; 695 } 696 697 // Convert both sides to the appropriate complex float. 698 assert(rhs->isComplexIntegerType()); 699 QualType result = Context.getComplexType(lhs); 700 701 // _Complex int -> _Complex float 702 rhsExpr = ImpCastExprToType(rhsExpr.take(), result, CK_IntegralComplexToFloatingComplex); 703 704 // float -> _Complex float 705 if (!isCompAssign) 706 lhsExpr = ImpCastExprToType(lhsExpr.take(), result, CK_FloatingRealToComplex); 707 708 return result; 709 } 710 711 assert(RHSFloat); 712 if (lhs->isIntegerType()) { 713 // Convert lhs to the rhs floating point type. 714 if (!isCompAssign) 715 lhsExpr = ImpCastExprToType(lhsExpr.take(), rhs, CK_IntegralToFloating); 716 return rhs; 717 } 718 719 // Convert both sides to the appropriate complex float. 720 assert(lhs->isComplexIntegerType()); 721 QualType result = Context.getComplexType(rhs); 722 723 // _Complex int -> _Complex float 724 if (!isCompAssign) 725 lhsExpr = ImpCastExprToType(lhsExpr.take(), result, CK_IntegralComplexToFloatingComplex); 726 727 // float -> _Complex float 728 rhsExpr = ImpCastExprToType(rhsExpr.take(), result, CK_FloatingRealToComplex); 729 730 return result; 731 } 732 733 // Handle GCC complex int extension. 734 // FIXME: if the operands are (int, _Complex long), we currently 735 // don't promote the complex. Also, signedness? 736 const ComplexType *lhsComplexInt = lhs->getAsComplexIntegerType(); 737 const ComplexType *rhsComplexInt = rhs->getAsComplexIntegerType(); 738 if (lhsComplexInt && rhsComplexInt) { 739 int order = Context.getIntegerTypeOrder(lhsComplexInt->getElementType(), 740 rhsComplexInt->getElementType()); 741 assert(order && "inequal types with equal element ordering"); 742 if (order > 0) { 743 // _Complex int -> _Complex long 744 rhsExpr = ImpCastExprToType(rhsExpr.take(), lhs, CK_IntegralComplexCast); 745 return lhs; 746 } 747 748 if (!isCompAssign) 749 lhsExpr = ImpCastExprToType(lhsExpr.take(), rhs, CK_IntegralComplexCast); 750 return rhs; 751 } else if (lhsComplexInt) { 752 // int -> _Complex int 753 rhsExpr = ImpCastExprToType(rhsExpr.take(), lhs, CK_IntegralRealToComplex); 754 return lhs; 755 } else if (rhsComplexInt) { 756 // int -> _Complex int 757 if (!isCompAssign) 758 lhsExpr = ImpCastExprToType(lhsExpr.take(), rhs, CK_IntegralRealToComplex); 759 return rhs; 760 } 761 762 // Finally, we have two differing integer types. 763 // The rules for this case are in C99 6.3.1.8 764 int compare = Context.getIntegerTypeOrder(lhs, rhs); 765 bool lhsSigned = lhs->hasSignedIntegerRepresentation(), 766 rhsSigned = rhs->hasSignedIntegerRepresentation(); 767 if (lhsSigned == rhsSigned) { 768 // Same signedness; use the higher-ranked type 769 if (compare >= 0) { 770 rhsExpr = ImpCastExprToType(rhsExpr.take(), lhs, CK_IntegralCast); 771 return lhs; 772 } else if (!isCompAssign) 773 lhsExpr = ImpCastExprToType(lhsExpr.take(), rhs, CK_IntegralCast); 774 return rhs; 775 } else if (compare != (lhsSigned ? 1 : -1)) { 776 // The unsigned type has greater than or equal rank to the 777 // signed type, so use the unsigned type 778 if (rhsSigned) { 779 rhsExpr = ImpCastExprToType(rhsExpr.take(), lhs, CK_IntegralCast); 780 return lhs; 781 } else if (!isCompAssign) 782 lhsExpr = ImpCastExprToType(lhsExpr.take(), rhs, CK_IntegralCast); 783 return rhs; 784 } else if (Context.getIntWidth(lhs) != Context.getIntWidth(rhs)) { 785 // The two types are different widths; if we are here, that 786 // means the signed type is larger than the unsigned type, so 787 // use the signed type. 788 if (lhsSigned) { 789 rhsExpr = ImpCastExprToType(rhsExpr.take(), lhs, CK_IntegralCast); 790 return lhs; 791 } else if (!isCompAssign) 792 lhsExpr = ImpCastExprToType(lhsExpr.take(), rhs, CK_IntegralCast); 793 return rhs; 794 } else { 795 // The signed type is higher-ranked than the unsigned type, 796 // but isn't actually any bigger (like unsigned int and long 797 // on most 32-bit systems). Use the unsigned type corresponding 798 // to the signed type. 799 QualType result = 800 Context.getCorrespondingUnsignedType(lhsSigned ? lhs : rhs); 801 rhsExpr = ImpCastExprToType(rhsExpr.take(), result, CK_IntegralCast); 802 if (!isCompAssign) 803 lhsExpr = ImpCastExprToType(lhsExpr.take(), result, CK_IntegralCast); 804 return result; 805 } 806} 807 808//===----------------------------------------------------------------------===// 809// Semantic Analysis for various Expression Types 810//===----------------------------------------------------------------------===// 811 812 813ExprResult 814Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc, 815 SourceLocation DefaultLoc, 816 SourceLocation RParenLoc, 817 Expr *ControllingExpr, 818 MultiTypeArg types, 819 MultiExprArg exprs) { 820 unsigned NumAssocs = types.size(); 821 assert(NumAssocs == exprs.size()); 822 823 ParsedType *ParsedTypes = types.release(); 824 Expr **Exprs = exprs.release(); 825 826 TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs]; 827 for (unsigned i = 0; i < NumAssocs; ++i) { 828 if (ParsedTypes[i]) 829 (void) GetTypeFromParser(ParsedTypes[i], &Types[i]); 830 else 831 Types[i] = 0; 832 } 833 834 ExprResult ER = CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, 835 ControllingExpr, Types, Exprs, 836 NumAssocs); 837 delete [] Types; 838 return ER; 839} 840 841ExprResult 842Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc, 843 SourceLocation DefaultLoc, 844 SourceLocation RParenLoc, 845 Expr *ControllingExpr, 846 TypeSourceInfo **Types, 847 Expr **Exprs, 848 unsigned NumAssocs) { 849 bool TypeErrorFound = false, 850 IsResultDependent = ControllingExpr->isTypeDependent(), 851 ContainsUnexpandedParameterPack 852 = ControllingExpr->containsUnexpandedParameterPack(); 853 854 for (unsigned i = 0; i < NumAssocs; ++i) { 855 if (Exprs[i]->containsUnexpandedParameterPack()) 856 ContainsUnexpandedParameterPack = true; 857 858 if (Types[i]) { 859 if (Types[i]->getType()->containsUnexpandedParameterPack()) 860 ContainsUnexpandedParameterPack = true; 861 862 if (Types[i]->getType()->isDependentType()) { 863 IsResultDependent = true; 864 } else { 865 // C1X 6.5.1.1p2 "The type name in a generic association shall specify a 866 // complete object type other than a variably modified type." 867 unsigned D = 0; 868 if (Types[i]->getType()->isIncompleteType()) 869 D = diag::err_assoc_type_incomplete; 870 else if (!Types[i]->getType()->isObjectType()) 871 D = diag::err_assoc_type_nonobject; 872 else if (Types[i]->getType()->isVariablyModifiedType()) 873 D = diag::err_assoc_type_variably_modified; 874 875 if (D != 0) { 876 Diag(Types[i]->getTypeLoc().getBeginLoc(), D) 877 << Types[i]->getTypeLoc().getSourceRange() 878 << Types[i]->getType(); 879 TypeErrorFound = true; 880 } 881 882 // C1X 6.5.1.1p2 "No two generic associations in the same generic 883 // selection shall specify compatible types." 884 for (unsigned j = i+1; j < NumAssocs; ++j) 885 if (Types[j] && !Types[j]->getType()->isDependentType() && 886 Context.typesAreCompatible(Types[i]->getType(), 887 Types[j]->getType())) { 888 Diag(Types[j]->getTypeLoc().getBeginLoc(), 889 diag::err_assoc_compatible_types) 890 << Types[j]->getTypeLoc().getSourceRange() 891 << Types[j]->getType() 892 << Types[i]->getType(); 893 Diag(Types[i]->getTypeLoc().getBeginLoc(), 894 diag::note_compat_assoc) 895 << Types[i]->getTypeLoc().getSourceRange() 896 << Types[i]->getType(); 897 TypeErrorFound = true; 898 } 899 } 900 } 901 } 902 if (TypeErrorFound) 903 return ExprError(); 904 905 // If we determined that the generic selection is result-dependent, don't 906 // try to compute the result expression. 907 if (IsResultDependent) 908 return Owned(new (Context) GenericSelectionExpr( 909 Context, KeyLoc, ControllingExpr, 910 Types, Exprs, NumAssocs, DefaultLoc, 911 RParenLoc, ContainsUnexpandedParameterPack)); 912 913 llvm::SmallVector<unsigned, 1> CompatIndices; 914 unsigned DefaultIndex = -1U; 915 for (unsigned i = 0; i < NumAssocs; ++i) { 916 if (!Types[i]) 917 DefaultIndex = i; 918 else if (Context.typesAreCompatible(ControllingExpr->getType(), 919 Types[i]->getType())) 920 CompatIndices.push_back(i); 921 } 922 923 // C1X 6.5.1.1p2 "The controlling expression of a generic selection shall have 924 // type compatible with at most one of the types named in its generic 925 // association list." 926 if (CompatIndices.size() > 1) { 927 // We strip parens here because the controlling expression is typically 928 // parenthesized in macro definitions. 929 ControllingExpr = ControllingExpr->IgnoreParens(); 930 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_multi_match) 931 << ControllingExpr->getSourceRange() << ControllingExpr->getType() 932 << (unsigned) CompatIndices.size(); 933 for (llvm::SmallVector<unsigned, 1>::iterator I = CompatIndices.begin(), 934 E = CompatIndices.end(); I != E; ++I) { 935 Diag(Types[*I]->getTypeLoc().getBeginLoc(), 936 diag::note_compat_assoc) 937 << Types[*I]->getTypeLoc().getSourceRange() 938 << Types[*I]->getType(); 939 } 940 return ExprError(); 941 } 942 943 // C1X 6.5.1.1p2 "If a generic selection has no default generic association, 944 // its controlling expression shall have type compatible with exactly one of 945 // the types named in its generic association list." 946 if (DefaultIndex == -1U && CompatIndices.size() == 0) { 947 // We strip parens here because the controlling expression is typically 948 // parenthesized in macro definitions. 949 ControllingExpr = ControllingExpr->IgnoreParens(); 950 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_no_match) 951 << ControllingExpr->getSourceRange() << ControllingExpr->getType(); 952 return ExprError(); 953 } 954 955 // C1X 6.5.1.1p3 "If a generic selection has a generic association with a 956 // type name that is compatible with the type of the controlling expression, 957 // then the result expression of the generic selection is the expression 958 // in that generic association. Otherwise, the result expression of the 959 // generic selection is the expression in the default generic association." 960 unsigned ResultIndex = 961 CompatIndices.size() ? CompatIndices[0] : DefaultIndex; 962 963 return Owned(new (Context) GenericSelectionExpr( 964 Context, KeyLoc, ControllingExpr, 965 Types, Exprs, NumAssocs, DefaultLoc, 966 RParenLoc, ContainsUnexpandedParameterPack, 967 ResultIndex)); 968} 969 970/// ActOnStringLiteral - The specified tokens were lexed as pasted string 971/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string 972/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from 973/// multiple tokens. However, the common case is that StringToks points to one 974/// string. 975/// 976ExprResult 977Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks) { 978 assert(NumStringToks && "Must have at least one string!"); 979 980 StringLiteralParser Literal(StringToks, NumStringToks, PP); 981 if (Literal.hadError) 982 return ExprError(); 983 984 llvm::SmallVector<SourceLocation, 4> StringTokLocs; 985 for (unsigned i = 0; i != NumStringToks; ++i) 986 StringTokLocs.push_back(StringToks[i].getLocation()); 987 988 QualType StrTy = Context.CharTy; 989 if (Literal.AnyWide) 990 StrTy = Context.getWCharType(); 991 else if (Literal.Pascal) 992 StrTy = Context.UnsignedCharTy; 993 994 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1). 995 if (getLangOptions().CPlusPlus || getLangOptions().ConstStrings) 996 StrTy.addConst(); 997 998 // Get an array type for the string, according to C99 6.4.5. This includes 999 // the nul terminator character as well as the string length for pascal 1000 // strings. 1001 StrTy = Context.getConstantArrayType(StrTy, 1002 llvm::APInt(32, Literal.GetNumStringChars()+1), 1003 ArrayType::Normal, 0); 1004 1005 // Pass &StringTokLocs[0], StringTokLocs.size() to factory! 1006 return Owned(StringLiteral::Create(Context, Literal.GetString(), 1007 Literal.GetStringLength(), 1008 Literal.AnyWide, Literal.Pascal, StrTy, 1009 &StringTokLocs[0], 1010 StringTokLocs.size())); 1011} 1012 1013enum CaptureResult { 1014 /// No capture is required. 1015 CR_NoCapture, 1016 1017 /// A capture is required. 1018 CR_Capture, 1019 1020 /// A by-ref capture is required. 1021 CR_CaptureByRef, 1022 1023 /// An error occurred when trying to capture the given variable. 1024 CR_Error 1025}; 1026 1027/// Diagnose an uncapturable value reference. 1028/// 1029/// \param var - the variable referenced 1030/// \param DC - the context which we couldn't capture through 1031static CaptureResult 1032diagnoseUncapturableValueReference(Sema &S, SourceLocation loc, 1033 VarDecl *var, DeclContext *DC) { 1034 switch (S.ExprEvalContexts.back().Context) { 1035 case Sema::Unevaluated: 1036 // The argument will never be evaluated, so don't complain. 1037 return CR_NoCapture; 1038 1039 case Sema::PotentiallyEvaluated: 1040 case Sema::PotentiallyEvaluatedIfUsed: 1041 break; 1042 1043 case Sema::PotentiallyPotentiallyEvaluated: 1044 // FIXME: delay these! 1045 break; 1046 } 1047 1048 // Don't diagnose about capture if we're not actually in code right 1049 // now; in general, there are more appropriate places that will 1050 // diagnose this. 1051 if (!S.CurContext->isFunctionOrMethod()) return CR_NoCapture; 1052 1053 // Certain madnesses can happen with parameter declarations, which 1054 // we want to ignore. 1055 if (isa<ParmVarDecl>(var)) { 1056 // - If the parameter still belongs to the translation unit, then 1057 // we're actually just using one parameter in the declaration of 1058 // the next. This is useful in e.g. VLAs. 1059 if (isa<TranslationUnitDecl>(var->getDeclContext())) 1060 return CR_NoCapture; 1061 1062 // - This particular madness can happen in ill-formed default 1063 // arguments; claim it's okay and let downstream code handle it. 1064 if (S.CurContext == var->getDeclContext()->getParent()) 1065 return CR_NoCapture; 1066 } 1067 1068 DeclarationName functionName; 1069 if (FunctionDecl *fn = dyn_cast<FunctionDecl>(var->getDeclContext())) 1070 functionName = fn->getDeclName(); 1071 // FIXME: variable from enclosing block that we couldn't capture from! 1072 1073 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_function) 1074 << var->getIdentifier() << functionName; 1075 S.Diag(var->getLocation(), diag::note_local_variable_declared_here) 1076 << var->getIdentifier(); 1077 1078 return CR_Error; 1079} 1080 1081/// There is a well-formed capture at a particular scope level; 1082/// propagate it through all the nested blocks. 1083static CaptureResult propagateCapture(Sema &S, unsigned validScopeIndex, 1084 const BlockDecl::Capture &capture) { 1085 VarDecl *var = capture.getVariable(); 1086 1087 // Update all the inner blocks with the capture information. 1088 for (unsigned i = validScopeIndex + 1, e = S.FunctionScopes.size(); 1089 i != e; ++i) { 1090 BlockScopeInfo *innerBlock = cast<BlockScopeInfo>(S.FunctionScopes[i]); 1091 innerBlock->Captures.push_back( 1092 BlockDecl::Capture(capture.getVariable(), capture.isByRef(), 1093 /*nested*/ true, capture.getCopyExpr())); 1094 innerBlock->CaptureMap[var] = innerBlock->Captures.size(); // +1 1095 } 1096 1097 return capture.isByRef() ? CR_CaptureByRef : CR_Capture; 1098} 1099 1100/// shouldCaptureValueReference - Determine if a reference to the 1101/// given value in the current context requires a variable capture. 1102/// 1103/// This also keeps the captures set in the BlockScopeInfo records 1104/// up-to-date. 1105static CaptureResult shouldCaptureValueReference(Sema &S, SourceLocation loc, 1106 ValueDecl *value) { 1107 // Only variables ever require capture. 1108 VarDecl *var = dyn_cast<VarDecl>(value); 1109 if (!var) return CR_NoCapture; 1110 1111 // Fast path: variables from the current context never require capture. 1112 DeclContext *DC = S.CurContext; 1113 if (var->getDeclContext() == DC) return CR_NoCapture; 1114 1115 // Only variables with local storage require capture. 1116 // FIXME: What about 'const' variables in C++? 1117 if (!var->hasLocalStorage()) return CR_NoCapture; 1118 1119 // Otherwise, we need to capture. 1120 1121 unsigned functionScopesIndex = S.FunctionScopes.size() - 1; 1122 do { 1123 // Only blocks (and eventually C++0x closures) can capture; other 1124 // scopes don't work. 1125 if (!isa<BlockDecl>(DC)) 1126 return diagnoseUncapturableValueReference(S, loc, var, DC); 1127 1128 BlockScopeInfo *blockScope = 1129 cast<BlockScopeInfo>(S.FunctionScopes[functionScopesIndex]); 1130 assert(blockScope->TheDecl == static_cast<BlockDecl*>(DC)); 1131 1132 // Check whether we've already captured it in this block. If so, 1133 // we're done. 1134 if (unsigned indexPlus1 = blockScope->CaptureMap[var]) 1135 return propagateCapture(S, functionScopesIndex, 1136 blockScope->Captures[indexPlus1 - 1]); 1137 1138 functionScopesIndex--; 1139 DC = cast<BlockDecl>(DC)->getDeclContext(); 1140 } while (var->getDeclContext() != DC); 1141 1142 // Okay, we descended all the way to the block that defines the variable. 1143 // Actually try to capture it. 1144 QualType type = var->getType(); 1145 1146 // Prohibit variably-modified types. 1147 if (type->isVariablyModifiedType()) { 1148 S.Diag(loc, diag::err_ref_vm_type); 1149 S.Diag(var->getLocation(), diag::note_declared_at); 1150 return CR_Error; 1151 } 1152 1153 // Prohibit arrays, even in __block variables, but not references to 1154 // them. 1155 if (type->isArrayType()) { 1156 S.Diag(loc, diag::err_ref_array_type); 1157 S.Diag(var->getLocation(), diag::note_declared_at); 1158 return CR_Error; 1159 } 1160 1161 S.MarkDeclarationReferenced(loc, var); 1162 1163 // The BlocksAttr indicates the variable is bound by-reference. 1164 bool byRef = var->hasAttr<BlocksAttr>(); 1165 1166 // Build a copy expression. 1167 Expr *copyExpr = 0; 1168 const RecordType *rtype; 1169 if (!byRef && S.getLangOptions().CPlusPlus && !type->isDependentType() && 1170 (rtype = type->getAs<RecordType>())) { 1171 1172 // The capture logic needs the destructor, so make sure we mark it. 1173 // Usually this is unnecessary because most local variables have 1174 // their destructors marked at declaration time, but parameters are 1175 // an exception because it's technically only the call site that 1176 // actually requires the destructor. 1177 if (isa<ParmVarDecl>(var)) 1178 S.FinalizeVarWithDestructor(var, rtype); 1179 1180 // According to the blocks spec, the capture of a variable from 1181 // the stack requires a const copy constructor. This is not true 1182 // of the copy/move done to move a __block variable to the heap. 1183 type.addConst(); 1184 1185 Expr *declRef = new (S.Context) DeclRefExpr(var, type, VK_LValue, loc); 1186 ExprResult result = 1187 S.PerformCopyInitialization( 1188 InitializedEntity::InitializeBlock(var->getLocation(), 1189 type, false), 1190 loc, S.Owned(declRef)); 1191 1192 // Build a full-expression copy expression if initialization 1193 // succeeded and used a non-trivial constructor. Recover from 1194 // errors by pretending that the copy isn't necessary. 1195 if (!result.isInvalid() && 1196 !cast<CXXConstructExpr>(result.get())->getConstructor()->isTrivial()) { 1197 result = S.MaybeCreateExprWithCleanups(result); 1198 copyExpr = result.take(); 1199 } 1200 } 1201 1202 // We're currently at the declarer; go back to the closure. 1203 functionScopesIndex++; 1204 BlockScopeInfo *blockScope = 1205 cast<BlockScopeInfo>(S.FunctionScopes[functionScopesIndex]); 1206 1207 // Build a valid capture in this scope. 1208 blockScope->Captures.push_back( 1209 BlockDecl::Capture(var, byRef, /*nested*/ false, copyExpr)); 1210 blockScope->CaptureMap[var] = blockScope->Captures.size(); // +1 1211 1212 // Propagate that to inner captures if necessary. 1213 return propagateCapture(S, functionScopesIndex, 1214 blockScope->Captures.back()); 1215} 1216 1217static ExprResult BuildBlockDeclRefExpr(Sema &S, ValueDecl *vd, 1218 const DeclarationNameInfo &NameInfo, 1219 bool byRef) { 1220 assert(isa<VarDecl>(vd) && "capturing non-variable"); 1221 1222 VarDecl *var = cast<VarDecl>(vd); 1223 assert(var->hasLocalStorage() && "capturing non-local"); 1224 assert(byRef == var->hasAttr<BlocksAttr>() && "byref set wrong"); 1225 1226 QualType exprType = var->getType().getNonReferenceType(); 1227 1228 BlockDeclRefExpr *BDRE; 1229 if (!byRef) { 1230 // The variable will be bound by copy; make it const within the 1231 // closure, but record that this was done in the expression. 1232 bool constAdded = !exprType.isConstQualified(); 1233 exprType.addConst(); 1234 1235 BDRE = new (S.Context) BlockDeclRefExpr(var, exprType, VK_LValue, 1236 NameInfo.getLoc(), false, 1237 constAdded); 1238 } else { 1239 BDRE = new (S.Context) BlockDeclRefExpr(var, exprType, VK_LValue, 1240 NameInfo.getLoc(), true); 1241 } 1242 1243 return S.Owned(BDRE); 1244} 1245 1246ExprResult 1247Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1248 SourceLocation Loc, 1249 const CXXScopeSpec *SS) { 1250 DeclarationNameInfo NameInfo(D->getDeclName(), Loc); 1251 return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS); 1252} 1253 1254/// BuildDeclRefExpr - Build an expression that references a 1255/// declaration that does not require a closure capture. 1256ExprResult 1257Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1258 const DeclarationNameInfo &NameInfo, 1259 const CXXScopeSpec *SS) { 1260 MarkDeclarationReferenced(NameInfo.getLoc(), D); 1261 1262 Expr *E = DeclRefExpr::Create(Context, 1263 SS? SS->getWithLocInContext(Context) 1264 : NestedNameSpecifierLoc(), 1265 D, NameInfo, Ty, VK); 1266 1267 // Just in case we're building an illegal pointer-to-member. 1268 if (isa<FieldDecl>(D) && cast<FieldDecl>(D)->getBitWidth()) 1269 E->setObjectKind(OK_BitField); 1270 1271 return Owned(E); 1272} 1273 1274static ExprResult 1275BuildFieldReferenceExpr(Sema &S, Expr *BaseExpr, bool IsArrow, 1276 const CXXScopeSpec &SS, FieldDecl *Field, 1277 DeclAccessPair FoundDecl, 1278 const DeclarationNameInfo &MemberNameInfo); 1279 1280ExprResult 1281Sema::BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, 1282 SourceLocation loc, 1283 IndirectFieldDecl *indirectField, 1284 Expr *baseObjectExpr, 1285 SourceLocation opLoc) { 1286 // First, build the expression that refers to the base object. 1287 1288 bool baseObjectIsPointer = false; 1289 Qualifiers baseQuals; 1290 1291 // Case 1: the base of the indirect field is not a field. 1292 VarDecl *baseVariable = indirectField->getVarDecl(); 1293 CXXScopeSpec EmptySS; 1294 if (baseVariable) { 1295 assert(baseVariable->getType()->isRecordType()); 1296 1297 // In principle we could have a member access expression that 1298 // accesses an anonymous struct/union that's a static member of 1299 // the base object's class. However, under the current standard, 1300 // static data members cannot be anonymous structs or unions. 1301 // Supporting this is as easy as building a MemberExpr here. 1302 assert(!baseObjectExpr && "anonymous struct/union is static data member?"); 1303 1304 DeclarationNameInfo baseNameInfo(DeclarationName(), loc); 1305 1306 ExprResult result = 1307 BuildDeclarationNameExpr(EmptySS, baseNameInfo, baseVariable); 1308 if (result.isInvalid()) return ExprError(); 1309 1310 baseObjectExpr = result.take(); 1311 baseObjectIsPointer = false; 1312 baseQuals = baseObjectExpr->getType().getQualifiers(); 1313 1314 // Case 2: the base of the indirect field is a field and the user 1315 // wrote a member expression. 1316 } else if (baseObjectExpr) { 1317 // The caller provided the base object expression. Determine 1318 // whether its a pointer and whether it adds any qualifiers to the 1319 // anonymous struct/union fields we're looking into. 1320 QualType objectType = baseObjectExpr->getType(); 1321 1322 if (const PointerType *ptr = objectType->getAs<PointerType>()) { 1323 baseObjectIsPointer = true; 1324 objectType = ptr->getPointeeType(); 1325 } else { 1326 baseObjectIsPointer = false; 1327 } 1328 baseQuals = objectType.getQualifiers(); 1329 1330 // Case 3: the base of the indirect field is a field and we should 1331 // build an implicit member access. 1332 } else { 1333 // We've found a member of an anonymous struct/union that is 1334 // inside a non-anonymous struct/union, so in a well-formed 1335 // program our base object expression is "this". 1336 QualType ThisTy = getAndCaptureCurrentThisType(); 1337 if (ThisTy.isNull()) { 1338 Diag(loc, diag::err_invalid_member_use_in_static_method) 1339 << indirectField->getDeclName(); 1340 return ExprError(); 1341 } 1342 1343 // Our base object expression is "this". 1344 baseObjectExpr = 1345 new (Context) CXXThisExpr(loc, ThisTy, /*isImplicit=*/ true); 1346 baseObjectIsPointer = true; 1347 baseQuals = ThisTy->castAs<PointerType>()->getPointeeType().getQualifiers(); 1348 } 1349 1350 // Build the implicit member references to the field of the 1351 // anonymous struct/union. 1352 Expr *result = baseObjectExpr; 1353 IndirectFieldDecl::chain_iterator 1354 FI = indirectField->chain_begin(), FEnd = indirectField->chain_end(); 1355 1356 // Build the first member access in the chain with full information. 1357 if (!baseVariable) { 1358 FieldDecl *field = cast<FieldDecl>(*FI); 1359 1360 // FIXME: use the real found-decl info! 1361 DeclAccessPair foundDecl = DeclAccessPair::make(field, field->getAccess()); 1362 1363 // Make a nameInfo that properly uses the anonymous name. 1364 DeclarationNameInfo memberNameInfo(field->getDeclName(), loc); 1365 1366 result = BuildFieldReferenceExpr(*this, result, baseObjectIsPointer, 1367 EmptySS, field, foundDecl, 1368 memberNameInfo).take(); 1369 baseObjectIsPointer = false; 1370 1371 // FIXME: check qualified member access 1372 } 1373 1374 // In all cases, we should now skip the first declaration in the chain. 1375 ++FI; 1376 1377 while (FI != FEnd) { 1378 FieldDecl *field = cast<FieldDecl>(*FI++); 1379 1380 // FIXME: these are somewhat meaningless 1381 DeclarationNameInfo memberNameInfo(field->getDeclName(), loc); 1382 DeclAccessPair foundDecl = DeclAccessPair::make(field, field->getAccess()); 1383 1384 result = BuildFieldReferenceExpr(*this, result, /*isarrow*/ false, 1385 (FI == FEnd? SS : EmptySS), field, 1386 foundDecl, memberNameInfo) 1387 .take(); 1388 } 1389 1390 return Owned(result); 1391} 1392 1393/// Decomposes the given name into a DeclarationNameInfo, its location, and 1394/// possibly a list of template arguments. 1395/// 1396/// If this produces template arguments, it is permitted to call 1397/// DecomposeTemplateName. 1398/// 1399/// This actually loses a lot of source location information for 1400/// non-standard name kinds; we should consider preserving that in 1401/// some way. 1402static void DecomposeUnqualifiedId(Sema &SemaRef, 1403 const UnqualifiedId &Id, 1404 TemplateArgumentListInfo &Buffer, 1405 DeclarationNameInfo &NameInfo, 1406 const TemplateArgumentListInfo *&TemplateArgs) { 1407 if (Id.getKind() == UnqualifiedId::IK_TemplateId) { 1408 Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc); 1409 Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc); 1410 1411 ASTTemplateArgsPtr TemplateArgsPtr(SemaRef, 1412 Id.TemplateId->getTemplateArgs(), 1413 Id.TemplateId->NumArgs); 1414 SemaRef.translateTemplateArguments(TemplateArgsPtr, Buffer); 1415 TemplateArgsPtr.release(); 1416 1417 TemplateName TName = Id.TemplateId->Template.get(); 1418 SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc; 1419 NameInfo = SemaRef.Context.getNameForTemplate(TName, TNameLoc); 1420 TemplateArgs = &Buffer; 1421 } else { 1422 NameInfo = SemaRef.GetNameFromUnqualifiedId(Id); 1423 TemplateArgs = 0; 1424 } 1425} 1426 1427/// Determines if the given class is provably not derived from all of 1428/// the prospective base classes. 1429static bool IsProvablyNotDerivedFrom(Sema &SemaRef, 1430 CXXRecordDecl *Record, 1431 const llvm::SmallPtrSet<CXXRecordDecl*, 4> &Bases) { 1432 if (Bases.count(Record->getCanonicalDecl())) 1433 return false; 1434 1435 RecordDecl *RD = Record->getDefinition(); 1436 if (!RD) return false; 1437 Record = cast<CXXRecordDecl>(RD); 1438 1439 for (CXXRecordDecl::base_class_iterator I = Record->bases_begin(), 1440 E = Record->bases_end(); I != E; ++I) { 1441 CanQualType BaseT = SemaRef.Context.getCanonicalType((*I).getType()); 1442 CanQual<RecordType> BaseRT = BaseT->getAs<RecordType>(); 1443 if (!BaseRT) return false; 1444 1445 CXXRecordDecl *BaseRecord = cast<CXXRecordDecl>(BaseRT->getDecl()); 1446 if (!IsProvablyNotDerivedFrom(SemaRef, BaseRecord, Bases)) 1447 return false; 1448 } 1449 1450 return true; 1451} 1452 1453enum IMAKind { 1454 /// The reference is definitely not an instance member access. 1455 IMA_Static, 1456 1457 /// The reference may be an implicit instance member access. 1458 IMA_Mixed, 1459 1460 /// The reference may be to an instance member, but it is invalid if 1461 /// so, because the context is not an instance method. 1462 IMA_Mixed_StaticContext, 1463 1464 /// The reference may be to an instance member, but it is invalid if 1465 /// so, because the context is from an unrelated class. 1466 IMA_Mixed_Unrelated, 1467 1468 /// The reference is definitely an implicit instance member access. 1469 IMA_Instance, 1470 1471 /// The reference may be to an unresolved using declaration. 1472 IMA_Unresolved, 1473 1474 /// The reference may be to an unresolved using declaration and the 1475 /// context is not an instance method. 1476 IMA_Unresolved_StaticContext, 1477 1478 /// All possible referrents are instance members and the current 1479 /// context is not an instance method. 1480 IMA_Error_StaticContext, 1481 1482 /// All possible referrents are instance members of an unrelated 1483 /// class. 1484 IMA_Error_Unrelated 1485}; 1486 1487/// The given lookup names class member(s) and is not being used for 1488/// an address-of-member expression. Classify the type of access 1489/// according to whether it's possible that this reference names an 1490/// instance member. This is best-effort; it is okay to 1491/// conservatively answer "yes", in which case some errors will simply 1492/// not be caught until template-instantiation. 1493static IMAKind ClassifyImplicitMemberAccess(Sema &SemaRef, 1494 Scope *CurScope, 1495 const LookupResult &R) { 1496 assert(!R.empty() && (*R.begin())->isCXXClassMember()); 1497 1498 DeclContext *DC = SemaRef.getFunctionLevelDeclContext(); 1499 1500 bool isStaticContext = 1501 (!isa<CXXMethodDecl>(DC) || 1502 cast<CXXMethodDecl>(DC)->isStatic()); 1503 1504 // C++0x [expr.prim]p4: 1505 // Otherwise, if a member-declarator declares a non-static data member 1506 // of a class X, the expression this is a prvalue of type "pointer to X" 1507 // within the optional brace-or-equal-initializer. 1508 if (CurScope->getFlags() & Scope::ThisScope) 1509 isStaticContext = false; 1510 1511 if (R.isUnresolvableResult()) 1512 return isStaticContext ? IMA_Unresolved_StaticContext : IMA_Unresolved; 1513 1514 // Collect all the declaring classes of instance members we find. 1515 bool hasNonInstance = false; 1516 bool hasField = false; 1517 llvm::SmallPtrSet<CXXRecordDecl*, 4> Classes; 1518 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { 1519 NamedDecl *D = *I; 1520 1521 if (D->isCXXInstanceMember()) { 1522 if (dyn_cast<FieldDecl>(D)) 1523 hasField = true; 1524 1525 CXXRecordDecl *R = cast<CXXRecordDecl>(D->getDeclContext()); 1526 Classes.insert(R->getCanonicalDecl()); 1527 } 1528 else 1529 hasNonInstance = true; 1530 } 1531 1532 // If we didn't find any instance members, it can't be an implicit 1533 // member reference. 1534 if (Classes.empty()) 1535 return IMA_Static; 1536 1537 // If the current context is not an instance method, it can't be 1538 // an implicit member reference. 1539 if (isStaticContext) { 1540 if (hasNonInstance) 1541 return IMA_Mixed_StaticContext; 1542 1543 if (SemaRef.getLangOptions().CPlusPlus0x && hasField) { 1544 // C++0x [expr.prim.general]p10: 1545 // An id-expression that denotes a non-static data member or non-static 1546 // member function of a class can only be used: 1547 // (...) 1548 // - if that id-expression denotes a non-static data member and it appears in an unevaluated operand. 1549 const Sema::ExpressionEvaluationContextRecord& record = SemaRef.ExprEvalContexts.back(); 1550 bool isUnevaluatedExpression = record.Context == Sema::Unevaluated; 1551 if (isUnevaluatedExpression) 1552 return IMA_Mixed_StaticContext; 1553 } 1554 1555 return IMA_Error_StaticContext; 1556 } 1557 1558 CXXRecordDecl *contextClass; 1559 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) 1560 contextClass = MD->getParent()->getCanonicalDecl(); 1561 else 1562 contextClass = cast<CXXRecordDecl>(DC); 1563 1564 // [class.mfct.non-static]p3: 1565 // ...is used in the body of a non-static member function of class X, 1566 // if name lookup (3.4.1) resolves the name in the id-expression to a 1567 // non-static non-type member of some class C [...] 1568 // ...if C is not X or a base class of X, the class member access expression 1569 // is ill-formed. 1570 if (R.getNamingClass() && 1571 contextClass != R.getNamingClass()->getCanonicalDecl() && 1572 contextClass->isProvablyNotDerivedFrom(R.getNamingClass())) 1573 return (hasNonInstance ? IMA_Mixed_Unrelated : IMA_Error_Unrelated); 1574 1575 // If we can prove that the current context is unrelated to all the 1576 // declaring classes, it can't be an implicit member reference (in 1577 // which case it's an error if any of those members are selected). 1578 if (IsProvablyNotDerivedFrom(SemaRef, contextClass, Classes)) 1579 return (hasNonInstance ? IMA_Mixed_Unrelated : IMA_Error_Unrelated); 1580 1581 return (hasNonInstance ? IMA_Mixed : IMA_Instance); 1582} 1583 1584/// Diagnose a reference to a field with no object available. 1585static void DiagnoseInstanceReference(Sema &SemaRef, 1586 const CXXScopeSpec &SS, 1587 NamedDecl *rep, 1588 const DeclarationNameInfo &nameInfo) { 1589 SourceLocation Loc = nameInfo.getLoc(); 1590 SourceRange Range(Loc); 1591 if (SS.isSet()) Range.setBegin(SS.getRange().getBegin()); 1592 1593 if (isa<FieldDecl>(rep) || isa<IndirectFieldDecl>(rep)) { 1594 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(SemaRef.CurContext)) { 1595 if (MD->isStatic()) { 1596 // "invalid use of member 'x' in static member function" 1597 SemaRef.Diag(Loc, diag::err_invalid_member_use_in_static_method) 1598 << Range << nameInfo.getName(); 1599 return; 1600 } 1601 } 1602 1603 SemaRef.Diag(Loc, diag::err_invalid_non_static_member_use) 1604 << nameInfo.getName() << Range; 1605 return; 1606 } 1607 1608 SemaRef.Diag(Loc, diag::err_member_call_without_object) << Range; 1609} 1610 1611/// Diagnose an empty lookup. 1612/// 1613/// \return false if new lookup candidates were found 1614bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, 1615 CorrectTypoContext CTC) { 1616 DeclarationName Name = R.getLookupName(); 1617 1618 unsigned diagnostic = diag::err_undeclared_var_use; 1619 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest; 1620 if (Name.getNameKind() == DeclarationName::CXXOperatorName || 1621 Name.getNameKind() == DeclarationName::CXXLiteralOperatorName || 1622 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 1623 diagnostic = diag::err_undeclared_use; 1624 diagnostic_suggest = diag::err_undeclared_use_suggest; 1625 } 1626 1627 // If the original lookup was an unqualified lookup, fake an 1628 // unqualified lookup. This is useful when (for example) the 1629 // original lookup would not have found something because it was a 1630 // dependent name. 1631 for (DeclContext *DC = SS.isEmpty() ? CurContext : 0; 1632 DC; DC = DC->getParent()) { 1633 if (isa<CXXRecordDecl>(DC)) { 1634 LookupQualifiedName(R, DC); 1635 1636 if (!R.empty()) { 1637 // Don't give errors about ambiguities in this lookup. 1638 R.suppressDiagnostics(); 1639 1640 CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext); 1641 bool isInstance = CurMethod && 1642 CurMethod->isInstance() && 1643 DC == CurMethod->getParent(); 1644 1645 // Give a code modification hint to insert 'this->'. 1646 // TODO: fixit for inserting 'Base<T>::' in the other cases. 1647 // Actually quite difficult! 1648 if (isInstance) { 1649 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>( 1650 CallsUndergoingInstantiation.back()->getCallee()); 1651 CXXMethodDecl *DepMethod = cast_or_null<CXXMethodDecl>( 1652 CurMethod->getInstantiatedFromMemberFunction()); 1653 if (DepMethod) { 1654 Diag(R.getNameLoc(), diagnostic) << Name 1655 << FixItHint::CreateInsertion(R.getNameLoc(), "this->"); 1656 QualType DepThisType = DepMethod->getThisType(Context); 1657 CXXThisExpr *DepThis = new (Context) CXXThisExpr( 1658 R.getNameLoc(), DepThisType, false); 1659 TemplateArgumentListInfo TList; 1660 if (ULE->hasExplicitTemplateArgs()) 1661 ULE->copyTemplateArgumentsInto(TList); 1662 1663 CXXScopeSpec SS; 1664 SS.Adopt(ULE->getQualifierLoc()); 1665 CXXDependentScopeMemberExpr *DepExpr = 1666 CXXDependentScopeMemberExpr::Create( 1667 Context, DepThis, DepThisType, true, SourceLocation(), 1668 SS.getWithLocInContext(Context), NULL, 1669 R.getLookupNameInfo(), &TList); 1670 CallsUndergoingInstantiation.back()->setCallee(DepExpr); 1671 } else { 1672 // FIXME: we should be able to handle this case too. It is correct 1673 // to add this-> here. This is a workaround for PR7947. 1674 Diag(R.getNameLoc(), diagnostic) << Name; 1675 } 1676 } else { 1677 Diag(R.getNameLoc(), diagnostic) << Name; 1678 } 1679 1680 // Do we really want to note all of these? 1681 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) 1682 Diag((*I)->getLocation(), diag::note_dependent_var_use); 1683 1684 // Tell the callee to try to recover. 1685 return false; 1686 } 1687 1688 R.clear(); 1689 } 1690 } 1691 1692 // We didn't find anything, so try to correct for a typo. 1693 DeclarationName Corrected; 1694 if (S && (Corrected = CorrectTypo(R, S, &SS, 0, false, CTC))) { 1695 if (!R.empty()) { 1696 if (isa<ValueDecl>(*R.begin()) || isa<FunctionTemplateDecl>(*R.begin())) { 1697 if (SS.isEmpty()) 1698 Diag(R.getNameLoc(), diagnostic_suggest) << Name << R.getLookupName() 1699 << FixItHint::CreateReplacement(R.getNameLoc(), 1700 R.getLookupName().getAsString()); 1701 else 1702 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1703 << Name << computeDeclContext(SS, false) << R.getLookupName() 1704 << SS.getRange() 1705 << FixItHint::CreateReplacement(R.getNameLoc(), 1706 R.getLookupName().getAsString()); 1707 if (NamedDecl *ND = R.getAsSingle<NamedDecl>()) 1708 Diag(ND->getLocation(), diag::note_previous_decl) 1709 << ND->getDeclName(); 1710 1711 // Tell the callee to try to recover. 1712 return false; 1713 } 1714 1715 if (isa<TypeDecl>(*R.begin()) || isa<ObjCInterfaceDecl>(*R.begin())) { 1716 // FIXME: If we ended up with a typo for a type name or 1717 // Objective-C class name, we're in trouble because the parser 1718 // is in the wrong place to recover. Suggest the typo 1719 // correction, but don't make it a fix-it since we're not going 1720 // to recover well anyway. 1721 if (SS.isEmpty()) 1722 Diag(R.getNameLoc(), diagnostic_suggest) << Name << R.getLookupName(); 1723 else 1724 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1725 << Name << computeDeclContext(SS, false) << R.getLookupName() 1726 << SS.getRange(); 1727 1728 // Don't try to recover; it won't work. 1729 return true; 1730 } 1731 } else { 1732 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it 1733 // because we aren't able to recover. 1734 if (SS.isEmpty()) 1735 Diag(R.getNameLoc(), diagnostic_suggest) << Name << Corrected; 1736 else 1737 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1738 << Name << computeDeclContext(SS, false) << Corrected 1739 << SS.getRange(); 1740 return true; 1741 } 1742 R.clear(); 1743 } 1744 1745 // Emit a special diagnostic for failed member lookups. 1746 // FIXME: computing the declaration context might fail here (?) 1747 if (!SS.isEmpty()) { 1748 Diag(R.getNameLoc(), diag::err_no_member) 1749 << Name << computeDeclContext(SS, false) 1750 << SS.getRange(); 1751 return true; 1752 } 1753 1754 // Give up, we can't recover. 1755 Diag(R.getNameLoc(), diagnostic) << Name; 1756 return true; 1757} 1758 1759ObjCPropertyDecl *Sema::canSynthesizeProvisionalIvar(IdentifierInfo *II) { 1760 ObjCMethodDecl *CurMeth = getCurMethodDecl(); 1761 ObjCInterfaceDecl *IDecl = CurMeth->getClassInterface(); 1762 if (!IDecl) 1763 return 0; 1764 ObjCImplementationDecl *ClassImpDecl = IDecl->getImplementation(); 1765 if (!ClassImpDecl) 1766 return 0; 1767 ObjCPropertyDecl *property = LookupPropertyDecl(IDecl, II); 1768 if (!property) 1769 return 0; 1770 if (ObjCPropertyImplDecl *PIDecl = ClassImpDecl->FindPropertyImplDecl(II)) 1771 if (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic || 1772 PIDecl->getPropertyIvarDecl()) 1773 return 0; 1774 return property; 1775} 1776 1777bool Sema::canSynthesizeProvisionalIvar(ObjCPropertyDecl *Property) { 1778 ObjCMethodDecl *CurMeth = getCurMethodDecl(); 1779 ObjCInterfaceDecl *IDecl = CurMeth->getClassInterface(); 1780 if (!IDecl) 1781 return false; 1782 ObjCImplementationDecl *ClassImpDecl = IDecl->getImplementation(); 1783 if (!ClassImpDecl) 1784 return false; 1785 if (ObjCPropertyImplDecl *PIDecl 1786 = ClassImpDecl->FindPropertyImplDecl(Property->getIdentifier())) 1787 if (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic || 1788 PIDecl->getPropertyIvarDecl()) 1789 return false; 1790 1791 return true; 1792} 1793 1794ObjCIvarDecl *Sema::SynthesizeProvisionalIvar(LookupResult &Lookup, 1795 IdentifierInfo *II, 1796 SourceLocation NameLoc) { 1797 ObjCMethodDecl *CurMeth = getCurMethodDecl(); 1798 bool LookForIvars; 1799 if (Lookup.empty()) 1800 LookForIvars = true; 1801 else if (CurMeth->isClassMethod()) 1802 LookForIvars = false; 1803 else 1804 LookForIvars = (Lookup.isSingleResult() && 1805 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod() && 1806 (Lookup.getAsSingle<VarDecl>() != 0)); 1807 if (!LookForIvars) 1808 return 0; 1809 1810 ObjCInterfaceDecl *IDecl = CurMeth->getClassInterface(); 1811 if (!IDecl) 1812 return 0; 1813 ObjCImplementationDecl *ClassImpDecl = IDecl->getImplementation(); 1814 if (!ClassImpDecl) 1815 return 0; 1816 bool DynamicImplSeen = false; 1817 ObjCPropertyDecl *property = LookupPropertyDecl(IDecl, II); 1818 if (!property) 1819 return 0; 1820 if (ObjCPropertyImplDecl *PIDecl = ClassImpDecl->FindPropertyImplDecl(II)) { 1821 DynamicImplSeen = 1822 (PIDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic); 1823 // property implementation has a designated ivar. No need to assume a new 1824 // one. 1825 if (!DynamicImplSeen && PIDecl->getPropertyIvarDecl()) 1826 return 0; 1827 } 1828 if (!DynamicImplSeen) { 1829 QualType PropType = Context.getCanonicalType(property->getType()); 1830 ObjCIvarDecl *Ivar = ObjCIvarDecl::Create(Context, ClassImpDecl, 1831 NameLoc, NameLoc, 1832 II, PropType, /*Dinfo=*/0, 1833 ObjCIvarDecl::Private, 1834 (Expr *)0, true); 1835 ClassImpDecl->addDecl(Ivar); 1836 IDecl->makeDeclVisibleInContext(Ivar, false); 1837 property->setPropertyIvarDecl(Ivar); 1838 return Ivar; 1839 } 1840 return 0; 1841} 1842 1843ExprResult Sema::ActOnIdExpression(Scope *S, 1844 CXXScopeSpec &SS, 1845 UnqualifiedId &Id, 1846 bool HasTrailingLParen, 1847 bool isAddressOfOperand) { 1848 assert(!(isAddressOfOperand && HasTrailingLParen) && 1849 "cannot be direct & operand and have a trailing lparen"); 1850 1851 if (SS.isInvalid()) 1852 return ExprError(); 1853 1854 TemplateArgumentListInfo TemplateArgsBuffer; 1855 1856 // Decompose the UnqualifiedId into the following data. 1857 DeclarationNameInfo NameInfo; 1858 const TemplateArgumentListInfo *TemplateArgs; 1859 DecomposeUnqualifiedId(*this, Id, TemplateArgsBuffer, NameInfo, TemplateArgs); 1860 1861 DeclarationName Name = NameInfo.getName(); 1862 IdentifierInfo *II = Name.getAsIdentifierInfo(); 1863 SourceLocation NameLoc = NameInfo.getLoc(); 1864 1865 // C++ [temp.dep.expr]p3: 1866 // An id-expression is type-dependent if it contains: 1867 // -- an identifier that was declared with a dependent type, 1868 // (note: handled after lookup) 1869 // -- a template-id that is dependent, 1870 // (note: handled in BuildTemplateIdExpr) 1871 // -- a conversion-function-id that specifies a dependent type, 1872 // -- a nested-name-specifier that contains a class-name that 1873 // names a dependent type. 1874 // Determine whether this is a member of an unknown specialization; 1875 // we need to handle these differently. 1876 bool DependentID = false; 1877 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName && 1878 Name.getCXXNameType()->isDependentType()) { 1879 DependentID = true; 1880 } else if (SS.isSet()) { 1881 if (DeclContext *DC = computeDeclContext(SS, false)) { 1882 if (RequireCompleteDeclContext(SS, DC)) 1883 return ExprError(); 1884 } else { 1885 DependentID = true; 1886 } 1887 } 1888 1889 if (DependentID) 1890 return ActOnDependentIdExpression(SS, NameInfo, isAddressOfOperand, 1891 TemplateArgs); 1892 1893 bool IvarLookupFollowUp = false; 1894 // Perform the required lookup. 1895 LookupResult R(*this, NameInfo, LookupOrdinaryName); 1896 if (TemplateArgs) { 1897 // Lookup the template name again to correctly establish the context in 1898 // which it was found. This is really unfortunate as we already did the 1899 // lookup to determine that it was a template name in the first place. If 1900 // this becomes a performance hit, we can work harder to preserve those 1901 // results until we get here but it's likely not worth it. 1902 bool MemberOfUnknownSpecialization; 1903 LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false, 1904 MemberOfUnknownSpecialization); 1905 1906 if (MemberOfUnknownSpecialization || 1907 (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)) 1908 return ActOnDependentIdExpression(SS, NameInfo, isAddressOfOperand, 1909 TemplateArgs); 1910 } else { 1911 IvarLookupFollowUp = (!SS.isSet() && II && getCurMethodDecl()); 1912 LookupParsedName(R, S, &SS, !IvarLookupFollowUp); 1913 1914 // If the result might be in a dependent base class, this is a dependent 1915 // id-expression. 1916 if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation) 1917 return ActOnDependentIdExpression(SS, NameInfo, isAddressOfOperand, 1918 TemplateArgs); 1919 1920 // If this reference is in an Objective-C method, then we need to do 1921 // some special Objective-C lookup, too. 1922 if (IvarLookupFollowUp) { 1923 ExprResult E(LookupInObjCMethod(R, S, II, true)); 1924 if (E.isInvalid()) 1925 return ExprError(); 1926 1927 if (Expr *Ex = E.takeAs<Expr>()) 1928 return Owned(Ex); 1929 1930 // Synthesize ivars lazily. 1931 if (getLangOptions().ObjCDefaultSynthProperties && 1932 getLangOptions().ObjCNonFragileABI2) { 1933 if (SynthesizeProvisionalIvar(R, II, NameLoc)) { 1934 if (const ObjCPropertyDecl *Property = 1935 canSynthesizeProvisionalIvar(II)) { 1936 Diag(NameLoc, diag::warn_synthesized_ivar_access) << II; 1937 Diag(Property->getLocation(), diag::note_property_declare); 1938 } 1939 return ActOnIdExpression(S, SS, Id, HasTrailingLParen, 1940 isAddressOfOperand); 1941 } 1942 } 1943 // for further use, this must be set to false if in class method. 1944 IvarLookupFollowUp = getCurMethodDecl()->isInstanceMethod(); 1945 } 1946 } 1947 1948 if (R.isAmbiguous()) 1949 return ExprError(); 1950 1951 // Determine whether this name might be a candidate for 1952 // argument-dependent lookup. 1953 bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen); 1954 1955 if (R.empty() && !ADL) { 1956 // Otherwise, this could be an implicitly declared function reference (legal 1957 // in C90, extension in C99, forbidden in C++). 1958 if (HasTrailingLParen && II && !getLangOptions().CPlusPlus) { 1959 NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S); 1960 if (D) R.addDecl(D); 1961 } 1962 1963 // If this name wasn't predeclared and if this is not a function 1964 // call, diagnose the problem. 1965 if (R.empty()) { 1966 if (DiagnoseEmptyLookup(S, SS, R, CTC_Unknown)) 1967 return ExprError(); 1968 1969 assert(!R.empty() && 1970 "DiagnoseEmptyLookup returned false but added no results"); 1971 1972 // If we found an Objective-C instance variable, let 1973 // LookupInObjCMethod build the appropriate expression to 1974 // reference the ivar. 1975 if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) { 1976 R.clear(); 1977 ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier())); 1978 assert(E.isInvalid() || E.get()); 1979 return move(E); 1980 } 1981 } 1982 } 1983 1984 // This is guaranteed from this point on. 1985 assert(!R.empty() || ADL); 1986 1987 // Check whether this might be a C++ implicit instance member access. 1988 // C++ [class.mfct.non-static]p3: 1989 // When an id-expression that is not part of a class member access 1990 // syntax and not used to form a pointer to member is used in the 1991 // body of a non-static member function of class X, if name lookup 1992 // resolves the name in the id-expression to a non-static non-type 1993 // member of some class C, the id-expression is transformed into a 1994 // class member access expression using (*this) as the 1995 // postfix-expression to the left of the . operator. 1996 // 1997 // But we don't actually need to do this for '&' operands if R 1998 // resolved to a function or overloaded function set, because the 1999 // expression is ill-formed if it actually works out to be a 2000 // non-static member function: 2001 // 2002 // C++ [expr.ref]p4: 2003 // Otherwise, if E1.E2 refers to a non-static member function. . . 2004 // [t]he expression can be used only as the left-hand operand of a 2005 // member function call. 2006 // 2007 // There are other safeguards against such uses, but it's important 2008 // to get this right here so that we don't end up making a 2009 // spuriously dependent expression if we're inside a dependent 2010 // instance method. 2011 if (!R.empty() && (*R.begin())->isCXXClassMember()) { 2012 bool MightBeImplicitMember; 2013 if (!isAddressOfOperand) 2014 MightBeImplicitMember = true; 2015 else if (!SS.isEmpty()) 2016 MightBeImplicitMember = false; 2017 else if (R.isOverloadedResult()) 2018 MightBeImplicitMember = false; 2019 else if (R.isUnresolvableResult()) 2020 MightBeImplicitMember = true; 2021 else 2022 MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) || 2023 isa<IndirectFieldDecl>(R.getFoundDecl()); 2024 2025 if (MightBeImplicitMember) 2026 return BuildPossibleImplicitMemberExpr(SS, R, TemplateArgs); 2027 } 2028 2029 if (TemplateArgs) 2030 return BuildTemplateIdExpr(SS, R, ADL, *TemplateArgs); 2031 2032 return BuildDeclarationNameExpr(SS, R, ADL); 2033} 2034 2035/// Builds an expression which might be an implicit member expression. 2036ExprResult 2037Sema::BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, 2038 LookupResult &R, 2039 const TemplateArgumentListInfo *TemplateArgs) { 2040 switch (ClassifyImplicitMemberAccess(*this, CurScope, R)) { 2041 case IMA_Instance: 2042 return BuildImplicitMemberExpr(SS, R, TemplateArgs, true); 2043 2044 case IMA_Mixed: 2045 case IMA_Mixed_Unrelated: 2046 case IMA_Unresolved: 2047 return BuildImplicitMemberExpr(SS, R, TemplateArgs, false); 2048 2049 case IMA_Static: 2050 case IMA_Mixed_StaticContext: 2051 case IMA_Unresolved_StaticContext: 2052 if (TemplateArgs) 2053 return BuildTemplateIdExpr(SS, R, false, *TemplateArgs); 2054 return BuildDeclarationNameExpr(SS, R, false); 2055 2056 case IMA_Error_StaticContext: 2057 case IMA_Error_Unrelated: 2058 DiagnoseInstanceReference(*this, SS, R.getRepresentativeDecl(), 2059 R.getLookupNameInfo()); 2060 return ExprError(); 2061 } 2062 2063 llvm_unreachable("unexpected instance member access kind"); 2064 return ExprError(); 2065} 2066 2067/// BuildQualifiedDeclarationNameExpr - Build a C++ qualified 2068/// declaration name, generally during template instantiation. 2069/// There's a large number of things which don't need to be done along 2070/// this path. 2071ExprResult 2072Sema::BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, 2073 const DeclarationNameInfo &NameInfo) { 2074 DeclContext *DC; 2075 if (!(DC = computeDeclContext(SS, false)) || DC->isDependentContext()) 2076 return BuildDependentDeclRefExpr(SS, NameInfo, 0); 2077 2078 if (RequireCompleteDeclContext(SS, DC)) 2079 return ExprError(); 2080 2081 LookupResult R(*this, NameInfo, LookupOrdinaryName); 2082 LookupQualifiedName(R, DC); 2083 2084 if (R.isAmbiguous()) 2085 return ExprError(); 2086 2087 if (R.empty()) { 2088 Diag(NameInfo.getLoc(), diag::err_no_member) 2089 << NameInfo.getName() << DC << SS.getRange(); 2090 return ExprError(); 2091 } 2092 2093 return BuildDeclarationNameExpr(SS, R, /*ADL*/ false); 2094} 2095 2096/// LookupInObjCMethod - The parser has read a name in, and Sema has 2097/// detected that we're currently inside an ObjC method. Perform some 2098/// additional lookup. 2099/// 2100/// Ideally, most of this would be done by lookup, but there's 2101/// actually quite a lot of extra work involved. 2102/// 2103/// Returns a null sentinel to indicate trivial success. 2104ExprResult 2105Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S, 2106 IdentifierInfo *II, bool AllowBuiltinCreation) { 2107 SourceLocation Loc = Lookup.getNameLoc(); 2108 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 2109 2110 // There are two cases to handle here. 1) scoped lookup could have failed, 2111 // in which case we should look for an ivar. 2) scoped lookup could have 2112 // found a decl, but that decl is outside the current instance method (i.e. 2113 // a global variable). In these two cases, we do a lookup for an ivar with 2114 // this name, if the lookup sucedes, we replace it our current decl. 2115 2116 // If we're in a class method, we don't normally want to look for 2117 // ivars. But if we don't find anything else, and there's an 2118 // ivar, that's an error. 2119 bool IsClassMethod = CurMethod->isClassMethod(); 2120 2121 bool LookForIvars; 2122 if (Lookup.empty()) 2123 LookForIvars = true; 2124 else if (IsClassMethod) 2125 LookForIvars = false; 2126 else 2127 LookForIvars = (Lookup.isSingleResult() && 2128 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()); 2129 ObjCInterfaceDecl *IFace = 0; 2130 if (LookForIvars) { 2131 IFace = CurMethod->getClassInterface(); 2132 ObjCInterfaceDecl *ClassDeclared; 2133 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) { 2134 // Diagnose using an ivar in a class method. 2135 if (IsClassMethod) 2136 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 2137 << IV->getDeclName()); 2138 2139 // If we're referencing an invalid decl, just return this as a silent 2140 // error node. The error diagnostic was already emitted on the decl. 2141 if (IV->isInvalidDecl()) 2142 return ExprError(); 2143 2144 // Check if referencing a field with __attribute__((deprecated)). 2145 if (DiagnoseUseOfDecl(IV, Loc)) 2146 return ExprError(); 2147 2148 // Diagnose the use of an ivar outside of the declaring class. 2149 if (IV->getAccessControl() == ObjCIvarDecl::Private && 2150 ClassDeclared != IFace) 2151 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName(); 2152 2153 // FIXME: This should use a new expr for a direct reference, don't 2154 // turn this into Self->ivar, just return a BareIVarExpr or something. 2155 IdentifierInfo &II = Context.Idents.get("self"); 2156 UnqualifiedId SelfName; 2157 SelfName.setIdentifier(&II, SourceLocation()); 2158 CXXScopeSpec SelfScopeSpec; 2159 ExprResult SelfExpr = ActOnIdExpression(S, SelfScopeSpec, 2160 SelfName, false, false); 2161 if (SelfExpr.isInvalid()) 2162 return ExprError(); 2163 2164 SelfExpr = DefaultLvalueConversion(SelfExpr.take()); 2165 if (SelfExpr.isInvalid()) 2166 return ExprError(); 2167 2168 MarkDeclarationReferenced(Loc, IV); 2169 Expr *base = SelfExpr.take(); 2170 base = base->IgnoreParenImpCasts(); 2171 if (const DeclRefExpr *DE = dyn_cast<DeclRefExpr>(base)) { 2172 const NamedDecl *ND = DE->getDecl(); 2173 if (!isa<ImplicitParamDecl>(ND)) { 2174 // relax the rule such that it is allowed to have a shadow 'self' 2175 // where stand-alone ivar can be found in this 'self' object. 2176 // This is to match gcc's behavior. 2177 ObjCInterfaceDecl *selfIFace = 0; 2178 if (const ObjCObjectPointerType *OPT = 2179 base->getType()->getAsObjCInterfacePointerType()) 2180 selfIFace = OPT->getInterfaceDecl(); 2181 if (!selfIFace || 2182 !selfIFace->lookupInstanceVariable(IV->getIdentifier())) { 2183 Diag(Loc, diag::error_implicit_ivar_access) 2184 << IV->getDeclName(); 2185 Diag(ND->getLocation(), diag::note_declared_at); 2186 return ExprError(); 2187 } 2188 } 2189 } 2190 return Owned(new (Context) 2191 ObjCIvarRefExpr(IV, IV->getType(), Loc, 2192 SelfExpr.take(), true, true)); 2193 } 2194 } else if (CurMethod->isInstanceMethod()) { 2195 // We should warn if a local variable hides an ivar. 2196 ObjCInterfaceDecl *IFace = CurMethod->getClassInterface(); 2197 ObjCInterfaceDecl *ClassDeclared; 2198 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) { 2199 if (IV->getAccessControl() != ObjCIvarDecl::Private || 2200 IFace == ClassDeclared) 2201 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName(); 2202 } 2203 } 2204 2205 if (Lookup.empty() && II && AllowBuiltinCreation) { 2206 // FIXME. Consolidate this with similar code in LookupName. 2207 if (unsigned BuiltinID = II->getBuiltinID()) { 2208 if (!(getLangOptions().CPlusPlus && 2209 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) { 2210 NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID, 2211 S, Lookup.isForRedeclaration(), 2212 Lookup.getNameLoc()); 2213 if (D) Lookup.addDecl(D); 2214 } 2215 } 2216 } 2217 // Sentinel value saying that we didn't do anything special. 2218 return Owned((Expr*) 0); 2219} 2220 2221/// \brief Cast a base object to a member's actual type. 2222/// 2223/// Logically this happens in three phases: 2224/// 2225/// * First we cast from the base type to the naming class. 2226/// The naming class is the class into which we were looking 2227/// when we found the member; it's the qualifier type if a 2228/// qualifier was provided, and otherwise it's the base type. 2229/// 2230/// * Next we cast from the naming class to the declaring class. 2231/// If the member we found was brought into a class's scope by 2232/// a using declaration, this is that class; otherwise it's 2233/// the class declaring the member. 2234/// 2235/// * Finally we cast from the declaring class to the "true" 2236/// declaring class of the member. This conversion does not 2237/// obey access control. 2238ExprResult 2239Sema::PerformObjectMemberConversion(Expr *From, 2240 NestedNameSpecifier *Qualifier, 2241 NamedDecl *FoundDecl, 2242 NamedDecl *Member) { 2243 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext()); 2244 if (!RD) 2245 return Owned(From); 2246 2247 QualType DestRecordType; 2248 QualType DestType; 2249 QualType FromRecordType; 2250 QualType FromType = From->getType(); 2251 bool PointerConversions = false; 2252 if (isa<FieldDecl>(Member)) { 2253 DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD)); 2254 2255 if (FromType->getAs<PointerType>()) { 2256 DestType = Context.getPointerType(DestRecordType); 2257 FromRecordType = FromType->getPointeeType(); 2258 PointerConversions = true; 2259 } else { 2260 DestType = DestRecordType; 2261 FromRecordType = FromType; 2262 } 2263 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) { 2264 if (Method->isStatic()) 2265 return Owned(From); 2266 2267 DestType = Method->getThisType(Context); 2268 DestRecordType = DestType->getPointeeType(); 2269 2270 if (FromType->getAs<PointerType>()) { 2271 FromRecordType = FromType->getPointeeType(); 2272 PointerConversions = true; 2273 } else { 2274 FromRecordType = FromType; 2275 DestType = DestRecordType; 2276 } 2277 } else { 2278 // No conversion necessary. 2279 return Owned(From); 2280 } 2281 2282 if (DestType->isDependentType() || FromType->isDependentType()) 2283 return Owned(From); 2284 2285 // If the unqualified types are the same, no conversion is necessary. 2286 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 2287 return Owned(From); 2288 2289 SourceRange FromRange = From->getSourceRange(); 2290 SourceLocation FromLoc = FromRange.getBegin(); 2291 2292 ExprValueKind VK = CastCategory(From); 2293 2294 // C++ [class.member.lookup]p8: 2295 // [...] Ambiguities can often be resolved by qualifying a name with its 2296 // class name. 2297 // 2298 // If the member was a qualified name and the qualified referred to a 2299 // specific base subobject type, we'll cast to that intermediate type 2300 // first and then to the object in which the member is declared. That allows 2301 // one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as: 2302 // 2303 // class Base { public: int x; }; 2304 // class Derived1 : public Base { }; 2305 // class Derived2 : public Base { }; 2306 // class VeryDerived : public Derived1, public Derived2 { void f(); }; 2307 // 2308 // void VeryDerived::f() { 2309 // x = 17; // error: ambiguous base subobjects 2310 // Derived1::x = 17; // okay, pick the Base subobject of Derived1 2311 // } 2312 if (Qualifier) { 2313 QualType QType = QualType(Qualifier->getAsType(), 0); 2314 assert(!QType.isNull() && "lookup done with dependent qualifier?"); 2315 assert(QType->isRecordType() && "lookup done with non-record type"); 2316 2317 QualType QRecordType = QualType(QType->getAs<RecordType>(), 0); 2318 2319 // In C++98, the qualifier type doesn't actually have to be a base 2320 // type of the object type, in which case we just ignore it. 2321 // Otherwise build the appropriate casts. 2322 if (IsDerivedFrom(FromRecordType, QRecordType)) { 2323 CXXCastPath BasePath; 2324 if (CheckDerivedToBaseConversion(FromRecordType, QRecordType, 2325 FromLoc, FromRange, &BasePath)) 2326 return ExprError(); 2327 2328 if (PointerConversions) 2329 QType = Context.getPointerType(QType); 2330 From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase, 2331 VK, &BasePath).take(); 2332 2333 FromType = QType; 2334 FromRecordType = QRecordType; 2335 2336 // If the qualifier type was the same as the destination type, 2337 // we're done. 2338 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 2339 return Owned(From); 2340 } 2341 } 2342 2343 bool IgnoreAccess = false; 2344 2345 // If we actually found the member through a using declaration, cast 2346 // down to the using declaration's type. 2347 // 2348 // Pointer equality is fine here because only one declaration of a 2349 // class ever has member declarations. 2350 if (FoundDecl->getDeclContext() != Member->getDeclContext()) { 2351 assert(isa<UsingShadowDecl>(FoundDecl)); 2352 QualType URecordType = Context.getTypeDeclType( 2353 cast<CXXRecordDecl>(FoundDecl->getDeclContext())); 2354 2355 // We only need to do this if the naming-class to declaring-class 2356 // conversion is non-trivial. 2357 if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) { 2358 assert(IsDerivedFrom(FromRecordType, URecordType)); 2359 CXXCastPath BasePath; 2360 if (CheckDerivedToBaseConversion(FromRecordType, URecordType, 2361 FromLoc, FromRange, &BasePath)) 2362 return ExprError(); 2363 2364 QualType UType = URecordType; 2365 if (PointerConversions) 2366 UType = Context.getPointerType(UType); 2367 From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase, 2368 VK, &BasePath).take(); 2369 FromType = UType; 2370 FromRecordType = URecordType; 2371 } 2372 2373 // We don't do access control for the conversion from the 2374 // declaring class to the true declaring class. 2375 IgnoreAccess = true; 2376 } 2377 2378 CXXCastPath BasePath; 2379 if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType, 2380 FromLoc, FromRange, &BasePath, 2381 IgnoreAccess)) 2382 return ExprError(); 2383 2384 return ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase, 2385 VK, &BasePath); 2386} 2387 2388/// \brief Build a MemberExpr AST node. 2389static MemberExpr *BuildMemberExpr(ASTContext &C, Expr *Base, bool isArrow, 2390 const CXXScopeSpec &SS, ValueDecl *Member, 2391 DeclAccessPair FoundDecl, 2392 const DeclarationNameInfo &MemberNameInfo, 2393 QualType Ty, 2394 ExprValueKind VK, ExprObjectKind OK, 2395 const TemplateArgumentListInfo *TemplateArgs = 0) { 2396 return MemberExpr::Create(C, Base, isArrow, SS.getWithLocInContext(C), 2397 Member, FoundDecl, MemberNameInfo, 2398 TemplateArgs, Ty, VK, OK); 2399} 2400 2401static ExprResult 2402BuildFieldReferenceExpr(Sema &S, Expr *BaseExpr, bool IsArrow, 2403 const CXXScopeSpec &SS, FieldDecl *Field, 2404 DeclAccessPair FoundDecl, 2405 const DeclarationNameInfo &MemberNameInfo) { 2406 // x.a is an l-value if 'a' has a reference type. Otherwise: 2407 // x.a is an l-value/x-value/pr-value if the base is (and note 2408 // that *x is always an l-value), except that if the base isn't 2409 // an ordinary object then we must have an rvalue. 2410 ExprValueKind VK = VK_LValue; 2411 ExprObjectKind OK = OK_Ordinary; 2412 if (!IsArrow) { 2413 if (BaseExpr->getObjectKind() == OK_Ordinary) 2414 VK = BaseExpr->getValueKind(); 2415 else 2416 VK = VK_RValue; 2417 } 2418 if (VK != VK_RValue && Field->isBitField()) 2419 OK = OK_BitField; 2420 2421 // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref] 2422 QualType MemberType = Field->getType(); 2423 if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>()) { 2424 MemberType = Ref->getPointeeType(); 2425 VK = VK_LValue; 2426 } else { 2427 QualType BaseType = BaseExpr->getType(); 2428 if (IsArrow) BaseType = BaseType->getAs<PointerType>()->getPointeeType(); 2429 2430 Qualifiers BaseQuals = BaseType.getQualifiers(); 2431 2432 // GC attributes are never picked up by members. 2433 BaseQuals.removeObjCGCAttr(); 2434 2435 // CVR attributes from the base are picked up by members, 2436 // except that 'mutable' members don't pick up 'const'. 2437 if (Field->isMutable()) BaseQuals.removeConst(); 2438 2439 Qualifiers MemberQuals 2440 = S.Context.getCanonicalType(MemberType).getQualifiers(); 2441 2442 // TR 18037 does not allow fields to be declared with address spaces. 2443 assert(!MemberQuals.hasAddressSpace()); 2444 2445 Qualifiers Combined = BaseQuals + MemberQuals; 2446 if (Combined != MemberQuals) 2447 MemberType = S.Context.getQualifiedType(MemberType, Combined); 2448 } 2449 2450 S.MarkDeclarationReferenced(MemberNameInfo.getLoc(), Field); 2451 ExprResult Base = 2452 S.PerformObjectMemberConversion(BaseExpr, SS.getScopeRep(), 2453 FoundDecl, Field); 2454 if (Base.isInvalid()) 2455 return ExprError(); 2456 return S.Owned(BuildMemberExpr(S.Context, Base.take(), IsArrow, SS, 2457 Field, FoundDecl, MemberNameInfo, 2458 MemberType, VK, OK)); 2459} 2460 2461/// Builds an implicit member access expression. The current context 2462/// is known to be an instance method, and the given unqualified lookup 2463/// set is known to contain only instance members, at least one of which 2464/// is from an appropriate type. 2465ExprResult 2466Sema::BuildImplicitMemberExpr(const CXXScopeSpec &SS, 2467 LookupResult &R, 2468 const TemplateArgumentListInfo *TemplateArgs, 2469 bool IsKnownInstance) { 2470 assert(!R.empty() && !R.isAmbiguous()); 2471 2472 SourceLocation loc = R.getNameLoc(); 2473 2474 // We may have found a field within an anonymous union or struct 2475 // (C++ [class.union]). 2476 // FIXME: template-ids inside anonymous structs? 2477 if (IndirectFieldDecl *FD = R.getAsSingle<IndirectFieldDecl>()) 2478 return BuildAnonymousStructUnionMemberReference(SS, R.getNameLoc(), FD); 2479 2480 // If this is known to be an instance access, go ahead and build an 2481 // implicit 'this' expression now. 2482 // 'this' expression now. 2483 QualType ThisTy = getAndCaptureCurrentThisType(); 2484 assert(!ThisTy.isNull() && "didn't correctly pre-flight capture of 'this'"); 2485 2486 Expr *baseExpr = 0; // null signifies implicit access 2487 if (IsKnownInstance) { 2488 SourceLocation Loc = R.getNameLoc(); 2489 if (SS.getRange().isValid()) 2490 Loc = SS.getRange().getBegin(); 2491 baseExpr = new (Context) CXXThisExpr(loc, ThisTy, /*isImplicit=*/true); 2492 } 2493 2494 return BuildMemberReferenceExpr(baseExpr, ThisTy, 2495 /*OpLoc*/ SourceLocation(), 2496 /*IsArrow*/ true, 2497 SS, 2498 /*FirstQualifierInScope*/ 0, 2499 R, TemplateArgs); 2500} 2501 2502bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS, 2503 const LookupResult &R, 2504 bool HasTrailingLParen) { 2505 // Only when used directly as the postfix-expression of a call. 2506 if (!HasTrailingLParen) 2507 return false; 2508 2509 // Never if a scope specifier was provided. 2510 if (SS.isSet()) 2511 return false; 2512 2513 // Only in C++ or ObjC++. 2514 if (!getLangOptions().CPlusPlus) 2515 return false; 2516 2517 // Turn off ADL when we find certain kinds of declarations during 2518 // normal lookup: 2519 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { 2520 NamedDecl *D = *I; 2521 2522 // C++0x [basic.lookup.argdep]p3: 2523 // -- a declaration of a class member 2524 // Since using decls preserve this property, we check this on the 2525 // original decl. 2526 if (D->isCXXClassMember()) 2527 return false; 2528 2529 // C++0x [basic.lookup.argdep]p3: 2530 // -- a block-scope function declaration that is not a 2531 // using-declaration 2532 // NOTE: we also trigger this for function templates (in fact, we 2533 // don't check the decl type at all, since all other decl types 2534 // turn off ADL anyway). 2535 if (isa<UsingShadowDecl>(D)) 2536 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 2537 else if (D->getDeclContext()->isFunctionOrMethod()) 2538 return false; 2539 2540 // C++0x [basic.lookup.argdep]p3: 2541 // -- a declaration that is neither a function or a function 2542 // template 2543 // And also for builtin functions. 2544 if (isa<FunctionDecl>(D)) { 2545 FunctionDecl *FDecl = cast<FunctionDecl>(D); 2546 2547 // But also builtin functions. 2548 if (FDecl->getBuiltinID() && FDecl->isImplicit()) 2549 return false; 2550 } else if (!isa<FunctionTemplateDecl>(D)) 2551 return false; 2552 } 2553 2554 return true; 2555} 2556 2557 2558/// Diagnoses obvious problems with the use of the given declaration 2559/// as an expression. This is only actually called for lookups that 2560/// were not overloaded, and it doesn't promise that the declaration 2561/// will in fact be used. 2562static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) { 2563 if (isa<TypedefNameDecl>(D)) { 2564 S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName(); 2565 return true; 2566 } 2567 2568 if (isa<ObjCInterfaceDecl>(D)) { 2569 S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName(); 2570 return true; 2571 } 2572 2573 if (isa<NamespaceDecl>(D)) { 2574 S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName(); 2575 return true; 2576 } 2577 2578 return false; 2579} 2580 2581ExprResult 2582Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2583 LookupResult &R, 2584 bool NeedsADL) { 2585 // If this is a single, fully-resolved result and we don't need ADL, 2586 // just build an ordinary singleton decl ref. 2587 if (!NeedsADL && R.isSingleResult() && !R.getAsSingle<FunctionTemplateDecl>()) 2588 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), 2589 R.getFoundDecl()); 2590 2591 // We only need to check the declaration if there's exactly one 2592 // result, because in the overloaded case the results can only be 2593 // functions and function templates. 2594 if (R.isSingleResult() && 2595 CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl())) 2596 return ExprError(); 2597 2598 // Otherwise, just build an unresolved lookup expression. Suppress 2599 // any lookup-related diagnostics; we'll hash these out later, when 2600 // we've picked a target. 2601 R.suppressDiagnostics(); 2602 2603 UnresolvedLookupExpr *ULE 2604 = UnresolvedLookupExpr::Create(Context, R.getNamingClass(), 2605 SS.getWithLocInContext(Context), 2606 R.getLookupNameInfo(), 2607 NeedsADL, R.isOverloadedResult(), 2608 R.begin(), R.end()); 2609 2610 return Owned(ULE); 2611} 2612 2613/// \brief Complete semantic analysis for a reference to the given declaration. 2614ExprResult 2615Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2616 const DeclarationNameInfo &NameInfo, 2617 NamedDecl *D) { 2618 assert(D && "Cannot refer to a NULL declaration"); 2619 assert(!isa<FunctionTemplateDecl>(D) && 2620 "Cannot refer unambiguously to a function template"); 2621 2622 SourceLocation Loc = NameInfo.getLoc(); 2623 if (CheckDeclInExpr(*this, Loc, D)) 2624 return ExprError(); 2625 2626 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) { 2627 // Specifically diagnose references to class templates that are missing 2628 // a template argument list. 2629 Diag(Loc, diag::err_template_decl_ref) 2630 << Template << SS.getRange(); 2631 Diag(Template->getLocation(), diag::note_template_decl_here); 2632 return ExprError(); 2633 } 2634 2635 // Make sure that we're referring to a value. 2636 ValueDecl *VD = dyn_cast<ValueDecl>(D); 2637 if (!VD) { 2638 Diag(Loc, diag::err_ref_non_value) 2639 << D << SS.getRange(); 2640 Diag(D->getLocation(), diag::note_declared_at); 2641 return ExprError(); 2642 } 2643 2644 // Check whether this declaration can be used. Note that we suppress 2645 // this check when we're going to perform argument-dependent lookup 2646 // on this function name, because this might not be the function 2647 // that overload resolution actually selects. 2648 if (DiagnoseUseOfDecl(VD, Loc)) 2649 return ExprError(); 2650 2651 // Only create DeclRefExpr's for valid Decl's. 2652 if (VD->isInvalidDecl()) 2653 return ExprError(); 2654 2655 // Handle members of anonymous structs and unions. If we got here, 2656 // and the reference is to a class member indirect field, then this 2657 // must be the subject of a pointer-to-member expression. 2658 if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD)) 2659 if (!indirectField->isCXXClassMember()) 2660 return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(), 2661 indirectField); 2662 2663 // If the identifier reference is inside a block, and it refers to a value 2664 // that is outside the block, create a BlockDeclRefExpr instead of a 2665 // DeclRefExpr. This ensures the value is treated as a copy-in snapshot when 2666 // the block is formed. 2667 // 2668 // We do not do this for things like enum constants, global variables, etc, 2669 // as they do not get snapshotted. 2670 // 2671 switch (shouldCaptureValueReference(*this, NameInfo.getLoc(), VD)) { 2672 case CR_Error: 2673 return ExprError(); 2674 2675 case CR_Capture: 2676 assert(!SS.isSet() && "referenced local variable with scope specifier?"); 2677 return BuildBlockDeclRefExpr(*this, VD, NameInfo, /*byref*/ false); 2678 2679 case CR_CaptureByRef: 2680 assert(!SS.isSet() && "referenced local variable with scope specifier?"); 2681 return BuildBlockDeclRefExpr(*this, VD, NameInfo, /*byref*/ true); 2682 2683 case CR_NoCapture: { 2684 // If this reference is not in a block or if the referenced 2685 // variable is within the block, create a normal DeclRefExpr. 2686 2687 QualType type = VD->getType(); 2688 ExprValueKind valueKind = VK_RValue; 2689 2690 switch (D->getKind()) { 2691 // Ignore all the non-ValueDecl kinds. 2692#define ABSTRACT_DECL(kind) 2693#define VALUE(type, base) 2694#define DECL(type, base) \ 2695 case Decl::type: 2696#include "clang/AST/DeclNodes.inc" 2697 llvm_unreachable("invalid value decl kind"); 2698 return ExprError(); 2699 2700 // These shouldn't make it here. 2701 case Decl::ObjCAtDefsField: 2702 case Decl::ObjCIvar: 2703 llvm_unreachable("forming non-member reference to ivar?"); 2704 return ExprError(); 2705 2706 // Enum constants are always r-values and never references. 2707 // Unresolved using declarations are dependent. 2708 case Decl::EnumConstant: 2709 case Decl::UnresolvedUsingValue: 2710 valueKind = VK_RValue; 2711 break; 2712 2713 // Fields and indirect fields that got here must be for 2714 // pointer-to-member expressions; we just call them l-values for 2715 // internal consistency, because this subexpression doesn't really 2716 // exist in the high-level semantics. 2717 case Decl::Field: 2718 case Decl::IndirectField: 2719 assert(getLangOptions().CPlusPlus && 2720 "building reference to field in C?"); 2721 2722 // These can't have reference type in well-formed programs, but 2723 // for internal consistency we do this anyway. 2724 type = type.getNonReferenceType(); 2725 valueKind = VK_LValue; 2726 break; 2727 2728 // Non-type template parameters are either l-values or r-values 2729 // depending on the type. 2730 case Decl::NonTypeTemplateParm: { 2731 if (const ReferenceType *reftype = type->getAs<ReferenceType>()) { 2732 type = reftype->getPointeeType(); 2733 valueKind = VK_LValue; // even if the parameter is an r-value reference 2734 break; 2735 } 2736 2737 // For non-references, we need to strip qualifiers just in case 2738 // the template parameter was declared as 'const int' or whatever. 2739 valueKind = VK_RValue; 2740 type = type.getUnqualifiedType(); 2741 break; 2742 } 2743 2744 case Decl::Var: 2745 // In C, "extern void blah;" is valid and is an r-value. 2746 if (!getLangOptions().CPlusPlus && 2747 !type.hasQualifiers() && 2748 type->isVoidType()) { 2749 valueKind = VK_RValue; 2750 break; 2751 } 2752 // fallthrough 2753 2754 case Decl::ImplicitParam: 2755 case Decl::ParmVar: 2756 // These are always l-values. 2757 valueKind = VK_LValue; 2758 type = type.getNonReferenceType(); 2759 break; 2760 2761 case Decl::Function: { 2762 const FunctionType *fty = type->castAs<FunctionType>(); 2763 2764 // If we're referring to a function with an __unknown_anytype 2765 // result type, make the entire expression __unknown_anytype. 2766 if (fty->getResultType() == Context.UnknownAnyTy) { 2767 type = Context.UnknownAnyTy; 2768 valueKind = VK_RValue; 2769 break; 2770 } 2771 2772 // Functions are l-values in C++. 2773 if (getLangOptions().CPlusPlus) { 2774 valueKind = VK_LValue; 2775 break; 2776 } 2777 2778 // C99 DR 316 says that, if a function type comes from a 2779 // function definition (without a prototype), that type is only 2780 // used for checking compatibility. Therefore, when referencing 2781 // the function, we pretend that we don't have the full function 2782 // type. 2783 if (!cast<FunctionDecl>(VD)->hasPrototype() && 2784 isa<FunctionProtoType>(fty)) 2785 type = Context.getFunctionNoProtoType(fty->getResultType(), 2786 fty->getExtInfo()); 2787 2788 // Functions are r-values in C. 2789 valueKind = VK_RValue; 2790 break; 2791 } 2792 2793 case Decl::CXXMethod: 2794 // If we're referring to a method with an __unknown_anytype 2795 // result type, make the entire expression __unknown_anytype. 2796 // This should only be possible with a type written directly. 2797 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(VD->getType())) 2798 if (proto->getResultType() == Context.UnknownAnyTy) { 2799 type = Context.UnknownAnyTy; 2800 valueKind = VK_RValue; 2801 break; 2802 } 2803 2804 // C++ methods are l-values if static, r-values if non-static. 2805 if (cast<CXXMethodDecl>(VD)->isStatic()) { 2806 valueKind = VK_LValue; 2807 break; 2808 } 2809 // fallthrough 2810 2811 case Decl::CXXConversion: 2812 case Decl::CXXDestructor: 2813 case Decl::CXXConstructor: 2814 valueKind = VK_RValue; 2815 break; 2816 } 2817 2818 return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS); 2819 } 2820 2821 } 2822 2823 llvm_unreachable("unknown capture result"); 2824 return ExprError(); 2825} 2826 2827ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) { 2828 PredefinedExpr::IdentType IT; 2829 2830 switch (Kind) { 2831 default: assert(0 && "Unknown simple primary expr!"); 2832 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2] 2833 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break; 2834 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break; 2835 } 2836 2837 // Pre-defined identifiers are of type char[x], where x is the length of the 2838 // string. 2839 2840 Decl *currentDecl = getCurFunctionOrMethodDecl(); 2841 if (!currentDecl && getCurBlock()) 2842 currentDecl = getCurBlock()->TheDecl; 2843 if (!currentDecl) { 2844 Diag(Loc, diag::ext_predef_outside_function); 2845 currentDecl = Context.getTranslationUnitDecl(); 2846 } 2847 2848 QualType ResTy; 2849 if (cast<DeclContext>(currentDecl)->isDependentContext()) { 2850 ResTy = Context.DependentTy; 2851 } else { 2852 unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length(); 2853 2854 llvm::APInt LengthI(32, Length + 1); 2855 ResTy = Context.CharTy.withConst(); 2856 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0); 2857 } 2858 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT)); 2859} 2860 2861ExprResult Sema::ActOnCharacterConstant(const Token &Tok) { 2862 llvm::SmallString<16> CharBuffer; 2863 bool Invalid = false; 2864 llvm::StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid); 2865 if (Invalid) 2866 return ExprError(); 2867 2868 CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(), 2869 PP); 2870 if (Literal.hadError()) 2871 return ExprError(); 2872 2873 QualType Ty; 2874 if (!getLangOptions().CPlusPlus) 2875 Ty = Context.IntTy; // 'x' and L'x' -> int in C. 2876 else if (Literal.isWide()) 2877 Ty = Context.WCharTy; // L'x' -> wchar_t in C++. 2878 else if (Literal.isMultiChar()) 2879 Ty = Context.IntTy; // 'wxyz' -> int in C++. 2880 else 2881 Ty = Context.CharTy; // 'x' -> char in C++ 2882 2883 return Owned(new (Context) CharacterLiteral(Literal.getValue(), 2884 Literal.isWide(), 2885 Ty, Tok.getLocation())); 2886} 2887 2888ExprResult Sema::ActOnNumericConstant(const Token &Tok) { 2889 // Fast path for a single digit (which is quite common). A single digit 2890 // cannot have a trigraph, escaped newline, radix prefix, or type suffix. 2891 if (Tok.getLength() == 1) { 2892 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok); 2893 unsigned IntSize = Context.Target.getIntWidth(); 2894 return Owned(IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val-'0'), 2895 Context.IntTy, Tok.getLocation())); 2896 } 2897 2898 llvm::SmallString<512> IntegerBuffer; 2899 // Add padding so that NumericLiteralParser can overread by one character. 2900 IntegerBuffer.resize(Tok.getLength()+1); 2901 const char *ThisTokBegin = &IntegerBuffer[0]; 2902 2903 // Get the spelling of the token, which eliminates trigraphs, etc. 2904 bool Invalid = false; 2905 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid); 2906 if (Invalid) 2907 return ExprError(); 2908 2909 NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength, 2910 Tok.getLocation(), PP); 2911 if (Literal.hadError) 2912 return ExprError(); 2913 2914 Expr *Res; 2915 2916 if (Literal.isFloatingLiteral()) { 2917 QualType Ty; 2918 if (Literal.isFloat) 2919 Ty = Context.FloatTy; 2920 else if (!Literal.isLong) 2921 Ty = Context.DoubleTy; 2922 else 2923 Ty = Context.LongDoubleTy; 2924 2925 const llvm::fltSemantics &Format = Context.getFloatTypeSemantics(Ty); 2926 2927 using llvm::APFloat; 2928 APFloat Val(Format); 2929 2930 APFloat::opStatus result = Literal.GetFloatValue(Val); 2931 2932 // Overflow is always an error, but underflow is only an error if 2933 // we underflowed to zero (APFloat reports denormals as underflow). 2934 if ((result & APFloat::opOverflow) || 2935 ((result & APFloat::opUnderflow) && Val.isZero())) { 2936 unsigned diagnostic; 2937 llvm::SmallString<20> buffer; 2938 if (result & APFloat::opOverflow) { 2939 diagnostic = diag::warn_float_overflow; 2940 APFloat::getLargest(Format).toString(buffer); 2941 } else { 2942 diagnostic = diag::warn_float_underflow; 2943 APFloat::getSmallest(Format).toString(buffer); 2944 } 2945 2946 Diag(Tok.getLocation(), diagnostic) 2947 << Ty 2948 << llvm::StringRef(buffer.data(), buffer.size()); 2949 } 2950 2951 bool isExact = (result == APFloat::opOK); 2952 Res = FloatingLiteral::Create(Context, Val, isExact, Ty, Tok.getLocation()); 2953 2954 if (Ty == Context.DoubleTy) { 2955 if (getLangOptions().SinglePrecisionConstants) { 2956 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); 2957 } else if (getLangOptions().OpenCL && !getOpenCLOptions().cl_khr_fp64) { 2958 Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64); 2959 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); 2960 } 2961 } 2962 } else if (!Literal.isIntegerLiteral()) { 2963 return ExprError(); 2964 } else { 2965 QualType Ty; 2966 2967 // long long is a C99 feature. 2968 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x && 2969 Literal.isLongLong) 2970 Diag(Tok.getLocation(), diag::ext_longlong); 2971 2972 // Get the value in the widest-possible width. 2973 llvm::APInt ResultVal(Context.Target.getIntMaxTWidth(), 0); 2974 2975 if (Literal.GetIntegerValue(ResultVal)) { 2976 // If this value didn't fit into uintmax_t, warn and force to ull. 2977 Diag(Tok.getLocation(), diag::warn_integer_too_large); 2978 Ty = Context.UnsignedLongLongTy; 2979 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() && 2980 "long long is not intmax_t?"); 2981 } else { 2982 // If this value fits into a ULL, try to figure out what else it fits into 2983 // according to the rules of C99 6.4.4.1p5. 2984 2985 // Octal, Hexadecimal, and integers with a U suffix are allowed to 2986 // be an unsigned int. 2987 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10; 2988 2989 // Check from smallest to largest, picking the smallest type we can. 2990 unsigned Width = 0; 2991 if (!Literal.isLong && !Literal.isLongLong) { 2992 // Are int/unsigned possibilities? 2993 unsigned IntSize = Context.Target.getIntWidth(); 2994 2995 // Does it fit in a unsigned int? 2996 if (ResultVal.isIntN(IntSize)) { 2997 // Does it fit in a signed int? 2998 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0) 2999 Ty = Context.IntTy; 3000 else if (AllowUnsigned) 3001 Ty = Context.UnsignedIntTy; 3002 Width = IntSize; 3003 } 3004 } 3005 3006 // Are long/unsigned long possibilities? 3007 if (Ty.isNull() && !Literal.isLongLong) { 3008 unsigned LongSize = Context.Target.getLongWidth(); 3009 3010 // Does it fit in a unsigned long? 3011 if (ResultVal.isIntN(LongSize)) { 3012 // Does it fit in a signed long? 3013 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0) 3014 Ty = Context.LongTy; 3015 else if (AllowUnsigned) 3016 Ty = Context.UnsignedLongTy; 3017 Width = LongSize; 3018 } 3019 } 3020 3021 // Finally, check long long if needed. 3022 if (Ty.isNull()) { 3023 unsigned LongLongSize = Context.Target.getLongLongWidth(); 3024 3025 // Does it fit in a unsigned long long? 3026 if (ResultVal.isIntN(LongLongSize)) { 3027 // Does it fit in a signed long long? 3028 // To be compatible with MSVC, hex integer literals ending with the 3029 // LL or i64 suffix are always signed in Microsoft mode. 3030 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 || 3031 (getLangOptions().Microsoft && Literal.isLongLong))) 3032 Ty = Context.LongLongTy; 3033 else if (AllowUnsigned) 3034 Ty = Context.UnsignedLongLongTy; 3035 Width = LongLongSize; 3036 } 3037 } 3038 3039 // If we still couldn't decide a type, we probably have something that 3040 // does not fit in a signed long long, but has no U suffix. 3041 if (Ty.isNull()) { 3042 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed); 3043 Ty = Context.UnsignedLongLongTy; 3044 Width = Context.Target.getLongLongWidth(); 3045 } 3046 3047 if (ResultVal.getBitWidth() != Width) 3048 ResultVal = ResultVal.trunc(Width); 3049 } 3050 Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation()); 3051 } 3052 3053 // If this is an imaginary literal, create the ImaginaryLiteral wrapper. 3054 if (Literal.isImaginary) 3055 Res = new (Context) ImaginaryLiteral(Res, 3056 Context.getComplexType(Res->getType())); 3057 3058 return Owned(Res); 3059} 3060 3061ExprResult Sema::ActOnParenExpr(SourceLocation L, 3062 SourceLocation R, Expr *E) { 3063 assert((E != 0) && "ActOnParenExpr() missing expr"); 3064 return Owned(new (Context) ParenExpr(L, R, E)); 3065} 3066 3067static bool CheckVecStepTraitOperandType(Sema &S, QualType T, 3068 SourceLocation Loc, 3069 SourceRange ArgRange) { 3070 // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in 3071 // scalar or vector data type argument..." 3072 // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic 3073 // type (C99 6.2.5p18) or void. 3074 if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) { 3075 S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type) 3076 << T << ArgRange; 3077 return true; 3078 } 3079 3080 assert((T->isVoidType() || !T->isIncompleteType()) && 3081 "Scalar types should always be complete"); 3082 return false; 3083} 3084 3085static bool CheckExtensionTraitOperandType(Sema &S, QualType T, 3086 SourceLocation Loc, 3087 SourceRange ArgRange, 3088 UnaryExprOrTypeTrait TraitKind) { 3089 // C99 6.5.3.4p1: 3090 if (T->isFunctionType()) { 3091 // alignof(function) is allowed as an extension. 3092 if (TraitKind == UETT_SizeOf) 3093 S.Diag(Loc, diag::ext_sizeof_function_type) << ArgRange; 3094 return false; 3095 } 3096 3097 // Allow sizeof(void)/alignof(void) as an extension. 3098 if (T->isVoidType()) { 3099 S.Diag(Loc, diag::ext_sizeof_void_type) << TraitKind << ArgRange; 3100 return false; 3101 } 3102 3103 return true; 3104} 3105 3106static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, 3107 SourceLocation Loc, 3108 SourceRange ArgRange, 3109 UnaryExprOrTypeTrait TraitKind) { 3110 // Reject sizeof(interface) and sizeof(interface<proto>) in 64-bit mode. 3111 if (S.LangOpts.ObjCNonFragileABI && T->isObjCObjectType()) { 3112 S.Diag(Loc, diag::err_sizeof_nonfragile_interface) 3113 << T << (TraitKind == UETT_SizeOf) 3114 << ArgRange; 3115 return true; 3116 } 3117 3118 return false; 3119} 3120 3121/// \brief Check the constrains on expression operands to unary type expression 3122/// and type traits. 3123/// 3124/// Completes any types necessary and validates the constraints on the operand 3125/// expression. The logic mostly mirrors the type-based overload, but may modify 3126/// the expression as it completes the type for that expression through template 3127/// instantiation, etc. 3128bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *Op, 3129 UnaryExprOrTypeTrait ExprKind) { 3130 QualType ExprTy = Op->getType(); 3131 3132 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 3133 // the result is the size of the referenced type." 3134 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the 3135 // result shall be the alignment of the referenced type." 3136 if (const ReferenceType *Ref = ExprTy->getAs<ReferenceType>()) 3137 ExprTy = Ref->getPointeeType(); 3138 3139 if (ExprKind == UETT_VecStep) 3140 return CheckVecStepTraitOperandType(*this, ExprTy, Op->getExprLoc(), 3141 Op->getSourceRange()); 3142 3143 // Whitelist some types as extensions 3144 if (!CheckExtensionTraitOperandType(*this, ExprTy, Op->getExprLoc(), 3145 Op->getSourceRange(), ExprKind)) 3146 return false; 3147 3148 if (RequireCompleteExprType(Op, 3149 PDiag(diag::err_sizeof_alignof_incomplete_type) 3150 << ExprKind << Op->getSourceRange(), 3151 std::make_pair(SourceLocation(), PDiag(0)))) 3152 return true; 3153 3154 // Completeing the expression's type may have changed it. 3155 ExprTy = Op->getType(); 3156 if (const ReferenceType *Ref = ExprTy->getAs<ReferenceType>()) 3157 ExprTy = Ref->getPointeeType(); 3158 3159 if (CheckObjCTraitOperandConstraints(*this, ExprTy, Op->getExprLoc(), 3160 Op->getSourceRange(), ExprKind)) 3161 return true; 3162 3163 if (ExprKind == UETT_SizeOf) { 3164 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(Op->IgnoreParens())) { 3165 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) { 3166 QualType OType = PVD->getOriginalType(); 3167 QualType Type = PVD->getType(); 3168 if (Type->isPointerType() && OType->isArrayType()) { 3169 Diag(Op->getExprLoc(), diag::warn_sizeof_array_param) 3170 << Type << OType; 3171 Diag(PVD->getLocation(), diag::note_declared_at); 3172 } 3173 } 3174 } 3175 } 3176 3177 return false; 3178} 3179 3180/// \brief Check the constraints on operands to unary expression and type 3181/// traits. 3182/// 3183/// This will complete any types necessary, and validate the various constraints 3184/// on those operands. 3185/// 3186/// The UsualUnaryConversions() function is *not* called by this routine. 3187/// C99 6.3.2.1p[2-4] all state: 3188/// Except when it is the operand of the sizeof operator ... 3189/// 3190/// C++ [expr.sizeof]p4 3191/// The lvalue-to-rvalue, array-to-pointer, and function-to-pointer 3192/// standard conversions are not applied to the operand of sizeof. 3193/// 3194/// This policy is followed for all of the unary trait expressions. 3195bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType exprType, 3196 SourceLocation OpLoc, 3197 SourceRange ExprRange, 3198 UnaryExprOrTypeTrait ExprKind) { 3199 if (exprType->isDependentType()) 3200 return false; 3201 3202 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 3203 // the result is the size of the referenced type." 3204 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the 3205 // result shall be the alignment of the referenced type." 3206 if (const ReferenceType *Ref = exprType->getAs<ReferenceType>()) 3207 exprType = Ref->getPointeeType(); 3208 3209 if (ExprKind == UETT_VecStep) 3210 return CheckVecStepTraitOperandType(*this, exprType, OpLoc, ExprRange); 3211 3212 // Whitelist some types as extensions 3213 if (!CheckExtensionTraitOperandType(*this, exprType, OpLoc, ExprRange, 3214 ExprKind)) 3215 return false; 3216 3217 if (RequireCompleteType(OpLoc, exprType, 3218 PDiag(diag::err_sizeof_alignof_incomplete_type) 3219 << ExprKind << ExprRange)) 3220 return true; 3221 3222 if (CheckObjCTraitOperandConstraints(*this, exprType, OpLoc, ExprRange, 3223 ExprKind)) 3224 return true; 3225 3226 return false; 3227} 3228 3229static bool CheckAlignOfExpr(Sema &S, Expr *E) { 3230 E = E->IgnoreParens(); 3231 3232 // alignof decl is always ok. 3233 if (isa<DeclRefExpr>(E)) 3234 return false; 3235 3236 // Cannot know anything else if the expression is dependent. 3237 if (E->isTypeDependent()) 3238 return false; 3239 3240 if (E->getBitField()) { 3241 S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) 3242 << 1 << E->getSourceRange(); 3243 return true; 3244 } 3245 3246 // Alignment of a field access is always okay, so long as it isn't a 3247 // bit-field. 3248 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) 3249 if (isa<FieldDecl>(ME->getMemberDecl())) 3250 return false; 3251 3252 return S.CheckUnaryExprOrTypeTraitOperand(E, UETT_AlignOf); 3253} 3254 3255bool Sema::CheckVecStepExpr(Expr *E) { 3256 E = E->IgnoreParens(); 3257 3258 // Cannot know anything else if the expression is dependent. 3259 if (E->isTypeDependent()) 3260 return false; 3261 3262 return CheckUnaryExprOrTypeTraitOperand(E, UETT_VecStep); 3263} 3264 3265/// \brief Build a sizeof or alignof expression given a type operand. 3266ExprResult 3267Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, 3268 SourceLocation OpLoc, 3269 UnaryExprOrTypeTrait ExprKind, 3270 SourceRange R) { 3271 if (!TInfo) 3272 return ExprError(); 3273 3274 QualType T = TInfo->getType(); 3275 3276 if (!T->isDependentType() && 3277 CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind)) 3278 return ExprError(); 3279 3280 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 3281 return Owned(new (Context) UnaryExprOrTypeTraitExpr(ExprKind, TInfo, 3282 Context.getSizeType(), 3283 OpLoc, R.getEnd())); 3284} 3285 3286/// \brief Build a sizeof or alignof expression given an expression 3287/// operand. 3288ExprResult 3289Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc, 3290 UnaryExprOrTypeTrait ExprKind) { 3291 // Verify that the operand is valid. 3292 bool isInvalid = false; 3293 if (E->isTypeDependent()) { 3294 // Delay type-checking for type-dependent expressions. 3295 } else if (ExprKind == UETT_AlignOf) { 3296 isInvalid = CheckAlignOfExpr(*this, E); 3297 } else if (ExprKind == UETT_VecStep) { 3298 isInvalid = CheckVecStepExpr(E); 3299 } else if (E->getBitField()) { // C99 6.5.3.4p1. 3300 Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) << 0; 3301 isInvalid = true; 3302 } else if (E->getType()->isPlaceholderType()) { 3303 ExprResult PE = CheckPlaceholderExpr(E); 3304 if (PE.isInvalid()) return ExprError(); 3305 return CreateUnaryExprOrTypeTraitExpr(PE.take(), OpLoc, ExprKind); 3306 } else { 3307 isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf); 3308 } 3309 3310 if (isInvalid) 3311 return ExprError(); 3312 3313 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 3314 return Owned(new (Context) UnaryExprOrTypeTraitExpr( 3315 ExprKind, E, Context.getSizeType(), OpLoc, 3316 E->getSourceRange().getEnd())); 3317} 3318 3319/// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c 3320/// expr and the same for @c alignof and @c __alignof 3321/// Note that the ArgRange is invalid if isType is false. 3322ExprResult 3323Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, 3324 UnaryExprOrTypeTrait ExprKind, bool isType, 3325 void *TyOrEx, const SourceRange &ArgRange) { 3326 // If error parsing type, ignore. 3327 if (TyOrEx == 0) return ExprError(); 3328 3329 if (isType) { 3330 TypeSourceInfo *TInfo; 3331 (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo); 3332 return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange); 3333 } 3334 3335 Expr *ArgEx = (Expr *)TyOrEx; 3336 ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind); 3337 return move(Result); 3338} 3339 3340static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, 3341 bool isReal) { 3342 if (V.get()->isTypeDependent()) 3343 return S.Context.DependentTy; 3344 3345 // _Real and _Imag are only l-values for normal l-values. 3346 if (V.get()->getObjectKind() != OK_Ordinary) { 3347 V = S.DefaultLvalueConversion(V.take()); 3348 if (V.isInvalid()) 3349 return QualType(); 3350 } 3351 3352 // These operators return the element type of a complex type. 3353 if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>()) 3354 return CT->getElementType(); 3355 3356 // Otherwise they pass through real integer and floating point types here. 3357 if (V.get()->getType()->isArithmeticType()) 3358 return V.get()->getType(); 3359 3360 // Test for placeholders. 3361 ExprResult PR = S.CheckPlaceholderExpr(V.get()); 3362 if (PR.isInvalid()) return QualType(); 3363 if (PR.get() != V.get()) { 3364 V = move(PR); 3365 return CheckRealImagOperand(S, V, Loc, isReal); 3366 } 3367 3368 // Reject anything else. 3369 S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType() 3370 << (isReal ? "__real" : "__imag"); 3371 return QualType(); 3372} 3373 3374 3375 3376ExprResult 3377Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, 3378 tok::TokenKind Kind, Expr *Input) { 3379 UnaryOperatorKind Opc; 3380 switch (Kind) { 3381 default: assert(0 && "Unknown unary op!"); 3382 case tok::plusplus: Opc = UO_PostInc; break; 3383 case tok::minusminus: Opc = UO_PostDec; break; 3384 } 3385 3386 return BuildUnaryOp(S, OpLoc, Opc, Input); 3387} 3388 3389/// Expressions of certain arbitrary types are forbidden by C from 3390/// having l-value type. These are: 3391/// - 'void', but not qualified void 3392/// - function types 3393/// 3394/// The exact rule here is C99 6.3.2.1: 3395/// An lvalue is an expression with an object type or an incomplete 3396/// type other than void. 3397static bool IsCForbiddenLValueType(ASTContext &C, QualType T) { 3398 return ((T->isVoidType() && !T.hasQualifiers()) || 3399 T->isFunctionType()); 3400} 3401 3402ExprResult 3403Sema::ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, 3404 Expr *Idx, SourceLocation RLoc) { 3405 // Since this might be a postfix expression, get rid of ParenListExprs. 3406 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); 3407 if (Result.isInvalid()) return ExprError(); 3408 Base = Result.take(); 3409 3410 Expr *LHSExp = Base, *RHSExp = Idx; 3411 3412 if (getLangOptions().CPlusPlus && 3413 (LHSExp->isTypeDependent() || RHSExp->isTypeDependent())) { 3414 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 3415 Context.DependentTy, 3416 VK_LValue, OK_Ordinary, 3417 RLoc)); 3418 } 3419 3420 if (getLangOptions().CPlusPlus && 3421 (LHSExp->getType()->isRecordType() || 3422 LHSExp->getType()->isEnumeralType() || 3423 RHSExp->getType()->isRecordType() || 3424 RHSExp->getType()->isEnumeralType())) { 3425 return CreateOverloadedArraySubscriptExpr(LLoc, RLoc, Base, Idx); 3426 } 3427 3428 return CreateBuiltinArraySubscriptExpr(Base, LLoc, Idx, RLoc); 3429} 3430 3431 3432ExprResult 3433Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, 3434 Expr *Idx, SourceLocation RLoc) { 3435 Expr *LHSExp = Base; 3436 Expr *RHSExp = Idx; 3437 3438 // Perform default conversions. 3439 if (!LHSExp->getType()->getAs<VectorType>()) { 3440 ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp); 3441 if (Result.isInvalid()) 3442 return ExprError(); 3443 LHSExp = Result.take(); 3444 } 3445 ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp); 3446 if (Result.isInvalid()) 3447 return ExprError(); 3448 RHSExp = Result.take(); 3449 3450 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType(); 3451 ExprValueKind VK = VK_LValue; 3452 ExprObjectKind OK = OK_Ordinary; 3453 3454 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent 3455 // to the expression *((e1)+(e2)). This means the array "Base" may actually be 3456 // in the subscript position. As a result, we need to derive the array base 3457 // and index from the expression types. 3458 Expr *BaseExpr, *IndexExpr; 3459 QualType ResultType; 3460 if (LHSTy->isDependentType() || RHSTy->isDependentType()) { 3461 BaseExpr = LHSExp; 3462 IndexExpr = RHSExp; 3463 ResultType = Context.DependentTy; 3464 } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) { 3465 BaseExpr = LHSExp; 3466 IndexExpr = RHSExp; 3467 ResultType = PTy->getPointeeType(); 3468 } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) { 3469 // Handle the uncommon case of "123[Ptr]". 3470 BaseExpr = RHSExp; 3471 IndexExpr = LHSExp; 3472 ResultType = PTy->getPointeeType(); 3473 } else if (const ObjCObjectPointerType *PTy = 3474 LHSTy->getAs<ObjCObjectPointerType>()) { 3475 BaseExpr = LHSExp; 3476 IndexExpr = RHSExp; 3477 ResultType = PTy->getPointeeType(); 3478 } else if (const ObjCObjectPointerType *PTy = 3479 RHSTy->getAs<ObjCObjectPointerType>()) { 3480 // Handle the uncommon case of "123[Ptr]". 3481 BaseExpr = RHSExp; 3482 IndexExpr = LHSExp; 3483 ResultType = PTy->getPointeeType(); 3484 } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) { 3485 BaseExpr = LHSExp; // vectors: V[123] 3486 IndexExpr = RHSExp; 3487 VK = LHSExp->getValueKind(); 3488 if (VK != VK_RValue) 3489 OK = OK_VectorComponent; 3490 3491 // FIXME: need to deal with const... 3492 ResultType = VTy->getElementType(); 3493 } else if (LHSTy->isArrayType()) { 3494 // If we see an array that wasn't promoted by 3495 // DefaultFunctionArrayLvalueConversion, it must be an array that 3496 // wasn't promoted because of the C90 rule that doesn't 3497 // allow promoting non-lvalue arrays. Warn, then 3498 // force the promotion here. 3499 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3500 LHSExp->getSourceRange(); 3501 LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy), 3502 CK_ArrayToPointerDecay).take(); 3503 LHSTy = LHSExp->getType(); 3504 3505 BaseExpr = LHSExp; 3506 IndexExpr = RHSExp; 3507 ResultType = LHSTy->getAs<PointerType>()->getPointeeType(); 3508 } else if (RHSTy->isArrayType()) { 3509 // Same as previous, except for 123[f().a] case 3510 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3511 RHSExp->getSourceRange(); 3512 RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy), 3513 CK_ArrayToPointerDecay).take(); 3514 RHSTy = RHSExp->getType(); 3515 3516 BaseExpr = RHSExp; 3517 IndexExpr = LHSExp; 3518 ResultType = RHSTy->getAs<PointerType>()->getPointeeType(); 3519 } else { 3520 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value) 3521 << LHSExp->getSourceRange() << RHSExp->getSourceRange()); 3522 } 3523 // C99 6.5.2.1p1 3524 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent()) 3525 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer) 3526 << IndexExpr->getSourceRange()); 3527 3528 if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) || 3529 IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U)) 3530 && !IndexExpr->isTypeDependent()) 3531 Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange(); 3532 3533 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly, 3534 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object 3535 // type. Note that Functions are not objects, and that (in C99 parlance) 3536 // incomplete types are not object types. 3537 if (ResultType->isFunctionType()) { 3538 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type) 3539 << ResultType << BaseExpr->getSourceRange(); 3540 return ExprError(); 3541 } 3542 3543 if (ResultType->isVoidType() && !getLangOptions().CPlusPlus) { 3544 // GNU extension: subscripting on pointer to void 3545 Diag(LLoc, diag::ext_gnu_void_ptr) 3546 << BaseExpr->getSourceRange(); 3547 3548 // C forbids expressions of unqualified void type from being l-values. 3549 // See IsCForbiddenLValueType. 3550 if (!ResultType.hasQualifiers()) VK = VK_RValue; 3551 } else if (!ResultType->isDependentType() && 3552 RequireCompleteType(LLoc, ResultType, 3553 PDiag(diag::err_subscript_incomplete_type) 3554 << BaseExpr->getSourceRange())) 3555 return ExprError(); 3556 3557 // Diagnose bad cases where we step over interface counts. 3558 if (ResultType->isObjCObjectType() && LangOpts.ObjCNonFragileABI) { 3559 Diag(LLoc, diag::err_subscript_nonfragile_interface) 3560 << ResultType << BaseExpr->getSourceRange(); 3561 return ExprError(); 3562 } 3563 3564 assert(VK == VK_RValue || LangOpts.CPlusPlus || 3565 !IsCForbiddenLValueType(Context, ResultType)); 3566 3567 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 3568 ResultType, VK, OK, RLoc)); 3569} 3570 3571/// Check an ext-vector component access expression. 3572/// 3573/// VK should be set in advance to the value kind of the base 3574/// expression. 3575static QualType 3576CheckExtVectorComponent(Sema &S, QualType baseType, ExprValueKind &VK, 3577 SourceLocation OpLoc, const IdentifierInfo *CompName, 3578 SourceLocation CompLoc) { 3579 // FIXME: Share logic with ExtVectorElementExpr::containsDuplicateElements, 3580 // see FIXME there. 3581 // 3582 // FIXME: This logic can be greatly simplified by splitting it along 3583 // halving/not halving and reworking the component checking. 3584 const ExtVectorType *vecType = baseType->getAs<ExtVectorType>(); 3585 3586 // The vector accessor can't exceed the number of elements. 3587 const char *compStr = CompName->getNameStart(); 3588 3589 // This flag determines whether or not the component is one of the four 3590 // special names that indicate a subset of exactly half the elements are 3591 // to be selected. 3592 bool HalvingSwizzle = false; 3593 3594 // This flag determines whether or not CompName has an 's' char prefix, 3595 // indicating that it is a string of hex values to be used as vector indices. 3596 bool HexSwizzle = *compStr == 's' || *compStr == 'S'; 3597 3598 bool HasRepeated = false; 3599 bool HasIndex[16] = {}; 3600 3601 int Idx; 3602 3603 // Check that we've found one of the special components, or that the component 3604 // names must come from the same set. 3605 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") || 3606 !strcmp(compStr, "even") || !strcmp(compStr, "odd")) { 3607 HalvingSwizzle = true; 3608 } else if (!HexSwizzle && 3609 (Idx = vecType->getPointAccessorIdx(*compStr)) != -1) { 3610 do { 3611 if (HasIndex[Idx]) HasRepeated = true; 3612 HasIndex[Idx] = true; 3613 compStr++; 3614 } while (*compStr && (Idx = vecType->getPointAccessorIdx(*compStr)) != -1); 3615 } else { 3616 if (HexSwizzle) compStr++; 3617 while ((Idx = vecType->getNumericAccessorIdx(*compStr)) != -1) { 3618 if (HasIndex[Idx]) HasRepeated = true; 3619 HasIndex[Idx] = true; 3620 compStr++; 3621 } 3622 } 3623 3624 if (!HalvingSwizzle && *compStr) { 3625 // We didn't get to the end of the string. This means the component names 3626 // didn't come from the same set *or* we encountered an illegal name. 3627 S.Diag(OpLoc, diag::err_ext_vector_component_name_illegal) 3628 << llvm::StringRef(compStr, 1) << SourceRange(CompLoc); 3629 return QualType(); 3630 } 3631 3632 // Ensure no component accessor exceeds the width of the vector type it 3633 // operates on. 3634 if (!HalvingSwizzle) { 3635 compStr = CompName->getNameStart(); 3636 3637 if (HexSwizzle) 3638 compStr++; 3639 3640 while (*compStr) { 3641 if (!vecType->isAccessorWithinNumElements(*compStr++)) { 3642 S.Diag(OpLoc, diag::err_ext_vector_component_exceeds_length) 3643 << baseType << SourceRange(CompLoc); 3644 return QualType(); 3645 } 3646 } 3647 } 3648 3649 // The component accessor looks fine - now we need to compute the actual type. 3650 // The vector type is implied by the component accessor. For example, 3651 // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc. 3652 // vec4.s0 is a float, vec4.s23 is a vec3, etc. 3653 // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2. 3654 unsigned CompSize = HalvingSwizzle ? (vecType->getNumElements() + 1) / 2 3655 : CompName->getLength(); 3656 if (HexSwizzle) 3657 CompSize--; 3658 3659 if (CompSize == 1) 3660 return vecType->getElementType(); 3661 3662 if (HasRepeated) VK = VK_RValue; 3663 3664 QualType VT = S.Context.getExtVectorType(vecType->getElementType(), CompSize); 3665 // Now look up the TypeDefDecl from the vector type. Without this, 3666 // diagostics look bad. We want extended vector types to appear built-in. 3667 for (unsigned i = 0, E = S.ExtVectorDecls.size(); i != E; ++i) { 3668 if (S.ExtVectorDecls[i]->getUnderlyingType() == VT) 3669 return S.Context.getTypedefType(S.ExtVectorDecls[i]); 3670 } 3671 return VT; // should never get here (a typedef type should always be found). 3672} 3673 3674static Decl *FindGetterSetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl, 3675 IdentifierInfo *Member, 3676 const Selector &Sel, 3677 ASTContext &Context) { 3678 if (Member) 3679 if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(Member)) 3680 return PD; 3681 if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Sel)) 3682 return OMD; 3683 3684 for (ObjCProtocolDecl::protocol_iterator I = PDecl->protocol_begin(), 3685 E = PDecl->protocol_end(); I != E; ++I) { 3686 if (Decl *D = FindGetterSetterNameDeclFromProtocolList(*I, Member, Sel, 3687 Context)) 3688 return D; 3689 } 3690 return 0; 3691} 3692 3693static Decl *FindGetterSetterNameDecl(const ObjCObjectPointerType *QIdTy, 3694 IdentifierInfo *Member, 3695 const Selector &Sel, 3696 ASTContext &Context) { 3697 // Check protocols on qualified interfaces. 3698 Decl *GDecl = 0; 3699 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(), 3700 E = QIdTy->qual_end(); I != E; ++I) { 3701 if (Member) 3702 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Member)) { 3703 GDecl = PD; 3704 break; 3705 } 3706 // Also must look for a getter or setter name which uses property syntax. 3707 if (ObjCMethodDecl *OMD = (*I)->getInstanceMethod(Sel)) { 3708 GDecl = OMD; 3709 break; 3710 } 3711 } 3712 if (!GDecl) { 3713 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(), 3714 E = QIdTy->qual_end(); I != E; ++I) { 3715 // Search in the protocol-qualifier list of current protocol. 3716 GDecl = FindGetterSetterNameDeclFromProtocolList(*I, Member, Sel, 3717 Context); 3718 if (GDecl) 3719 return GDecl; 3720 } 3721 } 3722 return GDecl; 3723} 3724 3725ExprResult 3726Sema::ActOnDependentMemberExpr(Expr *BaseExpr, QualType BaseType, 3727 bool IsArrow, SourceLocation OpLoc, 3728 const CXXScopeSpec &SS, 3729 NamedDecl *FirstQualifierInScope, 3730 const DeclarationNameInfo &NameInfo, 3731 const TemplateArgumentListInfo *TemplateArgs) { 3732 // Even in dependent contexts, try to diagnose base expressions with 3733 // obviously wrong types, e.g.: 3734 // 3735 // T* t; 3736 // t.f; 3737 // 3738 // In Obj-C++, however, the above expression is valid, since it could be 3739 // accessing the 'f' property if T is an Obj-C interface. The extra check 3740 // allows this, while still reporting an error if T is a struct pointer. 3741 if (!IsArrow) { 3742 const PointerType *PT = BaseType->getAs<PointerType>(); 3743 if (PT && (!getLangOptions().ObjC1 || 3744 PT->getPointeeType()->isRecordType())) { 3745 assert(BaseExpr && "cannot happen with implicit member accesses"); 3746 Diag(NameInfo.getLoc(), diag::err_typecheck_member_reference_struct_union) 3747 << BaseType << BaseExpr->getSourceRange(); 3748 return ExprError(); 3749 } 3750 } 3751 3752 assert(BaseType->isDependentType() || 3753 NameInfo.getName().isDependentName() || 3754 isDependentScopeSpecifier(SS)); 3755 3756 // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr 3757 // must have pointer type, and the accessed type is the pointee. 3758 return Owned(CXXDependentScopeMemberExpr::Create(Context, BaseExpr, BaseType, 3759 IsArrow, OpLoc, 3760 SS.getWithLocInContext(Context), 3761 FirstQualifierInScope, 3762 NameInfo, TemplateArgs)); 3763} 3764 3765/// We know that the given qualified member reference points only to 3766/// declarations which do not belong to the static type of the base 3767/// expression. Diagnose the problem. 3768static void DiagnoseQualifiedMemberReference(Sema &SemaRef, 3769 Expr *BaseExpr, 3770 QualType BaseType, 3771 const CXXScopeSpec &SS, 3772 NamedDecl *rep, 3773 const DeclarationNameInfo &nameInfo) { 3774 // If this is an implicit member access, use a different set of 3775 // diagnostics. 3776 if (!BaseExpr) 3777 return DiagnoseInstanceReference(SemaRef, SS, rep, nameInfo); 3778 3779 SemaRef.Diag(nameInfo.getLoc(), diag::err_qualified_member_of_unrelated) 3780 << SS.getRange() << rep << BaseType; 3781} 3782 3783// Check whether the declarations we found through a nested-name 3784// specifier in a member expression are actually members of the base 3785// type. The restriction here is: 3786// 3787// C++ [expr.ref]p2: 3788// ... In these cases, the id-expression shall name a 3789// member of the class or of one of its base classes. 3790// 3791// So it's perfectly legitimate for the nested-name specifier to name 3792// an unrelated class, and for us to find an overload set including 3793// decls from classes which are not superclasses, as long as the decl 3794// we actually pick through overload resolution is from a superclass. 3795bool Sema::CheckQualifiedMemberReference(Expr *BaseExpr, 3796 QualType BaseType, 3797 const CXXScopeSpec &SS, 3798 const LookupResult &R) { 3799 const RecordType *BaseRT = BaseType->getAs<RecordType>(); 3800 if (!BaseRT) { 3801 // We can't check this yet because the base type is still 3802 // dependent. 3803 assert(BaseType->isDependentType()); 3804 return false; 3805 } 3806 CXXRecordDecl *BaseRecord = cast<CXXRecordDecl>(BaseRT->getDecl()); 3807 3808 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { 3809 // If this is an implicit member reference and we find a 3810 // non-instance member, it's not an error. 3811 if (!BaseExpr && !(*I)->isCXXInstanceMember()) 3812 return false; 3813 3814 // Note that we use the DC of the decl, not the underlying decl. 3815 DeclContext *DC = (*I)->getDeclContext(); 3816 while (DC->isTransparentContext()) 3817 DC = DC->getParent(); 3818 3819 if (!DC->isRecord()) 3820 continue; 3821 3822 llvm::SmallPtrSet<CXXRecordDecl*,4> MemberRecord; 3823 MemberRecord.insert(cast<CXXRecordDecl>(DC)->getCanonicalDecl()); 3824 3825 if (!IsProvablyNotDerivedFrom(*this, BaseRecord, MemberRecord)) 3826 return false; 3827 } 3828 3829 DiagnoseQualifiedMemberReference(*this, BaseExpr, BaseType, SS, 3830 R.getRepresentativeDecl(), 3831 R.getLookupNameInfo()); 3832 return true; 3833} 3834 3835static bool 3836LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R, 3837 SourceRange BaseRange, const RecordType *RTy, 3838 SourceLocation OpLoc, CXXScopeSpec &SS, 3839 bool HasTemplateArgs) { 3840 RecordDecl *RDecl = RTy->getDecl(); 3841 if (SemaRef.RequireCompleteType(OpLoc, QualType(RTy, 0), 3842 SemaRef.PDiag(diag::err_typecheck_incomplete_tag) 3843 << BaseRange)) 3844 return true; 3845 3846 if (HasTemplateArgs) { 3847 // LookupTemplateName doesn't expect these both to exist simultaneously. 3848 QualType ObjectType = SS.isSet() ? QualType() : QualType(RTy, 0); 3849 3850 bool MOUS; 3851 SemaRef.LookupTemplateName(R, 0, SS, ObjectType, false, MOUS); 3852 return false; 3853 } 3854 3855 DeclContext *DC = RDecl; 3856 if (SS.isSet()) { 3857 // If the member name was a qualified-id, look into the 3858 // nested-name-specifier. 3859 DC = SemaRef.computeDeclContext(SS, false); 3860 3861 if (SemaRef.RequireCompleteDeclContext(SS, DC)) { 3862 SemaRef.Diag(SS.getRange().getEnd(), diag::err_typecheck_incomplete_tag) 3863 << SS.getRange() << DC; 3864 return true; 3865 } 3866 3867 assert(DC && "Cannot handle non-computable dependent contexts in lookup"); 3868 3869 if (!isa<TypeDecl>(DC)) { 3870 SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_nonclass) 3871 << DC << SS.getRange(); 3872 return true; 3873 } 3874 } 3875 3876 // The record definition is complete, now look up the member. 3877 SemaRef.LookupQualifiedName(R, DC); 3878 3879 if (!R.empty()) 3880 return false; 3881 3882 // We didn't find anything with the given name, so try to correct 3883 // for typos. 3884 DeclarationName Name = R.getLookupName(); 3885 if (SemaRef.CorrectTypo(R, 0, &SS, DC, false, Sema::CTC_MemberLookup) && 3886 !R.empty() && 3887 (isa<ValueDecl>(*R.begin()) || isa<FunctionTemplateDecl>(*R.begin()))) { 3888 SemaRef.Diag(R.getNameLoc(), diag::err_no_member_suggest) 3889 << Name << DC << R.getLookupName() << SS.getRange() 3890 << FixItHint::CreateReplacement(R.getNameLoc(), 3891 R.getLookupName().getAsString()); 3892 if (NamedDecl *ND = R.getAsSingle<NamedDecl>()) 3893 SemaRef.Diag(ND->getLocation(), diag::note_previous_decl) 3894 << ND->getDeclName(); 3895 return false; 3896 } else { 3897 R.clear(); 3898 R.setLookupName(Name); 3899 } 3900 3901 return false; 3902} 3903 3904ExprResult 3905Sema::BuildMemberReferenceExpr(Expr *Base, QualType BaseType, 3906 SourceLocation OpLoc, bool IsArrow, 3907 CXXScopeSpec &SS, 3908 NamedDecl *FirstQualifierInScope, 3909 const DeclarationNameInfo &NameInfo, 3910 const TemplateArgumentListInfo *TemplateArgs) { 3911 if (BaseType->isDependentType() || 3912 (SS.isSet() && isDependentScopeSpecifier(SS))) 3913 return ActOnDependentMemberExpr(Base, BaseType, 3914 IsArrow, OpLoc, 3915 SS, FirstQualifierInScope, 3916 NameInfo, TemplateArgs); 3917 3918 LookupResult R(*this, NameInfo, LookupMemberName); 3919 3920 // Implicit member accesses. 3921 if (!Base) { 3922 QualType RecordTy = BaseType; 3923 if (IsArrow) RecordTy = RecordTy->getAs<PointerType>()->getPointeeType(); 3924 if (LookupMemberExprInRecord(*this, R, SourceRange(), 3925 RecordTy->getAs<RecordType>(), 3926 OpLoc, SS, TemplateArgs != 0)) 3927 return ExprError(); 3928 3929 // Explicit member accesses. 3930 } else { 3931 ExprResult BaseResult = Owned(Base); 3932 ExprResult Result = 3933 LookupMemberExpr(R, BaseResult, IsArrow, OpLoc, 3934 SS, /*ObjCImpDecl*/ 0, TemplateArgs != 0); 3935 3936 if (BaseResult.isInvalid()) 3937 return ExprError(); 3938 Base = BaseResult.take(); 3939 3940 if (Result.isInvalid()) { 3941 Owned(Base); 3942 return ExprError(); 3943 } 3944 3945 if (Result.get()) 3946 return move(Result); 3947 3948 // LookupMemberExpr can modify Base, and thus change BaseType 3949 BaseType = Base->getType(); 3950 } 3951 3952 return BuildMemberReferenceExpr(Base, BaseType, 3953 OpLoc, IsArrow, SS, FirstQualifierInScope, 3954 R, TemplateArgs); 3955} 3956 3957ExprResult 3958Sema::BuildMemberReferenceExpr(Expr *BaseExpr, QualType BaseExprType, 3959 SourceLocation OpLoc, bool IsArrow, 3960 const CXXScopeSpec &SS, 3961 NamedDecl *FirstQualifierInScope, 3962 LookupResult &R, 3963 const TemplateArgumentListInfo *TemplateArgs, 3964 bool SuppressQualifierCheck) { 3965 QualType BaseType = BaseExprType; 3966 if (IsArrow) { 3967 assert(BaseType->isPointerType()); 3968 BaseType = BaseType->getAs<PointerType>()->getPointeeType(); 3969 } 3970 R.setBaseObjectType(BaseType); 3971 3972 const DeclarationNameInfo &MemberNameInfo = R.getLookupNameInfo(); 3973 DeclarationName MemberName = MemberNameInfo.getName(); 3974 SourceLocation MemberLoc = MemberNameInfo.getLoc(); 3975 3976 if (R.isAmbiguous()) 3977 return ExprError(); 3978 3979 if (R.empty()) { 3980 // Rederive where we looked up. 3981 DeclContext *DC = (SS.isSet() 3982 ? computeDeclContext(SS, false) 3983 : BaseType->getAs<RecordType>()->getDecl()); 3984 3985 Diag(R.getNameLoc(), diag::err_no_member) 3986 << MemberName << DC 3987 << (BaseExpr ? BaseExpr->getSourceRange() : SourceRange()); 3988 return ExprError(); 3989 } 3990 3991 // Diagnose lookups that find only declarations from a non-base 3992 // type. This is possible for either qualified lookups (which may 3993 // have been qualified with an unrelated type) or implicit member 3994 // expressions (which were found with unqualified lookup and thus 3995 // may have come from an enclosing scope). Note that it's okay for 3996 // lookup to find declarations from a non-base type as long as those 3997 // aren't the ones picked by overload resolution. 3998 if ((SS.isSet() || !BaseExpr || 3999 (isa<CXXThisExpr>(BaseExpr) && 4000 cast<CXXThisExpr>(BaseExpr)->isImplicit())) && 4001 !SuppressQualifierCheck && 4002 CheckQualifiedMemberReference(BaseExpr, BaseType, SS, R)) 4003 return ExprError(); 4004 4005 // Construct an unresolved result if we in fact got an unresolved 4006 // result. 4007 if (R.isOverloadedResult() || R.isUnresolvableResult()) { 4008 // Suppress any lookup-related diagnostics; we'll do these when we 4009 // pick a member. 4010 R.suppressDiagnostics(); 4011 4012 UnresolvedMemberExpr *MemExpr 4013 = UnresolvedMemberExpr::Create(Context, R.isUnresolvableResult(), 4014 BaseExpr, BaseExprType, 4015 IsArrow, OpLoc, 4016 SS.getWithLocInContext(Context), 4017 MemberNameInfo, 4018 TemplateArgs, R.begin(), R.end()); 4019 4020 return Owned(MemExpr); 4021 } 4022 4023 assert(R.isSingleResult()); 4024 DeclAccessPair FoundDecl = R.begin().getPair(); 4025 NamedDecl *MemberDecl = R.getFoundDecl(); 4026 4027 // FIXME: diagnose the presence of template arguments now. 4028 4029 // If the decl being referenced had an error, return an error for this 4030 // sub-expr without emitting another error, in order to avoid cascading 4031 // error cases. 4032 if (MemberDecl->isInvalidDecl()) 4033 return ExprError(); 4034 4035 // Handle the implicit-member-access case. 4036 if (!BaseExpr) { 4037 // If this is not an instance member, convert to a non-member access. 4038 if (!MemberDecl->isCXXInstanceMember()) 4039 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), MemberDecl); 4040 4041 SourceLocation Loc = R.getNameLoc(); 4042 if (SS.getRange().isValid()) 4043 Loc = SS.getRange().getBegin(); 4044 BaseExpr = new (Context) CXXThisExpr(Loc, BaseExprType,/*isImplicit=*/true); 4045 } 4046 4047 bool ShouldCheckUse = true; 4048 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MemberDecl)) { 4049 // Don't diagnose the use of a virtual member function unless it's 4050 // explicitly qualified. 4051 if (MD->isVirtual() && !SS.isSet()) 4052 ShouldCheckUse = false; 4053 } 4054 4055 // Check the use of this member. 4056 if (ShouldCheckUse && DiagnoseUseOfDecl(MemberDecl, MemberLoc)) { 4057 Owned(BaseExpr); 4058 return ExprError(); 4059 } 4060 4061 // Perform a property load on the base regardless of whether we 4062 // actually need it for the declaration. 4063 if (BaseExpr->getObjectKind() == OK_ObjCProperty) { 4064 ExprResult Result = ConvertPropertyForRValue(BaseExpr); 4065 if (Result.isInvalid()) 4066 return ExprError(); 4067 BaseExpr = Result.take(); 4068 } 4069 4070 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) 4071 return BuildFieldReferenceExpr(*this, BaseExpr, IsArrow, 4072 SS, FD, FoundDecl, MemberNameInfo); 4073 4074 if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(MemberDecl)) 4075 // We may have found a field within an anonymous union or struct 4076 // (C++ [class.union]). 4077 return BuildAnonymousStructUnionMemberReference(SS, MemberLoc, FD, 4078 BaseExpr, OpLoc); 4079 4080 if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) { 4081 MarkDeclarationReferenced(MemberLoc, Var); 4082 return Owned(BuildMemberExpr(Context, BaseExpr, IsArrow, SS, 4083 Var, FoundDecl, MemberNameInfo, 4084 Var->getType().getNonReferenceType(), 4085 VK_LValue, OK_Ordinary)); 4086 } 4087 4088 if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) { 4089 ExprValueKind valueKind; 4090 QualType type; 4091 if (MemberFn->isInstance()) { 4092 valueKind = VK_RValue; 4093 type = Context.BoundMemberTy; 4094 } else { 4095 valueKind = VK_LValue; 4096 type = MemberFn->getType(); 4097 } 4098 4099 MarkDeclarationReferenced(MemberLoc, MemberDecl); 4100 return Owned(BuildMemberExpr(Context, BaseExpr, IsArrow, SS, 4101 MemberFn, FoundDecl, MemberNameInfo, 4102 type, valueKind, OK_Ordinary)); 4103 } 4104 assert(!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?"); 4105 4106 if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) { 4107 MarkDeclarationReferenced(MemberLoc, MemberDecl); 4108 return Owned(BuildMemberExpr(Context, BaseExpr, IsArrow, SS, 4109 Enum, FoundDecl, MemberNameInfo, 4110 Enum->getType(), VK_RValue, OK_Ordinary)); 4111 } 4112 4113 Owned(BaseExpr); 4114 4115 // We found something that we didn't expect. Complain. 4116 if (isa<TypeDecl>(MemberDecl)) 4117 Diag(MemberLoc, diag::err_typecheck_member_reference_type) 4118 << MemberName << BaseType << int(IsArrow); 4119 else 4120 Diag(MemberLoc, diag::err_typecheck_member_reference_unknown) 4121 << MemberName << BaseType << int(IsArrow); 4122 4123 Diag(MemberDecl->getLocation(), diag::note_member_declared_here) 4124 << MemberName; 4125 R.suppressDiagnostics(); 4126 return ExprError(); 4127} 4128 4129/// Given that normal member access failed on the given expression, 4130/// and given that the expression's type involves builtin-id or 4131/// builtin-Class, decide whether substituting in the redefinition 4132/// types would be profitable. The redefinition type is whatever 4133/// this translation unit tried to typedef to id/Class; we store 4134/// it to the side and then re-use it in places like this. 4135static bool ShouldTryAgainWithRedefinitionType(Sema &S, ExprResult &base) { 4136 const ObjCObjectPointerType *opty 4137 = base.get()->getType()->getAs<ObjCObjectPointerType>(); 4138 if (!opty) return false; 4139 4140 const ObjCObjectType *ty = opty->getObjectType(); 4141 4142 QualType redef; 4143 if (ty->isObjCId()) { 4144 redef = S.Context.ObjCIdRedefinitionType; 4145 } else if (ty->isObjCClass()) { 4146 redef = S.Context.ObjCClassRedefinitionType; 4147 } else { 4148 return false; 4149 } 4150 4151 // Do the substitution as long as the redefinition type isn't just a 4152 // possibly-qualified pointer to builtin-id or builtin-Class again. 4153 opty = redef->getAs<ObjCObjectPointerType>(); 4154 if (opty && !opty->getObjectType()->getInterface() != 0) 4155 return false; 4156 4157 base = S.ImpCastExprToType(base.take(), redef, CK_BitCast); 4158 return true; 4159} 4160 4161/// Look up the given member of the given non-type-dependent 4162/// expression. This can return in one of two ways: 4163/// * If it returns a sentinel null-but-valid result, the caller will 4164/// assume that lookup was performed and the results written into 4165/// the provided structure. It will take over from there. 4166/// * Otherwise, the returned expression will be produced in place of 4167/// an ordinary member expression. 4168/// 4169/// The ObjCImpDecl bit is a gross hack that will need to be properly 4170/// fixed for ObjC++. 4171ExprResult 4172Sema::LookupMemberExpr(LookupResult &R, ExprResult &BaseExpr, 4173 bool &IsArrow, SourceLocation OpLoc, 4174 CXXScopeSpec &SS, 4175 Decl *ObjCImpDecl, bool HasTemplateArgs) { 4176 assert(BaseExpr.get() && "no base expression"); 4177 4178 // Perform default conversions. 4179 BaseExpr = DefaultFunctionArrayConversion(BaseExpr.take()); 4180 4181 if (IsArrow) { 4182 BaseExpr = DefaultLvalueConversion(BaseExpr.take()); 4183 if (BaseExpr.isInvalid()) 4184 return ExprError(); 4185 } 4186 4187 QualType BaseType = BaseExpr.get()->getType(); 4188 assert(!BaseType->isDependentType()); 4189 4190 DeclarationName MemberName = R.getLookupName(); 4191 SourceLocation MemberLoc = R.getNameLoc(); 4192 4193 // For later type-checking purposes, turn arrow accesses into dot 4194 // accesses. The only access type we support that doesn't follow 4195 // the C equivalence "a->b === (*a).b" is ObjC property accesses, 4196 // and those never use arrows, so this is unaffected. 4197 if (IsArrow) { 4198 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 4199 BaseType = Ptr->getPointeeType(); 4200 else if (const ObjCObjectPointerType *Ptr 4201 = BaseType->getAs<ObjCObjectPointerType>()) 4202 BaseType = Ptr->getPointeeType(); 4203 else if (BaseType->isRecordType()) { 4204 // Recover from arrow accesses to records, e.g.: 4205 // struct MyRecord foo; 4206 // foo->bar 4207 // This is actually well-formed in C++ if MyRecord has an 4208 // overloaded operator->, but that should have been dealt with 4209 // by now. 4210 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 4211 << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange() 4212 << FixItHint::CreateReplacement(OpLoc, "."); 4213 IsArrow = false; 4214 } else if (BaseType == Context.BoundMemberTy) { 4215 goto fail; 4216 } else { 4217 Diag(MemberLoc, diag::err_typecheck_member_reference_arrow) 4218 << BaseType << BaseExpr.get()->getSourceRange(); 4219 return ExprError(); 4220 } 4221 } 4222 4223 // Handle field access to simple records. 4224 if (const RecordType *RTy = BaseType->getAs<RecordType>()) { 4225 if (LookupMemberExprInRecord(*this, R, BaseExpr.get()->getSourceRange(), 4226 RTy, OpLoc, SS, HasTemplateArgs)) 4227 return ExprError(); 4228 4229 // Returning valid-but-null is how we indicate to the caller that 4230 // the lookup result was filled in. 4231 return Owned((Expr*) 0); 4232 } 4233 4234 // Handle ivar access to Objective-C objects. 4235 if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) { 4236 IdentifierInfo *Member = MemberName.getAsIdentifierInfo(); 4237 4238 // There are three cases for the base type: 4239 // - builtin id (qualified or unqualified) 4240 // - builtin Class (qualified or unqualified) 4241 // - an interface 4242 ObjCInterfaceDecl *IDecl = OTy->getInterface(); 4243 if (!IDecl) { 4244 // There's an implicit 'isa' ivar on all objects. 4245 // But we only actually find it this way on objects of type 'id', 4246 // apparently. 4247 if (OTy->isObjCId() && Member->isStr("isa")) 4248 return Owned(new (Context) ObjCIsaExpr(BaseExpr.take(), IsArrow, MemberLoc, 4249 Context.getObjCClassType())); 4250 4251 if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr)) 4252 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS, 4253 ObjCImpDecl, HasTemplateArgs); 4254 goto fail; 4255 } 4256 4257 ObjCInterfaceDecl *ClassDeclared; 4258 ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared); 4259 4260 if (!IV) { 4261 // Attempt to correct for typos in ivar names. 4262 LookupResult Res(*this, R.getLookupName(), R.getNameLoc(), 4263 LookupMemberName); 4264 if (CorrectTypo(Res, 0, 0, IDecl, false, 4265 IsArrow ? CTC_ObjCIvarLookup 4266 : CTC_ObjCPropertyLookup) && 4267 (IV = Res.getAsSingle<ObjCIvarDecl>())) { 4268 Diag(R.getNameLoc(), 4269 diag::err_typecheck_member_reference_ivar_suggest) 4270 << IDecl->getDeclName() << MemberName << IV->getDeclName() 4271 << FixItHint::CreateReplacement(R.getNameLoc(), 4272 IV->getNameAsString()); 4273 Diag(IV->getLocation(), diag::note_previous_decl) 4274 << IV->getDeclName(); 4275 } else { 4276 Res.clear(); 4277 Res.setLookupName(Member); 4278 4279 Diag(MemberLoc, diag::err_typecheck_member_reference_ivar) 4280 << IDecl->getDeclName() << MemberName 4281 << BaseExpr.get()->getSourceRange(); 4282 return ExprError(); 4283 } 4284 } 4285 4286 // If the decl being referenced had an error, return an error for this 4287 // sub-expr without emitting another error, in order to avoid cascading 4288 // error cases. 4289 if (IV->isInvalidDecl()) 4290 return ExprError(); 4291 4292 // Check whether we can reference this field. 4293 if (DiagnoseUseOfDecl(IV, MemberLoc)) 4294 return ExprError(); 4295 if (IV->getAccessControl() != ObjCIvarDecl::Public && 4296 IV->getAccessControl() != ObjCIvarDecl::Package) { 4297 ObjCInterfaceDecl *ClassOfMethodDecl = 0; 4298 if (ObjCMethodDecl *MD = getCurMethodDecl()) 4299 ClassOfMethodDecl = MD->getClassInterface(); 4300 else if (ObjCImpDecl && getCurFunctionDecl()) { 4301 // Case of a c-function declared inside an objc implementation. 4302 // FIXME: For a c-style function nested inside an objc implementation 4303 // class, there is no implementation context available, so we pass 4304 // down the context as argument to this routine. Ideally, this context 4305 // need be passed down in the AST node and somehow calculated from the 4306 // AST for a function decl. 4307 if (ObjCImplementationDecl *IMPD = 4308 dyn_cast<ObjCImplementationDecl>(ObjCImpDecl)) 4309 ClassOfMethodDecl = IMPD->getClassInterface(); 4310 else if (ObjCCategoryImplDecl* CatImplClass = 4311 dyn_cast<ObjCCategoryImplDecl>(ObjCImpDecl)) 4312 ClassOfMethodDecl = CatImplClass->getClassInterface(); 4313 } 4314 4315 if (IV->getAccessControl() == ObjCIvarDecl::Private) { 4316 if (ClassDeclared != IDecl || 4317 ClassOfMethodDecl != ClassDeclared) 4318 Diag(MemberLoc, diag::error_private_ivar_access) 4319 << IV->getDeclName(); 4320 } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl)) 4321 // @protected 4322 Diag(MemberLoc, diag::error_protected_ivar_access) 4323 << IV->getDeclName(); 4324 } 4325 4326 return Owned(new (Context) ObjCIvarRefExpr(IV, IV->getType(), 4327 MemberLoc, BaseExpr.take(), 4328 IsArrow)); 4329 } 4330 4331 // Objective-C property access. 4332 const ObjCObjectPointerType *OPT; 4333 if (!IsArrow && (OPT = BaseType->getAs<ObjCObjectPointerType>())) { 4334 // This actually uses the base as an r-value. 4335 BaseExpr = DefaultLvalueConversion(BaseExpr.take()); 4336 if (BaseExpr.isInvalid()) 4337 return ExprError(); 4338 4339 assert(Context.hasSameUnqualifiedType(BaseType, BaseExpr.get()->getType())); 4340 4341 IdentifierInfo *Member = MemberName.getAsIdentifierInfo(); 4342 4343 const ObjCObjectType *OT = OPT->getObjectType(); 4344 4345 // id, with and without qualifiers. 4346 if (OT->isObjCId()) { 4347 // Check protocols on qualified interfaces. 4348 Selector Sel = PP.getSelectorTable().getNullarySelector(Member); 4349 if (Decl *PMDecl = FindGetterSetterNameDecl(OPT, Member, Sel, Context)) { 4350 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) { 4351 // Check the use of this declaration 4352 if (DiagnoseUseOfDecl(PD, MemberLoc)) 4353 return ExprError(); 4354 4355 QualType T = PD->getType(); 4356 if (ObjCMethodDecl *Getter = PD->getGetterMethodDecl()) 4357 T = getMessageSendResultType(BaseType, Getter, false, false); 4358 4359 return Owned(new (Context) ObjCPropertyRefExpr(PD, T, 4360 VK_LValue, 4361 OK_ObjCProperty, 4362 MemberLoc, 4363 BaseExpr.take())); 4364 } 4365 4366 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) { 4367 // Check the use of this method. 4368 if (DiagnoseUseOfDecl(OMD, MemberLoc)) 4369 return ExprError(); 4370 Selector SetterSel = 4371 SelectorTable::constructSetterName(PP.getIdentifierTable(), 4372 PP.getSelectorTable(), Member); 4373 ObjCMethodDecl *SMD = 0; 4374 if (Decl *SDecl = FindGetterSetterNameDecl(OPT, /*Property id*/0, 4375 SetterSel, Context)) 4376 SMD = dyn_cast<ObjCMethodDecl>(SDecl); 4377 QualType PType = getMessageSendResultType(BaseType, OMD, false, 4378 false); 4379 4380 ExprValueKind VK = VK_LValue; 4381 if (!getLangOptions().CPlusPlus && 4382 IsCForbiddenLValueType(Context, PType)) 4383 VK = VK_RValue; 4384 ExprObjectKind OK = (VK == VK_RValue ? OK_Ordinary : OK_ObjCProperty); 4385 4386 return Owned(new (Context) ObjCPropertyRefExpr(OMD, SMD, PType, 4387 VK, OK, 4388 MemberLoc, BaseExpr.take())); 4389 } 4390 } 4391 // Use of id.member can only be for a property reference. Do not 4392 // use the 'id' redefinition in this case. 4393 if (IsArrow && ShouldTryAgainWithRedefinitionType(*this, BaseExpr)) 4394 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS, 4395 ObjCImpDecl, HasTemplateArgs); 4396 4397 return ExprError(Diag(MemberLoc, diag::err_property_not_found) 4398 << MemberName << BaseType); 4399 } 4400 4401 // 'Class', unqualified only. 4402 if (OT->isObjCClass()) { 4403 // Only works in a method declaration (??!). 4404 ObjCMethodDecl *MD = getCurMethodDecl(); 4405 if (!MD) { 4406 if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr)) 4407 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS, 4408 ObjCImpDecl, HasTemplateArgs); 4409 4410 goto fail; 4411 } 4412 4413 // Also must look for a getter name which uses property syntax. 4414 Selector Sel = PP.getSelectorTable().getNullarySelector(Member); 4415 ObjCInterfaceDecl *IFace = MD->getClassInterface(); 4416 ObjCMethodDecl *Getter; 4417 if ((Getter = IFace->lookupClassMethod(Sel))) { 4418 // Check the use of this method. 4419 if (DiagnoseUseOfDecl(Getter, MemberLoc)) 4420 return ExprError(); 4421 } else 4422 Getter = IFace->lookupPrivateMethod(Sel, false); 4423 // If we found a getter then this may be a valid dot-reference, we 4424 // will look for the matching setter, in case it is needed. 4425 Selector SetterSel = 4426 SelectorTable::constructSetterName(PP.getIdentifierTable(), 4427 PP.getSelectorTable(), Member); 4428 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel); 4429 if (!Setter) { 4430 // If this reference is in an @implementation, also check for 'private' 4431 // methods. 4432 Setter = IFace->lookupPrivateMethod(SetterSel, false); 4433 } 4434 // Look through local category implementations associated with the class. 4435 if (!Setter) 4436 Setter = IFace->getCategoryClassMethod(SetterSel); 4437 4438 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc)) 4439 return ExprError(); 4440 4441 if (Getter || Setter) { 4442 QualType PType; 4443 4444 ExprValueKind VK = VK_LValue; 4445 if (Getter) { 4446 PType = getMessageSendResultType(QualType(OT, 0), Getter, true, 4447 false); 4448 if (!getLangOptions().CPlusPlus && 4449 IsCForbiddenLValueType(Context, PType)) 4450 VK = VK_RValue; 4451 } else { 4452 // Get the expression type from Setter's incoming parameter. 4453 PType = (*(Setter->param_end() -1))->getType(); 4454 } 4455 ExprObjectKind OK = (VK == VK_RValue ? OK_Ordinary : OK_ObjCProperty); 4456 4457 // FIXME: we must check that the setter has property type. 4458 return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter, 4459 PType, VK, OK, 4460 MemberLoc, BaseExpr.take())); 4461 } 4462 4463 if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr)) 4464 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS, 4465 ObjCImpDecl, HasTemplateArgs); 4466 4467 return ExprError(Diag(MemberLoc, diag::err_property_not_found) 4468 << MemberName << BaseType); 4469 } 4470 4471 // Normal property access. 4472 return HandleExprPropertyRefExpr(OPT, BaseExpr.get(), MemberName, MemberLoc, 4473 SourceLocation(), QualType(), false); 4474 } 4475 4476 // Handle 'field access' to vectors, such as 'V.xx'. 4477 if (BaseType->isExtVectorType()) { 4478 // FIXME: this expr should store IsArrow. 4479 IdentifierInfo *Member = MemberName.getAsIdentifierInfo(); 4480 ExprValueKind VK = (IsArrow ? VK_LValue : BaseExpr.get()->getValueKind()); 4481 QualType ret = CheckExtVectorComponent(*this, BaseType, VK, OpLoc, 4482 Member, MemberLoc); 4483 if (ret.isNull()) 4484 return ExprError(); 4485 4486 return Owned(new (Context) ExtVectorElementExpr(ret, VK, BaseExpr.take(), 4487 *Member, MemberLoc)); 4488 } 4489 4490 // Adjust builtin-sel to the appropriate redefinition type if that's 4491 // not just a pointer to builtin-sel again. 4492 if (IsArrow && 4493 BaseType->isSpecificBuiltinType(BuiltinType::ObjCSel) && 4494 !Context.ObjCSelRedefinitionType->isObjCSelType()) { 4495 BaseExpr = ImpCastExprToType(BaseExpr.take(), Context.ObjCSelRedefinitionType, 4496 CK_BitCast); 4497 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS, 4498 ObjCImpDecl, HasTemplateArgs); 4499 } 4500 4501 // Failure cases. 4502 fail: 4503 4504 // Recover from dot accesses to pointers, e.g.: 4505 // type *foo; 4506 // foo.bar 4507 // This is actually well-formed in two cases: 4508 // - 'type' is an Objective C type 4509 // - 'bar' is a pseudo-destructor name which happens to refer to 4510 // the appropriate pointer type 4511 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) { 4512 if (!IsArrow && Ptr->getPointeeType()->isRecordType() && 4513 MemberName.getNameKind() != DeclarationName::CXXDestructorName) { 4514 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 4515 << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange() 4516 << FixItHint::CreateReplacement(OpLoc, "->"); 4517 4518 // Recurse as an -> access. 4519 IsArrow = true; 4520 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS, 4521 ObjCImpDecl, HasTemplateArgs); 4522 } 4523 } 4524 4525 // If the user is trying to apply -> or . to a function name, it's probably 4526 // because they forgot parentheses to call that function. 4527 QualType ZeroArgCallTy; 4528 UnresolvedSet<4> Overloads; 4529 if (isExprCallable(*BaseExpr.get(), ZeroArgCallTy, Overloads)) { 4530 if (ZeroArgCallTy.isNull()) { 4531 Diag(BaseExpr.get()->getExprLoc(), diag::err_member_reference_needs_call) 4532 << (Overloads.size() > 1) << 0 << BaseExpr.get()->getSourceRange(); 4533 UnresolvedSet<2> PlausibleOverloads; 4534 for (OverloadExpr::decls_iterator It = Overloads.begin(), 4535 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { 4536 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It); 4537 QualType OverloadResultTy = OverloadDecl->getResultType(); 4538 if ((!IsArrow && OverloadResultTy->isRecordType()) || 4539 (IsArrow && OverloadResultTy->isPointerType() && 4540 OverloadResultTy->getPointeeType()->isRecordType())) 4541 PlausibleOverloads.addDecl(It.getDecl()); 4542 } 4543 NoteOverloads(PlausibleOverloads, BaseExpr.get()->getExprLoc()); 4544 return ExprError(); 4545 } 4546 if ((!IsArrow && ZeroArgCallTy->isRecordType()) || 4547 (IsArrow && ZeroArgCallTy->isPointerType() && 4548 ZeroArgCallTy->getPointeeType()->isRecordType())) { 4549 // At this point, we know BaseExpr looks like it's potentially callable 4550 // with 0 arguments, and that it returns something of a reasonable type, 4551 // so we can emit a fixit and carry on pretending that BaseExpr was 4552 // actually a CallExpr. 4553 SourceLocation ParenInsertionLoc = 4554 PP.getLocForEndOfToken(BaseExpr.get()->getLocEnd()); 4555 Diag(BaseExpr.get()->getExprLoc(), diag::err_member_reference_needs_call) 4556 << (Overloads.size() > 1) << 1 << BaseExpr.get()->getSourceRange() 4557 << FixItHint::CreateInsertion(ParenInsertionLoc, "()"); 4558 // FIXME: Try this before emitting the fixit, and suppress diagnostics 4559 // while doing so. 4560 ExprResult NewBase = 4561 ActOnCallExpr(0, BaseExpr.take(), ParenInsertionLoc, 4562 MultiExprArg(*this, 0, 0), 4563 ParenInsertionLoc.getFileLocWithOffset(1)); 4564 if (NewBase.isInvalid()) 4565 return ExprError(); 4566 BaseExpr = NewBase; 4567 BaseExpr = DefaultFunctionArrayConversion(BaseExpr.take()); 4568 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS, 4569 ObjCImpDecl, HasTemplateArgs); 4570 } 4571 } 4572 4573 Diag(MemberLoc, diag::err_typecheck_member_reference_struct_union) 4574 << BaseType << BaseExpr.get()->getSourceRange(); 4575 4576 return ExprError(); 4577} 4578 4579/// The main callback when the parser finds something like 4580/// expression . [nested-name-specifier] identifier 4581/// expression -> [nested-name-specifier] identifier 4582/// where 'identifier' encompasses a fairly broad spectrum of 4583/// possibilities, including destructor and operator references. 4584/// 4585/// \param OpKind either tok::arrow or tok::period 4586/// \param HasTrailingLParen whether the next token is '(', which 4587/// is used to diagnose mis-uses of special members that can 4588/// only be called 4589/// \param ObjCImpDecl the current ObjC @implementation decl; 4590/// this is an ugly hack around the fact that ObjC @implementations 4591/// aren't properly put in the context chain 4592ExprResult Sema::ActOnMemberAccessExpr(Scope *S, Expr *Base, 4593 SourceLocation OpLoc, 4594 tok::TokenKind OpKind, 4595 CXXScopeSpec &SS, 4596 UnqualifiedId &Id, 4597 Decl *ObjCImpDecl, 4598 bool HasTrailingLParen) { 4599 if (SS.isSet() && SS.isInvalid()) 4600 return ExprError(); 4601 4602 // Warn about the explicit constructor calls Microsoft extension. 4603 if (getLangOptions().Microsoft && 4604 Id.getKind() == UnqualifiedId::IK_ConstructorName) 4605 Diag(Id.getSourceRange().getBegin(), 4606 diag::ext_ms_explicit_constructor_call); 4607 4608 TemplateArgumentListInfo TemplateArgsBuffer; 4609 4610 // Decompose the name into its component parts. 4611 DeclarationNameInfo NameInfo; 4612 const TemplateArgumentListInfo *TemplateArgs; 4613 DecomposeUnqualifiedId(*this, Id, TemplateArgsBuffer, 4614 NameInfo, TemplateArgs); 4615 4616 DeclarationName Name = NameInfo.getName(); 4617 bool IsArrow = (OpKind == tok::arrow); 4618 4619 NamedDecl *FirstQualifierInScope 4620 = (!SS.isSet() ? 0 : FindFirstQualifierInScope(S, 4621 static_cast<NestedNameSpecifier*>(SS.getScopeRep()))); 4622 4623 // This is a postfix expression, so get rid of ParenListExprs. 4624 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); 4625 if (Result.isInvalid()) return ExprError(); 4626 Base = Result.take(); 4627 4628 if (Base->getType()->isDependentType() || Name.isDependentName() || 4629 isDependentScopeSpecifier(SS)) { 4630 Result = ActOnDependentMemberExpr(Base, Base->getType(), 4631 IsArrow, OpLoc, 4632 SS, FirstQualifierInScope, 4633 NameInfo, TemplateArgs); 4634 } else { 4635 LookupResult R(*this, NameInfo, LookupMemberName); 4636 ExprResult BaseResult = Owned(Base); 4637 Result = LookupMemberExpr(R, BaseResult, IsArrow, OpLoc, 4638 SS, ObjCImpDecl, TemplateArgs != 0); 4639 if (BaseResult.isInvalid()) 4640 return ExprError(); 4641 Base = BaseResult.take(); 4642 4643 if (Result.isInvalid()) { 4644 Owned(Base); 4645 return ExprError(); 4646 } 4647 4648 if (Result.get()) { 4649 // The only way a reference to a destructor can be used is to 4650 // immediately call it, which falls into this case. If the 4651 // next token is not a '(', produce a diagnostic and build the 4652 // call now. 4653 if (!HasTrailingLParen && 4654 Id.getKind() == UnqualifiedId::IK_DestructorName) 4655 return DiagnoseDtorReference(NameInfo.getLoc(), Result.get()); 4656 4657 return move(Result); 4658 } 4659 4660 Result = BuildMemberReferenceExpr(Base, Base->getType(), 4661 OpLoc, IsArrow, SS, FirstQualifierInScope, 4662 R, TemplateArgs); 4663 } 4664 4665 return move(Result); 4666} 4667 4668ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc, 4669 FunctionDecl *FD, 4670 ParmVarDecl *Param) { 4671 if (Param->hasUnparsedDefaultArg()) { 4672 Diag(CallLoc, 4673 diag::err_use_of_default_argument_to_function_declared_later) << 4674 FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName(); 4675 Diag(UnparsedDefaultArgLocs[Param], 4676 diag::note_default_argument_declared_here); 4677 return ExprError(); 4678 } 4679 4680 if (Param->hasUninstantiatedDefaultArg()) { 4681 Expr *UninstExpr = Param->getUninstantiatedDefaultArg(); 4682 4683 // Instantiate the expression. 4684 MultiLevelTemplateArgumentList ArgList 4685 = getTemplateInstantiationArgs(FD, 0, /*RelativeToPrimary=*/true); 4686 4687 std::pair<const TemplateArgument *, unsigned> Innermost 4688 = ArgList.getInnermost(); 4689 InstantiatingTemplate Inst(*this, CallLoc, Param, Innermost.first, 4690 Innermost.second); 4691 4692 ExprResult Result; 4693 { 4694 // C++ [dcl.fct.default]p5: 4695 // The names in the [default argument] expression are bound, and 4696 // the semantic constraints are checked, at the point where the 4697 // default argument expression appears. 4698 ContextRAII SavedContext(*this, FD); 4699 Result = SubstExpr(UninstExpr, ArgList); 4700 } 4701 if (Result.isInvalid()) 4702 return ExprError(); 4703 4704 // Check the expression as an initializer for the parameter. 4705 InitializedEntity Entity 4706 = InitializedEntity::InitializeParameter(Context, Param); 4707 InitializationKind Kind 4708 = InitializationKind::CreateCopy(Param->getLocation(), 4709 /*FIXME:EqualLoc*/UninstExpr->getSourceRange().getBegin()); 4710 Expr *ResultE = Result.takeAs<Expr>(); 4711 4712 InitializationSequence InitSeq(*this, Entity, Kind, &ResultE, 1); 4713 Result = InitSeq.Perform(*this, Entity, Kind, 4714 MultiExprArg(*this, &ResultE, 1)); 4715 if (Result.isInvalid()) 4716 return ExprError(); 4717 4718 // Build the default argument expression. 4719 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param, 4720 Result.takeAs<Expr>())); 4721 } 4722 4723 // If the default expression creates temporaries, we need to 4724 // push them to the current stack of expression temporaries so they'll 4725 // be properly destroyed. 4726 // FIXME: We should really be rebuilding the default argument with new 4727 // bound temporaries; see the comment in PR5810. 4728 for (unsigned i = 0, e = Param->getNumDefaultArgTemporaries(); i != e; ++i) { 4729 CXXTemporary *Temporary = Param->getDefaultArgTemporary(i); 4730 MarkDeclarationReferenced(Param->getDefaultArg()->getLocStart(), 4731 const_cast<CXXDestructorDecl*>(Temporary->getDestructor())); 4732 ExprTemporaries.push_back(Temporary); 4733 } 4734 4735 // We already type-checked the argument, so we know it works. 4736 // Just mark all of the declarations in this potentially-evaluated expression 4737 // as being "referenced". 4738 MarkDeclarationsReferencedInExpr(Param->getDefaultArg()); 4739 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param)); 4740} 4741 4742/// ConvertArgumentsForCall - Converts the arguments specified in 4743/// Args/NumArgs to the parameter types of the function FDecl with 4744/// function prototype Proto. Call is the call expression itself, and 4745/// Fn is the function expression. For a C++ member function, this 4746/// routine does not attempt to convert the object argument. Returns 4747/// true if the call is ill-formed. 4748bool 4749Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, 4750 FunctionDecl *FDecl, 4751 const FunctionProtoType *Proto, 4752 Expr **Args, unsigned NumArgs, 4753 SourceLocation RParenLoc) { 4754 // Bail out early if calling a builtin with custom typechecking. 4755 // We don't need to do this in the 4756 if (FDecl) 4757 if (unsigned ID = FDecl->getBuiltinID()) 4758 if (Context.BuiltinInfo.hasCustomTypechecking(ID)) 4759 return false; 4760 4761 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by 4762 // assignment, to the types of the corresponding parameter, ... 4763 unsigned NumArgsInProto = Proto->getNumArgs(); 4764 bool Invalid = false; 4765 4766 // If too few arguments are available (and we don't have default 4767 // arguments for the remaining parameters), don't make the call. 4768 if (NumArgs < NumArgsInProto) { 4769 if (!FDecl || NumArgs < FDecl->getMinRequiredArguments()) 4770 return Diag(RParenLoc, diag::err_typecheck_call_too_few_args) 4771 << Fn->getType()->isBlockPointerType() 4772 << NumArgsInProto << NumArgs << Fn->getSourceRange(); 4773 Call->setNumArgs(Context, NumArgsInProto); 4774 } 4775 4776 // If too many are passed and not variadic, error on the extras and drop 4777 // them. 4778 if (NumArgs > NumArgsInProto) { 4779 if (!Proto->isVariadic()) { 4780 Diag(Args[NumArgsInProto]->getLocStart(), 4781 diag::err_typecheck_call_too_many_args) 4782 << Fn->getType()->isBlockPointerType() 4783 << NumArgsInProto << NumArgs << Fn->getSourceRange() 4784 << SourceRange(Args[NumArgsInProto]->getLocStart(), 4785 Args[NumArgs-1]->getLocEnd()); 4786 4787 // Emit the location of the prototype. 4788 if (FDecl && !FDecl->getBuiltinID()) 4789 Diag(FDecl->getLocStart(), 4790 diag::note_typecheck_call_too_many_args) 4791 << FDecl; 4792 4793 // This deletes the extra arguments. 4794 Call->setNumArgs(Context, NumArgsInProto); 4795 return true; 4796 } 4797 } 4798 llvm::SmallVector<Expr *, 8> AllArgs; 4799 VariadicCallType CallType = 4800 Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply; 4801 if (Fn->getType()->isBlockPointerType()) 4802 CallType = VariadicBlock; // Block 4803 else if (isa<MemberExpr>(Fn)) 4804 CallType = VariadicMethod; 4805 Invalid = GatherArgumentsForCall(Call->getSourceRange().getBegin(), FDecl, 4806 Proto, 0, Args, NumArgs, AllArgs, CallType); 4807 if (Invalid) 4808 return true; 4809 unsigned TotalNumArgs = AllArgs.size(); 4810 for (unsigned i = 0; i < TotalNumArgs; ++i) 4811 Call->setArg(i, AllArgs[i]); 4812 4813 return false; 4814} 4815 4816bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, 4817 FunctionDecl *FDecl, 4818 const FunctionProtoType *Proto, 4819 unsigned FirstProtoArg, 4820 Expr **Args, unsigned NumArgs, 4821 llvm::SmallVector<Expr *, 8> &AllArgs, 4822 VariadicCallType CallType) { 4823 unsigned NumArgsInProto = Proto->getNumArgs(); 4824 unsigned NumArgsToCheck = NumArgs; 4825 bool Invalid = false; 4826 if (NumArgs != NumArgsInProto) 4827 // Use default arguments for missing arguments 4828 NumArgsToCheck = NumArgsInProto; 4829 unsigned ArgIx = 0; 4830 // Continue to check argument types (even if we have too few/many args). 4831 for (unsigned i = FirstProtoArg; i != NumArgsToCheck; i++) { 4832 QualType ProtoArgType = Proto->getArgType(i); 4833 4834 Expr *Arg; 4835 if (ArgIx < NumArgs) { 4836 Arg = Args[ArgIx++]; 4837 4838 if (RequireCompleteType(Arg->getSourceRange().getBegin(), 4839 ProtoArgType, 4840 PDiag(diag::err_call_incomplete_argument) 4841 << Arg->getSourceRange())) 4842 return true; 4843 4844 // Pass the argument 4845 ParmVarDecl *Param = 0; 4846 if (FDecl && i < FDecl->getNumParams()) 4847 Param = FDecl->getParamDecl(i); 4848 4849 InitializedEntity Entity = 4850 Param? InitializedEntity::InitializeParameter(Context, Param) 4851 : InitializedEntity::InitializeParameter(Context, ProtoArgType); 4852 ExprResult ArgE = PerformCopyInitialization(Entity, 4853 SourceLocation(), 4854 Owned(Arg)); 4855 if (ArgE.isInvalid()) 4856 return true; 4857 4858 Arg = ArgE.takeAs<Expr>(); 4859 } else { 4860 ParmVarDecl *Param = FDecl->getParamDecl(i); 4861 4862 ExprResult ArgExpr = 4863 BuildCXXDefaultArgExpr(CallLoc, FDecl, Param); 4864 if (ArgExpr.isInvalid()) 4865 return true; 4866 4867 Arg = ArgExpr.takeAs<Expr>(); 4868 } 4869 AllArgs.push_back(Arg); 4870 } 4871 4872 // If this is a variadic call, handle args passed through "...". 4873 if (CallType != VariadicDoesNotApply) { 4874 4875 // Assume that extern "C" functions with variadic arguments that 4876 // return __unknown_anytype aren't *really* variadic. 4877 if (Proto->getResultType() == Context.UnknownAnyTy && 4878 FDecl && FDecl->isExternC()) { 4879 for (unsigned i = ArgIx; i != NumArgs; ++i) { 4880 ExprResult arg; 4881 if (isa<ExplicitCastExpr>(Args[i]->IgnoreParens())) 4882 arg = DefaultFunctionArrayLvalueConversion(Args[i]); 4883 else 4884 arg = DefaultVariadicArgumentPromotion(Args[i], CallType, FDecl); 4885 Invalid |= arg.isInvalid(); 4886 AllArgs.push_back(arg.take()); 4887 } 4888 4889 // Otherwise do argument promotion, (C99 6.5.2.2p7). 4890 } else { 4891 for (unsigned i = ArgIx; i != NumArgs; ++i) { 4892 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], CallType, FDecl); 4893 Invalid |= Arg.isInvalid(); 4894 AllArgs.push_back(Arg.take()); 4895 } 4896 } 4897 } 4898 return Invalid; 4899} 4900 4901/// Given a function expression of unknown-any type, try to rebuild it 4902/// to have a function type. 4903static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn); 4904 4905/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments. 4906/// This provides the location of the left/right parens and a list of comma 4907/// locations. 4908ExprResult 4909Sema::ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, 4910 MultiExprArg args, SourceLocation RParenLoc, 4911 Expr *ExecConfig) { 4912 unsigned NumArgs = args.size(); 4913 4914 // Since this might be a postfix expression, get rid of ParenListExprs. 4915 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn); 4916 if (Result.isInvalid()) return ExprError(); 4917 Fn = Result.take(); 4918 4919 Expr **Args = args.release(); 4920 4921 if (getLangOptions().CPlusPlus) { 4922 // If this is a pseudo-destructor expression, build the call immediately. 4923 if (isa<CXXPseudoDestructorExpr>(Fn)) { 4924 if (NumArgs > 0) { 4925 // Pseudo-destructor calls should not have any arguments. 4926 Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args) 4927 << FixItHint::CreateRemoval( 4928 SourceRange(Args[0]->getLocStart(), 4929 Args[NumArgs-1]->getLocEnd())); 4930 4931 NumArgs = 0; 4932 } 4933 4934 return Owned(new (Context) CallExpr(Context, Fn, 0, 0, Context.VoidTy, 4935 VK_RValue, RParenLoc)); 4936 } 4937 4938 // Determine whether this is a dependent call inside a C++ template, 4939 // in which case we won't do any semantic analysis now. 4940 // FIXME: Will need to cache the results of name lookup (including ADL) in 4941 // Fn. 4942 bool Dependent = false; 4943 if (Fn->isTypeDependent()) 4944 Dependent = true; 4945 else if (Expr::hasAnyTypeDependentArguments(Args, NumArgs)) 4946 Dependent = true; 4947 4948 if (Dependent) { 4949 if (ExecConfig) { 4950 return Owned(new (Context) CUDAKernelCallExpr( 4951 Context, Fn, cast<CallExpr>(ExecConfig), Args, NumArgs, 4952 Context.DependentTy, VK_RValue, RParenLoc)); 4953 } else { 4954 return Owned(new (Context) CallExpr(Context, Fn, Args, NumArgs, 4955 Context.DependentTy, VK_RValue, 4956 RParenLoc)); 4957 } 4958 } 4959 4960 // Determine whether this is a call to an object (C++ [over.call.object]). 4961 if (Fn->getType()->isRecordType()) 4962 return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc, Args, NumArgs, 4963 RParenLoc)); 4964 4965 if (Fn->getType() == Context.UnknownAnyTy) { 4966 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 4967 if (result.isInvalid()) return ExprError(); 4968 Fn = result.take(); 4969 } 4970 4971 if (Fn->getType() == Context.BoundMemberTy) { 4972 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs, 4973 RParenLoc); 4974 } 4975 } 4976 4977 // Check for overloaded calls. This can happen even in C due to extensions. 4978 if (Fn->getType() == Context.OverloadTy) { 4979 OverloadExpr::FindResult find = OverloadExpr::find(Fn); 4980 4981 // We aren't supposed to apply this logic if there's an '&' involved. 4982 if (!find.IsAddressOfOperand) { 4983 OverloadExpr *ovl = find.Expression; 4984 if (isa<UnresolvedLookupExpr>(ovl)) { 4985 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(ovl); 4986 return BuildOverloadedCallExpr(S, Fn, ULE, LParenLoc, Args, NumArgs, 4987 RParenLoc, ExecConfig); 4988 } else { 4989 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs, 4990 RParenLoc); 4991 } 4992 } 4993 } 4994 4995 // If we're directly calling a function, get the appropriate declaration. 4996 4997 Expr *NakedFn = Fn->IgnoreParens(); 4998 4999 NamedDecl *NDecl = 0; 5000 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) 5001 if (UnOp->getOpcode() == UO_AddrOf) 5002 NakedFn = UnOp->getSubExpr()->IgnoreParens(); 5003 5004 if (isa<DeclRefExpr>(NakedFn)) 5005 NDecl = cast<DeclRefExpr>(NakedFn)->getDecl(); 5006 else if (isa<MemberExpr>(NakedFn)) 5007 NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl(); 5008 5009 return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, Args, NumArgs, RParenLoc, 5010 ExecConfig); 5011} 5012 5013ExprResult 5014Sema::ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc, 5015 MultiExprArg execConfig, SourceLocation GGGLoc) { 5016 FunctionDecl *ConfigDecl = Context.getcudaConfigureCallDecl(); 5017 if (!ConfigDecl) 5018 return ExprError(Diag(LLLLoc, diag::err_undeclared_var_use) 5019 << "cudaConfigureCall"); 5020 QualType ConfigQTy = ConfigDecl->getType(); 5021 5022 DeclRefExpr *ConfigDR = new (Context) DeclRefExpr( 5023 ConfigDecl, ConfigQTy, VK_LValue, LLLLoc); 5024 5025 return ActOnCallExpr(S, ConfigDR, LLLLoc, execConfig, GGGLoc, 0); 5026} 5027 5028/// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments. 5029/// 5030/// __builtin_astype( value, dst type ) 5031/// 5032ExprResult Sema::ActOnAsTypeExpr(Expr *expr, ParsedType destty, 5033 SourceLocation BuiltinLoc, 5034 SourceLocation RParenLoc) { 5035 ExprValueKind VK = VK_RValue; 5036 ExprObjectKind OK = OK_Ordinary; 5037 QualType DstTy = GetTypeFromParser(destty); 5038 QualType SrcTy = expr->getType(); 5039 if (Context.getTypeSize(DstTy) != Context.getTypeSize(SrcTy)) 5040 return ExprError(Diag(BuiltinLoc, 5041 diag::err_invalid_astype_of_different_size) 5042 << DstTy 5043 << SrcTy 5044 << expr->getSourceRange()); 5045 return Owned(new (Context) AsTypeExpr(expr, DstTy, VK, OK, BuiltinLoc, RParenLoc)); 5046} 5047 5048/// BuildResolvedCallExpr - Build a call to a resolved expression, 5049/// i.e. an expression not of \p OverloadTy. The expression should 5050/// unary-convert to an expression of function-pointer or 5051/// block-pointer type. 5052/// 5053/// \param NDecl the declaration being called, if available 5054ExprResult 5055Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, 5056 SourceLocation LParenLoc, 5057 Expr **Args, unsigned NumArgs, 5058 SourceLocation RParenLoc, 5059 Expr *Config) { 5060 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl); 5061 5062 // Promote the function operand. 5063 ExprResult Result = UsualUnaryConversions(Fn); 5064 if (Result.isInvalid()) 5065 return ExprError(); 5066 Fn = Result.take(); 5067 5068 // Make the call expr early, before semantic checks. This guarantees cleanup 5069 // of arguments and function on error. 5070 CallExpr *TheCall; 5071 if (Config) { 5072 TheCall = new (Context) CUDAKernelCallExpr(Context, Fn, 5073 cast<CallExpr>(Config), 5074 Args, NumArgs, 5075 Context.BoolTy, 5076 VK_RValue, 5077 RParenLoc); 5078 } else { 5079 TheCall = new (Context) CallExpr(Context, Fn, 5080 Args, NumArgs, 5081 Context.BoolTy, 5082 VK_RValue, 5083 RParenLoc); 5084 } 5085 5086 unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0); 5087 5088 // Bail out early if calling a builtin with custom typechecking. 5089 if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID)) 5090 return CheckBuiltinFunctionCall(BuiltinID, TheCall); 5091 5092 retry: 5093 const FunctionType *FuncT; 5094 if (const PointerType *PT = Fn->getType()->getAs<PointerType>()) { 5095 // C99 6.5.2.2p1 - "The expression that denotes the called function shall 5096 // have type pointer to function". 5097 FuncT = PT->getPointeeType()->getAs<FunctionType>(); 5098 if (FuncT == 0) 5099 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 5100 << Fn->getType() << Fn->getSourceRange()); 5101 } else if (const BlockPointerType *BPT = 5102 Fn->getType()->getAs<BlockPointerType>()) { 5103 FuncT = BPT->getPointeeType()->castAs<FunctionType>(); 5104 } else { 5105 // Handle calls to expressions of unknown-any type. 5106 if (Fn->getType() == Context.UnknownAnyTy) { 5107 ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn); 5108 if (rewrite.isInvalid()) return ExprError(); 5109 Fn = rewrite.take(); 5110 TheCall->setCallee(Fn); 5111 goto retry; 5112 } 5113 5114 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 5115 << Fn->getType() << Fn->getSourceRange()); 5116 } 5117 5118 if (getLangOptions().CUDA) { 5119 if (Config) { 5120 // CUDA: Kernel calls must be to global functions 5121 if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>()) 5122 return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function) 5123 << FDecl->getName() << Fn->getSourceRange()); 5124 5125 // CUDA: Kernel function must have 'void' return type 5126 if (!FuncT->getResultType()->isVoidType()) 5127 return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return) 5128 << Fn->getType() << Fn->getSourceRange()); 5129 } 5130 } 5131 5132 // Check for a valid return type 5133 if (CheckCallReturnType(FuncT->getResultType(), 5134 Fn->getSourceRange().getBegin(), TheCall, 5135 FDecl)) 5136 return ExprError(); 5137 5138 // We know the result type of the call, set it. 5139 TheCall->setType(FuncT->getCallResultType(Context)); 5140 TheCall->setValueKind(Expr::getValueKindForType(FuncT->getResultType())); 5141 5142 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) { 5143 if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, NumArgs, 5144 RParenLoc)) 5145 return ExprError(); 5146 } else { 5147 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!"); 5148 5149 if (FDecl) { 5150 // Check if we have too few/too many template arguments, based 5151 // on our knowledge of the function definition. 5152 const FunctionDecl *Def = 0; 5153 if (FDecl->hasBody(Def) && NumArgs != Def->param_size()) { 5154 const FunctionProtoType *Proto 5155 = Def->getType()->getAs<FunctionProtoType>(); 5156 if (!Proto || !(Proto->isVariadic() && NumArgs >= Def->param_size())) 5157 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments) 5158 << (NumArgs > Def->param_size()) << FDecl << Fn->getSourceRange(); 5159 } 5160 5161 // If the function we're calling isn't a function prototype, but we have 5162 // a function prototype from a prior declaratiom, use that prototype. 5163 if (!FDecl->hasPrototype()) 5164 Proto = FDecl->getType()->getAs<FunctionProtoType>(); 5165 } 5166 5167 // Promote the arguments (C99 6.5.2.2p6). 5168 for (unsigned i = 0; i != NumArgs; i++) { 5169 Expr *Arg = Args[i]; 5170 5171 if (Proto && i < Proto->getNumArgs()) { 5172 InitializedEntity Entity 5173 = InitializedEntity::InitializeParameter(Context, 5174 Proto->getArgType(i)); 5175 ExprResult ArgE = PerformCopyInitialization(Entity, 5176 SourceLocation(), 5177 Owned(Arg)); 5178 if (ArgE.isInvalid()) 5179 return true; 5180 5181 Arg = ArgE.takeAs<Expr>(); 5182 5183 } else { 5184 ExprResult ArgE = DefaultArgumentPromotion(Arg); 5185 5186 if (ArgE.isInvalid()) 5187 return true; 5188 5189 Arg = ArgE.takeAs<Expr>(); 5190 } 5191 5192 if (RequireCompleteType(Arg->getSourceRange().getBegin(), 5193 Arg->getType(), 5194 PDiag(diag::err_call_incomplete_argument) 5195 << Arg->getSourceRange())) 5196 return ExprError(); 5197 5198 TheCall->setArg(i, Arg); 5199 } 5200 } 5201 5202 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl)) 5203 if (!Method->isStatic()) 5204 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object) 5205 << Fn->getSourceRange()); 5206 5207 // Check for sentinels 5208 if (NDecl) 5209 DiagnoseSentinelCalls(NDecl, LParenLoc, Args, NumArgs); 5210 5211 // Do special checking on direct calls to functions. 5212 if (FDecl) { 5213 if (CheckFunctionCall(FDecl, TheCall)) 5214 return ExprError(); 5215 5216 if (BuiltinID) 5217 return CheckBuiltinFunctionCall(BuiltinID, TheCall); 5218 } else if (NDecl) { 5219 if (CheckBlockCall(NDecl, TheCall)) 5220 return ExprError(); 5221 } 5222 5223 return MaybeBindToTemporary(TheCall); 5224} 5225 5226ExprResult 5227Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, 5228 SourceLocation RParenLoc, Expr *InitExpr) { 5229 assert((Ty != 0) && "ActOnCompoundLiteral(): missing type"); 5230 // FIXME: put back this assert when initializers are worked out. 5231 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression"); 5232 5233 TypeSourceInfo *TInfo; 5234 QualType literalType = GetTypeFromParser(Ty, &TInfo); 5235 if (!TInfo) 5236 TInfo = Context.getTrivialTypeSourceInfo(literalType); 5237 5238 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr); 5239} 5240 5241ExprResult 5242Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, 5243 SourceLocation RParenLoc, Expr *literalExpr) { 5244 QualType literalType = TInfo->getType(); 5245 5246 if (literalType->isArrayType()) { 5247 if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType), 5248 PDiag(diag::err_illegal_decl_array_incomplete_type) 5249 << SourceRange(LParenLoc, 5250 literalExpr->getSourceRange().getEnd()))) 5251 return ExprError(); 5252 if (literalType->isVariableArrayType()) 5253 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init) 5254 << SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd())); 5255 } else if (!literalType->isDependentType() && 5256 RequireCompleteType(LParenLoc, literalType, 5257 PDiag(diag::err_typecheck_decl_incomplete_type) 5258 << SourceRange(LParenLoc, 5259 literalExpr->getSourceRange().getEnd()))) 5260 return ExprError(); 5261 5262 InitializedEntity Entity 5263 = InitializedEntity::InitializeTemporary(literalType); 5264 InitializationKind Kind 5265 = InitializationKind::CreateCast(SourceRange(LParenLoc, RParenLoc), 5266 /*IsCStyleCast=*/true); 5267 InitializationSequence InitSeq(*this, Entity, Kind, &literalExpr, 1); 5268 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, 5269 MultiExprArg(*this, &literalExpr, 1), 5270 &literalType); 5271 if (Result.isInvalid()) 5272 return ExprError(); 5273 literalExpr = Result.get(); 5274 5275 bool isFileScope = getCurFunctionOrMethodDecl() == 0; 5276 if (isFileScope) { // 6.5.2.5p3 5277 if (CheckForConstantInitializer(literalExpr, literalType)) 5278 return ExprError(); 5279 } 5280 5281 // In C, compound literals are l-values for some reason. 5282 ExprValueKind VK = getLangOptions().CPlusPlus ? VK_RValue : VK_LValue; 5283 5284 return Owned(new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType, 5285 VK, literalExpr, isFileScope)); 5286} 5287 5288ExprResult 5289Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg initlist, 5290 SourceLocation RBraceLoc) { 5291 unsigned NumInit = initlist.size(); 5292 Expr **InitList = initlist.release(); 5293 5294 // Semantic analysis for initializers is done by ActOnDeclarator() and 5295 // CheckInitializer() - it requires knowledge of the object being intialized. 5296 5297 InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitList, 5298 NumInit, RBraceLoc); 5299 E->setType(Context.VoidTy); // FIXME: just a place holder for now. 5300 return Owned(E); 5301} 5302 5303/// Prepares for a scalar cast, performing all the necessary stages 5304/// except the final cast and returning the kind required. 5305static CastKind PrepareScalarCast(Sema &S, ExprResult &Src, QualType DestTy) { 5306 // Both Src and Dest are scalar types, i.e. arithmetic or pointer. 5307 // Also, callers should have filtered out the invalid cases with 5308 // pointers. Everything else should be possible. 5309 5310 QualType SrcTy = Src.get()->getType(); 5311 if (S.Context.hasSameUnqualifiedType(SrcTy, DestTy)) 5312 return CK_NoOp; 5313 5314 switch (SrcTy->getScalarTypeKind()) { 5315 case Type::STK_MemberPointer: 5316 llvm_unreachable("member pointer type in C"); 5317 5318 case Type::STK_Pointer: 5319 switch (DestTy->getScalarTypeKind()) { 5320 case Type::STK_Pointer: 5321 return DestTy->isObjCObjectPointerType() ? 5322 CK_AnyPointerToObjCPointerCast : 5323 CK_BitCast; 5324 case Type::STK_Bool: 5325 return CK_PointerToBoolean; 5326 case Type::STK_Integral: 5327 return CK_PointerToIntegral; 5328 case Type::STK_Floating: 5329 case Type::STK_FloatingComplex: 5330 case Type::STK_IntegralComplex: 5331 case Type::STK_MemberPointer: 5332 llvm_unreachable("illegal cast from pointer"); 5333 } 5334 break; 5335 5336 case Type::STK_Bool: // casting from bool is like casting from an integer 5337 case Type::STK_Integral: 5338 switch (DestTy->getScalarTypeKind()) { 5339 case Type::STK_Pointer: 5340 if (Src.get()->isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNull)) 5341 return CK_NullToPointer; 5342 return CK_IntegralToPointer; 5343 case Type::STK_Bool: 5344 return CK_IntegralToBoolean; 5345 case Type::STK_Integral: 5346 return CK_IntegralCast; 5347 case Type::STK_Floating: 5348 return CK_IntegralToFloating; 5349 case Type::STK_IntegralComplex: 5350 Src = S.ImpCastExprToType(Src.take(), DestTy->getAs<ComplexType>()->getElementType(), 5351 CK_IntegralCast); 5352 return CK_IntegralRealToComplex; 5353 case Type::STK_FloatingComplex: 5354 Src = S.ImpCastExprToType(Src.take(), DestTy->getAs<ComplexType>()->getElementType(), 5355 CK_IntegralToFloating); 5356 return CK_FloatingRealToComplex; 5357 case Type::STK_MemberPointer: 5358 llvm_unreachable("member pointer type in C"); 5359 } 5360 break; 5361 5362 case Type::STK_Floating: 5363 switch (DestTy->getScalarTypeKind()) { 5364 case Type::STK_Floating: 5365 return CK_FloatingCast; 5366 case Type::STK_Bool: 5367 return CK_FloatingToBoolean; 5368 case Type::STK_Integral: 5369 return CK_FloatingToIntegral; 5370 case Type::STK_FloatingComplex: 5371 Src = S.ImpCastExprToType(Src.take(), DestTy->getAs<ComplexType>()->getElementType(), 5372 CK_FloatingCast); 5373 return CK_FloatingRealToComplex; 5374 case Type::STK_IntegralComplex: 5375 Src = S.ImpCastExprToType(Src.take(), DestTy->getAs<ComplexType>()->getElementType(), 5376 CK_FloatingToIntegral); 5377 return CK_IntegralRealToComplex; 5378 case Type::STK_Pointer: 5379 llvm_unreachable("valid float->pointer cast?"); 5380 case Type::STK_MemberPointer: 5381 llvm_unreachable("member pointer type in C"); 5382 } 5383 break; 5384 5385 case Type::STK_FloatingComplex: 5386 switch (DestTy->getScalarTypeKind()) { 5387 case Type::STK_FloatingComplex: 5388 return CK_FloatingComplexCast; 5389 case Type::STK_IntegralComplex: 5390 return CK_FloatingComplexToIntegralComplex; 5391 case Type::STK_Floating: { 5392 QualType ET = SrcTy->getAs<ComplexType>()->getElementType(); 5393 if (S.Context.hasSameType(ET, DestTy)) 5394 return CK_FloatingComplexToReal; 5395 Src = S.ImpCastExprToType(Src.take(), ET, CK_FloatingComplexToReal); 5396 return CK_FloatingCast; 5397 } 5398 case Type::STK_Bool: 5399 return CK_FloatingComplexToBoolean; 5400 case Type::STK_Integral: 5401 Src = S.ImpCastExprToType(Src.take(), SrcTy->getAs<ComplexType>()->getElementType(), 5402 CK_FloatingComplexToReal); 5403 return CK_FloatingToIntegral; 5404 case Type::STK_Pointer: 5405 llvm_unreachable("valid complex float->pointer cast?"); 5406 case Type::STK_MemberPointer: 5407 llvm_unreachable("member pointer type in C"); 5408 } 5409 break; 5410 5411 case Type::STK_IntegralComplex: 5412 switch (DestTy->getScalarTypeKind()) { 5413 case Type::STK_FloatingComplex: 5414 return CK_IntegralComplexToFloatingComplex; 5415 case Type::STK_IntegralComplex: 5416 return CK_IntegralComplexCast; 5417 case Type::STK_Integral: { 5418 QualType ET = SrcTy->getAs<ComplexType>()->getElementType(); 5419 if (S.Context.hasSameType(ET, DestTy)) 5420 return CK_IntegralComplexToReal; 5421 Src = S.ImpCastExprToType(Src.take(), ET, CK_IntegralComplexToReal); 5422 return CK_IntegralCast; 5423 } 5424 case Type::STK_Bool: 5425 return CK_IntegralComplexToBoolean; 5426 case Type::STK_Floating: 5427 Src = S.ImpCastExprToType(Src.take(), SrcTy->getAs<ComplexType>()->getElementType(), 5428 CK_IntegralComplexToReal); 5429 return CK_IntegralToFloating; 5430 case Type::STK_Pointer: 5431 llvm_unreachable("valid complex int->pointer cast?"); 5432 case Type::STK_MemberPointer: 5433 llvm_unreachable("member pointer type in C"); 5434 } 5435 break; 5436 } 5437 5438 llvm_unreachable("Unhandled scalar cast"); 5439 return CK_BitCast; 5440} 5441 5442/// CheckCastTypes - Check type constraints for casting between types. 5443ExprResult Sema::CheckCastTypes(SourceRange TyR, QualType castType, 5444 Expr *castExpr, CastKind& Kind, ExprValueKind &VK, 5445 CXXCastPath &BasePath, bool FunctionalStyle) { 5446 if (castExpr->getType() == Context.UnknownAnyTy) 5447 return checkUnknownAnyCast(TyR, castType, castExpr, Kind, VK, BasePath); 5448 5449 if (getLangOptions().CPlusPlus) 5450 return CXXCheckCStyleCast(SourceRange(TyR.getBegin(), 5451 castExpr->getLocEnd()), 5452 castType, VK, castExpr, Kind, BasePath, 5453 FunctionalStyle); 5454 5455 assert(!castExpr->getType()->isPlaceholderType()); 5456 5457 // We only support r-value casts in C. 5458 VK = VK_RValue; 5459 5460 // C99 6.5.4p2: the cast type needs to be void or scalar and the expression 5461 // type needs to be scalar. 5462 if (castType->isVoidType()) { 5463 // We don't necessarily do lvalue-to-rvalue conversions on this. 5464 ExprResult castExprRes = IgnoredValueConversions(castExpr); 5465 if (castExprRes.isInvalid()) 5466 return ExprError(); 5467 castExpr = castExprRes.take(); 5468 5469 // Cast to void allows any expr type. 5470 Kind = CK_ToVoid; 5471 return Owned(castExpr); 5472 } 5473 5474 ExprResult castExprRes = DefaultFunctionArrayLvalueConversion(castExpr); 5475 if (castExprRes.isInvalid()) 5476 return ExprError(); 5477 castExpr = castExprRes.take(); 5478 5479 if (RequireCompleteType(TyR.getBegin(), castType, 5480 diag::err_typecheck_cast_to_incomplete)) 5481 return ExprError(); 5482 5483 if (!castType->isScalarType() && !castType->isVectorType()) { 5484 if (Context.hasSameUnqualifiedType(castType, castExpr->getType()) && 5485 (castType->isStructureType() || castType->isUnionType())) { 5486 // GCC struct/union extension: allow cast to self. 5487 // FIXME: Check that the cast destination type is complete. 5488 Diag(TyR.getBegin(), diag::ext_typecheck_cast_nonscalar) 5489 << castType << castExpr->getSourceRange(); 5490 Kind = CK_NoOp; 5491 return Owned(castExpr); 5492 } 5493 5494 if (castType->isUnionType()) { 5495 // GCC cast to union extension 5496 RecordDecl *RD = castType->getAs<RecordType>()->getDecl(); 5497 RecordDecl::field_iterator Field, FieldEnd; 5498 for (Field = RD->field_begin(), FieldEnd = RD->field_end(); 5499 Field != FieldEnd; ++Field) { 5500 if (Context.hasSameUnqualifiedType(Field->getType(), 5501 castExpr->getType()) && 5502 !Field->isUnnamedBitfield()) { 5503 Diag(TyR.getBegin(), diag::ext_typecheck_cast_to_union) 5504 << castExpr->getSourceRange(); 5505 break; 5506 } 5507 } 5508 if (Field == FieldEnd) { 5509 Diag(TyR.getBegin(), diag::err_typecheck_cast_to_union_no_type) 5510 << castExpr->getType() << castExpr->getSourceRange(); 5511 return ExprError(); 5512 } 5513 Kind = CK_ToUnion; 5514 return Owned(castExpr); 5515 } 5516 5517 // Reject any other conversions to non-scalar types. 5518 Diag(TyR.getBegin(), diag::err_typecheck_cond_expect_scalar) 5519 << castType << castExpr->getSourceRange(); 5520 return ExprError(); 5521 } 5522 5523 // The type we're casting to is known to be a scalar or vector. 5524 5525 // Require the operand to be a scalar or vector. 5526 if (!castExpr->getType()->isScalarType() && 5527 !castExpr->getType()->isVectorType()) { 5528 Diag(castExpr->getLocStart(), 5529 diag::err_typecheck_expect_scalar_operand) 5530 << castExpr->getType() << castExpr->getSourceRange(); 5531 return ExprError(); 5532 } 5533 5534 if (castType->isExtVectorType()) 5535 return CheckExtVectorCast(TyR, castType, castExpr, Kind); 5536 5537 if (castType->isVectorType()) { 5538 if (castType->getAs<VectorType>()->getVectorKind() == 5539 VectorType::AltiVecVector && 5540 (castExpr->getType()->isIntegerType() || 5541 castExpr->getType()->isFloatingType())) { 5542 Kind = CK_VectorSplat; 5543 return Owned(castExpr); 5544 } else if (CheckVectorCast(TyR, castType, castExpr->getType(), Kind)) { 5545 return ExprError(); 5546 } else 5547 return Owned(castExpr); 5548 } 5549 if (castExpr->getType()->isVectorType()) { 5550 if (CheckVectorCast(TyR, castExpr->getType(), castType, Kind)) 5551 return ExprError(); 5552 else 5553 return Owned(castExpr); 5554 } 5555 5556 // The source and target types are both scalars, i.e. 5557 // - arithmetic types (fundamental, enum, and complex) 5558 // - all kinds of pointers 5559 // Note that member pointers were filtered out with C++, above. 5560 5561 if (isa<ObjCSelectorExpr>(castExpr)) { 5562 Diag(castExpr->getLocStart(), diag::err_cast_selector_expr); 5563 return ExprError(); 5564 } 5565 5566 // If either type is a pointer, the other type has to be either an 5567 // integer or a pointer. 5568 if (!castType->isArithmeticType()) { 5569 QualType castExprType = castExpr->getType(); 5570 if (!castExprType->isIntegralType(Context) && 5571 castExprType->isArithmeticType()) { 5572 Diag(castExpr->getLocStart(), 5573 diag::err_cast_pointer_from_non_pointer_int) 5574 << castExprType << castExpr->getSourceRange(); 5575 return ExprError(); 5576 } 5577 } else if (!castExpr->getType()->isArithmeticType()) { 5578 if (!castType->isIntegralType(Context) && castType->isArithmeticType()) { 5579 Diag(castExpr->getLocStart(), diag::err_cast_pointer_to_non_pointer_int) 5580 << castType << castExpr->getSourceRange(); 5581 return ExprError(); 5582 } 5583 } 5584 5585 castExprRes = Owned(castExpr); 5586 Kind = PrepareScalarCast(*this, castExprRes, castType); 5587 if (castExprRes.isInvalid()) 5588 return ExprError(); 5589 castExpr = castExprRes.take(); 5590 5591 if (Kind == CK_BitCast) 5592 CheckCastAlign(castExpr, castType, TyR); 5593 5594 return Owned(castExpr); 5595} 5596 5597bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, 5598 CastKind &Kind) { 5599 assert(VectorTy->isVectorType() && "Not a vector type!"); 5600 5601 if (Ty->isVectorType() || Ty->isIntegerType()) { 5602 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty)) 5603 return Diag(R.getBegin(), 5604 Ty->isVectorType() ? 5605 diag::err_invalid_conversion_between_vectors : 5606 diag::err_invalid_conversion_between_vector_and_integer) 5607 << VectorTy << Ty << R; 5608 } else 5609 return Diag(R.getBegin(), 5610 diag::err_invalid_conversion_between_vector_and_scalar) 5611 << VectorTy << Ty << R; 5612 5613 Kind = CK_BitCast; 5614 return false; 5615} 5616 5617ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy, 5618 Expr *CastExpr, CastKind &Kind) { 5619 assert(DestTy->isExtVectorType() && "Not an extended vector type!"); 5620 5621 QualType SrcTy = CastExpr->getType(); 5622 5623 // If SrcTy is a VectorType, the total size must match to explicitly cast to 5624 // an ExtVectorType. 5625 if (SrcTy->isVectorType()) { 5626 if (Context.getTypeSize(DestTy) != Context.getTypeSize(SrcTy)) { 5627 Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors) 5628 << DestTy << SrcTy << R; 5629 return ExprError(); 5630 } 5631 Kind = CK_BitCast; 5632 return Owned(CastExpr); 5633 } 5634 5635 // All non-pointer scalars can be cast to ExtVector type. The appropriate 5636 // conversion will take place first from scalar to elt type, and then 5637 // splat from elt type to vector. 5638 if (SrcTy->isPointerType()) 5639 return Diag(R.getBegin(), 5640 diag::err_invalid_conversion_between_vector_and_scalar) 5641 << DestTy << SrcTy << R; 5642 5643 QualType DestElemTy = DestTy->getAs<ExtVectorType>()->getElementType(); 5644 ExprResult CastExprRes = Owned(CastExpr); 5645 CastKind CK = PrepareScalarCast(*this, CastExprRes, DestElemTy); 5646 if (CastExprRes.isInvalid()) 5647 return ExprError(); 5648 CastExpr = ImpCastExprToType(CastExprRes.take(), DestElemTy, CK).take(); 5649 5650 Kind = CK_VectorSplat; 5651 return Owned(CastExpr); 5652} 5653 5654ExprResult 5655Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, ParsedType Ty, 5656 SourceLocation RParenLoc, Expr *castExpr) { 5657 assert((Ty != 0) && (castExpr != 0) && 5658 "ActOnCastExpr(): missing type or expr"); 5659 5660 TypeSourceInfo *castTInfo; 5661 QualType castType = GetTypeFromParser(Ty, &castTInfo); 5662 if (!castTInfo) 5663 castTInfo = Context.getTrivialTypeSourceInfo(castType); 5664 5665 // If the Expr being casted is a ParenListExpr, handle it specially. 5666 if (isa<ParenListExpr>(castExpr)) 5667 return ActOnCastOfParenListExpr(S, LParenLoc, RParenLoc, castExpr, 5668 castTInfo); 5669 5670 return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, castExpr); 5671} 5672 5673ExprResult 5674Sema::BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, 5675 SourceLocation RParenLoc, Expr *castExpr) { 5676 CastKind Kind = CK_Invalid; 5677 ExprValueKind VK = VK_RValue; 5678 CXXCastPath BasePath; 5679 ExprResult CastResult = 5680 CheckCastTypes(SourceRange(LParenLoc, RParenLoc), Ty->getType(), castExpr, 5681 Kind, VK, BasePath); 5682 if (CastResult.isInvalid()) 5683 return ExprError(); 5684 castExpr = CastResult.take(); 5685 5686 return Owned(CStyleCastExpr::Create(Context, 5687 Ty->getType().getNonLValueExprType(Context), 5688 VK, Kind, castExpr, &BasePath, Ty, 5689 LParenLoc, RParenLoc)); 5690} 5691 5692/// This is not an AltiVec-style cast, so turn the ParenListExpr into a sequence 5693/// of comma binary operators. 5694ExprResult 5695Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *expr) { 5696 ParenListExpr *E = dyn_cast<ParenListExpr>(expr); 5697 if (!E) 5698 return Owned(expr); 5699 5700 ExprResult Result(E->getExpr(0)); 5701 5702 for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i) 5703 Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(), 5704 E->getExpr(i)); 5705 5706 if (Result.isInvalid()) return ExprError(); 5707 5708 return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get()); 5709} 5710 5711ExprResult 5712Sema::ActOnCastOfParenListExpr(Scope *S, SourceLocation LParenLoc, 5713 SourceLocation RParenLoc, Expr *Op, 5714 TypeSourceInfo *TInfo) { 5715 ParenListExpr *PE = cast<ParenListExpr>(Op); 5716 QualType Ty = TInfo->getType(); 5717 bool isVectorLiteral = false; 5718 5719 // Check for an altivec or OpenCL literal, 5720 // i.e. all the elements are integer constants. 5721 if (getLangOptions().AltiVec && Ty->isVectorType()) { 5722 if (PE->getNumExprs() == 0) { 5723 Diag(PE->getExprLoc(), diag::err_altivec_empty_initializer); 5724 return ExprError(); 5725 } 5726 if (PE->getNumExprs() == 1) { 5727 if (!PE->getExpr(0)->getType()->isVectorType()) 5728 isVectorLiteral = true; 5729 } 5730 else 5731 isVectorLiteral = true; 5732 } 5733 5734 // If this is a vector initializer, '(' type ')' '(' init, ..., init ')' 5735 // then handle it as such. 5736 if (isVectorLiteral) { 5737 llvm::SmallVector<Expr *, 8> initExprs; 5738 // '(...)' form of vector initialization in AltiVec: the number of 5739 // initializers must be one or must match the size of the vector. 5740 // If a single value is specified in the initializer then it will be 5741 // replicated to all the components of the vector 5742 if (Ty->getAs<VectorType>()->getVectorKind() == 5743 VectorType::AltiVecVector) { 5744 unsigned numElems = Ty->getAs<VectorType>()->getNumElements(); 5745 // The number of initializers must be one or must match the size of the 5746 // vector. If a single value is specified in the initializer then it will 5747 // be replicated to all the components of the vector 5748 if (PE->getNumExprs() == 1) { 5749 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 5750 ExprResult Literal = Owned(PE->getExpr(0)); 5751 Literal = ImpCastExprToType(Literal.take(), ElemTy, 5752 PrepareScalarCast(*this, Literal, ElemTy)); 5753 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take()); 5754 } 5755 else if (PE->getNumExprs() < numElems) { 5756 Diag(PE->getExprLoc(), 5757 diag::err_incorrect_number_of_vector_initializers); 5758 return ExprError(); 5759 } 5760 else 5761 for (unsigned i = 0, e = PE->getNumExprs(); i != e; ++i) 5762 initExprs.push_back(PE->getExpr(i)); 5763 } 5764 else 5765 for (unsigned i = 0, e = PE->getNumExprs(); i != e; ++i) 5766 initExprs.push_back(PE->getExpr(i)); 5767 5768 // FIXME: This means that pretty-printing the final AST will produce curly 5769 // braces instead of the original commas. 5770 InitListExpr *E = new (Context) InitListExpr(Context, LParenLoc, 5771 &initExprs[0], 5772 initExprs.size(), RParenLoc); 5773 E->setType(Ty); 5774 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, E); 5775 } else { 5776 // This is not an AltiVec-style cast, so turn the ParenListExpr into a 5777 // sequence of BinOp comma operators. 5778 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Op); 5779 if (Result.isInvalid()) return ExprError(); 5780 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Result.take()); 5781 } 5782} 5783 5784ExprResult Sema::ActOnParenOrParenListExpr(SourceLocation L, 5785 SourceLocation R, 5786 MultiExprArg Val, 5787 ParsedType TypeOfCast) { 5788 unsigned nexprs = Val.size(); 5789 Expr **exprs = reinterpret_cast<Expr**>(Val.release()); 5790 assert((exprs != 0) && "ActOnParenOrParenListExpr() missing expr list"); 5791 Expr *expr; 5792 if (nexprs == 1 && TypeOfCast && !TypeIsVectorType(TypeOfCast)) 5793 expr = new (Context) ParenExpr(L, R, exprs[0]); 5794 else 5795 expr = new (Context) ParenListExpr(Context, L, exprs, nexprs, R); 5796 return Owned(expr); 5797} 5798 5799/// \brief Emit a specialized diagnostic when one expression is a null pointer 5800/// constant and the other is not a pointer. 5801bool Sema::DiagnoseConditionalForNull(Expr *LHS, Expr *RHS, 5802 SourceLocation QuestionLoc) { 5803 Expr *NullExpr = LHS; 5804 Expr *NonPointerExpr = RHS; 5805 Expr::NullPointerConstantKind NullKind = 5806 NullExpr->isNullPointerConstant(Context, 5807 Expr::NPC_ValueDependentIsNotNull); 5808 5809 if (NullKind == Expr::NPCK_NotNull) { 5810 NullExpr = RHS; 5811 NonPointerExpr = LHS; 5812 NullKind = 5813 NullExpr->isNullPointerConstant(Context, 5814 Expr::NPC_ValueDependentIsNotNull); 5815 } 5816 5817 if (NullKind == Expr::NPCK_NotNull) 5818 return false; 5819 5820 if (NullKind == Expr::NPCK_ZeroInteger) { 5821 // In this case, check to make sure that we got here from a "NULL" 5822 // string in the source code. 5823 NullExpr = NullExpr->IgnoreParenImpCasts(); 5824 SourceLocation loc = NullExpr->getExprLoc(); 5825 if (!findMacroSpelling(loc, "NULL")) 5826 return false; 5827 } 5828 5829 int DiagType = (NullKind == Expr::NPCK_CXX0X_nullptr); 5830 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null) 5831 << NonPointerExpr->getType() << DiagType 5832 << NonPointerExpr->getSourceRange(); 5833 return true; 5834} 5835 5836/// Note that lhs is not null here, even if this is the gnu "x ?: y" extension. 5837/// In that case, lhs = cond. 5838/// C99 6.5.15 5839QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, 5840 ExprValueKind &VK, ExprObjectKind &OK, 5841 SourceLocation QuestionLoc) { 5842 5843 ExprResult lhsResult = CheckPlaceholderExpr(LHS.get()); 5844 if (!lhsResult.isUsable()) return QualType(); 5845 LHS = move(lhsResult); 5846 5847 ExprResult rhsResult = CheckPlaceholderExpr(RHS.get()); 5848 if (!rhsResult.isUsable()) return QualType(); 5849 RHS = move(rhsResult); 5850 5851 // C++ is sufficiently different to merit its own checker. 5852 if (getLangOptions().CPlusPlus) 5853 return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc); 5854 5855 VK = VK_RValue; 5856 OK = OK_Ordinary; 5857 5858 Cond = UsualUnaryConversions(Cond.take()); 5859 if (Cond.isInvalid()) 5860 return QualType(); 5861 LHS = UsualUnaryConversions(LHS.take()); 5862 if (LHS.isInvalid()) 5863 return QualType(); 5864 RHS = UsualUnaryConversions(RHS.take()); 5865 if (RHS.isInvalid()) 5866 return QualType(); 5867 5868 QualType CondTy = Cond.get()->getType(); 5869 QualType LHSTy = LHS.get()->getType(); 5870 QualType RHSTy = RHS.get()->getType(); 5871 5872 // first, check the condition. 5873 if (!CondTy->isScalarType()) { // C99 6.5.15p2 5874 // OpenCL: Sec 6.3.i says the condition is allowed to be a vector or scalar. 5875 // Throw an error if its not either. 5876 if (getLangOptions().OpenCL) { 5877 if (!CondTy->isVectorType()) { 5878 Diag(Cond.get()->getLocStart(), 5879 diag::err_typecheck_cond_expect_scalar_or_vector) 5880 << CondTy; 5881 return QualType(); 5882 } 5883 } 5884 else { 5885 Diag(Cond.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 5886 << CondTy; 5887 return QualType(); 5888 } 5889 } 5890 5891 // Now check the two expressions. 5892 if (LHSTy->isVectorType() || RHSTy->isVectorType()) 5893 return CheckVectorOperands(QuestionLoc, LHS, RHS); 5894 5895 // OpenCL: If the condition is a vector, and both operands are scalar, 5896 // attempt to implicity convert them to the vector type to act like the 5897 // built in select. 5898 if (getLangOptions().OpenCL && CondTy->isVectorType()) { 5899 // Both operands should be of scalar type. 5900 if (!LHSTy->isScalarType()) { 5901 Diag(LHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 5902 << CondTy; 5903 return QualType(); 5904 } 5905 if (!RHSTy->isScalarType()) { 5906 Diag(RHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 5907 << CondTy; 5908 return QualType(); 5909 } 5910 // Implicity convert these scalars to the type of the condition. 5911 LHS = ImpCastExprToType(LHS.take(), CondTy, CK_IntegralCast); 5912 RHS = ImpCastExprToType(RHS.take(), CondTy, CK_IntegralCast); 5913 } 5914 5915 // If both operands have arithmetic type, do the usual arithmetic conversions 5916 // to find a common type: C99 6.5.15p3,5. 5917 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) { 5918 UsualArithmeticConversions(LHS, RHS); 5919 if (LHS.isInvalid() || RHS.isInvalid()) 5920 return QualType(); 5921 return LHS.get()->getType(); 5922 } 5923 5924 // If both operands are the same structure or union type, the result is that 5925 // type. 5926 if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3 5927 if (const RecordType *RHSRT = RHSTy->getAs<RecordType>()) 5928 if (LHSRT->getDecl() == RHSRT->getDecl()) 5929 // "If both the operands have structure or union type, the result has 5930 // that type." This implies that CV qualifiers are dropped. 5931 return LHSTy.getUnqualifiedType(); 5932 // FIXME: Type of conditional expression must be complete in C mode. 5933 } 5934 5935 // C99 6.5.15p5: "If both operands have void type, the result has void type." 5936 // The following || allows only one side to be void (a GCC-ism). 5937 if (LHSTy->isVoidType() || RHSTy->isVoidType()) { 5938 if (!LHSTy->isVoidType()) 5939 Diag(RHS.get()->getLocStart(), diag::ext_typecheck_cond_one_void) 5940 << RHS.get()->getSourceRange(); 5941 if (!RHSTy->isVoidType()) 5942 Diag(LHS.get()->getLocStart(), diag::ext_typecheck_cond_one_void) 5943 << LHS.get()->getSourceRange(); 5944 LHS = ImpCastExprToType(LHS.take(), Context.VoidTy, CK_ToVoid); 5945 RHS = ImpCastExprToType(RHS.take(), Context.VoidTy, CK_ToVoid); 5946 return Context.VoidTy; 5947 } 5948 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has 5949 // the type of the other operand." 5950 if ((LHSTy->isAnyPointerType() || LHSTy->isBlockPointerType()) && 5951 RHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 5952 // promote the null to a pointer. 5953 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_NullToPointer); 5954 return LHSTy; 5955 } 5956 if ((RHSTy->isAnyPointerType() || RHSTy->isBlockPointerType()) && 5957 LHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 5958 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_NullToPointer); 5959 return RHSTy; 5960 } 5961 5962 // All objective-c pointer type analysis is done here. 5963 QualType compositeType = FindCompositeObjCPointerType(LHS, RHS, 5964 QuestionLoc); 5965 if (LHS.isInvalid() || RHS.isInvalid()) 5966 return QualType(); 5967 if (!compositeType.isNull()) 5968 return compositeType; 5969 5970 5971 // Handle block pointer types. 5972 if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) { 5973 if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) { 5974 if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) { 5975 QualType destType = Context.getPointerType(Context.VoidTy); 5976 LHS = ImpCastExprToType(LHS.take(), destType, CK_BitCast); 5977 RHS = ImpCastExprToType(RHS.take(), destType, CK_BitCast); 5978 return destType; 5979 } 5980 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 5981 << LHSTy << RHSTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5982 return QualType(); 5983 } 5984 // We have 2 block pointer types. 5985 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) { 5986 // Two identical block pointer types are always compatible. 5987 return LHSTy; 5988 } 5989 // The block pointer types aren't identical, continue checking. 5990 QualType lhptee = LHSTy->getAs<BlockPointerType>()->getPointeeType(); 5991 QualType rhptee = RHSTy->getAs<BlockPointerType>()->getPointeeType(); 5992 5993 if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(), 5994 rhptee.getUnqualifiedType())) { 5995 Diag(QuestionLoc, diag::warn_typecheck_cond_incompatible_pointers) 5996 << LHSTy << RHSTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5997 // In this situation, we assume void* type. No especially good 5998 // reason, but this is what gcc does, and we do have to pick 5999 // to get a consistent AST. 6000 QualType incompatTy = Context.getPointerType(Context.VoidTy); 6001 LHS = ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); 6002 RHS = ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); 6003 return incompatTy; 6004 } 6005 // The block pointer types are compatible. 6006 LHS = ImpCastExprToType(LHS.take(), LHSTy, CK_BitCast); 6007 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 6008 return LHSTy; 6009 } 6010 6011 // Check constraints for C object pointers types (C99 6.5.15p3,6). 6012 if (LHSTy->isPointerType() && RHSTy->isPointerType()) { 6013 // get the "pointed to" types 6014 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 6015 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 6016 6017 // ignore qualifiers on void (C99 6.5.15p3, clause 6) 6018 if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) { 6019 // Figure out necessary qualifiers (C99 6.5.15p6) 6020 QualType destPointee 6021 = Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 6022 QualType destType = Context.getPointerType(destPointee); 6023 // Add qualifiers if necessary. 6024 LHS = ImpCastExprToType(LHS.take(), destType, CK_NoOp); 6025 // Promote to void*. 6026 RHS = ImpCastExprToType(RHS.take(), destType, CK_BitCast); 6027 return destType; 6028 } 6029 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) { 6030 QualType destPointee 6031 = Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 6032 QualType destType = Context.getPointerType(destPointee); 6033 // Add qualifiers if necessary. 6034 RHS = ImpCastExprToType(RHS.take(), destType, CK_NoOp); 6035 // Promote to void*. 6036 LHS = ImpCastExprToType(LHS.take(), destType, CK_BitCast); 6037 return destType; 6038 } 6039 6040 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) { 6041 // Two identical pointer types are always compatible. 6042 return LHSTy; 6043 } 6044 if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(), 6045 rhptee.getUnqualifiedType())) { 6046 Diag(QuestionLoc, diag::warn_typecheck_cond_incompatible_pointers) 6047 << LHSTy << RHSTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6048 // In this situation, we assume void* type. No especially good 6049 // reason, but this is what gcc does, and we do have to pick 6050 // to get a consistent AST. 6051 QualType incompatTy = Context.getPointerType(Context.VoidTy); 6052 LHS = ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); 6053 RHS = ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); 6054 return incompatTy; 6055 } 6056 // The pointer types are compatible. 6057 // C99 6.5.15p6: If both operands are pointers to compatible types *or* to 6058 // differently qualified versions of compatible types, the result type is 6059 // a pointer to an appropriately qualified version of the *composite* 6060 // type. 6061 // FIXME: Need to calculate the composite type. 6062 // FIXME: Need to add qualifiers 6063 LHS = ImpCastExprToType(LHS.take(), LHSTy, CK_BitCast); 6064 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 6065 return LHSTy; 6066 } 6067 6068 // GCC compatibility: soften pointer/integer mismatch. Note that 6069 // null pointers have been filtered out by this point. 6070 if (RHSTy->isPointerType() && LHSTy->isIntegerType()) { 6071 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch) 6072 << LHSTy << RHSTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6073 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_IntegralToPointer); 6074 return RHSTy; 6075 } 6076 if (LHSTy->isPointerType() && RHSTy->isIntegerType()) { 6077 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch) 6078 << LHSTy << RHSTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6079 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_IntegralToPointer); 6080 return LHSTy; 6081 } 6082 6083 // Emit a better diagnostic if one of the expressions is a null pointer 6084 // constant and the other is not a pointer type. In this case, the user most 6085 // likely forgot to take the address of the other expression. 6086 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc)) 6087 return QualType(); 6088 6089 // Otherwise, the operands are not compatible. 6090 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 6091 << LHSTy << RHSTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6092 return QualType(); 6093} 6094 6095/// FindCompositeObjCPointerType - Helper method to find composite type of 6096/// two objective-c pointer types of the two input expressions. 6097QualType Sema::FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, 6098 SourceLocation QuestionLoc) { 6099 QualType LHSTy = LHS.get()->getType(); 6100 QualType RHSTy = RHS.get()->getType(); 6101 6102 // Handle things like Class and struct objc_class*. Here we case the result 6103 // to the pseudo-builtin, because that will be implicitly cast back to the 6104 // redefinition type if an attempt is made to access its fields. 6105 if (LHSTy->isObjCClassType() && 6106 (Context.hasSameType(RHSTy, Context.ObjCClassRedefinitionType))) { 6107 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 6108 return LHSTy; 6109 } 6110 if (RHSTy->isObjCClassType() && 6111 (Context.hasSameType(LHSTy, Context.ObjCClassRedefinitionType))) { 6112 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_BitCast); 6113 return RHSTy; 6114 } 6115 // And the same for struct objc_object* / id 6116 if (LHSTy->isObjCIdType() && 6117 (Context.hasSameType(RHSTy, Context.ObjCIdRedefinitionType))) { 6118 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 6119 return LHSTy; 6120 } 6121 if (RHSTy->isObjCIdType() && 6122 (Context.hasSameType(LHSTy, Context.ObjCIdRedefinitionType))) { 6123 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_BitCast); 6124 return RHSTy; 6125 } 6126 // And the same for struct objc_selector* / SEL 6127 if (Context.isObjCSelType(LHSTy) && 6128 (Context.hasSameType(RHSTy, Context.ObjCSelRedefinitionType))) { 6129 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 6130 return LHSTy; 6131 } 6132 if (Context.isObjCSelType(RHSTy) && 6133 (Context.hasSameType(LHSTy, Context.ObjCSelRedefinitionType))) { 6134 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_BitCast); 6135 return RHSTy; 6136 } 6137 // Check constraints for Objective-C object pointers types. 6138 if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) { 6139 6140 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) { 6141 // Two identical object pointer types are always compatible. 6142 return LHSTy; 6143 } 6144 const ObjCObjectPointerType *LHSOPT = LHSTy->getAs<ObjCObjectPointerType>(); 6145 const ObjCObjectPointerType *RHSOPT = RHSTy->getAs<ObjCObjectPointerType>(); 6146 QualType compositeType = LHSTy; 6147 6148 // If both operands are interfaces and either operand can be 6149 // assigned to the other, use that type as the composite 6150 // type. This allows 6151 // xxx ? (A*) a : (B*) b 6152 // where B is a subclass of A. 6153 // 6154 // Additionally, as for assignment, if either type is 'id' 6155 // allow silent coercion. Finally, if the types are 6156 // incompatible then make sure to use 'id' as the composite 6157 // type so the result is acceptable for sending messages to. 6158 6159 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'. 6160 // It could return the composite type. 6161 if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) { 6162 compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy; 6163 } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) { 6164 compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy; 6165 } else if ((LHSTy->isObjCQualifiedIdType() || 6166 RHSTy->isObjCQualifiedIdType()) && 6167 Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) { 6168 // Need to handle "id<xx>" explicitly. 6169 // GCC allows qualified id and any Objective-C type to devolve to 6170 // id. Currently localizing to here until clear this should be 6171 // part of ObjCQualifiedIdTypesAreCompatible. 6172 compositeType = Context.getObjCIdType(); 6173 } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) { 6174 compositeType = Context.getObjCIdType(); 6175 } else if (!(compositeType = 6176 Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull()) 6177 ; 6178 else { 6179 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands) 6180 << LHSTy << RHSTy 6181 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6182 QualType incompatTy = Context.getObjCIdType(); 6183 LHS = ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); 6184 RHS = ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); 6185 return incompatTy; 6186 } 6187 // The object pointer types are compatible. 6188 LHS = ImpCastExprToType(LHS.take(), compositeType, CK_BitCast); 6189 RHS = ImpCastExprToType(RHS.take(), compositeType, CK_BitCast); 6190 return compositeType; 6191 } 6192 // Check Objective-C object pointer types and 'void *' 6193 if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) { 6194 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 6195 QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 6196 QualType destPointee 6197 = Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 6198 QualType destType = Context.getPointerType(destPointee); 6199 // Add qualifiers if necessary. 6200 LHS = ImpCastExprToType(LHS.take(), destType, CK_NoOp); 6201 // Promote to void*. 6202 RHS = ImpCastExprToType(RHS.take(), destType, CK_BitCast); 6203 return destType; 6204 } 6205 if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) { 6206 QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 6207 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 6208 QualType destPointee 6209 = Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 6210 QualType destType = Context.getPointerType(destPointee); 6211 // Add qualifiers if necessary. 6212 RHS = ImpCastExprToType(RHS.take(), destType, CK_NoOp); 6213 // Promote to void*. 6214 LHS = ImpCastExprToType(LHS.take(), destType, CK_BitCast); 6215 return destType; 6216 } 6217 return QualType(); 6218} 6219 6220/// SuggestParentheses - Emit a diagnostic together with a fixit hint that wraps 6221/// ParenRange in parentheses. 6222static void SuggestParentheses(Sema &Self, SourceLocation Loc, 6223 const PartialDiagnostic &PD, 6224 const PartialDiagnostic &FirstNote, 6225 SourceRange FirstParenRange, 6226 const PartialDiagnostic &SecondNote, 6227 SourceRange SecondParenRange) { 6228 Self.Diag(Loc, PD); 6229 6230 if (!FirstNote.getDiagID()) 6231 return; 6232 6233 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(FirstParenRange.getEnd()); 6234 if (!FirstParenRange.getEnd().isFileID() || EndLoc.isInvalid()) { 6235 // We can't display the parentheses, so just return. 6236 return; 6237 } 6238 6239 Self.Diag(Loc, FirstNote) 6240 << FixItHint::CreateInsertion(FirstParenRange.getBegin(), "(") 6241 << FixItHint::CreateInsertion(EndLoc, ")"); 6242 6243 if (!SecondNote.getDiagID()) 6244 return; 6245 6246 EndLoc = Self.PP.getLocForEndOfToken(SecondParenRange.getEnd()); 6247 if (!SecondParenRange.getEnd().isFileID() || EndLoc.isInvalid()) { 6248 // We can't display the parentheses, so just dig the 6249 // warning/error and return. 6250 Self.Diag(Loc, SecondNote); 6251 return; 6252 } 6253 6254 Self.Diag(Loc, SecondNote) 6255 << FixItHint::CreateInsertion(SecondParenRange.getBegin(), "(") 6256 << FixItHint::CreateInsertion(EndLoc, ")"); 6257} 6258 6259static bool IsArithmeticOp(BinaryOperatorKind Opc) { 6260 return Opc >= BO_Mul && Opc <= BO_Shr; 6261} 6262 6263/// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary 6264/// expression, either using a built-in or overloaded operator, 6265/// and sets *OpCode to the opcode and *RHS to the right-hand side expression. 6266static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode, 6267 Expr **RHS) { 6268 E = E->IgnoreParenImpCasts(); 6269 E = E->IgnoreConversionOperator(); 6270 E = E->IgnoreParenImpCasts(); 6271 6272 // Built-in binary operator. 6273 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) { 6274 if (IsArithmeticOp(OP->getOpcode())) { 6275 *Opcode = OP->getOpcode(); 6276 *RHS = OP->getRHS(); 6277 return true; 6278 } 6279 } 6280 6281 // Overloaded operator. 6282 if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(E)) { 6283 if (Call->getNumArgs() != 2) 6284 return false; 6285 6286 // Make sure this is really a binary operator that is safe to pass into 6287 // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op. 6288 OverloadedOperatorKind OO = Call->getOperator(); 6289 if (OO < OO_Plus || OO > OO_Arrow) 6290 return false; 6291 6292 BinaryOperatorKind OpKind = BinaryOperator::getOverloadedOpcode(OO); 6293 if (IsArithmeticOp(OpKind)) { 6294 *Opcode = OpKind; 6295 *RHS = Call->getArg(1); 6296 return true; 6297 } 6298 } 6299 6300 return false; 6301} 6302 6303static bool IsLogicOp(BinaryOperatorKind Opc) { 6304 return (Opc >= BO_LT && Opc <= BO_NE) || (Opc >= BO_LAnd && Opc <= BO_LOr); 6305} 6306 6307/// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type 6308/// or is a logical expression such as (x==y) which has int type, but is 6309/// commonly interpreted as boolean. 6310static bool ExprLooksBoolean(Expr *E) { 6311 E = E->IgnoreParenImpCasts(); 6312 6313 if (E->getType()->isBooleanType()) 6314 return true; 6315 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) 6316 return IsLogicOp(OP->getOpcode()); 6317 if (UnaryOperator *OP = dyn_cast<UnaryOperator>(E)) 6318 return OP->getOpcode() == UO_LNot; 6319 6320 return false; 6321} 6322 6323/// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator 6324/// and binary operator are mixed in a way that suggests the programmer assumed 6325/// the conditional operator has higher precedence, for example: 6326/// "int x = a + someBinaryCondition ? 1 : 2". 6327static void DiagnoseConditionalPrecedence(Sema &Self, 6328 SourceLocation OpLoc, 6329 Expr *cond, 6330 Expr *lhs, 6331 Expr *rhs) { 6332 BinaryOperatorKind CondOpcode; 6333 Expr *CondRHS; 6334 6335 if (!IsArithmeticBinaryExpr(cond, &CondOpcode, &CondRHS)) 6336 return; 6337 if (!ExprLooksBoolean(CondRHS)) 6338 return; 6339 6340 // The condition is an arithmetic binary expression, with a right- 6341 // hand side that looks boolean, so warn. 6342 6343 PartialDiagnostic Warn = Self.PDiag(diag::warn_precedence_conditional) 6344 << cond->getSourceRange() 6345 << BinaryOperator::getOpcodeStr(CondOpcode); 6346 6347 PartialDiagnostic FirstNote = 6348 Self.PDiag(diag::note_precedence_conditional_silence) 6349 << BinaryOperator::getOpcodeStr(CondOpcode); 6350 6351 SourceRange FirstParenRange(cond->getLocStart(), 6352 cond->getLocEnd()); 6353 6354 PartialDiagnostic SecondNote = 6355 Self.PDiag(diag::note_precedence_conditional_first); 6356 6357 SourceRange SecondParenRange(CondRHS->getLocStart(), 6358 rhs->getLocEnd()); 6359 6360 SuggestParentheses(Self, OpLoc, Warn, FirstNote, FirstParenRange, 6361 SecondNote, SecondParenRange); 6362} 6363 6364/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null 6365/// in the case of a the GNU conditional expr extension. 6366ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc, 6367 SourceLocation ColonLoc, 6368 Expr *CondExpr, Expr *LHSExpr, 6369 Expr *RHSExpr) { 6370 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS 6371 // was the condition. 6372 OpaqueValueExpr *opaqueValue = 0; 6373 Expr *commonExpr = 0; 6374 if (LHSExpr == 0) { 6375 commonExpr = CondExpr; 6376 6377 // We usually want to apply unary conversions *before* saving, except 6378 // in the special case of a C++ l-value conditional. 6379 if (!(getLangOptions().CPlusPlus 6380 && !commonExpr->isTypeDependent() 6381 && commonExpr->getValueKind() == RHSExpr->getValueKind() 6382 && commonExpr->isGLValue() 6383 && commonExpr->isOrdinaryOrBitFieldObject() 6384 && RHSExpr->isOrdinaryOrBitFieldObject() 6385 && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) { 6386 ExprResult commonRes = UsualUnaryConversions(commonExpr); 6387 if (commonRes.isInvalid()) 6388 return ExprError(); 6389 commonExpr = commonRes.take(); 6390 } 6391 6392 opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(), 6393 commonExpr->getType(), 6394 commonExpr->getValueKind(), 6395 commonExpr->getObjectKind()); 6396 LHSExpr = CondExpr = opaqueValue; 6397 } 6398 6399 ExprValueKind VK = VK_RValue; 6400 ExprObjectKind OK = OK_Ordinary; 6401 ExprResult Cond = Owned(CondExpr), LHS = Owned(LHSExpr), RHS = Owned(RHSExpr); 6402 QualType result = CheckConditionalOperands(Cond, LHS, RHS, 6403 VK, OK, QuestionLoc); 6404 if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() || 6405 RHS.isInvalid()) 6406 return ExprError(); 6407 6408 DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(), 6409 RHS.get()); 6410 6411 if (!commonExpr) 6412 return Owned(new (Context) ConditionalOperator(Cond.take(), QuestionLoc, 6413 LHS.take(), ColonLoc, 6414 RHS.take(), result, VK, OK)); 6415 6416 return Owned(new (Context) 6417 BinaryConditionalOperator(commonExpr, opaqueValue, Cond.take(), LHS.take(), 6418 RHS.take(), QuestionLoc, ColonLoc, result, VK, OK)); 6419} 6420 6421// checkPointerTypesForAssignment - This is a very tricky routine (despite 6422// being closely modeled after the C99 spec:-). The odd characteristic of this 6423// routine is it effectively iqnores the qualifiers on the top level pointee. 6424// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3]. 6425// FIXME: add a couple examples in this comment. 6426static Sema::AssignConvertType 6427checkPointerTypesForAssignment(Sema &S, QualType lhsType, QualType rhsType) { 6428 assert(lhsType.isCanonical() && "LHS not canonicalized!"); 6429 assert(rhsType.isCanonical() && "RHS not canonicalized!"); 6430 6431 // get the "pointed to" type (ignoring qualifiers at the top level) 6432 const Type *lhptee, *rhptee; 6433 Qualifiers lhq, rhq; 6434 llvm::tie(lhptee, lhq) = cast<PointerType>(lhsType)->getPointeeType().split(); 6435 llvm::tie(rhptee, rhq) = cast<PointerType>(rhsType)->getPointeeType().split(); 6436 6437 Sema::AssignConvertType ConvTy = Sema::Compatible; 6438 6439 // C99 6.5.16.1p1: This following citation is common to constraints 6440 // 3 & 4 (below). ...and the type *pointed to* by the left has all the 6441 // qualifiers of the type *pointed to* by the right; 6442 Qualifiers lq; 6443 6444 if (!lhq.compatiblyIncludes(rhq)) { 6445 // Treat address-space mismatches as fatal. TODO: address subspaces 6446 if (lhq.getAddressSpace() != rhq.getAddressSpace()) 6447 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 6448 6449 // It's okay to add or remove GC qualifiers when converting to 6450 // and from void*. 6451 else if (lhq.withoutObjCGCAttr().compatiblyIncludes(rhq.withoutObjCGCAttr()) 6452 && (lhptee->isVoidType() || rhptee->isVoidType())) 6453 ; // keep old 6454 6455 // For GCC compatibility, other qualifier mismatches are treated 6456 // as still compatible in C. 6457 else ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 6458 } 6459 6460 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or 6461 // incomplete type and the other is a pointer to a qualified or unqualified 6462 // version of void... 6463 if (lhptee->isVoidType()) { 6464 if (rhptee->isIncompleteOrObjectType()) 6465 return ConvTy; 6466 6467 // As an extension, we allow cast to/from void* to function pointer. 6468 assert(rhptee->isFunctionType()); 6469 return Sema::FunctionVoidPointer; 6470 } 6471 6472 if (rhptee->isVoidType()) { 6473 if (lhptee->isIncompleteOrObjectType()) 6474 return ConvTy; 6475 6476 // As an extension, we allow cast to/from void* to function pointer. 6477 assert(lhptee->isFunctionType()); 6478 return Sema::FunctionVoidPointer; 6479 } 6480 6481 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or 6482 // unqualified versions of compatible types, ... 6483 QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0); 6484 if (!S.Context.typesAreCompatible(ltrans, rtrans)) { 6485 // Check if the pointee types are compatible ignoring the sign. 6486 // We explicitly check for char so that we catch "char" vs 6487 // "unsigned char" on systems where "char" is unsigned. 6488 if (lhptee->isCharType()) 6489 ltrans = S.Context.UnsignedCharTy; 6490 else if (lhptee->hasSignedIntegerRepresentation()) 6491 ltrans = S.Context.getCorrespondingUnsignedType(ltrans); 6492 6493 if (rhptee->isCharType()) 6494 rtrans = S.Context.UnsignedCharTy; 6495 else if (rhptee->hasSignedIntegerRepresentation()) 6496 rtrans = S.Context.getCorrespondingUnsignedType(rtrans); 6497 6498 if (ltrans == rtrans) { 6499 // Types are compatible ignoring the sign. Qualifier incompatibility 6500 // takes priority over sign incompatibility because the sign 6501 // warning can be disabled. 6502 if (ConvTy != Sema::Compatible) 6503 return ConvTy; 6504 6505 return Sema::IncompatiblePointerSign; 6506 } 6507 6508 // If we are a multi-level pointer, it's possible that our issue is simply 6509 // one of qualification - e.g. char ** -> const char ** is not allowed. If 6510 // the eventual target type is the same and the pointers have the same 6511 // level of indirection, this must be the issue. 6512 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) { 6513 do { 6514 lhptee = cast<PointerType>(lhptee)->getPointeeType().getTypePtr(); 6515 rhptee = cast<PointerType>(rhptee)->getPointeeType().getTypePtr(); 6516 } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)); 6517 6518 if (lhptee == rhptee) 6519 return Sema::IncompatibleNestedPointerQualifiers; 6520 } 6521 6522 // General pointer incompatibility takes priority over qualifiers. 6523 return Sema::IncompatiblePointer; 6524 } 6525 return ConvTy; 6526} 6527 6528/// checkBlockPointerTypesForAssignment - This routine determines whether two 6529/// block pointer types are compatible or whether a block and normal pointer 6530/// are compatible. It is more restrict than comparing two function pointer 6531// types. 6532static Sema::AssignConvertType 6533checkBlockPointerTypesForAssignment(Sema &S, QualType lhsType, 6534 QualType rhsType) { 6535 assert(lhsType.isCanonical() && "LHS not canonicalized!"); 6536 assert(rhsType.isCanonical() && "RHS not canonicalized!"); 6537 6538 QualType lhptee, rhptee; 6539 6540 // get the "pointed to" type (ignoring qualifiers at the top level) 6541 lhptee = cast<BlockPointerType>(lhsType)->getPointeeType(); 6542 rhptee = cast<BlockPointerType>(rhsType)->getPointeeType(); 6543 6544 // In C++, the types have to match exactly. 6545 if (S.getLangOptions().CPlusPlus) 6546 return Sema::IncompatibleBlockPointer; 6547 6548 Sema::AssignConvertType ConvTy = Sema::Compatible; 6549 6550 // For blocks we enforce that qualifiers are identical. 6551 if (lhptee.getLocalQualifiers() != rhptee.getLocalQualifiers()) 6552 ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 6553 6554 if (!S.Context.typesAreBlockPointerCompatible(lhsType, rhsType)) 6555 return Sema::IncompatibleBlockPointer; 6556 6557 return ConvTy; 6558} 6559 6560/// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types 6561/// for assignment compatibility. 6562static Sema::AssignConvertType 6563checkObjCPointerTypesForAssignment(Sema &S, QualType lhsType, QualType rhsType) { 6564 assert(lhsType.isCanonical() && "LHS was not canonicalized!"); 6565 assert(rhsType.isCanonical() && "RHS was not canonicalized!"); 6566 6567 if (lhsType->isObjCBuiltinType()) { 6568 // Class is not compatible with ObjC object pointers. 6569 if (lhsType->isObjCClassType() && !rhsType->isObjCBuiltinType() && 6570 !rhsType->isObjCQualifiedClassType()) 6571 return Sema::IncompatiblePointer; 6572 return Sema::Compatible; 6573 } 6574 if (rhsType->isObjCBuiltinType()) { 6575 // Class is not compatible with ObjC object pointers. 6576 if (rhsType->isObjCClassType() && !lhsType->isObjCBuiltinType() && 6577 !lhsType->isObjCQualifiedClassType()) 6578 return Sema::IncompatiblePointer; 6579 return Sema::Compatible; 6580 } 6581 QualType lhptee = 6582 lhsType->getAs<ObjCObjectPointerType>()->getPointeeType(); 6583 QualType rhptee = 6584 rhsType->getAs<ObjCObjectPointerType>()->getPointeeType(); 6585 6586 if (!lhptee.isAtLeastAsQualifiedAs(rhptee)) 6587 return Sema::CompatiblePointerDiscardsQualifiers; 6588 6589 if (S.Context.typesAreCompatible(lhsType, rhsType)) 6590 return Sema::Compatible; 6591 if (lhsType->isObjCQualifiedIdType() || rhsType->isObjCQualifiedIdType()) 6592 return Sema::IncompatibleObjCQualifiedId; 6593 return Sema::IncompatiblePointer; 6594} 6595 6596Sema::AssignConvertType 6597Sema::CheckAssignmentConstraints(SourceLocation Loc, 6598 QualType lhsType, QualType rhsType) { 6599 // Fake up an opaque expression. We don't actually care about what 6600 // cast operations are required, so if CheckAssignmentConstraints 6601 // adds casts to this they'll be wasted, but fortunately that doesn't 6602 // usually happen on valid code. 6603 OpaqueValueExpr rhs(Loc, rhsType, VK_RValue); 6604 ExprResult rhsPtr = &rhs; 6605 CastKind K = CK_Invalid; 6606 6607 return CheckAssignmentConstraints(lhsType, rhsPtr, K); 6608} 6609 6610/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently 6611/// has code to accommodate several GCC extensions when type checking 6612/// pointers. Here are some objectionable examples that GCC considers warnings: 6613/// 6614/// int a, *pint; 6615/// short *pshort; 6616/// struct foo *pfoo; 6617/// 6618/// pint = pshort; // warning: assignment from incompatible pointer type 6619/// a = pint; // warning: assignment makes integer from pointer without a cast 6620/// pint = a; // warning: assignment makes pointer from integer without a cast 6621/// pint = pfoo; // warning: assignment from incompatible pointer type 6622/// 6623/// As a result, the code for dealing with pointers is more complex than the 6624/// C99 spec dictates. 6625/// 6626/// Sets 'Kind' for any result kind except Incompatible. 6627Sema::AssignConvertType 6628Sema::CheckAssignmentConstraints(QualType lhsType, ExprResult &rhs, 6629 CastKind &Kind) { 6630 QualType rhsType = rhs.get()->getType(); 6631 6632 // Get canonical types. We're not formatting these types, just comparing 6633 // them. 6634 lhsType = Context.getCanonicalType(lhsType).getUnqualifiedType(); 6635 rhsType = Context.getCanonicalType(rhsType).getUnqualifiedType(); 6636 6637 // Common case: no conversion required. 6638 if (lhsType == rhsType) { 6639 Kind = CK_NoOp; 6640 return Compatible; 6641 } 6642 6643 // If the left-hand side is a reference type, then we are in a 6644 // (rare!) case where we've allowed the use of references in C, 6645 // e.g., as a parameter type in a built-in function. In this case, 6646 // just make sure that the type referenced is compatible with the 6647 // right-hand side type. The caller is responsible for adjusting 6648 // lhsType so that the resulting expression does not have reference 6649 // type. 6650 if (const ReferenceType *lhsTypeRef = lhsType->getAs<ReferenceType>()) { 6651 if (Context.typesAreCompatible(lhsTypeRef->getPointeeType(), rhsType)) { 6652 Kind = CK_LValueBitCast; 6653 return Compatible; 6654 } 6655 return Incompatible; 6656 } 6657 6658 // Allow scalar to ExtVector assignments, and assignments of an ExtVector type 6659 // to the same ExtVector type. 6660 if (lhsType->isExtVectorType()) { 6661 if (rhsType->isExtVectorType()) 6662 return Incompatible; 6663 if (rhsType->isArithmeticType()) { 6664 // CK_VectorSplat does T -> vector T, so first cast to the 6665 // element type. 6666 QualType elType = cast<ExtVectorType>(lhsType)->getElementType(); 6667 if (elType != rhsType) { 6668 Kind = PrepareScalarCast(*this, rhs, elType); 6669 rhs = ImpCastExprToType(rhs.take(), elType, Kind); 6670 } 6671 Kind = CK_VectorSplat; 6672 return Compatible; 6673 } 6674 } 6675 6676 // Conversions to or from vector type. 6677 if (lhsType->isVectorType() || rhsType->isVectorType()) { 6678 if (lhsType->isVectorType() && rhsType->isVectorType()) { 6679 // Allow assignments of an AltiVec vector type to an equivalent GCC 6680 // vector type and vice versa 6681 if (Context.areCompatibleVectorTypes(lhsType, rhsType)) { 6682 Kind = CK_BitCast; 6683 return Compatible; 6684 } 6685 6686 // If we are allowing lax vector conversions, and LHS and RHS are both 6687 // vectors, the total size only needs to be the same. This is a bitcast; 6688 // no bits are changed but the result type is different. 6689 if (getLangOptions().LaxVectorConversions && 6690 (Context.getTypeSize(lhsType) == Context.getTypeSize(rhsType))) { 6691 Kind = CK_BitCast; 6692 return IncompatibleVectors; 6693 } 6694 } 6695 return Incompatible; 6696 } 6697 6698 // Arithmetic conversions. 6699 if (lhsType->isArithmeticType() && rhsType->isArithmeticType() && 6700 !(getLangOptions().CPlusPlus && lhsType->isEnumeralType())) { 6701 Kind = PrepareScalarCast(*this, rhs, lhsType); 6702 return Compatible; 6703 } 6704 6705 // Conversions to normal pointers. 6706 if (const PointerType *lhsPointer = dyn_cast<PointerType>(lhsType)) { 6707 // U* -> T* 6708 if (isa<PointerType>(rhsType)) { 6709 Kind = CK_BitCast; 6710 return checkPointerTypesForAssignment(*this, lhsType, rhsType); 6711 } 6712 6713 // int -> T* 6714 if (rhsType->isIntegerType()) { 6715 Kind = CK_IntegralToPointer; // FIXME: null? 6716 return IntToPointer; 6717 } 6718 6719 // C pointers are not compatible with ObjC object pointers, 6720 // with two exceptions: 6721 if (isa<ObjCObjectPointerType>(rhsType)) { 6722 // - conversions to void* 6723 if (lhsPointer->getPointeeType()->isVoidType()) { 6724 Kind = CK_AnyPointerToObjCPointerCast; 6725 return Compatible; 6726 } 6727 6728 // - conversions from 'Class' to the redefinition type 6729 if (rhsType->isObjCClassType() && 6730 Context.hasSameType(lhsType, Context.ObjCClassRedefinitionType)) { 6731 Kind = CK_BitCast; 6732 return Compatible; 6733 } 6734 6735 Kind = CK_BitCast; 6736 return IncompatiblePointer; 6737 } 6738 6739 // U^ -> void* 6740 if (rhsType->getAs<BlockPointerType>()) { 6741 if (lhsPointer->getPointeeType()->isVoidType()) { 6742 Kind = CK_BitCast; 6743 return Compatible; 6744 } 6745 } 6746 6747 return Incompatible; 6748 } 6749 6750 // Conversions to block pointers. 6751 if (isa<BlockPointerType>(lhsType)) { 6752 // U^ -> T^ 6753 if (rhsType->isBlockPointerType()) { 6754 Kind = CK_AnyPointerToBlockPointerCast; 6755 return checkBlockPointerTypesForAssignment(*this, lhsType, rhsType); 6756 } 6757 6758 // int or null -> T^ 6759 if (rhsType->isIntegerType()) { 6760 Kind = CK_IntegralToPointer; // FIXME: null 6761 return IntToBlockPointer; 6762 } 6763 6764 // id -> T^ 6765 if (getLangOptions().ObjC1 && rhsType->isObjCIdType()) { 6766 Kind = CK_AnyPointerToBlockPointerCast; 6767 return Compatible; 6768 } 6769 6770 // void* -> T^ 6771 if (const PointerType *RHSPT = rhsType->getAs<PointerType>()) 6772 if (RHSPT->getPointeeType()->isVoidType()) { 6773 Kind = CK_AnyPointerToBlockPointerCast; 6774 return Compatible; 6775 } 6776 6777 return Incompatible; 6778 } 6779 6780 // Conversions to Objective-C pointers. 6781 if (isa<ObjCObjectPointerType>(lhsType)) { 6782 // A* -> B* 6783 if (rhsType->isObjCObjectPointerType()) { 6784 Kind = CK_BitCast; 6785 return checkObjCPointerTypesForAssignment(*this, lhsType, rhsType); 6786 } 6787 6788 // int or null -> A* 6789 if (rhsType->isIntegerType()) { 6790 Kind = CK_IntegralToPointer; // FIXME: null 6791 return IntToPointer; 6792 } 6793 6794 // In general, C pointers are not compatible with ObjC object pointers, 6795 // with two exceptions: 6796 if (isa<PointerType>(rhsType)) { 6797 // - conversions from 'void*' 6798 if (rhsType->isVoidPointerType()) { 6799 Kind = CK_AnyPointerToObjCPointerCast; 6800 return Compatible; 6801 } 6802 6803 // - conversions to 'Class' from its redefinition type 6804 if (lhsType->isObjCClassType() && 6805 Context.hasSameType(rhsType, Context.ObjCClassRedefinitionType)) { 6806 Kind = CK_BitCast; 6807 return Compatible; 6808 } 6809 6810 Kind = CK_AnyPointerToObjCPointerCast; 6811 return IncompatiblePointer; 6812 } 6813 6814 // T^ -> A* 6815 if (rhsType->isBlockPointerType()) { 6816 Kind = CK_AnyPointerToObjCPointerCast; 6817 return Compatible; 6818 } 6819 6820 return Incompatible; 6821 } 6822 6823 // Conversions from pointers that are not covered by the above. 6824 if (isa<PointerType>(rhsType)) { 6825 // T* -> _Bool 6826 if (lhsType == Context.BoolTy) { 6827 Kind = CK_PointerToBoolean; 6828 return Compatible; 6829 } 6830 6831 // T* -> int 6832 if (lhsType->isIntegerType()) { 6833 Kind = CK_PointerToIntegral; 6834 return PointerToInt; 6835 } 6836 6837 return Incompatible; 6838 } 6839 6840 // Conversions from Objective-C pointers that are not covered by the above. 6841 if (isa<ObjCObjectPointerType>(rhsType)) { 6842 // T* -> _Bool 6843 if (lhsType == Context.BoolTy) { 6844 Kind = CK_PointerToBoolean; 6845 return Compatible; 6846 } 6847 6848 // T* -> int 6849 if (lhsType->isIntegerType()) { 6850 Kind = CK_PointerToIntegral; 6851 return PointerToInt; 6852 } 6853 6854 return Incompatible; 6855 } 6856 6857 // struct A -> struct B 6858 if (isa<TagType>(lhsType) && isa<TagType>(rhsType)) { 6859 if (Context.typesAreCompatible(lhsType, rhsType)) { 6860 Kind = CK_NoOp; 6861 return Compatible; 6862 } 6863 } 6864 6865 return Incompatible; 6866} 6867 6868/// \brief Constructs a transparent union from an expression that is 6869/// used to initialize the transparent union. 6870static void ConstructTransparentUnion(Sema &S, ASTContext &C, ExprResult &EResult, 6871 QualType UnionType, FieldDecl *Field) { 6872 // Build an initializer list that designates the appropriate member 6873 // of the transparent union. 6874 Expr *E = EResult.take(); 6875 InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(), 6876 &E, 1, 6877 SourceLocation()); 6878 Initializer->setType(UnionType); 6879 Initializer->setInitializedFieldInUnion(Field); 6880 6881 // Build a compound literal constructing a value of the transparent 6882 // union type from this initializer list. 6883 TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType); 6884 EResult = S.Owned( 6885 new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType, 6886 VK_RValue, Initializer, false)); 6887} 6888 6889Sema::AssignConvertType 6890Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &rExpr) { 6891 QualType FromType = rExpr.get()->getType(); 6892 6893 // If the ArgType is a Union type, we want to handle a potential 6894 // transparent_union GCC extension. 6895 const RecordType *UT = ArgType->getAsUnionType(); 6896 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>()) 6897 return Incompatible; 6898 6899 // The field to initialize within the transparent union. 6900 RecordDecl *UD = UT->getDecl(); 6901 FieldDecl *InitField = 0; 6902 // It's compatible if the expression matches any of the fields. 6903 for (RecordDecl::field_iterator it = UD->field_begin(), 6904 itend = UD->field_end(); 6905 it != itend; ++it) { 6906 if (it->getType()->isPointerType()) { 6907 // If the transparent union contains a pointer type, we allow: 6908 // 1) void pointer 6909 // 2) null pointer constant 6910 if (FromType->isPointerType()) 6911 if (FromType->getAs<PointerType>()->getPointeeType()->isVoidType()) { 6912 rExpr = ImpCastExprToType(rExpr.take(), it->getType(), CK_BitCast); 6913 InitField = *it; 6914 break; 6915 } 6916 6917 if (rExpr.get()->isNullPointerConstant(Context, 6918 Expr::NPC_ValueDependentIsNull)) { 6919 rExpr = ImpCastExprToType(rExpr.take(), it->getType(), CK_NullToPointer); 6920 InitField = *it; 6921 break; 6922 } 6923 } 6924 6925 CastKind Kind = CK_Invalid; 6926 if (CheckAssignmentConstraints(it->getType(), rExpr, Kind) 6927 == Compatible) { 6928 rExpr = ImpCastExprToType(rExpr.take(), it->getType(), Kind); 6929 InitField = *it; 6930 break; 6931 } 6932 } 6933 6934 if (!InitField) 6935 return Incompatible; 6936 6937 ConstructTransparentUnion(*this, Context, rExpr, ArgType, InitField); 6938 return Compatible; 6939} 6940 6941Sema::AssignConvertType 6942Sema::CheckSingleAssignmentConstraints(QualType lhsType, ExprResult &rExpr) { 6943 if (getLangOptions().CPlusPlus) { 6944 if (!lhsType->isRecordType()) { 6945 // C++ 5.17p3: If the left operand is not of class type, the 6946 // expression is implicitly converted (C++ 4) to the 6947 // cv-unqualified type of the left operand. 6948 ExprResult Res = PerformImplicitConversion(rExpr.get(), 6949 lhsType.getUnqualifiedType(), 6950 AA_Assigning); 6951 if (Res.isInvalid()) 6952 return Incompatible; 6953 rExpr = move(Res); 6954 return Compatible; 6955 } 6956 6957 // FIXME: Currently, we fall through and treat C++ classes like C 6958 // structures. 6959 } 6960 6961 // C99 6.5.16.1p1: the left operand is a pointer and the right is 6962 // a null pointer constant. 6963 if ((lhsType->isPointerType() || 6964 lhsType->isObjCObjectPointerType() || 6965 lhsType->isBlockPointerType()) 6966 && rExpr.get()->isNullPointerConstant(Context, 6967 Expr::NPC_ValueDependentIsNull)) { 6968 rExpr = ImpCastExprToType(rExpr.take(), lhsType, CK_NullToPointer); 6969 return Compatible; 6970 } 6971 6972 // This check seems unnatural, however it is necessary to ensure the proper 6973 // conversion of functions/arrays. If the conversion were done for all 6974 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary 6975 // expressions that suppress this implicit conversion (&, sizeof). 6976 // 6977 // Suppress this for references: C++ 8.5.3p5. 6978 if (!lhsType->isReferenceType()) { 6979 rExpr = DefaultFunctionArrayLvalueConversion(rExpr.take()); 6980 if (rExpr.isInvalid()) 6981 return Incompatible; 6982 } 6983 6984 CastKind Kind = CK_Invalid; 6985 Sema::AssignConvertType result = 6986 CheckAssignmentConstraints(lhsType, rExpr, Kind); 6987 6988 // C99 6.5.16.1p2: The value of the right operand is converted to the 6989 // type of the assignment expression. 6990 // CheckAssignmentConstraints allows the left-hand side to be a reference, 6991 // so that we can use references in built-in functions even in C. 6992 // The getNonReferenceType() call makes sure that the resulting expression 6993 // does not have reference type. 6994 if (result != Incompatible && rExpr.get()->getType() != lhsType) 6995 rExpr = ImpCastExprToType(rExpr.take(), lhsType.getNonLValueExprType(Context), Kind); 6996 return result; 6997} 6998 6999QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &lex, ExprResult &rex) { 7000 Diag(Loc, diag::err_typecheck_invalid_operands) 7001 << lex.get()->getType() << rex.get()->getType() 7002 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7003 return QualType(); 7004} 7005 7006QualType Sema::CheckVectorOperands(SourceLocation Loc, ExprResult &lex, ExprResult &rex) { 7007 // For conversion purposes, we ignore any qualifiers. 7008 // For example, "const float" and "float" are equivalent. 7009 QualType lhsType = 7010 Context.getCanonicalType(lex.get()->getType()).getUnqualifiedType(); 7011 QualType rhsType = 7012 Context.getCanonicalType(rex.get()->getType()).getUnqualifiedType(); 7013 7014 // If the vector types are identical, return. 7015 if (lhsType == rhsType) 7016 return lhsType; 7017 7018 // Handle the case of a vector & extvector type of the same size and element 7019 // type. It would be nice if we only had one vector type someday. 7020 if (getLangOptions().LaxVectorConversions) { 7021 if (const VectorType *LV = lhsType->getAs<VectorType>()) { 7022 if (const VectorType *RV = rhsType->getAs<VectorType>()) { 7023 if (LV->getElementType() == RV->getElementType() && 7024 LV->getNumElements() == RV->getNumElements()) { 7025 if (lhsType->isExtVectorType()) { 7026 rex = ImpCastExprToType(rex.take(), lhsType, CK_BitCast); 7027 return lhsType; 7028 } 7029 7030 lex = ImpCastExprToType(lex.take(), rhsType, CK_BitCast); 7031 return rhsType; 7032 } else if (Context.getTypeSize(lhsType) ==Context.getTypeSize(rhsType)){ 7033 // If we are allowing lax vector conversions, and LHS and RHS are both 7034 // vectors, the total size only needs to be the same. This is a 7035 // bitcast; no bits are changed but the result type is different. 7036 rex = ImpCastExprToType(rex.take(), lhsType, CK_BitCast); 7037 return lhsType; 7038 } 7039 } 7040 } 7041 } 7042 7043 // Handle the case of equivalent AltiVec and GCC vector types 7044 if (lhsType->isVectorType() && rhsType->isVectorType() && 7045 Context.areCompatibleVectorTypes(lhsType, rhsType)) { 7046 lex = ImpCastExprToType(lex.take(), rhsType, CK_BitCast); 7047 return rhsType; 7048 } 7049 7050 // Canonicalize the ExtVector to the LHS, remember if we swapped so we can 7051 // swap back (so that we don't reverse the inputs to a subtract, for instance. 7052 bool swapped = false; 7053 if (rhsType->isExtVectorType()) { 7054 swapped = true; 7055 std::swap(rex, lex); 7056 std::swap(rhsType, lhsType); 7057 } 7058 7059 // Handle the case of an ext vector and scalar. 7060 if (const ExtVectorType *LV = lhsType->getAs<ExtVectorType>()) { 7061 QualType EltTy = LV->getElementType(); 7062 if (EltTy->isIntegralType(Context) && rhsType->isIntegralType(Context)) { 7063 int order = Context.getIntegerTypeOrder(EltTy, rhsType); 7064 if (order > 0) 7065 rex = ImpCastExprToType(rex.take(), EltTy, CK_IntegralCast); 7066 if (order >= 0) { 7067 rex = ImpCastExprToType(rex.take(), lhsType, CK_VectorSplat); 7068 if (swapped) std::swap(rex, lex); 7069 return lhsType; 7070 } 7071 } 7072 if (EltTy->isRealFloatingType() && rhsType->isScalarType() && 7073 rhsType->isRealFloatingType()) { 7074 int order = Context.getFloatingTypeOrder(EltTy, rhsType); 7075 if (order > 0) 7076 rex = ImpCastExprToType(rex.take(), EltTy, CK_FloatingCast); 7077 if (order >= 0) { 7078 rex = ImpCastExprToType(rex.take(), lhsType, CK_VectorSplat); 7079 if (swapped) std::swap(rex, lex); 7080 return lhsType; 7081 } 7082 } 7083 } 7084 7085 // Vectors of different size or scalar and non-ext-vector are errors. 7086 Diag(Loc, diag::err_typecheck_vector_not_convertable) 7087 << lex.get()->getType() << rex.get()->getType() 7088 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7089 return QualType(); 7090} 7091 7092QualType Sema::CheckMultiplyDivideOperands( 7093 ExprResult &lex, ExprResult &rex, SourceLocation Loc, bool isCompAssign, bool isDiv) { 7094 if (lex.get()->getType()->isVectorType() || rex.get()->getType()->isVectorType()) 7095 return CheckVectorOperands(Loc, lex, rex); 7096 7097 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign); 7098 if (lex.isInvalid() || rex.isInvalid()) 7099 return QualType(); 7100 7101 if (!lex.get()->getType()->isArithmeticType() || 7102 !rex.get()->getType()->isArithmeticType()) 7103 return InvalidOperands(Loc, lex, rex); 7104 7105 // Check for division by zero. 7106 if (isDiv && 7107 rex.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull)) 7108 DiagRuntimeBehavior(Loc, rex.get(), PDiag(diag::warn_division_by_zero) 7109 << rex.get()->getSourceRange()); 7110 7111 return compType; 7112} 7113 7114QualType Sema::CheckRemainderOperands( 7115 ExprResult &lex, ExprResult &rex, SourceLocation Loc, bool isCompAssign) { 7116 if (lex.get()->getType()->isVectorType() || rex.get()->getType()->isVectorType()) { 7117 if (lex.get()->getType()->hasIntegerRepresentation() && 7118 rex.get()->getType()->hasIntegerRepresentation()) 7119 return CheckVectorOperands(Loc, lex, rex); 7120 return InvalidOperands(Loc, lex, rex); 7121 } 7122 7123 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign); 7124 if (lex.isInvalid() || rex.isInvalid()) 7125 return QualType(); 7126 7127 if (!lex.get()->getType()->isIntegerType() || !rex.get()->getType()->isIntegerType()) 7128 return InvalidOperands(Loc, lex, rex); 7129 7130 // Check for remainder by zero. 7131 if (rex.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull)) 7132 DiagRuntimeBehavior(Loc, rex.get(), PDiag(diag::warn_remainder_by_zero) 7133 << rex.get()->getSourceRange()); 7134 7135 return compType; 7136} 7137 7138QualType Sema::CheckAdditionOperands( // C99 6.5.6 7139 ExprResult &lex, ExprResult &rex, SourceLocation Loc, QualType* CompLHSTy) { 7140 if (lex.get()->getType()->isVectorType() || rex.get()->getType()->isVectorType()) { 7141 QualType compType = CheckVectorOperands(Loc, lex, rex); 7142 if (CompLHSTy) *CompLHSTy = compType; 7143 return compType; 7144 } 7145 7146 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy); 7147 if (lex.isInvalid() || rex.isInvalid()) 7148 return QualType(); 7149 7150 // handle the common case first (both operands are arithmetic). 7151 if (lex.get()->getType()->isArithmeticType() && 7152 rex.get()->getType()->isArithmeticType()) { 7153 if (CompLHSTy) *CompLHSTy = compType; 7154 return compType; 7155 } 7156 7157 // Put any potential pointer into PExp 7158 Expr* PExp = lex.get(), *IExp = rex.get(); 7159 if (IExp->getType()->isAnyPointerType()) 7160 std::swap(PExp, IExp); 7161 7162 if (PExp->getType()->isAnyPointerType()) { 7163 7164 if (IExp->getType()->isIntegerType()) { 7165 QualType PointeeTy = PExp->getType()->getPointeeType(); 7166 7167 // Check for arithmetic on pointers to incomplete types. 7168 if (PointeeTy->isVoidType()) { 7169 if (getLangOptions().CPlusPlus) { 7170 Diag(Loc, diag::err_typecheck_pointer_arith_void_type) 7171 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7172 return QualType(); 7173 } 7174 7175 // GNU extension: arithmetic on pointer to void 7176 Diag(Loc, diag::ext_gnu_void_ptr) 7177 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7178 } else if (PointeeTy->isFunctionType()) { 7179 if (getLangOptions().CPlusPlus) { 7180 Diag(Loc, diag::err_typecheck_pointer_arith_function_type) 7181 << lex.get()->getType() << lex.get()->getSourceRange(); 7182 return QualType(); 7183 } 7184 7185 // GNU extension: arithmetic on pointer to function 7186 Diag(Loc, diag::ext_gnu_ptr_func_arith) 7187 << lex.get()->getType() << lex.get()->getSourceRange(); 7188 } else { 7189 // Check if we require a complete type. 7190 if (((PExp->getType()->isPointerType() && 7191 !PExp->getType()->isDependentType()) || 7192 PExp->getType()->isObjCObjectPointerType()) && 7193 RequireCompleteType(Loc, PointeeTy, 7194 PDiag(diag::err_typecheck_arithmetic_incomplete_type) 7195 << PExp->getSourceRange() 7196 << PExp->getType())) 7197 return QualType(); 7198 } 7199 // Diagnose bad cases where we step over interface counts. 7200 if (PointeeTy->isObjCObjectType() && LangOpts.ObjCNonFragileABI) { 7201 Diag(Loc, diag::err_arithmetic_nonfragile_interface) 7202 << PointeeTy << PExp->getSourceRange(); 7203 return QualType(); 7204 } 7205 7206 if (CompLHSTy) { 7207 QualType LHSTy = Context.isPromotableBitField(lex.get()); 7208 if (LHSTy.isNull()) { 7209 LHSTy = lex.get()->getType(); 7210 if (LHSTy->isPromotableIntegerType()) 7211 LHSTy = Context.getPromotedIntegerType(LHSTy); 7212 } 7213 *CompLHSTy = LHSTy; 7214 } 7215 return PExp->getType(); 7216 } 7217 } 7218 7219 return InvalidOperands(Loc, lex, rex); 7220} 7221 7222// C99 6.5.6 7223QualType Sema::CheckSubtractionOperands(ExprResult &lex, ExprResult &rex, 7224 SourceLocation Loc, QualType* CompLHSTy) { 7225 if (lex.get()->getType()->isVectorType() || rex.get()->getType()->isVectorType()) { 7226 QualType compType = CheckVectorOperands(Loc, lex, rex); 7227 if (CompLHSTy) *CompLHSTy = compType; 7228 return compType; 7229 } 7230 7231 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy); 7232 if (lex.isInvalid() || rex.isInvalid()) 7233 return QualType(); 7234 7235 // Enforce type constraints: C99 6.5.6p3. 7236 7237 // Handle the common case first (both operands are arithmetic). 7238 if (lex.get()->getType()->isArithmeticType() && 7239 rex.get()->getType()->isArithmeticType()) { 7240 if (CompLHSTy) *CompLHSTy = compType; 7241 return compType; 7242 } 7243 7244 // Either ptr - int or ptr - ptr. 7245 if (lex.get()->getType()->isAnyPointerType()) { 7246 QualType lpointee = lex.get()->getType()->getPointeeType(); 7247 7248 // The LHS must be an completely-defined object type. 7249 7250 bool ComplainAboutVoid = false; 7251 Expr *ComplainAboutFunc = 0; 7252 if (lpointee->isVoidType()) { 7253 if (getLangOptions().CPlusPlus) { 7254 Diag(Loc, diag::err_typecheck_pointer_arith_void_type) 7255 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7256 return QualType(); 7257 } 7258 7259 // GNU C extension: arithmetic on pointer to void 7260 ComplainAboutVoid = true; 7261 } else if (lpointee->isFunctionType()) { 7262 if (getLangOptions().CPlusPlus) { 7263 Diag(Loc, diag::err_typecheck_pointer_arith_function_type) 7264 << lex.get()->getType() << lex.get()->getSourceRange(); 7265 return QualType(); 7266 } 7267 7268 // GNU C extension: arithmetic on pointer to function 7269 ComplainAboutFunc = lex.get(); 7270 } else if (!lpointee->isDependentType() && 7271 RequireCompleteType(Loc, lpointee, 7272 PDiag(diag::err_typecheck_sub_ptr_object) 7273 << lex.get()->getSourceRange() 7274 << lex.get()->getType())) 7275 return QualType(); 7276 7277 // Diagnose bad cases where we step over interface counts. 7278 if (lpointee->isObjCObjectType() && LangOpts.ObjCNonFragileABI) { 7279 Diag(Loc, diag::err_arithmetic_nonfragile_interface) 7280 << lpointee << lex.get()->getSourceRange(); 7281 return QualType(); 7282 } 7283 7284 // The result type of a pointer-int computation is the pointer type. 7285 if (rex.get()->getType()->isIntegerType()) { 7286 if (ComplainAboutVoid) 7287 Diag(Loc, diag::ext_gnu_void_ptr) 7288 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7289 if (ComplainAboutFunc) 7290 Diag(Loc, diag::ext_gnu_ptr_func_arith) 7291 << ComplainAboutFunc->getType() 7292 << ComplainAboutFunc->getSourceRange(); 7293 7294 if (CompLHSTy) *CompLHSTy = lex.get()->getType(); 7295 return lex.get()->getType(); 7296 } 7297 7298 // Handle pointer-pointer subtractions. 7299 if (const PointerType *RHSPTy = rex.get()->getType()->getAs<PointerType>()) { 7300 QualType rpointee = RHSPTy->getPointeeType(); 7301 7302 // RHS must be a completely-type object type. 7303 // Handle the GNU void* extension. 7304 if (rpointee->isVoidType()) { 7305 if (getLangOptions().CPlusPlus) { 7306 Diag(Loc, diag::err_typecheck_pointer_arith_void_type) 7307 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7308 return QualType(); 7309 } 7310 7311 ComplainAboutVoid = true; 7312 } else if (rpointee->isFunctionType()) { 7313 if (getLangOptions().CPlusPlus) { 7314 Diag(Loc, diag::err_typecheck_pointer_arith_function_type) 7315 << rex.get()->getType() << rex.get()->getSourceRange(); 7316 return QualType(); 7317 } 7318 7319 // GNU extension: arithmetic on pointer to function 7320 if (!ComplainAboutFunc) 7321 ComplainAboutFunc = rex.get(); 7322 } else if (!rpointee->isDependentType() && 7323 RequireCompleteType(Loc, rpointee, 7324 PDiag(diag::err_typecheck_sub_ptr_object) 7325 << rex.get()->getSourceRange() 7326 << rex.get()->getType())) 7327 return QualType(); 7328 7329 if (getLangOptions().CPlusPlus) { 7330 // Pointee types must be the same: C++ [expr.add] 7331 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) { 7332 Diag(Loc, diag::err_typecheck_sub_ptr_compatible) 7333 << lex.get()->getType() << rex.get()->getType() 7334 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7335 return QualType(); 7336 } 7337 } else { 7338 // Pointee types must be compatible C99 6.5.6p3 7339 if (!Context.typesAreCompatible( 7340 Context.getCanonicalType(lpointee).getUnqualifiedType(), 7341 Context.getCanonicalType(rpointee).getUnqualifiedType())) { 7342 Diag(Loc, diag::err_typecheck_sub_ptr_compatible) 7343 << lex.get()->getType() << rex.get()->getType() 7344 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7345 return QualType(); 7346 } 7347 } 7348 7349 if (ComplainAboutVoid) 7350 Diag(Loc, diag::ext_gnu_void_ptr) 7351 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7352 if (ComplainAboutFunc) 7353 Diag(Loc, diag::ext_gnu_ptr_func_arith) 7354 << ComplainAboutFunc->getType() 7355 << ComplainAboutFunc->getSourceRange(); 7356 7357 if (CompLHSTy) *CompLHSTy = lex.get()->getType(); 7358 return Context.getPointerDiffType(); 7359 } 7360 } 7361 7362 return InvalidOperands(Loc, lex, rex); 7363} 7364 7365static bool isScopedEnumerationType(QualType T) { 7366 if (const EnumType *ET = dyn_cast<EnumType>(T)) 7367 return ET->getDecl()->isScoped(); 7368 return false; 7369} 7370 7371static void DiagnoseBadShiftValues(Sema& S, ExprResult &lex, ExprResult &rex, 7372 SourceLocation Loc, unsigned Opc, 7373 QualType LHSTy) { 7374 llvm::APSInt Right; 7375 // Check right/shifter operand 7376 if (rex.get()->isValueDependent() || !rex.get()->isIntegerConstantExpr(Right, S.Context)) 7377 return; 7378 7379 if (Right.isNegative()) { 7380 S.DiagRuntimeBehavior(Loc, rex.get(), 7381 S.PDiag(diag::warn_shift_negative) 7382 << rex.get()->getSourceRange()); 7383 return; 7384 } 7385 llvm::APInt LeftBits(Right.getBitWidth(), 7386 S.Context.getTypeSize(lex.get()->getType())); 7387 if (Right.uge(LeftBits)) { 7388 S.DiagRuntimeBehavior(Loc, rex.get(), 7389 S.PDiag(diag::warn_shift_gt_typewidth) 7390 << rex.get()->getSourceRange()); 7391 return; 7392 } 7393 if (Opc != BO_Shl) 7394 return; 7395 7396 // When left shifting an ICE which is signed, we can check for overflow which 7397 // according to C++ has undefined behavior ([expr.shift] 5.8/2). Unsigned 7398 // integers have defined behavior modulo one more than the maximum value 7399 // representable in the result type, so never warn for those. 7400 llvm::APSInt Left; 7401 if (lex.get()->isValueDependent() || !lex.get()->isIntegerConstantExpr(Left, S.Context) || 7402 LHSTy->hasUnsignedIntegerRepresentation()) 7403 return; 7404 llvm::APInt ResultBits = 7405 static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits(); 7406 if (LeftBits.uge(ResultBits)) 7407 return; 7408 llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue()); 7409 Result = Result.shl(Right); 7410 7411 // Print the bit representation of the signed integer as an unsigned 7412 // hexadecimal number. 7413 llvm::SmallString<40> HexResult; 7414 Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true); 7415 7416 // If we are only missing a sign bit, this is less likely to result in actual 7417 // bugs -- if the result is cast back to an unsigned type, it will have the 7418 // expected value. Thus we place this behind a different warning that can be 7419 // turned off separately if needed. 7420 if (LeftBits == ResultBits - 1) { 7421 S.Diag(Loc, diag::warn_shift_result_sets_sign_bit) 7422 << HexResult.str() << LHSTy 7423 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7424 return; 7425 } 7426 7427 S.Diag(Loc, diag::warn_shift_result_gt_typewidth) 7428 << HexResult.str() << Result.getMinSignedBits() << LHSTy 7429 << Left.getBitWidth() << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7430} 7431 7432// C99 6.5.7 7433QualType Sema::CheckShiftOperands(ExprResult &lex, ExprResult &rex, SourceLocation Loc, 7434 unsigned Opc, bool isCompAssign) { 7435 // C99 6.5.7p2: Each of the operands shall have integer type. 7436 if (!lex.get()->getType()->hasIntegerRepresentation() || 7437 !rex.get()->getType()->hasIntegerRepresentation()) 7438 return InvalidOperands(Loc, lex, rex); 7439 7440 // C++0x: Don't allow scoped enums. FIXME: Use something better than 7441 // hasIntegerRepresentation() above instead of this. 7442 if (isScopedEnumerationType(lex.get()->getType()) || 7443 isScopedEnumerationType(rex.get()->getType())) { 7444 return InvalidOperands(Loc, lex, rex); 7445 } 7446 7447 // Vector shifts promote their scalar inputs to vector type. 7448 if (lex.get()->getType()->isVectorType() || rex.get()->getType()->isVectorType()) 7449 return CheckVectorOperands(Loc, lex, rex); 7450 7451 // Shifts don't perform usual arithmetic conversions, they just do integer 7452 // promotions on each operand. C99 6.5.7p3 7453 7454 // For the LHS, do usual unary conversions, but then reset them away 7455 // if this is a compound assignment. 7456 ExprResult old_lex = lex; 7457 lex = UsualUnaryConversions(lex.take()); 7458 if (lex.isInvalid()) 7459 return QualType(); 7460 QualType LHSTy = lex.get()->getType(); 7461 if (isCompAssign) lex = old_lex; 7462 7463 // The RHS is simpler. 7464 rex = UsualUnaryConversions(rex.take()); 7465 if (rex.isInvalid()) 7466 return QualType(); 7467 7468 // Sanity-check shift operands 7469 DiagnoseBadShiftValues(*this, lex, rex, Loc, Opc, LHSTy); 7470 7471 // "The type of the result is that of the promoted left operand." 7472 return LHSTy; 7473} 7474 7475static bool IsWithinTemplateSpecialization(Decl *D) { 7476 if (DeclContext *DC = D->getDeclContext()) { 7477 if (isa<ClassTemplateSpecializationDecl>(DC)) 7478 return true; 7479 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) 7480 return FD->isFunctionTemplateSpecialization(); 7481 } 7482 return false; 7483} 7484 7485// C99 6.5.8, C++ [expr.rel] 7486QualType Sema::CheckCompareOperands(ExprResult &lex, ExprResult &rex, SourceLocation Loc, 7487 unsigned OpaqueOpc, bool isRelational) { 7488 BinaryOperatorKind Opc = (BinaryOperatorKind) OpaqueOpc; 7489 7490 // Handle vector comparisons separately. 7491 if (lex.get()->getType()->isVectorType() || rex.get()->getType()->isVectorType()) 7492 return CheckVectorCompareOperands(lex, rex, Loc, isRelational); 7493 7494 QualType lType = lex.get()->getType(); 7495 QualType rType = rex.get()->getType(); 7496 7497 Expr *LHSStripped = lex.get()->IgnoreParenImpCasts(); 7498 Expr *RHSStripped = rex.get()->IgnoreParenImpCasts(); 7499 QualType LHSStrippedType = LHSStripped->getType(); 7500 QualType RHSStrippedType = RHSStripped->getType(); 7501 7502 7503 7504 // Two different enums will raise a warning when compared. 7505 if (const EnumType *LHSEnumType = LHSStrippedType->getAs<EnumType>()) { 7506 if (const EnumType *RHSEnumType = RHSStrippedType->getAs<EnumType>()) { 7507 if (LHSEnumType->getDecl()->getIdentifier() && 7508 RHSEnumType->getDecl()->getIdentifier() && 7509 !Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType)) { 7510 Diag(Loc, diag::warn_comparison_of_mixed_enum_types) 7511 << LHSStrippedType << RHSStrippedType 7512 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7513 } 7514 } 7515 } 7516 7517 if (!lType->hasFloatingRepresentation() && 7518 !(lType->isBlockPointerType() && isRelational) && 7519 !lex.get()->getLocStart().isMacroID() && 7520 !rex.get()->getLocStart().isMacroID()) { 7521 // For non-floating point types, check for self-comparisons of the form 7522 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 7523 // often indicate logic errors in the program. 7524 // 7525 // NOTE: Don't warn about comparison expressions resulting from macro 7526 // expansion. Also don't warn about comparisons which are only self 7527 // comparisons within a template specialization. The warnings should catch 7528 // obvious cases in the definition of the template anyways. The idea is to 7529 // warn when the typed comparison operator will always evaluate to the same 7530 // result. 7531 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHSStripped)) { 7532 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHSStripped)) { 7533 if (DRL->getDecl() == DRR->getDecl() && 7534 !IsWithinTemplateSpecialization(DRL->getDecl())) { 7535 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always) 7536 << 0 // self- 7537 << (Opc == BO_EQ 7538 || Opc == BO_LE 7539 || Opc == BO_GE)); 7540 } else if (lType->isArrayType() && rType->isArrayType() && 7541 !DRL->getDecl()->getType()->isReferenceType() && 7542 !DRR->getDecl()->getType()->isReferenceType()) { 7543 // what is it always going to eval to? 7544 char always_evals_to; 7545 switch(Opc) { 7546 case BO_EQ: // e.g. array1 == array2 7547 always_evals_to = 0; // false 7548 break; 7549 case BO_NE: // e.g. array1 != array2 7550 always_evals_to = 1; // true 7551 break; 7552 default: 7553 // best we can say is 'a constant' 7554 always_evals_to = 2; // e.g. array1 <= array2 7555 break; 7556 } 7557 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always) 7558 << 1 // array 7559 << always_evals_to); 7560 } 7561 } 7562 } 7563 7564 if (isa<CastExpr>(LHSStripped)) 7565 LHSStripped = LHSStripped->IgnoreParenCasts(); 7566 if (isa<CastExpr>(RHSStripped)) 7567 RHSStripped = RHSStripped->IgnoreParenCasts(); 7568 7569 // Warn about comparisons against a string constant (unless the other 7570 // operand is null), the user probably wants strcmp. 7571 Expr *literalString = 0; 7572 Expr *literalStringStripped = 0; 7573 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) && 7574 !RHSStripped->isNullPointerConstant(Context, 7575 Expr::NPC_ValueDependentIsNull)) { 7576 literalString = lex.get(); 7577 literalStringStripped = LHSStripped; 7578 } else if ((isa<StringLiteral>(RHSStripped) || 7579 isa<ObjCEncodeExpr>(RHSStripped)) && 7580 !LHSStripped->isNullPointerConstant(Context, 7581 Expr::NPC_ValueDependentIsNull)) { 7582 literalString = rex.get(); 7583 literalStringStripped = RHSStripped; 7584 } 7585 7586 if (literalString) { 7587 std::string resultComparison; 7588 switch (Opc) { 7589 case BO_LT: resultComparison = ") < 0"; break; 7590 case BO_GT: resultComparison = ") > 0"; break; 7591 case BO_LE: resultComparison = ") <= 0"; break; 7592 case BO_GE: resultComparison = ") >= 0"; break; 7593 case BO_EQ: resultComparison = ") == 0"; break; 7594 case BO_NE: resultComparison = ") != 0"; break; 7595 default: assert(false && "Invalid comparison operator"); 7596 } 7597 7598 DiagRuntimeBehavior(Loc, 0, 7599 PDiag(diag::warn_stringcompare) 7600 << isa<ObjCEncodeExpr>(literalStringStripped) 7601 << literalString->getSourceRange()); 7602 } 7603 } 7604 7605 // C99 6.5.8p3 / C99 6.5.9p4 7606 if (lex.get()->getType()->isArithmeticType() && rex.get()->getType()->isArithmeticType()) { 7607 UsualArithmeticConversions(lex, rex); 7608 if (lex.isInvalid() || rex.isInvalid()) 7609 return QualType(); 7610 } 7611 else { 7612 lex = UsualUnaryConversions(lex.take()); 7613 if (lex.isInvalid()) 7614 return QualType(); 7615 7616 rex = UsualUnaryConversions(rex.take()); 7617 if (rex.isInvalid()) 7618 return QualType(); 7619 } 7620 7621 lType = lex.get()->getType(); 7622 rType = rex.get()->getType(); 7623 7624 // The result of comparisons is 'bool' in C++, 'int' in C. 7625 QualType ResultTy = Context.getLogicalOperationType(); 7626 7627 if (isRelational) { 7628 if (lType->isRealType() && rType->isRealType()) 7629 return ResultTy; 7630 } else { 7631 // Check for comparisons of floating point operands using != and ==. 7632 if (lType->hasFloatingRepresentation()) 7633 CheckFloatComparison(Loc, lex.get(), rex.get()); 7634 7635 if (lType->isArithmeticType() && rType->isArithmeticType()) 7636 return ResultTy; 7637 } 7638 7639 bool LHSIsNull = lex.get()->isNullPointerConstant(Context, 7640 Expr::NPC_ValueDependentIsNull); 7641 bool RHSIsNull = rex.get()->isNullPointerConstant(Context, 7642 Expr::NPC_ValueDependentIsNull); 7643 7644 // All of the following pointer-related warnings are GCC extensions, except 7645 // when handling null pointer constants. 7646 if (lType->isPointerType() && rType->isPointerType()) { // C99 6.5.8p2 7647 QualType LCanPointeeTy = 7648 Context.getCanonicalType(lType->getAs<PointerType>()->getPointeeType()); 7649 QualType RCanPointeeTy = 7650 Context.getCanonicalType(rType->getAs<PointerType>()->getPointeeType()); 7651 7652 if (getLangOptions().CPlusPlus) { 7653 if (LCanPointeeTy == RCanPointeeTy) 7654 return ResultTy; 7655 if (!isRelational && 7656 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 7657 // Valid unless comparison between non-null pointer and function pointer 7658 // This is a gcc extension compatibility comparison. 7659 // In a SFINAE context, we treat this as a hard error to maintain 7660 // conformance with the C++ standard. 7661 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 7662 && !LHSIsNull && !RHSIsNull) { 7663 Diag(Loc, 7664 isSFINAEContext()? 7665 diag::err_typecheck_comparison_of_fptr_to_void 7666 : diag::ext_typecheck_comparison_of_fptr_to_void) 7667 << lType << rType << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7668 7669 if (isSFINAEContext()) 7670 return QualType(); 7671 7672 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 7673 return ResultTy; 7674 } 7675 } 7676 7677 // C++ [expr.rel]p2: 7678 // [...] Pointer conversions (4.10) and qualification 7679 // conversions (4.4) are performed on pointer operands (or on 7680 // a pointer operand and a null pointer constant) to bring 7681 // them to their composite pointer type. [...] 7682 // 7683 // C++ [expr.eq]p1 uses the same notion for (in)equality 7684 // comparisons of pointers. 7685 bool NonStandardCompositeType = false; 7686 QualType T = FindCompositePointerType(Loc, lex, rex, 7687 isSFINAEContext()? 0 : &NonStandardCompositeType); 7688 if (T.isNull()) { 7689 Diag(Loc, diag::err_typecheck_comparison_of_distinct_pointers) 7690 << lType << rType << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7691 return QualType(); 7692 } else if (NonStandardCompositeType) { 7693 Diag(Loc, 7694 diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard) 7695 << lType << rType << T 7696 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7697 } 7698 7699 lex = ImpCastExprToType(lex.take(), T, CK_BitCast); 7700 rex = ImpCastExprToType(rex.take(), T, CK_BitCast); 7701 return ResultTy; 7702 } 7703 // C99 6.5.9p2 and C99 6.5.8p2 7704 if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(), 7705 RCanPointeeTy.getUnqualifiedType())) { 7706 // Valid unless a relational comparison of function pointers 7707 if (isRelational && LCanPointeeTy->isFunctionType()) { 7708 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers) 7709 << lType << rType << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7710 } 7711 } else if (!isRelational && 7712 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 7713 // Valid unless comparison between non-null pointer and function pointer 7714 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 7715 && !LHSIsNull && !RHSIsNull) { 7716 Diag(Loc, diag::ext_typecheck_comparison_of_fptr_to_void) 7717 << lType << rType << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7718 } 7719 } else { 7720 // Invalid 7721 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers) 7722 << lType << rType << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7723 } 7724 if (LCanPointeeTy != RCanPointeeTy) { 7725 if (LHSIsNull && !RHSIsNull) 7726 lex = ImpCastExprToType(lex.take(), rType, CK_BitCast); 7727 else 7728 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 7729 } 7730 return ResultTy; 7731 } 7732 7733 if (getLangOptions().CPlusPlus) { 7734 // Comparison of nullptr_t with itself. 7735 if (lType->isNullPtrType() && rType->isNullPtrType()) 7736 return ResultTy; 7737 7738 // Comparison of pointers with null pointer constants and equality 7739 // comparisons of member pointers to null pointer constants. 7740 if (RHSIsNull && 7741 ((lType->isAnyPointerType() || lType->isNullPtrType()) || 7742 (!isRelational && lType->isMemberPointerType()))) { 7743 rex = ImpCastExprToType(rex.take(), lType, 7744 lType->isMemberPointerType() 7745 ? CK_NullToMemberPointer 7746 : CK_NullToPointer); 7747 return ResultTy; 7748 } 7749 if (LHSIsNull && 7750 ((rType->isAnyPointerType() || rType->isNullPtrType()) || 7751 (!isRelational && rType->isMemberPointerType()))) { 7752 lex = ImpCastExprToType(lex.take(), rType, 7753 rType->isMemberPointerType() 7754 ? CK_NullToMemberPointer 7755 : CK_NullToPointer); 7756 return ResultTy; 7757 } 7758 7759 // Comparison of member pointers. 7760 if (!isRelational && 7761 lType->isMemberPointerType() && rType->isMemberPointerType()) { 7762 // C++ [expr.eq]p2: 7763 // In addition, pointers to members can be compared, or a pointer to 7764 // member and a null pointer constant. Pointer to member conversions 7765 // (4.11) and qualification conversions (4.4) are performed to bring 7766 // them to a common type. If one operand is a null pointer constant, 7767 // the common type is the type of the other operand. Otherwise, the 7768 // common type is a pointer to member type similar (4.4) to the type 7769 // of one of the operands, with a cv-qualification signature (4.4) 7770 // that is the union of the cv-qualification signatures of the operand 7771 // types. 7772 bool NonStandardCompositeType = false; 7773 QualType T = FindCompositePointerType(Loc, lex, rex, 7774 isSFINAEContext()? 0 : &NonStandardCompositeType); 7775 if (T.isNull()) { 7776 Diag(Loc, diag::err_typecheck_comparison_of_distinct_pointers) 7777 << lType << rType << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7778 return QualType(); 7779 } else if (NonStandardCompositeType) { 7780 Diag(Loc, 7781 diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard) 7782 << lType << rType << T 7783 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7784 } 7785 7786 lex = ImpCastExprToType(lex.take(), T, CK_BitCast); 7787 rex = ImpCastExprToType(rex.take(), T, CK_BitCast); 7788 return ResultTy; 7789 } 7790 7791 // Handle scoped enumeration types specifically, since they don't promote 7792 // to integers. 7793 if (lex.get()->getType()->isEnumeralType() && 7794 Context.hasSameUnqualifiedType(lex.get()->getType(), rex.get()->getType())) 7795 return ResultTy; 7796 } 7797 7798 // Handle block pointer types. 7799 if (!isRelational && lType->isBlockPointerType() && rType->isBlockPointerType()) { 7800 QualType lpointee = lType->getAs<BlockPointerType>()->getPointeeType(); 7801 QualType rpointee = rType->getAs<BlockPointerType>()->getPointeeType(); 7802 7803 if (!LHSIsNull && !RHSIsNull && 7804 !Context.typesAreCompatible(lpointee, rpointee)) { 7805 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 7806 << lType << rType << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7807 } 7808 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 7809 return ResultTy; 7810 } 7811 7812 // Allow block pointers to be compared with null pointer constants. 7813 if (!isRelational 7814 && ((lType->isBlockPointerType() && rType->isPointerType()) 7815 || (lType->isPointerType() && rType->isBlockPointerType()))) { 7816 if (!LHSIsNull && !RHSIsNull) { 7817 if (!((rType->isPointerType() && rType->castAs<PointerType>() 7818 ->getPointeeType()->isVoidType()) 7819 || (lType->isPointerType() && lType->castAs<PointerType>() 7820 ->getPointeeType()->isVoidType()))) 7821 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 7822 << lType << rType << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7823 } 7824 if (LHSIsNull && !RHSIsNull) 7825 lex = ImpCastExprToType(lex.take(), rType, CK_BitCast); 7826 else 7827 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 7828 return ResultTy; 7829 } 7830 7831 if (lType->isObjCObjectPointerType() || rType->isObjCObjectPointerType()) { 7832 const PointerType *LPT = lType->getAs<PointerType>(); 7833 const PointerType *RPT = rType->getAs<PointerType>(); 7834 if (LPT || RPT) { 7835 bool LPtrToVoid = LPT ? LPT->getPointeeType()->isVoidType() : false; 7836 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() : false; 7837 7838 if (!LPtrToVoid && !RPtrToVoid && 7839 !Context.typesAreCompatible(lType, rType)) { 7840 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers) 7841 << lType << rType << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7842 } 7843 if (LHSIsNull && !RHSIsNull) 7844 lex = ImpCastExprToType(lex.take(), rType, CK_BitCast); 7845 else 7846 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 7847 return ResultTy; 7848 } 7849 if (lType->isObjCObjectPointerType() && rType->isObjCObjectPointerType()) { 7850 if (!Context.areComparableObjCPointerTypes(lType, rType)) 7851 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers) 7852 << lType << rType << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7853 if (LHSIsNull && !RHSIsNull) 7854 lex = ImpCastExprToType(lex.take(), rType, CK_BitCast); 7855 else 7856 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 7857 return ResultTy; 7858 } 7859 } 7860 if ((lType->isAnyPointerType() && rType->isIntegerType()) || 7861 (lType->isIntegerType() && rType->isAnyPointerType())) { 7862 unsigned DiagID = 0; 7863 bool isError = false; 7864 if ((LHSIsNull && lType->isIntegerType()) || 7865 (RHSIsNull && rType->isIntegerType())) { 7866 if (isRelational && !getLangOptions().CPlusPlus) 7867 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero; 7868 } else if (isRelational && !getLangOptions().CPlusPlus) 7869 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer; 7870 else if (getLangOptions().CPlusPlus) { 7871 DiagID = diag::err_typecheck_comparison_of_pointer_integer; 7872 isError = true; 7873 } else 7874 DiagID = diag::ext_typecheck_comparison_of_pointer_integer; 7875 7876 if (DiagID) { 7877 Diag(Loc, DiagID) 7878 << lType << rType << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7879 if (isError) 7880 return QualType(); 7881 } 7882 7883 if (lType->isIntegerType()) 7884 lex = ImpCastExprToType(lex.take(), rType, 7885 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 7886 else 7887 rex = ImpCastExprToType(rex.take(), lType, 7888 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 7889 return ResultTy; 7890 } 7891 7892 // Handle block pointers. 7893 if (!isRelational && RHSIsNull 7894 && lType->isBlockPointerType() && rType->isIntegerType()) { 7895 rex = ImpCastExprToType(rex.take(), lType, CK_NullToPointer); 7896 return ResultTy; 7897 } 7898 if (!isRelational && LHSIsNull 7899 && lType->isIntegerType() && rType->isBlockPointerType()) { 7900 lex = ImpCastExprToType(lex.take(), rType, CK_NullToPointer); 7901 return ResultTy; 7902 } 7903 7904 return InvalidOperands(Loc, lex, rex); 7905} 7906 7907/// CheckVectorCompareOperands - vector comparisons are a clang extension that 7908/// operates on extended vector types. Instead of producing an IntTy result, 7909/// like a scalar comparison, a vector comparison produces a vector of integer 7910/// types. 7911QualType Sema::CheckVectorCompareOperands(ExprResult &lex, ExprResult &rex, 7912 SourceLocation Loc, 7913 bool isRelational) { 7914 // Check to make sure we're operating on vectors of the same type and width, 7915 // Allowing one side to be a scalar of element type. 7916 QualType vType = CheckVectorOperands(Loc, lex, rex); 7917 if (vType.isNull()) 7918 return vType; 7919 7920 QualType lType = lex.get()->getType(); 7921 QualType rType = rex.get()->getType(); 7922 7923 // If AltiVec, the comparison results in a numeric type, i.e. 7924 // bool for C++, int for C 7925 if (vType->getAs<VectorType>()->getVectorKind() == VectorType::AltiVecVector) 7926 return Context.getLogicalOperationType(); 7927 7928 // For non-floating point types, check for self-comparisons of the form 7929 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 7930 // often indicate logic errors in the program. 7931 if (!lType->hasFloatingRepresentation()) { 7932 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(lex.get()->IgnoreParens())) 7933 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(rex.get()->IgnoreParens())) 7934 if (DRL->getDecl() == DRR->getDecl()) 7935 DiagRuntimeBehavior(Loc, 0, 7936 PDiag(diag::warn_comparison_always) 7937 << 0 // self- 7938 << 2 // "a constant" 7939 ); 7940 } 7941 7942 // Check for comparisons of floating point operands using != and ==. 7943 if (!isRelational && lType->hasFloatingRepresentation()) { 7944 assert (rType->hasFloatingRepresentation()); 7945 CheckFloatComparison(Loc, lex.get(), rex.get()); 7946 } 7947 7948 // Return the type for the comparison, which is the same as vector type for 7949 // integer vectors, or an integer type of identical size and number of 7950 // elements for floating point vectors. 7951 if (lType->hasIntegerRepresentation()) 7952 return lType; 7953 7954 const VectorType *VTy = lType->getAs<VectorType>(); 7955 unsigned TypeSize = Context.getTypeSize(VTy->getElementType()); 7956 if (TypeSize == Context.getTypeSize(Context.IntTy)) 7957 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements()); 7958 if (TypeSize == Context.getTypeSize(Context.LongTy)) 7959 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements()); 7960 7961 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) && 7962 "Unhandled vector element size in vector compare"); 7963 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements()); 7964} 7965 7966inline QualType Sema::CheckBitwiseOperands( 7967 ExprResult &lex, ExprResult &rex, SourceLocation Loc, bool isCompAssign) { 7968 if (lex.get()->getType()->isVectorType() || rex.get()->getType()->isVectorType()) { 7969 if (lex.get()->getType()->hasIntegerRepresentation() && 7970 rex.get()->getType()->hasIntegerRepresentation()) 7971 return CheckVectorOperands(Loc, lex, rex); 7972 7973 return InvalidOperands(Loc, lex, rex); 7974 } 7975 7976 ExprResult lexResult = Owned(lex), rexResult = Owned(rex); 7977 QualType compType = UsualArithmeticConversions(lexResult, rexResult, isCompAssign); 7978 if (lexResult.isInvalid() || rexResult.isInvalid()) 7979 return QualType(); 7980 lex = lexResult.take(); 7981 rex = rexResult.take(); 7982 7983 if (lex.get()->getType()->isIntegralOrUnscopedEnumerationType() && 7984 rex.get()->getType()->isIntegralOrUnscopedEnumerationType()) 7985 return compType; 7986 return InvalidOperands(Loc, lex, rex); 7987} 7988 7989inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14] 7990 ExprResult &lex, ExprResult &rex, SourceLocation Loc, unsigned Opc) { 7991 7992 // Diagnose cases where the user write a logical and/or but probably meant a 7993 // bitwise one. We do this when the LHS is a non-bool integer and the RHS 7994 // is a constant. 7995 if (lex.get()->getType()->isIntegerType() && !lex.get()->getType()->isBooleanType() && 7996 rex.get()->getType()->isIntegerType() && !rex.get()->isValueDependent() && 7997 // Don't warn in macros. 7998 !Loc.isMacroID()) { 7999 // If the RHS can be constant folded, and if it constant folds to something 8000 // that isn't 0 or 1 (which indicate a potential logical operation that 8001 // happened to fold to true/false) then warn. 8002 // Parens on the RHS are ignored. 8003 Expr::EvalResult Result; 8004 if (rex.get()->Evaluate(Result, Context) && !Result.HasSideEffects) 8005 if ((getLangOptions().Bool && !rex.get()->getType()->isBooleanType()) || 8006 (Result.Val.getInt() != 0 && Result.Val.getInt() != 1)) { 8007 Diag(Loc, diag::warn_logical_instead_of_bitwise) 8008 << rex.get()->getSourceRange() 8009 << (Opc == BO_LAnd ? "&&" : "||") 8010 << (Opc == BO_LAnd ? "&" : "|"); 8011 } 8012 } 8013 8014 if (!Context.getLangOptions().CPlusPlus) { 8015 lex = UsualUnaryConversions(lex.take()); 8016 if (lex.isInvalid()) 8017 return QualType(); 8018 8019 rex = UsualUnaryConversions(rex.take()); 8020 if (rex.isInvalid()) 8021 return QualType(); 8022 8023 if (!lex.get()->getType()->isScalarType() || !rex.get()->getType()->isScalarType()) 8024 return InvalidOperands(Loc, lex, rex); 8025 8026 return Context.IntTy; 8027 } 8028 8029 // The following is safe because we only use this method for 8030 // non-overloadable operands. 8031 8032 // C++ [expr.log.and]p1 8033 // C++ [expr.log.or]p1 8034 // The operands are both contextually converted to type bool. 8035 ExprResult lexRes = PerformContextuallyConvertToBool(lex.get()); 8036 if (lexRes.isInvalid()) 8037 return InvalidOperands(Loc, lex, rex); 8038 lex = move(lexRes); 8039 8040 ExprResult rexRes = PerformContextuallyConvertToBool(rex.get()); 8041 if (rexRes.isInvalid()) 8042 return InvalidOperands(Loc, lex, rex); 8043 rex = move(rexRes); 8044 8045 // C++ [expr.log.and]p2 8046 // C++ [expr.log.or]p2 8047 // The result is a bool. 8048 return Context.BoolTy; 8049} 8050 8051/// IsReadonlyProperty - Verify that otherwise a valid l-value expression 8052/// is a read-only property; return true if so. A readonly property expression 8053/// depends on various declarations and thus must be treated specially. 8054/// 8055static bool IsReadonlyProperty(Expr *E, Sema &S) { 8056 if (E->getStmtClass() == Expr::ObjCPropertyRefExprClass) { 8057 const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(E); 8058 if (PropExpr->isImplicitProperty()) return false; 8059 8060 ObjCPropertyDecl *PDecl = PropExpr->getExplicitProperty(); 8061 QualType BaseType = PropExpr->isSuperReceiver() ? 8062 PropExpr->getSuperReceiverType() : 8063 PropExpr->getBase()->getType(); 8064 8065 if (const ObjCObjectPointerType *OPT = 8066 BaseType->getAsObjCInterfacePointerType()) 8067 if (ObjCInterfaceDecl *IFace = OPT->getInterfaceDecl()) 8068 if (S.isPropertyReadonly(PDecl, IFace)) 8069 return true; 8070 } 8071 return false; 8072} 8073 8074static bool IsConstProperty(Expr *E, Sema &S) { 8075 if (E->getStmtClass() == Expr::ObjCPropertyRefExprClass) { 8076 const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(E); 8077 if (PropExpr->isImplicitProperty()) return false; 8078 8079 ObjCPropertyDecl *PDecl = PropExpr->getExplicitProperty(); 8080 QualType T = PDecl->getType(); 8081 if (T->isReferenceType()) 8082 T = T->getAs<ReferenceType>()->getPointeeType(); 8083 CanQualType CT = S.Context.getCanonicalType(T); 8084 return CT.isConstQualified(); 8085 } 8086 return false; 8087} 8088 8089static bool IsReadonlyMessage(Expr *E, Sema &S) { 8090 if (E->getStmtClass() != Expr::MemberExprClass) 8091 return false; 8092 const MemberExpr *ME = cast<MemberExpr>(E); 8093 NamedDecl *Member = ME->getMemberDecl(); 8094 if (isa<FieldDecl>(Member)) { 8095 Expr *Base = ME->getBase()->IgnoreParenImpCasts(); 8096 if (Base->getStmtClass() != Expr::ObjCMessageExprClass) 8097 return false; 8098 return cast<ObjCMessageExpr>(Base)->getMethodDecl() != 0; 8099 } 8100 return false; 8101} 8102 8103/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not, 8104/// emit an error and return true. If so, return false. 8105static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) { 8106 SourceLocation OrigLoc = Loc; 8107 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context, 8108 &Loc); 8109 if (IsLV == Expr::MLV_Valid && IsReadonlyProperty(E, S)) 8110 IsLV = Expr::MLV_ReadonlyProperty; 8111 else if (Expr::MLV_ConstQualified && IsConstProperty(E, S)) 8112 IsLV = Expr::MLV_Valid; 8113 else if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S)) 8114 IsLV = Expr::MLV_InvalidMessageExpression; 8115 if (IsLV == Expr::MLV_Valid) 8116 return false; 8117 8118 unsigned Diag = 0; 8119 bool NeedType = false; 8120 switch (IsLV) { // C99 6.5.16p2 8121 case Expr::MLV_ConstQualified: Diag = diag::err_typecheck_assign_const; break; 8122 case Expr::MLV_ArrayType: 8123 Diag = diag::err_typecheck_array_not_modifiable_lvalue; 8124 NeedType = true; 8125 break; 8126 case Expr::MLV_NotObjectType: 8127 Diag = diag::err_typecheck_non_object_not_modifiable_lvalue; 8128 NeedType = true; 8129 break; 8130 case Expr::MLV_LValueCast: 8131 Diag = diag::err_typecheck_lvalue_casts_not_supported; 8132 break; 8133 case Expr::MLV_Valid: 8134 llvm_unreachable("did not take early return for MLV_Valid"); 8135 case Expr::MLV_InvalidExpression: 8136 case Expr::MLV_MemberFunction: 8137 case Expr::MLV_ClassTemporary: 8138 Diag = diag::err_typecheck_expression_not_modifiable_lvalue; 8139 break; 8140 case Expr::MLV_IncompleteType: 8141 case Expr::MLV_IncompleteVoidType: 8142 return S.RequireCompleteType(Loc, E->getType(), 8143 S.PDiag(diag::err_typecheck_incomplete_type_not_modifiable_lvalue) 8144 << E->getSourceRange()); 8145 case Expr::MLV_DuplicateVectorComponents: 8146 Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue; 8147 break; 8148 case Expr::MLV_NotBlockQualified: 8149 Diag = diag::err_block_decl_ref_not_modifiable_lvalue; 8150 break; 8151 case Expr::MLV_ReadonlyProperty: 8152 Diag = diag::error_readonly_property_assignment; 8153 break; 8154 case Expr::MLV_NoSetterProperty: 8155 Diag = diag::error_nosetter_property_assignment; 8156 break; 8157 case Expr::MLV_InvalidMessageExpression: 8158 Diag = diag::error_readonly_message_assignment; 8159 break; 8160 case Expr::MLV_SubObjCPropertySetting: 8161 Diag = diag::error_no_subobject_property_setting; 8162 break; 8163 } 8164 8165 SourceRange Assign; 8166 if (Loc != OrigLoc) 8167 Assign = SourceRange(OrigLoc, OrigLoc); 8168 if (NeedType) 8169 S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign; 8170 else 8171 S.Diag(Loc, Diag) << E->getSourceRange() << Assign; 8172 return true; 8173} 8174 8175 8176 8177// C99 6.5.16.1 8178QualType Sema::CheckAssignmentOperands(Expr *LHS, ExprResult &RHS, 8179 SourceLocation Loc, 8180 QualType CompoundType) { 8181 // Verify that LHS is a modifiable lvalue, and emit error if not. 8182 if (CheckForModifiableLvalue(LHS, Loc, *this)) 8183 return QualType(); 8184 8185 QualType LHSType = LHS->getType(); 8186 QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() : CompoundType; 8187 AssignConvertType ConvTy; 8188 if (CompoundType.isNull()) { 8189 QualType LHSTy(LHSType); 8190 // Simple assignment "x = y". 8191 if (LHS->getObjectKind() == OK_ObjCProperty) { 8192 ExprResult LHSResult = Owned(LHS); 8193 ConvertPropertyForLValue(LHSResult, RHS, LHSTy); 8194 if (LHSResult.isInvalid()) 8195 return QualType(); 8196 LHS = LHSResult.take(); 8197 } 8198 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS); 8199 if (RHS.isInvalid()) 8200 return QualType(); 8201 // Special case of NSObject attributes on c-style pointer types. 8202 if (ConvTy == IncompatiblePointer && 8203 ((Context.isObjCNSObjectType(LHSType) && 8204 RHSType->isObjCObjectPointerType()) || 8205 (Context.isObjCNSObjectType(RHSType) && 8206 LHSType->isObjCObjectPointerType()))) 8207 ConvTy = Compatible; 8208 8209 if (ConvTy == Compatible && 8210 getLangOptions().ObjCNonFragileABI && 8211 LHSType->isObjCObjectType()) 8212 Diag(Loc, diag::err_assignment_requires_nonfragile_object) 8213 << LHSType; 8214 8215 // If the RHS is a unary plus or minus, check to see if they = and + are 8216 // right next to each other. If so, the user may have typo'd "x =+ 4" 8217 // instead of "x += 4". 8218 Expr *RHSCheck = RHS.get(); 8219 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck)) 8220 RHSCheck = ICE->getSubExpr(); 8221 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) { 8222 if ((UO->getOpcode() == UO_Plus || 8223 UO->getOpcode() == UO_Minus) && 8224 Loc.isFileID() && UO->getOperatorLoc().isFileID() && 8225 // Only if the two operators are exactly adjacent. 8226 Loc.getFileLocWithOffset(1) == UO->getOperatorLoc() && 8227 // And there is a space or other character before the subexpr of the 8228 // unary +/-. We don't want to warn on "x=-1". 8229 Loc.getFileLocWithOffset(2) != UO->getSubExpr()->getLocStart() && 8230 UO->getSubExpr()->getLocStart().isFileID()) { 8231 Diag(Loc, diag::warn_not_compound_assign) 8232 << (UO->getOpcode() == UO_Plus ? "+" : "-") 8233 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc()); 8234 } 8235 } 8236 } else { 8237 // Compound assignment "x += y" 8238 ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType); 8239 } 8240 8241 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType, 8242 RHS.get(), AA_Assigning)) 8243 return QualType(); 8244 8245 CheckForNullPointerDereference(*this, LHS); 8246 // Check for trivial buffer overflows. 8247 CheckArrayAccess(LHS->IgnoreParenCasts()); 8248 8249 // C99 6.5.16p3: The type of an assignment expression is the type of the 8250 // left operand unless the left operand has qualified type, in which case 8251 // it is the unqualified version of the type of the left operand. 8252 // C99 6.5.16.1p2: In simple assignment, the value of the right operand 8253 // is converted to the type of the assignment expression (above). 8254 // C++ 5.17p1: the type of the assignment expression is that of its left 8255 // operand. 8256 return (getLangOptions().CPlusPlus 8257 ? LHSType : LHSType.getUnqualifiedType()); 8258} 8259 8260// C99 6.5.17 8261static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, 8262 SourceLocation Loc) { 8263 S.DiagnoseUnusedExprResult(LHS.get()); 8264 8265 LHS = S.CheckPlaceholderExpr(LHS.take()); 8266 RHS = S.CheckPlaceholderExpr(RHS.take()); 8267 if (LHS.isInvalid() || RHS.isInvalid()) 8268 return QualType(); 8269 8270 // C's comma performs lvalue conversion (C99 6.3.2.1) on both its 8271 // operands, but not unary promotions. 8272 // C++'s comma does not do any conversions at all (C++ [expr.comma]p1). 8273 8274 // So we treat the LHS as a ignored value, and in C++ we allow the 8275 // containing site to determine what should be done with the RHS. 8276 LHS = S.IgnoredValueConversions(LHS.take()); 8277 if (LHS.isInvalid()) 8278 return QualType(); 8279 8280 if (!S.getLangOptions().CPlusPlus) { 8281 RHS = S.DefaultFunctionArrayLvalueConversion(RHS.take()); 8282 if (RHS.isInvalid()) 8283 return QualType(); 8284 if (!RHS.get()->getType()->isVoidType()) 8285 S.RequireCompleteType(Loc, RHS.get()->getType(), diag::err_incomplete_type); 8286 } 8287 8288 return RHS.get()->getType(); 8289} 8290 8291/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine 8292/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions. 8293static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, 8294 ExprValueKind &VK, 8295 SourceLocation OpLoc, 8296 bool isInc, bool isPrefix) { 8297 if (Op->isTypeDependent()) 8298 return S.Context.DependentTy; 8299 8300 QualType ResType = Op->getType(); 8301 assert(!ResType.isNull() && "no type for increment/decrement expression"); 8302 8303 if (S.getLangOptions().CPlusPlus && ResType->isBooleanType()) { 8304 // Decrement of bool is not allowed. 8305 if (!isInc) { 8306 S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange(); 8307 return QualType(); 8308 } 8309 // Increment of bool sets it to true, but is deprecated. 8310 S.Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange(); 8311 } else if (ResType->isRealType()) { 8312 // OK! 8313 } else if (ResType->isAnyPointerType()) { 8314 QualType PointeeTy = ResType->getPointeeType(); 8315 8316 // C99 6.5.2.4p2, 6.5.6p2 8317 if (PointeeTy->isVoidType()) { 8318 if (S.getLangOptions().CPlusPlus) { 8319 S.Diag(OpLoc, diag::err_typecheck_pointer_arith_void_type) 8320 << Op->getSourceRange(); 8321 return QualType(); 8322 } 8323 8324 // Pointer to void is a GNU extension in C. 8325 S.Diag(OpLoc, diag::ext_gnu_void_ptr) << Op->getSourceRange(); 8326 } else if (PointeeTy->isFunctionType()) { 8327 if (S.getLangOptions().CPlusPlus) { 8328 S.Diag(OpLoc, diag::err_typecheck_pointer_arith_function_type) 8329 << Op->getType() << Op->getSourceRange(); 8330 return QualType(); 8331 } 8332 8333 S.Diag(OpLoc, diag::ext_gnu_ptr_func_arith) 8334 << ResType << Op->getSourceRange(); 8335 } else if (S.RequireCompleteType(OpLoc, PointeeTy, 8336 S.PDiag(diag::err_typecheck_arithmetic_incomplete_type) 8337 << Op->getSourceRange() 8338 << ResType)) 8339 return QualType(); 8340 // Diagnose bad cases where we step over interface counts. 8341 else if (PointeeTy->isObjCObjectType() && S.LangOpts.ObjCNonFragileABI) { 8342 S.Diag(OpLoc, diag::err_arithmetic_nonfragile_interface) 8343 << PointeeTy << Op->getSourceRange(); 8344 return QualType(); 8345 } 8346 } else if (ResType->isAnyComplexType()) { 8347 // C99 does not support ++/-- on complex types, we allow as an extension. 8348 S.Diag(OpLoc, diag::ext_integer_increment_complex) 8349 << ResType << Op->getSourceRange(); 8350 } else if (ResType->isPlaceholderType()) { 8351 ExprResult PR = S.CheckPlaceholderExpr(Op); 8352 if (PR.isInvalid()) return QualType(); 8353 return CheckIncrementDecrementOperand(S, PR.take(), VK, OpLoc, 8354 isInc, isPrefix); 8355 } else if (S.getLangOptions().AltiVec && ResType->isVectorType()) { 8356 // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 ) 8357 } else { 8358 S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement) 8359 << ResType << int(isInc) << Op->getSourceRange(); 8360 return QualType(); 8361 } 8362 // At this point, we know we have a real, complex or pointer type. 8363 // Now make sure the operand is a modifiable lvalue. 8364 if (CheckForModifiableLvalue(Op, OpLoc, S)) 8365 return QualType(); 8366 // In C++, a prefix increment is the same type as the operand. Otherwise 8367 // (in C or with postfix), the increment is the unqualified type of the 8368 // operand. 8369 if (isPrefix && S.getLangOptions().CPlusPlus) { 8370 VK = VK_LValue; 8371 return ResType; 8372 } else { 8373 VK = VK_RValue; 8374 return ResType.getUnqualifiedType(); 8375 } 8376} 8377 8378ExprResult Sema::ConvertPropertyForRValue(Expr *E) { 8379 assert(E->getValueKind() == VK_LValue && 8380 E->getObjectKind() == OK_ObjCProperty); 8381 const ObjCPropertyRefExpr *PRE = E->getObjCProperty(); 8382 8383 QualType T = E->getType(); 8384 QualType ReceiverType; 8385 if (PRE->isObjectReceiver()) 8386 ReceiverType = PRE->getBase()->getType(); 8387 else if (PRE->isSuperReceiver()) 8388 ReceiverType = PRE->getSuperReceiverType(); 8389 else 8390 ReceiverType = Context.getObjCInterfaceType(PRE->getClassReceiver()); 8391 8392 ExprValueKind VK = VK_RValue; 8393 if (PRE->isImplicitProperty()) { 8394 if (ObjCMethodDecl *GetterMethod = 8395 PRE->getImplicitPropertyGetter()) { 8396 T = getMessageSendResultType(ReceiverType, GetterMethod, 8397 PRE->isClassReceiver(), 8398 PRE->isSuperReceiver()); 8399 VK = Expr::getValueKindForType(GetterMethod->getResultType()); 8400 } 8401 else { 8402 Diag(PRE->getLocation(), diag::err_getter_not_found) 8403 << PRE->getBase()->getType(); 8404 } 8405 } 8406 8407 E = ImplicitCastExpr::Create(Context, T, CK_GetObjCProperty, 8408 E, 0, VK); 8409 8410 ExprResult Result = MaybeBindToTemporary(E); 8411 if (!Result.isInvalid()) 8412 E = Result.take(); 8413 8414 return Owned(E); 8415} 8416 8417void Sema::ConvertPropertyForLValue(ExprResult &LHS, ExprResult &RHS, QualType &LHSTy) { 8418 assert(LHS.get()->getValueKind() == VK_LValue && 8419 LHS.get()->getObjectKind() == OK_ObjCProperty); 8420 const ObjCPropertyRefExpr *PropRef = LHS.get()->getObjCProperty(); 8421 8422 if (PropRef->isImplicitProperty()) { 8423 // If using property-dot syntax notation for assignment, and there is a 8424 // setter, RHS expression is being passed to the setter argument. So, 8425 // type conversion (and comparison) is RHS to setter's argument type. 8426 if (const ObjCMethodDecl *SetterMD = PropRef->getImplicitPropertySetter()) { 8427 ObjCMethodDecl::param_iterator P = SetterMD->param_begin(); 8428 LHSTy = (*P)->getType(); 8429 8430 // Otherwise, if the getter returns an l-value, just call that. 8431 } else { 8432 QualType Result = PropRef->getImplicitPropertyGetter()->getResultType(); 8433 ExprValueKind VK = Expr::getValueKindForType(Result); 8434 if (VK == VK_LValue) { 8435 LHS = ImplicitCastExpr::Create(Context, LHS.get()->getType(), 8436 CK_GetObjCProperty, LHS.take(), 0, VK); 8437 return; 8438 } 8439 } 8440 } 8441 8442 if (getLangOptions().CPlusPlus && LHSTy->isRecordType()) { 8443 InitializedEntity Entity = 8444 InitializedEntity::InitializeParameter(Context, LHSTy); 8445 ExprResult ArgE = PerformCopyInitialization(Entity, SourceLocation(), RHS); 8446 if (!ArgE.isInvalid()) 8447 RHS = ArgE; 8448 } 8449} 8450 8451 8452/// getPrimaryDecl - Helper function for CheckAddressOfOperand(). 8453/// This routine allows us to typecheck complex/recursive expressions 8454/// where the declaration is needed for type checking. We only need to 8455/// handle cases when the expression references a function designator 8456/// or is an lvalue. Here are some examples: 8457/// - &(x) => x 8458/// - &*****f => f for f a function designator. 8459/// - &s.xx => s 8460/// - &s.zz[1].yy -> s, if zz is an array 8461/// - *(x + 1) -> x, if x is an array 8462/// - &"123"[2] -> 0 8463/// - & __real__ x -> x 8464static ValueDecl *getPrimaryDecl(Expr *E) { 8465 switch (E->getStmtClass()) { 8466 case Stmt::DeclRefExprClass: 8467 return cast<DeclRefExpr>(E)->getDecl(); 8468 case Stmt::MemberExprClass: 8469 // If this is an arrow operator, the address is an offset from 8470 // the base's value, so the object the base refers to is 8471 // irrelevant. 8472 if (cast<MemberExpr>(E)->isArrow()) 8473 return 0; 8474 // Otherwise, the expression refers to a part of the base 8475 return getPrimaryDecl(cast<MemberExpr>(E)->getBase()); 8476 case Stmt::ArraySubscriptExprClass: { 8477 // FIXME: This code shouldn't be necessary! We should catch the implicit 8478 // promotion of register arrays earlier. 8479 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase(); 8480 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) { 8481 if (ICE->getSubExpr()->getType()->isArrayType()) 8482 return getPrimaryDecl(ICE->getSubExpr()); 8483 } 8484 return 0; 8485 } 8486 case Stmt::UnaryOperatorClass: { 8487 UnaryOperator *UO = cast<UnaryOperator>(E); 8488 8489 switch(UO->getOpcode()) { 8490 case UO_Real: 8491 case UO_Imag: 8492 case UO_Extension: 8493 return getPrimaryDecl(UO->getSubExpr()); 8494 default: 8495 return 0; 8496 } 8497 } 8498 case Stmt::ParenExprClass: 8499 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr()); 8500 case Stmt::ImplicitCastExprClass: 8501 // If the result of an implicit cast is an l-value, we care about 8502 // the sub-expression; otherwise, the result here doesn't matter. 8503 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr()); 8504 default: 8505 return 0; 8506 } 8507} 8508 8509/// CheckAddressOfOperand - The operand of & must be either a function 8510/// designator or an lvalue designating an object. If it is an lvalue, the 8511/// object cannot be declared with storage class register or be a bit field. 8512/// Note: The usual conversions are *not* applied to the operand of the & 8513/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue. 8514/// In C++, the operand might be an overloaded function name, in which case 8515/// we allow the '&' but retain the overloaded-function type. 8516static QualType CheckAddressOfOperand(Sema &S, Expr *OrigOp, 8517 SourceLocation OpLoc) { 8518 if (OrigOp->isTypeDependent()) 8519 return S.Context.DependentTy; 8520 if (OrigOp->getType() == S.Context.OverloadTy) 8521 return S.Context.OverloadTy; 8522 if (OrigOp->getType() == S.Context.UnknownAnyTy) 8523 return S.Context.UnknownAnyTy; 8524 if (OrigOp->getType() == S.Context.BoundMemberTy) { 8525 S.Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 8526 << OrigOp->getSourceRange(); 8527 return QualType(); 8528 } 8529 8530 assert(!OrigOp->getType()->isPlaceholderType()); 8531 8532 // Make sure to ignore parentheses in subsequent checks 8533 Expr *op = OrigOp->IgnoreParens(); 8534 8535 if (S.getLangOptions().C99) { 8536 // Implement C99-only parts of addressof rules. 8537 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) { 8538 if (uOp->getOpcode() == UO_Deref) 8539 // Per C99 6.5.3.2, the address of a deref always returns a valid result 8540 // (assuming the deref expression is valid). 8541 return uOp->getSubExpr()->getType(); 8542 } 8543 // Technically, there should be a check for array subscript 8544 // expressions here, but the result of one is always an lvalue anyway. 8545 } 8546 ValueDecl *dcl = getPrimaryDecl(op); 8547 Expr::LValueClassification lval = op->ClassifyLValue(S.Context); 8548 8549 if (lval == Expr::LV_ClassTemporary) { 8550 bool sfinae = S.isSFINAEContext(); 8551 S.Diag(OpLoc, sfinae ? diag::err_typecheck_addrof_class_temporary 8552 : diag::ext_typecheck_addrof_class_temporary) 8553 << op->getType() << op->getSourceRange(); 8554 if (sfinae) 8555 return QualType(); 8556 } else if (isa<ObjCSelectorExpr>(op)) { 8557 return S.Context.getPointerType(op->getType()); 8558 } else if (lval == Expr::LV_MemberFunction) { 8559 // If it's an instance method, make a member pointer. 8560 // The expression must have exactly the form &A::foo. 8561 8562 // If the underlying expression isn't a decl ref, give up. 8563 if (!isa<DeclRefExpr>(op)) { 8564 S.Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 8565 << OrigOp->getSourceRange(); 8566 return QualType(); 8567 } 8568 DeclRefExpr *DRE = cast<DeclRefExpr>(op); 8569 CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl()); 8570 8571 // The id-expression was parenthesized. 8572 if (OrigOp != DRE) { 8573 S.Diag(OpLoc, diag::err_parens_pointer_member_function) 8574 << OrigOp->getSourceRange(); 8575 8576 // The method was named without a qualifier. 8577 } else if (!DRE->getQualifier()) { 8578 S.Diag(OpLoc, diag::err_unqualified_pointer_member_function) 8579 << op->getSourceRange(); 8580 } 8581 8582 return S.Context.getMemberPointerType(op->getType(), 8583 S.Context.getTypeDeclType(MD->getParent()).getTypePtr()); 8584 } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) { 8585 // C99 6.5.3.2p1 8586 // The operand must be either an l-value or a function designator 8587 if (!op->getType()->isFunctionType()) { 8588 // FIXME: emit more specific diag... 8589 S.Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof) 8590 << op->getSourceRange(); 8591 return QualType(); 8592 } 8593 } else if (op->getObjectKind() == OK_BitField) { // C99 6.5.3.2p1 8594 // The operand cannot be a bit-field 8595 S.Diag(OpLoc, diag::err_typecheck_address_of) 8596 << "bit-field" << op->getSourceRange(); 8597 return QualType(); 8598 } else if (op->getObjectKind() == OK_VectorComponent) { 8599 // The operand cannot be an element of a vector 8600 S.Diag(OpLoc, diag::err_typecheck_address_of) 8601 << "vector element" << op->getSourceRange(); 8602 return QualType(); 8603 } else if (op->getObjectKind() == OK_ObjCProperty) { 8604 // cannot take address of a property expression. 8605 S.Diag(OpLoc, diag::err_typecheck_address_of) 8606 << "property expression" << op->getSourceRange(); 8607 return QualType(); 8608 } else if (dcl) { // C99 6.5.3.2p1 8609 // We have an lvalue with a decl. Make sure the decl is not declared 8610 // with the register storage-class specifier. 8611 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) { 8612 // in C++ it is not error to take address of a register 8613 // variable (c++03 7.1.1P3) 8614 if (vd->getStorageClass() == SC_Register && 8615 !S.getLangOptions().CPlusPlus) { 8616 S.Diag(OpLoc, diag::err_typecheck_address_of) 8617 << "register variable" << op->getSourceRange(); 8618 return QualType(); 8619 } 8620 } else if (isa<FunctionTemplateDecl>(dcl)) { 8621 return S.Context.OverloadTy; 8622 } else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) { 8623 // Okay: we can take the address of a field. 8624 // Could be a pointer to member, though, if there is an explicit 8625 // scope qualifier for the class. 8626 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) { 8627 DeclContext *Ctx = dcl->getDeclContext(); 8628 if (Ctx && Ctx->isRecord()) { 8629 if (dcl->getType()->isReferenceType()) { 8630 S.Diag(OpLoc, 8631 diag::err_cannot_form_pointer_to_member_of_reference_type) 8632 << dcl->getDeclName() << dcl->getType(); 8633 return QualType(); 8634 } 8635 8636 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion()) 8637 Ctx = Ctx->getParent(); 8638 return S.Context.getMemberPointerType(op->getType(), 8639 S.Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr()); 8640 } 8641 } 8642 } else if (!isa<FunctionDecl>(dcl)) 8643 assert(0 && "Unknown/unexpected decl type"); 8644 } 8645 8646 if (lval == Expr::LV_IncompleteVoidType) { 8647 // Taking the address of a void variable is technically illegal, but we 8648 // allow it in cases which are otherwise valid. 8649 // Example: "extern void x; void* y = &x;". 8650 S.Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange(); 8651 } 8652 8653 // If the operand has type "type", the result has type "pointer to type". 8654 if (op->getType()->isObjCObjectType()) 8655 return S.Context.getObjCObjectPointerType(op->getType()); 8656 return S.Context.getPointerType(op->getType()); 8657} 8658 8659/// CheckIndirectionOperand - Type check unary indirection (prefix '*'). 8660static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK, 8661 SourceLocation OpLoc) { 8662 if (Op->isTypeDependent()) 8663 return S.Context.DependentTy; 8664 8665 ExprResult ConvResult = S.UsualUnaryConversions(Op); 8666 if (ConvResult.isInvalid()) 8667 return QualType(); 8668 Op = ConvResult.take(); 8669 QualType OpTy = Op->getType(); 8670 QualType Result; 8671 8672 if (isa<CXXReinterpretCastExpr>(Op)) { 8673 QualType OpOrigType = Op->IgnoreParenCasts()->getType(); 8674 S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true, 8675 Op->getSourceRange()); 8676 } 8677 8678 // Note that per both C89 and C99, indirection is always legal, even if OpTy 8679 // is an incomplete type or void. It would be possible to warn about 8680 // dereferencing a void pointer, but it's completely well-defined, and such a 8681 // warning is unlikely to catch any mistakes. 8682 if (const PointerType *PT = OpTy->getAs<PointerType>()) 8683 Result = PT->getPointeeType(); 8684 else if (const ObjCObjectPointerType *OPT = 8685 OpTy->getAs<ObjCObjectPointerType>()) 8686 Result = OPT->getPointeeType(); 8687 else { 8688 ExprResult PR = S.CheckPlaceholderExpr(Op); 8689 if (PR.isInvalid()) return QualType(); 8690 if (PR.take() != Op) 8691 return CheckIndirectionOperand(S, PR.take(), VK, OpLoc); 8692 } 8693 8694 if (Result.isNull()) { 8695 S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer) 8696 << OpTy << Op->getSourceRange(); 8697 return QualType(); 8698 } 8699 8700 // Dereferences are usually l-values... 8701 VK = VK_LValue; 8702 8703 // ...except that certain expressions are never l-values in C. 8704 if (!S.getLangOptions().CPlusPlus && 8705 IsCForbiddenLValueType(S.Context, Result)) 8706 VK = VK_RValue; 8707 8708 return Result; 8709} 8710 8711static inline BinaryOperatorKind ConvertTokenKindToBinaryOpcode( 8712 tok::TokenKind Kind) { 8713 BinaryOperatorKind Opc; 8714 switch (Kind) { 8715 default: assert(0 && "Unknown binop!"); 8716 case tok::periodstar: Opc = BO_PtrMemD; break; 8717 case tok::arrowstar: Opc = BO_PtrMemI; break; 8718 case tok::star: Opc = BO_Mul; break; 8719 case tok::slash: Opc = BO_Div; break; 8720 case tok::percent: Opc = BO_Rem; break; 8721 case tok::plus: Opc = BO_Add; break; 8722 case tok::minus: Opc = BO_Sub; break; 8723 case tok::lessless: Opc = BO_Shl; break; 8724 case tok::greatergreater: Opc = BO_Shr; break; 8725 case tok::lessequal: Opc = BO_LE; break; 8726 case tok::less: Opc = BO_LT; break; 8727 case tok::greaterequal: Opc = BO_GE; break; 8728 case tok::greater: Opc = BO_GT; break; 8729 case tok::exclaimequal: Opc = BO_NE; break; 8730 case tok::equalequal: Opc = BO_EQ; break; 8731 case tok::amp: Opc = BO_And; break; 8732 case tok::caret: Opc = BO_Xor; break; 8733 case tok::pipe: Opc = BO_Or; break; 8734 case tok::ampamp: Opc = BO_LAnd; break; 8735 case tok::pipepipe: Opc = BO_LOr; break; 8736 case tok::equal: Opc = BO_Assign; break; 8737 case tok::starequal: Opc = BO_MulAssign; break; 8738 case tok::slashequal: Opc = BO_DivAssign; break; 8739 case tok::percentequal: Opc = BO_RemAssign; break; 8740 case tok::plusequal: Opc = BO_AddAssign; break; 8741 case tok::minusequal: Opc = BO_SubAssign; break; 8742 case tok::lesslessequal: Opc = BO_ShlAssign; break; 8743 case tok::greatergreaterequal: Opc = BO_ShrAssign; break; 8744 case tok::ampequal: Opc = BO_AndAssign; break; 8745 case tok::caretequal: Opc = BO_XorAssign; break; 8746 case tok::pipeequal: Opc = BO_OrAssign; break; 8747 case tok::comma: Opc = BO_Comma; break; 8748 } 8749 return Opc; 8750} 8751 8752static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode( 8753 tok::TokenKind Kind) { 8754 UnaryOperatorKind Opc; 8755 switch (Kind) { 8756 default: assert(0 && "Unknown unary op!"); 8757 case tok::plusplus: Opc = UO_PreInc; break; 8758 case tok::minusminus: Opc = UO_PreDec; break; 8759 case tok::amp: Opc = UO_AddrOf; break; 8760 case tok::star: Opc = UO_Deref; break; 8761 case tok::plus: Opc = UO_Plus; break; 8762 case tok::minus: Opc = UO_Minus; break; 8763 case tok::tilde: Opc = UO_Not; break; 8764 case tok::exclaim: Opc = UO_LNot; break; 8765 case tok::kw___real: Opc = UO_Real; break; 8766 case tok::kw___imag: Opc = UO_Imag; break; 8767 case tok::kw___extension__: Opc = UO_Extension; break; 8768 } 8769 return Opc; 8770} 8771 8772/// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself. 8773/// This warning is only emitted for builtin assignment operations. It is also 8774/// suppressed in the event of macro expansions. 8775static void DiagnoseSelfAssignment(Sema &S, Expr *lhs, Expr *rhs, 8776 SourceLocation OpLoc) { 8777 if (!S.ActiveTemplateInstantiations.empty()) 8778 return; 8779 if (OpLoc.isInvalid() || OpLoc.isMacroID()) 8780 return; 8781 lhs = lhs->IgnoreParenImpCasts(); 8782 rhs = rhs->IgnoreParenImpCasts(); 8783 const DeclRefExpr *LeftDeclRef = dyn_cast<DeclRefExpr>(lhs); 8784 const DeclRefExpr *RightDeclRef = dyn_cast<DeclRefExpr>(rhs); 8785 if (!LeftDeclRef || !RightDeclRef || 8786 LeftDeclRef->getLocation().isMacroID() || 8787 RightDeclRef->getLocation().isMacroID()) 8788 return; 8789 const ValueDecl *LeftDecl = 8790 cast<ValueDecl>(LeftDeclRef->getDecl()->getCanonicalDecl()); 8791 const ValueDecl *RightDecl = 8792 cast<ValueDecl>(RightDeclRef->getDecl()->getCanonicalDecl()); 8793 if (LeftDecl != RightDecl) 8794 return; 8795 if (LeftDecl->getType().isVolatileQualified()) 8796 return; 8797 if (const ReferenceType *RefTy = LeftDecl->getType()->getAs<ReferenceType>()) 8798 if (RefTy->getPointeeType().isVolatileQualified()) 8799 return; 8800 8801 S.Diag(OpLoc, diag::warn_self_assignment) 8802 << LeftDeclRef->getType() 8803 << lhs->getSourceRange() << rhs->getSourceRange(); 8804} 8805 8806/// CreateBuiltinBinOp - Creates a new built-in binary operation with 8807/// operator @p Opc at location @c TokLoc. This routine only supports 8808/// built-in operations; ActOnBinOp handles overloaded operators. 8809ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc, 8810 BinaryOperatorKind Opc, 8811 Expr *lhsExpr, Expr *rhsExpr) { 8812 ExprResult lhs = Owned(lhsExpr), rhs = Owned(rhsExpr); 8813 QualType ResultTy; // Result type of the binary operator. 8814 // The following two variables are used for compound assignment operators 8815 QualType CompLHSTy; // Type of LHS after promotions for computation 8816 QualType CompResultTy; // Type of computation result 8817 ExprValueKind VK = VK_RValue; 8818 ExprObjectKind OK = OK_Ordinary; 8819 8820 // Check if a 'foo<int>' involved in a binary op, identifies a single 8821 // function unambiguously (i.e. an lvalue ala 13.4) 8822 // But since an assignment can trigger target based overload, exclude it in 8823 // our blind search. i.e: 8824 // template<class T> void f(); template<class T, class U> void f(U); 8825 // f<int> == 0; // resolve f<int> blindly 8826 // void (*p)(int); p = f<int>; // resolve f<int> using target 8827 if (Opc != BO_Assign) { 8828 ExprResult resolvedLHS = CheckPlaceholderExpr(lhs.get()); 8829 if (!resolvedLHS.isUsable()) return ExprError(); 8830 lhs = move(resolvedLHS); 8831 8832 ExprResult resolvedRHS = CheckPlaceholderExpr(rhs.get()); 8833 if (!resolvedRHS.isUsable()) return ExprError(); 8834 rhs = move(resolvedRHS); 8835 } 8836 8837 switch (Opc) { 8838 case BO_Assign: 8839 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, QualType()); 8840 if (getLangOptions().CPlusPlus && 8841 lhs.get()->getObjectKind() != OK_ObjCProperty) { 8842 VK = lhs.get()->getValueKind(); 8843 OK = lhs.get()->getObjectKind(); 8844 } 8845 if (!ResultTy.isNull()) 8846 DiagnoseSelfAssignment(*this, lhs.get(), rhs.get(), OpLoc); 8847 break; 8848 case BO_PtrMemD: 8849 case BO_PtrMemI: 8850 ResultTy = CheckPointerToMemberOperands(lhs, rhs, VK, OpLoc, 8851 Opc == BO_PtrMemI); 8852 break; 8853 case BO_Mul: 8854 case BO_Div: 8855 ResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc, false, 8856 Opc == BO_Div); 8857 break; 8858 case BO_Rem: 8859 ResultTy = CheckRemainderOperands(lhs, rhs, OpLoc); 8860 break; 8861 case BO_Add: 8862 ResultTy = CheckAdditionOperands(lhs, rhs, OpLoc); 8863 break; 8864 case BO_Sub: 8865 ResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc); 8866 break; 8867 case BO_Shl: 8868 case BO_Shr: 8869 ResultTy = CheckShiftOperands(lhs, rhs, OpLoc, Opc); 8870 break; 8871 case BO_LE: 8872 case BO_LT: 8873 case BO_GE: 8874 case BO_GT: 8875 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, true); 8876 break; 8877 case BO_EQ: 8878 case BO_NE: 8879 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, false); 8880 break; 8881 case BO_And: 8882 case BO_Xor: 8883 case BO_Or: 8884 ResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc); 8885 break; 8886 case BO_LAnd: 8887 case BO_LOr: 8888 ResultTy = CheckLogicalOperands(lhs, rhs, OpLoc, Opc); 8889 break; 8890 case BO_MulAssign: 8891 case BO_DivAssign: 8892 CompResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc, true, 8893 Opc == BO_DivAssign); 8894 CompLHSTy = CompResultTy; 8895 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 8896 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 8897 break; 8898 case BO_RemAssign: 8899 CompResultTy = CheckRemainderOperands(lhs, rhs, OpLoc, true); 8900 CompLHSTy = CompResultTy; 8901 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 8902 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 8903 break; 8904 case BO_AddAssign: 8905 CompResultTy = CheckAdditionOperands(lhs, rhs, OpLoc, &CompLHSTy); 8906 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 8907 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 8908 break; 8909 case BO_SubAssign: 8910 CompResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc, &CompLHSTy); 8911 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 8912 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 8913 break; 8914 case BO_ShlAssign: 8915 case BO_ShrAssign: 8916 CompResultTy = CheckShiftOperands(lhs, rhs, OpLoc, Opc, true); 8917 CompLHSTy = CompResultTy; 8918 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 8919 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 8920 break; 8921 case BO_AndAssign: 8922 case BO_XorAssign: 8923 case BO_OrAssign: 8924 CompResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc, true); 8925 CompLHSTy = CompResultTy; 8926 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 8927 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 8928 break; 8929 case BO_Comma: 8930 ResultTy = CheckCommaOperands(*this, lhs, rhs, OpLoc); 8931 if (getLangOptions().CPlusPlus && !rhs.isInvalid()) { 8932 VK = rhs.get()->getValueKind(); 8933 OK = rhs.get()->getObjectKind(); 8934 } 8935 break; 8936 } 8937 if (ResultTy.isNull() || lhs.isInvalid() || rhs.isInvalid()) 8938 return ExprError(); 8939 if (CompResultTy.isNull()) 8940 return Owned(new (Context) BinaryOperator(lhs.take(), rhs.take(), Opc, 8941 ResultTy, VK, OK, OpLoc)); 8942 if (getLangOptions().CPlusPlus && lhs.get()->getObjectKind() != OK_ObjCProperty) { 8943 VK = VK_LValue; 8944 OK = lhs.get()->getObjectKind(); 8945 } 8946 return Owned(new (Context) CompoundAssignOperator(lhs.take(), rhs.take(), Opc, 8947 ResultTy, VK, OK, CompLHSTy, 8948 CompResultTy, OpLoc)); 8949} 8950 8951/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison 8952/// operators are mixed in a way that suggests that the programmer forgot that 8953/// comparison operators have higher precedence. The most typical example of 8954/// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1". 8955static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, 8956 SourceLocation OpLoc,Expr *lhs,Expr *rhs){ 8957 typedef BinaryOperator BinOp; 8958 BinOp::Opcode lhsopc = static_cast<BinOp::Opcode>(-1), 8959 rhsopc = static_cast<BinOp::Opcode>(-1); 8960 if (BinOp *BO = dyn_cast<BinOp>(lhs)) 8961 lhsopc = BO->getOpcode(); 8962 if (BinOp *BO = dyn_cast<BinOp>(rhs)) 8963 rhsopc = BO->getOpcode(); 8964 8965 // Subs are not binary operators. 8966 if (lhsopc == -1 && rhsopc == -1) 8967 return; 8968 8969 // Bitwise operations are sometimes used as eager logical ops. 8970 // Don't diagnose this. 8971 if ((BinOp::isComparisonOp(lhsopc) || BinOp::isBitwiseOp(lhsopc)) && 8972 (BinOp::isComparisonOp(rhsopc) || BinOp::isBitwiseOp(rhsopc))) 8973 return; 8974 8975 if (BinOp::isComparisonOp(lhsopc)) 8976 SuggestParentheses(Self, OpLoc, 8977 Self.PDiag(diag::warn_precedence_bitwise_rel) 8978 << SourceRange(lhs->getLocStart(), OpLoc) 8979 << BinOp::getOpcodeStr(Opc) << BinOp::getOpcodeStr(lhsopc), 8980 Self.PDiag(diag::note_precedence_bitwise_silence) 8981 << BinOp::getOpcodeStr(lhsopc), 8982 lhs->getSourceRange(), 8983 Self.PDiag(diag::note_precedence_bitwise_first) 8984 << BinOp::getOpcodeStr(Opc), 8985 SourceRange(cast<BinOp>(lhs)->getRHS()->getLocStart(), rhs->getLocEnd())); 8986 else if (BinOp::isComparisonOp(rhsopc)) 8987 SuggestParentheses(Self, OpLoc, 8988 Self.PDiag(diag::warn_precedence_bitwise_rel) 8989 << SourceRange(OpLoc, rhs->getLocEnd()) 8990 << BinOp::getOpcodeStr(Opc) << BinOp::getOpcodeStr(rhsopc), 8991 Self.PDiag(diag::note_precedence_bitwise_silence) 8992 << BinOp::getOpcodeStr(rhsopc), 8993 rhs->getSourceRange(), 8994 Self.PDiag(diag::note_precedence_bitwise_first) 8995 << BinOp::getOpcodeStr(Opc), 8996 SourceRange(lhs->getLocEnd(), cast<BinOp>(rhs)->getLHS()->getLocStart())); 8997} 8998 8999/// \brief It accepts a '&&' expr that is inside a '||' one. 9000/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression 9001/// in parentheses. 9002static void 9003EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, 9004 BinaryOperator *Bop) { 9005 assert(Bop->getOpcode() == BO_LAnd); 9006 SuggestParentheses(Self, Bop->getOperatorLoc(), 9007 Self.PDiag(diag::warn_logical_and_in_logical_or) 9008 << Bop->getSourceRange() << OpLoc, 9009 Self.PDiag(diag::note_logical_and_in_logical_or_silence), 9010 Bop->getSourceRange(), 9011 Self.PDiag(0), SourceRange()); 9012} 9013 9014/// \brief Returns true if the given expression can be evaluated as a constant 9015/// 'true'. 9016static bool EvaluatesAsTrue(Sema &S, Expr *E) { 9017 bool Res; 9018 return E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res; 9019} 9020 9021/// \brief Returns true if the given expression can be evaluated as a constant 9022/// 'false'. 9023static bool EvaluatesAsFalse(Sema &S, Expr *E) { 9024 bool Res; 9025 return E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res; 9026} 9027 9028/// \brief Look for '&&' in the left hand of a '||' expr. 9029static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, 9030 Expr *OrLHS, Expr *OrRHS) { 9031 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrLHS)) { 9032 if (Bop->getOpcode() == BO_LAnd) { 9033 // If it's "a && b || 0" don't warn since the precedence doesn't matter. 9034 if (EvaluatesAsFalse(S, OrRHS)) 9035 return; 9036 // If it's "1 && a || b" don't warn since the precedence doesn't matter. 9037 if (!EvaluatesAsTrue(S, Bop->getLHS())) 9038 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 9039 } else if (Bop->getOpcode() == BO_LOr) { 9040 if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) { 9041 // If it's "a || b && 1 || c" we didn't warn earlier for 9042 // "a || b && 1", but warn now. 9043 if (RBop->getOpcode() == BO_LAnd && EvaluatesAsTrue(S, RBop->getRHS())) 9044 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop); 9045 } 9046 } 9047 } 9048} 9049 9050/// \brief Look for '&&' in the right hand of a '||' expr. 9051static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, 9052 Expr *OrLHS, Expr *OrRHS) { 9053 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrRHS)) { 9054 if (Bop->getOpcode() == BO_LAnd) { 9055 // If it's "0 || a && b" don't warn since the precedence doesn't matter. 9056 if (EvaluatesAsFalse(S, OrLHS)) 9057 return; 9058 // If it's "a || b && 1" don't warn since the precedence doesn't matter. 9059 if (!EvaluatesAsTrue(S, Bop->getRHS())) 9060 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 9061 } 9062 } 9063} 9064 9065/// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky 9066/// precedence. 9067static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc, 9068 SourceLocation OpLoc, Expr *lhs, Expr *rhs){ 9069 // Diagnose "arg1 'bitwise' arg2 'eq' arg3". 9070 if (BinaryOperator::isBitwiseOp(Opc)) 9071 return DiagnoseBitwisePrecedence(Self, Opc, OpLoc, lhs, rhs); 9072 9073 // Warn about arg1 || arg2 && arg3, as GCC 4.3+ does. 9074 // We don't warn for 'assert(a || b && "bad")' since this is safe. 9075 if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) { 9076 DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, lhs, rhs); 9077 DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, lhs, rhs); 9078 } 9079} 9080 9081// Binary Operators. 'Tok' is the token for the operator. 9082ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc, 9083 tok::TokenKind Kind, 9084 Expr *lhs, Expr *rhs) { 9085 BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind); 9086 assert((lhs != 0) && "ActOnBinOp(): missing left expression"); 9087 assert((rhs != 0) && "ActOnBinOp(): missing right expression"); 9088 9089 // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0" 9090 DiagnoseBinOpPrecedence(*this, Opc, TokLoc, lhs, rhs); 9091 9092 return BuildBinOp(S, TokLoc, Opc, lhs, rhs); 9093} 9094 9095ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc, 9096 BinaryOperatorKind Opc, 9097 Expr *lhs, Expr *rhs) { 9098 if (getLangOptions().CPlusPlus) { 9099 bool UseBuiltinOperator; 9100 9101 if (lhs->isTypeDependent() || rhs->isTypeDependent()) { 9102 UseBuiltinOperator = false; 9103 } else if (Opc == BO_Assign && lhs->getObjectKind() == OK_ObjCProperty) { 9104 UseBuiltinOperator = true; 9105 } else { 9106 UseBuiltinOperator = !lhs->getType()->isOverloadableType() && 9107 !rhs->getType()->isOverloadableType(); 9108 } 9109 9110 if (!UseBuiltinOperator) { 9111 // Find all of the overloaded operators visible from this 9112 // point. We perform both an operator-name lookup from the local 9113 // scope and an argument-dependent lookup based on the types of 9114 // the arguments. 9115 UnresolvedSet<16> Functions; 9116 OverloadedOperatorKind OverOp 9117 = BinaryOperator::getOverloadedOperator(Opc); 9118 if (S && OverOp != OO_None) 9119 LookupOverloadedOperatorName(OverOp, S, lhs->getType(), rhs->getType(), 9120 Functions); 9121 9122 // Build the (potentially-overloaded, potentially-dependent) 9123 // binary operation. 9124 return CreateOverloadedBinOp(OpLoc, Opc, Functions, lhs, rhs); 9125 } 9126 } 9127 9128 // Build a built-in binary operation. 9129 return CreateBuiltinBinOp(OpLoc, Opc, lhs, rhs); 9130} 9131 9132ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc, 9133 UnaryOperatorKind Opc, 9134 Expr *InputExpr) { 9135 ExprResult Input = Owned(InputExpr); 9136 ExprValueKind VK = VK_RValue; 9137 ExprObjectKind OK = OK_Ordinary; 9138 QualType resultType; 9139 switch (Opc) { 9140 case UO_PreInc: 9141 case UO_PreDec: 9142 case UO_PostInc: 9143 case UO_PostDec: 9144 resultType = CheckIncrementDecrementOperand(*this, Input.get(), VK, OpLoc, 9145 Opc == UO_PreInc || 9146 Opc == UO_PostInc, 9147 Opc == UO_PreInc || 9148 Opc == UO_PreDec); 9149 break; 9150 case UO_AddrOf: 9151 resultType = CheckAddressOfOperand(*this, Input.get(), OpLoc); 9152 break; 9153 case UO_Deref: { 9154 ExprResult resolved = CheckPlaceholderExpr(Input.get()); 9155 if (!resolved.isUsable()) return ExprError(); 9156 Input = move(resolved); 9157 Input = DefaultFunctionArrayLvalueConversion(Input.take()); 9158 resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc); 9159 break; 9160 } 9161 case UO_Plus: 9162 case UO_Minus: 9163 Input = UsualUnaryConversions(Input.take()); 9164 if (Input.isInvalid()) return ExprError(); 9165 resultType = Input.get()->getType(); 9166 if (resultType->isDependentType()) 9167 break; 9168 if (resultType->isArithmeticType() || // C99 6.5.3.3p1 9169 resultType->isVectorType()) 9170 break; 9171 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6-7 9172 resultType->isEnumeralType()) 9173 break; 9174 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6 9175 Opc == UO_Plus && 9176 resultType->isPointerType()) 9177 break; 9178 else if (resultType->isPlaceholderType()) { 9179 Input = CheckPlaceholderExpr(Input.take()); 9180 if (Input.isInvalid()) return ExprError(); 9181 return CreateBuiltinUnaryOp(OpLoc, Opc, Input.take()); 9182 } 9183 9184 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 9185 << resultType << Input.get()->getSourceRange()); 9186 9187 case UO_Not: // bitwise complement 9188 Input = UsualUnaryConversions(Input.take()); 9189 if (Input.isInvalid()) return ExprError(); 9190 resultType = Input.get()->getType(); 9191 if (resultType->isDependentType()) 9192 break; 9193 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension. 9194 if (resultType->isComplexType() || resultType->isComplexIntegerType()) 9195 // C99 does not support '~' for complex conjugation. 9196 Diag(OpLoc, diag::ext_integer_complement_complex) 9197 << resultType << Input.get()->getSourceRange(); 9198 else if (resultType->hasIntegerRepresentation()) 9199 break; 9200 else if (resultType->isPlaceholderType()) { 9201 Input = CheckPlaceholderExpr(Input.take()); 9202 if (Input.isInvalid()) return ExprError(); 9203 return CreateBuiltinUnaryOp(OpLoc, Opc, Input.take()); 9204 } else { 9205 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 9206 << resultType << Input.get()->getSourceRange()); 9207 } 9208 break; 9209 9210 case UO_LNot: // logical negation 9211 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5). 9212 Input = DefaultFunctionArrayLvalueConversion(Input.take()); 9213 if (Input.isInvalid()) return ExprError(); 9214 resultType = Input.get()->getType(); 9215 if (resultType->isDependentType()) 9216 break; 9217 if (resultType->isScalarType()) { 9218 // C99 6.5.3.3p1: ok, fallthrough; 9219 if (Context.getLangOptions().CPlusPlus) { 9220 // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9: 9221 // operand contextually converted to bool. 9222 Input = ImpCastExprToType(Input.take(), Context.BoolTy, 9223 ScalarTypeToBooleanCastKind(resultType)); 9224 } 9225 } else if (resultType->isPlaceholderType()) { 9226 Input = CheckPlaceholderExpr(Input.take()); 9227 if (Input.isInvalid()) return ExprError(); 9228 return CreateBuiltinUnaryOp(OpLoc, Opc, Input.take()); 9229 } else { 9230 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 9231 << resultType << Input.get()->getSourceRange()); 9232 } 9233 9234 // LNot always has type int. C99 6.5.3.3p5. 9235 // In C++, it's bool. C++ 5.3.1p8 9236 resultType = Context.getLogicalOperationType(); 9237 break; 9238 case UO_Real: 9239 case UO_Imag: 9240 resultType = CheckRealImagOperand(*this, Input, OpLoc, Opc == UO_Real); 9241 // _Real and _Imag map ordinary l-values into ordinary l-values. 9242 if (Input.isInvalid()) return ExprError(); 9243 if (Input.get()->getValueKind() != VK_RValue && 9244 Input.get()->getObjectKind() == OK_Ordinary) 9245 VK = Input.get()->getValueKind(); 9246 break; 9247 case UO_Extension: 9248 resultType = Input.get()->getType(); 9249 VK = Input.get()->getValueKind(); 9250 OK = Input.get()->getObjectKind(); 9251 break; 9252 } 9253 if (resultType.isNull() || Input.isInvalid()) 9254 return ExprError(); 9255 9256 return Owned(new (Context) UnaryOperator(Input.take(), Opc, resultType, 9257 VK, OK, OpLoc)); 9258} 9259 9260ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc, 9261 UnaryOperatorKind Opc, 9262 Expr *Input) { 9263 if (getLangOptions().CPlusPlus && Input->getType()->isOverloadableType() && 9264 UnaryOperator::getOverloadedOperator(Opc) != OO_None) { 9265 // Find all of the overloaded operators visible from this 9266 // point. We perform both an operator-name lookup from the local 9267 // scope and an argument-dependent lookup based on the types of 9268 // the arguments. 9269 UnresolvedSet<16> Functions; 9270 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc); 9271 if (S && OverOp != OO_None) 9272 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(), 9273 Functions); 9274 9275 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input); 9276 } 9277 9278 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 9279} 9280 9281// Unary Operators. 'Tok' is the token for the operator. 9282ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc, 9283 tok::TokenKind Op, Expr *Input) { 9284 return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input); 9285} 9286 9287/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo". 9288ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, 9289 LabelDecl *TheDecl) { 9290 TheDecl->setUsed(); 9291 // Create the AST node. The address of a label always has type 'void*'. 9292 return Owned(new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl, 9293 Context.getPointerType(Context.VoidTy))); 9294} 9295 9296ExprResult 9297Sema::ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, 9298 SourceLocation RPLoc) { // "({..})" 9299 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!"); 9300 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt); 9301 9302 bool isFileScope 9303 = (getCurFunctionOrMethodDecl() == 0) && (getCurBlock() == 0); 9304 if (isFileScope) 9305 return ExprError(Diag(LPLoc, diag::err_stmtexpr_file_scope)); 9306 9307 // FIXME: there are a variety of strange constraints to enforce here, for 9308 // example, it is not possible to goto into a stmt expression apparently. 9309 // More semantic analysis is needed. 9310 9311 // If there are sub stmts in the compound stmt, take the type of the last one 9312 // as the type of the stmtexpr. 9313 QualType Ty = Context.VoidTy; 9314 bool StmtExprMayBindToTemp = false; 9315 if (!Compound->body_empty()) { 9316 Stmt *LastStmt = Compound->body_back(); 9317 LabelStmt *LastLabelStmt = 0; 9318 // If LastStmt is a label, skip down through into the body. 9319 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt)) { 9320 LastLabelStmt = Label; 9321 LastStmt = Label->getSubStmt(); 9322 } 9323 if (Expr *LastE = dyn_cast<Expr>(LastStmt)) { 9324 // Do function/array conversion on the last expression, but not 9325 // lvalue-to-rvalue. However, initialize an unqualified type. 9326 ExprResult LastExpr = DefaultFunctionArrayConversion(LastE); 9327 if (LastExpr.isInvalid()) 9328 return ExprError(); 9329 Ty = LastExpr.get()->getType().getUnqualifiedType(); 9330 9331 if (!Ty->isDependentType() && !LastExpr.get()->isTypeDependent()) { 9332 LastExpr = PerformCopyInitialization( 9333 InitializedEntity::InitializeResult(LPLoc, 9334 Ty, 9335 false), 9336 SourceLocation(), 9337 LastExpr); 9338 if (LastExpr.isInvalid()) 9339 return ExprError(); 9340 if (LastExpr.get() != 0) { 9341 if (!LastLabelStmt) 9342 Compound->setLastStmt(LastExpr.take()); 9343 else 9344 LastLabelStmt->setSubStmt(LastExpr.take()); 9345 StmtExprMayBindToTemp = true; 9346 } 9347 } 9348 } 9349 } 9350 9351 // FIXME: Check that expression type is complete/non-abstract; statement 9352 // expressions are not lvalues. 9353 Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc); 9354 if (StmtExprMayBindToTemp) 9355 return MaybeBindToTemporary(ResStmtExpr); 9356 return Owned(ResStmtExpr); 9357} 9358 9359ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, 9360 TypeSourceInfo *TInfo, 9361 OffsetOfComponent *CompPtr, 9362 unsigned NumComponents, 9363 SourceLocation RParenLoc) { 9364 QualType ArgTy = TInfo->getType(); 9365 bool Dependent = ArgTy->isDependentType(); 9366 SourceRange TypeRange = TInfo->getTypeLoc().getLocalSourceRange(); 9367 9368 // We must have at least one component that refers to the type, and the first 9369 // one is known to be a field designator. Verify that the ArgTy represents 9370 // a struct/union/class. 9371 if (!Dependent && !ArgTy->isRecordType()) 9372 return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type) 9373 << ArgTy << TypeRange); 9374 9375 // Type must be complete per C99 7.17p3 because a declaring a variable 9376 // with an incomplete type would be ill-formed. 9377 if (!Dependent 9378 && RequireCompleteType(BuiltinLoc, ArgTy, 9379 PDiag(diag::err_offsetof_incomplete_type) 9380 << TypeRange)) 9381 return ExprError(); 9382 9383 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a 9384 // GCC extension, diagnose them. 9385 // FIXME: This diagnostic isn't actually visible because the location is in 9386 // a system header! 9387 if (NumComponents != 1) 9388 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator) 9389 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd); 9390 9391 bool DidWarnAboutNonPOD = false; 9392 QualType CurrentType = ArgTy; 9393 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode; 9394 llvm::SmallVector<OffsetOfNode, 4> Comps; 9395 llvm::SmallVector<Expr*, 4> Exprs; 9396 for (unsigned i = 0; i != NumComponents; ++i) { 9397 const OffsetOfComponent &OC = CompPtr[i]; 9398 if (OC.isBrackets) { 9399 // Offset of an array sub-field. TODO: Should we allow vector elements? 9400 if (!CurrentType->isDependentType()) { 9401 const ArrayType *AT = Context.getAsArrayType(CurrentType); 9402 if(!AT) 9403 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type) 9404 << CurrentType); 9405 CurrentType = AT->getElementType(); 9406 } else 9407 CurrentType = Context.DependentTy; 9408 9409 // The expression must be an integral expression. 9410 // FIXME: An integral constant expression? 9411 Expr *Idx = static_cast<Expr*>(OC.U.E); 9412 if (!Idx->isTypeDependent() && !Idx->isValueDependent() && 9413 !Idx->getType()->isIntegerType()) 9414 return ExprError(Diag(Idx->getLocStart(), 9415 diag::err_typecheck_subscript_not_integer) 9416 << Idx->getSourceRange()); 9417 9418 // Record this array index. 9419 Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd)); 9420 Exprs.push_back(Idx); 9421 continue; 9422 } 9423 9424 // Offset of a field. 9425 if (CurrentType->isDependentType()) { 9426 // We have the offset of a field, but we can't look into the dependent 9427 // type. Just record the identifier of the field. 9428 Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd)); 9429 CurrentType = Context.DependentTy; 9430 continue; 9431 } 9432 9433 // We need to have a complete type to look into. 9434 if (RequireCompleteType(OC.LocStart, CurrentType, 9435 diag::err_offsetof_incomplete_type)) 9436 return ExprError(); 9437 9438 // Look for the designated field. 9439 const RecordType *RC = CurrentType->getAs<RecordType>(); 9440 if (!RC) 9441 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type) 9442 << CurrentType); 9443 RecordDecl *RD = RC->getDecl(); 9444 9445 // C++ [lib.support.types]p5: 9446 // The macro offsetof accepts a restricted set of type arguments in this 9447 // International Standard. type shall be a POD structure or a POD union 9448 // (clause 9). 9449 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) { 9450 if (!CRD->isPOD() && !DidWarnAboutNonPOD && 9451 DiagRuntimeBehavior(BuiltinLoc, 0, 9452 PDiag(diag::warn_offsetof_non_pod_type) 9453 << SourceRange(CompPtr[0].LocStart, OC.LocEnd) 9454 << CurrentType)) 9455 DidWarnAboutNonPOD = true; 9456 } 9457 9458 // Look for the field. 9459 LookupResult R(*this, OC.U.IdentInfo, OC.LocStart, LookupMemberName); 9460 LookupQualifiedName(R, RD); 9461 FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>(); 9462 IndirectFieldDecl *IndirectMemberDecl = 0; 9463 if (!MemberDecl) { 9464 if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>())) 9465 MemberDecl = IndirectMemberDecl->getAnonField(); 9466 } 9467 9468 if (!MemberDecl) 9469 return ExprError(Diag(BuiltinLoc, diag::err_no_member) 9470 << OC.U.IdentInfo << RD << SourceRange(OC.LocStart, 9471 OC.LocEnd)); 9472 9473 // C99 7.17p3: 9474 // (If the specified member is a bit-field, the behavior is undefined.) 9475 // 9476 // We diagnose this as an error. 9477 if (MemberDecl->getBitWidth()) { 9478 Diag(OC.LocEnd, diag::err_offsetof_bitfield) 9479 << MemberDecl->getDeclName() 9480 << SourceRange(BuiltinLoc, RParenLoc); 9481 Diag(MemberDecl->getLocation(), diag::note_bitfield_decl); 9482 return ExprError(); 9483 } 9484 9485 RecordDecl *Parent = MemberDecl->getParent(); 9486 if (IndirectMemberDecl) 9487 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext()); 9488 9489 // If the member was found in a base class, introduce OffsetOfNodes for 9490 // the base class indirections. 9491 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 9492 /*DetectVirtual=*/false); 9493 if (IsDerivedFrom(CurrentType, Context.getTypeDeclType(Parent), Paths)) { 9494 CXXBasePath &Path = Paths.front(); 9495 for (CXXBasePath::iterator B = Path.begin(), BEnd = Path.end(); 9496 B != BEnd; ++B) 9497 Comps.push_back(OffsetOfNode(B->Base)); 9498 } 9499 9500 if (IndirectMemberDecl) { 9501 for (IndirectFieldDecl::chain_iterator FI = 9502 IndirectMemberDecl->chain_begin(), 9503 FEnd = IndirectMemberDecl->chain_end(); FI != FEnd; FI++) { 9504 assert(isa<FieldDecl>(*FI)); 9505 Comps.push_back(OffsetOfNode(OC.LocStart, 9506 cast<FieldDecl>(*FI), OC.LocEnd)); 9507 } 9508 } else 9509 Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd)); 9510 9511 CurrentType = MemberDecl->getType().getNonReferenceType(); 9512 } 9513 9514 return Owned(OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc, 9515 TInfo, Comps.data(), Comps.size(), 9516 Exprs.data(), Exprs.size(), RParenLoc)); 9517} 9518 9519ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S, 9520 SourceLocation BuiltinLoc, 9521 SourceLocation TypeLoc, 9522 ParsedType argty, 9523 OffsetOfComponent *CompPtr, 9524 unsigned NumComponents, 9525 SourceLocation RPLoc) { 9526 9527 TypeSourceInfo *ArgTInfo; 9528 QualType ArgTy = GetTypeFromParser(argty, &ArgTInfo); 9529 if (ArgTy.isNull()) 9530 return ExprError(); 9531 9532 if (!ArgTInfo) 9533 ArgTInfo = Context.getTrivialTypeSourceInfo(ArgTy, TypeLoc); 9534 9535 return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, CompPtr, NumComponents, 9536 RPLoc); 9537} 9538 9539 9540ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, 9541 Expr *CondExpr, 9542 Expr *LHSExpr, Expr *RHSExpr, 9543 SourceLocation RPLoc) { 9544 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)"); 9545 9546 ExprValueKind VK = VK_RValue; 9547 ExprObjectKind OK = OK_Ordinary; 9548 QualType resType; 9549 bool ValueDependent = false; 9550 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) { 9551 resType = Context.DependentTy; 9552 ValueDependent = true; 9553 } else { 9554 // The conditional expression is required to be a constant expression. 9555 llvm::APSInt condEval(32); 9556 SourceLocation ExpLoc; 9557 if (!CondExpr->isIntegerConstantExpr(condEval, Context, &ExpLoc)) 9558 return ExprError(Diag(ExpLoc, 9559 diag::err_typecheck_choose_expr_requires_constant) 9560 << CondExpr->getSourceRange()); 9561 9562 // If the condition is > zero, then the AST type is the same as the LSHExpr. 9563 Expr *ActiveExpr = condEval.getZExtValue() ? LHSExpr : RHSExpr; 9564 9565 resType = ActiveExpr->getType(); 9566 ValueDependent = ActiveExpr->isValueDependent(); 9567 VK = ActiveExpr->getValueKind(); 9568 OK = ActiveExpr->getObjectKind(); 9569 } 9570 9571 return Owned(new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, 9572 resType, VK, OK, RPLoc, 9573 resType->isDependentType(), 9574 ValueDependent)); 9575} 9576 9577//===----------------------------------------------------------------------===// 9578// Clang Extensions. 9579//===----------------------------------------------------------------------===// 9580 9581/// ActOnBlockStart - This callback is invoked when a block literal is started. 9582void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *BlockScope) { 9583 BlockDecl *Block = BlockDecl::Create(Context, CurContext, CaretLoc); 9584 PushBlockScope(BlockScope, Block); 9585 CurContext->addDecl(Block); 9586 if (BlockScope) 9587 PushDeclContext(BlockScope, Block); 9588 else 9589 CurContext = Block; 9590} 9591 9592void Sema::ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope) { 9593 assert(ParamInfo.getIdentifier()==0 && "block-id should have no identifier!"); 9594 assert(ParamInfo.getContext() == Declarator::BlockLiteralContext); 9595 BlockScopeInfo *CurBlock = getCurBlock(); 9596 9597 TypeSourceInfo *Sig = GetTypeForDeclarator(ParamInfo, CurScope); 9598 QualType T = Sig->getType(); 9599 9600 // GetTypeForDeclarator always produces a function type for a block 9601 // literal signature. Furthermore, it is always a FunctionProtoType 9602 // unless the function was written with a typedef. 9603 assert(T->isFunctionType() && 9604 "GetTypeForDeclarator made a non-function block signature"); 9605 9606 // Look for an explicit signature in that function type. 9607 FunctionProtoTypeLoc ExplicitSignature; 9608 9609 TypeLoc tmp = Sig->getTypeLoc().IgnoreParens(); 9610 if (isa<FunctionProtoTypeLoc>(tmp)) { 9611 ExplicitSignature = cast<FunctionProtoTypeLoc>(tmp); 9612 9613 // Check whether that explicit signature was synthesized by 9614 // GetTypeForDeclarator. If so, don't save that as part of the 9615 // written signature. 9616 if (ExplicitSignature.getLocalRangeBegin() == 9617 ExplicitSignature.getLocalRangeEnd()) { 9618 // This would be much cheaper if we stored TypeLocs instead of 9619 // TypeSourceInfos. 9620 TypeLoc Result = ExplicitSignature.getResultLoc(); 9621 unsigned Size = Result.getFullDataSize(); 9622 Sig = Context.CreateTypeSourceInfo(Result.getType(), Size); 9623 Sig->getTypeLoc().initializeFullCopy(Result, Size); 9624 9625 ExplicitSignature = FunctionProtoTypeLoc(); 9626 } 9627 } 9628 9629 CurBlock->TheDecl->setSignatureAsWritten(Sig); 9630 CurBlock->FunctionType = T; 9631 9632 const FunctionType *Fn = T->getAs<FunctionType>(); 9633 QualType RetTy = Fn->getResultType(); 9634 bool isVariadic = 9635 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic()); 9636 9637 CurBlock->TheDecl->setIsVariadic(isVariadic); 9638 9639 // Don't allow returning a objc interface by value. 9640 if (RetTy->isObjCObjectType()) { 9641 Diag(ParamInfo.getSourceRange().getBegin(), 9642 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy; 9643 return; 9644 } 9645 9646 // Context.DependentTy is used as a placeholder for a missing block 9647 // return type. TODO: what should we do with declarators like: 9648 // ^ * { ... } 9649 // If the answer is "apply template argument deduction".... 9650 if (RetTy != Context.DependentTy) 9651 CurBlock->ReturnType = RetTy; 9652 9653 // Push block parameters from the declarator if we had them. 9654 llvm::SmallVector<ParmVarDecl*, 8> Params; 9655 if (ExplicitSignature) { 9656 for (unsigned I = 0, E = ExplicitSignature.getNumArgs(); I != E; ++I) { 9657 ParmVarDecl *Param = ExplicitSignature.getArg(I); 9658 if (Param->getIdentifier() == 0 && 9659 !Param->isImplicit() && 9660 !Param->isInvalidDecl() && 9661 !getLangOptions().CPlusPlus) 9662 Diag(Param->getLocation(), diag::err_parameter_name_omitted); 9663 Params.push_back(Param); 9664 } 9665 9666 // Fake up parameter variables if we have a typedef, like 9667 // ^ fntype { ... } 9668 } else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) { 9669 for (FunctionProtoType::arg_type_iterator 9670 I = Fn->arg_type_begin(), E = Fn->arg_type_end(); I != E; ++I) { 9671 ParmVarDecl *Param = 9672 BuildParmVarDeclForTypedef(CurBlock->TheDecl, 9673 ParamInfo.getSourceRange().getBegin(), 9674 *I); 9675 Params.push_back(Param); 9676 } 9677 } 9678 9679 // Set the parameters on the block decl. 9680 if (!Params.empty()) { 9681 CurBlock->TheDecl->setParams(Params.data(), Params.size()); 9682 CheckParmsForFunctionDef(CurBlock->TheDecl->param_begin(), 9683 CurBlock->TheDecl->param_end(), 9684 /*CheckParameterNames=*/false); 9685 } 9686 9687 // Finally we can process decl attributes. 9688 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo); 9689 9690 if (!isVariadic && CurBlock->TheDecl->getAttr<SentinelAttr>()) { 9691 Diag(ParamInfo.getAttributes()->getLoc(), 9692 diag::warn_attribute_sentinel_not_variadic) << 1; 9693 // FIXME: remove the attribute. 9694 } 9695 9696 // Put the parameter variables in scope. We can bail out immediately 9697 // if we don't have any. 9698 if (Params.empty()) 9699 return; 9700 9701 for (BlockDecl::param_iterator AI = CurBlock->TheDecl->param_begin(), 9702 E = CurBlock->TheDecl->param_end(); AI != E; ++AI) { 9703 (*AI)->setOwningFunction(CurBlock->TheDecl); 9704 9705 // If this has an identifier, add it to the scope stack. 9706 if ((*AI)->getIdentifier()) { 9707 CheckShadow(CurBlock->TheScope, *AI); 9708 9709 PushOnScopeChains(*AI, CurBlock->TheScope); 9710 } 9711 } 9712} 9713 9714/// ActOnBlockError - If there is an error parsing a block, this callback 9715/// is invoked to pop the information about the block from the action impl. 9716void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) { 9717 // Pop off CurBlock, handle nested blocks. 9718 PopDeclContext(); 9719 PopFunctionOrBlockScope(); 9720} 9721 9722/// ActOnBlockStmtExpr - This is called when the body of a block statement 9723/// literal was successfully completed. ^(int x){...} 9724ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, 9725 Stmt *Body, Scope *CurScope) { 9726 // If blocks are disabled, emit an error. 9727 if (!LangOpts.Blocks) 9728 Diag(CaretLoc, diag::err_blocks_disable); 9729 9730 BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back()); 9731 9732 PopDeclContext(); 9733 9734 QualType RetTy = Context.VoidTy; 9735 if (!BSI->ReturnType.isNull()) 9736 RetTy = BSI->ReturnType; 9737 9738 bool NoReturn = BSI->TheDecl->getAttr<NoReturnAttr>(); 9739 QualType BlockTy; 9740 9741 // Set the captured variables on the block. 9742 BSI->TheDecl->setCaptures(Context, BSI->Captures.begin(), BSI->Captures.end(), 9743 BSI->CapturesCXXThis); 9744 9745 // If the user wrote a function type in some form, try to use that. 9746 if (!BSI->FunctionType.isNull()) { 9747 const FunctionType *FTy = BSI->FunctionType->getAs<FunctionType>(); 9748 9749 FunctionType::ExtInfo Ext = FTy->getExtInfo(); 9750 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true); 9751 9752 // Turn protoless block types into nullary block types. 9753 if (isa<FunctionNoProtoType>(FTy)) { 9754 FunctionProtoType::ExtProtoInfo EPI; 9755 EPI.ExtInfo = Ext; 9756 BlockTy = Context.getFunctionType(RetTy, 0, 0, EPI); 9757 9758 // Otherwise, if we don't need to change anything about the function type, 9759 // preserve its sugar structure. 9760 } else if (FTy->getResultType() == RetTy && 9761 (!NoReturn || FTy->getNoReturnAttr())) { 9762 BlockTy = BSI->FunctionType; 9763 9764 // Otherwise, make the minimal modifications to the function type. 9765 } else { 9766 const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy); 9767 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 9768 EPI.TypeQuals = 0; // FIXME: silently? 9769 EPI.ExtInfo = Ext; 9770 BlockTy = Context.getFunctionType(RetTy, 9771 FPT->arg_type_begin(), 9772 FPT->getNumArgs(), 9773 EPI); 9774 } 9775 9776 // If we don't have a function type, just build one from nothing. 9777 } else { 9778 FunctionProtoType::ExtProtoInfo EPI; 9779 EPI.ExtInfo = FunctionType::ExtInfo(NoReturn, false, 0, CC_Default); 9780 BlockTy = Context.getFunctionType(RetTy, 0, 0, EPI); 9781 } 9782 9783 DiagnoseUnusedParameters(BSI->TheDecl->param_begin(), 9784 BSI->TheDecl->param_end()); 9785 BlockTy = Context.getBlockPointerType(BlockTy); 9786 9787 // If needed, diagnose invalid gotos and switches in the block. 9788 if (getCurFunction()->NeedsScopeChecking() && !hasAnyErrorsInThisFunction()) 9789 DiagnoseInvalidJumps(cast<CompoundStmt>(Body)); 9790 9791 BSI->TheDecl->setBody(cast<CompoundStmt>(Body)); 9792 9793 BlockExpr *Result = new (Context) BlockExpr(BSI->TheDecl, BlockTy); 9794 9795 const AnalysisBasedWarnings::Policy &WP = AnalysisWarnings.getDefaultPolicy(); 9796 PopFunctionOrBlockScope(&WP, Result->getBlockDecl(), Result); 9797 return Owned(Result); 9798} 9799 9800ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc, 9801 Expr *expr, ParsedType type, 9802 SourceLocation RPLoc) { 9803 TypeSourceInfo *TInfo; 9804 GetTypeFromParser(type, &TInfo); 9805 return BuildVAArgExpr(BuiltinLoc, expr, TInfo, RPLoc); 9806} 9807 9808ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, 9809 Expr *E, TypeSourceInfo *TInfo, 9810 SourceLocation RPLoc) { 9811 Expr *OrigExpr = E; 9812 9813 // Get the va_list type 9814 QualType VaListType = Context.getBuiltinVaListType(); 9815 if (VaListType->isArrayType()) { 9816 // Deal with implicit array decay; for example, on x86-64, 9817 // va_list is an array, but it's supposed to decay to 9818 // a pointer for va_arg. 9819 VaListType = Context.getArrayDecayedType(VaListType); 9820 // Make sure the input expression also decays appropriately. 9821 ExprResult Result = UsualUnaryConversions(E); 9822 if (Result.isInvalid()) 9823 return ExprError(); 9824 E = Result.take(); 9825 } else { 9826 // Otherwise, the va_list argument must be an l-value because 9827 // it is modified by va_arg. 9828 if (!E->isTypeDependent() && 9829 CheckForModifiableLvalue(E, BuiltinLoc, *this)) 9830 return ExprError(); 9831 } 9832 9833 if (!E->isTypeDependent() && 9834 !Context.hasSameType(VaListType, E->getType())) { 9835 return ExprError(Diag(E->getLocStart(), 9836 diag::err_first_argument_to_va_arg_not_of_type_va_list) 9837 << OrigExpr->getType() << E->getSourceRange()); 9838 } 9839 9840 if (!TInfo->getType()->isDependentType()) { 9841 if (RequireCompleteType(TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(), 9842 PDiag(diag::err_second_parameter_to_va_arg_incomplete) 9843 << TInfo->getTypeLoc().getSourceRange())) 9844 return ExprError(); 9845 9846 if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(), 9847 TInfo->getType(), 9848 PDiag(diag::err_second_parameter_to_va_arg_abstract) 9849 << TInfo->getTypeLoc().getSourceRange())) 9850 return ExprError(); 9851 9852 if (!TInfo->getType()->isPODType()) 9853 Diag(TInfo->getTypeLoc().getBeginLoc(), 9854 diag::warn_second_parameter_to_va_arg_not_pod) 9855 << TInfo->getType() 9856 << TInfo->getTypeLoc().getSourceRange(); 9857 } 9858 9859 QualType T = TInfo->getType().getNonLValueExprType(Context); 9860 return Owned(new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T)); 9861} 9862 9863ExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) { 9864 // The type of __null will be int or long, depending on the size of 9865 // pointers on the target. 9866 QualType Ty; 9867 unsigned pw = Context.Target.getPointerWidth(0); 9868 if (pw == Context.Target.getIntWidth()) 9869 Ty = Context.IntTy; 9870 else if (pw == Context.Target.getLongWidth()) 9871 Ty = Context.LongTy; 9872 else if (pw == Context.Target.getLongLongWidth()) 9873 Ty = Context.LongLongTy; 9874 else { 9875 assert(!"I don't know size of pointer!"); 9876 Ty = Context.IntTy; 9877 } 9878 9879 return Owned(new (Context) GNUNullExpr(Ty, TokenLoc)); 9880} 9881 9882static void MakeObjCStringLiteralFixItHint(Sema& SemaRef, QualType DstType, 9883 Expr *SrcExpr, FixItHint &Hint) { 9884 if (!SemaRef.getLangOptions().ObjC1) 9885 return; 9886 9887 const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>(); 9888 if (!PT) 9889 return; 9890 9891 // Check if the destination is of type 'id'. 9892 if (!PT->isObjCIdType()) { 9893 // Check if the destination is the 'NSString' interface. 9894 const ObjCInterfaceDecl *ID = PT->getInterfaceDecl(); 9895 if (!ID || !ID->getIdentifier()->isStr("NSString")) 9896 return; 9897 } 9898 9899 // Strip off any parens and casts. 9900 StringLiteral *SL = dyn_cast<StringLiteral>(SrcExpr->IgnoreParenCasts()); 9901 if (!SL || SL->isWide()) 9902 return; 9903 9904 Hint = FixItHint::CreateInsertion(SL->getLocStart(), "@"); 9905} 9906 9907bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy, 9908 SourceLocation Loc, 9909 QualType DstType, QualType SrcType, 9910 Expr *SrcExpr, AssignmentAction Action, 9911 bool *Complained) { 9912 if (Complained) 9913 *Complained = false; 9914 9915 // Decode the result (notice that AST's are still created for extensions). 9916 bool CheckInferredResultType = false; 9917 bool isInvalid = false; 9918 unsigned DiagKind; 9919 FixItHint Hint; 9920 9921 switch (ConvTy) { 9922 default: assert(0 && "Unknown conversion type"); 9923 case Compatible: return false; 9924 case PointerToInt: 9925 DiagKind = diag::ext_typecheck_convert_pointer_int; 9926 break; 9927 case IntToPointer: 9928 DiagKind = diag::ext_typecheck_convert_int_pointer; 9929 break; 9930 case IncompatiblePointer: 9931 MakeObjCStringLiteralFixItHint(*this, DstType, SrcExpr, Hint); 9932 DiagKind = diag::ext_typecheck_convert_incompatible_pointer; 9933 CheckInferredResultType = DstType->isObjCObjectPointerType() && 9934 SrcType->isObjCObjectPointerType(); 9935 break; 9936 case IncompatiblePointerSign: 9937 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign; 9938 break; 9939 case FunctionVoidPointer: 9940 DiagKind = diag::ext_typecheck_convert_pointer_void_func; 9941 break; 9942 case IncompatiblePointerDiscardsQualifiers: { 9943 // Perform array-to-pointer decay if necessary. 9944 if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType); 9945 9946 Qualifiers lhq = SrcType->getPointeeType().getQualifiers(); 9947 Qualifiers rhq = DstType->getPointeeType().getQualifiers(); 9948 if (lhq.getAddressSpace() != rhq.getAddressSpace()) { 9949 DiagKind = diag::err_typecheck_incompatible_address_space; 9950 break; 9951 } 9952 9953 llvm_unreachable("unknown error case for discarding qualifiers!"); 9954 // fallthrough 9955 } 9956 case CompatiblePointerDiscardsQualifiers: 9957 // If the qualifiers lost were because we were applying the 9958 // (deprecated) C++ conversion from a string literal to a char* 9959 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME: 9960 // Ideally, this check would be performed in 9961 // checkPointerTypesForAssignment. However, that would require a 9962 // bit of refactoring (so that the second argument is an 9963 // expression, rather than a type), which should be done as part 9964 // of a larger effort to fix checkPointerTypesForAssignment for 9965 // C++ semantics. 9966 if (getLangOptions().CPlusPlus && 9967 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType)) 9968 return false; 9969 DiagKind = diag::ext_typecheck_convert_discards_qualifiers; 9970 break; 9971 case IncompatibleNestedPointerQualifiers: 9972 DiagKind = diag::ext_nested_pointer_qualifier_mismatch; 9973 break; 9974 case IntToBlockPointer: 9975 DiagKind = diag::err_int_to_block_pointer; 9976 break; 9977 case IncompatibleBlockPointer: 9978 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer; 9979 break; 9980 case IncompatibleObjCQualifiedId: 9981 // FIXME: Diagnose the problem in ObjCQualifiedIdTypesAreCompatible, since 9982 // it can give a more specific diagnostic. 9983 DiagKind = diag::warn_incompatible_qualified_id; 9984 break; 9985 case IncompatibleVectors: 9986 DiagKind = diag::warn_incompatible_vectors; 9987 break; 9988 case Incompatible: 9989 DiagKind = diag::err_typecheck_convert_incompatible; 9990 isInvalid = true; 9991 break; 9992 } 9993 9994 QualType FirstType, SecondType; 9995 switch (Action) { 9996 case AA_Assigning: 9997 case AA_Initializing: 9998 // The destination type comes first. 9999 FirstType = DstType; 10000 SecondType = SrcType; 10001 break; 10002 10003 case AA_Returning: 10004 case AA_Passing: 10005 case AA_Converting: 10006 case AA_Sending: 10007 case AA_Casting: 10008 // The source type comes first. 10009 FirstType = SrcType; 10010 SecondType = DstType; 10011 break; 10012 } 10013 10014 Diag(Loc, DiagKind) << FirstType << SecondType << Action 10015 << SrcExpr->getSourceRange() << Hint; 10016 if (CheckInferredResultType) 10017 EmitRelatedResultTypeNote(SrcExpr); 10018 10019 if (Complained) 10020 *Complained = true; 10021 return isInvalid; 10022} 10023 10024bool Sema::VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result){ 10025 llvm::APSInt ICEResult; 10026 if (E->isIntegerConstantExpr(ICEResult, Context)) { 10027 if (Result) 10028 *Result = ICEResult; 10029 return false; 10030 } 10031 10032 Expr::EvalResult EvalResult; 10033 10034 if (!E->Evaluate(EvalResult, Context) || !EvalResult.Val.isInt() || 10035 EvalResult.HasSideEffects) { 10036 Diag(E->getExprLoc(), diag::err_expr_not_ice) << E->getSourceRange(); 10037 10038 if (EvalResult.Diag) { 10039 // We only show the note if it's not the usual "invalid subexpression" 10040 // or if it's actually in a subexpression. 10041 if (EvalResult.Diag != diag::note_invalid_subexpr_in_ice || 10042 E->IgnoreParens() != EvalResult.DiagExpr->IgnoreParens()) 10043 Diag(EvalResult.DiagLoc, EvalResult.Diag); 10044 } 10045 10046 return true; 10047 } 10048 10049 Diag(E->getExprLoc(), diag::ext_expr_not_ice) << 10050 E->getSourceRange(); 10051 10052 if (EvalResult.Diag && 10053 Diags.getDiagnosticLevel(diag::ext_expr_not_ice, EvalResult.DiagLoc) 10054 != Diagnostic::Ignored) 10055 Diag(EvalResult.DiagLoc, EvalResult.Diag); 10056 10057 if (Result) 10058 *Result = EvalResult.Val.getInt(); 10059 return false; 10060} 10061 10062void 10063Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext) { 10064 ExprEvalContexts.push_back( 10065 ExpressionEvaluationContextRecord(NewContext, ExprTemporaries.size())); 10066} 10067 10068void 10069Sema::PopExpressionEvaluationContext() { 10070 // Pop the current expression evaluation context off the stack. 10071 ExpressionEvaluationContextRecord Rec = ExprEvalContexts.back(); 10072 ExprEvalContexts.pop_back(); 10073 10074 if (Rec.Context == PotentiallyPotentiallyEvaluated) { 10075 if (Rec.PotentiallyReferenced) { 10076 // Mark any remaining declarations in the current position of the stack 10077 // as "referenced". If they were not meant to be referenced, semantic 10078 // analysis would have eliminated them (e.g., in ActOnCXXTypeId). 10079 for (PotentiallyReferencedDecls::iterator 10080 I = Rec.PotentiallyReferenced->begin(), 10081 IEnd = Rec.PotentiallyReferenced->end(); 10082 I != IEnd; ++I) 10083 MarkDeclarationReferenced(I->first, I->second); 10084 } 10085 10086 if (Rec.PotentiallyDiagnosed) { 10087 // Emit any pending diagnostics. 10088 for (PotentiallyEmittedDiagnostics::iterator 10089 I = Rec.PotentiallyDiagnosed->begin(), 10090 IEnd = Rec.PotentiallyDiagnosed->end(); 10091 I != IEnd; ++I) 10092 Diag(I->first, I->second); 10093 } 10094 } 10095 10096 // When are coming out of an unevaluated context, clear out any 10097 // temporaries that we may have created as part of the evaluation of 10098 // the expression in that context: they aren't relevant because they 10099 // will never be constructed. 10100 if (Rec.Context == Unevaluated && 10101 ExprTemporaries.size() > Rec.NumTemporaries) 10102 ExprTemporaries.erase(ExprTemporaries.begin() + Rec.NumTemporaries, 10103 ExprTemporaries.end()); 10104 10105 // Destroy the popped expression evaluation record. 10106 Rec.Destroy(); 10107} 10108 10109/// \brief Note that the given declaration was referenced in the source code. 10110/// 10111/// This routine should be invoke whenever a given declaration is referenced 10112/// in the source code, and where that reference occurred. If this declaration 10113/// reference means that the the declaration is used (C++ [basic.def.odr]p2, 10114/// C99 6.9p3), then the declaration will be marked as used. 10115/// 10116/// \param Loc the location where the declaration was referenced. 10117/// 10118/// \param D the declaration that has been referenced by the source code. 10119void Sema::MarkDeclarationReferenced(SourceLocation Loc, Decl *D) { 10120 assert(D && "No declaration?"); 10121 10122 D->setReferenced(); 10123 10124 if (D->isUsed(false)) 10125 return; 10126 10127 // Mark a parameter or variable declaration "used", regardless of whether we're in a 10128 // template or not. The reason for this is that unevaluated expressions 10129 // (e.g. (void)sizeof()) constitute a use for warning purposes (-Wunused-variables and 10130 // -Wunused-parameters) 10131 if (isa<ParmVarDecl>(D) || 10132 (isa<VarDecl>(D) && D->getDeclContext()->isFunctionOrMethod())) { 10133 D->setUsed(); 10134 return; 10135 } 10136 10137 if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) 10138 return; 10139 10140 // Do not mark anything as "used" within a dependent context; wait for 10141 // an instantiation. 10142 if (CurContext->isDependentContext()) 10143 return; 10144 10145 switch (ExprEvalContexts.back().Context) { 10146 case Unevaluated: 10147 // We are in an expression that is not potentially evaluated; do nothing. 10148 return; 10149 10150 case PotentiallyEvaluated: 10151 // We are in a potentially-evaluated expression, so this declaration is 10152 // "used"; handle this below. 10153 break; 10154 10155 case PotentiallyPotentiallyEvaluated: 10156 // We are in an expression that may be potentially evaluated; queue this 10157 // declaration reference until we know whether the expression is 10158 // potentially evaluated. 10159 ExprEvalContexts.back().addReferencedDecl(Loc, D); 10160 return; 10161 10162 case PotentiallyEvaluatedIfUsed: 10163 // Referenced declarations will only be used if the construct in the 10164 // containing expression is used. 10165 return; 10166 } 10167 10168 // Note that this declaration has been used. 10169 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) { 10170 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor()) { 10171 if (Constructor->isTrivial()) 10172 return; 10173 if (!Constructor->isUsed(false)) 10174 DefineImplicitDefaultConstructor(Loc, Constructor); 10175 } else if (Constructor->isDefaulted() && 10176 Constructor->isCopyConstructor()) { 10177 if (!Constructor->isUsed(false)) 10178 DefineImplicitCopyConstructor(Loc, Constructor); 10179 } 10180 10181 MarkVTableUsed(Loc, Constructor->getParent()); 10182 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) { 10183 if (Destructor->isDefaulted() && !Destructor->isUsed(false)) 10184 DefineImplicitDestructor(Loc, Destructor); 10185 if (Destructor->isVirtual()) 10186 MarkVTableUsed(Loc, Destructor->getParent()); 10187 } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D)) { 10188 if (MethodDecl->isDefaulted() && MethodDecl->isOverloadedOperator() && 10189 MethodDecl->getOverloadedOperator() == OO_Equal) { 10190 if (!MethodDecl->isUsed(false)) 10191 DefineImplicitCopyAssignment(Loc, MethodDecl); 10192 } else if (MethodDecl->isVirtual()) 10193 MarkVTableUsed(Loc, MethodDecl->getParent()); 10194 } 10195 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 10196 // Recursive functions should be marked when used from another function. 10197 if (CurContext == Function) return; 10198 10199 // Implicit instantiation of function templates and member functions of 10200 // class templates. 10201 if (Function->isImplicitlyInstantiable()) { 10202 bool AlreadyInstantiated = false; 10203 if (FunctionTemplateSpecializationInfo *SpecInfo 10204 = Function->getTemplateSpecializationInfo()) { 10205 if (SpecInfo->getPointOfInstantiation().isInvalid()) 10206 SpecInfo->setPointOfInstantiation(Loc); 10207 else if (SpecInfo->getTemplateSpecializationKind() 10208 == TSK_ImplicitInstantiation) 10209 AlreadyInstantiated = true; 10210 } else if (MemberSpecializationInfo *MSInfo 10211 = Function->getMemberSpecializationInfo()) { 10212 if (MSInfo->getPointOfInstantiation().isInvalid()) 10213 MSInfo->setPointOfInstantiation(Loc); 10214 else if (MSInfo->getTemplateSpecializationKind() 10215 == TSK_ImplicitInstantiation) 10216 AlreadyInstantiated = true; 10217 } 10218 10219 if (!AlreadyInstantiated) { 10220 if (isa<CXXRecordDecl>(Function->getDeclContext()) && 10221 cast<CXXRecordDecl>(Function->getDeclContext())->isLocalClass()) 10222 PendingLocalImplicitInstantiations.push_back(std::make_pair(Function, 10223 Loc)); 10224 else 10225 PendingInstantiations.push_back(std::make_pair(Function, Loc)); 10226 } 10227 } else { 10228 // Walk redefinitions, as some of them may be instantiable. 10229 for (FunctionDecl::redecl_iterator i(Function->redecls_begin()), 10230 e(Function->redecls_end()); i != e; ++i) { 10231 if (!i->isUsed(false) && i->isImplicitlyInstantiable()) 10232 MarkDeclarationReferenced(Loc, *i); 10233 } 10234 } 10235 10236 // Keep track of used but undefined functions. 10237 if (!Function->isPure() && !Function->hasBody() && 10238 Function->getLinkage() != ExternalLinkage) { 10239 SourceLocation &old = UndefinedInternals[Function->getCanonicalDecl()]; 10240 if (old.isInvalid()) old = Loc; 10241 } 10242 10243 Function->setUsed(true); 10244 return; 10245 } 10246 10247 if (VarDecl *Var = dyn_cast<VarDecl>(D)) { 10248 // Implicit instantiation of static data members of class templates. 10249 if (Var->isStaticDataMember() && 10250 Var->getInstantiatedFromStaticDataMember()) { 10251 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo(); 10252 assert(MSInfo && "Missing member specialization information?"); 10253 if (MSInfo->getPointOfInstantiation().isInvalid() && 10254 MSInfo->getTemplateSpecializationKind()== TSK_ImplicitInstantiation) { 10255 MSInfo->setPointOfInstantiation(Loc); 10256 // This is a modification of an existing AST node. Notify listeners. 10257 if (ASTMutationListener *L = getASTMutationListener()) 10258 L->StaticDataMemberInstantiated(Var); 10259 PendingInstantiations.push_back(std::make_pair(Var, Loc)); 10260 } 10261 } 10262 10263 // Keep track of used but undefined variables. We make a hole in 10264 // the warning for static const data members with in-line 10265 // initializers. 10266 if (Var->hasDefinition() == VarDecl::DeclarationOnly 10267 && Var->getLinkage() != ExternalLinkage 10268 && !(Var->isStaticDataMember() && Var->hasInit())) { 10269 SourceLocation &old = UndefinedInternals[Var->getCanonicalDecl()]; 10270 if (old.isInvalid()) old = Loc; 10271 } 10272 10273 D->setUsed(true); 10274 return; 10275 } 10276} 10277 10278namespace { 10279 // Mark all of the declarations referenced 10280 // FIXME: Not fully implemented yet! We need to have a better understanding 10281 // of when we're entering 10282 class MarkReferencedDecls : public RecursiveASTVisitor<MarkReferencedDecls> { 10283 Sema &S; 10284 SourceLocation Loc; 10285 10286 public: 10287 typedef RecursiveASTVisitor<MarkReferencedDecls> Inherited; 10288 10289 MarkReferencedDecls(Sema &S, SourceLocation Loc) : S(S), Loc(Loc) { } 10290 10291 bool TraverseTemplateArgument(const TemplateArgument &Arg); 10292 bool TraverseRecordType(RecordType *T); 10293 }; 10294} 10295 10296bool MarkReferencedDecls::TraverseTemplateArgument( 10297 const TemplateArgument &Arg) { 10298 if (Arg.getKind() == TemplateArgument::Declaration) { 10299 S.MarkDeclarationReferenced(Loc, Arg.getAsDecl()); 10300 } 10301 10302 return Inherited::TraverseTemplateArgument(Arg); 10303} 10304 10305bool MarkReferencedDecls::TraverseRecordType(RecordType *T) { 10306 if (ClassTemplateSpecializationDecl *Spec 10307 = dyn_cast<ClassTemplateSpecializationDecl>(T->getDecl())) { 10308 const TemplateArgumentList &Args = Spec->getTemplateArgs(); 10309 return TraverseTemplateArguments(Args.data(), Args.size()); 10310 } 10311 10312 return true; 10313} 10314 10315void Sema::MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T) { 10316 MarkReferencedDecls Marker(*this, Loc); 10317 Marker.TraverseType(Context.getCanonicalType(T)); 10318} 10319 10320namespace { 10321 /// \brief Helper class that marks all of the declarations referenced by 10322 /// potentially-evaluated subexpressions as "referenced". 10323 class EvaluatedExprMarker : public EvaluatedExprVisitor<EvaluatedExprMarker> { 10324 Sema &S; 10325 10326 public: 10327 typedef EvaluatedExprVisitor<EvaluatedExprMarker> Inherited; 10328 10329 explicit EvaluatedExprMarker(Sema &S) : Inherited(S.Context), S(S) { } 10330 10331 void VisitDeclRefExpr(DeclRefExpr *E) { 10332 S.MarkDeclarationReferenced(E->getLocation(), E->getDecl()); 10333 } 10334 10335 void VisitMemberExpr(MemberExpr *E) { 10336 S.MarkDeclarationReferenced(E->getMemberLoc(), E->getMemberDecl()); 10337 Inherited::VisitMemberExpr(E); 10338 } 10339 10340 void VisitCXXNewExpr(CXXNewExpr *E) { 10341 if (E->getConstructor()) 10342 S.MarkDeclarationReferenced(E->getLocStart(), E->getConstructor()); 10343 if (E->getOperatorNew()) 10344 S.MarkDeclarationReferenced(E->getLocStart(), E->getOperatorNew()); 10345 if (E->getOperatorDelete()) 10346 S.MarkDeclarationReferenced(E->getLocStart(), E->getOperatorDelete()); 10347 Inherited::VisitCXXNewExpr(E); 10348 } 10349 10350 void VisitCXXDeleteExpr(CXXDeleteExpr *E) { 10351 if (E->getOperatorDelete()) 10352 S.MarkDeclarationReferenced(E->getLocStart(), E->getOperatorDelete()); 10353 QualType Destroyed = S.Context.getBaseElementType(E->getDestroyedType()); 10354 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) { 10355 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl()); 10356 S.MarkDeclarationReferenced(E->getLocStart(), 10357 S.LookupDestructor(Record)); 10358 } 10359 10360 Inherited::VisitCXXDeleteExpr(E); 10361 } 10362 10363 void VisitCXXConstructExpr(CXXConstructExpr *E) { 10364 S.MarkDeclarationReferenced(E->getLocStart(), E->getConstructor()); 10365 Inherited::VisitCXXConstructExpr(E); 10366 } 10367 10368 void VisitBlockDeclRefExpr(BlockDeclRefExpr *E) { 10369 S.MarkDeclarationReferenced(E->getLocation(), E->getDecl()); 10370 } 10371 10372 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 10373 Visit(E->getExpr()); 10374 } 10375 }; 10376} 10377 10378/// \brief Mark any declarations that appear within this expression or any 10379/// potentially-evaluated subexpressions as "referenced". 10380void Sema::MarkDeclarationsReferencedInExpr(Expr *E) { 10381 EvaluatedExprMarker(*this).Visit(E); 10382} 10383 10384/// \brief Emit a diagnostic that describes an effect on the run-time behavior 10385/// of the program being compiled. 10386/// 10387/// This routine emits the given diagnostic when the code currently being 10388/// type-checked is "potentially evaluated", meaning that there is a 10389/// possibility that the code will actually be executable. Code in sizeof() 10390/// expressions, code used only during overload resolution, etc., are not 10391/// potentially evaluated. This routine will suppress such diagnostics or, 10392/// in the absolutely nutty case of potentially potentially evaluated 10393/// expressions (C++ typeid), queue the diagnostic to potentially emit it 10394/// later. 10395/// 10396/// This routine should be used for all diagnostics that describe the run-time 10397/// behavior of a program, such as passing a non-POD value through an ellipsis. 10398/// Failure to do so will likely result in spurious diagnostics or failures 10399/// during overload resolution or within sizeof/alignof/typeof/typeid. 10400bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *stmt, 10401 const PartialDiagnostic &PD) { 10402 switch (ExprEvalContexts.back().Context ) { 10403 case Unevaluated: 10404 // The argument will never be evaluated, so don't complain. 10405 break; 10406 10407 case PotentiallyEvaluated: 10408 case PotentiallyEvaluatedIfUsed: 10409 if (stmt && getCurFunctionOrMethodDecl()) { 10410 FunctionScopes.back()->PossiblyUnreachableDiags. 10411 push_back(sema::PossiblyUnreachableDiag(PD, Loc, stmt)); 10412 } 10413 else 10414 Diag(Loc, PD); 10415 10416 return true; 10417 10418 case PotentiallyPotentiallyEvaluated: 10419 ExprEvalContexts.back().addDiagnostic(Loc, PD); 10420 break; 10421 } 10422 10423 return false; 10424} 10425 10426bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc, 10427 CallExpr *CE, FunctionDecl *FD) { 10428 if (ReturnType->isVoidType() || !ReturnType->isIncompleteType()) 10429 return false; 10430 10431 PartialDiagnostic Note = 10432 FD ? PDiag(diag::note_function_with_incomplete_return_type_declared_here) 10433 << FD->getDeclName() : PDiag(); 10434 SourceLocation NoteLoc = FD ? FD->getLocation() : SourceLocation(); 10435 10436 if (RequireCompleteType(Loc, ReturnType, 10437 FD ? 10438 PDiag(diag::err_call_function_incomplete_return) 10439 << CE->getSourceRange() << FD->getDeclName() : 10440 PDiag(diag::err_call_incomplete_return) 10441 << CE->getSourceRange(), 10442 std::make_pair(NoteLoc, Note))) 10443 return true; 10444 10445 return false; 10446} 10447 10448// Diagnose the s/=/==/ and s/\|=/!=/ typos. Note that adding parentheses 10449// will prevent this condition from triggering, which is what we want. 10450void Sema::DiagnoseAssignmentAsCondition(Expr *E) { 10451 SourceLocation Loc; 10452 10453 unsigned diagnostic = diag::warn_condition_is_assignment; 10454 bool IsOrAssign = false; 10455 10456 if (isa<BinaryOperator>(E)) { 10457 BinaryOperator *Op = cast<BinaryOperator>(E); 10458 if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign) 10459 return; 10460 10461 IsOrAssign = Op->getOpcode() == BO_OrAssign; 10462 10463 // Greylist some idioms by putting them into a warning subcategory. 10464 if (ObjCMessageExpr *ME 10465 = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) { 10466 Selector Sel = ME->getSelector(); 10467 10468 // self = [<foo> init...] 10469 if (isSelfExpr(Op->getLHS()) && Sel.getNameForSlot(0).startswith("init")) 10470 diagnostic = diag::warn_condition_is_idiomatic_assignment; 10471 10472 // <foo> = [<bar> nextObject] 10473 else if (Sel.isUnarySelector() && Sel.getNameForSlot(0) == "nextObject") 10474 diagnostic = diag::warn_condition_is_idiomatic_assignment; 10475 } 10476 10477 Loc = Op->getOperatorLoc(); 10478 } else if (isa<CXXOperatorCallExpr>(E)) { 10479 CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(E); 10480 if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual) 10481 return; 10482 10483 IsOrAssign = Op->getOperator() == OO_PipeEqual; 10484 Loc = Op->getOperatorLoc(); 10485 } else { 10486 // Not an assignment. 10487 return; 10488 } 10489 10490 Diag(Loc, diagnostic) << E->getSourceRange(); 10491 10492 SourceLocation Open = E->getSourceRange().getBegin(); 10493 SourceLocation Close = PP.getLocForEndOfToken(E->getSourceRange().getEnd()); 10494 Diag(Loc, diag::note_condition_assign_silence) 10495 << FixItHint::CreateInsertion(Open, "(") 10496 << FixItHint::CreateInsertion(Close, ")"); 10497 10498 if (IsOrAssign) 10499 Diag(Loc, diag::note_condition_or_assign_to_comparison) 10500 << FixItHint::CreateReplacement(Loc, "!="); 10501 else 10502 Diag(Loc, diag::note_condition_assign_to_comparison) 10503 << FixItHint::CreateReplacement(Loc, "=="); 10504} 10505 10506/// \brief Redundant parentheses over an equality comparison can indicate 10507/// that the user intended an assignment used as condition. 10508void Sema::DiagnoseEqualityWithExtraParens(ParenExpr *parenE) { 10509 // Don't warn if the parens came from a macro. 10510 SourceLocation parenLoc = parenE->getLocStart(); 10511 if (parenLoc.isInvalid() || parenLoc.isMacroID()) 10512 return; 10513 // Don't warn for dependent expressions. 10514 if (parenE->isTypeDependent()) 10515 return; 10516 10517 Expr *E = parenE->IgnoreParens(); 10518 10519 if (BinaryOperator *opE = dyn_cast<BinaryOperator>(E)) 10520 if (opE->getOpcode() == BO_EQ && 10521 opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context) 10522 == Expr::MLV_Valid) { 10523 SourceLocation Loc = opE->getOperatorLoc(); 10524 10525 Diag(Loc, diag::warn_equality_with_extra_parens) << E->getSourceRange(); 10526 Diag(Loc, diag::note_equality_comparison_silence) 10527 << FixItHint::CreateRemoval(parenE->getSourceRange().getBegin()) 10528 << FixItHint::CreateRemoval(parenE->getSourceRange().getEnd()); 10529 Diag(Loc, diag::note_equality_comparison_to_assign) 10530 << FixItHint::CreateReplacement(Loc, "="); 10531 } 10532} 10533 10534ExprResult Sema::CheckBooleanCondition(Expr *E, SourceLocation Loc) { 10535 DiagnoseAssignmentAsCondition(E); 10536 if (ParenExpr *parenE = dyn_cast<ParenExpr>(E)) 10537 DiagnoseEqualityWithExtraParens(parenE); 10538 10539 ExprResult result = CheckPlaceholderExpr(E); 10540 if (result.isInvalid()) return ExprError(); 10541 E = result.take(); 10542 10543 if (!E->isTypeDependent()) { 10544 if (getLangOptions().CPlusPlus) 10545 return CheckCXXBooleanCondition(E); // C++ 6.4p4 10546 10547 ExprResult ERes = DefaultFunctionArrayLvalueConversion(E); 10548 if (ERes.isInvalid()) 10549 return ExprError(); 10550 E = ERes.take(); 10551 10552 QualType T = E->getType(); 10553 if (!T->isScalarType()) { // C99 6.8.4.1p1 10554 Diag(Loc, diag::err_typecheck_statement_requires_scalar) 10555 << T << E->getSourceRange(); 10556 return ExprError(); 10557 } 10558 } 10559 10560 return Owned(E); 10561} 10562 10563ExprResult Sema::ActOnBooleanCondition(Scope *S, SourceLocation Loc, 10564 Expr *Sub) { 10565 if (!Sub) 10566 return ExprError(); 10567 10568 return CheckBooleanCondition(Sub, Loc); 10569} 10570 10571namespace { 10572 /// A visitor for rebuilding a call to an __unknown_any expression 10573 /// to have an appropriate type. 10574 struct RebuildUnknownAnyFunction 10575 : StmtVisitor<RebuildUnknownAnyFunction, ExprResult> { 10576 10577 Sema &S; 10578 10579 RebuildUnknownAnyFunction(Sema &S) : S(S) {} 10580 10581 ExprResult VisitStmt(Stmt *S) { 10582 llvm_unreachable("unexpected statement!"); 10583 return ExprError(); 10584 } 10585 10586 ExprResult VisitExpr(Expr *expr) { 10587 S.Diag(expr->getExprLoc(), diag::err_unsupported_unknown_any_call) 10588 << expr->getSourceRange(); 10589 return ExprError(); 10590 } 10591 10592 /// Rebuild an expression which simply semantically wraps another 10593 /// expression which it shares the type and value kind of. 10594 template <class T> ExprResult rebuildSugarExpr(T *expr) { 10595 ExprResult subResult = Visit(expr->getSubExpr()); 10596 if (subResult.isInvalid()) return ExprError(); 10597 10598 Expr *subExpr = subResult.take(); 10599 expr->setSubExpr(subExpr); 10600 expr->setType(subExpr->getType()); 10601 expr->setValueKind(subExpr->getValueKind()); 10602 assert(expr->getObjectKind() == OK_Ordinary); 10603 return expr; 10604 } 10605 10606 ExprResult VisitParenExpr(ParenExpr *paren) { 10607 return rebuildSugarExpr(paren); 10608 } 10609 10610 ExprResult VisitUnaryExtension(UnaryOperator *op) { 10611 return rebuildSugarExpr(op); 10612 } 10613 10614 ExprResult VisitUnaryAddrOf(UnaryOperator *op) { 10615 ExprResult subResult = Visit(op->getSubExpr()); 10616 if (subResult.isInvalid()) return ExprError(); 10617 10618 Expr *subExpr = subResult.take(); 10619 op->setSubExpr(subExpr); 10620 op->setType(S.Context.getPointerType(subExpr->getType())); 10621 assert(op->getValueKind() == VK_RValue); 10622 assert(op->getObjectKind() == OK_Ordinary); 10623 return op; 10624 } 10625 10626 ExprResult resolveDecl(Expr *expr, ValueDecl *decl) { 10627 if (!isa<FunctionDecl>(decl)) return VisitExpr(expr); 10628 10629 expr->setType(decl->getType()); 10630 10631 assert(expr->getValueKind() == VK_RValue); 10632 if (S.getLangOptions().CPlusPlus && 10633 !(isa<CXXMethodDecl>(decl) && 10634 cast<CXXMethodDecl>(decl)->isInstance())) 10635 expr->setValueKind(VK_LValue); 10636 10637 return expr; 10638 } 10639 10640 ExprResult VisitMemberExpr(MemberExpr *mem) { 10641 return resolveDecl(mem, mem->getMemberDecl()); 10642 } 10643 10644 ExprResult VisitDeclRefExpr(DeclRefExpr *ref) { 10645 return resolveDecl(ref, ref->getDecl()); 10646 } 10647 }; 10648} 10649 10650/// Given a function expression of unknown-any type, try to rebuild it 10651/// to have a function type. 10652static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn) { 10653 ExprResult result = RebuildUnknownAnyFunction(S).Visit(fn); 10654 if (result.isInvalid()) return ExprError(); 10655 return S.DefaultFunctionArrayConversion(result.take()); 10656} 10657 10658namespace { 10659 /// A visitor for rebuilding an expression of type __unknown_anytype 10660 /// into one which resolves the type directly on the referring 10661 /// expression. Strict preservation of the original source 10662 /// structure is not a goal. 10663 struct RebuildUnknownAnyExpr 10664 : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> { 10665 10666 Sema &S; 10667 10668 /// The current destination type. 10669 QualType DestType; 10670 10671 RebuildUnknownAnyExpr(Sema &S, QualType castType) 10672 : S(S), DestType(castType) {} 10673 10674 ExprResult VisitStmt(Stmt *S) { 10675 llvm_unreachable("unexpected statement!"); 10676 return ExprError(); 10677 } 10678 10679 ExprResult VisitExpr(Expr *expr) { 10680 S.Diag(expr->getExprLoc(), diag::err_unsupported_unknown_any_expr) 10681 << expr->getSourceRange(); 10682 return ExprError(); 10683 } 10684 10685 ExprResult VisitCallExpr(CallExpr *call); 10686 ExprResult VisitObjCMessageExpr(ObjCMessageExpr *message); 10687 10688 /// Rebuild an expression which simply semantically wraps another 10689 /// expression which it shares the type and value kind of. 10690 template <class T> ExprResult rebuildSugarExpr(T *expr) { 10691 ExprResult subResult = Visit(expr->getSubExpr()); 10692 if (subResult.isInvalid()) return ExprError(); 10693 Expr *subExpr = subResult.take(); 10694 expr->setSubExpr(subExpr); 10695 expr->setType(subExpr->getType()); 10696 expr->setValueKind(subExpr->getValueKind()); 10697 assert(expr->getObjectKind() == OK_Ordinary); 10698 return expr; 10699 } 10700 10701 ExprResult VisitParenExpr(ParenExpr *paren) { 10702 return rebuildSugarExpr(paren); 10703 } 10704 10705 ExprResult VisitUnaryExtension(UnaryOperator *op) { 10706 return rebuildSugarExpr(op); 10707 } 10708 10709 ExprResult VisitUnaryAddrOf(UnaryOperator *op) { 10710 const PointerType *ptr = DestType->getAs<PointerType>(); 10711 if (!ptr) { 10712 S.Diag(op->getOperatorLoc(), diag::err_unknown_any_addrof) 10713 << op->getSourceRange(); 10714 return ExprError(); 10715 } 10716 assert(op->getValueKind() == VK_RValue); 10717 assert(op->getObjectKind() == OK_Ordinary); 10718 op->setType(DestType); 10719 10720 // Build the sub-expression as if it were an object of the pointee type. 10721 DestType = ptr->getPointeeType(); 10722 ExprResult subResult = Visit(op->getSubExpr()); 10723 if (subResult.isInvalid()) return ExprError(); 10724 op->setSubExpr(subResult.take()); 10725 return op; 10726 } 10727 10728 ExprResult VisitImplicitCastExpr(ImplicitCastExpr *ice); 10729 10730 ExprResult resolveDecl(Expr *expr, ValueDecl *decl); 10731 10732 ExprResult VisitMemberExpr(MemberExpr *mem) { 10733 return resolveDecl(mem, mem->getMemberDecl()); 10734 } 10735 10736 ExprResult VisitDeclRefExpr(DeclRefExpr *ref) { 10737 return resolveDecl(ref, ref->getDecl()); 10738 } 10739 }; 10740} 10741 10742/// Rebuilds a call expression which yielded __unknown_anytype. 10743ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *call) { 10744 Expr *callee = call->getCallee(); 10745 10746 enum FnKind { 10747 FK_MemberFunction, 10748 FK_FunctionPointer, 10749 FK_BlockPointer 10750 }; 10751 10752 FnKind kind; 10753 QualType type = callee->getType(); 10754 if (type == S.Context.BoundMemberTy) { 10755 assert(isa<CXXMemberCallExpr>(call) || isa<CXXOperatorCallExpr>(call)); 10756 kind = FK_MemberFunction; 10757 type = Expr::findBoundMemberType(callee); 10758 } else if (const PointerType *ptr = type->getAs<PointerType>()) { 10759 type = ptr->getPointeeType(); 10760 kind = FK_FunctionPointer; 10761 } else { 10762 type = type->castAs<BlockPointerType>()->getPointeeType(); 10763 kind = FK_BlockPointer; 10764 } 10765 const FunctionType *fnType = type->castAs<FunctionType>(); 10766 10767 // Verify that this is a legal result type of a function. 10768 if (DestType->isArrayType() || DestType->isFunctionType()) { 10769 unsigned diagID = diag::err_func_returning_array_function; 10770 if (kind == FK_BlockPointer) 10771 diagID = diag::err_block_returning_array_function; 10772 10773 S.Diag(call->getExprLoc(), diagID) 10774 << DestType->isFunctionType() << DestType; 10775 return ExprError(); 10776 } 10777 10778 // Otherwise, go ahead and set DestType as the call's result. 10779 call->setType(DestType.getNonLValueExprType(S.Context)); 10780 call->setValueKind(Expr::getValueKindForType(DestType)); 10781 assert(call->getObjectKind() == OK_Ordinary); 10782 10783 // Rebuild the function type, replacing the result type with DestType. 10784 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) 10785 DestType = S.Context.getFunctionType(DestType, 10786 proto->arg_type_begin(), 10787 proto->getNumArgs(), 10788 proto->getExtProtoInfo()); 10789 else 10790 DestType = S.Context.getFunctionNoProtoType(DestType, 10791 fnType->getExtInfo()); 10792 10793 // Rebuild the appropriate pointer-to-function type. 10794 switch (kind) { 10795 case FK_MemberFunction: 10796 // Nothing to do. 10797 break; 10798 10799 case FK_FunctionPointer: 10800 DestType = S.Context.getPointerType(DestType); 10801 break; 10802 10803 case FK_BlockPointer: 10804 DestType = S.Context.getBlockPointerType(DestType); 10805 break; 10806 } 10807 10808 // Finally, we can recurse. 10809 ExprResult calleeResult = Visit(callee); 10810 if (!calleeResult.isUsable()) return ExprError(); 10811 call->setCallee(calleeResult.take()); 10812 10813 // Bind a temporary if necessary. 10814 return S.MaybeBindToTemporary(call); 10815} 10816 10817ExprResult RebuildUnknownAnyExpr::VisitObjCMessageExpr(ObjCMessageExpr *msg) { 10818 ObjCMethodDecl *method = msg->getMethodDecl(); 10819 assert(method && "__unknown_anytype message without result type?"); 10820 10821 // Verify that this is a legal result type of a call. 10822 if (DestType->isArrayType() || DestType->isFunctionType()) { 10823 S.Diag(msg->getExprLoc(), diag::err_func_returning_array_function) 10824 << DestType->isFunctionType() << DestType; 10825 return ExprError(); 10826 } 10827 10828 assert(method->getResultType() == S.Context.UnknownAnyTy); 10829 method->setResultType(DestType); 10830 10831 // Change the type of the message. 10832 msg->setType(DestType.getNonReferenceType()); 10833 msg->setValueKind(Expr::getValueKindForType(DestType)); 10834 10835 return S.MaybeBindToTemporary(msg); 10836} 10837 10838ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *ice) { 10839 // The only case we should ever see here is a function-to-pointer decay. 10840 assert(ice->getCastKind() == CK_FunctionToPointerDecay); 10841 assert(ice->getValueKind() == VK_RValue); 10842 assert(ice->getObjectKind() == OK_Ordinary); 10843 10844 ice->setType(DestType); 10845 10846 // Rebuild the sub-expression as the pointee (function) type. 10847 DestType = DestType->castAs<PointerType>()->getPointeeType(); 10848 10849 ExprResult result = Visit(ice->getSubExpr()); 10850 if (!result.isUsable()) return ExprError(); 10851 10852 ice->setSubExpr(result.take()); 10853 return S.Owned(ice); 10854} 10855 10856ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *expr, ValueDecl *decl) { 10857 ExprValueKind valueKind = VK_LValue; 10858 QualType type = DestType; 10859 10860 // We know how to make this work for certain kinds of decls: 10861 10862 // - functions 10863 if (FunctionDecl *fn = dyn_cast<FunctionDecl>(decl)) { 10864 // This is true because FunctionDecls must always have function 10865 // type, so we can't be resolving the entire thing at once. 10866 assert(type->isFunctionType()); 10867 10868 if (CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(fn)) 10869 if (method->isInstance()) { 10870 valueKind = VK_RValue; 10871 type = S.Context.BoundMemberTy; 10872 } 10873 10874 // Function references aren't l-values in C. 10875 if (!S.getLangOptions().CPlusPlus) 10876 valueKind = VK_RValue; 10877 10878 // - variables 10879 } else if (isa<VarDecl>(decl)) { 10880 if (const ReferenceType *refTy = type->getAs<ReferenceType>()) { 10881 type = refTy->getPointeeType(); 10882 } else if (type->isFunctionType()) { 10883 S.Diag(expr->getExprLoc(), diag::err_unknown_any_var_function_type) 10884 << decl << expr->getSourceRange(); 10885 return ExprError(); 10886 } 10887 10888 // - nothing else 10889 } else { 10890 S.Diag(expr->getExprLoc(), diag::err_unsupported_unknown_any_decl) 10891 << decl << expr->getSourceRange(); 10892 return ExprError(); 10893 } 10894 10895 decl->setType(DestType); 10896 expr->setType(type); 10897 expr->setValueKind(valueKind); 10898 return S.Owned(expr); 10899} 10900 10901/// Check a cast of an unknown-any type. We intentionally only 10902/// trigger this for C-style casts. 10903ExprResult Sema::checkUnknownAnyCast(SourceRange typeRange, QualType castType, 10904 Expr *castExpr, CastKind &castKind, 10905 ExprValueKind &VK, CXXCastPath &path) { 10906 // Rewrite the casted expression from scratch. 10907 ExprResult result = RebuildUnknownAnyExpr(*this, castType).Visit(castExpr); 10908 if (!result.isUsable()) return ExprError(); 10909 10910 castExpr = result.take(); 10911 VK = castExpr->getValueKind(); 10912 castKind = CK_NoOp; 10913 10914 return castExpr; 10915} 10916 10917static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *e) { 10918 Expr *orig = e; 10919 unsigned diagID = diag::err_uncasted_use_of_unknown_any; 10920 while (true) { 10921 e = e->IgnoreParenImpCasts(); 10922 if (CallExpr *call = dyn_cast<CallExpr>(e)) { 10923 e = call->getCallee(); 10924 diagID = diag::err_uncasted_call_of_unknown_any; 10925 } else { 10926 break; 10927 } 10928 } 10929 10930 SourceLocation loc; 10931 NamedDecl *d; 10932 if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e)) { 10933 loc = ref->getLocation(); 10934 d = ref->getDecl(); 10935 } else if (MemberExpr *mem = dyn_cast<MemberExpr>(e)) { 10936 loc = mem->getMemberLoc(); 10937 d = mem->getMemberDecl(); 10938 } else if (ObjCMessageExpr *msg = dyn_cast<ObjCMessageExpr>(e)) { 10939 diagID = diag::err_uncasted_call_of_unknown_any; 10940 loc = msg->getSelectorLoc(); 10941 d = msg->getMethodDecl(); 10942 assert(d && "unknown method returning __unknown_any?"); 10943 } else { 10944 S.Diag(e->getExprLoc(), diag::err_unsupported_unknown_any_expr) 10945 << e->getSourceRange(); 10946 return ExprError(); 10947 } 10948 10949 S.Diag(loc, diagID) << d << orig->getSourceRange(); 10950 10951 // Never recoverable. 10952 return ExprError(); 10953} 10954 10955/// Check for operands with placeholder types and complain if found. 10956/// Returns true if there was an error and no recovery was possible. 10957ExprResult Sema::CheckPlaceholderExpr(Expr *E) { 10958 // Placeholder types are always *exactly* the appropriate builtin type. 10959 QualType type = E->getType(); 10960 10961 // Overloaded expressions. 10962 if (type == Context.OverloadTy) 10963 return ResolveAndFixSingleFunctionTemplateSpecialization(E, false, true, 10964 E->getSourceRange(), 10965 QualType(), 10966 diag::err_ovl_unresolvable); 10967 10968 // Bound member functions. 10969 if (type == Context.BoundMemberTy) { 10970 Diag(E->getLocStart(), diag::err_invalid_use_of_bound_member_func) 10971 << E->getSourceRange(); 10972 return ExprError(); 10973 } 10974 10975 // Expressions of unknown type. 10976 if (type == Context.UnknownAnyTy) 10977 return diagnoseUnknownAnyExpr(*this, E); 10978 10979 assert(!type->isPlaceholderType()); 10980 return Owned(E); 10981} 10982 10983bool Sema::CheckCaseExpression(Expr *expr) { 10984 if (expr->isTypeDependent()) 10985 return true; 10986 if (expr->isValueDependent() || expr->isIntegerConstantExpr(Context)) 10987 return expr->getType()->isIntegralOrEnumerationType(); 10988 return false; 10989} 10990