SemaStmt.cpp revision 263508
1//===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===// 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 statements. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Sema/SemaInternal.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/ASTDiagnostic.h" 17#include "clang/AST/CharUnits.h" 18#include "clang/AST/DeclObjC.h" 19#include "clang/AST/EvaluatedExprVisitor.h" 20#include "clang/AST/ExprCXX.h" 21#include "clang/AST/ExprObjC.h" 22#include "clang/AST/StmtCXX.h" 23#include "clang/AST/StmtObjC.h" 24#include "clang/AST/TypeLoc.h" 25#include "clang/Lex/Preprocessor.h" 26#include "clang/Sema/Initialization.h" 27#include "clang/Sema/Lookup.h" 28#include "clang/Sema/Scope.h" 29#include "clang/Sema/ScopeInfo.h" 30#include "llvm/ADT/ArrayRef.h" 31#include "llvm/ADT/STLExtras.h" 32#include "llvm/ADT/SmallPtrSet.h" 33#include "llvm/ADT/SmallString.h" 34#include "llvm/ADT/SmallVector.h" 35using namespace clang; 36using namespace sema; 37 38StmtResult Sema::ActOnExprStmt(ExprResult FE) { 39 if (FE.isInvalid()) 40 return StmtError(); 41 42 FE = ActOnFinishFullExpr(FE.get(), FE.get()->getExprLoc(), 43 /*DiscardedValue*/ true); 44 if (FE.isInvalid()) 45 return StmtError(); 46 47 // C99 6.8.3p2: The expression in an expression statement is evaluated as a 48 // void expression for its side effects. Conversion to void allows any 49 // operand, even incomplete types. 50 51 // Same thing in for stmt first clause (when expr) and third clause. 52 return Owned(static_cast<Stmt*>(FE.take())); 53} 54 55 56StmtResult Sema::ActOnExprStmtError() { 57 DiscardCleanupsInEvaluationContext(); 58 return StmtError(); 59} 60 61StmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc, 62 bool HasLeadingEmptyMacro) { 63 return Owned(new (Context) NullStmt(SemiLoc, HasLeadingEmptyMacro)); 64} 65 66StmtResult Sema::ActOnDeclStmt(DeclGroupPtrTy dg, SourceLocation StartLoc, 67 SourceLocation EndLoc) { 68 DeclGroupRef DG = dg.get(); 69 70 // If we have an invalid decl, just return an error. 71 if (DG.isNull()) return StmtError(); 72 73 return Owned(new (Context) DeclStmt(DG, StartLoc, EndLoc)); 74} 75 76void Sema::ActOnForEachDeclStmt(DeclGroupPtrTy dg) { 77 DeclGroupRef DG = dg.get(); 78 79 // If we don't have a declaration, or we have an invalid declaration, 80 // just return. 81 if (DG.isNull() || !DG.isSingleDecl()) 82 return; 83 84 Decl *decl = DG.getSingleDecl(); 85 if (!decl || decl->isInvalidDecl()) 86 return; 87 88 // Only variable declarations are permitted. 89 VarDecl *var = dyn_cast<VarDecl>(decl); 90 if (!var) { 91 Diag(decl->getLocation(), diag::err_non_variable_decl_in_for); 92 decl->setInvalidDecl(); 93 return; 94 } 95 96 // foreach variables are never actually initialized in the way that 97 // the parser came up with. 98 var->setInit(0); 99 100 // In ARC, we don't need to retain the iteration variable of a fast 101 // enumeration loop. Rather than actually trying to catch that 102 // during declaration processing, we remove the consequences here. 103 if (getLangOpts().ObjCAutoRefCount) { 104 QualType type = var->getType(); 105 106 // Only do this if we inferred the lifetime. Inferred lifetime 107 // will show up as a local qualifier because explicit lifetime 108 // should have shown up as an AttributedType instead. 109 if (type.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong) { 110 // Add 'const' and mark the variable as pseudo-strong. 111 var->setType(type.withConst()); 112 var->setARCPseudoStrong(true); 113 } 114 } 115} 116 117/// \brief Diagnose unused '==' and '!=' as likely typos for '=' or '|='. 118/// 119/// Adding a cast to void (or other expression wrappers) will prevent the 120/// warning from firing. 121static bool DiagnoseUnusedComparison(Sema &S, const Expr *E) { 122 SourceLocation Loc; 123 bool IsNotEqual, CanAssign; 124 125 if (const BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) { 126 if (Op->getOpcode() != BO_EQ && Op->getOpcode() != BO_NE) 127 return false; 128 129 Loc = Op->getOperatorLoc(); 130 IsNotEqual = Op->getOpcode() == BO_NE; 131 CanAssign = Op->getLHS()->IgnoreParenImpCasts()->isLValue(); 132 } else if (const CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) { 133 if (Op->getOperator() != OO_EqualEqual && 134 Op->getOperator() != OO_ExclaimEqual) 135 return false; 136 137 Loc = Op->getOperatorLoc(); 138 IsNotEqual = Op->getOperator() == OO_ExclaimEqual; 139 CanAssign = Op->getArg(0)->IgnoreParenImpCasts()->isLValue(); 140 } else { 141 // Not a typo-prone comparison. 142 return false; 143 } 144 145 // Suppress warnings when the operator, suspicious as it may be, comes from 146 // a macro expansion. 147 if (S.SourceMgr.isMacroBodyExpansion(Loc)) 148 return false; 149 150 S.Diag(Loc, diag::warn_unused_comparison) 151 << (unsigned)IsNotEqual << E->getSourceRange(); 152 153 // If the LHS is a plausible entity to assign to, provide a fixit hint to 154 // correct common typos. 155 if (CanAssign) { 156 if (IsNotEqual) 157 S.Diag(Loc, diag::note_inequality_comparison_to_or_assign) 158 << FixItHint::CreateReplacement(Loc, "|="); 159 else 160 S.Diag(Loc, diag::note_equality_comparison_to_assign) 161 << FixItHint::CreateReplacement(Loc, "="); 162 } 163 164 return true; 165} 166 167void Sema::DiagnoseUnusedExprResult(const Stmt *S) { 168 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) 169 return DiagnoseUnusedExprResult(Label->getSubStmt()); 170 171 const Expr *E = dyn_cast_or_null<Expr>(S); 172 if (!E) 173 return; 174 SourceLocation ExprLoc = E->IgnoreParens()->getExprLoc(); 175 // In most cases, we don't want to warn if the expression is written in a 176 // macro body, or if the macro comes from a system header. If the offending 177 // expression is a call to a function with the warn_unused_result attribute, 178 // we warn no matter the location. Because of the order in which the various 179 // checks need to happen, we factor out the macro-related test here. 180 bool ShouldSuppress = 181 SourceMgr.isMacroBodyExpansion(ExprLoc) || 182 SourceMgr.isInSystemMacro(ExprLoc); 183 184 const Expr *WarnExpr; 185 SourceLocation Loc; 186 SourceRange R1, R2; 187 if (!E->isUnusedResultAWarning(WarnExpr, Loc, R1, R2, Context)) 188 return; 189 190 // If this is a GNU statement expression expanded from a macro, it is probably 191 // unused because it is a function-like macro that can be used as either an 192 // expression or statement. Don't warn, because it is almost certainly a 193 // false positive. 194 if (isa<StmtExpr>(E) && Loc.isMacroID()) 195 return; 196 197 // Okay, we have an unused result. Depending on what the base expression is, 198 // we might want to make a more specific diagnostic. Check for one of these 199 // cases now. 200 unsigned DiagID = diag::warn_unused_expr; 201 if (const ExprWithCleanups *Temps = dyn_cast<ExprWithCleanups>(E)) 202 E = Temps->getSubExpr(); 203 if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E)) 204 E = TempExpr->getSubExpr(); 205 206 if (DiagnoseUnusedComparison(*this, E)) 207 return; 208 209 E = WarnExpr; 210 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) { 211 if (E->getType()->isVoidType()) 212 return; 213 214 // If the callee has attribute pure, const, or warn_unused_result, warn with 215 // a more specific message to make it clear what is happening. If the call 216 // is written in a macro body, only warn if it has the warn_unused_result 217 // attribute. 218 if (const Decl *FD = CE->getCalleeDecl()) { 219 if (FD->getAttr<WarnUnusedResultAttr>()) { 220 Diag(Loc, diag::warn_unused_result) << R1 << R2; 221 return; 222 } 223 if (ShouldSuppress) 224 return; 225 if (FD->getAttr<PureAttr>()) { 226 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure"; 227 return; 228 } 229 if (FD->getAttr<ConstAttr>()) { 230 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const"; 231 return; 232 } 233 } 234 } else if (ShouldSuppress) 235 return; 236 237 if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) { 238 if (getLangOpts().ObjCAutoRefCount && ME->isDelegateInitCall()) { 239 Diag(Loc, diag::err_arc_unused_init_message) << R1; 240 return; 241 } 242 const ObjCMethodDecl *MD = ME->getMethodDecl(); 243 if (MD && MD->getAttr<WarnUnusedResultAttr>()) { 244 Diag(Loc, diag::warn_unused_result) << R1 << R2; 245 return; 246 } 247 } else if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) { 248 const Expr *Source = POE->getSyntacticForm(); 249 if (isa<ObjCSubscriptRefExpr>(Source)) 250 DiagID = diag::warn_unused_container_subscript_expr; 251 else 252 DiagID = diag::warn_unused_property_expr; 253 } else if (const CXXFunctionalCastExpr *FC 254 = dyn_cast<CXXFunctionalCastExpr>(E)) { 255 if (isa<CXXConstructExpr>(FC->getSubExpr()) || 256 isa<CXXTemporaryObjectExpr>(FC->getSubExpr())) 257 return; 258 } 259 // Diagnose "(void*) blah" as a typo for "(void) blah". 260 else if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(E)) { 261 TypeSourceInfo *TI = CE->getTypeInfoAsWritten(); 262 QualType T = TI->getType(); 263 264 // We really do want to use the non-canonical type here. 265 if (T == Context.VoidPtrTy) { 266 PointerTypeLoc TL = TI->getTypeLoc().castAs<PointerTypeLoc>(); 267 268 Diag(Loc, diag::warn_unused_voidptr) 269 << FixItHint::CreateRemoval(TL.getStarLoc()); 270 return; 271 } 272 } 273 274 if (E->isGLValue() && E->getType().isVolatileQualified()) { 275 Diag(Loc, diag::warn_unused_volatile) << R1 << R2; 276 return; 277 } 278 279 DiagRuntimeBehavior(Loc, 0, PDiag(DiagID) << R1 << R2); 280} 281 282void Sema::ActOnStartOfCompoundStmt() { 283 PushCompoundScope(); 284} 285 286void Sema::ActOnFinishOfCompoundStmt() { 287 PopCompoundScope(); 288} 289 290sema::CompoundScopeInfo &Sema::getCurCompoundScope() const { 291 return getCurFunction()->CompoundScopes.back(); 292} 293 294StmtResult Sema::ActOnCompoundStmt(SourceLocation L, SourceLocation R, 295 ArrayRef<Stmt *> Elts, bool isStmtExpr) { 296 const unsigned NumElts = Elts.size(); 297 298 // If we're in C89 mode, check that we don't have any decls after stmts. If 299 // so, emit an extension diagnostic. 300 if (!getLangOpts().C99 && !getLangOpts().CPlusPlus) { 301 // Note that __extension__ can be around a decl. 302 unsigned i = 0; 303 // Skip over all declarations. 304 for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i) 305 /*empty*/; 306 307 // We found the end of the list or a statement. Scan for another declstmt. 308 for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i) 309 /*empty*/; 310 311 if (i != NumElts) { 312 Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin(); 313 Diag(D->getLocation(), diag::ext_mixed_decls_code); 314 } 315 } 316 // Warn about unused expressions in statements. 317 for (unsigned i = 0; i != NumElts; ++i) { 318 // Ignore statements that are last in a statement expression. 319 if (isStmtExpr && i == NumElts - 1) 320 continue; 321 322 DiagnoseUnusedExprResult(Elts[i]); 323 } 324 325 // Check for suspicious empty body (null statement) in `for' and `while' 326 // statements. Don't do anything for template instantiations, this just adds 327 // noise. 328 if (NumElts != 0 && !CurrentInstantiationScope && 329 getCurCompoundScope().HasEmptyLoopBodies) { 330 for (unsigned i = 0; i != NumElts - 1; ++i) 331 DiagnoseEmptyLoopBody(Elts[i], Elts[i + 1]); 332 } 333 334 return Owned(new (Context) CompoundStmt(Context, Elts, L, R)); 335} 336 337StmtResult 338Sema::ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal, 339 SourceLocation DotDotDotLoc, Expr *RHSVal, 340 SourceLocation ColonLoc) { 341 assert((LHSVal != 0) && "missing expression in case statement"); 342 343 if (getCurFunction()->SwitchStack.empty()) { 344 Diag(CaseLoc, diag::err_case_not_in_switch); 345 return StmtError(); 346 } 347 348 if (!getLangOpts().CPlusPlus11) { 349 // C99 6.8.4.2p3: The expression shall be an integer constant. 350 // However, GCC allows any evaluatable integer expression. 351 if (!LHSVal->isTypeDependent() && !LHSVal->isValueDependent()) { 352 LHSVal = VerifyIntegerConstantExpression(LHSVal).take(); 353 if (!LHSVal) 354 return StmtError(); 355 } 356 357 // GCC extension: The expression shall be an integer constant. 358 359 if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent()) { 360 RHSVal = VerifyIntegerConstantExpression(RHSVal).take(); 361 // Recover from an error by just forgetting about it. 362 } 363 } 364 365 LHSVal = ActOnFinishFullExpr(LHSVal, LHSVal->getExprLoc(), false, 366 getLangOpts().CPlusPlus11).take(); 367 if (RHSVal) 368 RHSVal = ActOnFinishFullExpr(RHSVal, RHSVal->getExprLoc(), false, 369 getLangOpts().CPlusPlus11).take(); 370 371 CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc, 372 ColonLoc); 373 getCurFunction()->SwitchStack.back()->addSwitchCase(CS); 374 return Owned(CS); 375} 376 377/// ActOnCaseStmtBody - This installs a statement as the body of a case. 378void Sema::ActOnCaseStmtBody(Stmt *caseStmt, Stmt *SubStmt) { 379 DiagnoseUnusedExprResult(SubStmt); 380 381 CaseStmt *CS = static_cast<CaseStmt*>(caseStmt); 382 CS->setSubStmt(SubStmt); 383} 384 385StmtResult 386Sema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc, 387 Stmt *SubStmt, Scope *CurScope) { 388 DiagnoseUnusedExprResult(SubStmt); 389 390 if (getCurFunction()->SwitchStack.empty()) { 391 Diag(DefaultLoc, diag::err_default_not_in_switch); 392 return Owned(SubStmt); 393 } 394 395 DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt); 396 getCurFunction()->SwitchStack.back()->addSwitchCase(DS); 397 return Owned(DS); 398} 399 400StmtResult 401Sema::ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl, 402 SourceLocation ColonLoc, Stmt *SubStmt) { 403 // If the label was multiply defined, reject it now. 404 if (TheDecl->getStmt()) { 405 Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->getDeclName(); 406 Diag(TheDecl->getLocation(), diag::note_previous_definition); 407 return Owned(SubStmt); 408 } 409 410 // Otherwise, things are good. Fill in the declaration and return it. 411 LabelStmt *LS = new (Context) LabelStmt(IdentLoc, TheDecl, SubStmt); 412 TheDecl->setStmt(LS); 413 if (!TheDecl->isGnuLocal()) { 414 TheDecl->setLocStart(IdentLoc); 415 TheDecl->setLocation(IdentLoc); 416 } 417 return Owned(LS); 418} 419 420StmtResult Sema::ActOnAttributedStmt(SourceLocation AttrLoc, 421 ArrayRef<const Attr*> Attrs, 422 Stmt *SubStmt) { 423 // Fill in the declaration and return it. 424 AttributedStmt *LS = AttributedStmt::Create(Context, AttrLoc, Attrs, SubStmt); 425 return Owned(LS); 426} 427 428StmtResult 429Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, Decl *CondVar, 430 Stmt *thenStmt, SourceLocation ElseLoc, 431 Stmt *elseStmt) { 432 // If the condition was invalid, discard the if statement. We could recover 433 // better by replacing it with a valid expr, but don't do that yet. 434 if (!CondVal.get() && !CondVar) { 435 getCurFunction()->setHasDroppedStmt(); 436 return StmtError(); 437 } 438 439 ExprResult CondResult(CondVal.release()); 440 441 VarDecl *ConditionVar = 0; 442 if (CondVar) { 443 ConditionVar = cast<VarDecl>(CondVar); 444 CondResult = CheckConditionVariable(ConditionVar, IfLoc, true); 445 if (CondResult.isInvalid()) 446 return StmtError(); 447 } 448 Expr *ConditionExpr = CondResult.takeAs<Expr>(); 449 if (!ConditionExpr) 450 return StmtError(); 451 452 DiagnoseUnusedExprResult(thenStmt); 453 454 if (!elseStmt) { 455 DiagnoseEmptyStmtBody(ConditionExpr->getLocEnd(), thenStmt, 456 diag::warn_empty_if_body); 457 } 458 459 DiagnoseUnusedExprResult(elseStmt); 460 461 return Owned(new (Context) IfStmt(Context, IfLoc, ConditionVar, ConditionExpr, 462 thenStmt, ElseLoc, elseStmt)); 463} 464 465/// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have 466/// the specified width and sign. If an overflow occurs, detect it and emit 467/// the specified diagnostic. 468void Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val, 469 unsigned NewWidth, bool NewSign, 470 SourceLocation Loc, 471 unsigned DiagID) { 472 // Perform a conversion to the promoted condition type if needed. 473 if (NewWidth > Val.getBitWidth()) { 474 // If this is an extension, just do it. 475 Val = Val.extend(NewWidth); 476 Val.setIsSigned(NewSign); 477 478 // If the input was signed and negative and the output is 479 // unsigned, don't bother to warn: this is implementation-defined 480 // behavior. 481 // FIXME: Introduce a second, default-ignored warning for this case? 482 } else if (NewWidth < Val.getBitWidth()) { 483 // If this is a truncation, check for overflow. 484 llvm::APSInt ConvVal(Val); 485 ConvVal = ConvVal.trunc(NewWidth); 486 ConvVal.setIsSigned(NewSign); 487 ConvVal = ConvVal.extend(Val.getBitWidth()); 488 ConvVal.setIsSigned(Val.isSigned()); 489 if (ConvVal != Val) 490 Diag(Loc, DiagID) << Val.toString(10) << ConvVal.toString(10); 491 492 // Regardless of whether a diagnostic was emitted, really do the 493 // truncation. 494 Val = Val.trunc(NewWidth); 495 Val.setIsSigned(NewSign); 496 } else if (NewSign != Val.isSigned()) { 497 // Convert the sign to match the sign of the condition. This can cause 498 // overflow as well: unsigned(INTMIN) 499 // We don't diagnose this overflow, because it is implementation-defined 500 // behavior. 501 // FIXME: Introduce a second, default-ignored warning for this case? 502 llvm::APSInt OldVal(Val); 503 Val.setIsSigned(NewSign); 504 } 505} 506 507namespace { 508 struct CaseCompareFunctor { 509 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS, 510 const llvm::APSInt &RHS) { 511 return LHS.first < RHS; 512 } 513 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS, 514 const std::pair<llvm::APSInt, CaseStmt*> &RHS) { 515 return LHS.first < RHS.first; 516 } 517 bool operator()(const llvm::APSInt &LHS, 518 const std::pair<llvm::APSInt, CaseStmt*> &RHS) { 519 return LHS < RHS.first; 520 } 521 }; 522} 523 524/// CmpCaseVals - Comparison predicate for sorting case values. 525/// 526static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs, 527 const std::pair<llvm::APSInt, CaseStmt*>& rhs) { 528 if (lhs.first < rhs.first) 529 return true; 530 531 if (lhs.first == rhs.first && 532 lhs.second->getCaseLoc().getRawEncoding() 533 < rhs.second->getCaseLoc().getRawEncoding()) 534 return true; 535 return false; 536} 537 538/// CmpEnumVals - Comparison predicate for sorting enumeration values. 539/// 540static bool CmpEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs, 541 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs) 542{ 543 return lhs.first < rhs.first; 544} 545 546/// EqEnumVals - Comparison preficate for uniqing enumeration values. 547/// 548static bool EqEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs, 549 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs) 550{ 551 return lhs.first == rhs.first; 552} 553 554/// GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of 555/// potentially integral-promoted expression @p expr. 556static QualType GetTypeBeforeIntegralPromotion(Expr *&expr) { 557 if (ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(expr)) 558 expr = cleanups->getSubExpr(); 559 while (ImplicitCastExpr *impcast = dyn_cast<ImplicitCastExpr>(expr)) { 560 if (impcast->getCastKind() != CK_IntegralCast) break; 561 expr = impcast->getSubExpr(); 562 } 563 return expr->getType(); 564} 565 566StmtResult 567Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, Expr *Cond, 568 Decl *CondVar) { 569 ExprResult CondResult; 570 571 VarDecl *ConditionVar = 0; 572 if (CondVar) { 573 ConditionVar = cast<VarDecl>(CondVar); 574 CondResult = CheckConditionVariable(ConditionVar, SourceLocation(), false); 575 if (CondResult.isInvalid()) 576 return StmtError(); 577 578 Cond = CondResult.release(); 579 } 580 581 if (!Cond) 582 return StmtError(); 583 584 class SwitchConvertDiagnoser : public ICEConvertDiagnoser { 585 Expr *Cond; 586 587 public: 588 SwitchConvertDiagnoser(Expr *Cond) 589 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/true, false, true), 590 Cond(Cond) {} 591 592 virtual SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc, 593 QualType T) { 594 return S.Diag(Loc, diag::err_typecheck_statement_requires_integer) << T; 595 } 596 597 virtual SemaDiagnosticBuilder diagnoseIncomplete( 598 Sema &S, SourceLocation Loc, QualType T) { 599 return S.Diag(Loc, diag::err_switch_incomplete_class_type) 600 << T << Cond->getSourceRange(); 601 } 602 603 virtual SemaDiagnosticBuilder diagnoseExplicitConv( 604 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) { 605 return S.Diag(Loc, diag::err_switch_explicit_conversion) << T << ConvTy; 606 } 607 608 virtual SemaDiagnosticBuilder noteExplicitConv( 609 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) { 610 return S.Diag(Conv->getLocation(), diag::note_switch_conversion) 611 << ConvTy->isEnumeralType() << ConvTy; 612 } 613 614 virtual SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, 615 QualType T) { 616 return S.Diag(Loc, diag::err_switch_multiple_conversions) << T; 617 } 618 619 virtual SemaDiagnosticBuilder noteAmbiguous( 620 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) { 621 return S.Diag(Conv->getLocation(), diag::note_switch_conversion) 622 << ConvTy->isEnumeralType() << ConvTy; 623 } 624 625 virtual SemaDiagnosticBuilder diagnoseConversion( 626 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) { 627 llvm_unreachable("conversion functions are permitted"); 628 } 629 } SwitchDiagnoser(Cond); 630 631 CondResult = 632 PerformContextualImplicitConversion(SwitchLoc, Cond, SwitchDiagnoser); 633 if (CondResult.isInvalid()) return StmtError(); 634 Cond = CondResult.take(); 635 636 // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr. 637 CondResult = UsualUnaryConversions(Cond); 638 if (CondResult.isInvalid()) return StmtError(); 639 Cond = CondResult.take(); 640 641 if (!CondVar) { 642 CondResult = ActOnFinishFullExpr(Cond, SwitchLoc); 643 if (CondResult.isInvalid()) 644 return StmtError(); 645 Cond = CondResult.take(); 646 } 647 648 getCurFunction()->setHasBranchIntoScope(); 649 650 SwitchStmt *SS = new (Context) SwitchStmt(Context, ConditionVar, Cond); 651 getCurFunction()->SwitchStack.push_back(SS); 652 return Owned(SS); 653} 654 655static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned) { 656 if (Val.getBitWidth() < BitWidth) 657 Val = Val.extend(BitWidth); 658 else if (Val.getBitWidth() > BitWidth) 659 Val = Val.trunc(BitWidth); 660 Val.setIsSigned(IsSigned); 661} 662 663StmtResult 664Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch, 665 Stmt *BodyStmt) { 666 SwitchStmt *SS = cast<SwitchStmt>(Switch); 667 assert(SS == getCurFunction()->SwitchStack.back() && 668 "switch stack missing push/pop!"); 669 670 SS->setBody(BodyStmt, SwitchLoc); 671 getCurFunction()->SwitchStack.pop_back(); 672 673 Expr *CondExpr = SS->getCond(); 674 if (!CondExpr) return StmtError(); 675 676 QualType CondType = CondExpr->getType(); 677 678 Expr *CondExprBeforePromotion = CondExpr; 679 QualType CondTypeBeforePromotion = 680 GetTypeBeforeIntegralPromotion(CondExprBeforePromotion); 681 682 // C++ 6.4.2.p2: 683 // Integral promotions are performed (on the switch condition). 684 // 685 // A case value unrepresentable by the original switch condition 686 // type (before the promotion) doesn't make sense, even when it can 687 // be represented by the promoted type. Therefore we need to find 688 // the pre-promotion type of the switch condition. 689 if (!CondExpr->isTypeDependent()) { 690 // We have already converted the expression to an integral or enumeration 691 // type, when we started the switch statement. If we don't have an 692 // appropriate type now, just return an error. 693 if (!CondType->isIntegralOrEnumerationType()) 694 return StmtError(); 695 696 if (CondExpr->isKnownToHaveBooleanValue()) { 697 // switch(bool_expr) {...} is often a programmer error, e.g. 698 // switch(n && mask) { ... } // Doh - should be "n & mask". 699 // One can always use an if statement instead of switch(bool_expr). 700 Diag(SwitchLoc, diag::warn_bool_switch_condition) 701 << CondExpr->getSourceRange(); 702 } 703 } 704 705 // Get the bitwidth of the switched-on value before promotions. We must 706 // convert the integer case values to this width before comparison. 707 bool HasDependentValue 708 = CondExpr->isTypeDependent() || CondExpr->isValueDependent(); 709 unsigned CondWidth 710 = HasDependentValue ? 0 : Context.getIntWidth(CondTypeBeforePromotion); 711 bool CondIsSigned 712 = CondTypeBeforePromotion->isSignedIntegerOrEnumerationType(); 713 714 // Accumulate all of the case values in a vector so that we can sort them 715 // and detect duplicates. This vector contains the APInt for the case after 716 // it has been converted to the condition type. 717 typedef SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy; 718 CaseValsTy CaseVals; 719 720 // Keep track of any GNU case ranges we see. The APSInt is the low value. 721 typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy; 722 CaseRangesTy CaseRanges; 723 724 DefaultStmt *TheDefaultStmt = 0; 725 726 bool CaseListIsErroneous = false; 727 728 for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue; 729 SC = SC->getNextSwitchCase()) { 730 731 if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) { 732 if (TheDefaultStmt) { 733 Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined); 734 Diag(TheDefaultStmt->getDefaultLoc(), diag::note_duplicate_case_prev); 735 736 // FIXME: Remove the default statement from the switch block so that 737 // we'll return a valid AST. This requires recursing down the AST and 738 // finding it, not something we are set up to do right now. For now, 739 // just lop the entire switch stmt out of the AST. 740 CaseListIsErroneous = true; 741 } 742 TheDefaultStmt = DS; 743 744 } else { 745 CaseStmt *CS = cast<CaseStmt>(SC); 746 747 Expr *Lo = CS->getLHS(); 748 749 if (Lo->isTypeDependent() || Lo->isValueDependent()) { 750 HasDependentValue = true; 751 break; 752 } 753 754 llvm::APSInt LoVal; 755 756 if (getLangOpts().CPlusPlus11) { 757 // C++11 [stmt.switch]p2: the constant-expression shall be a converted 758 // constant expression of the promoted type of the switch condition. 759 ExprResult ConvLo = 760 CheckConvertedConstantExpression(Lo, CondType, LoVal, CCEK_CaseValue); 761 if (ConvLo.isInvalid()) { 762 CaseListIsErroneous = true; 763 continue; 764 } 765 Lo = ConvLo.take(); 766 } else { 767 // We already verified that the expression has a i-c-e value (C99 768 // 6.8.4.2p3) - get that value now. 769 LoVal = Lo->EvaluateKnownConstInt(Context); 770 771 // If the LHS is not the same type as the condition, insert an implicit 772 // cast. 773 Lo = DefaultLvalueConversion(Lo).take(); 774 Lo = ImpCastExprToType(Lo, CondType, CK_IntegralCast).take(); 775 } 776 777 // Convert the value to the same width/sign as the condition had prior to 778 // integral promotions. 779 // 780 // FIXME: This causes us to reject valid code: 781 // switch ((char)c) { case 256: case 0: return 0; } 782 // Here we claim there is a duplicated condition value, but there is not. 783 ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned, 784 Lo->getLocStart(), 785 diag::warn_case_value_overflow); 786 787 CS->setLHS(Lo); 788 789 // If this is a case range, remember it in CaseRanges, otherwise CaseVals. 790 if (CS->getRHS()) { 791 if (CS->getRHS()->isTypeDependent() || 792 CS->getRHS()->isValueDependent()) { 793 HasDependentValue = true; 794 break; 795 } 796 CaseRanges.push_back(std::make_pair(LoVal, CS)); 797 } else 798 CaseVals.push_back(std::make_pair(LoVal, CS)); 799 } 800 } 801 802 if (!HasDependentValue) { 803 // If we don't have a default statement, check whether the 804 // condition is constant. 805 llvm::APSInt ConstantCondValue; 806 bool HasConstantCond = false; 807 if (!HasDependentValue && !TheDefaultStmt) { 808 HasConstantCond 809 = CondExprBeforePromotion->EvaluateAsInt(ConstantCondValue, Context, 810 Expr::SE_AllowSideEffects); 811 assert(!HasConstantCond || 812 (ConstantCondValue.getBitWidth() == CondWidth && 813 ConstantCondValue.isSigned() == CondIsSigned)); 814 } 815 bool ShouldCheckConstantCond = HasConstantCond; 816 817 // Sort all the scalar case values so we can easily detect duplicates. 818 std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals); 819 820 if (!CaseVals.empty()) { 821 for (unsigned i = 0, e = CaseVals.size(); i != e; ++i) { 822 if (ShouldCheckConstantCond && 823 CaseVals[i].first == ConstantCondValue) 824 ShouldCheckConstantCond = false; 825 826 if (i != 0 && CaseVals[i].first == CaseVals[i-1].first) { 827 // If we have a duplicate, report it. 828 // First, determine if either case value has a name 829 StringRef PrevString, CurrString; 830 Expr *PrevCase = CaseVals[i-1].second->getLHS()->IgnoreParenCasts(); 831 Expr *CurrCase = CaseVals[i].second->getLHS()->IgnoreParenCasts(); 832 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(PrevCase)) { 833 PrevString = DeclRef->getDecl()->getName(); 834 } 835 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(CurrCase)) { 836 CurrString = DeclRef->getDecl()->getName(); 837 } 838 SmallString<16> CaseValStr; 839 CaseVals[i-1].first.toString(CaseValStr); 840 841 if (PrevString == CurrString) 842 Diag(CaseVals[i].second->getLHS()->getLocStart(), 843 diag::err_duplicate_case) << 844 (PrevString.empty() ? CaseValStr.str() : PrevString); 845 else 846 Diag(CaseVals[i].second->getLHS()->getLocStart(), 847 diag::err_duplicate_case_differing_expr) << 848 (PrevString.empty() ? CaseValStr.str() : PrevString) << 849 (CurrString.empty() ? CaseValStr.str() : CurrString) << 850 CaseValStr; 851 852 Diag(CaseVals[i-1].second->getLHS()->getLocStart(), 853 diag::note_duplicate_case_prev); 854 // FIXME: We really want to remove the bogus case stmt from the 855 // substmt, but we have no way to do this right now. 856 CaseListIsErroneous = true; 857 } 858 } 859 } 860 861 // Detect duplicate case ranges, which usually don't exist at all in 862 // the first place. 863 if (!CaseRanges.empty()) { 864 // Sort all the case ranges by their low value so we can easily detect 865 // overlaps between ranges. 866 std::stable_sort(CaseRanges.begin(), CaseRanges.end()); 867 868 // Scan the ranges, computing the high values and removing empty ranges. 869 std::vector<llvm::APSInt> HiVals; 870 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) { 871 llvm::APSInt &LoVal = CaseRanges[i].first; 872 CaseStmt *CR = CaseRanges[i].second; 873 Expr *Hi = CR->getRHS(); 874 llvm::APSInt HiVal; 875 876 if (getLangOpts().CPlusPlus11) { 877 // C++11 [stmt.switch]p2: the constant-expression shall be a converted 878 // constant expression of the promoted type of the switch condition. 879 ExprResult ConvHi = 880 CheckConvertedConstantExpression(Hi, CondType, HiVal, 881 CCEK_CaseValue); 882 if (ConvHi.isInvalid()) { 883 CaseListIsErroneous = true; 884 continue; 885 } 886 Hi = ConvHi.take(); 887 } else { 888 HiVal = Hi->EvaluateKnownConstInt(Context); 889 890 // If the RHS is not the same type as the condition, insert an 891 // implicit cast. 892 Hi = DefaultLvalueConversion(Hi).take(); 893 Hi = ImpCastExprToType(Hi, CondType, CK_IntegralCast).take(); 894 } 895 896 // Convert the value to the same width/sign as the condition. 897 ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned, 898 Hi->getLocStart(), 899 diag::warn_case_value_overflow); 900 901 CR->setRHS(Hi); 902 903 // If the low value is bigger than the high value, the case is empty. 904 if (LoVal > HiVal) { 905 Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range) 906 << SourceRange(CR->getLHS()->getLocStart(), 907 Hi->getLocEnd()); 908 CaseRanges.erase(CaseRanges.begin()+i); 909 --i, --e; 910 continue; 911 } 912 913 if (ShouldCheckConstantCond && 914 LoVal <= ConstantCondValue && 915 ConstantCondValue <= HiVal) 916 ShouldCheckConstantCond = false; 917 918 HiVals.push_back(HiVal); 919 } 920 921 // Rescan the ranges, looking for overlap with singleton values and other 922 // ranges. Since the range list is sorted, we only need to compare case 923 // ranges with their neighbors. 924 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) { 925 llvm::APSInt &CRLo = CaseRanges[i].first; 926 llvm::APSInt &CRHi = HiVals[i]; 927 CaseStmt *CR = CaseRanges[i].second; 928 929 // Check to see whether the case range overlaps with any 930 // singleton cases. 931 CaseStmt *OverlapStmt = 0; 932 llvm::APSInt OverlapVal(32); 933 934 // Find the smallest value >= the lower bound. If I is in the 935 // case range, then we have overlap. 936 CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(), 937 CaseVals.end(), CRLo, 938 CaseCompareFunctor()); 939 if (I != CaseVals.end() && I->first < CRHi) { 940 OverlapVal = I->first; // Found overlap with scalar. 941 OverlapStmt = I->second; 942 } 943 944 // Find the smallest value bigger than the upper bound. 945 I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor()); 946 if (I != CaseVals.begin() && (I-1)->first >= CRLo) { 947 OverlapVal = (I-1)->first; // Found overlap with scalar. 948 OverlapStmt = (I-1)->second; 949 } 950 951 // Check to see if this case stmt overlaps with the subsequent 952 // case range. 953 if (i && CRLo <= HiVals[i-1]) { 954 OverlapVal = HiVals[i-1]; // Found overlap with range. 955 OverlapStmt = CaseRanges[i-1].second; 956 } 957 958 if (OverlapStmt) { 959 // If we have a duplicate, report it. 960 Diag(CR->getLHS()->getLocStart(), diag::err_duplicate_case) 961 << OverlapVal.toString(10); 962 Diag(OverlapStmt->getLHS()->getLocStart(), 963 diag::note_duplicate_case_prev); 964 // FIXME: We really want to remove the bogus case stmt from the 965 // substmt, but we have no way to do this right now. 966 CaseListIsErroneous = true; 967 } 968 } 969 } 970 971 // Complain if we have a constant condition and we didn't find a match. 972 if (!CaseListIsErroneous && ShouldCheckConstantCond) { 973 // TODO: it would be nice if we printed enums as enums, chars as 974 // chars, etc. 975 Diag(CondExpr->getExprLoc(), diag::warn_missing_case_for_condition) 976 << ConstantCondValue.toString(10) 977 << CondExpr->getSourceRange(); 978 } 979 980 // Check to see if switch is over an Enum and handles all of its 981 // values. We only issue a warning if there is not 'default:', but 982 // we still do the analysis to preserve this information in the AST 983 // (which can be used by flow-based analyes). 984 // 985 const EnumType *ET = CondTypeBeforePromotion->getAs<EnumType>(); 986 987 // If switch has default case, then ignore it. 988 if (!CaseListIsErroneous && !HasConstantCond && ET) { 989 const EnumDecl *ED = ET->getDecl(); 990 typedef SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64> 991 EnumValsTy; 992 EnumValsTy EnumVals; 993 994 // Gather all enum values, set their type and sort them, 995 // allowing easier comparison with CaseVals. 996 for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin(); 997 EDI != ED->enumerator_end(); ++EDI) { 998 llvm::APSInt Val = EDI->getInitVal(); 999 AdjustAPSInt(Val, CondWidth, CondIsSigned); 1000 EnumVals.push_back(std::make_pair(Val, *EDI)); 1001 } 1002 std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals); 1003 EnumValsTy::iterator EIend = 1004 std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals); 1005 1006 // See which case values aren't in enum. 1007 EnumValsTy::const_iterator EI = EnumVals.begin(); 1008 for (CaseValsTy::const_iterator CI = CaseVals.begin(); 1009 CI != CaseVals.end(); CI++) { 1010 while (EI != EIend && EI->first < CI->first) 1011 EI++; 1012 if (EI == EIend || EI->first > CI->first) 1013 Diag(CI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum) 1014 << CondTypeBeforePromotion; 1015 } 1016 // See which of case ranges aren't in enum 1017 EI = EnumVals.begin(); 1018 for (CaseRangesTy::const_iterator RI = CaseRanges.begin(); 1019 RI != CaseRanges.end() && EI != EIend; RI++) { 1020 while (EI != EIend && EI->first < RI->first) 1021 EI++; 1022 1023 if (EI == EIend || EI->first != RI->first) { 1024 Diag(RI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum) 1025 << CondTypeBeforePromotion; 1026 } 1027 1028 llvm::APSInt Hi = 1029 RI->second->getRHS()->EvaluateKnownConstInt(Context); 1030 AdjustAPSInt(Hi, CondWidth, CondIsSigned); 1031 while (EI != EIend && EI->first < Hi) 1032 EI++; 1033 if (EI == EIend || EI->first != Hi) 1034 Diag(RI->second->getRHS()->getExprLoc(), diag::warn_not_in_enum) 1035 << CondTypeBeforePromotion; 1036 } 1037 1038 // Check which enum vals aren't in switch 1039 CaseValsTy::const_iterator CI = CaseVals.begin(); 1040 CaseRangesTy::const_iterator RI = CaseRanges.begin(); 1041 bool hasCasesNotInSwitch = false; 1042 1043 SmallVector<DeclarationName,8> UnhandledNames; 1044 1045 for (EI = EnumVals.begin(); EI != EIend; EI++){ 1046 // Drop unneeded case values 1047 llvm::APSInt CIVal; 1048 while (CI != CaseVals.end() && CI->first < EI->first) 1049 CI++; 1050 1051 if (CI != CaseVals.end() && CI->first == EI->first) 1052 continue; 1053 1054 // Drop unneeded case ranges 1055 for (; RI != CaseRanges.end(); RI++) { 1056 llvm::APSInt Hi = 1057 RI->second->getRHS()->EvaluateKnownConstInt(Context); 1058 AdjustAPSInt(Hi, CondWidth, CondIsSigned); 1059 if (EI->first <= Hi) 1060 break; 1061 } 1062 1063 if (RI == CaseRanges.end() || EI->first < RI->first) { 1064 hasCasesNotInSwitch = true; 1065 UnhandledNames.push_back(EI->second->getDeclName()); 1066 } 1067 } 1068 1069 if (TheDefaultStmt && UnhandledNames.empty()) 1070 Diag(TheDefaultStmt->getDefaultLoc(), diag::warn_unreachable_default); 1071 1072 // Produce a nice diagnostic if multiple values aren't handled. 1073 switch (UnhandledNames.size()) { 1074 case 0: break; 1075 case 1: 1076 Diag(CondExpr->getExprLoc(), TheDefaultStmt 1077 ? diag::warn_def_missing_case1 : diag::warn_missing_case1) 1078 << UnhandledNames[0]; 1079 break; 1080 case 2: 1081 Diag(CondExpr->getExprLoc(), TheDefaultStmt 1082 ? diag::warn_def_missing_case2 : diag::warn_missing_case2) 1083 << UnhandledNames[0] << UnhandledNames[1]; 1084 break; 1085 case 3: 1086 Diag(CondExpr->getExprLoc(), TheDefaultStmt 1087 ? diag::warn_def_missing_case3 : diag::warn_missing_case3) 1088 << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2]; 1089 break; 1090 default: 1091 Diag(CondExpr->getExprLoc(), TheDefaultStmt 1092 ? diag::warn_def_missing_cases : diag::warn_missing_cases) 1093 << (unsigned)UnhandledNames.size() 1094 << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2]; 1095 break; 1096 } 1097 1098 if (!hasCasesNotInSwitch) 1099 SS->setAllEnumCasesCovered(); 1100 } 1101 } 1102 1103 DiagnoseEmptyStmtBody(CondExpr->getLocEnd(), BodyStmt, 1104 diag::warn_empty_switch_body); 1105 1106 // FIXME: If the case list was broken is some way, we don't have a good system 1107 // to patch it up. Instead, just return the whole substmt as broken. 1108 if (CaseListIsErroneous) 1109 return StmtError(); 1110 1111 return Owned(SS); 1112} 1113 1114void 1115Sema::DiagnoseAssignmentEnum(QualType DstType, QualType SrcType, 1116 Expr *SrcExpr) { 1117 if (Diags.getDiagnosticLevel(diag::warn_not_in_enum_assignment, 1118 SrcExpr->getExprLoc()) == 1119 DiagnosticsEngine::Ignored) 1120 return; 1121 1122 if (const EnumType *ET = DstType->getAs<EnumType>()) 1123 if (!Context.hasSameType(SrcType, DstType) && 1124 SrcType->isIntegerType()) { 1125 if (!SrcExpr->isTypeDependent() && !SrcExpr->isValueDependent() && 1126 SrcExpr->isIntegerConstantExpr(Context)) { 1127 // Get the bitwidth of the enum value before promotions. 1128 unsigned DstWidth = Context.getIntWidth(DstType); 1129 bool DstIsSigned = DstType->isSignedIntegerOrEnumerationType(); 1130 1131 llvm::APSInt RhsVal = SrcExpr->EvaluateKnownConstInt(Context); 1132 AdjustAPSInt(RhsVal, DstWidth, DstIsSigned); 1133 const EnumDecl *ED = ET->getDecl(); 1134 typedef SmallVector<std::pair<llvm::APSInt, EnumConstantDecl *>, 64> 1135 EnumValsTy; 1136 EnumValsTy EnumVals; 1137 1138 // Gather all enum values, set their type and sort them, 1139 // allowing easier comparison with rhs constant. 1140 for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin(); 1141 EDI != ED->enumerator_end(); ++EDI) { 1142 llvm::APSInt Val = EDI->getInitVal(); 1143 AdjustAPSInt(Val, DstWidth, DstIsSigned); 1144 EnumVals.push_back(std::make_pair(Val, *EDI)); 1145 } 1146 if (EnumVals.empty()) 1147 return; 1148 std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals); 1149 EnumValsTy::iterator EIend = 1150 std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals); 1151 1152 // See which values aren't in the enum. 1153 EnumValsTy::const_iterator EI = EnumVals.begin(); 1154 while (EI != EIend && EI->first < RhsVal) 1155 EI++; 1156 if (EI == EIend || EI->first != RhsVal) { 1157 Diag(SrcExpr->getExprLoc(), diag::warn_not_in_enum_assignment) 1158 << DstType; 1159 } 1160 } 1161 } 1162} 1163 1164StmtResult 1165Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond, 1166 Decl *CondVar, Stmt *Body) { 1167 ExprResult CondResult(Cond.release()); 1168 1169 VarDecl *ConditionVar = 0; 1170 if (CondVar) { 1171 ConditionVar = cast<VarDecl>(CondVar); 1172 CondResult = CheckConditionVariable(ConditionVar, WhileLoc, true); 1173 if (CondResult.isInvalid()) 1174 return StmtError(); 1175 } 1176 Expr *ConditionExpr = CondResult.take(); 1177 if (!ConditionExpr) 1178 return StmtError(); 1179 1180 DiagnoseUnusedExprResult(Body); 1181 1182 if (isa<NullStmt>(Body)) 1183 getCurCompoundScope().setHasEmptyLoopBodies(); 1184 1185 return Owned(new (Context) WhileStmt(Context, ConditionVar, ConditionExpr, 1186 Body, WhileLoc)); 1187} 1188 1189StmtResult 1190Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body, 1191 SourceLocation WhileLoc, SourceLocation CondLParen, 1192 Expr *Cond, SourceLocation CondRParen) { 1193 assert(Cond && "ActOnDoStmt(): missing expression"); 1194 1195 ExprResult CondResult = CheckBooleanCondition(Cond, DoLoc); 1196 if (CondResult.isInvalid()) 1197 return StmtError(); 1198 Cond = CondResult.take(); 1199 1200 CondResult = ActOnFinishFullExpr(Cond, DoLoc); 1201 if (CondResult.isInvalid()) 1202 return StmtError(); 1203 Cond = CondResult.take(); 1204 1205 DiagnoseUnusedExprResult(Body); 1206 1207 return Owned(new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen)); 1208} 1209 1210namespace { 1211 // This visitor will traverse a conditional statement and store all 1212 // the evaluated decls into a vector. Simple is set to true if none 1213 // of the excluded constructs are used. 1214 class DeclExtractor : public EvaluatedExprVisitor<DeclExtractor> { 1215 llvm::SmallPtrSet<VarDecl*, 8> &Decls; 1216 SmallVectorImpl<SourceRange> &Ranges; 1217 bool Simple; 1218 public: 1219 typedef EvaluatedExprVisitor<DeclExtractor> Inherited; 1220 1221 DeclExtractor(Sema &S, llvm::SmallPtrSet<VarDecl*, 8> &Decls, 1222 SmallVectorImpl<SourceRange> &Ranges) : 1223 Inherited(S.Context), 1224 Decls(Decls), 1225 Ranges(Ranges), 1226 Simple(true) {} 1227 1228 bool isSimple() { return Simple; } 1229 1230 // Replaces the method in EvaluatedExprVisitor. 1231 void VisitMemberExpr(MemberExpr* E) { 1232 Simple = false; 1233 } 1234 1235 // Any Stmt not whitelisted will cause the condition to be marked complex. 1236 void VisitStmt(Stmt *S) { 1237 Simple = false; 1238 } 1239 1240 void VisitBinaryOperator(BinaryOperator *E) { 1241 Visit(E->getLHS()); 1242 Visit(E->getRHS()); 1243 } 1244 1245 void VisitCastExpr(CastExpr *E) { 1246 Visit(E->getSubExpr()); 1247 } 1248 1249 void VisitUnaryOperator(UnaryOperator *E) { 1250 // Skip checking conditionals with derefernces. 1251 if (E->getOpcode() == UO_Deref) 1252 Simple = false; 1253 else 1254 Visit(E->getSubExpr()); 1255 } 1256 1257 void VisitConditionalOperator(ConditionalOperator *E) { 1258 Visit(E->getCond()); 1259 Visit(E->getTrueExpr()); 1260 Visit(E->getFalseExpr()); 1261 } 1262 1263 void VisitParenExpr(ParenExpr *E) { 1264 Visit(E->getSubExpr()); 1265 } 1266 1267 void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { 1268 Visit(E->getOpaqueValue()->getSourceExpr()); 1269 Visit(E->getFalseExpr()); 1270 } 1271 1272 void VisitIntegerLiteral(IntegerLiteral *E) { } 1273 void VisitFloatingLiteral(FloatingLiteral *E) { } 1274 void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { } 1275 void VisitCharacterLiteral(CharacterLiteral *E) { } 1276 void VisitGNUNullExpr(GNUNullExpr *E) { } 1277 void VisitImaginaryLiteral(ImaginaryLiteral *E) { } 1278 1279 void VisitDeclRefExpr(DeclRefExpr *E) { 1280 VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()); 1281 if (!VD) return; 1282 1283 Ranges.push_back(E->getSourceRange()); 1284 1285 Decls.insert(VD); 1286 } 1287 1288 }; // end class DeclExtractor 1289 1290 // DeclMatcher checks to see if the decls are used in a non-evauluated 1291 // context. 1292 class DeclMatcher : public EvaluatedExprVisitor<DeclMatcher> { 1293 llvm::SmallPtrSet<VarDecl*, 8> &Decls; 1294 bool FoundDecl; 1295 1296 public: 1297 typedef EvaluatedExprVisitor<DeclMatcher> Inherited; 1298 1299 DeclMatcher(Sema &S, llvm::SmallPtrSet<VarDecl*, 8> &Decls, 1300 Stmt *Statement) : 1301 Inherited(S.Context), Decls(Decls), FoundDecl(false) { 1302 if (!Statement) return; 1303 1304 Visit(Statement); 1305 } 1306 1307 void VisitReturnStmt(ReturnStmt *S) { 1308 FoundDecl = true; 1309 } 1310 1311 void VisitBreakStmt(BreakStmt *S) { 1312 FoundDecl = true; 1313 } 1314 1315 void VisitGotoStmt(GotoStmt *S) { 1316 FoundDecl = true; 1317 } 1318 1319 void VisitCastExpr(CastExpr *E) { 1320 if (E->getCastKind() == CK_LValueToRValue) 1321 CheckLValueToRValueCast(E->getSubExpr()); 1322 else 1323 Visit(E->getSubExpr()); 1324 } 1325 1326 void CheckLValueToRValueCast(Expr *E) { 1327 E = E->IgnoreParenImpCasts(); 1328 1329 if (isa<DeclRefExpr>(E)) { 1330 return; 1331 } 1332 1333 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 1334 Visit(CO->getCond()); 1335 CheckLValueToRValueCast(CO->getTrueExpr()); 1336 CheckLValueToRValueCast(CO->getFalseExpr()); 1337 return; 1338 } 1339 1340 if (BinaryConditionalOperator *BCO = 1341 dyn_cast<BinaryConditionalOperator>(E)) { 1342 CheckLValueToRValueCast(BCO->getOpaqueValue()->getSourceExpr()); 1343 CheckLValueToRValueCast(BCO->getFalseExpr()); 1344 return; 1345 } 1346 1347 Visit(E); 1348 } 1349 1350 void VisitDeclRefExpr(DeclRefExpr *E) { 1351 if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) 1352 if (Decls.count(VD)) 1353 FoundDecl = true; 1354 } 1355 1356 bool FoundDeclInUse() { return FoundDecl; } 1357 1358 }; // end class DeclMatcher 1359 1360 void CheckForLoopConditionalStatement(Sema &S, Expr *Second, 1361 Expr *Third, Stmt *Body) { 1362 // Condition is empty 1363 if (!Second) return; 1364 1365 if (S.Diags.getDiagnosticLevel(diag::warn_variables_not_in_loop_body, 1366 Second->getLocStart()) 1367 == DiagnosticsEngine::Ignored) 1368 return; 1369 1370 PartialDiagnostic PDiag = S.PDiag(diag::warn_variables_not_in_loop_body); 1371 llvm::SmallPtrSet<VarDecl*, 8> Decls; 1372 SmallVector<SourceRange, 10> Ranges; 1373 DeclExtractor DE(S, Decls, Ranges); 1374 DE.Visit(Second); 1375 1376 // Don't analyze complex conditionals. 1377 if (!DE.isSimple()) return; 1378 1379 // No decls found. 1380 if (Decls.size() == 0) return; 1381 1382 // Don't warn on volatile, static, or global variables. 1383 for (llvm::SmallPtrSet<VarDecl*, 8>::iterator I = Decls.begin(), 1384 E = Decls.end(); 1385 I != E; ++I) 1386 if ((*I)->getType().isVolatileQualified() || 1387 (*I)->hasGlobalStorage()) return; 1388 1389 if (DeclMatcher(S, Decls, Second).FoundDeclInUse() || 1390 DeclMatcher(S, Decls, Third).FoundDeclInUse() || 1391 DeclMatcher(S, Decls, Body).FoundDeclInUse()) 1392 return; 1393 1394 // Load decl names into diagnostic. 1395 if (Decls.size() > 4) 1396 PDiag << 0; 1397 else { 1398 PDiag << Decls.size(); 1399 for (llvm::SmallPtrSet<VarDecl*, 8>::iterator I = Decls.begin(), 1400 E = Decls.end(); 1401 I != E; ++I) 1402 PDiag << (*I)->getDeclName(); 1403 } 1404 1405 // Load SourceRanges into diagnostic if there is room. 1406 // Otherwise, load the SourceRange of the conditional expression. 1407 if (Ranges.size() <= PartialDiagnostic::MaxArguments) 1408 for (SmallVectorImpl<SourceRange>::iterator I = Ranges.begin(), 1409 E = Ranges.end(); 1410 I != E; ++I) 1411 PDiag << *I; 1412 else 1413 PDiag << Second->getSourceRange(); 1414 1415 S.Diag(Ranges.begin()->getBegin(), PDiag); 1416 } 1417 1418 // If Statement is an incemement or decrement, return true and sets the 1419 // variables Increment and DRE. 1420 bool ProcessIterationStmt(Sema &S, Stmt* Statement, bool &Increment, 1421 DeclRefExpr *&DRE) { 1422 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(Statement)) { 1423 switch (UO->getOpcode()) { 1424 default: return false; 1425 case UO_PostInc: 1426 case UO_PreInc: 1427 Increment = true; 1428 break; 1429 case UO_PostDec: 1430 case UO_PreDec: 1431 Increment = false; 1432 break; 1433 } 1434 DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr()); 1435 return DRE; 1436 } 1437 1438 if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(Statement)) { 1439 FunctionDecl *FD = Call->getDirectCallee(); 1440 if (!FD || !FD->isOverloadedOperator()) return false; 1441 switch (FD->getOverloadedOperator()) { 1442 default: return false; 1443 case OO_PlusPlus: 1444 Increment = true; 1445 break; 1446 case OO_MinusMinus: 1447 Increment = false; 1448 break; 1449 } 1450 DRE = dyn_cast<DeclRefExpr>(Call->getArg(0)); 1451 return DRE; 1452 } 1453 1454 return false; 1455 } 1456 1457 // A visitor to determine if a continue statement is a subexpression. 1458 class ContinueFinder : public EvaluatedExprVisitor<ContinueFinder> { 1459 bool Found; 1460 public: 1461 ContinueFinder(Sema &S, Stmt* Body) : 1462 Inherited(S.Context), 1463 Found(false) { 1464 Visit(Body); 1465 } 1466 1467 typedef EvaluatedExprVisitor<ContinueFinder> Inherited; 1468 1469 void VisitContinueStmt(ContinueStmt* E) { 1470 Found = true; 1471 } 1472 1473 bool ContinueFound() { return Found; } 1474 1475 }; // end class ContinueFinder 1476 1477 // Emit a warning when a loop increment/decrement appears twice per loop 1478 // iteration. The conditions which trigger this warning are: 1479 // 1) The last statement in the loop body and the third expression in the 1480 // for loop are both increment or both decrement of the same variable 1481 // 2) No continue statements in the loop body. 1482 void CheckForRedundantIteration(Sema &S, Expr *Third, Stmt *Body) { 1483 // Return when there is nothing to check. 1484 if (!Body || !Third) return; 1485 1486 if (S.Diags.getDiagnosticLevel(diag::warn_redundant_loop_iteration, 1487 Third->getLocStart()) 1488 == DiagnosticsEngine::Ignored) 1489 return; 1490 1491 // Get the last statement from the loop body. 1492 CompoundStmt *CS = dyn_cast<CompoundStmt>(Body); 1493 if (!CS || CS->body_empty()) return; 1494 Stmt *LastStmt = CS->body_back(); 1495 if (!LastStmt) return; 1496 1497 bool LoopIncrement, LastIncrement; 1498 DeclRefExpr *LoopDRE, *LastDRE; 1499 1500 if (!ProcessIterationStmt(S, Third, LoopIncrement, LoopDRE)) return; 1501 if (!ProcessIterationStmt(S, LastStmt, LastIncrement, LastDRE)) return; 1502 1503 // Check that the two statements are both increments or both decrements 1504 // on the same varaible. 1505 if (LoopIncrement != LastIncrement || 1506 LoopDRE->getDecl() != LastDRE->getDecl()) return; 1507 1508 if (ContinueFinder(S, Body).ContinueFound()) return; 1509 1510 S.Diag(LastDRE->getLocation(), diag::warn_redundant_loop_iteration) 1511 << LastDRE->getDecl() << LastIncrement; 1512 S.Diag(LoopDRE->getLocation(), diag::note_loop_iteration_here) 1513 << LoopIncrement; 1514 } 1515 1516} // end namespace 1517 1518StmtResult 1519Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, 1520 Stmt *First, FullExprArg second, Decl *secondVar, 1521 FullExprArg third, 1522 SourceLocation RParenLoc, Stmt *Body) { 1523 if (!getLangOpts().CPlusPlus) { 1524 if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) { 1525 // C99 6.8.5p3: The declaration part of a 'for' statement shall only 1526 // declare identifiers for objects having storage class 'auto' or 1527 // 'register'. 1528 for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end(); 1529 DI!=DE; ++DI) { 1530 VarDecl *VD = dyn_cast<VarDecl>(*DI); 1531 if (VD && VD->isLocalVarDecl() && !VD->hasLocalStorage()) 1532 VD = 0; 1533 if (VD == 0) { 1534 Diag((*DI)->getLocation(), diag::err_non_local_variable_decl_in_for); 1535 (*DI)->setInvalidDecl(); 1536 } 1537 } 1538 } 1539 } 1540 1541 CheckForLoopConditionalStatement(*this, second.get(), third.get(), Body); 1542 CheckForRedundantIteration(*this, third.get(), Body); 1543 1544 ExprResult SecondResult(second.release()); 1545 VarDecl *ConditionVar = 0; 1546 if (secondVar) { 1547 ConditionVar = cast<VarDecl>(secondVar); 1548 SecondResult = CheckConditionVariable(ConditionVar, ForLoc, true); 1549 if (SecondResult.isInvalid()) 1550 return StmtError(); 1551 } 1552 1553 Expr *Third = third.release().takeAs<Expr>(); 1554 1555 DiagnoseUnusedExprResult(First); 1556 DiagnoseUnusedExprResult(Third); 1557 DiagnoseUnusedExprResult(Body); 1558 1559 if (isa<NullStmt>(Body)) 1560 getCurCompoundScope().setHasEmptyLoopBodies(); 1561 1562 return Owned(new (Context) ForStmt(Context, First, 1563 SecondResult.take(), ConditionVar, 1564 Third, Body, ForLoc, LParenLoc, 1565 RParenLoc)); 1566} 1567 1568/// In an Objective C collection iteration statement: 1569/// for (x in y) 1570/// x can be an arbitrary l-value expression. Bind it up as a 1571/// full-expression. 1572StmtResult Sema::ActOnForEachLValueExpr(Expr *E) { 1573 // Reduce placeholder expressions here. Note that this rejects the 1574 // use of pseudo-object l-values in this position. 1575 ExprResult result = CheckPlaceholderExpr(E); 1576 if (result.isInvalid()) return StmtError(); 1577 E = result.take(); 1578 1579 ExprResult FullExpr = ActOnFinishFullExpr(E); 1580 if (FullExpr.isInvalid()) 1581 return StmtError(); 1582 return StmtResult(static_cast<Stmt*>(FullExpr.take())); 1583} 1584 1585ExprResult 1586Sema::CheckObjCForCollectionOperand(SourceLocation forLoc, Expr *collection) { 1587 if (!collection) 1588 return ExprError(); 1589 1590 // Bail out early if we've got a type-dependent expression. 1591 if (collection->isTypeDependent()) return Owned(collection); 1592 1593 // Perform normal l-value conversion. 1594 ExprResult result = DefaultFunctionArrayLvalueConversion(collection); 1595 if (result.isInvalid()) 1596 return ExprError(); 1597 collection = result.take(); 1598 1599 // The operand needs to have object-pointer type. 1600 // TODO: should we do a contextual conversion? 1601 const ObjCObjectPointerType *pointerType = 1602 collection->getType()->getAs<ObjCObjectPointerType>(); 1603 if (!pointerType) 1604 return Diag(forLoc, diag::err_collection_expr_type) 1605 << collection->getType() << collection->getSourceRange(); 1606 1607 // Check that the operand provides 1608 // - countByEnumeratingWithState:objects:count: 1609 const ObjCObjectType *objectType = pointerType->getObjectType(); 1610 ObjCInterfaceDecl *iface = objectType->getInterface(); 1611 1612 // If we have a forward-declared type, we can't do this check. 1613 // Under ARC, it is an error not to have a forward-declared class. 1614 if (iface && 1615 RequireCompleteType(forLoc, QualType(objectType, 0), 1616 getLangOpts().ObjCAutoRefCount 1617 ? diag::err_arc_collection_forward 1618 : 0, 1619 collection)) { 1620 // Otherwise, if we have any useful type information, check that 1621 // the type declares the appropriate method. 1622 } else if (iface || !objectType->qual_empty()) { 1623 IdentifierInfo *selectorIdents[] = { 1624 &Context.Idents.get("countByEnumeratingWithState"), 1625 &Context.Idents.get("objects"), 1626 &Context.Idents.get("count") 1627 }; 1628 Selector selector = Context.Selectors.getSelector(3, &selectorIdents[0]); 1629 1630 ObjCMethodDecl *method = 0; 1631 1632 // If there's an interface, look in both the public and private APIs. 1633 if (iface) { 1634 method = iface->lookupInstanceMethod(selector); 1635 if (!method) method = iface->lookupPrivateMethod(selector); 1636 } 1637 1638 // Also check protocol qualifiers. 1639 if (!method) 1640 method = LookupMethodInQualifiedType(selector, pointerType, 1641 /*instance*/ true); 1642 1643 // If we didn't find it anywhere, give up. 1644 if (!method) { 1645 Diag(forLoc, diag::warn_collection_expr_type) 1646 << collection->getType() << selector << collection->getSourceRange(); 1647 } 1648 1649 // TODO: check for an incompatible signature? 1650 } 1651 1652 // Wrap up any cleanups in the expression. 1653 return Owned(collection); 1654} 1655 1656StmtResult 1657Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc, 1658 Stmt *First, Expr *collection, 1659 SourceLocation RParenLoc) { 1660 1661 ExprResult CollectionExprResult = 1662 CheckObjCForCollectionOperand(ForLoc, collection); 1663 1664 if (First) { 1665 QualType FirstType; 1666 if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) { 1667 if (!DS->isSingleDecl()) 1668 return StmtError(Diag((*DS->decl_begin())->getLocation(), 1669 diag::err_toomany_element_decls)); 1670 1671 VarDecl *D = dyn_cast<VarDecl>(DS->getSingleDecl()); 1672 if (!D || D->isInvalidDecl()) 1673 return StmtError(); 1674 1675 FirstType = D->getType(); 1676 // C99 6.8.5p3: The declaration part of a 'for' statement shall only 1677 // declare identifiers for objects having storage class 'auto' or 1678 // 'register'. 1679 if (!D->hasLocalStorage()) 1680 return StmtError(Diag(D->getLocation(), 1681 diag::err_non_local_variable_decl_in_for)); 1682 1683 // If the type contained 'auto', deduce the 'auto' to 'id'. 1684 if (FirstType->getContainedAutoType()) { 1685 OpaqueValueExpr OpaqueId(D->getLocation(), Context.getObjCIdType(), 1686 VK_RValue); 1687 Expr *DeducedInit = &OpaqueId; 1688 if (DeduceAutoType(D->getTypeSourceInfo(), DeducedInit, FirstType) == 1689 DAR_Failed) 1690 DiagnoseAutoDeductionFailure(D, DeducedInit); 1691 if (FirstType.isNull()) { 1692 D->setInvalidDecl(); 1693 return StmtError(); 1694 } 1695 1696 D->setType(FirstType); 1697 1698 if (ActiveTemplateInstantiations.empty()) { 1699 SourceLocation Loc = 1700 D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(); 1701 Diag(Loc, diag::warn_auto_var_is_id) 1702 << D->getDeclName(); 1703 } 1704 } 1705 1706 } else { 1707 Expr *FirstE = cast<Expr>(First); 1708 if (!FirstE->isTypeDependent() && !FirstE->isLValue()) 1709 return StmtError(Diag(First->getLocStart(), 1710 diag::err_selector_element_not_lvalue) 1711 << First->getSourceRange()); 1712 1713 FirstType = static_cast<Expr*>(First)->getType(); 1714 if (FirstType.isConstQualified()) 1715 Diag(ForLoc, diag::err_selector_element_const_type) 1716 << FirstType << First->getSourceRange(); 1717 } 1718 if (!FirstType->isDependentType() && 1719 !FirstType->isObjCObjectPointerType() && 1720 !FirstType->isBlockPointerType()) 1721 return StmtError(Diag(ForLoc, diag::err_selector_element_type) 1722 << FirstType << First->getSourceRange()); 1723 } 1724 1725 if (CollectionExprResult.isInvalid()) 1726 return StmtError(); 1727 1728 CollectionExprResult = ActOnFinishFullExpr(CollectionExprResult.take()); 1729 if (CollectionExprResult.isInvalid()) 1730 return StmtError(); 1731 1732 return Owned(new (Context) ObjCForCollectionStmt(First, 1733 CollectionExprResult.take(), 0, 1734 ForLoc, RParenLoc)); 1735} 1736 1737/// Finish building a variable declaration for a for-range statement. 1738/// \return true if an error occurs. 1739static bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init, 1740 SourceLocation Loc, int DiagID) { 1741 // Deduce the type for the iterator variable now rather than leaving it to 1742 // AddInitializerToDecl, so we can produce a more suitable diagnostic. 1743 QualType InitType; 1744 if ((!isa<InitListExpr>(Init) && Init->getType()->isVoidType()) || 1745 SemaRef.DeduceAutoType(Decl->getTypeSourceInfo(), Init, InitType) == 1746 Sema::DAR_Failed) 1747 SemaRef.Diag(Loc, DiagID) << Init->getType(); 1748 if (InitType.isNull()) { 1749 Decl->setInvalidDecl(); 1750 return true; 1751 } 1752 Decl->setType(InitType); 1753 1754 // In ARC, infer lifetime. 1755 // FIXME: ARC may want to turn this into 'const __unsafe_unretained' if 1756 // we're doing the equivalent of fast iteration. 1757 if (SemaRef.getLangOpts().ObjCAutoRefCount && 1758 SemaRef.inferObjCARCLifetime(Decl)) 1759 Decl->setInvalidDecl(); 1760 1761 SemaRef.AddInitializerToDecl(Decl, Init, /*DirectInit=*/false, 1762 /*TypeMayContainAuto=*/false); 1763 SemaRef.FinalizeDeclaration(Decl); 1764 SemaRef.CurContext->addHiddenDecl(Decl); 1765 return false; 1766} 1767 1768namespace { 1769 1770/// Produce a note indicating which begin/end function was implicitly called 1771/// by a C++11 for-range statement. This is often not obvious from the code, 1772/// nor from the diagnostics produced when analysing the implicit expressions 1773/// required in a for-range statement. 1774void NoteForRangeBeginEndFunction(Sema &SemaRef, Expr *E, 1775 Sema::BeginEndFunction BEF) { 1776 CallExpr *CE = dyn_cast<CallExpr>(E); 1777 if (!CE) 1778 return; 1779 FunctionDecl *D = dyn_cast<FunctionDecl>(CE->getCalleeDecl()); 1780 if (!D) 1781 return; 1782 SourceLocation Loc = D->getLocation(); 1783 1784 std::string Description; 1785 bool IsTemplate = false; 1786 if (FunctionTemplateDecl *FunTmpl = D->getPrimaryTemplate()) { 1787 Description = SemaRef.getTemplateArgumentBindingsText( 1788 FunTmpl->getTemplateParameters(), *D->getTemplateSpecializationArgs()); 1789 IsTemplate = true; 1790 } 1791 1792 SemaRef.Diag(Loc, diag::note_for_range_begin_end) 1793 << BEF << IsTemplate << Description << E->getType(); 1794} 1795 1796/// Build a variable declaration for a for-range statement. 1797VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc, 1798 QualType Type, const char *Name) { 1799 DeclContext *DC = SemaRef.CurContext; 1800 IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name); 1801 TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc); 1802 VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type, 1803 TInfo, SC_None); 1804 Decl->setImplicit(); 1805 return Decl; 1806} 1807 1808} 1809 1810static bool ObjCEnumerationCollection(Expr *Collection) { 1811 return !Collection->isTypeDependent() 1812 && Collection->getType()->getAs<ObjCObjectPointerType>() != 0; 1813} 1814 1815/// ActOnCXXForRangeStmt - Check and build a C++11 for-range statement. 1816/// 1817/// C++11 [stmt.ranged]: 1818/// A range-based for statement is equivalent to 1819/// 1820/// { 1821/// auto && __range = range-init; 1822/// for ( auto __begin = begin-expr, 1823/// __end = end-expr; 1824/// __begin != __end; 1825/// ++__begin ) { 1826/// for-range-declaration = *__begin; 1827/// statement 1828/// } 1829/// } 1830/// 1831/// The body of the loop is not available yet, since it cannot be analysed until 1832/// we have determined the type of the for-range-declaration. 1833StmtResult 1834Sema::ActOnCXXForRangeStmt(SourceLocation ForLoc, 1835 Stmt *First, SourceLocation ColonLoc, Expr *Range, 1836 SourceLocation RParenLoc, BuildForRangeKind Kind) { 1837 if (!First) 1838 return StmtError(); 1839 1840 if (Range && ObjCEnumerationCollection(Range)) 1841 return ActOnObjCForCollectionStmt(ForLoc, First, Range, RParenLoc); 1842 1843 DeclStmt *DS = dyn_cast<DeclStmt>(First); 1844 assert(DS && "first part of for range not a decl stmt"); 1845 1846 if (!DS->isSingleDecl()) { 1847 Diag(DS->getStartLoc(), diag::err_type_defined_in_for_range); 1848 return StmtError(); 1849 } 1850 1851 Decl *LoopVar = DS->getSingleDecl(); 1852 if (LoopVar->isInvalidDecl() || !Range || 1853 DiagnoseUnexpandedParameterPack(Range, UPPC_Expression)) { 1854 LoopVar->setInvalidDecl(); 1855 return StmtError(); 1856 } 1857 1858 // Build auto && __range = range-init 1859 SourceLocation RangeLoc = Range->getLocStart(); 1860 VarDecl *RangeVar = BuildForRangeVarDecl(*this, RangeLoc, 1861 Context.getAutoRRefDeductType(), 1862 "__range"); 1863 if (FinishForRangeVarDecl(*this, RangeVar, Range, RangeLoc, 1864 diag::err_for_range_deduction_failure)) { 1865 LoopVar->setInvalidDecl(); 1866 return StmtError(); 1867 } 1868 1869 // Claim the type doesn't contain auto: we've already done the checking. 1870 DeclGroupPtrTy RangeGroup = 1871 BuildDeclaratorGroup(llvm::MutableArrayRef<Decl *>((Decl **)&RangeVar, 1), 1872 /*TypeMayContainAuto=*/ false); 1873 StmtResult RangeDecl = ActOnDeclStmt(RangeGroup, RangeLoc, RangeLoc); 1874 if (RangeDecl.isInvalid()) { 1875 LoopVar->setInvalidDecl(); 1876 return StmtError(); 1877 } 1878 1879 return BuildCXXForRangeStmt(ForLoc, ColonLoc, RangeDecl.get(), 1880 /*BeginEndDecl=*/0, /*Cond=*/0, /*Inc=*/0, DS, 1881 RParenLoc, Kind); 1882} 1883 1884/// \brief Create the initialization, compare, and increment steps for 1885/// the range-based for loop expression. 1886/// This function does not handle array-based for loops, 1887/// which are created in Sema::BuildCXXForRangeStmt. 1888/// 1889/// \returns a ForRangeStatus indicating success or what kind of error occurred. 1890/// BeginExpr and EndExpr are set and FRS_Success is returned on success; 1891/// CandidateSet and BEF are set and some non-success value is returned on 1892/// failure. 1893static Sema::ForRangeStatus BuildNonArrayForRange(Sema &SemaRef, Scope *S, 1894 Expr *BeginRange, Expr *EndRange, 1895 QualType RangeType, 1896 VarDecl *BeginVar, 1897 VarDecl *EndVar, 1898 SourceLocation ColonLoc, 1899 OverloadCandidateSet *CandidateSet, 1900 ExprResult *BeginExpr, 1901 ExprResult *EndExpr, 1902 Sema::BeginEndFunction *BEF) { 1903 DeclarationNameInfo BeginNameInfo( 1904 &SemaRef.PP.getIdentifierTable().get("begin"), ColonLoc); 1905 DeclarationNameInfo EndNameInfo(&SemaRef.PP.getIdentifierTable().get("end"), 1906 ColonLoc); 1907 1908 LookupResult BeginMemberLookup(SemaRef, BeginNameInfo, 1909 Sema::LookupMemberName); 1910 LookupResult EndMemberLookup(SemaRef, EndNameInfo, Sema::LookupMemberName); 1911 1912 if (CXXRecordDecl *D = RangeType->getAsCXXRecordDecl()) { 1913 // - if _RangeT is a class type, the unqualified-ids begin and end are 1914 // looked up in the scope of class _RangeT as if by class member access 1915 // lookup (3.4.5), and if either (or both) finds at least one 1916 // declaration, begin-expr and end-expr are __range.begin() and 1917 // __range.end(), respectively; 1918 SemaRef.LookupQualifiedName(BeginMemberLookup, D); 1919 SemaRef.LookupQualifiedName(EndMemberLookup, D); 1920 1921 if (BeginMemberLookup.empty() != EndMemberLookup.empty()) { 1922 SourceLocation RangeLoc = BeginVar->getLocation(); 1923 *BEF = BeginMemberLookup.empty() ? Sema::BEF_end : Sema::BEF_begin; 1924 1925 SemaRef.Diag(RangeLoc, diag::err_for_range_member_begin_end_mismatch) 1926 << RangeLoc << BeginRange->getType() << *BEF; 1927 return Sema::FRS_DiagnosticIssued; 1928 } 1929 } else { 1930 // - otherwise, begin-expr and end-expr are begin(__range) and 1931 // end(__range), respectively, where begin and end are looked up with 1932 // argument-dependent lookup (3.4.2). For the purposes of this name 1933 // lookup, namespace std is an associated namespace. 1934 1935 } 1936 1937 *BEF = Sema::BEF_begin; 1938 Sema::ForRangeStatus RangeStatus = 1939 SemaRef.BuildForRangeBeginEndCall(S, ColonLoc, ColonLoc, BeginVar, 1940 Sema::BEF_begin, BeginNameInfo, 1941 BeginMemberLookup, CandidateSet, 1942 BeginRange, BeginExpr); 1943 1944 if (RangeStatus != Sema::FRS_Success) 1945 return RangeStatus; 1946 if (FinishForRangeVarDecl(SemaRef, BeginVar, BeginExpr->get(), ColonLoc, 1947 diag::err_for_range_iter_deduction_failure)) { 1948 NoteForRangeBeginEndFunction(SemaRef, BeginExpr->get(), *BEF); 1949 return Sema::FRS_DiagnosticIssued; 1950 } 1951 1952 *BEF = Sema::BEF_end; 1953 RangeStatus = 1954 SemaRef.BuildForRangeBeginEndCall(S, ColonLoc, ColonLoc, EndVar, 1955 Sema::BEF_end, EndNameInfo, 1956 EndMemberLookup, CandidateSet, 1957 EndRange, EndExpr); 1958 if (RangeStatus != Sema::FRS_Success) 1959 return RangeStatus; 1960 if (FinishForRangeVarDecl(SemaRef, EndVar, EndExpr->get(), ColonLoc, 1961 diag::err_for_range_iter_deduction_failure)) { 1962 NoteForRangeBeginEndFunction(SemaRef, EndExpr->get(), *BEF); 1963 return Sema::FRS_DiagnosticIssued; 1964 } 1965 return Sema::FRS_Success; 1966} 1967 1968/// Speculatively attempt to dereference an invalid range expression. 1969/// If the attempt fails, this function will return a valid, null StmtResult 1970/// and emit no diagnostics. 1971static StmtResult RebuildForRangeWithDereference(Sema &SemaRef, Scope *S, 1972 SourceLocation ForLoc, 1973 Stmt *LoopVarDecl, 1974 SourceLocation ColonLoc, 1975 Expr *Range, 1976 SourceLocation RangeLoc, 1977 SourceLocation RParenLoc) { 1978 // Determine whether we can rebuild the for-range statement with a 1979 // dereferenced range expression. 1980 ExprResult AdjustedRange; 1981 { 1982 Sema::SFINAETrap Trap(SemaRef); 1983 1984 AdjustedRange = SemaRef.BuildUnaryOp(S, RangeLoc, UO_Deref, Range); 1985 if (AdjustedRange.isInvalid()) 1986 return StmtResult(); 1987 1988 StmtResult SR = 1989 SemaRef.ActOnCXXForRangeStmt(ForLoc, LoopVarDecl, ColonLoc, 1990 AdjustedRange.get(), RParenLoc, 1991 Sema::BFRK_Check); 1992 if (SR.isInvalid()) 1993 return StmtResult(); 1994 } 1995 1996 // The attempt to dereference worked well enough that it could produce a valid 1997 // loop. Produce a fixit, and rebuild the loop with diagnostics enabled, in 1998 // case there are any other (non-fatal) problems with it. 1999 SemaRef.Diag(RangeLoc, diag::err_for_range_dereference) 2000 << Range->getType() << FixItHint::CreateInsertion(RangeLoc, "*"); 2001 return SemaRef.ActOnCXXForRangeStmt(ForLoc, LoopVarDecl, ColonLoc, 2002 AdjustedRange.get(), RParenLoc, 2003 Sema::BFRK_Rebuild); 2004} 2005 2006namespace { 2007/// RAII object to automatically invalidate a declaration if an error occurs. 2008struct InvalidateOnErrorScope { 2009 InvalidateOnErrorScope(Sema &SemaRef, Decl *D, bool Enabled) 2010 : Trap(SemaRef.Diags), D(D), Enabled(Enabled) {} 2011 ~InvalidateOnErrorScope() { 2012 if (Enabled && Trap.hasErrorOccurred()) 2013 D->setInvalidDecl(); 2014 } 2015 2016 DiagnosticErrorTrap Trap; 2017 Decl *D; 2018 bool Enabled; 2019}; 2020} 2021 2022/// BuildCXXForRangeStmt - Build or instantiate a C++11 for-range statement. 2023StmtResult 2024Sema::BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation ColonLoc, 2025 Stmt *RangeDecl, Stmt *BeginEnd, Expr *Cond, 2026 Expr *Inc, Stmt *LoopVarDecl, 2027 SourceLocation RParenLoc, BuildForRangeKind Kind) { 2028 Scope *S = getCurScope(); 2029 2030 DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl); 2031 VarDecl *RangeVar = cast<VarDecl>(RangeDS->getSingleDecl()); 2032 QualType RangeVarType = RangeVar->getType(); 2033 2034 DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl); 2035 VarDecl *LoopVar = cast<VarDecl>(LoopVarDS->getSingleDecl()); 2036 2037 // If we hit any errors, mark the loop variable as invalid if its type 2038 // contains 'auto'. 2039 InvalidateOnErrorScope Invalidate(*this, LoopVar, 2040 LoopVar->getType()->isUndeducedType()); 2041 2042 StmtResult BeginEndDecl = BeginEnd; 2043 ExprResult NotEqExpr = Cond, IncrExpr = Inc; 2044 2045 if (RangeVarType->isDependentType()) { 2046 // The range is implicitly used as a placeholder when it is dependent. 2047 RangeVar->markUsed(Context); 2048 2049 // Deduce any 'auto's in the loop variable as 'DependentTy'. We'll fill 2050 // them in properly when we instantiate the loop. 2051 if (!LoopVar->isInvalidDecl() && Kind != BFRK_Check) 2052 LoopVar->setType(SubstAutoType(LoopVar->getType(), Context.DependentTy)); 2053 } else if (!BeginEndDecl.get()) { 2054 SourceLocation RangeLoc = RangeVar->getLocation(); 2055 2056 const QualType RangeVarNonRefType = RangeVarType.getNonReferenceType(); 2057 2058 ExprResult BeginRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType, 2059 VK_LValue, ColonLoc); 2060 if (BeginRangeRef.isInvalid()) 2061 return StmtError(); 2062 2063 ExprResult EndRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType, 2064 VK_LValue, ColonLoc); 2065 if (EndRangeRef.isInvalid()) 2066 return StmtError(); 2067 2068 QualType AutoType = Context.getAutoDeductType(); 2069 Expr *Range = RangeVar->getInit(); 2070 if (!Range) 2071 return StmtError(); 2072 QualType RangeType = Range->getType(); 2073 2074 if (RequireCompleteType(RangeLoc, RangeType, 2075 diag::err_for_range_incomplete_type)) 2076 return StmtError(); 2077 2078 // Build auto __begin = begin-expr, __end = end-expr. 2079 VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType, 2080 "__begin"); 2081 VarDecl *EndVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType, 2082 "__end"); 2083 2084 // Build begin-expr and end-expr and attach to __begin and __end variables. 2085 ExprResult BeginExpr, EndExpr; 2086 if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) { 2087 // - if _RangeT is an array type, begin-expr and end-expr are __range and 2088 // __range + __bound, respectively, where __bound is the array bound. If 2089 // _RangeT is an array of unknown size or an array of incomplete type, 2090 // the program is ill-formed; 2091 2092 // begin-expr is __range. 2093 BeginExpr = BeginRangeRef; 2094 if (FinishForRangeVarDecl(*this, BeginVar, BeginRangeRef.get(), ColonLoc, 2095 diag::err_for_range_iter_deduction_failure)) { 2096 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin); 2097 return StmtError(); 2098 } 2099 2100 // Find the array bound. 2101 ExprResult BoundExpr; 2102 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(UnqAT)) 2103 BoundExpr = Owned(IntegerLiteral::Create(Context, CAT->getSize(), 2104 Context.getPointerDiffType(), 2105 RangeLoc)); 2106 else if (const VariableArrayType *VAT = 2107 dyn_cast<VariableArrayType>(UnqAT)) 2108 BoundExpr = VAT->getSizeExpr(); 2109 else { 2110 // Can't be a DependentSizedArrayType or an IncompleteArrayType since 2111 // UnqAT is not incomplete and Range is not type-dependent. 2112 llvm_unreachable("Unexpected array type in for-range"); 2113 } 2114 2115 // end-expr is __range + __bound. 2116 EndExpr = ActOnBinOp(S, ColonLoc, tok::plus, EndRangeRef.get(), 2117 BoundExpr.get()); 2118 if (EndExpr.isInvalid()) 2119 return StmtError(); 2120 if (FinishForRangeVarDecl(*this, EndVar, EndExpr.get(), ColonLoc, 2121 diag::err_for_range_iter_deduction_failure)) { 2122 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end); 2123 return StmtError(); 2124 } 2125 } else { 2126 OverloadCandidateSet CandidateSet(RangeLoc); 2127 Sema::BeginEndFunction BEFFailure; 2128 ForRangeStatus RangeStatus = 2129 BuildNonArrayForRange(*this, S, BeginRangeRef.get(), 2130 EndRangeRef.get(), RangeType, 2131 BeginVar, EndVar, ColonLoc, &CandidateSet, 2132 &BeginExpr, &EndExpr, &BEFFailure); 2133 2134 if (Kind == BFRK_Build && RangeStatus == FRS_NoViableFunction && 2135 BEFFailure == BEF_begin) { 2136 // If the range is being built from an array parameter, emit a 2137 // a diagnostic that it is being treated as a pointer. 2138 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Range)) { 2139 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) { 2140 QualType ArrayTy = PVD->getOriginalType(); 2141 QualType PointerTy = PVD->getType(); 2142 if (PointerTy->isPointerType() && ArrayTy->isArrayType()) { 2143 Diag(Range->getLocStart(), diag::err_range_on_array_parameter) 2144 << RangeLoc << PVD << ArrayTy << PointerTy; 2145 Diag(PVD->getLocation(), diag::note_declared_at); 2146 return StmtError(); 2147 } 2148 } 2149 } 2150 2151 // If building the range failed, try dereferencing the range expression 2152 // unless a diagnostic was issued or the end function is problematic. 2153 StmtResult SR = RebuildForRangeWithDereference(*this, S, ForLoc, 2154 LoopVarDecl, ColonLoc, 2155 Range, RangeLoc, 2156 RParenLoc); 2157 if (SR.isInvalid() || SR.isUsable()) 2158 return SR; 2159 } 2160 2161 // Otherwise, emit diagnostics if we haven't already. 2162 if (RangeStatus == FRS_NoViableFunction) { 2163 Expr *Range = BEFFailure ? EndRangeRef.get() : BeginRangeRef.get(); 2164 Diag(Range->getLocStart(), diag::err_for_range_invalid) 2165 << RangeLoc << Range->getType() << BEFFailure; 2166 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Range); 2167 } 2168 // Return an error if no fix was discovered. 2169 if (RangeStatus != FRS_Success) 2170 return StmtError(); 2171 } 2172 2173 assert(!BeginExpr.isInvalid() && !EndExpr.isInvalid() && 2174 "invalid range expression in for loop"); 2175 2176 // C++11 [dcl.spec.auto]p7: BeginType and EndType must be the same. 2177 QualType BeginType = BeginVar->getType(), EndType = EndVar->getType(); 2178 if (!Context.hasSameType(BeginType, EndType)) { 2179 Diag(RangeLoc, diag::err_for_range_begin_end_types_differ) 2180 << BeginType << EndType; 2181 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin); 2182 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end); 2183 } 2184 2185 Decl *BeginEndDecls[] = { BeginVar, EndVar }; 2186 // Claim the type doesn't contain auto: we've already done the checking. 2187 DeclGroupPtrTy BeginEndGroup = 2188 BuildDeclaratorGroup(llvm::MutableArrayRef<Decl *>(BeginEndDecls, 2), 2189 /*TypeMayContainAuto=*/ false); 2190 BeginEndDecl = ActOnDeclStmt(BeginEndGroup, ColonLoc, ColonLoc); 2191 2192 const QualType BeginRefNonRefType = BeginType.getNonReferenceType(); 2193 ExprResult BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType, 2194 VK_LValue, ColonLoc); 2195 if (BeginRef.isInvalid()) 2196 return StmtError(); 2197 2198 ExprResult EndRef = BuildDeclRefExpr(EndVar, EndType.getNonReferenceType(), 2199 VK_LValue, ColonLoc); 2200 if (EndRef.isInvalid()) 2201 return StmtError(); 2202 2203 // Build and check __begin != __end expression. 2204 NotEqExpr = ActOnBinOp(S, ColonLoc, tok::exclaimequal, 2205 BeginRef.get(), EndRef.get()); 2206 NotEqExpr = ActOnBooleanCondition(S, ColonLoc, NotEqExpr.get()); 2207 NotEqExpr = ActOnFinishFullExpr(NotEqExpr.get()); 2208 if (NotEqExpr.isInvalid()) { 2209 Diag(RangeLoc, diag::note_for_range_invalid_iterator) 2210 << RangeLoc << 0 << BeginRangeRef.get()->getType(); 2211 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin); 2212 if (!Context.hasSameType(BeginType, EndType)) 2213 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end); 2214 return StmtError(); 2215 } 2216 2217 // Build and check ++__begin expression. 2218 BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType, 2219 VK_LValue, ColonLoc); 2220 if (BeginRef.isInvalid()) 2221 return StmtError(); 2222 2223 IncrExpr = ActOnUnaryOp(S, ColonLoc, tok::plusplus, BeginRef.get()); 2224 IncrExpr = ActOnFinishFullExpr(IncrExpr.get()); 2225 if (IncrExpr.isInvalid()) { 2226 Diag(RangeLoc, diag::note_for_range_invalid_iterator) 2227 << RangeLoc << 2 << BeginRangeRef.get()->getType() ; 2228 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin); 2229 return StmtError(); 2230 } 2231 2232 // Build and check *__begin expression. 2233 BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType, 2234 VK_LValue, ColonLoc); 2235 if (BeginRef.isInvalid()) 2236 return StmtError(); 2237 2238 ExprResult DerefExpr = ActOnUnaryOp(S, ColonLoc, tok::star, BeginRef.get()); 2239 if (DerefExpr.isInvalid()) { 2240 Diag(RangeLoc, diag::note_for_range_invalid_iterator) 2241 << RangeLoc << 1 << BeginRangeRef.get()->getType(); 2242 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin); 2243 return StmtError(); 2244 } 2245 2246 // Attach *__begin as initializer for VD. Don't touch it if we're just 2247 // trying to determine whether this would be a valid range. 2248 if (!LoopVar->isInvalidDecl() && Kind != BFRK_Check) { 2249 AddInitializerToDecl(LoopVar, DerefExpr.get(), /*DirectInit=*/false, 2250 /*TypeMayContainAuto=*/true); 2251 if (LoopVar->isInvalidDecl()) 2252 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin); 2253 } 2254 } 2255 2256 // Don't bother to actually allocate the result if we're just trying to 2257 // determine whether it would be valid. 2258 if (Kind == BFRK_Check) 2259 return StmtResult(); 2260 2261 return Owned(new (Context) CXXForRangeStmt(RangeDS, 2262 cast_or_null<DeclStmt>(BeginEndDecl.get()), 2263 NotEqExpr.take(), IncrExpr.take(), 2264 LoopVarDS, /*Body=*/0, ForLoc, 2265 ColonLoc, RParenLoc)); 2266} 2267 2268/// FinishObjCForCollectionStmt - Attach the body to a objective-C foreach 2269/// statement. 2270StmtResult Sema::FinishObjCForCollectionStmt(Stmt *S, Stmt *B) { 2271 if (!S || !B) 2272 return StmtError(); 2273 ObjCForCollectionStmt * ForStmt = cast<ObjCForCollectionStmt>(S); 2274 2275 ForStmt->setBody(B); 2276 return S; 2277} 2278 2279/// FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement. 2280/// This is a separate step from ActOnCXXForRangeStmt because analysis of the 2281/// body cannot be performed until after the type of the range variable is 2282/// determined. 2283StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) { 2284 if (!S || !B) 2285 return StmtError(); 2286 2287 if (isa<ObjCForCollectionStmt>(S)) 2288 return FinishObjCForCollectionStmt(S, B); 2289 2290 CXXForRangeStmt *ForStmt = cast<CXXForRangeStmt>(S); 2291 ForStmt->setBody(B); 2292 2293 DiagnoseEmptyStmtBody(ForStmt->getRParenLoc(), B, 2294 diag::warn_empty_range_based_for_body); 2295 2296 return S; 2297} 2298 2299StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc, 2300 SourceLocation LabelLoc, 2301 LabelDecl *TheDecl) { 2302 getCurFunction()->setHasBranchIntoScope(); 2303 TheDecl->markUsed(Context); 2304 return Owned(new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc)); 2305} 2306 2307StmtResult 2308Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc, 2309 Expr *E) { 2310 // Convert operand to void* 2311 if (!E->isTypeDependent()) { 2312 QualType ETy = E->getType(); 2313 QualType DestTy = Context.getPointerType(Context.VoidTy.withConst()); 2314 ExprResult ExprRes = Owned(E); 2315 AssignConvertType ConvTy = 2316 CheckSingleAssignmentConstraints(DestTy, ExprRes); 2317 if (ExprRes.isInvalid()) 2318 return StmtError(); 2319 E = ExprRes.take(); 2320 if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E, AA_Passing)) 2321 return StmtError(); 2322 } 2323 2324 ExprResult ExprRes = ActOnFinishFullExpr(E); 2325 if (ExprRes.isInvalid()) 2326 return StmtError(); 2327 E = ExprRes.take(); 2328 2329 getCurFunction()->setHasIndirectGoto(); 2330 2331 return Owned(new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E)); 2332} 2333 2334StmtResult 2335Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) { 2336 Scope *S = CurScope->getContinueParent(); 2337 if (!S) { 2338 // C99 6.8.6.2p1: A break shall appear only in or as a loop body. 2339 return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop)); 2340 } 2341 2342 return Owned(new (Context) ContinueStmt(ContinueLoc)); 2343} 2344 2345StmtResult 2346Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) { 2347 Scope *S = CurScope->getBreakParent(); 2348 if (!S) { 2349 // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body. 2350 return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch)); 2351 } 2352 2353 return Owned(new (Context) BreakStmt(BreakLoc)); 2354} 2355 2356/// \brief Determine whether the given expression is a candidate for 2357/// copy elision in either a return statement or a throw expression. 2358/// 2359/// \param ReturnType If we're determining the copy elision candidate for 2360/// a return statement, this is the return type of the function. If we're 2361/// determining the copy elision candidate for a throw expression, this will 2362/// be a NULL type. 2363/// 2364/// \param E The expression being returned from the function or block, or 2365/// being thrown. 2366/// 2367/// \param AllowFunctionParameter Whether we allow function parameters to 2368/// be considered NRVO candidates. C++ prohibits this for NRVO itself, but 2369/// we re-use this logic to determine whether we should try to move as part of 2370/// a return or throw (which does allow function parameters). 2371/// 2372/// \returns The NRVO candidate variable, if the return statement may use the 2373/// NRVO, or NULL if there is no such candidate. 2374const VarDecl *Sema::getCopyElisionCandidate(QualType ReturnType, 2375 Expr *E, 2376 bool AllowFunctionParameter) { 2377 QualType ExprType = E->getType(); 2378 // - in a return statement in a function with ... 2379 // ... a class return type ... 2380 if (!ReturnType.isNull()) { 2381 if (!ReturnType->isRecordType()) 2382 return 0; 2383 // ... the same cv-unqualified type as the function return type ... 2384 if (!Context.hasSameUnqualifiedType(ReturnType, ExprType)) 2385 return 0; 2386 } 2387 2388 // ... the expression is the name of a non-volatile automatic object 2389 // (other than a function or catch-clause parameter)) ... 2390 const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens()); 2391 if (!DR || DR->refersToEnclosingLocal()) 2392 return 0; 2393 const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl()); 2394 if (!VD) 2395 return 0; 2396 2397 // ...object (other than a function or catch-clause parameter)... 2398 if (VD->getKind() != Decl::Var && 2399 !(AllowFunctionParameter && VD->getKind() == Decl::ParmVar)) 2400 return 0; 2401 if (VD->isExceptionVariable()) return 0; 2402 2403 // ...automatic... 2404 if (!VD->hasLocalStorage()) return 0; 2405 2406 // ...non-volatile... 2407 if (VD->getType().isVolatileQualified()) return 0; 2408 if (VD->getType()->isReferenceType()) return 0; 2409 2410 // __block variables can't be allocated in a way that permits NRVO. 2411 if (VD->hasAttr<BlocksAttr>()) return 0; 2412 2413 // Variables with higher required alignment than their type's ABI 2414 // alignment cannot use NRVO. 2415 if (VD->hasAttr<AlignedAttr>() && 2416 Context.getDeclAlign(VD) > Context.getTypeAlignInChars(VD->getType())) 2417 return 0; 2418 2419 return VD; 2420} 2421 2422/// \brief Perform the initialization of a potentially-movable value, which 2423/// is the result of return value. 2424/// 2425/// This routine implements C++0x [class.copy]p33, which attempts to treat 2426/// returned lvalues as rvalues in certain cases (to prefer move construction), 2427/// then falls back to treating them as lvalues if that failed. 2428ExprResult 2429Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity, 2430 const VarDecl *NRVOCandidate, 2431 QualType ResultType, 2432 Expr *Value, 2433 bool AllowNRVO) { 2434 // C++0x [class.copy]p33: 2435 // When the criteria for elision of a copy operation are met or would 2436 // be met save for the fact that the source object is a function 2437 // parameter, and the object to be copied is designated by an lvalue, 2438 // overload resolution to select the constructor for the copy is first 2439 // performed as if the object were designated by an rvalue. 2440 ExprResult Res = ExprError(); 2441 if (AllowNRVO && 2442 (NRVOCandidate || getCopyElisionCandidate(ResultType, Value, true))) { 2443 ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack, 2444 Value->getType(), CK_NoOp, Value, VK_XValue); 2445 2446 Expr *InitExpr = &AsRvalue; 2447 InitializationKind Kind 2448 = InitializationKind::CreateCopy(Value->getLocStart(), 2449 Value->getLocStart()); 2450 InitializationSequence Seq(*this, Entity, Kind, InitExpr); 2451 2452 // [...] If overload resolution fails, or if the type of the first 2453 // parameter of the selected constructor is not an rvalue reference 2454 // to the object's type (possibly cv-qualified), overload resolution 2455 // is performed again, considering the object as an lvalue. 2456 if (Seq) { 2457 for (InitializationSequence::step_iterator Step = Seq.step_begin(), 2458 StepEnd = Seq.step_end(); 2459 Step != StepEnd; ++Step) { 2460 if (Step->Kind != InitializationSequence::SK_ConstructorInitialization) 2461 continue; 2462 2463 CXXConstructorDecl *Constructor 2464 = cast<CXXConstructorDecl>(Step->Function.Function); 2465 2466 const RValueReferenceType *RRefType 2467 = Constructor->getParamDecl(0)->getType() 2468 ->getAs<RValueReferenceType>(); 2469 2470 // If we don't meet the criteria, break out now. 2471 if (!RRefType || 2472 !Context.hasSameUnqualifiedType(RRefType->getPointeeType(), 2473 Context.getTypeDeclType(Constructor->getParent()))) 2474 break; 2475 2476 // Promote "AsRvalue" to the heap, since we now need this 2477 // expression node to persist. 2478 Value = ImplicitCastExpr::Create(Context, Value->getType(), 2479 CK_NoOp, Value, 0, VK_XValue); 2480 2481 // Complete type-checking the initialization of the return type 2482 // using the constructor we found. 2483 Res = Seq.Perform(*this, Entity, Kind, Value); 2484 } 2485 } 2486 } 2487 2488 // Either we didn't meet the criteria for treating an lvalue as an rvalue, 2489 // above, or overload resolution failed. Either way, we need to try 2490 // (again) now with the return value expression as written. 2491 if (Res.isInvalid()) 2492 Res = PerformCopyInitialization(Entity, SourceLocation(), Value); 2493 2494 return Res; 2495} 2496 2497/// \brief Determine whether the declared return type of the specified function 2498/// contains 'auto'. 2499static bool hasDeducedReturnType(FunctionDecl *FD) { 2500 const FunctionProtoType *FPT = 2501 FD->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>(); 2502 return FPT->getResultType()->isUndeducedType(); 2503} 2504 2505/// ActOnCapScopeReturnStmt - Utility routine to type-check return statements 2506/// for capturing scopes. 2507/// 2508StmtResult 2509Sema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) { 2510 // If this is the first return we've seen, infer the return type. 2511 // [expr.prim.lambda]p4 in C++11; block literals follow the same rules. 2512 CapturingScopeInfo *CurCap = cast<CapturingScopeInfo>(getCurFunction()); 2513 QualType FnRetType = CurCap->ReturnType; 2514 LambdaScopeInfo *CurLambda = dyn_cast<LambdaScopeInfo>(CurCap); 2515 2516 if (CurLambda && hasDeducedReturnType(CurLambda->CallOperator)) { 2517 // In C++1y, the return type may involve 'auto'. 2518 // FIXME: Blocks might have a return type of 'auto' explicitly specified. 2519 FunctionDecl *FD = CurLambda->CallOperator; 2520 if (CurCap->ReturnType.isNull()) 2521 CurCap->ReturnType = FD->getResultType(); 2522 2523 AutoType *AT = CurCap->ReturnType->getContainedAutoType(); 2524 assert(AT && "lost auto type from lambda return type"); 2525 if (DeduceFunctionTypeFromReturnExpr(FD, ReturnLoc, RetValExp, AT)) { 2526 FD->setInvalidDecl(); 2527 return StmtError(); 2528 } 2529 CurCap->ReturnType = FnRetType = FD->getResultType(); 2530 } else if (CurCap->HasImplicitReturnType) { 2531 // For blocks/lambdas with implicit return types, we check each return 2532 // statement individually, and deduce the common return type when the block 2533 // or lambda is completed. 2534 // FIXME: Fold this into the 'auto' codepath above. 2535 if (RetValExp && !isa<InitListExpr>(RetValExp)) { 2536 ExprResult Result = DefaultFunctionArrayLvalueConversion(RetValExp); 2537 if (Result.isInvalid()) 2538 return StmtError(); 2539 RetValExp = Result.take(); 2540 2541 if (!CurContext->isDependentContext()) 2542 FnRetType = RetValExp->getType(); 2543 else 2544 FnRetType = CurCap->ReturnType = Context.DependentTy; 2545 } else { 2546 if (RetValExp) { 2547 // C++11 [expr.lambda.prim]p4 bans inferring the result from an 2548 // initializer list, because it is not an expression (even 2549 // though we represent it as one). We still deduce 'void'. 2550 Diag(ReturnLoc, diag::err_lambda_return_init_list) 2551 << RetValExp->getSourceRange(); 2552 } 2553 2554 FnRetType = Context.VoidTy; 2555 } 2556 2557 // Although we'll properly infer the type of the block once it's completed, 2558 // make sure we provide a return type now for better error recovery. 2559 if (CurCap->ReturnType.isNull()) 2560 CurCap->ReturnType = FnRetType; 2561 } 2562 assert(!FnRetType.isNull()); 2563 2564 if (BlockScopeInfo *CurBlock = dyn_cast<BlockScopeInfo>(CurCap)) { 2565 if (CurBlock->FunctionType->getAs<FunctionType>()->getNoReturnAttr()) { 2566 Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr); 2567 return StmtError(); 2568 } 2569 } else if (CapturedRegionScopeInfo *CurRegion = 2570 dyn_cast<CapturedRegionScopeInfo>(CurCap)) { 2571 Diag(ReturnLoc, diag::err_return_in_captured_stmt) << CurRegion->getRegionName(); 2572 return StmtError(); 2573 } else { 2574 assert(CurLambda && "unknown kind of captured scope"); 2575 if (CurLambda->CallOperator->getType()->getAs<FunctionType>() 2576 ->getNoReturnAttr()) { 2577 Diag(ReturnLoc, diag::err_noreturn_lambda_has_return_expr); 2578 return StmtError(); 2579 } 2580 } 2581 2582 // Otherwise, verify that this result type matches the previous one. We are 2583 // pickier with blocks than for normal functions because we don't have GCC 2584 // compatibility to worry about here. 2585 const VarDecl *NRVOCandidate = 0; 2586 if (FnRetType->isDependentType()) { 2587 // Delay processing for now. TODO: there are lots of dependent 2588 // types we can conclusively prove aren't void. 2589 } else if (FnRetType->isVoidType()) { 2590 if (RetValExp && !isa<InitListExpr>(RetValExp) && 2591 !(getLangOpts().CPlusPlus && 2592 (RetValExp->isTypeDependent() || 2593 RetValExp->getType()->isVoidType()))) { 2594 if (!getLangOpts().CPlusPlus && 2595 RetValExp->getType()->isVoidType()) 2596 Diag(ReturnLoc, diag::ext_return_has_void_expr) << "literal" << 2; 2597 else { 2598 Diag(ReturnLoc, diag::err_return_block_has_expr); 2599 RetValExp = 0; 2600 } 2601 } 2602 } else if (!RetValExp) { 2603 return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr)); 2604 } else if (!RetValExp->isTypeDependent()) { 2605 // we have a non-void block with an expression, continue checking 2606 2607 // C99 6.8.6.4p3(136): The return statement is not an assignment. The 2608 // overlap restriction of subclause 6.5.16.1 does not apply to the case of 2609 // function return. 2610 2611 // In C++ the return statement is handled via a copy initialization. 2612 // the C version of which boils down to CheckSingleAssignmentConstraints. 2613 NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false); 2614 InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc, 2615 FnRetType, 2616 NRVOCandidate != 0); 2617 ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate, 2618 FnRetType, RetValExp); 2619 if (Res.isInvalid()) { 2620 // FIXME: Cleanup temporaries here, anyway? 2621 return StmtError(); 2622 } 2623 RetValExp = Res.take(); 2624 CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc); 2625 } 2626 2627 if (RetValExp) { 2628 ExprResult ER = ActOnFinishFullExpr(RetValExp, ReturnLoc); 2629 if (ER.isInvalid()) 2630 return StmtError(); 2631 RetValExp = ER.take(); 2632 } 2633 ReturnStmt *Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 2634 NRVOCandidate); 2635 2636 // If we need to check for the named return value optimization, 2637 // or if we need to infer the return type, 2638 // save the return statement in our scope for later processing. 2639 if (CurCap->HasImplicitReturnType || 2640 (getLangOpts().CPlusPlus && FnRetType->isRecordType() && 2641 !CurContext->isDependentContext())) 2642 FunctionScopes.back()->Returns.push_back(Result); 2643 2644 return Owned(Result); 2645} 2646 2647/// Deduce the return type for a function from a returned expression, per 2648/// C++1y [dcl.spec.auto]p6. 2649bool Sema::DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD, 2650 SourceLocation ReturnLoc, 2651 Expr *&RetExpr, 2652 AutoType *AT) { 2653 TypeLoc OrigResultType = FD->getTypeSourceInfo()->getTypeLoc(). 2654 IgnoreParens().castAs<FunctionProtoTypeLoc>().getResultLoc(); 2655 QualType Deduced; 2656 2657 if (RetExpr && isa<InitListExpr>(RetExpr)) { 2658 // If the deduction is for a return statement and the initializer is 2659 // a braced-init-list, the program is ill-formed. 2660 Diag(RetExpr->getExprLoc(), 2661 getCurLambda() ? diag::err_lambda_return_init_list 2662 : diag::err_auto_fn_return_init_list) 2663 << RetExpr->getSourceRange(); 2664 return true; 2665 } 2666 2667 if (FD->isDependentContext()) { 2668 // C++1y [dcl.spec.auto]p12: 2669 // Return type deduction [...] occurs when the definition is 2670 // instantiated even if the function body contains a return 2671 // statement with a non-type-dependent operand. 2672 assert(AT->isDeduced() && "should have deduced to dependent type"); 2673 return false; 2674 } else if (RetExpr) { 2675 // If the deduction is for a return statement and the initializer is 2676 // a braced-init-list, the program is ill-formed. 2677 if (isa<InitListExpr>(RetExpr)) { 2678 Diag(RetExpr->getExprLoc(), diag::err_auto_fn_return_init_list); 2679 return true; 2680 } 2681 2682 // Otherwise, [...] deduce a value for U using the rules of template 2683 // argument deduction. 2684 DeduceAutoResult DAR = DeduceAutoType(OrigResultType, RetExpr, Deduced); 2685 2686 if (DAR == DAR_Failed && !FD->isInvalidDecl()) 2687 Diag(RetExpr->getExprLoc(), diag::err_auto_fn_deduction_failure) 2688 << OrigResultType.getType() << RetExpr->getType(); 2689 2690 if (DAR != DAR_Succeeded) 2691 return true; 2692 } else { 2693 // In the case of a return with no operand, the initializer is considered 2694 // to be void(). 2695 // 2696 // Deduction here can only succeed if the return type is exactly 'cv auto' 2697 // or 'decltype(auto)', so just check for that case directly. 2698 if (!OrigResultType.getType()->getAs<AutoType>()) { 2699 Diag(ReturnLoc, diag::err_auto_fn_return_void_but_not_auto) 2700 << OrigResultType.getType(); 2701 return true; 2702 } 2703 // We always deduce U = void in this case. 2704 Deduced = SubstAutoType(OrigResultType.getType(), Context.VoidTy); 2705 if (Deduced.isNull()) 2706 return true; 2707 } 2708 2709 // If a function with a declared return type that contains a placeholder type 2710 // has multiple return statements, the return type is deduced for each return 2711 // statement. [...] if the type deduced is not the same in each deduction, 2712 // the program is ill-formed. 2713 if (AT->isDeduced() && !FD->isInvalidDecl()) { 2714 AutoType *NewAT = Deduced->getContainedAutoType(); 2715 if (!FD->isDependentContext() && 2716 !Context.hasSameType(AT->getDeducedType(), NewAT->getDeducedType())) { 2717 const LambdaScopeInfo *LambdaSI = getCurLambda(); 2718 if (LambdaSI && LambdaSI->HasImplicitReturnType) { 2719 Diag(ReturnLoc, diag::err_typecheck_missing_return_type_incompatible) 2720 << NewAT->getDeducedType() << AT->getDeducedType() 2721 << true /*IsLambda*/; 2722 } else { 2723 Diag(ReturnLoc, diag::err_auto_fn_different_deductions) 2724 << (AT->isDecltypeAuto() ? 1 : 0) 2725 << NewAT->getDeducedType() << AT->getDeducedType(); 2726 } 2727 return true; 2728 } 2729 } else if (!FD->isInvalidDecl()) { 2730 // Update all declarations of the function to have the deduced return type. 2731 Context.adjustDeducedFunctionResultType(FD, Deduced); 2732 } 2733 2734 return false; 2735} 2736 2737StmtResult 2738Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) { 2739 // Check for unexpanded parameter packs. 2740 if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp)) 2741 return StmtError(); 2742 2743 if (isa<CapturingScopeInfo>(getCurFunction())) 2744 return ActOnCapScopeReturnStmt(ReturnLoc, RetValExp); 2745 2746 QualType FnRetType; 2747 QualType RelatedRetType; 2748 if (const FunctionDecl *FD = getCurFunctionDecl()) { 2749 FnRetType = FD->getResultType(); 2750 if (FD->isNoReturn()) 2751 Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr) 2752 << FD->getDeclName(); 2753 } else if (ObjCMethodDecl *MD = getCurMethodDecl()) { 2754 FnRetType = MD->getResultType(); 2755 if (MD->hasRelatedResultType() && MD->getClassInterface()) { 2756 // In the implementation of a method with a related return type, the 2757 // type used to type-check the validity of return statements within the 2758 // method body is a pointer to the type of the class being implemented. 2759 RelatedRetType = Context.getObjCInterfaceType(MD->getClassInterface()); 2760 RelatedRetType = Context.getObjCObjectPointerType(RelatedRetType); 2761 } 2762 } else // If we don't have a function/method context, bail. 2763 return StmtError(); 2764 2765 // FIXME: Add a flag to the ScopeInfo to indicate whether we're performing 2766 // deduction. 2767 if (getLangOpts().CPlusPlus1y) { 2768 if (AutoType *AT = FnRetType->getContainedAutoType()) { 2769 FunctionDecl *FD = cast<FunctionDecl>(CurContext); 2770 if (DeduceFunctionTypeFromReturnExpr(FD, ReturnLoc, RetValExp, AT)) { 2771 FD->setInvalidDecl(); 2772 return StmtError(); 2773 } else { 2774 FnRetType = FD->getResultType(); 2775 } 2776 } 2777 } 2778 2779 bool HasDependentReturnType = FnRetType->isDependentType(); 2780 2781 ReturnStmt *Result = 0; 2782 if (FnRetType->isVoidType()) { 2783 if (RetValExp) { 2784 if (isa<InitListExpr>(RetValExp)) { 2785 // We simply never allow init lists as the return value of void 2786 // functions. This is compatible because this was never allowed before, 2787 // so there's no legacy code to deal with. 2788 NamedDecl *CurDecl = getCurFunctionOrMethodDecl(); 2789 int FunctionKind = 0; 2790 if (isa<ObjCMethodDecl>(CurDecl)) 2791 FunctionKind = 1; 2792 else if (isa<CXXConstructorDecl>(CurDecl)) 2793 FunctionKind = 2; 2794 else if (isa<CXXDestructorDecl>(CurDecl)) 2795 FunctionKind = 3; 2796 2797 Diag(ReturnLoc, diag::err_return_init_list) 2798 << CurDecl->getDeclName() << FunctionKind 2799 << RetValExp->getSourceRange(); 2800 2801 // Drop the expression. 2802 RetValExp = 0; 2803 } else if (!RetValExp->isTypeDependent()) { 2804 // C99 6.8.6.4p1 (ext_ since GCC warns) 2805 unsigned D = diag::ext_return_has_expr; 2806 if (RetValExp->getType()->isVoidType()) 2807 D = diag::ext_return_has_void_expr; 2808 else { 2809 ExprResult Result = Owned(RetValExp); 2810 Result = IgnoredValueConversions(Result.take()); 2811 if (Result.isInvalid()) 2812 return StmtError(); 2813 RetValExp = Result.take(); 2814 RetValExp = ImpCastExprToType(RetValExp, 2815 Context.VoidTy, CK_ToVoid).take(); 2816 } 2817 2818 // return (some void expression); is legal in C++. 2819 if (D != diag::ext_return_has_void_expr || 2820 !getLangOpts().CPlusPlus) { 2821 NamedDecl *CurDecl = getCurFunctionOrMethodDecl(); 2822 2823 int FunctionKind = 0; 2824 if (isa<ObjCMethodDecl>(CurDecl)) 2825 FunctionKind = 1; 2826 else if (isa<CXXConstructorDecl>(CurDecl)) 2827 FunctionKind = 2; 2828 else if (isa<CXXDestructorDecl>(CurDecl)) 2829 FunctionKind = 3; 2830 2831 Diag(ReturnLoc, D) 2832 << CurDecl->getDeclName() << FunctionKind 2833 << RetValExp->getSourceRange(); 2834 } 2835 } 2836 2837 if (RetValExp) { 2838 ExprResult ER = ActOnFinishFullExpr(RetValExp, ReturnLoc); 2839 if (ER.isInvalid()) 2840 return StmtError(); 2841 RetValExp = ER.take(); 2842 } 2843 } 2844 2845 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 0); 2846 } else if (!RetValExp && !HasDependentReturnType) { 2847 unsigned DiagID = diag::warn_return_missing_expr; // C90 6.6.6.4p4 2848 // C99 6.8.6.4p1 (ext_ since GCC warns) 2849 if (getLangOpts().C99) DiagID = diag::ext_return_missing_expr; 2850 2851 if (FunctionDecl *FD = getCurFunctionDecl()) 2852 Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/; 2853 else 2854 Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/; 2855 Result = new (Context) ReturnStmt(ReturnLoc); 2856 } else { 2857 assert(RetValExp || HasDependentReturnType); 2858 const VarDecl *NRVOCandidate = 0; 2859 if (!HasDependentReturnType && !RetValExp->isTypeDependent()) { 2860 // we have a non-void function with an expression, continue checking 2861 2862 QualType RetType = (RelatedRetType.isNull() ? FnRetType : RelatedRetType); 2863 2864 // C99 6.8.6.4p3(136): The return statement is not an assignment. The 2865 // overlap restriction of subclause 6.5.16.1 does not apply to the case of 2866 // function return. 2867 2868 // In C++ the return statement is handled via a copy initialization, 2869 // the C version of which boils down to CheckSingleAssignmentConstraints. 2870 NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false); 2871 InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc, 2872 RetType, 2873 NRVOCandidate != 0); 2874 ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate, 2875 RetType, RetValExp); 2876 if (Res.isInvalid()) { 2877 // FIXME: Clean up temporaries here anyway? 2878 return StmtError(); 2879 } 2880 RetValExp = Res.takeAs<Expr>(); 2881 2882 // If we have a related result type, we need to implicitly 2883 // convert back to the formal result type. We can't pretend to 2884 // initialize the result again --- we might end double-retaining 2885 // --- so instead we initialize a notional temporary. 2886 if (!RelatedRetType.isNull()) { 2887 Entity = InitializedEntity::InitializeRelatedResult(getCurMethodDecl(), 2888 FnRetType); 2889 Res = PerformCopyInitialization(Entity, ReturnLoc, RetValExp); 2890 if (Res.isInvalid()) { 2891 // FIXME: Clean up temporaries here anyway? 2892 return StmtError(); 2893 } 2894 RetValExp = Res.takeAs<Expr>(); 2895 } 2896 2897 CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc); 2898 } 2899 2900 if (RetValExp) { 2901 ExprResult ER = ActOnFinishFullExpr(RetValExp, ReturnLoc); 2902 if (ER.isInvalid()) 2903 return StmtError(); 2904 RetValExp = ER.take(); 2905 } 2906 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate); 2907 } 2908 2909 // If we need to check for the named return value optimization, save the 2910 // return statement in our scope for later processing. 2911 if (getLangOpts().CPlusPlus && FnRetType->isRecordType() && 2912 !CurContext->isDependentContext()) 2913 FunctionScopes.back()->Returns.push_back(Result); 2914 2915 return Owned(Result); 2916} 2917 2918StmtResult 2919Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc, 2920 SourceLocation RParen, Decl *Parm, 2921 Stmt *Body) { 2922 VarDecl *Var = cast_or_null<VarDecl>(Parm); 2923 if (Var && Var->isInvalidDecl()) 2924 return StmtError(); 2925 2926 return Owned(new (Context) ObjCAtCatchStmt(AtLoc, RParen, Var, Body)); 2927} 2928 2929StmtResult 2930Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body) { 2931 return Owned(new (Context) ObjCAtFinallyStmt(AtLoc, Body)); 2932} 2933 2934StmtResult 2935Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try, 2936 MultiStmtArg CatchStmts, Stmt *Finally) { 2937 if (!getLangOpts().ObjCExceptions) 2938 Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@try"; 2939 2940 getCurFunction()->setHasBranchProtectedScope(); 2941 unsigned NumCatchStmts = CatchStmts.size(); 2942 return Owned(ObjCAtTryStmt::Create(Context, AtLoc, Try, 2943 CatchStmts.data(), 2944 NumCatchStmts, 2945 Finally)); 2946} 2947 2948StmtResult Sema::BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw) { 2949 if (Throw) { 2950 ExprResult Result = DefaultLvalueConversion(Throw); 2951 if (Result.isInvalid()) 2952 return StmtError(); 2953 2954 Result = ActOnFinishFullExpr(Result.take()); 2955 if (Result.isInvalid()) 2956 return StmtError(); 2957 Throw = Result.take(); 2958 2959 QualType ThrowType = Throw->getType(); 2960 // Make sure the expression type is an ObjC pointer or "void *". 2961 if (!ThrowType->isDependentType() && 2962 !ThrowType->isObjCObjectPointerType()) { 2963 const PointerType *PT = ThrowType->getAs<PointerType>(); 2964 if (!PT || !PT->getPointeeType()->isVoidType()) 2965 return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object) 2966 << Throw->getType() << Throw->getSourceRange()); 2967 } 2968 } 2969 2970 return Owned(new (Context) ObjCAtThrowStmt(AtLoc, Throw)); 2971} 2972 2973StmtResult 2974Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw, 2975 Scope *CurScope) { 2976 if (!getLangOpts().ObjCExceptions) 2977 Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@throw"; 2978 2979 if (!Throw) { 2980 // @throw without an expression designates a rethrow (which much occur 2981 // in the context of an @catch clause). 2982 Scope *AtCatchParent = CurScope; 2983 while (AtCatchParent && !AtCatchParent->isAtCatchScope()) 2984 AtCatchParent = AtCatchParent->getParent(); 2985 if (!AtCatchParent) 2986 return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch)); 2987 } 2988 return BuildObjCAtThrowStmt(AtLoc, Throw); 2989} 2990 2991ExprResult 2992Sema::ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, Expr *operand) { 2993 ExprResult result = DefaultLvalueConversion(operand); 2994 if (result.isInvalid()) 2995 return ExprError(); 2996 operand = result.take(); 2997 2998 // Make sure the expression type is an ObjC pointer or "void *". 2999 QualType type = operand->getType(); 3000 if (!type->isDependentType() && 3001 !type->isObjCObjectPointerType()) { 3002 const PointerType *pointerType = type->getAs<PointerType>(); 3003 if (!pointerType || !pointerType->getPointeeType()->isVoidType()) 3004 return Diag(atLoc, diag::error_objc_synchronized_expects_object) 3005 << type << operand->getSourceRange(); 3006 } 3007 3008 // The operand to @synchronized is a full-expression. 3009 return ActOnFinishFullExpr(operand); 3010} 3011 3012StmtResult 3013Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SyncExpr, 3014 Stmt *SyncBody) { 3015 // We can't jump into or indirect-jump out of a @synchronized block. 3016 getCurFunction()->setHasBranchProtectedScope(); 3017 return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc, SyncExpr, SyncBody)); 3018} 3019 3020/// ActOnCXXCatchBlock - Takes an exception declaration and a handler block 3021/// and creates a proper catch handler from them. 3022StmtResult 3023Sema::ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl, 3024 Stmt *HandlerBlock) { 3025 // There's nothing to test that ActOnExceptionDecl didn't already test. 3026 return Owned(new (Context) CXXCatchStmt(CatchLoc, 3027 cast_or_null<VarDecl>(ExDecl), 3028 HandlerBlock)); 3029} 3030 3031StmtResult 3032Sema::ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body) { 3033 getCurFunction()->setHasBranchProtectedScope(); 3034 return Owned(new (Context) ObjCAutoreleasePoolStmt(AtLoc, Body)); 3035} 3036 3037namespace { 3038 3039class TypeWithHandler { 3040 QualType t; 3041 CXXCatchStmt *stmt; 3042public: 3043 TypeWithHandler(const QualType &type, CXXCatchStmt *statement) 3044 : t(type), stmt(statement) {} 3045 3046 // An arbitrary order is fine as long as it places identical 3047 // types next to each other. 3048 bool operator<(const TypeWithHandler &y) const { 3049 if (t.getAsOpaquePtr() < y.t.getAsOpaquePtr()) 3050 return true; 3051 if (t.getAsOpaquePtr() > y.t.getAsOpaquePtr()) 3052 return false; 3053 else 3054 return getTypeSpecStartLoc() < y.getTypeSpecStartLoc(); 3055 } 3056 3057 bool operator==(const TypeWithHandler& other) const { 3058 return t == other.t; 3059 } 3060 3061 CXXCatchStmt *getCatchStmt() const { return stmt; } 3062 SourceLocation getTypeSpecStartLoc() const { 3063 return stmt->getExceptionDecl()->getTypeSpecStartLoc(); 3064 } 3065}; 3066 3067} 3068 3069/// ActOnCXXTryBlock - Takes a try compound-statement and a number of 3070/// handlers and creates a try statement from them. 3071StmtResult Sema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock, 3072 ArrayRef<Stmt *> Handlers) { 3073 // Don't report an error if 'try' is used in system headers. 3074 if (!getLangOpts().CXXExceptions && 3075 !getSourceManager().isInSystemHeader(TryLoc)) 3076 Diag(TryLoc, diag::err_exceptions_disabled) << "try"; 3077 3078 const unsigned NumHandlers = Handlers.size(); 3079 assert(NumHandlers > 0 && 3080 "The parser shouldn't call this if there are no handlers."); 3081 3082 SmallVector<TypeWithHandler, 8> TypesWithHandlers; 3083 3084 for (unsigned i = 0; i < NumHandlers; ++i) { 3085 CXXCatchStmt *Handler = cast<CXXCatchStmt>(Handlers[i]); 3086 if (!Handler->getExceptionDecl()) { 3087 if (i < NumHandlers - 1) 3088 return StmtError(Diag(Handler->getLocStart(), 3089 diag::err_early_catch_all)); 3090 3091 continue; 3092 } 3093 3094 const QualType CaughtType = Handler->getCaughtType(); 3095 const QualType CanonicalCaughtType = Context.getCanonicalType(CaughtType); 3096 TypesWithHandlers.push_back(TypeWithHandler(CanonicalCaughtType, Handler)); 3097 } 3098 3099 // Detect handlers for the same type as an earlier one. 3100 if (NumHandlers > 1) { 3101 llvm::array_pod_sort(TypesWithHandlers.begin(), TypesWithHandlers.end()); 3102 3103 TypeWithHandler prev = TypesWithHandlers[0]; 3104 for (unsigned i = 1; i < TypesWithHandlers.size(); ++i) { 3105 TypeWithHandler curr = TypesWithHandlers[i]; 3106 3107 if (curr == prev) { 3108 Diag(curr.getTypeSpecStartLoc(), 3109 diag::warn_exception_caught_by_earlier_handler) 3110 << curr.getCatchStmt()->getCaughtType().getAsString(); 3111 Diag(prev.getTypeSpecStartLoc(), 3112 diag::note_previous_exception_handler) 3113 << prev.getCatchStmt()->getCaughtType().getAsString(); 3114 } 3115 3116 prev = curr; 3117 } 3118 } 3119 3120 getCurFunction()->setHasBranchProtectedScope(); 3121 3122 // FIXME: We should detect handlers that cannot catch anything because an 3123 // earlier handler catches a superclass. Need to find a method that is not 3124 // quadratic for this. 3125 // Neither of these are explicitly forbidden, but every compiler detects them 3126 // and warns. 3127 3128 return Owned(CXXTryStmt::Create(Context, TryLoc, TryBlock, Handlers)); 3129} 3130 3131StmtResult 3132Sema::ActOnSEHTryBlock(bool IsCXXTry, 3133 SourceLocation TryLoc, 3134 Stmt *TryBlock, 3135 Stmt *Handler) { 3136 assert(TryBlock && Handler); 3137 3138 getCurFunction()->setHasBranchProtectedScope(); 3139 3140 return Owned(SEHTryStmt::Create(Context,IsCXXTry,TryLoc,TryBlock,Handler)); 3141} 3142 3143StmtResult 3144Sema::ActOnSEHExceptBlock(SourceLocation Loc, 3145 Expr *FilterExpr, 3146 Stmt *Block) { 3147 assert(FilterExpr && Block); 3148 3149 if(!FilterExpr->getType()->isIntegerType()) { 3150 return StmtError(Diag(FilterExpr->getExprLoc(), 3151 diag::err_filter_expression_integral) 3152 << FilterExpr->getType()); 3153 } 3154 3155 return Owned(SEHExceptStmt::Create(Context,Loc,FilterExpr,Block)); 3156} 3157 3158StmtResult 3159Sema::ActOnSEHFinallyBlock(SourceLocation Loc, 3160 Stmt *Block) { 3161 assert(Block); 3162 return Owned(SEHFinallyStmt::Create(Context,Loc,Block)); 3163} 3164 3165StmtResult Sema::BuildMSDependentExistsStmt(SourceLocation KeywordLoc, 3166 bool IsIfExists, 3167 NestedNameSpecifierLoc QualifierLoc, 3168 DeclarationNameInfo NameInfo, 3169 Stmt *Nested) 3170{ 3171 return new (Context) MSDependentExistsStmt(KeywordLoc, IsIfExists, 3172 QualifierLoc, NameInfo, 3173 cast<CompoundStmt>(Nested)); 3174} 3175 3176 3177StmtResult Sema::ActOnMSDependentExistsStmt(SourceLocation KeywordLoc, 3178 bool IsIfExists, 3179 CXXScopeSpec &SS, 3180 UnqualifiedId &Name, 3181 Stmt *Nested) { 3182 return BuildMSDependentExistsStmt(KeywordLoc, IsIfExists, 3183 SS.getWithLocInContext(Context), 3184 GetNameFromUnqualifiedId(Name), 3185 Nested); 3186} 3187 3188RecordDecl* 3189Sema::CreateCapturedStmtRecordDecl(CapturedDecl *&CD, SourceLocation Loc, 3190 unsigned NumParams) { 3191 DeclContext *DC = CurContext; 3192 while (!(DC->isFunctionOrMethod() || DC->isRecord() || DC->isFileContext())) 3193 DC = DC->getParent(); 3194 3195 RecordDecl *RD = 0; 3196 if (getLangOpts().CPlusPlus) 3197 RD = CXXRecordDecl::Create(Context, TTK_Struct, DC, Loc, Loc, /*Id=*/0); 3198 else 3199 RD = RecordDecl::Create(Context, TTK_Struct, DC, Loc, Loc, /*Id=*/0); 3200 3201 DC->addDecl(RD); 3202 RD->setImplicit(); 3203 RD->startDefinition(); 3204 3205 CD = CapturedDecl::Create(Context, CurContext, NumParams); 3206 DC->addDecl(CD); 3207 3208 // Build the context parameter 3209 assert(NumParams > 0 && "CapturedStmt requires context parameter"); 3210 DC = CapturedDecl::castToDeclContext(CD); 3211 IdentifierInfo *VarName = &Context.Idents.get("__context"); 3212 QualType ParamType = Context.getPointerType(Context.getTagDeclType(RD)); 3213 ImplicitParamDecl *Param 3214 = ImplicitParamDecl::Create(Context, DC, Loc, VarName, ParamType); 3215 DC->addDecl(Param); 3216 3217 CD->setContextParam(Param); 3218 3219 return RD; 3220} 3221 3222static void buildCapturedStmtCaptureList( 3223 SmallVectorImpl<CapturedStmt::Capture> &Captures, 3224 SmallVectorImpl<Expr *> &CaptureInits, 3225 ArrayRef<CapturingScopeInfo::Capture> Candidates) { 3226 3227 typedef ArrayRef<CapturingScopeInfo::Capture>::const_iterator CaptureIter; 3228 for (CaptureIter Cap = Candidates.begin(); Cap != Candidates.end(); ++Cap) { 3229 3230 if (Cap->isThisCapture()) { 3231 Captures.push_back(CapturedStmt::Capture(Cap->getLocation(), 3232 CapturedStmt::VCK_This)); 3233 CaptureInits.push_back(Cap->getInitExpr()); 3234 continue; 3235 } 3236 3237 assert(Cap->isReferenceCapture() && 3238 "non-reference capture not yet implemented"); 3239 3240 Captures.push_back(CapturedStmt::Capture(Cap->getLocation(), 3241 CapturedStmt::VCK_ByRef, 3242 Cap->getVariable())); 3243 CaptureInits.push_back(Cap->getInitExpr()); 3244 } 3245} 3246 3247void Sema::ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope, 3248 CapturedRegionKind Kind, 3249 unsigned NumParams) { 3250 CapturedDecl *CD = 0; 3251 RecordDecl *RD = CreateCapturedStmtRecordDecl(CD, Loc, NumParams); 3252 3253 // Enter the capturing scope for this captured region. 3254 PushCapturedRegionScope(CurScope, CD, RD, Kind); 3255 3256 if (CurScope) 3257 PushDeclContext(CurScope, CD); 3258 else 3259 CurContext = CD; 3260 3261 PushExpressionEvaluationContext(PotentiallyEvaluated); 3262} 3263 3264void Sema::ActOnCapturedRegionError() { 3265 DiscardCleanupsInEvaluationContext(); 3266 PopExpressionEvaluationContext(); 3267 3268 CapturedRegionScopeInfo *RSI = getCurCapturedRegion(); 3269 RecordDecl *Record = RSI->TheRecordDecl; 3270 Record->setInvalidDecl(); 3271 3272 SmallVector<Decl*, 4> Fields; 3273 for (RecordDecl::field_iterator I = Record->field_begin(), 3274 E = Record->field_end(); I != E; ++I) 3275 Fields.push_back(*I); 3276 ActOnFields(/*Scope=*/0, Record->getLocation(), Record, Fields, 3277 SourceLocation(), SourceLocation(), /*AttributeList=*/0); 3278 3279 PopDeclContext(); 3280 PopFunctionScopeInfo(); 3281} 3282 3283StmtResult Sema::ActOnCapturedRegionEnd(Stmt *S) { 3284 CapturedRegionScopeInfo *RSI = getCurCapturedRegion(); 3285 3286 SmallVector<CapturedStmt::Capture, 4> Captures; 3287 SmallVector<Expr *, 4> CaptureInits; 3288 buildCapturedStmtCaptureList(Captures, CaptureInits, RSI->Captures); 3289 3290 CapturedDecl *CD = RSI->TheCapturedDecl; 3291 RecordDecl *RD = RSI->TheRecordDecl; 3292 3293 CapturedStmt *Res = CapturedStmt::Create(getASTContext(), S, 3294 RSI->CapRegionKind, Captures, 3295 CaptureInits, CD, RD); 3296 3297 CD->setBody(Res->getCapturedStmt()); 3298 RD->completeDefinition(); 3299 3300 DiscardCleanupsInEvaluationContext(); 3301 PopExpressionEvaluationContext(); 3302 3303 PopDeclContext(); 3304 PopFunctionScopeInfo(); 3305 3306 return Owned(Res); 3307} 3308