lib/Sema/SemaStmt.cpp

   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/Sema/Scope.h"
  16 #include "clang/Sema/ScopeInfo.h"
  17 #include "clang/Sema/Initialization.h"
  18 #include "clang/Sema/Lookup.h"
  19 #include "clang/AST/APValue.h"
  20 #include "clang/AST/ASTContext.h"
  21 #include "clang/AST/DeclObjC.h"
  22 #include "clang/AST/ExprCXX.h"
  23 #include "clang/AST/ExprObjC.h"
  24 #include "clang/AST/StmtObjC.h"
  25 #include "clang/AST/StmtCXX.h"
  26 #include "clang/AST/TypeLoc.h"
  27 #include "clang/Lex/Preprocessor.h"
  28 #include "clang/Basic/TargetInfo.h"
  29 #include "llvm/ADT/ArrayRef.h"
  30 #include "llvm/ADT/STLExtras.h"
  31 #include "llvm/ADT/SmallVector.h"
  32 using namespace clang;
  33 using namespace sema;
  34
  35 StmtResult Sema::ActOnExprStmt(FullExprArg expr) {
  36   Expr *E = expr.get();
  37   if (!E) // FIXME: FullExprArg has no error state?
  38     return StmtError();
  39
  40   // C99 6.8.3p2: The expression in an expression statement is evaluated as a
  41   // void expression for its side effects.  Conversion to void allows any
  42   // operand, even incomplete types.
  43
  44   // Same thing in for stmt first clause (when expr) and third clause.
  45   return Owned(static_cast<Stmt*>(E));
  46 }
  47
  48
  49 StmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc,
  50                                SourceLocation LeadingEmptyMacroLoc) {
  51   return Owned(new (Context) NullStmt(SemiLoc, LeadingEmptyMacroLoc));
  52 }
  53
  54 StmtResult Sema::ActOnDeclStmt(DeclGroupPtrTy dg, SourceLocation StartLoc,
  55                                SourceLocation EndLoc) {
  56   DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
  57
  58   // If we have an invalid decl, just return an error.
  59   if (DG.isNull()) return StmtError();
  60
  61   return Owned(new (Context) DeclStmt(DG, StartLoc, EndLoc));
  62 }
  63
  64 void Sema::ActOnForEachDeclStmt(DeclGroupPtrTy dg) {
  65   DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
  66
  67   // If we have an invalid decl, just return.
  68   if (DG.isNull() || !DG.isSingleDecl()) return;
  69   // suppress any potential 'unused variable' warning.
  70   DG.getSingleDecl()->setUsed();
  71 }
  72
  73 void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
  74   if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
  75     return DiagnoseUnusedExprResult(Label->getSubStmt());
  76
  77   const Expr *E = dyn_cast_or_null<Expr>(S);
  78   if (!E)
  79     return;
  80
  81   SourceLocation Loc;
  82   SourceRange R1, R2;
  83   if (!E->isUnusedResultAWarning(Loc, R1, R2, Context))
  84     return;
  85
  86   // Okay, we have an unused result.  Depending on what the base expression is,
  87   // we might want to make a more specific diagnostic.  Check for one of these
  88   // cases now.
  89   unsigned DiagID = diag::warn_unused_expr;
  90   if (const ExprWithCleanups *Temps = dyn_cast<ExprWithCleanups>(E))
  91     E = Temps->getSubExpr();
  92   if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E))
  93     E = TempExpr->getSubExpr();
  94
  95   E = E->IgnoreParenImpCasts();
  96   if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
  97     if (E->getType()->isVoidType())
  98       return;
  99
 100     // If the callee has attribute pure, const, or warn_unused_result, warn with
 101     // a more specific message to make it clear what is happening.
 102     if (const Decl *FD = CE->getCalleeDecl()) {
 103       if (FD->getAttr<WarnUnusedResultAttr>()) {
 104         Diag(Loc, diag::warn_unused_call) << R1 << R2 << "warn_unused_result";
 105         return;
 106       }
 107       if (FD->getAttr<PureAttr>()) {
 108         Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure";
 109         return;
 110       }
 111       if (FD->getAttr<ConstAttr>()) {
 112         Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const";
 113         return;
 114       }
 115     }
 116   } else if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
 117     const ObjCMethodDecl *MD = ME->getMethodDecl();
 118     if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
 119       Diag(Loc, diag::warn_unused_call) << R1 << R2 << "warn_unused_result";
 120       return;
 121     }
 122   } else if (isa<ObjCPropertyRefExpr>(E)) {
 123     DiagID = diag::warn_unused_property_expr;
 124   } else if (const CXXFunctionalCastExpr *FC
 125                                        = dyn_cast<CXXFunctionalCastExpr>(E)) {
 126     if (isa<CXXConstructExpr>(FC->getSubExpr()) ||
 127         isa<CXXTemporaryObjectExpr>(FC->getSubExpr()))
 128       return;
 129   }
 130   // Diagnose "(void*) blah" as a typo for "(void) blah".
 131   else if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(E)) {
 132     TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
 133     QualType T = TI->getType();
 134
 135     // We really do want to use the non-canonical type here.
 136     if (T == Context.VoidPtrTy) {
 137       PointerTypeLoc TL = cast<PointerTypeLoc>(TI->getTypeLoc());
 138
 139       Diag(Loc, diag::warn_unused_voidptr)
 140         << FixItHint::CreateRemoval(TL.getStarLoc());
 141       return;
 142     }
 143   }
 144
 145   DiagRuntimeBehavior(Loc, 0, PDiag(DiagID) << R1 << R2);
 146 }
 147
 148 StmtResult
 149 Sema::ActOnCompoundStmt(SourceLocation L, SourceLocation R,
 150                         MultiStmtArg elts, bool isStmtExpr) {
 151   unsigned NumElts = elts.size();
 152   Stmt **Elts = reinterpret_cast<Stmt**>(elts.release());
 153   // If we're in C89 mode, check that we don't have any decls after stmts.  If
 154   // so, emit an extension diagnostic.
 155   if (!getLangOptions().C99 && !getLangOptions().CPlusPlus) {
 156     // Note that __extension__ can be around a decl.
 157     unsigned i = 0;
 158     // Skip over all declarations.
 159     for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
 160       /*empty*/;
 161
 162     // We found the end of the list or a statement.  Scan for another declstmt.
 163     for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
 164       /*empty*/;
 165
 166     if (i != NumElts) {
 167       Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin();
 168       Diag(D->getLocation(), diag::ext_mixed_decls_code);
 169     }
 170   }
 171   // Warn about unused expressions in statements.
 172   for (unsigned i = 0; i != NumElts; ++i) {
 173     // Ignore statements that are last in a statement expression.
 174     if (isStmtExpr && i == NumElts - 1)
 175       continue;
 176
 177     DiagnoseUnusedExprResult(Elts[i]);
 178   }
 179
 180   return Owned(new (Context) CompoundStmt(Context, Elts, NumElts, L, R));
 181 }
 182
 183 StmtResult
 184 Sema::ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
 185                     SourceLocation DotDotDotLoc, Expr *RHSVal,
 186                     SourceLocation ColonLoc) {
 187   assert((LHSVal != 0) && "missing expression in case statement");
 188
 189   // C99 6.8.4.2p3: The expression shall be an integer constant.
 190   // However, GCC allows any evaluatable integer expression.
 191   if (!LHSVal->isTypeDependent() && !LHSVal->isValueDependent() &&
 192       VerifyIntegerConstantExpression(LHSVal))
 193     return StmtError();
 194
 195   // GCC extension: The expression shall be an integer constant.
 196
 197   if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent() &&
 198       VerifyIntegerConstantExpression(RHSVal)) {
 199     RHSVal = 0;  // Recover by just forgetting about it.
 200   }
 201
 202   if (getCurFunction()->SwitchStack.empty()) {
 203     Diag(CaseLoc, diag::err_case_not_in_switch);
 204     return StmtError();
 205   }
 206
 207   CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc,
 208                                         ColonLoc);
 209   getCurFunction()->SwitchStack.back()->addSwitchCase(CS);
 210   return Owned(CS);
 211 }
 212
 213 /// ActOnCaseStmtBody - This installs a statement as the body of a case.
 214 void Sema::ActOnCaseStmtBody(Stmt *caseStmt, Stmt *SubStmt) {
 215   CaseStmt *CS = static_cast<CaseStmt*>(caseStmt);
 216   CS->setSubStmt(SubStmt);
 217 }
 218
 219 StmtResult
 220 Sema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc,
 221                        Stmt *SubStmt, Scope *CurScope) {
 222   if (getCurFunction()->SwitchStack.empty()) {
 223     Diag(DefaultLoc, diag::err_default_not_in_switch);
 224     return Owned(SubStmt);
 225   }
 226
 227   DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt);
 228   getCurFunction()->SwitchStack.back()->addSwitchCase(DS);
 229   return Owned(DS);
 230 }
 231
 232 StmtResult
 233 Sema::ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
 234                      SourceLocation ColonLoc, Stmt *SubStmt) {
 235
 236   // If the label was multiply defined, reject it now.
 237   if (TheDecl->getStmt()) {
 238     Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->getDeclName();
 239     Diag(TheDecl->getLocation(), diag::note_previous_definition);
 240     return Owned(SubStmt);
 241   }
 242
 243   // Otherwise, things are good.  Fill in the declaration and return it.
 244   LabelStmt *LS = new (Context) LabelStmt(IdentLoc, TheDecl, SubStmt);
 245   TheDecl->setStmt(LS);
 246   if (!TheDecl->isGnuLocal())
 247     TheDecl->setLocation(IdentLoc);
 248   return Owned(LS);
 249 }
 250
 251 StmtResult
 252 Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, Decl *CondVar,
 253                   Stmt *thenStmt, SourceLocation ElseLoc,
 254                   Stmt *elseStmt) {
 255   ExprResult CondResult(CondVal.release());
 256
 257   VarDecl *ConditionVar = 0;
 258   if (CondVar) {
 259     ConditionVar = cast<VarDecl>(CondVar);
 260     CondResult = CheckConditionVariable(ConditionVar, IfLoc, true);
 261     if (CondResult.isInvalid())
 262       return StmtError();
 263   }
 264   Expr *ConditionExpr = CondResult.takeAs<Expr>();
 265   if (!ConditionExpr)
 266     return StmtError();
 267
 268   DiagnoseUnusedExprResult(thenStmt);
 269
 270   // Warn if the if block has a null body without an else value.
 271   // this helps prevent bugs due to typos, such as
 272   // if (condition);
 273   //   do_stuff();
 274   //
 275   if (!elseStmt) {
 276     if (NullStmt* stmt = dyn_cast<NullStmt>(thenStmt))
 277       // But do not warn if the body is a macro that expands to nothing, e.g:
 278       //
 279       // #define CALL(x)
 280       // if (condition)
 281       //   CALL(0);
 282       //
 283       if (!stmt->hasLeadingEmptyMacro())
 284         Diag(stmt->getSemiLoc(), diag::warn_empty_if_body);
 285   }
 286
 287   DiagnoseUnusedExprResult(elseStmt);
 288
 289   return Owned(new (Context) IfStmt(Context, IfLoc, ConditionVar, ConditionExpr,
 290                                     thenStmt, ElseLoc, elseStmt));
 291 }
 292
 293 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
 294 /// the specified width and sign.  If an overflow occurs, detect it and emit
 295 /// the specified diagnostic.
 296 void Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val,
 297                                               unsigned NewWidth, bool NewSign,
 298                                               SourceLocation Loc,
 299                                               unsigned DiagID) {
 300   // Perform a conversion to the promoted condition type if needed.
 301   if (NewWidth > Val.getBitWidth()) {
 302     // If this is an extension, just do it.
 303     Val = Val.extend(NewWidth);
 304     Val.setIsSigned(NewSign);
 305
 306     // If the input was signed and negative and the output is
 307     // unsigned, don't bother to warn: this is implementation-defined
 308     // behavior.
 309     // FIXME: Introduce a second, default-ignored warning for this case?
 310   } else if (NewWidth < Val.getBitWidth()) {
 311     // If this is a truncation, check for overflow.
 312     llvm::APSInt ConvVal(Val);
 313     ConvVal = ConvVal.trunc(NewWidth);
 314     ConvVal.setIsSigned(NewSign);
 315     ConvVal = ConvVal.extend(Val.getBitWidth());
 316     ConvVal.setIsSigned(Val.isSigned());
 317     if (ConvVal != Val)
 318       Diag(Loc, DiagID) << Val.toString(10) << ConvVal.toString(10);
 319
 320     // Regardless of whether a diagnostic was emitted, really do the
 321     // truncation.
 322     Val = Val.trunc(NewWidth);
 323     Val.setIsSigned(NewSign);
 324   } else if (NewSign != Val.isSigned()) {
 325     // Convert the sign to match the sign of the condition.  This can cause
 326     // overflow as well: unsigned(INTMIN)
 327     // We don't diagnose this overflow, because it is implementation-defined
 328     // behavior.
 329     // FIXME: Introduce a second, default-ignored warning for this case?
 330     llvm::APSInt OldVal(Val);
 331     Val.setIsSigned(NewSign);
 332   }
 333 }
 334
 335 namespace {
 336   struct CaseCompareFunctor {
 337     bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
 338                     const llvm::APSInt &RHS) {
 339       return LHS.first < RHS;
 340     }
 341     bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
 342                     const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
 343       return LHS.first < RHS.first;
 344     }
 345     bool operator()(const llvm::APSInt &LHS,
 346                     const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
 347       return LHS < RHS.first;
 348     }
 349   };
 350 }
 351
 352 /// CmpCaseVals - Comparison predicate for sorting case values.
 353 ///
 354 static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs,
 355                         const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
 356   if (lhs.first < rhs.first)
 357     return true;
 358
 359   if (lhs.first == rhs.first &&
 360       lhs.second->getCaseLoc().getRawEncoding()
 361        < rhs.second->getCaseLoc().getRawEncoding())
 362     return true;
 363   return false;
 364 }
 365
 366 /// CmpEnumVals - Comparison predicate for sorting enumeration values.
 367 ///
 368 static bool CmpEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
 369                         const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
 370 {
 371   return lhs.first < rhs.first;
 372 }
 373
 374 /// EqEnumVals - Comparison preficate for uniqing enumeration values.
 375 ///
 376 static bool EqEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
 377                        const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
 378 {
 379   return lhs.first == rhs.first;
 380 }
 381
 382 /// GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of
 383 /// potentially integral-promoted expression @p expr.
 384 static QualType GetTypeBeforeIntegralPromotion(const Expr* expr) {
 385   if (const CastExpr *ImplicitCast = dyn_cast<ImplicitCastExpr>(expr)) {
 386     const Expr *ExprBeforePromotion = ImplicitCast->getSubExpr();
 387     QualType TypeBeforePromotion = ExprBeforePromotion->getType();
 388     if (TypeBeforePromotion->isIntegralOrEnumerationType()) {
 389       return TypeBeforePromotion;
 390     }
 391   }
 392   return expr->getType();
 393 }
 394
 395 StmtResult
 396 Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, Expr *Cond,
 397                              Decl *CondVar) {
 398   ExprResult CondResult;
 399
 400   VarDecl *ConditionVar = 0;
 401   if (CondVar) {
 402     ConditionVar = cast<VarDecl>(CondVar);
 403     CondResult = CheckConditionVariable(ConditionVar, SourceLocation(), false);
 404     if (CondResult.isInvalid())
 405       return StmtError();
 406
 407     Cond = CondResult.release();
 408   }
 409
 410   if (!Cond)
 411     return StmtError();
 412
 413   CondResult
 414     = ConvertToIntegralOrEnumerationType(SwitchLoc, Cond,
 415                           PDiag(diag::err_typecheck_statement_requires_integer),
 416                                    PDiag(diag::err_switch_incomplete_class_type)
 417                                      << Cond->getSourceRange(),
 418                                    PDiag(diag::err_switch_explicit_conversion),
 419                                          PDiag(diag::note_switch_conversion),
 420                                    PDiag(diag::err_switch_multiple_conversions),
 421                                          PDiag(diag::note_switch_conversion),
 422                                          PDiag(0));
 423   if (CondResult.isInvalid()) return StmtError();
 424   Cond = CondResult.take();
 425
 426   if (!CondVar) {
 427     CheckImplicitConversions(Cond, SwitchLoc);
 428     CondResult = MaybeCreateExprWithCleanups(Cond);
 429     if (CondResult.isInvalid())
 430       return StmtError();
 431     Cond = CondResult.take();
 432   }
 433
 434   getCurFunction()->setHasBranchIntoScope();
 435
 436   SwitchStmt *SS = new (Context) SwitchStmt(Context, ConditionVar, Cond);
 437   getCurFunction()->SwitchStack.push_back(SS);
 438   return Owned(SS);
 439 }
 440
 441 static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned) {
 442   if (Val.getBitWidth() < BitWidth)
 443     Val = Val.extend(BitWidth);
 444   else if (Val.getBitWidth() > BitWidth)
 445     Val = Val.trunc(BitWidth);
 446   Val.setIsSigned(IsSigned);
 447 }
 448
 449 StmtResult
 450 Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch,
 451                             Stmt *BodyStmt) {
 452   SwitchStmt *SS = cast<SwitchStmt>(Switch);
 453   assert(SS == getCurFunction()->SwitchStack.back() &&
 454          "switch stack missing push/pop!");
 455
 456   SS->setBody(BodyStmt, SwitchLoc);
 457   getCurFunction()->SwitchStack.pop_back();
 458
 459   if (SS->getCond() == 0)
 460     return StmtError();
 461
 462   Expr *CondExpr = SS->getCond();
 463   Expr *CondExprBeforePromotion = CondExpr;
 464   QualType CondTypeBeforePromotion =
 465       GetTypeBeforeIntegralPromotion(CondExpr);
 466
 467   // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr.
 468   ExprResult CondResult = UsualUnaryConversions(CondExpr);
 469   if (CondResult.isInvalid())
 470     return StmtError();
 471   CondExpr = CondResult.take();
 472   QualType CondType = CondExpr->getType();
 473   SS->setCond(CondExpr);
 474
 475   // C++ 6.4.2.p2:
 476   // Integral promotions are performed (on the switch condition).
 477   //
 478   // A case value unrepresentable by the original switch condition
 479   // type (before the promotion) doesn't make sense, even when it can
 480   // be represented by the promoted type.  Therefore we need to find
 481   // the pre-promotion type of the switch condition.
 482   if (!CondExpr->isTypeDependent()) {
 483     // We have already converted the expression to an integral or enumeration
 484     // type, when we started the switch statement. If we don't have an
 485     // appropriate type now, just return an error.
 486     if (!CondType->isIntegralOrEnumerationType())
 487       return StmtError();
 488
 489     if (CondExpr->isKnownToHaveBooleanValue()) {
 490       // switch(bool_expr) {...} is often a programmer error, e.g.
 491       //   switch(n && mask) { ... }  // Doh - should be "n & mask".
 492       // One can always use an if statement instead of switch(bool_expr).
 493       Diag(SwitchLoc, diag::warn_bool_switch_condition)
 494           << CondExpr->getSourceRange();
 495     }
 496   }
 497
 498   // Get the bitwidth of the switched-on value before promotions.  We must
 499   // convert the integer case values to this width before comparison.
 500   bool HasDependentValue
 501     = CondExpr->isTypeDependent() || CondExpr->isValueDependent();
 502   unsigned CondWidth
 503     = HasDependentValue ? 0 : Context.getIntWidth(CondTypeBeforePromotion);
 504   bool CondIsSigned
 505     = CondTypeBeforePromotion->isSignedIntegerOrEnumerationType();
 506
 507   // Accumulate all of the case values in a vector so that we can sort them
 508   // and detect duplicates.  This vector contains the APInt for the case after
 509   // it has been converted to the condition type.
 510   typedef llvm::SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy;
 511   CaseValsTy CaseVals;
 512
 513   // Keep track of any GNU case ranges we see.  The APSInt is the low value.
 514   typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy;
 515   CaseRangesTy CaseRanges;
 516
 517   DefaultStmt *TheDefaultStmt = 0;
 518
 519   bool CaseListIsErroneous = false;
 520
 521   for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue;
 522        SC = SC->getNextSwitchCase()) {
 523
 524     if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
 525       if (TheDefaultStmt) {
 526         Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);
 527         Diag(TheDefaultStmt->getDefaultLoc(), diag::note_duplicate_case_prev);
 528
 529         // FIXME: Remove the default statement from the switch block so that
 530         // we'll return a valid AST.  This requires recursing down the AST and
 531         // finding it, not something we are set up to do right now.  For now,
 532         // just lop the entire switch stmt out of the AST.
 533         CaseListIsErroneous = true;
 534       }
 535       TheDefaultStmt = DS;
 536
 537     } else {
 538       CaseStmt *CS = cast<CaseStmt>(SC);
 539
 540       // We already verified that the expression has a i-c-e value (C99
 541       // 6.8.4.2p3) - get that value now.
 542       Expr *Lo = CS->getLHS();
 543
 544       if (Lo->isTypeDependent() || Lo->isValueDependent()) {
 545         HasDependentValue = true;
 546         break;
 547       }
 548
 549       llvm::APSInt LoVal = Lo->EvaluateAsInt(Context);
 550
 551       // Convert the value to the same width/sign as the condition.
 552       ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned,
 553                                          Lo->getLocStart(),
 554                                          diag::warn_case_value_overflow);
 555
 556       // If the LHS is not the same type as the condition, insert an implicit
 557       // cast.
 558       Lo = ImpCastExprToType(Lo, CondType, CK_IntegralCast).take();
 559       CS->setLHS(Lo);
 560
 561       // If this is a case range, remember it in CaseRanges, otherwise CaseVals.
 562       if (CS->getRHS()) {
 563         if (CS->getRHS()->isTypeDependent() ||
 564             CS->getRHS()->isValueDependent()) {
 565           HasDependentValue = true;
 566           break;
 567         }
 568         CaseRanges.push_back(std::make_pair(LoVal, CS));
 569       } else
 570         CaseVals.push_back(std::make_pair(LoVal, CS));
 571     }
 572   }
 573
 574   if (!HasDependentValue) {
 575     // If we don't have a default statement, check whether the
 576     // condition is constant.
 577     llvm::APSInt ConstantCondValue;
 578     bool HasConstantCond = false;
 579     bool ShouldCheckConstantCond = false;
 580     if (!HasDependentValue && !TheDefaultStmt) {
 581       Expr::EvalResult Result;
 582       HasConstantCond = CondExprBeforePromotion->Evaluate(Result, Context);
 583       if (HasConstantCond) {
 584         assert(Result.Val.isInt() && "switch condition evaluated to non-int");
 585         ConstantCondValue = Result.Val.getInt();
 586         ShouldCheckConstantCond = true;
 587
 588         assert(ConstantCondValue.getBitWidth() == CondWidth &&
 589                ConstantCondValue.isSigned() == CondIsSigned);
 590       }
 591     }
 592
 593     // Sort all the scalar case values so we can easily detect duplicates.
 594     std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals);
 595
 596     if (!CaseVals.empty()) {
 597       for (unsigned i = 0, e = CaseVals.size(); i != e; ++i) {
 598         if (ShouldCheckConstantCond &&
 599             CaseVals[i].first == ConstantCondValue)
 600           ShouldCheckConstantCond = false;
 601
 602         if (i != 0 && CaseVals[i].first == CaseVals[i-1].first) {
 603           // If we have a duplicate, report it.
 604           Diag(CaseVals[i].second->getLHS()->getLocStart(),
 605                diag::err_duplicate_case) << CaseVals[i].first.toString(10);
 606           Diag(CaseVals[i-1].second->getLHS()->getLocStart(),
 607                diag::note_duplicate_case_prev);
 608           // FIXME: We really want to remove the bogus case stmt from the
 609           // substmt, but we have no way to do this right now.
 610           CaseListIsErroneous = true;
 611         }
 612       }
 613     }
 614
 615     // Detect duplicate case ranges, which usually don't exist at all in
 616     // the first place.
 617     if (!CaseRanges.empty()) {
 618       // Sort all the case ranges by their low value so we can easily detect
 619       // overlaps between ranges.
 620       std::stable_sort(CaseRanges.begin(), CaseRanges.end());
 621
 622       // Scan the ranges, computing the high values and removing empty ranges.
 623       std::vector<llvm::APSInt> HiVals;
 624       for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
 625         llvm::APSInt &LoVal = CaseRanges[i].first;
 626         CaseStmt *CR = CaseRanges[i].second;
 627         Expr *Hi = CR->getRHS();
 628         llvm::APSInt HiVal = Hi->EvaluateAsInt(Context);
 629
 630         // Convert the value to the same width/sign as the condition.
 631         ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned,
 632                                            Hi->getLocStart(),
 633                                            diag::warn_case_value_overflow);
 634
 635         // If the LHS is not the same type as the condition, insert an implicit
 636         // cast.
 637         Hi = ImpCastExprToType(Hi, CondType, CK_IntegralCast).take();
 638         CR->setRHS(Hi);
 639
 640         // If the low value is bigger than the high value, the case is empty.
 641         if (LoVal > HiVal) {
 642           Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range)
 643             << SourceRange(CR->getLHS()->getLocStart(),
 644                            Hi->getLocEnd());
 645           CaseRanges.erase(CaseRanges.begin()+i);
 646           --i, --e;
 647           continue;
 648         }
 649
 650         if (ShouldCheckConstantCond &&
 651             LoVal <= ConstantCondValue &&
 652             ConstantCondValue <= HiVal)
 653           ShouldCheckConstantCond = false;
 654
 655         HiVals.push_back(HiVal);
 656       }
 657
 658       // Rescan the ranges, looking for overlap with singleton values and other
 659       // ranges.  Since the range list is sorted, we only need to compare case
 660       // ranges with their neighbors.
 661       for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
 662         llvm::APSInt &CRLo = CaseRanges[i].first;
 663         llvm::APSInt &CRHi = HiVals[i];
 664         CaseStmt *CR = CaseRanges[i].second;
 665
 666         // Check to see whether the case range overlaps with any
 667         // singleton cases.
 668         CaseStmt *OverlapStmt = 0;
 669         llvm::APSInt OverlapVal(32);
 670
 671         // Find the smallest value >= the lower bound.  If I is in the
 672         // case range, then we have overlap.
 673         CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(),
 674                                                   CaseVals.end(), CRLo,
 675                                                   CaseCompareFunctor());
 676         if (I != CaseVals.end() && I->first < CRHi) {
 677           OverlapVal  = I->first;   // Found overlap with scalar.
 678           OverlapStmt = I->second;
 679         }
 680
 681         // Find the smallest value bigger than the upper bound.
 682         I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());
 683         if (I != CaseVals.begin() && (I-1)->first >= CRLo) {
 684           OverlapVal  = (I-1)->first;      // Found overlap with scalar.
 685           OverlapStmt = (I-1)->second;
 686         }
 687
 688         // Check to see if this case stmt overlaps with the subsequent
 689         // case range.
 690         if (i && CRLo <= HiVals[i-1]) {
 691           OverlapVal  = HiVals[i-1];       // Found overlap with range.
 692           OverlapStmt = CaseRanges[i-1].second;
 693         }
 694
 695         if (OverlapStmt) {
 696           // If we have a duplicate, report it.
 697           Diag(CR->getLHS()->getLocStart(), diag::err_duplicate_case)
 698             << OverlapVal.toString(10);
 699           Diag(OverlapStmt->getLHS()->getLocStart(),
 700                diag::note_duplicate_case_prev);
 701           // FIXME: We really want to remove the bogus case stmt from the
 702           // substmt, but we have no way to do this right now.
 703           CaseListIsErroneous = true;
 704         }
 705       }
 706     }
 707
 708     // Complain if we have a constant condition and we didn't find a match.
 709     if (!CaseListIsErroneous && ShouldCheckConstantCond) {
 710       // TODO: it would be nice if we printed enums as enums, chars as
 711       // chars, etc.
 712       Diag(CondExpr->getExprLoc(), diag::warn_missing_case_for_condition)
 713         << ConstantCondValue.toString(10)
 714         << CondExpr->getSourceRange();
 715     }
 716
 717     // Check to see if switch is over an Enum and handles all of its
 718     // values.  We only issue a warning if there is not 'default:', but
 719     // we still do the analysis to preserve this information in the AST
 720     // (which can be used by flow-based analyes).
 721     //
 722     const EnumType *ET = CondTypeBeforePromotion->getAs<EnumType>();
 723
 724     // If switch has default case, then ignore it.
 725     if (!CaseListIsErroneous  && !HasConstantCond && ET) {
 726       const EnumDecl *ED = ET->getDecl();
 727       typedef llvm::SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64>
 728         EnumValsTy;
 729       EnumValsTy EnumVals;
 730
 731       // Gather all enum values, set their type and sort them,
 732       // allowing easier comparison with CaseVals.
 733       for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin();
 734            EDI != ED->enumerator_end(); ++EDI) {
 735         llvm::APSInt Val = EDI->getInitVal();
 736         AdjustAPSInt(Val, CondWidth, CondIsSigned);
 737         EnumVals.push_back(std::make_pair(Val, *EDI));
 738       }
 739       std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals);
 740       EnumValsTy::iterator EIend =
 741         std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
 742
 743       // See which case values aren't in enum.
 744       // TODO: we might want to check whether case values are out of the
 745       // enum even if we don't want to check whether all cases are handled.
 746       if (!TheDefaultStmt) {
 747         EnumValsTy::const_iterator EI = EnumVals.begin();
 748         for (CaseValsTy::const_iterator CI = CaseVals.begin();
 749              CI != CaseVals.end(); CI++) {
 750           while (EI != EIend && EI->first < CI->first)
 751             EI++;
 752           if (EI == EIend || EI->first > CI->first)
 753             Diag(CI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
 754               << ED->getDeclName();
 755         }
 756         // See which of case ranges aren't in enum
 757         EI = EnumVals.begin();
 758         for (CaseRangesTy::const_iterator RI = CaseRanges.begin();
 759              RI != CaseRanges.end() && EI != EIend; RI++) {
 760           while (EI != EIend && EI->first < RI->first)
 761             EI++;
 762
 763           if (EI == EIend || EI->first != RI->first) {
 764             Diag(RI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
 765               << ED->getDeclName();
 766           }
 767
 768           llvm::APSInt Hi = RI->second->getRHS()->EvaluateAsInt(Context);
 769           AdjustAPSInt(Hi, CondWidth, CondIsSigned);
 770           while (EI != EIend && EI->first < Hi)
 771             EI++;
 772           if (EI == EIend || EI->first != Hi)
 773             Diag(RI->second->getRHS()->getExprLoc(), diag::warn_not_in_enum)
 774               << ED->getDeclName();
 775         }
 776       }
 777
 778       // Check which enum vals aren't in switch
 779       CaseValsTy::const_iterator CI = CaseVals.begin();
 780       CaseRangesTy::const_iterator RI = CaseRanges.begin();
 781       bool hasCasesNotInSwitch = false;
 782
 783       llvm::SmallVector<DeclarationName,8> UnhandledNames;
 784
 785       for (EnumValsTy::const_iterator EI = EnumVals.begin(); EI != EIend; EI++){
 786         // Drop unneeded case values
 787         llvm::APSInt CIVal;
 788         while (CI != CaseVals.end() && CI->first < EI->first)
 789           CI++;
 790
 791         if (CI != CaseVals.end() && CI->first == EI->first)
 792           continue;
 793
 794         // Drop unneeded case ranges
 795         for (; RI != CaseRanges.end(); RI++) {
 796           llvm::APSInt Hi = RI->second->getRHS()->EvaluateAsInt(Context);
 797           AdjustAPSInt(Hi, CondWidth, CondIsSigned);
 798           if (EI->first <= Hi)
 799             break;
 800         }
 801
 802         if (RI == CaseRanges.end() || EI->first < RI->first) {
 803           hasCasesNotInSwitch = true;
 804           if (!TheDefaultStmt)
 805             UnhandledNames.push_back(EI->second->getDeclName());
 806         }
 807       }
 808
 809       // Produce a nice diagnostic if multiple values aren't handled.
 810       switch (UnhandledNames.size()) {
 811       case 0: break;
 812       case 1:
 813         Diag(CondExpr->getExprLoc(), diag::warn_missing_case1)
 814           << UnhandledNames[0];
 815         break;
 816       case 2:
 817         Diag(CondExpr->getExprLoc(), diag::warn_missing_case2)
 818           << UnhandledNames[0] << UnhandledNames[1];
 819         break;
 820       case 3:
 821         Diag(CondExpr->getExprLoc(), diag::warn_missing_case3)
 822           << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
 823         break;
 824       default:
 825         Diag(CondExpr->getExprLoc(), diag::warn_missing_cases)
 826           << (unsigned)UnhandledNames.size()
 827           << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
 828         break;
 829       }
 830
 831       if (!hasCasesNotInSwitch)
 832         SS->setAllEnumCasesCovered();
 833     }
 834   }
 835
 836   // FIXME: If the case list was broken is some way, we don't have a good system
 837   // to patch it up.  Instead, just return the whole substmt as broken.
 838   if (CaseListIsErroneous)
 839     return StmtError();
 840
 841   return Owned(SS);
 842 }
 843
 844 StmtResult
 845 Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond,
 846                      Decl *CondVar, Stmt *Body) {
 847   ExprResult CondResult(Cond.release());
 848
 849   VarDecl *ConditionVar = 0;
 850   if (CondVar) {
 851     ConditionVar = cast<VarDecl>(CondVar);
 852     CondResult = CheckConditionVariable(ConditionVar, WhileLoc, true);
 853     if (CondResult.isInvalid())
 854       return StmtError();
 855   }
 856   Expr *ConditionExpr = CondResult.take();
 857   if (!ConditionExpr)
 858     return StmtError();
 859
 860   DiagnoseUnusedExprResult(Body);
 861
 862   return Owned(new (Context) WhileStmt(Context, ConditionVar, ConditionExpr,
 863                                        Body, WhileLoc));
 864 }
 865
 866 StmtResult
 867 Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
 868                   SourceLocation WhileLoc, SourceLocation CondLParen,
 869                   Expr *Cond, SourceLocation CondRParen) {
 870   assert(Cond && "ActOnDoStmt(): missing expression");
 871
 872   ExprResult CondResult = CheckBooleanCondition(Cond, DoLoc);
 873   if (CondResult.isInvalid() || CondResult.isInvalid())
 874     return StmtError();
 875   Cond = CondResult.take();
 876
 877   CheckImplicitConversions(Cond, DoLoc);
 878   CondResult = MaybeCreateExprWithCleanups(Cond);
 879   if (CondResult.isInvalid())
 880     return StmtError();
 881   Cond = CondResult.take();
 882
 883   DiagnoseUnusedExprResult(Body);
 884
 885   return Owned(new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen));
 886 }
 887
 888 StmtResult
 889 Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
 890                    Stmt *First, FullExprArg second, Decl *secondVar,
 891                    FullExprArg third,
 892                    SourceLocation RParenLoc, Stmt *Body) {
 893   if (!getLangOptions().CPlusPlus) {
 894     if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) {
 895       // C99 6.8.5p3: The declaration part of a 'for' statement shall only
 896       // declare identifiers for objects having storage class 'auto' or
 897       // 'register'.
 898       for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end();
 899            DI!=DE; ++DI) {
 900         VarDecl *VD = dyn_cast<VarDecl>(*DI);
 901         if (VD && VD->isLocalVarDecl() && !VD->hasLocalStorage())
 902           VD = 0;
 903         if (VD == 0)
 904           Diag((*DI)->getLocation(), diag::err_non_variable_decl_in_for);
 905         // FIXME: mark decl erroneous!
 906       }
 907     }
 908   }
 909
 910   ExprResult SecondResult(second.release());
 911   VarDecl *ConditionVar = 0;
 912   if (secondVar) {
 913     ConditionVar = cast<VarDecl>(secondVar);
 914     SecondResult = CheckConditionVariable(ConditionVar, ForLoc, true);
 915     if (SecondResult.isInvalid())
 916       return StmtError();
 917   }
 918
 919   Expr *Third  = third.release().takeAs<Expr>();
 920
 921   DiagnoseUnusedExprResult(First);
 922   DiagnoseUnusedExprResult(Third);
 923   DiagnoseUnusedExprResult(Body);
 924
 925   return Owned(new (Context) ForStmt(Context, First,
 926                                      SecondResult.take(), ConditionVar,
 927                                      Third, Body, ForLoc, LParenLoc,
 928                                      RParenLoc));
 929 }
 930
 931 /// In an Objective C collection iteration statement:
 932 ///   for (x in y)
 933 /// x can be an arbitrary l-value expression.  Bind it up as a
 934 /// full-expression.
 935 StmtResult Sema::ActOnForEachLValueExpr(Expr *E) {
 936   CheckImplicitConversions(E);
 937   ExprResult Result = MaybeCreateExprWithCleanups(E);
 938   if (Result.isInvalid()) return StmtError();
 939   return Owned(static_cast<Stmt*>(Result.get()));
 940 }
 941
 942 StmtResult
 943 Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc,
 944                                  SourceLocation LParenLoc,
 945                                  Stmt *First, Expr *Second,
 946                                  SourceLocation RParenLoc, Stmt *Body) {
 947   if (First) {
 948     QualType FirstType;
 949     if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) {
 950       if (!DS->isSingleDecl())
 951         return StmtError(Diag((*DS->decl_begin())->getLocation(),
 952                          diag::err_toomany_element_decls));
 953
 954       Decl *D = DS->getSingleDecl();
 955       FirstType = cast<ValueDecl>(D)->getType();
 956       // C99 6.8.5p3: The declaration part of a 'for' statement shall only
 957       // declare identifiers for objects having storage class 'auto' or
 958       // 'register'.
 959       VarDecl *VD = cast<VarDecl>(D);
 960       if (VD->isLocalVarDecl() && !VD->hasLocalStorage())
 961         return StmtError(Diag(VD->getLocation(),
 962                               diag::err_non_variable_decl_in_for));
 963     } else {
 964       Expr *FirstE = cast<Expr>(First);
 965       if (!FirstE->isTypeDependent() && !FirstE->isLValue())
 966         return StmtError(Diag(First->getLocStart(),
 967                    diag::err_selector_element_not_lvalue)
 968           << First->getSourceRange());
 969
 970       FirstType = static_cast<Expr*>(First)->getType();
 971     }
 972     if (!FirstType->isDependentType() &&
 973         !FirstType->isObjCObjectPointerType() &&
 974         !FirstType->isBlockPointerType())
 975         Diag(ForLoc, diag::err_selector_element_type)
 976           << FirstType << First->getSourceRange();
 977   }
 978   if (Second && !Second->isTypeDependent()) {
 979     ExprResult Result = DefaultFunctionArrayLvalueConversion(Second);
 980     if (Result.isInvalid())
 981       return StmtError();
 982     Second = Result.take();
 983     QualType SecondType = Second->getType();
 984     if (!SecondType->isObjCObjectPointerType())
 985       Diag(ForLoc, diag::err_collection_expr_type)
 986         << SecondType << Second->getSourceRange();
 987     else if (const ObjCObjectPointerType *OPT =
 988              SecondType->getAsObjCInterfacePointerType()) {
 989       llvm::SmallVector<IdentifierInfo *, 4> KeyIdents;
 990       IdentifierInfo* selIdent =
 991         &Context.Idents.get("countByEnumeratingWithState");
 992       KeyIdents.push_back(selIdent);
 993       selIdent = &Context.Idents.get("objects");
 994       KeyIdents.push_back(selIdent);
 995       selIdent = &Context.Idents.get("count");
 996       KeyIdents.push_back(selIdent);
 997       Selector CSelector = Context.Selectors.getSelector(3, &KeyIdents[0]);
 998       if (ObjCInterfaceDecl *IDecl = OPT->getInterfaceDecl()) {
 999         if (!IDecl->isForwardDecl() &&
1000             !IDecl->lookupInstanceMethod(CSelector) &&
1001             !LookupMethodInQualifiedType(CSelector, OPT, true)) {
1002           // Must further look into private implementation methods.
1003           if (!LookupPrivateInstanceMethod(CSelector, IDecl))
1004             Diag(ForLoc, diag::warn_collection_expr_type)
1005               << SecondType << CSelector << Second->getSourceRange();
1006         }
1007       }
1008     }
1009   }
1010   return Owned(new (Context) ObjCForCollectionStmt(First, Second, Body,
1011                                                    ForLoc, RParenLoc));
1012 }
1013
1014 namespace {
1015
1016 enum BeginEndFunction {
1017   BEF_begin,
1018   BEF_end
1019 };
1020
1021 /// Build a variable declaration for a for-range statement.
1022 static VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc,
1023                                      QualType Type, const char *Name) {
1024   DeclContext *DC = SemaRef.CurContext;
1025   IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
1026   TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
1027   VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type,
1028                                   TInfo, SC_Auto, SC_None);
1029   Decl->setImplicit();
1030   return Decl;
1031 }
1032
1033 /// Finish building a variable declaration for a for-range statement.
1034 /// \return true if an error occurs.
1035 static bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init,
1036                                   SourceLocation Loc, int diag) {
1037   // Deduce the type for the iterator variable now rather than leaving it to
1038   // AddInitializerToDecl, so we can produce a more suitable diagnostic.
1039   TypeSourceInfo *InitTSI = 0;
1040   if (Init->getType()->isVoidType() ||
1041       !SemaRef.DeduceAutoType(Decl->getTypeSourceInfo(), Init, InitTSI))
1042     SemaRef.Diag(Loc, diag) << Init->getType();
1043   if (!InitTSI) {
1044     Decl->setInvalidDecl();
1045     return true;
1046   }
1047   Decl->setTypeSourceInfo(InitTSI);
1048   Decl->setType(InitTSI->getType());
1049
1050   SemaRef.AddInitializerToDecl(Decl, Init, /*DirectInit=*/false,
1051                                /*TypeMayContainAuto=*/false);
1052   SemaRef.FinalizeDeclaration(Decl);
1053   SemaRef.CurContext->addHiddenDecl(Decl);
1054   return false;
1055 }
1056
1057 /// Produce a note indicating which begin/end function was implicitly called
1058 /// by a C++0x for-range statement. This is often not obvious from the code,
1059 /// nor from the diagnostics produced when analysing the implicit expressions
1060 /// required in a for-range statement.
1061 void NoteForRangeBeginEndFunction(Sema &SemaRef, Expr *E,
1062                                   BeginEndFunction BEF) {
1063   CallExpr *CE = dyn_cast<CallExpr>(E);
1064   if (!CE)
1065     return;
1066   FunctionDecl *D = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
1067   if (!D)
1068     return;
1069   SourceLocation Loc = D->getLocation();
1070
1071   std::string Description;
1072   bool IsTemplate = false;
1073   if (FunctionTemplateDecl *FunTmpl = D->getPrimaryTemplate()) {
1074     Description = SemaRef.getTemplateArgumentBindingsText(
1075       FunTmpl->getTemplateParameters(), *D->getTemplateSpecializationArgs());
1076     IsTemplate = true;
1077   }
1078
1079   SemaRef.Diag(Loc, diag::note_for_range_begin_end)
1080     << BEF << IsTemplate << Description << E->getType();
1081 }
1082
1083 /// Build a call to 'begin' or 'end' for a C++0x for-range statement. If the
1084 /// given LookupResult is non-empty, it is assumed to describe a member which
1085 /// will be invoked. Otherwise, the function will be found via argument
1086 /// dependent lookup.
1087 static ExprResult BuildForRangeBeginEndCall(Sema &SemaRef, Scope *S,
1088                                             SourceLocation Loc,
1089                                             VarDecl *Decl,
1090                                             BeginEndFunction BEF,
1091                                             const DeclarationNameInfo &NameInfo,
1092                                             LookupResult &MemberLookup,
1093                                             Expr *Range) {
1094   ExprResult CallExpr;
1095   if (!MemberLookup.empty()) {
1096     ExprResult MemberRef =
1097       SemaRef.BuildMemberReferenceExpr(Range, Range->getType(), Loc,
1098                                        /*IsPtr=*/false, CXXScopeSpec(),
1099                                        /*Qualifier=*/0, MemberLookup,
1100                                        /*TemplateArgs=*/0);
1101     if (MemberRef.isInvalid())
1102       return ExprError();
1103     CallExpr = SemaRef.ActOnCallExpr(S, MemberRef.get(), Loc, MultiExprArg(),
1104                                      Loc, 0);
1105     if (CallExpr.isInvalid())
1106       return ExprError();
1107   } else {
1108     UnresolvedSet<0> FoundNames;
1109     // C++0x [stmt.ranged]p1: For the purposes of this name lookup, namespace
1110     // std is an associated namespace.
1111     UnresolvedLookupExpr *Fn =
1112       UnresolvedLookupExpr::Create(SemaRef.Context, /*NamingClass=*/0,
1113                                    NestedNameSpecifierLoc(), NameInfo,
1114                                    /*NeedsADL=*/true, /*Overloaded=*/false,
1115                                    FoundNames.begin(), FoundNames.end(),
1116                                    /*LookInStdNamespace=*/true);
1117     CallExpr = SemaRef.BuildOverloadedCallExpr(S, Fn, Fn, Loc, &Range, 1, Loc,
1118                                                0);
1119     if (CallExpr.isInvalid()) {
1120       SemaRef.Diag(Range->getLocStart(), diag::note_for_range_type)
1121         << Range->getType();
1122       return ExprError();
1123     }
1124   }
1125   if (FinishForRangeVarDecl(SemaRef, Decl, CallExpr.get(), Loc,
1126                             diag::err_for_range_iter_deduction_failure)) {
1127     NoteForRangeBeginEndFunction(SemaRef, CallExpr.get(), BEF);
1128     return ExprError();
1129   }
1130   return CallExpr;
1131 }
1132
1133 }
1134
1135 /// ActOnCXXForRangeStmt - Check and build a C++0x for-range statement.
1136 ///
1137 /// C++0x [stmt.ranged]:
1138 ///   A range-based for statement is equivalent to
1139 ///
1140 ///   {
1141 ///     auto && __range = range-init;
1142 ///     for ( auto __begin = begin-expr,
1143 ///           __end = end-expr;
1144 ///           __begin != __end;
1145 ///           ++__begin ) {
1146 ///       for-range-declaration = *__begin;
1147 ///       statement
1148 ///     }
1149 ///   }
1150 ///
1151 /// The body of the loop is not available yet, since it cannot be analysed until
1152 /// we have determined the type of the for-range-declaration.
1153 StmtResult
1154 Sema::ActOnCXXForRangeStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1155                            Stmt *First, SourceLocation ColonLoc, Expr *Range,
1156                            SourceLocation RParenLoc) {
1157   if (!First || !Range)
1158     return StmtError();
1159
1160   DeclStmt *DS = dyn_cast<DeclStmt>(First);
1161   assert(DS && "first part of for range not a decl stmt");
1162
1163   if (!DS->isSingleDecl()) {
1164     Diag(DS->getStartLoc(), diag::err_type_defined_in_for_range);
1165     return StmtError();
1166   }
1167   if (DS->getSingleDecl()->isInvalidDecl())
1168     return StmtError();
1169
1170   if (DiagnoseUnexpandedParameterPack(Range, UPPC_Expression))
1171     return StmtError();
1172
1173   // Build  auto && __range = range-init
1174   SourceLocation RangeLoc = Range->getLocStart();
1175   VarDecl *RangeVar = BuildForRangeVarDecl(*this, RangeLoc,
1176                                            Context.getAutoRRefDeductType(),
1177                                            "__range");
1178   if (FinishForRangeVarDecl(*this, RangeVar, Range, RangeLoc,
1179                             diag::err_for_range_deduction_failure))
1180     return StmtError();
1181
1182   // Claim the type doesn't contain auto: we've already done the checking.
1183   DeclGroupPtrTy RangeGroup =
1184     BuildDeclaratorGroup((Decl**)&RangeVar, 1, /*TypeMayContainAuto=*/false);
1185   StmtResult RangeDecl = ActOnDeclStmt(RangeGroup, RangeLoc, RangeLoc);
1186   if (RangeDecl.isInvalid())
1187     return StmtError();
1188
1189   return BuildCXXForRangeStmt(ForLoc, ColonLoc, RangeDecl.get(),
1190                               /*BeginEndDecl=*/0, /*Cond=*/0, /*Inc=*/0, DS,
1191                               RParenLoc);
1192 }
1193
1194 /// BuildCXXForRangeStmt - Build or instantiate a C++0x for-range statement.
1195 StmtResult
1196 Sema::BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation ColonLoc,
1197                            Stmt *RangeDecl, Stmt *BeginEnd, Expr *Cond,
1198                            Expr *Inc, Stmt *LoopVarDecl,
1199                            SourceLocation RParenLoc) {
1200   Scope *S = getCurScope();
1201
1202   DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl);
1203   VarDecl *RangeVar = cast<VarDecl>(RangeDS->getSingleDecl());
1204   QualType RangeVarType = RangeVar->getType();
1205
1206   DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl);
1207   VarDecl *LoopVar = cast<VarDecl>(LoopVarDS->getSingleDecl());
1208
1209   StmtResult BeginEndDecl = BeginEnd;
1210   ExprResult NotEqExpr = Cond, IncrExpr = Inc;
1211
1212   if (!BeginEndDecl.get() && !RangeVarType->isDependentType()) {
1213     SourceLocation RangeLoc = RangeVar->getLocation();
1214
1215     ExprResult RangeRef = BuildDeclRefExpr(RangeVar,
1216                                            RangeVarType.getNonReferenceType(),
1217                                            VK_LValue, ColonLoc);
1218     if (RangeRef.isInvalid())
1219       return StmtError();
1220
1221     QualType AutoType = Context.getAutoDeductType();
1222     Expr *Range = RangeVar->getInit();
1223     if (!Range)
1224       return StmtError();
1225     QualType RangeType = Range->getType();
1226
1227     if (RequireCompleteType(RangeLoc, RangeType,
1228                             PDiag(diag::err_for_range_incomplete_type)))
1229       return StmtError();
1230
1231     // Build auto __begin = begin-expr, __end = end-expr.
1232     VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1233                                              "__begin");
1234     VarDecl *EndVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1235                                            "__end");
1236
1237     // Build begin-expr and end-expr and attach to __begin and __end variables.
1238     ExprResult BeginExpr, EndExpr;
1239     if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {
1240       // - if _RangeT is an array type, begin-expr and end-expr are __range and
1241       //   __range + __bound, respectively, where __bound is the array bound. If
1242       //   _RangeT is an array of unknown size or an array of incomplete type,
1243       //   the program is ill-formed;
1244
1245       // begin-expr is __range.
1246       BeginExpr = RangeRef;
1247       if (FinishForRangeVarDecl(*this, BeginVar, RangeRef.get(), ColonLoc,
1248                                 diag::err_for_range_iter_deduction_failure)) {
1249         NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1250         return StmtError();
1251       }
1252
1253       // Find the array bound.
1254       ExprResult BoundExpr;
1255       if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(UnqAT))
1256         BoundExpr = Owned(IntegerLiteral::Create(Context, CAT->getSize(),
1257                                                  Context.getPointerDiffType(),
1258                                                  RangeLoc));
1259       else if (const VariableArrayType *VAT =
1260                dyn_cast<VariableArrayType>(UnqAT))
1261         BoundExpr = VAT->getSizeExpr();
1262       else {
1263         // Can't be a DependentSizedArrayType or an IncompleteArrayType since
1264         // UnqAT is not incomplete and Range is not type-dependent.
1265         assert(0 && "Unexpected array type in for-range");
1266         return StmtError();
1267       }
1268
1269       // end-expr is __range + __bound.
1270       EndExpr = ActOnBinOp(S, ColonLoc, tok::plus, RangeRef.get(),
1271                            BoundExpr.get());
1272       if (EndExpr.isInvalid())
1273         return StmtError();
1274       if (FinishForRangeVarDecl(*this, EndVar, EndExpr.get(), ColonLoc,
1275                                 diag::err_for_range_iter_deduction_failure)) {
1276         NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1277         return StmtError();
1278       }
1279     } else {
1280       DeclarationNameInfo BeginNameInfo(&PP.getIdentifierTable().get("begin"),
1281                                         ColonLoc);
1282       DeclarationNameInfo EndNameInfo(&PP.getIdentifierTable().get("end"),
1283                                       ColonLoc);
1284
1285       LookupResult BeginMemberLookup(*this, BeginNameInfo, LookupMemberName);
1286       LookupResult EndMemberLookup(*this, EndNameInfo, LookupMemberName);
1287
1288       if (CXXRecordDecl *D = RangeType->getAsCXXRecordDecl()) {
1289         // - if _RangeT is a class type, the unqualified-ids begin and end are
1290         //   looked up in the scope of class _RangeT as if by class member access
1291         //   lookup (3.4.5), and if either (or both) finds at least one
1292         //   declaration, begin-expr and end-expr are __range.begin() and
1293         //   __range.end(), respectively;
1294         LookupQualifiedName(BeginMemberLookup, D);
1295         LookupQualifiedName(EndMemberLookup, D);
1296
1297         if (BeginMemberLookup.empty() != EndMemberLookup.empty()) {
1298           Diag(ColonLoc, diag::err_for_range_member_begin_end_mismatch)
1299             << RangeType << BeginMemberLookup.empty();
1300           return StmtError();
1301         }
1302       } else {
1303         // - otherwise, begin-expr and end-expr are begin(__range) and
1304         //   end(__range), respectively, where begin and end are looked up with
1305         //   argument-dependent lookup (3.4.2). For the purposes of this name
1306         //   lookup, namespace std is an associated namespace.
1307       }
1308
1309       BeginExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, BeginVar,
1310                                             BEF_begin, BeginNameInfo,
1311                                             BeginMemberLookup, RangeRef.get());
1312       if (BeginExpr.isInvalid())
1313         return StmtError();
1314
1315       EndExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, EndVar,
1316                                           BEF_end, EndNameInfo,
1317                                           EndMemberLookup, RangeRef.get());
1318       if (EndExpr.isInvalid())
1319         return StmtError();
1320     }
1321
1322     // C++0x [decl.spec.auto]p6: BeginType and EndType must be the same.
1323     QualType BeginType = BeginVar->getType(), EndType = EndVar->getType();
1324     if (!Context.hasSameType(BeginType, EndType)) {
1325       Diag(RangeLoc, diag::err_for_range_begin_end_types_differ)
1326         << BeginType << EndType;
1327       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1328       NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1329     }
1330
1331     Decl *BeginEndDecls[] = { BeginVar, EndVar };
1332     // Claim the type doesn't contain auto: we've already done the checking.
1333     DeclGroupPtrTy BeginEndGroup =
1334       BuildDeclaratorGroup(BeginEndDecls, 2, /*TypeMayContainAuto=*/false);
1335     BeginEndDecl = ActOnDeclStmt(BeginEndGroup, ColonLoc, ColonLoc);
1336
1337     ExprResult BeginRef = BuildDeclRefExpr(BeginVar,
1338                                            BeginType.getNonReferenceType(),
1339                                            VK_LValue, ColonLoc);
1340     ExprResult EndRef = BuildDeclRefExpr(EndVar, EndType.getNonReferenceType(),
1341                                          VK_LValue, ColonLoc);
1342
1343     // Build and check __begin != __end expression.
1344     NotEqExpr = ActOnBinOp(S, ColonLoc, tok::exclaimequal,
1345                            BeginRef.get(), EndRef.get());
1346     NotEqExpr = ActOnBooleanCondition(S, ColonLoc, NotEqExpr.get());
1347     NotEqExpr = ActOnFinishFullExpr(NotEqExpr.get());
1348     if (NotEqExpr.isInvalid()) {
1349       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1350       if (!Context.hasSameType(BeginType, EndType))
1351         NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1352       return StmtError();
1353     }
1354
1355     // Build and check ++__begin expression.
1356     IncrExpr = ActOnUnaryOp(S, ColonLoc, tok::plusplus, BeginRef.get());
1357     IncrExpr = ActOnFinishFullExpr(IncrExpr.get());
1358     if (IncrExpr.isInvalid()) {
1359       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1360       return StmtError();
1361     }
1362
1363     // Build and check *__begin  expression.
1364     ExprResult DerefExpr = ActOnUnaryOp(S, ColonLoc, tok::star, BeginRef.get());
1365     if (DerefExpr.isInvalid()) {
1366       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1367       return StmtError();
1368     }
1369
1370     // Attach  *__begin  as initializer for VD.
1371     if (!LoopVar->isInvalidDecl()) {
1372       AddInitializerToDecl(LoopVar, DerefExpr.get(), /*DirectInit=*/false,
1373                            /*TypeMayContainAuto=*/true);
1374       if (LoopVar->isInvalidDecl())
1375         NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1376     }
1377   }
1378
1379   return Owned(new (Context) CXXForRangeStmt(RangeDS,
1380                                      cast_or_null<DeclStmt>(BeginEndDecl.get()),
1381                                              NotEqExpr.take(), IncrExpr.take(),
1382                                              LoopVarDS, /*Body=*/0, ForLoc,
1383                                              ColonLoc, RParenLoc));
1384 }
1385
1386 /// FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
1387 /// This is a separate step from ActOnCXXForRangeStmt because analysis of the
1388 /// body cannot be performed until after the type of the range variable is
1389 /// determined.
1390 StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
1391   if (!S || !B)
1392     return StmtError();
1393
1394   cast<CXXForRangeStmt>(S)->setBody(B);
1395   return S;
1396 }
1397
1398 StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc,
1399                                SourceLocation LabelLoc,
1400                                LabelDecl *TheDecl) {
1401   getCurFunction()->setHasBranchIntoScope();
1402   TheDecl->setUsed();
1403   return Owned(new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc));
1404 }
1405
1406 StmtResult
1407 Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc,
1408                             Expr *E) {
1409   // Convert operand to void*
1410   if (!E->isTypeDependent()) {
1411     QualType ETy = E->getType();
1412     QualType DestTy = Context.getPointerType(Context.VoidTy.withConst());
1413     ExprResult ExprRes = Owned(E);
1414     AssignConvertType ConvTy =
1415       CheckSingleAssignmentConstraints(DestTy, ExprRes);
1416     if (ExprRes.isInvalid())
1417       return StmtError();
1418     E = ExprRes.take();
1419     if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E, AA_Passing))
1420       return StmtError();
1421   }
1422
1423   getCurFunction()->setHasIndirectGoto();
1424
1425   return Owned(new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E));
1426 }
1427
1428 StmtResult
1429 Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) {
1430   Scope *S = CurScope->getContinueParent();
1431   if (!S) {
1432     // C99 6.8.6.2p1: A break shall appear only in or as a loop body.
1433     return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop));
1434   }
1435
1436   return Owned(new (Context) ContinueStmt(ContinueLoc));
1437 }
1438
1439 StmtResult
1440 Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
1441   Scope *S = CurScope->getBreakParent();
1442   if (!S) {
1443     // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
1444     return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
1445   }
1446
1447   return Owned(new (Context) BreakStmt(BreakLoc));
1448 }
1449
1450 /// \brief Determine whether the given expression is a candidate for
1451 /// copy elision in either a return statement or a throw expression.
1452 ///
1453 /// \param ReturnType If we're determining the copy elision candidate for
1454 /// a return statement, this is the return type of the function. If we're
1455 /// determining the copy elision candidate for a throw expression, this will
1456 /// be a NULL type.
1457 ///
1458 /// \param E The expression being returned from the function or block, or
1459 /// being thrown.
1460 ///
1461 /// \param AllowFunctionParameter Whether we allow function parameters to
1462 /// be considered NRVO candidates. C++ prohibits this for NRVO itself, but
1463 /// we re-use this logic to determine whether we should try to move as part of
1464 /// a return or throw (which does allow function parameters).
1465 ///
1466 /// \returns The NRVO candidate variable, if the return statement may use the
1467 /// NRVO, or NULL if there is no such candidate.
1468 const VarDecl *Sema::getCopyElisionCandidate(QualType ReturnType,
1469                                              Expr *E,
1470                                              bool AllowFunctionParameter) {
1471   QualType ExprType = E->getType();
1472   // - in a return statement in a function with ...
1473   // ... a class return type ...
1474   if (!ReturnType.isNull()) {
1475     if (!ReturnType->isRecordType())
1476       return 0;
1477     // ... the same cv-unqualified type as the function return type ...
1478     if (!Context.hasSameUnqualifiedType(ReturnType, ExprType))
1479       return 0;
1480   }
1481
1482   // ... the expression is the name of a non-volatile automatic object
1483   // (other than a function or catch-clause parameter)) ...
1484   const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
1485   if (!DR)
1486     return 0;
1487   const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
1488   if (!VD)
1489     return 0;
1490
1491   if (VD->hasLocalStorage() && !VD->isExceptionVariable() &&
1492       !VD->getType()->isReferenceType() && !VD->hasAttr<BlocksAttr>() &&
1493       !VD->getType().isVolatileQualified() &&
1494       ((VD->getKind() == Decl::Var) ||
1495        (AllowFunctionParameter && VD->getKind() == Decl::ParmVar)))
1496     return VD;
1497
1498   return 0;
1499 }
1500
1501 /// \brief Perform the initialization of a potentially-movable value, which
1502 /// is the result of return value.
1503 ///
1504 /// This routine implements C++0x [class.copy]p33, which attempts to treat
1505 /// returned lvalues as rvalues in certain cases (to prefer move construction),
1506 /// then falls back to treating them as lvalues if that failed.
1507 ExprResult
1508 Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
1509                                       const VarDecl *NRVOCandidate,
1510                                       QualType ResultType,
1511                                       Expr *Value) {
1512   // C++0x [class.copy]p33:
1513   //   When the criteria for elision of a copy operation are met or would
1514   //   be met save for the fact that the source object is a function
1515   //   parameter, and the object to be copied is designated by an lvalue,
1516   //   overload resolution to select the constructor for the copy is first
1517   //   performed as if the object were designated by an rvalue.
1518   ExprResult Res = ExprError();
1519   if (NRVOCandidate || getCopyElisionCandidate(ResultType, Value, true)) {
1520     ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack,
1521                               Value->getType(), CK_LValueToRValue,
1522                               Value, VK_XValue);
1523
1524     Expr *InitExpr = &AsRvalue;
1525     InitializationKind Kind
1526       = InitializationKind::CreateCopy(Value->getLocStart(),
1527                                        Value->getLocStart());
1528     InitializationSequence Seq(*this, Entity, Kind, &InitExpr, 1);
1529
1530     //   [...] If overload resolution fails, or if the type of the first
1531     //   parameter of the selected constructor is not an rvalue reference
1532     //   to the object's type (possibly cv-qualified), overload resolution
1533     //   is performed again, considering the object as an lvalue.
1534     if (Seq) {
1535       for (InitializationSequence::step_iterator Step = Seq.step_begin(),
1536            StepEnd = Seq.step_end();
1537            Step != StepEnd; ++Step) {
1538         if (Step->Kind != InitializationSequence::SK_ConstructorInitialization)
1539           continue;
1540
1541         CXXConstructorDecl *Constructor
1542         = cast<CXXConstructorDecl>(Step->Function.Function);
1543
1544         const RValueReferenceType *RRefType
1545           = Constructor->getParamDecl(0)->getType()
1546                                                  ->getAs<RValueReferenceType>();
1547
1548         // If we don't meet the criteria, break out now.
1549         if (!RRefType ||
1550             !Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
1551                             Context.getTypeDeclType(Constructor->getParent())))
1552           break;
1553
1554         // Promote "AsRvalue" to the heap, since we now need this
1555         // expression node to persist.
1556         Value = ImplicitCastExpr::Create(Context, Value->getType(),
1557                                          CK_LValueToRValue, Value, 0,
1558                                          VK_XValue);
1559
1560         // Complete type-checking the initialization of the return type
1561         // using the constructor we found.
1562         Res = Seq.Perform(*this, Entity, Kind, MultiExprArg(&Value, 1));
1563       }
1564     }
1565   }
1566
1567   // Either we didn't meet the criteria for treating an lvalue as an rvalue,
1568   // above, or overload resolution failed. Either way, we need to try
1569   // (again) now with the return value expression as written.
1570   if (Res.isInvalid())
1571     Res = PerformCopyInitialization(Entity, SourceLocation(), Value);
1572
1573   return Res;
1574 }
1575
1576 /// ActOnBlockReturnStmt - Utility routine to figure out block's return type.
1577 ///
1578 StmtResult
1579 Sema::ActOnBlockReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
1580   // If this is the first return we've seen in the block, infer the type of
1581   // the block from it.
1582   BlockScopeInfo *CurBlock = getCurBlock();
1583   if (CurBlock->ReturnType.isNull()) {
1584     if (RetValExp) {
1585       // Don't call UsualUnaryConversions(), since we don't want to do
1586       // integer promotions here.
1587       ExprResult Result = DefaultFunctionArrayLvalueConversion(RetValExp);
1588       if (Result.isInvalid())
1589         return StmtError();
1590       RetValExp = Result.take();
1591
1592       if (!RetValExp->isTypeDependent()) {
1593         CurBlock->ReturnType = RetValExp->getType();
1594         if (BlockDeclRefExpr *CDRE = dyn_cast<BlockDeclRefExpr>(RetValExp)) {
1595           // We have to remove a 'const' added to copied-in variable which was
1596           // part of the implementation spec. and not the actual qualifier for
1597           // the variable.
1598           if (CDRE->isConstQualAdded())
1599             CurBlock->ReturnType.removeLocalConst(); // FIXME: local???
1600         }
1601       } else
1602         CurBlock->ReturnType = Context.DependentTy;
1603     } else
1604       CurBlock->ReturnType = Context.VoidTy;
1605   }
1606   QualType FnRetType = CurBlock->ReturnType;
1607
1608   if (CurBlock->FunctionType->getAs<FunctionType>()->getNoReturnAttr()) {
1609     Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr)
1610       << getCurFunctionOrMethodDecl()->getDeclName();
1611     return StmtError();
1612   }
1613
1614   // Otherwise, verify that this result type matches the previous one.  We are
1615   // pickier with blocks than for normal functions because we don't have GCC
1616   // compatibility to worry about here.
1617   ReturnStmt *Result = 0;
1618   if (CurBlock->ReturnType->isVoidType()) {
1619     if (RetValExp && !RetValExp->isTypeDependent() &&
1620         (!getLangOptions().CPlusPlus || !RetValExp->getType()->isVoidType())) {
1621       Diag(ReturnLoc, diag::err_return_block_has_expr);
1622       RetValExp = 0;
1623     }
1624     Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 0);
1625   } else if (!RetValExp) {
1626     if (!CurBlock->ReturnType->isDependentType())
1627       return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr));
1628
1629     Result = new (Context) ReturnStmt(ReturnLoc, 0, 0);
1630   } else {
1631     const VarDecl *NRVOCandidate = 0;
1632
1633     if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
1634       // we have a non-void block with an expression, continue checking
1635
1636       // C99 6.8.6.4p3(136): The return statement is not an assignment. The
1637       // overlap restriction of subclause 6.5.16.1 does not apply to the case of
1638       // function return.
1639
1640       // In C++ the return statement is handled via a copy initialization.
1641       // the C version of which boils down to CheckSingleAssignmentConstraints.
1642       NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
1643       InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
1644                                                                      FnRetType,
1645                                                            NRVOCandidate != 0);
1646       ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
1647                                                        FnRetType, RetValExp);
1648       if (Res.isInvalid()) {
1649         // FIXME: Cleanup temporaries here, anyway?
1650         return StmtError();
1651       }
1652
1653       if (RetValExp) {
1654         CheckImplicitConversions(RetValExp, ReturnLoc);
1655         RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1656       }
1657
1658       RetValExp = Res.takeAs<Expr>();
1659       if (RetValExp)
1660         CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
1661     }
1662
1663     Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
1664   }
1665
1666   // If we need to check for the named return value optimization, save the
1667   // return statement in our scope for later processing.
1668   if (getLangOptions().CPlusPlus && FnRetType->isRecordType() &&
1669       !CurContext->isDependentContext())
1670     FunctionScopes.back()->Returns.push_back(Result);
1671
1672   return Owned(Result);
1673 }
1674
1675 StmtResult
1676 Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
1677   // Check for unexpanded parameter packs.
1678   if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
1679     return StmtError();
1680
1681   if (getCurBlock())
1682     return ActOnBlockReturnStmt(ReturnLoc, RetValExp);
1683
1684   QualType FnRetType;
1685   QualType DeclaredRetType;
1686   if (const FunctionDecl *FD = getCurFunctionDecl()) {
1687     FnRetType = FD->getResultType();
1688     DeclaredRetType = FnRetType;
1689     if (FD->hasAttr<NoReturnAttr>() ||
1690         FD->getType()->getAs<FunctionType>()->getNoReturnAttr())
1691       Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr)
1692         << getCurFunctionOrMethodDecl()->getDeclName();
1693   } else if (ObjCMethodDecl *MD = getCurMethodDecl()) {
1694     DeclaredRetType = MD->getResultType();
1695     if (MD->hasRelatedResultType() && MD->getClassInterface()) {
1696       // In the implementation of a method with a related return type, the
1697       // type used to type-check the validity of return statements within the
1698       // method body is a pointer to the type of the class being implemented.
1699       FnRetType = Context.getObjCInterfaceType(MD->getClassInterface());
1700       FnRetType = Context.getObjCObjectPointerType(FnRetType);
1701     } else {
1702       FnRetType = DeclaredRetType;
1703     }
1704   } else // If we don't have a function/method context, bail.
1705     return StmtError();
1706
1707   ReturnStmt *Result = 0;
1708   if (FnRetType->isVoidType()) {
1709     if (RetValExp) {
1710       if (!RetValExp->isTypeDependent()) {
1711         // C99 6.8.6.4p1 (ext_ since GCC warns)
1712         unsigned D = diag::ext_return_has_expr;
1713         if (RetValExp->getType()->isVoidType())
1714           D = diag::ext_return_has_void_expr;
1715         else {
1716           ExprResult Result = Owned(RetValExp);
1717           Result = IgnoredValueConversions(Result.take());
1718           if (Result.isInvalid())
1719             return StmtError();
1720           RetValExp = Result.take();
1721           RetValExp = ImpCastExprToType(RetValExp,
1722                                         Context.VoidTy, CK_ToVoid).take();
1723         }
1724
1725         // return (some void expression); is legal in C++.
1726         if (D != diag::ext_return_has_void_expr ||
1727             !getLangOptions().CPlusPlus) {
1728           NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
1729           Diag(ReturnLoc, D)
1730             << CurDecl->getDeclName() << isa<ObjCMethodDecl>(CurDecl)
1731             << RetValExp->getSourceRange();
1732         }
1733       }
1734
1735       CheckImplicitConversions(RetValExp, ReturnLoc);
1736       RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1737     }
1738
1739     Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 0);
1740   } else if (!RetValExp && !FnRetType->isDependentType()) {
1741     unsigned DiagID = diag::warn_return_missing_expr;  // C90 6.6.6.4p4
1742     // C99 6.8.6.4p1 (ext_ since GCC warns)
1743     if (getLangOptions().C99) DiagID = diag::ext_return_missing_expr;
1744
1745     if (FunctionDecl *FD = getCurFunctionDecl())
1746       Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/;
1747     else
1748       Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/;
1749     Result = new (Context) ReturnStmt(ReturnLoc);
1750   } else {
1751     const VarDecl *NRVOCandidate = 0;
1752     if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
1753       // we have a non-void function with an expression, continue checking
1754
1755       // C99 6.8.6.4p3(136): The return statement is not an assignment. The
1756       // overlap restriction of subclause 6.5.16.1 does not apply to the case of
1757       // function return.
1758
1759       // In C++ the return statement is handled via a copy initialization.
1760       // the C version of which boils down to CheckSingleAssignmentConstraints.
1761       NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
1762       InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
1763                                                                      FnRetType,
1764                                                             NRVOCandidate != 0);
1765       ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
1766                                                        FnRetType, RetValExp);
1767       if (Res.isInvalid()) {
1768         // FIXME: Cleanup temporaries here, anyway?
1769         return StmtError();
1770       }
1771
1772       RetValExp = Res.takeAs<Expr>();
1773       if (RetValExp)
1774         CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
1775     }
1776
1777     if (RetValExp) {
1778       // If we type-checked an Objective-C method's return type based
1779       // on a related return type, we may need to adjust the return
1780       // type again. Do so now.
1781       if (DeclaredRetType != FnRetType) {
1782         ExprResult result = PerformImplicitConversion(RetValExp,
1783                                                       DeclaredRetType,
1784                                                       AA_Returning);
1785         if (result.isInvalid()) return StmtError();
1786         RetValExp = result.take();
1787       }
1788
1789       CheckImplicitConversions(RetValExp, ReturnLoc);
1790       RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1791     }
1792     Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
1793   }
1794
1795   // If we need to check for the named return value optimization, save the
1796   // return statement in our scope for later processing.
1797   if (getLangOptions().CPlusPlus && FnRetType->isRecordType() &&
1798       !CurContext->isDependentContext())
1799     FunctionScopes.back()->Returns.push_back(Result);
1800
1801   return Owned(Result);
1802 }
1803
1804 /// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently
1805 /// ignore "noop" casts in places where an lvalue is required by an inline asm.
1806 /// We emulate this behavior when -fheinous-gnu-extensions is specified, but
1807 /// provide a strong guidance to not use it.
1808 ///
1809 /// This method checks to see if the argument is an acceptable l-value and
1810 /// returns false if it is a case we can handle.
1811 static bool CheckAsmLValue(const Expr *E, Sema &S) {
1812   // Type dependent expressions will be checked during instantiation.
1813   if (E->isTypeDependent())
1814     return false;
1815
1816   if (E->isLValue())
1817     return false;  // Cool, this is an lvalue.
1818
1819   // Okay, this is not an lvalue, but perhaps it is the result of a cast that we
1820   // are supposed to allow.
1821   const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
1822   if (E != E2 && E2->isLValue()) {
1823     if (!S.getLangOptions().HeinousExtensions)
1824       S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue)
1825         << E->getSourceRange();
1826     else
1827       S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
1828         << E->getSourceRange();
1829     // Accept, even if we emitted an error diagnostic.
1830     return false;
1831   }
1832
1833   // None of the above, just randomly invalid non-lvalue.
1834   return true;
1835 }
1836
1837 /// isOperandMentioned - Return true if the specified operand # is mentioned
1838 /// anywhere in the decomposed asm string.
1839 static bool isOperandMentioned(unsigned OpNo,
1840                          llvm::ArrayRef<AsmStmt::AsmStringPiece> AsmStrPieces) {
1841   for (unsigned p = 0, e = AsmStrPieces.size(); p != e; ++p) {
1842     const AsmStmt::AsmStringPiece &Piece = AsmStrPieces[p];
1843     if (!Piece.isOperand()) continue;
1844
1845     // If this is a reference to the input and if the input was the smaller
1846     // one, then we have to reject this asm.
1847     if (Piece.getOperandNo() == OpNo)
1848       return true;
1849   }
1850
1851   return false;
1852 }
1853
1854 StmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, bool IsSimple,
1855                               bool IsVolatile, unsigned NumOutputs,
1856                               unsigned NumInputs, IdentifierInfo **Names,
1857                               MultiExprArg constraints, MultiExprArg exprs,
1858                               Expr *asmString, MultiExprArg clobbers,
1859                               SourceLocation RParenLoc, bool MSAsm) {
1860   unsigned NumClobbers = clobbers.size();
1861   StringLiteral **Constraints =
1862     reinterpret_cast<StringLiteral**>(constraints.get());
1863   Expr **Exprs = exprs.get();
1864   StringLiteral *AsmString = cast<StringLiteral>(asmString);
1865   StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.get());
1866
1867   llvm::SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
1868
1869   // The parser verifies that there is a string literal here.
1870   if (AsmString->isWide())
1871     return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character)
1872       << AsmString->getSourceRange());
1873
1874   for (unsigned i = 0; i != NumOutputs; i++) {
1875     StringLiteral *Literal = Constraints[i];
1876     if (Literal->isWide())
1877       return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
1878         << Literal->getSourceRange());
1879
1880     llvm::StringRef OutputName;
1881     if (Names[i])
1882       OutputName = Names[i]->getName();
1883
1884     TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName);
1885     if (!Context.Target.validateOutputConstraint(Info))
1886       return StmtError(Diag(Literal->getLocStart(),
1887                             diag::err_asm_invalid_output_constraint)
1888                        << Info.getConstraintStr());
1889
1890     // Check that the output exprs are valid lvalues.
1891     Expr *OutputExpr = Exprs[i];
1892     if (CheckAsmLValue(OutputExpr, *this)) {
1893       return StmtError(Diag(OutputExpr->getLocStart(),
1894                   diag::err_asm_invalid_lvalue_in_output)
1895         << OutputExpr->getSourceRange());
1896     }
1897
1898     OutputConstraintInfos.push_back(Info);
1899   }
1900
1901   llvm::SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
1902
1903   for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
1904     StringLiteral *Literal = Constraints[i];
1905     if (Literal->isWide())
1906       return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
1907         << Literal->getSourceRange());
1908
1909     llvm::StringRef InputName;
1910     if (Names[i])
1911       InputName = Names[i]->getName();
1912
1913     TargetInfo::ConstraintInfo Info(Literal->getString(), InputName);
1914     if (!Context.Target.validateInputConstraint(OutputConstraintInfos.data(),
1915                                                 NumOutputs, Info)) {
1916       return StmtError(Diag(Literal->getLocStart(),
1917                             diag::err_asm_invalid_input_constraint)
1918                        << Info.getConstraintStr());
1919     }
1920
1921     Expr *InputExpr = Exprs[i];
1922
1923     // Only allow void types for memory constraints.
1924     if (Info.allowsMemory() && !Info.allowsRegister()) {
1925       if (CheckAsmLValue(InputExpr, *this))
1926         return StmtError(Diag(InputExpr->getLocStart(),
1927                               diag::err_asm_invalid_lvalue_in_input)
1928                          << Info.getConstraintStr()
1929                          << InputExpr->getSourceRange());
1930     }
1931
1932     if (Info.allowsRegister()) {
1933       if (InputExpr->getType()->isVoidType()) {
1934         return StmtError(Diag(InputExpr->getLocStart(),
1935                               diag::err_asm_invalid_type_in_input)
1936           << InputExpr->getType() << Info.getConstraintStr()
1937           << InputExpr->getSourceRange());
1938       }
1939     }
1940
1941     ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]);
1942     if (Result.isInvalid())
1943       return StmtError();
1944
1945     Exprs[i] = Result.take();
1946     InputConstraintInfos.push_back(Info);
1947   }
1948
1949   // Check that the clobbers are valid.
1950   for (unsigned i = 0; i != NumClobbers; i++) {
1951     StringLiteral *Literal = Clobbers[i];
1952     if (Literal->isWide())
1953       return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
1954         << Literal->getSourceRange());
1955
1956     llvm::StringRef Clobber = Literal->getString();
1957
1958     if (!Context.Target.isValidGCCRegisterName(Clobber))
1959       return StmtError(Diag(Literal->getLocStart(),
1960                   diag::err_asm_unknown_register_name) << Clobber);
1961   }
1962
1963   AsmStmt *NS =
1964     new (Context) AsmStmt(Context, AsmLoc, IsSimple, IsVolatile, MSAsm,
1965                           NumOutputs, NumInputs, Names, Constraints, Exprs,
1966                           AsmString, NumClobbers, Clobbers, RParenLoc);
1967   // Validate the asm string, ensuring it makes sense given the operands we
1968   // have.
1969   llvm::SmallVector<AsmStmt::AsmStringPiece, 8> Pieces;
1970   unsigned DiagOffs;
1971   if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
1972     Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
1973            << AsmString->getSourceRange();
1974     return StmtError();
1975   }
1976
1977   // Validate tied input operands for type mismatches.
1978   for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
1979     TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
1980
1981     // If this is a tied constraint, verify that the output and input have
1982     // either exactly the same type, or that they are int/ptr operands with the
1983     // same size (int/long, int*/long, are ok etc).
1984     if (!Info.hasTiedOperand()) continue;
1985
1986     unsigned TiedTo = Info.getTiedOperand();
1987     unsigned InputOpNo = i+NumOutputs;
1988     Expr *OutputExpr = Exprs[TiedTo];
1989     Expr *InputExpr = Exprs[InputOpNo];
1990     QualType InTy = InputExpr->getType();
1991     QualType OutTy = OutputExpr->getType();
1992     if (Context.hasSameType(InTy, OutTy))
1993       continue;  // All types can be tied to themselves.
1994
1995     // Decide if the input and output are in the same domain (integer/ptr or
1996     // floating point.
1997     enum AsmDomain {
1998       AD_Int, AD_FP, AD_Other
1999     } InputDomain, OutputDomain;
2000
2001     if (InTy->isIntegerType() || InTy->isPointerType())
2002       InputDomain = AD_Int;
2003     else if (InTy->isRealFloatingType())
2004       InputDomain = AD_FP;
2005     else
2006       InputDomain = AD_Other;
2007
2008     if (OutTy->isIntegerType() || OutTy->isPointerType())
2009       OutputDomain = AD_Int;
2010     else if (OutTy->isRealFloatingType())
2011       OutputDomain = AD_FP;
2012     else
2013       OutputDomain = AD_Other;
2014
2015     // They are ok if they are the same size and in the same domain.  This
2016     // allows tying things like:
2017     //   void* to int*
2018     //   void* to int            if they are the same size.
2019     //   double to long double   if they are the same size.
2020     //
2021     uint64_t OutSize = Context.getTypeSize(OutTy);
2022     uint64_t InSize = Context.getTypeSize(InTy);
2023     if (OutSize == InSize && InputDomain == OutputDomain &&
2024         InputDomain != AD_Other)
2025       continue;
2026
2027     // If the smaller input/output operand is not mentioned in the asm string,
2028     // then we can promote the smaller one to a larger input and the asm string
2029     // won't notice.
2030     bool SmallerValueMentioned = false;
2031
2032     // If this is a reference to the input and if the input was the smaller
2033     // one, then we have to reject this asm.
2034     if (isOperandMentioned(InputOpNo, Pieces)) {
2035       // This is a use in the asm string of the smaller operand.  Since we
2036       // codegen this by promoting to a wider value, the asm will get printed
2037       // "wrong".
2038       SmallerValueMentioned |= InSize < OutSize;
2039     }
2040     if (isOperandMentioned(TiedTo, Pieces)) {
2041       // If this is a reference to the output, and if the output is the larger
2042       // value, then it's ok because we'll promote the input to the larger type.
2043       SmallerValueMentioned |= OutSize < InSize;
2044     }
2045
2046     // If the smaller value wasn't mentioned in the asm string, and if the
2047     // output was a register, just extend the shorter one to the size of the
2048     // larger one.
2049     if (!SmallerValueMentioned && InputDomain != AD_Other &&
2050         OutputConstraintInfos[TiedTo].allowsRegister())
2051       continue;
2052
2053     // Either both of the operands were mentioned or the smaller one was
2054     // mentioned.  One more special case that we'll allow: if the tied input is
2055     // integer, unmentioned, and is a constant, then we'll allow truncating it
2056     // down to the size of the destination.
2057     if (InputDomain == AD_Int && OutputDomain == AD_Int &&
2058         !isOperandMentioned(InputOpNo, Pieces) &&
2059         InputExpr->isEvaluatable(Context)) {
2060       CastKind castKind =
2061         (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast);
2062       InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).take();
2063       Exprs[InputOpNo] = InputExpr;
2064       NS->setInputExpr(i, InputExpr);
2065       continue;
2066     }
2067
2068     Diag(InputExpr->getLocStart(),
2069          diag::err_asm_tying_incompatible_types)
2070       << InTy << OutTy << OutputExpr->getSourceRange()
2071       << InputExpr->getSourceRange();
2072     return StmtError();
2073   }
2074
2075   return Owned(NS);
2076 }
2077
2078 StmtResult
2079 Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc,
2080                            SourceLocation RParen, Decl *Parm,
2081                            Stmt *Body) {
2082   VarDecl *Var = cast_or_null<VarDecl>(Parm);
2083   if (Var && Var->isInvalidDecl())
2084     return StmtError();
2085
2086   return Owned(new (Context) ObjCAtCatchStmt(AtLoc, RParen, Var, Body));
2087 }
2088
2089 StmtResult
2090 Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body) {
2091   return Owned(new (Context) ObjCAtFinallyStmt(AtLoc, Body));
2092 }
2093
2094 StmtResult
2095 Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
2096                          MultiStmtArg CatchStmts, Stmt *Finally) {
2097   if (!getLangOptions().ObjCExceptions)
2098     Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@try";
2099
2100   getCurFunction()->setHasBranchProtectedScope();
2101   unsigned NumCatchStmts = CatchStmts.size();
2102   return Owned(ObjCAtTryStmt::Create(Context, AtLoc, Try,
2103                                      CatchStmts.release(),
2104                                      NumCatchStmts,
2105                                      Finally));
2106 }
2107
2108 StmtResult Sema::BuildObjCAtThrowStmt(SourceLocation AtLoc,
2109                                                   Expr *Throw) {
2110   if (Throw) {
2111     ExprResult Result = DefaultLvalueConversion(Throw);
2112     if (Result.isInvalid())
2113       return StmtError();
2114
2115     Throw = Result.take();
2116     QualType ThrowType = Throw->getType();
2117     // Make sure the expression type is an ObjC pointer or "void *".
2118     if (!ThrowType->isDependentType() &&
2119         !ThrowType->isObjCObjectPointerType()) {
2120       const PointerType *PT = ThrowType->getAs<PointerType>();
2121       if (!PT || !PT->getPointeeType()->isVoidType())
2122         return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object)
2123                          << Throw->getType() << Throw->getSourceRange());
2124     }
2125   }
2126
2127   return Owned(new (Context) ObjCAtThrowStmt(AtLoc, Throw));
2128 }
2129
2130 StmtResult
2131 Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
2132                            Scope *CurScope) {
2133   if (!getLangOptions().ObjCExceptions)
2134     Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@throw";
2135
2136   if (!Throw) {
2137     // @throw without an expression designates a rethrow (which much occur
2138     // in the context of an @catch clause).
2139     Scope *AtCatchParent = CurScope;
2140     while (AtCatchParent && !AtCatchParent->isAtCatchScope())
2141       AtCatchParent = AtCatchParent->getParent();
2142     if (!AtCatchParent)
2143       return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch));
2144   }
2145
2146   return BuildObjCAtThrowStmt(AtLoc, Throw);
2147 }
2148
2149 StmtResult
2150 Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SyncExpr,
2151                                   Stmt *SyncBody) {
2152   getCurFunction()->setHasBranchProtectedScope();
2153
2154   ExprResult Result = DefaultLvalueConversion(SyncExpr);
2155   if (Result.isInvalid())
2156     return StmtError();
2157
2158   SyncExpr = Result.take();
2159   // Make sure the expression type is an ObjC pointer or "void *".
2160   if (!SyncExpr->getType()->isDependentType() &&
2161       !SyncExpr->getType()->isObjCObjectPointerType()) {
2162     const PointerType *PT = SyncExpr->getType()->getAs<PointerType>();
2163     if (!PT || !PT->getPointeeType()->isVoidType())
2164       return StmtError(Diag(AtLoc, diag::error_objc_synchronized_expects_object)
2165                        << SyncExpr->getType() << SyncExpr->getSourceRange());
2166   }
2167
2168   return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc, SyncExpr, SyncBody));
2169 }
2170
2171 /// ActOnCXXCatchBlock - Takes an exception declaration and a handler block
2172 /// and creates a proper catch handler from them.
2173 StmtResult
2174 Sema::ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl,
2175                          Stmt *HandlerBlock) {
2176   // There's nothing to test that ActOnExceptionDecl didn't already test.
2177   return Owned(new (Context) CXXCatchStmt(CatchLoc,
2178                                           cast_or_null<VarDecl>(ExDecl),
2179                                           HandlerBlock));
2180 }
2181
2182 namespace {
2183
2184 class TypeWithHandler {
2185   QualType t;
2186   CXXCatchStmt *stmt;
2187 public:
2188   TypeWithHandler(const QualType &type, CXXCatchStmt *statement)
2189   : t(type), stmt(statement) {}
2190
2191   // An arbitrary order is fine as long as it places identical
2192   // types next to each other.
2193   bool operator<(const TypeWithHandler &y) const {
2194     if (t.getAsOpaquePtr() < y.t.getAsOpaquePtr())
2195       return true;
2196     if (t.getAsOpaquePtr() > y.t.getAsOpaquePtr())
2197       return false;
2198     else
2199       return getTypeSpecStartLoc() < y.getTypeSpecStartLoc();
2200   }
2201
2202   bool operator==(const TypeWithHandler& other) const {
2203     return t == other.t;
2204   }
2205
2206   CXXCatchStmt *getCatchStmt() const { return stmt; }
2207   SourceLocation getTypeSpecStartLoc() const {
2208     return stmt->getExceptionDecl()->getTypeSpecStartLoc();
2209   }
2210 };
2211
2212 }
2213
2214 /// ActOnCXXTryBlock - Takes a try compound-statement and a number of
2215 /// handlers and creates a try statement from them.
2216 StmtResult
2217 Sema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
2218                        MultiStmtArg RawHandlers) {
2219   // Don't report an error if 'try' is used in system headers.
2220   if (!getLangOptions().CXXExceptions &&
2221       !getSourceManager().isInSystemHeader(TryLoc))
2222       Diag(TryLoc, diag::err_exceptions_disabled) << "try";
2223
2224   unsigned NumHandlers = RawHandlers.size();
2225   assert(NumHandlers > 0 &&
2226          "The parser shouldn't call this if there are no handlers.");
2227   Stmt **Handlers = RawHandlers.get();
2228
2229   llvm::SmallVector<TypeWithHandler, 8> TypesWithHandlers;
2230
2231   for (unsigned i = 0; i < NumHandlers; ++i) {
2232     CXXCatchStmt *Handler = llvm::cast<CXXCatchStmt>(Handlers[i]);
2233     if (!Handler->getExceptionDecl()) {
2234       if (i < NumHandlers - 1)
2235         return StmtError(Diag(Handler->getLocStart(),
2236                               diag::err_early_catch_all));
2237
2238       continue;
2239     }
2240
2241     const QualType CaughtType = Handler->getCaughtType();
2242     const QualType CanonicalCaughtType = Context.getCanonicalType(CaughtType);
2243     TypesWithHandlers.push_back(TypeWithHandler(CanonicalCaughtType, Handler));
2244   }
2245
2246   // Detect handlers for the same type as an earlier one.
2247   if (NumHandlers > 1) {
2248     llvm::array_pod_sort(TypesWithHandlers.begin(), TypesWithHandlers.end());
2249
2250     TypeWithHandler prev = TypesWithHandlers[0];
2251     for (unsigned i = 1; i < TypesWithHandlers.size(); ++i) {
2252       TypeWithHandler curr = TypesWithHandlers[i];
2253
2254       if (curr == prev) {
2255         Diag(curr.getTypeSpecStartLoc(),
2256              diag::warn_exception_caught_by_earlier_handler)
2257           << curr.getCatchStmt()->getCaughtType().getAsString();
2258         Diag(prev.getTypeSpecStartLoc(),
2259              diag::note_previous_exception_handler)
2260           << prev.getCatchStmt()->getCaughtType().getAsString();
2261       }
2262
2263       prev = curr;
2264     }
2265   }
2266
2267   getCurFunction()->setHasBranchProtectedScope();
2268
2269   // FIXME: We should detect handlers that cannot catch anything because an
2270   // earlier handler catches a superclass. Need to find a method that is not
2271   // quadratic for this.
2272   // Neither of these are explicitly forbidden, but every compiler detects them
2273   // and warns.
2274
2275   return Owned(CXXTryStmt::Create(Context, TryLoc, TryBlock,
2276                                   Handlers, NumHandlers));
2277 }
2278
2279 StmtResult
2280 Sema::ActOnSEHTryBlock(bool IsCXXTry,
2281                        SourceLocation TryLoc,
2282                        Stmt *TryBlock,
2283                        Stmt *Handler) {
2284   assert(TryBlock && Handler);
2285
2286   getCurFunction()->setHasBranchProtectedScope();
2287
2288   return Owned(SEHTryStmt::Create(Context,IsCXXTry,TryLoc,TryBlock,Handler));
2289 }
2290
2291 StmtResult
2292 Sema::ActOnSEHExceptBlock(SourceLocation Loc,
2293                           Expr *FilterExpr,
2294                           Stmt *Block) {
2295   assert(FilterExpr && Block);
2296
2297   if(!FilterExpr->getType()->isIntegerType()) {
2298     return StmtError(Diag(FilterExpr->getExprLoc(),
2299                      diag::err_filter_expression_integral)
2300                      << FilterExpr->getType());
2301   }
2302
2303   return Owned(SEHExceptStmt::Create(Context,Loc,FilterExpr,Block));
2304 }
2305
2306 StmtResult
2307 Sema::ActOnSEHFinallyBlock(SourceLocation Loc,
2308                            Stmt *Block) {
2309   assert(Block);
2310   return Owned(SEHFinallyStmt::Create(Context,Loc,Block));
2311 }
2312