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