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