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