SemaStmt.cpp revision 4d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===//
25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//
35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//                     The LLVM Compiler Infrastructure
45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//
50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source
60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details.
75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//
85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===//
95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//
105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//  This file implements semantic analysis for statements.
115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//
125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===//
135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
142d88708cbe4e4ec5e04e4acb6bd7f5be68557379John McCall#include "clang/Sema/SemaInternal.h"
155f1e0942a32657b625702aa52f82430d0120f424John McCall#include "clang/Sema/Scope.h"
16781472fe99a120098c631b0cbe33c89f8cef5e70John McCall#include "clang/Sema/ScopeInfo.h"
17e737f5041a36d0befb39ffeed8d50ba15916d3daDouglas Gregor#include "clang/Sema/Initialization.h"
18ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith#include "clang/Sema/Lookup.h"
19f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner#include "clang/AST/ASTContext.h"
201cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall#include "clang/AST/CharUnits.h"
21c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/DeclObjC.h"
22694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu#include "clang/AST/EvaluatedExprVisitor.h"
2384fb9c0be621c9e4ca4e56f67dae2a0bb6e44821Douglas Gregor#include "clang/AST/ExprCXX.h"
24419cfb318cd69b6c717019288d5a3822be18d8f9Chris Lattner#include "clang/AST/ExprObjC.h"
2516f0049415ec596504891259e2a83e19871c0d52Chris Lattner#include "clang/AST/StmtObjC.h"
2616f0049415ec596504891259e2a83e19871c0d52Chris Lattner#include "clang/AST/StmtCXX.h"
27209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall#include "clang/AST/TypeLoc.h"
2884fb9c0be621c9e4ca4e56f67dae2a0bb6e44821Douglas Gregor#include "clang/Lex/Preprocessor.h"
296fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson#include "clang/Basic/TargetInfo.h"
30ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner#include "llvm/ADT/ArrayRef.h"
31c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl#include "llvm/ADT/STLExtras.h"
32694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu#include "llvm/ADT/SmallPtrSet.h"
3350de5e3247a20e0e548dc47022a011250e6e4e8fDouglas Gregor#include "llvm/ADT/SmallString.h"
34c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl#include "llvm/ADT/SmallVector.h"
355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang;
36781472fe99a120098c631b0cbe33c89f8cef5e70John McCallusing namespace sema;
375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
3860d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult Sema::ActOnExprStmt(FullExprArg expr) {
399ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  Expr *E = expr.get();
40bebbe0d9b7568ce43a464286bee49429489ef483Douglas Gregor  if (!E) // FIXME: FullExprArg has no error state?
41bebbe0d9b7568ce43a464286bee49429489ef483Douglas Gregor    return StmtError();
42bebbe0d9b7568ce43a464286bee49429489ef483Douglas Gregor
43834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner  // C99 6.8.3p2: The expression in an expression statement is evaluated as a
44834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner  // void expression for its side effects.  Conversion to void allows any
45834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner  // operand, even incomplete types.
46a60528cdac7deee3991c2b48af4df4f315e49e9dSebastian Redl
47834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner  // Same thing in for stmt first clause (when expr) and third clause.
48a60528cdac7deee3991c2b48af4df4f315e49e9dSebastian Redl  return Owned(static_cast<Stmt*>(E));
495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
52b7d98d35ea723624345f06e5895ddce2e0388ef0Argyrios KyrtzidisStmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc,
53e2ca828119b8bff4a5c25c6db8ee4fec558451e7Argyrios Kyrtzidis                               bool HasLeadingEmptyMacro) {
54e2ca828119b8bff4a5c25c6db8ee4fec558451e7Argyrios Kyrtzidis  return Owned(new (Context) NullStmt(SemiLoc, HasLeadingEmptyMacro));
555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
57337e550218128e7d922c09bb354fbc71de90c568Chris LattnerStmtResult Sema::ActOnDeclStmt(DeclGroupPtrTy dg, SourceLocation StartLoc,
58337e550218128e7d922c09bb354fbc71de90c568Chris Lattner                               SourceLocation EndLoc) {
5920401698e3bd93a24bb5d9e18e435895cefe5fd1Chris Lattner  DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
61682bf92db408a6cbc3d37b5496a99b6ef85041ecChris Lattner  // If we have an invalid decl, just return an error.
6220401698e3bd93a24bb5d9e18e435895cefe5fd1Chris Lattner  if (DG.isNull()) return StmtError();
631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
6424e1e707b4c362f18e371e2bbf054a8345b57bfaChris Lattner  return Owned(new (Context) DeclStmt(DG, StartLoc, EndLoc));
655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
67a7cf23a72b0846fc5aacf3f38bb8c8f9e76784cfFariborz Jahanianvoid Sema::ActOnForEachDeclStmt(DeclGroupPtrTy dg) {
68a7cf23a72b0846fc5aacf3f38bb8c8f9e76784cfFariborz Jahanian  DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
69dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
70a7cf23a72b0846fc5aacf3f38bb8c8f9e76784cfFariborz Jahanian  // If we have an invalid decl, just return.
71a7cf23a72b0846fc5aacf3f38bb8c8f9e76784cfFariborz Jahanian  if (DG.isNull() || !DG.isSingleDecl()) return;
72f85e193739c953358c865005855253af4f68a497John McCall  VarDecl *var = cast<VarDecl>(DG.getSingleDecl());
73f85e193739c953358c865005855253af4f68a497John McCall
74a7cf23a72b0846fc5aacf3f38bb8c8f9e76784cfFariborz Jahanian  // suppress any potential 'unused variable' warning.
75f85e193739c953358c865005855253af4f68a497John McCall  var->setUsed();
76f85e193739c953358c865005855253af4f68a497John McCall
777acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall  // foreach variables are never actually initialized in the way that
787acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall  // the parser came up with.
797acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall  var->setInit(0);
807acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall
817acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall  // In ARC, we don't need to retain the iteration variable of a fast
827acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall  // enumeration loop.  Rather than actually trying to catch that
837acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall  // during declaration processing, we remove the consequences here.
844e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie  if (getLangOpts().ObjCAutoRefCount) {
857acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall    QualType type = var->getType();
867acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall
877acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall    // Only do this if we inferred the lifetime.  Inferred lifetime
887acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall    // will show up as a local qualifier because explicit lifetime
897acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall    // should have shown up as an AttributedType instead.
907acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall    if (type.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong) {
917acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall      // Add 'const' and mark the variable as pseudo-strong.
927acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall      var->setType(type.withConst());
937acddacc921cd0b3f813443a8641eeddb82dfbd4John McCall      var->setARCPseudoStrong(true);
94f85e193739c953358c865005855253af4f68a497John McCall    }
95f85e193739c953358c865005855253af4f68a497John McCall  }
96a7cf23a72b0846fc5aacf3f38bb8c8f9e76784cfFariborz Jahanian}
97a7cf23a72b0846fc5aacf3f38bb8c8f9e76784cfFariborz Jahanian
98ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruth/// \brief Diagnose unused '==' and '!=' as likely typos for '=' or '|='.
999d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth///
1009d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth/// Adding a cast to void (or other expression wrappers) will prevent the
1019d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth/// warning from firing.
102ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruthstatic bool DiagnoseUnusedComparison(Sema &S, const Expr *E) {
1039d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth  SourceLocation Loc;
10450bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth  bool IsNotEqual, CanAssign;
1059d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth
1069d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth  if (const BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
1079d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth    if (Op->getOpcode() != BO_EQ && Op->getOpcode() != BO_NE)
108ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruth      return false;
1099d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth
1109d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth    Loc = Op->getOperatorLoc();
11150bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth    IsNotEqual = Op->getOpcode() == BO_NE;
11250bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth    CanAssign = Op->getLHS()->IgnoreParenImpCasts()->isLValue();
1139d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth  } else if (const CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) {
1149d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth    if (Op->getOperator() != OO_EqualEqual &&
1159d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth        Op->getOperator() != OO_ExclaimEqual)
116ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruth      return false;
1179d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth
1189d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth    Loc = Op->getOperatorLoc();
11950bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth    IsNotEqual = Op->getOperator() == OO_ExclaimEqual;
12050bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth    CanAssign = Op->getArg(0)->IgnoreParenImpCasts()->isLValue();
1219d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth  } else {
1229d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth    // Not a typo-prone comparison.
123ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruth    return false;
1249d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth  }
1259d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth
1269d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth  // Suppress warnings when the operator, suspicious as it may be, comes from
1279d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth  // a macro expansion.
1289d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth  if (Loc.isMacroID())
129ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruth    return false;
1309d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth
131ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruth  S.Diag(Loc, diag::warn_unused_comparison)
1329d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth    << (unsigned)IsNotEqual << E->getSourceRange();
1339d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth
13450bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth  // If the LHS is a plausible entity to assign to, provide a fixit hint to
13550bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth  // correct common typos.
13650bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth  if (CanAssign) {
13750bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth    if (IsNotEqual)
13850bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth      S.Diag(Loc, diag::note_inequality_comparison_to_or_assign)
13950bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth        << FixItHint::CreateReplacement(Loc, "|=");
14050bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth    else
14150bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth      S.Diag(Loc, diag::note_equality_comparison_to_assign)
14250bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth        << FixItHint::CreateReplacement(Loc, "=");
14350bf68fc9698742e36c311fc37e6e4b7de235c4bChandler Carruth  }
144ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruth
145ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruth  return true;
1469d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth}
1479d8eb3b2a892697aed332f6c318a8554fc2623ceChandler Carruth
148636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlssonvoid Sema::DiagnoseUnusedExprResult(const Stmt *S) {
149d2827af6f96d441d72315dbe6d8505c3be0f2aa6Argyrios Kyrtzidis  if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
150d2827af6f96d441d72315dbe6d8505c3be0f2aa6Argyrios Kyrtzidis    return DiagnoseUnusedExprResult(Label->getSubStmt());
151d2827af6f96d441d72315dbe6d8505c3be0f2aa6Argyrios Kyrtzidis
152754431107b61a0523df5271c2876a73dd5a051e9Anders Carlsson  const Expr *E = dyn_cast_or_null<Expr>(S);
153636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlsson  if (!E)
154636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlsson    return;
155636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlsson
156a6115068cde719142eb394db88612c185cabd05bEli Friedman  const Expr *WarnExpr;
157636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlsson  SourceLocation Loc;
158636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlsson  SourceRange R1, R2;
159d87a0cd2b3e1c9e9f01212875f4cbe5b7bb7ab57Matt Beaumont-Gay  if (SourceMgr.isInSystemMacro(E->getExprLoc()) ||
160a6115068cde719142eb394db88612c185cabd05bEli Friedman      !E->isUnusedResultAWarning(WarnExpr, Loc, R1, R2, Context))
161636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlsson    return;
1621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
163419cfb318cd69b6c717019288d5a3822be18d8f9Chris Lattner  // Okay, we have an unused result.  Depending on what the base expression is,
164419cfb318cd69b6c717019288d5a3822be18d8f9Chris Lattner  // we might want to make a more specific diagnostic.  Check for one of these
165419cfb318cd69b6c717019288d5a3822be18d8f9Chris Lattner  // cases now.
166419cfb318cd69b6c717019288d5a3822be18d8f9Chris Lattner  unsigned DiagID = diag::warn_unused_expr;
1674765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall  if (const ExprWithCleanups *Temps = dyn_cast<ExprWithCleanups>(E))
1684dffad64c5c7106dc5ac506be94944299c8f7bc3Douglas Gregor    E = Temps->getSubExpr();
16934d49471e0b6386aefdc0f6bd15e4a4876ce5db1Chandler Carruth  if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E))
17034d49471e0b6386aefdc0f6bd15e4a4876ce5db1Chandler Carruth    E = TempExpr->getSubExpr();
17112f78a6741a4cb3d904340f8d3d2714568b50e7aJohn McCall
172ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruth  if (DiagnoseUnusedComparison(*this, E))
173ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruth    return;
174ec8058f64bbcd79bd47748f4cf8628123dd3bae6Chandler Carruth
175a6115068cde719142eb394db88612c185cabd05bEli Friedman  E = WarnExpr;
176bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner  if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1770faede6f31b07bcec7b776f2b420c3ea9bb3e58cJohn McCall    if (E->getType()->isVoidType())
1780faede6f31b07bcec7b776f2b420c3ea9bb3e58cJohn McCall      return;
1790faede6f31b07bcec7b776f2b420c3ea9bb3e58cJohn McCall
180bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner    // If the callee has attribute pure, const, or warn_unused_result, warn with
181bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner    // a more specific message to make it clear what is happening.
182d20254f2875d0004c57ee766f258dbcee29f4841Nuno Lopes    if (const Decl *FD = CE->getCalleeDecl()) {
183bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner      if (FD->getAttr<WarnUnusedResultAttr>()) {
18442d7b2d25b6f90dc397886d05502b10ab5a8b51bMatt Beaumont-Gay        Diag(Loc, diag::warn_unused_result) << R1 << R2;
185bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner        return;
186bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner      }
187bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner      if (FD->getAttr<PureAttr>()) {
188bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner        Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure";
189bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner        return;
190bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner      }
191bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner      if (FD->getAttr<ConstAttr>()) {
192bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner        Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const";
193bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner        return;
194bc8d42c6f1565c0b2f93ad524edebfd7a4e6cac6Chris Lattner      }
195dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi    }
19612f78a6741a4cb3d904340f8d3d2714568b50e7aJohn McCall  } else if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
1974e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie    if (getLangOpts().ObjCAutoRefCount && ME->isDelegateInitCall()) {
198f85e193739c953358c865005855253af4f68a497John McCall      Diag(Loc, diag::err_arc_unused_init_message) << R1;
199f85e193739c953358c865005855253af4f68a497John McCall      return;
200f85e193739c953358c865005855253af4f68a497John McCall    }
201f031774aa2638b4d3f487e7e44180c1f89b867efFariborz Jahanian    const ObjCMethodDecl *MD = ME->getMethodDecl();
202f031774aa2638b4d3f487e7e44180c1f89b867efFariborz Jahanian    if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
20342d7b2d25b6f90dc397886d05502b10ab5a8b51bMatt Beaumont-Gay      Diag(Loc, diag::warn_unused_result) << R1 << R2;
204f031774aa2638b4d3f487e7e44180c1f89b867efFariborz Jahanian      return;
205f031774aa2638b4d3f487e7e44180c1f89b867efFariborz Jahanian    }
206ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek  } else if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) {
207ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek    const Expr *Source = POE->getSyntacticForm();
208ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek    if (isa<ObjCSubscriptRefExpr>(Source))
209ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek      DiagID = diag::warn_unused_container_subscript_expr;
210ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek    else
211ebcb57a8d298862c65043e88b2429591ab3c58d3Ted Kremenek      DiagID = diag::warn_unused_property_expr;
212d6e44a3c4193bd422bfa78c8086fb16bb2168e34Douglas Gregor  } else if (const CXXFunctionalCastExpr *FC
213d6e44a3c4193bd422bfa78c8086fb16bb2168e34Douglas Gregor                                       = dyn_cast<CXXFunctionalCastExpr>(E)) {
214d6e44a3c4193bd422bfa78c8086fb16bb2168e34Douglas Gregor    if (isa<CXXConstructExpr>(FC->getSubExpr()) ||
215d6e44a3c4193bd422bfa78c8086fb16bb2168e34Douglas Gregor        isa<CXXTemporaryObjectExpr>(FC->getSubExpr()))
216d6e44a3c4193bd422bfa78c8086fb16bb2168e34Douglas Gregor      return;
217f031774aa2638b4d3f487e7e44180c1f89b867efFariborz Jahanian  }
218209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall  // Diagnose "(void*) blah" as a typo for "(void) blah".
219209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall  else if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(E)) {
220209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall    TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
221209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall    QualType T = TI->getType();
222209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall
223209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall    // We really do want to use the non-canonical type here.
224209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall    if (T == Context.VoidPtrTy) {
225209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall      PointerTypeLoc TL = cast<PointerTypeLoc>(TI->getTypeLoc());
226209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall
227209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall      Diag(Loc, diag::warn_unused_voidptr)
228209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall        << FixItHint::CreateRemoval(TL.getStarLoc());
229209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall      return;
230209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall    }
231209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall  }
232209acbd6d0c1b4444eb8c1682717753e1cbe38deJohn McCall
233a6115068cde719142eb394db88612c185cabd05bEli Friedman  if (E->isGLValue() && E->getType().isVolatileQualified()) {
234a6115068cde719142eb394db88612c185cabd05bEli Friedman    Diag(Loc, diag::warn_unused_volatile) << R1 << R2;
235a6115068cde719142eb394db88612c185cabd05bEli Friedman    return;
236a6115068cde719142eb394db88612c185cabd05bEli Friedman  }
237a6115068cde719142eb394db88612c185cabd05bEli Friedman
238351ba91eaa6d30e523587b2d7ed676a5172c6e56Ted Kremenek  DiagRuntimeBehavior(Loc, 0, PDiag(DiagID) << R1 << R2);
239636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlsson}
240636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlsson
241625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenkovoid Sema::ActOnStartOfCompoundStmt() {
242625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  PushCompoundScope();
243625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko}
244625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko
245625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenkovoid Sema::ActOnFinishOfCompoundStmt() {
246625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  PopCompoundScope();
247625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko}
248625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko
249625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenkosema::CompoundScopeInfo &Sema::getCurCompoundScope() const {
250625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  return getCurFunction()->CompoundScopes.back();
251625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko}
252625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko
25360d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
2541b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnCompoundStmt(SourceLocation L, SourceLocation R,
255a60528cdac7deee3991c2b48af4df4f315e49e9dSebastian Redl                        MultiStmtArg elts, bool isStmtExpr) {
256a60528cdac7deee3991c2b48af4df4f315e49e9dSebastian Redl  unsigned NumElts = elts.size();
257a60528cdac7deee3991c2b48af4df4f315e49e9dSebastian Redl  Stmt **Elts = reinterpret_cast<Stmt**>(elts.release());
258c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner  // If we're in C89 mode, check that we don't have any decls after stmts.  If
259c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner  // so, emit an extension diagnostic.
2604e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie  if (!getLangOpts().C99 && !getLangOpts().CPlusPlus) {
261c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner    // Note that __extension__ can be around a decl.
262c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner    unsigned i = 0;
263c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner    // Skip over all declarations.
264c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner    for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
265c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner      /*empty*/;
266c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner
267c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner    // We found the end of the list or a statement.  Scan for another declstmt.
268c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner    for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
269c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner      /*empty*/;
2701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
271c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner    if (i != NumElts) {
2724afa39deaa245592977136d367251ee2c173dd8dDouglas Gregor      Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin();
273c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner      Diag(D->getLocation(), diag::ext_mixed_decls_code);
274c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner    }
275c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner  }
27698414c1b7d1944a57156d52e29bd41c005de09acChris Lattner  // Warn about unused expressions in statements.
27798414c1b7d1944a57156d52e29bd41c005de09acChris Lattner  for (unsigned i = 0; i != NumElts; ++i) {
278636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlsson    // Ignore statements that are last in a statement expression.
279636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlsson    if (isStmtExpr && i == NumElts - 1)
28098414c1b7d1944a57156d52e29bd41c005de09acChris Lattner      continue;
2811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
282636463e4c43be15e2f0fd0b8a08667f3066d8af7Anders Carlsson    DiagnoseUnusedExprResult(Elts[i]);
28398414c1b7d1944a57156d52e29bd41c005de09acChris Lattner  }
284a60528cdac7deee3991c2b48af4df4f315e49e9dSebastian Redl
285625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  // Check for suspicious empty body (null statement) in `for' and `while'
286625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  // statements.  Don't do anything for template instantiations, this just adds
287625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  // noise.
288625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  if (NumElts != 0 && !CurrentInstantiationScope &&
289625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko      getCurCompoundScope().HasEmptyLoopBodies) {
290625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko    for (unsigned i = 0; i != NumElts - 1; ++i)
291625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko      DiagnoseEmptyLoopBody(Elts[i], Elts[i + 1]);
292625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  }
293625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko
2948189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek  return Owned(new (Context) CompoundStmt(Context, Elts, NumElts, L, R));
2955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
2965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
29760d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
2989ae2f076ca5ab1feb3ba95629099ec2319833701John McCallSema::ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
2999ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                    SourceLocation DotDotDotLoc, Expr *RHSVal,
30024e1e707b4c362f18e371e2bbf054a8345b57bfaChris Lattner                    SourceLocation ColonLoc) {
3019ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  assert((LHSVal != 0) && "missing expression in case statement");
302117054a99f4994e4ec8a1fc904b554e1f2dc9b29Sebastian Redl
3038ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith  if (getCurFunction()->SwitchStack.empty()) {
3048ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith    Diag(CaseLoc, diag::err_case_not_in_switch);
30524e1e707b4c362f18e371e2bbf054a8345b57bfaChris Lattner    return StmtError();
3068ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith  }
3075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
3084e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie  if (!getLangOpts().CPlusPlus0x) {
3098ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith    // C99 6.8.4.2p3: The expression shall be an integer constant.
3108ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith    // However, GCC allows any evaluatable integer expression.
311282e7e66748cc6dd14d6f7f2cb52e5373c531e61Richard Smith    if (!LHSVal->isTypeDependent() && !LHSVal->isValueDependent()) {
312282e7e66748cc6dd14d6f7f2cb52e5373c531e61Richard Smith      LHSVal = VerifyIntegerConstantExpression(LHSVal).take();
313282e7e66748cc6dd14d6f7f2cb52e5373c531e61Richard Smith      if (!LHSVal)
314282e7e66748cc6dd14d6f7f2cb52e5373c531e61Richard Smith        return StmtError();
315282e7e66748cc6dd14d6f7f2cb52e5373c531e61Richard Smith    }
316117054a99f4994e4ec8a1fc904b554e1f2dc9b29Sebastian Redl
3178ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith    // GCC extension: The expression shall be an integer constant.
318117054a99f4994e4ec8a1fc904b554e1f2dc9b29Sebastian Redl
319282e7e66748cc6dd14d6f7f2cb52e5373c531e61Richard Smith    if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent()) {
320282e7e66748cc6dd14d6f7f2cb52e5373c531e61Richard Smith      RHSVal = VerifyIntegerConstantExpression(RHSVal).take();
321282e7e66748cc6dd14d6f7f2cb52e5373c531e61Richard Smith      // Recover from an error by just forgetting about it.
3228ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith    }
3238a87e57beb96212ee61dc08a5f691cd7f7710703Chris Lattner  }
3245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
325dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor  CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc,
326dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor                                        ColonLoc);
327781472fe99a120098c631b0cbe33c89f8cef5e70John McCall  getCurFunction()->SwitchStack.back()->addSwitchCase(CS);
328117054a99f4994e4ec8a1fc904b554e1f2dc9b29Sebastian Redl  return Owned(CS);
3295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
3305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
33124e1e707b4c362f18e371e2bbf054a8345b57bfaChris Lattner/// ActOnCaseStmtBody - This installs a statement as the body of a case.
3329ae2f076ca5ab1feb3ba95629099ec2319833701John McCallvoid Sema::ActOnCaseStmtBody(Stmt *caseStmt, Stmt *SubStmt) {
3335440bfaff6aec058b60bc6da75bb4f13b7a76491Chandler Carruth  DiagnoseUnusedExprResult(SubStmt);
3345440bfaff6aec058b60bc6da75bb4f13b7a76491Chandler Carruth
33524e1e707b4c362f18e371e2bbf054a8345b57bfaChris Lattner  CaseStmt *CS = static_cast<CaseStmt*>(caseStmt);
33624e1e707b4c362f18e371e2bbf054a8345b57bfaChris Lattner  CS->setSubStmt(SubStmt);
33724e1e707b4c362f18e371e2bbf054a8345b57bfaChris Lattner}
33824e1e707b4c362f18e371e2bbf054a8345b57bfaChris Lattner
33960d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
3401eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpSema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc,
3419ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                       Stmt *SubStmt, Scope *CurScope) {
3425440bfaff6aec058b60bc6da75bb4f13b7a76491Chandler Carruth  DiagnoseUnusedExprResult(SubStmt);
3435440bfaff6aec058b60bc6da75bb4f13b7a76491Chandler Carruth
344781472fe99a120098c631b0cbe33c89f8cef5e70John McCall  if (getCurFunction()->SwitchStack.empty()) {
3450fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner    Diag(DefaultLoc, diag::err_default_not_in_switch);
346117054a99f4994e4ec8a1fc904b554e1f2dc9b29Sebastian Redl    return Owned(SubStmt);
3470fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner  }
348117054a99f4994e4ec8a1fc904b554e1f2dc9b29Sebastian Redl
349dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor  DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt);
350781472fe99a120098c631b0cbe33c89f8cef5e70John McCall  getCurFunction()->SwitchStack.back()->addSwitchCase(DS);
351117054a99f4994e4ec8a1fc904b554e1f2dc9b29Sebastian Redl  return Owned(DS);
3525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
3535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
35460d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
35557ad37823e198f977cac605dbfbaefb4daf325e9Chris LattnerSema::ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
35657ad37823e198f977cac605dbfbaefb4daf325e9Chris Lattner                     SourceLocation ColonLoc, Stmt *SubStmt) {
357ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattner  // If the label was multiply defined, reject it now.
358ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattner  if (TheDecl->getStmt()) {
359ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattner    Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->getDeclName();
360ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattner    Diag(TheDecl->getLocation(), diag::note_previous_definition);
361de307473448fb3cebcb4c10090728300b53bca03Sebastian Redl    return Owned(SubStmt);
3625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer  }
363de307473448fb3cebcb4c10090728300b53bca03Sebastian Redl
364ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattner  // Otherwise, things are good.  Fill in the declaration and return it.
365ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattner  LabelStmt *LS = new (Context) LabelStmt(IdentLoc, TheDecl, SubStmt);
366ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattner  TheDecl->setStmt(LS);
367203548ba4b72e7e59320d352afc1eb0b5ab131deAbramo Bagnara  if (!TheDecl->isGnuLocal())
368203548ba4b72e7e59320d352afc1eb0b5ab131deAbramo Bagnara    TheDecl->setLocation(IdentLoc);
369ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattner  return Owned(LS);
3705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
3715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
372534986f2b21e6050bf00163cd6423fd92155a6edRichard SmithStmtResult Sema::ActOnAttributedStmt(SourceLocation AttrLoc,
373534986f2b21e6050bf00163cd6423fd92155a6edRichard Smith                                     const AttrVec &Attrs,
374534986f2b21e6050bf00163cd6423fd92155a6edRichard Smith                                     Stmt *SubStmt) {
375534986f2b21e6050bf00163cd6423fd92155a6edRichard Smith  // Fill in the declaration and return it. Variable length will require to
376534986f2b21e6050bf00163cd6423fd92155a6edRichard Smith  // change this to AttributedStmt::Create(Context, ....);
377534986f2b21e6050bf00163cd6423fd92155a6edRichard Smith  // and probably using ArrayRef
378534986f2b21e6050bf00163cd6423fd92155a6edRichard Smith  AttributedStmt *LS = new (Context) AttributedStmt(AttrLoc, Attrs, SubStmt);
379534986f2b21e6050bf00163cd6423fd92155a6edRichard Smith  return Owned(LS);
380534986f2b21e6050bf00163cd6423fd92155a6edRichard Smith}
381534986f2b21e6050bf00163cd6423fd92155a6edRichard Smith
38260d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
383d226f65006733ed7f709c3174f22ce33391cb58fJohn McCallSema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, Decl *CondVar,
38444aa1f397855f130e88e62ffc1029f7f83bb5d2eArgyrios Kyrtzidis                  Stmt *thenStmt, SourceLocation ElseLoc,
38544aa1f397855f130e88e62ffc1029f7f83bb5d2eArgyrios Kyrtzidis                  Stmt *elseStmt) {
38660d7b3a319d84d688752be3870615ac0f111fb16John McCall  ExprResult CondResult(CondVal.release());
3871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
3888cfe5a784133d90bf329fd20801824a6f71bb8caDouglas Gregor  VarDecl *ConditionVar = 0;
389d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall  if (CondVar) {
390d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall    ConditionVar = cast<VarDecl>(CondVar);
391586596fd7f7a336a2847b300c80614dcf39ab6d5Douglas Gregor    CondResult = CheckConditionVariable(ConditionVar, IfLoc, true);
39299e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor    if (CondResult.isInvalid())
39399e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor      return StmtError();
3948cfe5a784133d90bf329fd20801824a6f71bb8caDouglas Gregor  }
39599e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor  Expr *ConditionExpr = CondResult.takeAs<Expr>();
39699e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor  if (!ConditionExpr)
39799e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor    return StmtError();
398dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
399754431107b61a0523df5271c2876a73dd5a051e9Anders Carlsson  DiagnoseUnusedExprResult(thenStmt);
4005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
4019ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  if (!elseStmt) {
402625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko    DiagnoseEmptyStmtBody(ConditionExpr->getLocEnd(), thenStmt,
403625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko                          diag::warn_empty_if_body);
4042d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson  }
4052d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson
406754431107b61a0523df5271c2876a73dd5a051e9Anders Carlsson  DiagnoseUnusedExprResult(elseStmt);
4071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
408dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi  return Owned(new (Context) IfStmt(Context, IfLoc, ConditionVar, ConditionExpr,
40944aa1f397855f130e88e62ffc1029f7f83bb5d2eArgyrios Kyrtzidis                                    thenStmt, ElseLoc, elseStmt));
4105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
4115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
412f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner/// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
413f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner/// the specified width and sign.  If an overflow occurs, detect it and emit
414f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner/// the specified diagnostic.
415f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattnervoid Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val,
416f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner                                              unsigned NewWidth, bool NewSign,
4171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump                                              SourceLocation Loc,
418f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner                                              unsigned DiagID) {
419f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  // Perform a conversion to the promoted condition type if needed.
420f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  if (NewWidth > Val.getBitWidth()) {
421f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    // If this is an extension, just do it.
4229f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad    Val = Val.extend(NewWidth);
423f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    Val.setIsSigned(NewSign);
424f9f627dbbc62fbf51b906c24c783b4249dc7e9bbDouglas Gregor
425f9f627dbbc62fbf51b906c24c783b4249dc7e9bbDouglas Gregor    // If the input was signed and negative and the output is
426f9f627dbbc62fbf51b906c24c783b4249dc7e9bbDouglas Gregor    // unsigned, don't bother to warn: this is implementation-defined
427f9f627dbbc62fbf51b906c24c783b4249dc7e9bbDouglas Gregor    // behavior.
428f9f627dbbc62fbf51b906c24c783b4249dc7e9bbDouglas Gregor    // FIXME: Introduce a second, default-ignored warning for this case?
429f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  } else if (NewWidth < Val.getBitWidth()) {
430f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    // If this is a truncation, check for overflow.
431f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    llvm::APSInt ConvVal(Val);
4329f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad    ConvVal = ConvVal.trunc(NewWidth);
433b2137ae3f1bd0aadb0552189af2824a324ffaa69Chris Lattner    ConvVal.setIsSigned(NewSign);
4349f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad    ConvVal = ConvVal.extend(Val.getBitWidth());
435b2137ae3f1bd0aadb0552189af2824a324ffaa69Chris Lattner    ConvVal.setIsSigned(Val.isSigned());
436f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    if (ConvVal != Val)
437d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner      Diag(Loc, DiagID) << Val.toString(10) << ConvVal.toString(10);
4381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
439f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    // Regardless of whether a diagnostic was emitted, really do the
440f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    // truncation.
4419f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad    Val = Val.trunc(NewWidth);
442b2137ae3f1bd0aadb0552189af2824a324ffaa69Chris Lattner    Val.setIsSigned(NewSign);
443f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  } else if (NewSign != Val.isSigned()) {
444f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    // Convert the sign to match the sign of the condition.  This can cause
445f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    // overflow as well: unsigned(INTMIN)
446dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi    // We don't diagnose this overflow, because it is implementation-defined
4472853eac24e2e70a74d7da817653b0528b976039fDouglas Gregor    // behavior.
4482853eac24e2e70a74d7da817653b0528b976039fDouglas Gregor    // FIXME: Introduce a second, default-ignored warning for this case?
449f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    llvm::APSInt OldVal(Val);
450f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    Val.setIsSigned(NewSign);
451f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  }
452f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner}
453f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner
4540471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattnernamespace {
4550471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner  struct CaseCompareFunctor {
4560471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner    bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
4570471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner                    const llvm::APSInt &RHS) {
4580471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner      return LHS.first < RHS;
4590471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner    }
4600e85a2761ace912c66663d779dd230f88cf77fe0Chris Lattner    bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
4610e85a2761ace912c66663d779dd230f88cf77fe0Chris Lattner                    const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
4620e85a2761ace912c66663d779dd230f88cf77fe0Chris Lattner      return LHS.first < RHS.first;
4630e85a2761ace912c66663d779dd230f88cf77fe0Chris Lattner    }
4640471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner    bool operator()(const llvm::APSInt &LHS,
4650471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner                    const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
4660471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner      return LHS < RHS.first;
4670471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner    }
4680471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner  };
4690471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner}
4700471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner
471764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner/// CmpCaseVals - Comparison predicate for sorting case values.
472764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner///
473764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattnerstatic bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs,
474764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner                        const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
475764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner  if (lhs.first < rhs.first)
476764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner    return true;
477764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner
478764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner  if (lhs.first == rhs.first &&
479764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner      lhs.second->getCaseLoc().getRawEncoding()
480764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner       < rhs.second->getCaseLoc().getRawEncoding())
481764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner    return true;
482764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner  return false;
483764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner}
484764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner
485ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor/// CmpEnumVals - Comparison predicate for sorting enumeration values.
486ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor///
487ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregorstatic bool CmpEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
488ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor                        const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
489ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor{
490ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor  return lhs.first < rhs.first;
491ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor}
492ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor
493ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor/// EqEnumVals - Comparison preficate for uniqing enumeration values.
494ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor///
495ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregorstatic bool EqEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
496ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor                       const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
497ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor{
498ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor  return lhs.first == rhs.first;
499ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor}
500ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor
5015f04881eb025f61396d0555d8173730fe2759e0aChris Lattner/// GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of
5025f04881eb025f61396d0555d8173730fe2759e0aChris Lattner/// potentially integral-promoted expression @p expr.
503a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCallstatic QualType GetTypeBeforeIntegralPromotion(Expr *&expr) {
504a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall  if (ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(expr))
505a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall    expr = cleanups->getSubExpr();
506a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall  while (ImplicitCastExpr *impcast = dyn_cast<ImplicitCastExpr>(expr)) {
507a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall    if (impcast->getCastKind() != CK_IntegralCast) break;
508a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall    expr = impcast->getSubExpr();
5095f04881eb025f61396d0555d8173730fe2759e0aChris Lattner  }
5105f04881eb025f61396d0555d8173730fe2759e0aChris Lattner  return expr->getType();
5115f04881eb025f61396d0555d8173730fe2759e0aChris Lattner}
5125f04881eb025f61396d0555d8173730fe2759e0aChris Lattner
51360d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
514dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA TakumiSema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, Expr *Cond,
515d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall                             Decl *CondVar) {
51660d7b3a319d84d688752be3870615ac0f111fb16John McCall  ExprResult CondResult;
5179ae2f076ca5ab1feb3ba95629099ec2319833701John McCall
518586596fd7f7a336a2847b300c80614dcf39ab6d5Douglas Gregor  VarDecl *ConditionVar = 0;
519d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall  if (CondVar) {
520d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall    ConditionVar = cast<VarDecl>(CondVar);
5219ae2f076ca5ab1feb3ba95629099ec2319833701John McCall    CondResult = CheckConditionVariable(ConditionVar, SourceLocation(), false);
5229ae2f076ca5ab1feb3ba95629099ec2319833701John McCall    if (CondResult.isInvalid())
523586596fd7f7a336a2847b300c80614dcf39ab6d5Douglas Gregor      return StmtError();
524dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
5259ae2f076ca5ab1feb3ba95629099ec2319833701John McCall    Cond = CondResult.release();
526586596fd7f7a336a2847b300c80614dcf39ab6d5Douglas Gregor  }
527dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
5289ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  if (!Cond)
529586596fd7f7a336a2847b300c80614dcf39ab6d5Douglas Gregor    return StmtError();
530dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
531ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor  class SwitchConvertDiagnoser : public ICEConvertDiagnoser {
532ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    Expr *Cond;
5338e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
534ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor  public:
535ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    SwitchConvertDiagnoser(Expr *Cond)
536ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor      : ICEConvertDiagnoser(false, true), Cond(Cond) { }
5378e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
538ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    virtual DiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
539ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor                                             QualType T) {
540ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor      return S.Diag(Loc, diag::err_typecheck_statement_requires_integer) << T;
541ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    }
5428e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
543ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    virtual DiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
544ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor                                                 QualType T) {
545ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor      return S.Diag(Loc, diag::err_switch_incomplete_class_type)
546ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor               << T << Cond->getSourceRange();
547ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    }
5488e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
549ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    virtual DiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
550ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor                                                   QualType T,
551ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor                                                   QualType ConvTy) {
552ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor      return S.Diag(Loc, diag::err_switch_explicit_conversion) << T << ConvTy;
553ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    }
5548e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
555ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    virtual DiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
556ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor                                               QualType ConvTy) {
557ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor      return S.Diag(Conv->getLocation(), diag::note_switch_conversion)
558ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor        << ConvTy->isEnumeralType() << ConvTy;
559ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    }
5608e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
561ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    virtual DiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
562ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor                                                QualType T) {
563ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor      return S.Diag(Loc, diag::err_switch_multiple_conversions) << T;
564ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    }
5658e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
566ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    virtual DiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
567ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor                                            QualType ConvTy) {
568ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor      return S.Diag(Conv->getLocation(), diag::note_switch_conversion)
569ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor      << ConvTy->isEnumeralType() << ConvTy;
570ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    }
5718e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
572ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    virtual DiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
573ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor                                                 QualType T,
574ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor                                                 QualType ConvTy) {
575ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor      return DiagnosticBuilder::getEmpty();
576ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    }
577ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor  } SwitchDiagnoser(Cond);
578ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor
5799ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  CondResult
580ab41fe914f63bb470dfa7e400876ada72f57a931Douglas Gregor    = ConvertToIntegralOrEnumerationType(SwitchLoc, Cond, SwitchDiagnoser,
581f39aec17b89f8f0dd78e78c50ad2fa08f12272e3Richard Smith                                         /*AllowScopedEnumerations*/ true);
5829ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  if (CondResult.isInvalid()) return StmtError();
5839ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  Cond = CondResult.take();
584dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
585a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall  // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr.
586a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall  CondResult = UsualUnaryConversions(Cond);
587a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall  if (CondResult.isInvalid()) return StmtError();
588a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall  Cond = CondResult.take();
589a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall
590d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall  if (!CondVar) {
591b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall    CheckImplicitConversions(Cond, SwitchLoc);
5924765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall    CondResult = MaybeCreateExprWithCleanups(Cond);
5939ae2f076ca5ab1feb3ba95629099ec2319833701John McCall    if (CondResult.isInvalid())
594586596fd7f7a336a2847b300c80614dcf39ab6d5Douglas Gregor      return StmtError();
5959ae2f076ca5ab1feb3ba95629099ec2319833701John McCall    Cond = CondResult.take();
596586596fd7f7a336a2847b300c80614dcf39ab6d5Douglas Gregor  }
597b60a77e453d32db0ab1914d28e175c2defc0eb65John McCall
598781472fe99a120098c631b0cbe33c89f8cef5e70John McCall  getCurFunction()->setHasBranchIntoScope();
599dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
6009ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  SwitchStmt *SS = new (Context) SwitchStmt(Context, ConditionVar, Cond);
601781472fe99a120098c631b0cbe33c89f8cef5e70John McCall  getCurFunction()->SwitchStack.push_back(SS);
602586596fd7f7a336a2847b300c80614dcf39ab6d5Douglas Gregor  return Owned(SS);
6037e52de4b45286d057b367bb1f9283a1e32d79252Chris Lattner}
6047e52de4b45286d057b367bb1f9283a1e32d79252Chris Lattner
60528164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greifstatic void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned) {
60628164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif  if (Val.getBitWidth() < BitWidth)
6079f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad    Val = Val.extend(BitWidth);
60828164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif  else if (Val.getBitWidth() > BitWidth)
6099f71a8f4c7a182a5236da9e747d57cc1d1bd24c2Jay Foad    Val = Val.trunc(BitWidth);
61028164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif  Val.setIsSigned(IsSigned);
61128164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif}
61228164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif
61360d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
6149ae2f076ca5ab1feb3ba95629099ec2319833701John McCallSema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch,
6159ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                            Stmt *BodyStmt) {
6169ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  SwitchStmt *SS = cast<SwitchStmt>(Switch);
617781472fe99a120098c631b0cbe33c89f8cef5e70John McCall  assert(SS == getCurFunction()->SwitchStack.back() &&
618781472fe99a120098c631b0cbe33c89f8cef5e70John McCall         "switch stack missing push/pop!");
619de307473448fb3cebcb4c10090728300b53bca03Sebastian Redl
6209dcbfa450d751bd68fc4af8b75da381d4f6984b9Steve Naroff  SS->setBody(BodyStmt, SwitchLoc);
621781472fe99a120098c631b0cbe33c89f8cef5e70John McCall  getCurFunction()->SwitchStack.pop_back();
622c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson
623f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  Expr *CondExpr = SS->getCond();
624a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall  if (!CondExpr) return StmtError();
625de307473448fb3cebcb4c10090728300b53bca03Sebastian Redl
626a0d3ca1ea5578bc736bb71bcec50ab41fefc87b9Douglas Gregor  QualType CondType = CondExpr->getType();
627a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall
628a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall  Expr *CondExprBeforePromotion = CondExpr;
629a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall  QualType CondTypeBeforePromotion =
630a8e0cd8cdecc7e0ba1792e46773b884c6eed4829John McCall      GetTypeBeforeIntegralPromotion(CondExprBeforePromotion);
63184fb9c0be621c9e4ca4e56f67dae2a0bb6e44821Douglas Gregor
6325f04881eb025f61396d0555d8173730fe2759e0aChris Lattner  // C++ 6.4.2.p2:
6335f04881eb025f61396d0555d8173730fe2759e0aChris Lattner  // Integral promotions are performed (on the switch condition).
6345f04881eb025f61396d0555d8173730fe2759e0aChris Lattner  //
6355f04881eb025f61396d0555d8173730fe2759e0aChris Lattner  // A case value unrepresentable by the original switch condition
6365f04881eb025f61396d0555d8173730fe2759e0aChris Lattner  // type (before the promotion) doesn't make sense, even when it can
6375f04881eb025f61396d0555d8173730fe2759e0aChris Lattner  // be represented by the promoted type.  Therefore we need to find
6385f04881eb025f61396d0555d8173730fe2759e0aChris Lattner  // the pre-promotion type of the switch condition.
63912356b119032edd64e9c32f9f01920d12c2acc57Edward O'Callaghan  if (!CondExpr->isTypeDependent()) {
640acb0bd85d30ecacbe872ca9d9cfac5d7b6038a43Douglas Gregor    // We have already converted the expression to an integral or enumeration
641dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi    // type, when we started the switch statement. If we don't have an
642acb0bd85d30ecacbe872ca9d9cfac5d7b6038a43Douglas Gregor    // appropriate type now, just return an error.
643acb0bd85d30ecacbe872ca9d9cfac5d7b6038a43Douglas Gregor    if (!CondType->isIntegralOrEnumerationType())
64412356b119032edd64e9c32f9f01920d12c2acc57Edward O'Callaghan      return StmtError();
64512356b119032edd64e9c32f9f01920d12c2acc57Edward O'Callaghan
6462b334bb3126a67895813e49e6228dad4aec0b4d6Chris Lattner    if (CondExpr->isKnownToHaveBooleanValue()) {
64712356b119032edd64e9c32f9f01920d12c2acc57Edward O'Callaghan      // switch(bool_expr) {...} is often a programmer error, e.g.
64812356b119032edd64e9c32f9f01920d12c2acc57Edward O'Callaghan      //   switch(n && mask) { ... }  // Doh - should be "n & mask".
64912356b119032edd64e9c32f9f01920d12c2acc57Edward O'Callaghan      // One can always use an if statement instead of switch(bool_expr).
65012356b119032edd64e9c32f9f01920d12c2acc57Edward O'Callaghan      Diag(SwitchLoc, diag::warn_bool_switch_condition)
65112356b119032edd64e9c32f9f01920d12c2acc57Edward O'Callaghan          << CondExpr->getSourceRange();
65212356b119032edd64e9c32f9f01920d12c2acc57Edward O'Callaghan    }
653c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson  }
654de307473448fb3cebcb4c10090728300b53bca03Sebastian Redl
655f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  // Get the bitwidth of the switched-on value before promotions.  We must
656f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  // convert the integer case values to this width before comparison.
6571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  bool HasDependentValue
658dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor    = CondExpr->isTypeDependent() || CondExpr->isValueDependent();
6591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  unsigned CondWidth
6601d6ab7af99a1fc059a6aa5da083640c1d94b07f7Chris Lattner    = HasDependentValue ? 0 : Context.getIntWidth(CondTypeBeforePromotion);
661575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor  bool CondIsSigned
662575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor    = CondTypeBeforePromotion->isSignedIntegerOrEnumerationType();
6631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
664f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  // Accumulate all of the case values in a vector so that we can sort them
665f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  // and detect duplicates.  This vector contains the APInt for the case after
666f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  // it has been converted to the condition type.
6675f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner  typedef SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy;
6680471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner  CaseValsTy CaseVals;
6691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
670f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  // Keep track of any GNU case ranges we see.  The APSInt is the low value.
671ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor  typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy;
672ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor  CaseRangesTy CaseRanges;
6731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
674f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  DefaultStmt *TheDefaultStmt = 0;
6751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
676b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner  bool CaseListIsErroneous = false;
6771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
678dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor  for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue;
679c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson       SC = SC->getNextSwitchCase()) {
6801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
681c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson    if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
682f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner      if (TheDefaultStmt) {
683f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner        Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);
6845f4a6829dc58cab2f76e2b98492859aa3b91e3f2Chris Lattner        Diag(TheDefaultStmt->getDefaultLoc(), diag::note_duplicate_case_prev);
685de307473448fb3cebcb4c10090728300b53bca03Sebastian Redl
686f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner        // FIXME: Remove the default statement from the switch block so that
687390b4cc8b45a05612349269ef08faab3e4688f06Mike Stump        // we'll return a valid AST.  This requires recursing down the AST and
688390b4cc8b45a05612349269ef08faab3e4688f06Mike Stump        // finding it, not something we are set up to do right now.  For now,
689390b4cc8b45a05612349269ef08faab3e4688f06Mike Stump        // just lop the entire switch stmt out of the AST.
690b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner        CaseListIsErroneous = true;
691c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson      }
692f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner      TheDefaultStmt = DS;
6931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
694f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    } else {
695f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner      CaseStmt *CS = cast<CaseStmt>(SC);
6961eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
6971e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner      Expr *Lo = CS->getLHS();
698dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor
699dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      if (Lo->isTypeDependent() || Lo->isValueDependent()) {
700dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        HasDependentValue = true;
701dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        break;
702dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      }
7031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
7048ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith      llvm::APSInt LoVal;
7051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
7064e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie      if (getLangOpts().CPlusPlus0x) {
7078ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        // C++11 [stmt.switch]p2: the constant-expression shall be a converted
7088ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        // constant expression of the promoted type of the switch condition.
7098ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        ExprResult ConvLo =
7108ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          CheckConvertedConstantExpression(Lo, CondType, LoVal, CCEK_CaseValue);
7118ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        if (ConvLo.isInvalid()) {
7128ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          CaseListIsErroneous = true;
7138ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          continue;
7148ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        }
7158ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        Lo = ConvLo.take();
7168ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith      } else {
7178ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        // We already verified that the expression has a i-c-e value (C99
7188ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        // 6.8.4.2p3) - get that value now.
7198ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        LoVal = Lo->EvaluateKnownConstInt(Context);
7208ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith
7218ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        // If the LHS is not the same type as the condition, insert an implicit
7228ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        // cast.
7238ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        Lo = DefaultLvalueConversion(Lo).take();
7248ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        Lo = ImpCastExprToType(Lo, CondType, CK_IntegralCast).take();
7258ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith      }
7268ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith
7278ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith      // Convert the value to the same width/sign as the condition had prior to
7288ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith      // integral promotions.
7298ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith      //
7308ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith      // FIXME: This causes us to reject valid code:
7318ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith      //   switch ((char)c) { case 256: case 0: return 0; }
7328ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith      // Here we claim there is a duplicated condition value, but there is not.
733f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner      ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned,
73428164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif                                         Lo->getLocStart(),
735f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner                                         diag::warn_case_value_overflow);
7366c36be5b383875b490684bcf439d6d427298c1afChris Lattner
7371e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner      CS->setLHS(Lo);
7381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
739b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner      // If this is a case range, remember it in CaseRanges, otherwise CaseVals.
740dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      if (CS->getRHS()) {
7411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump        if (CS->getRHS()->isTypeDependent() ||
742dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor            CS->getRHS()->isValueDependent()) {
743dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          HasDependentValue = true;
744dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          break;
745dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        }
746f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner        CaseRanges.push_back(std::make_pair(LoVal, CS));
7471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump      } else
748b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner        CaseVals.push_back(std::make_pair(LoVal, CS));
749f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner    }
750f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner  }
751b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner
752dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor  if (!HasDependentValue) {
7530fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall    // If we don't have a default statement, check whether the
7540fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall    // condition is constant.
7550fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall    llvm::APSInt ConstantCondValue;
7560fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall    bool HasConstantCond = false;
7570fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall    if (!HasDependentValue && !TheDefaultStmt) {
75851f4708c00110940ca3f337961915f2ca1668375Richard Smith      HasConstantCond
75980d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith        = CondExprBeforePromotion->EvaluateAsInt(ConstantCondValue, Context,
76080d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith                                                 Expr::SE_AllowSideEffects);
76180d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith      assert(!HasConstantCond ||
76280d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith             (ConstantCondValue.getBitWidth() == CondWidth &&
76380d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith              ConstantCondValue.isSigned() == CondIsSigned));
7640fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall    }
76580d4b55db94db2172a04617d1a80feca6bbcea5cRichard Smith    bool ShouldCheckConstantCond = HasConstantCond;
7660fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall
767dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor    // Sort all the scalar case values so we can easily detect duplicates.
768dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor    std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals);
769dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor
770dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor    if (!CaseVals.empty()) {
7710fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall      for (unsigned i = 0, e = CaseVals.size(); i != e; ++i) {
7720fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall        if (ShouldCheckConstantCond &&
7730fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall            CaseVals[i].first == ConstantCondValue)
7740fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall          ShouldCheckConstantCond = false;
7750fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall
7760fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall        if (i != 0 && CaseVals[i].first == CaseVals[i-1].first) {
777dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          // If we have a duplicate, report it.
7783940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor          // First, determine if either case value has a name
7793940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor          StringRef PrevString, CurrString;
7803940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor          Expr *PrevCase = CaseVals[i-1].second->getLHS()->IgnoreParenCasts();
7813940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor          Expr *CurrCase = CaseVals[i].second->getLHS()->IgnoreParenCasts();
7823940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor          if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(PrevCase)) {
7833940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor            PrevString = DeclRef->getDecl()->getName();
7843940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor          }
7853940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor          if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(CurrCase)) {
7863940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor            CurrString = DeclRef->getDecl()->getName();
7873940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor          }
78850de5e3247a20e0e548dc47022a011250e6e4e8fDouglas Gregor          llvm::SmallString<16> CaseValStr;
78950de5e3247a20e0e548dc47022a011250e6e4e8fDouglas Gregor          CaseVals[i-1].first.toString(CaseValStr);
7903940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor
7913940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor          if (PrevString == CurrString)
7923940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor            Diag(CaseVals[i].second->getLHS()->getLocStart(),
7933940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor                 diag::err_duplicate_case) <<
79450de5e3247a20e0e548dc47022a011250e6e4e8fDouglas Gregor                 (PrevString.empty() ? CaseValStr.str() : PrevString);
7953940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor          else
7963940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor            Diag(CaseVals[i].second->getLHS()->getLocStart(),
7973940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor                 diag::err_duplicate_case_differing_expr) <<
79850de5e3247a20e0e548dc47022a011250e6e4e8fDouglas Gregor                 (PrevString.empty() ? CaseValStr.str() : PrevString) <<
79950de5e3247a20e0e548dc47022a011250e6e4e8fDouglas Gregor                 (CurrString.empty() ? CaseValStr.str() : CurrString) <<
8003940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor                 CaseValStr;
8013940ce83438e2332ba541f4e65e700fbefe0c7a8Douglas Gregor
8020fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall          Diag(CaseVals[i-1].second->getLHS()->getLocStart(),
803dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor               diag::note_duplicate_case_prev);
804390b4cc8b45a05612349269ef08faab3e4688f06Mike Stump          // FIXME: We really want to remove the bogus case stmt from the
805390b4cc8b45a05612349269ef08faab3e4688f06Mike Stump          // substmt, but we have no way to do this right now.
806dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          CaseListIsErroneous = true;
807dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        }
8086efc4d3659632ddcea4a58cb62e9ee54ca4a373eChris Lattner      }
809b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner    }
8101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
811dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor    // Detect duplicate case ranges, which usually don't exist at all in
812dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor    // the first place.
813dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor    if (!CaseRanges.empty()) {
814dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      // Sort all the case ranges by their low value so we can easily detect
815dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      // overlaps between ranges.
816dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      std::stable_sort(CaseRanges.begin(), CaseRanges.end());
8171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
818dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      // Scan the ranges, computing the high values and removing empty ranges.
819dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      std::vector<llvm::APSInt> HiVals;
820dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
8210fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall        llvm::APSInt &LoVal = CaseRanges[i].first;
822dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        CaseStmt *CR = CaseRanges[i].second;
823dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        Expr *Hi = CR->getRHS();
8248ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        llvm::APSInt HiVal;
8258ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith
8264e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie        if (getLangOpts().CPlusPlus0x) {
8278ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          // C++11 [stmt.switch]p2: the constant-expression shall be a converted
8288ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          // constant expression of the promoted type of the switch condition.
8298ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          ExprResult ConvHi =
8308ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith            CheckConvertedConstantExpression(Hi, CondType, HiVal,
8318ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith                                             CCEK_CaseValue);
8328ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          if (ConvHi.isInvalid()) {
8338ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith            CaseListIsErroneous = true;
8348ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith            continue;
8358ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          }
8368ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          Hi = ConvHi.take();
8378ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        } else {
8388ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          HiVal = Hi->EvaluateKnownConstInt(Context);
8398ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith
8408ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          // If the RHS is not the same type as the condition, insert an
8418ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          // implicit cast.
8428ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          Hi = DefaultLvalueConversion(Hi).take();
8438ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith          Hi = ImpCastExprToType(Hi, CondType, CK_IntegralCast).take();
8448ef7b203332b0c8d65876a1f5e6d1db4e6f40e4bRichard Smith        }
8451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
846dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        // Convert the value to the same width/sign as the condition.
847dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned,
84828164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif                                           Hi->getLocStart(),
849dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor                                           diag::warn_case_value_overflow);
8501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
851dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        CR->setRHS(Hi);
8521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
853dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        // If the low value is bigger than the high value, the case is empty.
8540fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall        if (LoVal > HiVal) {
855dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range)
856dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor            << SourceRange(CR->getLHS()->getLocStart(),
85728164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif                           Hi->getLocEnd());
858dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          CaseRanges.erase(CaseRanges.begin()+i);
859dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          --i, --e;
860dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          continue;
861dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        }
8620fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall
8630fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall        if (ShouldCheckConstantCond &&
8640fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall            LoVal <= ConstantCondValue &&
8650fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall            ConstantCondValue <= HiVal)
8660fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall          ShouldCheckConstantCond = false;
8670fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall
868dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        HiVals.push_back(HiVal);
8690471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner      }
8701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
871dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      // Rescan the ranges, looking for overlap with singleton values and other
872dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      // ranges.  Since the range list is sorted, we only need to compare case
873dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      // ranges with their neighbors.
874dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor      for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
875dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        llvm::APSInt &CRLo = CaseRanges[i].first;
876dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        llvm::APSInt &CRHi = HiVals[i];
877dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        CaseStmt *CR = CaseRanges[i].second;
8781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
879dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        // Check to see whether the case range overlaps with any
880dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        // singleton cases.
881dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        CaseStmt *OverlapStmt = 0;
882dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        llvm::APSInt OverlapVal(32);
8831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
884dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        // Find the smallest value >= the lower bound.  If I is in the
885dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        // case range, then we have overlap.
886dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(),
887dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor                                                  CaseVals.end(), CRLo,
888dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor                                                  CaseCompareFunctor());
889dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        if (I != CaseVals.end() && I->first < CRHi) {
890dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          OverlapVal  = I->first;   // Found overlap with scalar.
891dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          OverlapStmt = I->second;
892dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        }
8931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
894dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        // Find the smallest value bigger than the upper bound.
895dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());
896dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        if (I != CaseVals.begin() && (I-1)->first >= CRLo) {
897dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          OverlapVal  = (I-1)->first;      // Found overlap with scalar.
898dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          OverlapStmt = (I-1)->second;
899dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        }
9001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
901dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        // Check to see if this case stmt overlaps with the subsequent
902dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        // case range.
903dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        if (i && CRLo <= HiVals[i-1]) {
904dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          OverlapVal  = HiVals[i-1];       // Found overlap with range.
905dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          OverlapStmt = CaseRanges[i-1].second;
906dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        }
9071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
908dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        if (OverlapStmt) {
909dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          // If we have a duplicate, report it.
910dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          Diag(CR->getLHS()->getLocStart(), diag::err_duplicate_case)
911dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor            << OverlapVal.toString(10);
9121eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump          Diag(OverlapStmt->getLHS()->getLocStart(),
913dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor               diag::note_duplicate_case_prev);
914390b4cc8b45a05612349269ef08faab3e4688f06Mike Stump          // FIXME: We really want to remove the bogus case stmt from the
915390b4cc8b45a05612349269ef08faab3e4688f06Mike Stump          // substmt, but we have no way to do this right now.
916dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor          CaseListIsErroneous = true;
917dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor        }
9180471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner      }
919b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner    }
920ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor
9210fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall    // Complain if we have a constant condition and we didn't find a match.
9220fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall    if (!CaseListIsErroneous && ShouldCheckConstantCond) {
9230fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall      // TODO: it would be nice if we printed enums as enums, chars as
9240fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall      // chars, etc.
9250fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall      Diag(CondExpr->getExprLoc(), diag::warn_missing_case_for_condition)
9260fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall        << ConstantCondValue.toString(10)
9270fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall        << CondExpr->getSourceRange();
9280fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall    }
9290fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall
9300fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall    // Check to see if switch is over an Enum and handles all of its
931559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek    // values.  We only issue a warning if there is not 'default:', but
932559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek    // we still do the analysis to preserve this information in the AST
933559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek    // (which can be used by flow-based analyes).
9340fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall    //
935ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner    const EnumType *ET = CondTypeBeforePromotion->getAs<EnumType>();
936559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek
937ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor    // If switch has default case, then ignore it.
938559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek    if (!CaseListIsErroneous  && !HasConstantCond && ET) {
939ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor      const EnumDecl *ED = ET->getDecl();
9405f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner      typedef SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64>
94158f14c012e5d739b09532bb12645dc161f88cfcfFrancois Pichet        EnumValsTy;
942ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor      EnumValsTy EnumVals;
943ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor
9440fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall      // Gather all enum values, set their type and sort them,
9450fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall      // allowing easier comparison with CaseVals.
9460fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall      for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin();
94728164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif           EDI != ED->enumerator_end(); ++EDI) {
94828164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif        llvm::APSInt Val = EDI->getInitVal();
94928164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif        AdjustAPSInt(Val, CondWidth, CondIsSigned);
950581deb3da481053c4993c7600f97acf7768caac5David Blaikie        EnumVals.push_back(std::make_pair(Val, *EDI));
951ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor      }
952ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor      std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals);
9530fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall      EnumValsTy::iterator EIend =
9540fb97083cc0f8a82e404e22991ae80d2216e71d5John McCall        std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
955559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek
956559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek      // See which case values aren't in enum.
9579366750a5a97c8aeae1df4898ea849b087865195David Blaikie      EnumValsTy::const_iterator EI = EnumVals.begin();
9589366750a5a97c8aeae1df4898ea849b087865195David Blaikie      for (CaseValsTy::const_iterator CI = CaseVals.begin();
9599366750a5a97c8aeae1df4898ea849b087865195David Blaikie           CI != CaseVals.end(); CI++) {
9609366750a5a97c8aeae1df4898ea849b087865195David Blaikie        while (EI != EIend && EI->first < CI->first)
9619366750a5a97c8aeae1df4898ea849b087865195David Blaikie          EI++;
9629366750a5a97c8aeae1df4898ea849b087865195David Blaikie        if (EI == EIend || EI->first > CI->first)
9639366750a5a97c8aeae1df4898ea849b087865195David Blaikie          Diag(CI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
96454faba4f7f3f0e8f1376da1c459312596ad5486dFariborz Jahanian            << CondTypeBeforePromotion;
9659366750a5a97c8aeae1df4898ea849b087865195David Blaikie      }
9669366750a5a97c8aeae1df4898ea849b087865195David Blaikie      // See which of case ranges aren't in enum
9679366750a5a97c8aeae1df4898ea849b087865195David Blaikie      EI = EnumVals.begin();
9689366750a5a97c8aeae1df4898ea849b087865195David Blaikie      for (CaseRangesTy::const_iterator RI = CaseRanges.begin();
9699366750a5a97c8aeae1df4898ea849b087865195David Blaikie           RI != CaseRanges.end() && EI != EIend; RI++) {
9709366750a5a97c8aeae1df4898ea849b087865195David Blaikie        while (EI != EIend && EI->first < RI->first)
9719366750a5a97c8aeae1df4898ea849b087865195David Blaikie          EI++;
9729366750a5a97c8aeae1df4898ea849b087865195David Blaikie
9739366750a5a97c8aeae1df4898ea849b087865195David Blaikie        if (EI == EIend || EI->first != RI->first) {
9749366750a5a97c8aeae1df4898ea849b087865195David Blaikie          Diag(RI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
97554faba4f7f3f0e8f1376da1c459312596ad5486dFariborz Jahanian            << CondTypeBeforePromotion;
97647bb27f16882e4f5ababdd0cf6642bb904a9aaf8Ted Kremenek        }
977e0ba9d1beeba01a96808c2fc61f9ca89acec313bTed Kremenek
9789366750a5a97c8aeae1df4898ea849b087865195David Blaikie        llvm::APSInt Hi =
9799366750a5a97c8aeae1df4898ea849b087865195David Blaikie          RI->second->getRHS()->EvaluateKnownConstInt(Context);
9809366750a5a97c8aeae1df4898ea849b087865195David Blaikie        AdjustAPSInt(Hi, CondWidth, CondIsSigned);
9819366750a5a97c8aeae1df4898ea849b087865195David Blaikie        while (EI != EIend && EI->first < Hi)
9829366750a5a97c8aeae1df4898ea849b087865195David Blaikie          EI++;
9839366750a5a97c8aeae1df4898ea849b087865195David Blaikie        if (EI == EIend || EI->first != Hi)
9849366750a5a97c8aeae1df4898ea849b087865195David Blaikie          Diag(RI->second->getRHS()->getExprLoc(), diag::warn_not_in_enum)
98554faba4f7f3f0e8f1376da1c459312596ad5486dFariborz Jahanian            << CondTypeBeforePromotion;
986ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor      }
987dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
988559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek      // Check which enum vals aren't in switch
989ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor      CaseValsTy::const_iterator CI = CaseVals.begin();
990ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor      CaseRangesTy::const_iterator RI = CaseRanges.begin();
991559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek      bool hasCasesNotInSwitch = false;
992559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek
9935f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner      SmallVector<DeclarationName,8> UnhandledNames;
994dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
9959366750a5a97c8aeae1df4898ea849b087865195David Blaikie      for (EI = EnumVals.begin(); EI != EIend; EI++){
996ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner        // Drop unneeded case values
997ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor        llvm::APSInt CIVal;
998ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor        while (CI != CaseVals.end() && CI->first < EI->first)
999ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor          CI++;
1000dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
1001ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor        if (CI != CaseVals.end() && CI->first == EI->first)
1002ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor          continue;
1003ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor
1004559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek        // Drop unneeded case ranges
1005ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor        for (; RI != CaseRanges.end(); RI++) {
1006a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith          llvm::APSInt Hi =
1007a6b8b2c09610b8bc4330e948ece8b940c2386406Richard Smith            RI->second->getRHS()->EvaluateKnownConstInt(Context);
100828164ab2ac1deea68cdb989f941728bf1860ce41Gabor Greif          AdjustAPSInt(Hi, CondWidth, CondIsSigned);
1009ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor          if (EI->first <= Hi)
1010ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor            break;
1011ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor        }
1012ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor
1013559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek        if (RI == CaseRanges.end() || EI->first < RI->first) {
101447bb27f16882e4f5ababdd0cf6642bb904a9aaf8Ted Kremenek          hasCasesNotInSwitch = true;
101531ceb61172bca7ebc3fb90e9125864c7a29c55c0David Blaikie          UnhandledNames.push_back(EI->second->getDeclName());
101647bb27f16882e4f5ababdd0cf6642bb904a9aaf8Ted Kremenek        }
1017ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor      }
1018dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
1019585d7795c2dddaa510b3bb1b3b18633bfcfdf643David Blaikie      if (TheDefaultStmt && UnhandledNames.empty())
1020585d7795c2dddaa510b3bb1b3b18633bfcfdf643David Blaikie        Diag(TheDefaultStmt->getDefaultLoc(), diag::warn_unreachable_default);
102131ceb61172bca7ebc3fb90e9125864c7a29c55c0David Blaikie
1022ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner      // Produce a nice diagnostic if multiple values aren't handled.
1023ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner      switch (UnhandledNames.size()) {
1024ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner      case 0: break;
1025ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner      case 1:
1026585d7795c2dddaa510b3bb1b3b18633bfcfdf643David Blaikie        Diag(CondExpr->getExprLoc(), TheDefaultStmt
1027585d7795c2dddaa510b3bb1b3b18633bfcfdf643David Blaikie          ? diag::warn_def_missing_case1 : diag::warn_missing_case1)
1028ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner          << UnhandledNames[0];
1029ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner        break;
1030ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner      case 2:
1031585d7795c2dddaa510b3bb1b3b18633bfcfdf643David Blaikie        Diag(CondExpr->getExprLoc(), TheDefaultStmt
1032585d7795c2dddaa510b3bb1b3b18633bfcfdf643David Blaikie          ? diag::warn_def_missing_case2 : diag::warn_missing_case2)
1033ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner          << UnhandledNames[0] << UnhandledNames[1];
1034ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner        break;
1035ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner      case 3:
1036585d7795c2dddaa510b3bb1b3b18633bfcfdf643David Blaikie        Diag(CondExpr->getExprLoc(), TheDefaultStmt
1037585d7795c2dddaa510b3bb1b3b18633bfcfdf643David Blaikie          ? diag::warn_def_missing_case3 : diag::warn_missing_case3)
1038ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner          << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
1039ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner        break;
1040ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner      default:
1041585d7795c2dddaa510b3bb1b3b18633bfcfdf643David Blaikie        Diag(CondExpr->getExprLoc(), TheDefaultStmt
1042585d7795c2dddaa510b3bb1b3b18633bfcfdf643David Blaikie          ? diag::warn_def_missing_cases : diag::warn_missing_cases)
1043ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner          << (unsigned)UnhandledNames.size()
1044ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner          << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
1045ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner        break;
1046ce78461303f45fecb3460d1c49c9b71f27ad19c3Chris Lattner      }
1047559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek
1048559fb554602bedb57dbbf3cc14ac8a38264b4547Ted Kremenek      if (!hasCasesNotInSwitch)
104947bb27f16882e4f5ababdd0cf6642bb904a9aaf8Ted Kremenek        SS->setAllEnumCasesCovered();
1050ba915af51ced751c46e7c2b9c6f3b59d2e668825Douglas Gregor    }
1051b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner  }
1052dbb26db1d426fb6caaaf1b4fa47b46d1947c12c9Douglas Gregor
1053625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  DiagnoseEmptyStmtBody(CondExpr->getLocEnd(), BodyStmt,
1054625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko                        diag::warn_empty_switch_body);
1055625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko
1056390b4cc8b45a05612349269ef08faab3e4688f06Mike Stump  // FIXME: If the case list was broken is some way, we don't have a good system
1057390b4cc8b45a05612349269ef08faab3e4688f06Mike Stump  // to patch it up.  Instead, just return the whole substmt as broken.
1058b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner  if (CaseListIsErroneous)
1059de307473448fb3cebcb4c10090728300b53bca03Sebastian Redl    return StmtError();
1060de307473448fb3cebcb4c10090728300b53bca03Sebastian Redl
1061de307473448fb3cebcb4c10090728300b53bca03Sebastian Redl  return Owned(SS);
10625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
10635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
106460d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
1065dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA TakumiSema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond,
10669ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                     Decl *CondVar, Stmt *Body) {
106760d7b3a319d84d688752be3870615ac0f111fb16John McCall  ExprResult CondResult(Cond.release());
1068dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
10695656e14d91405417182171a705ed3e3d2d6d7aa3Douglas Gregor  VarDecl *ConditionVar = 0;
1070d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall  if (CondVar) {
1071d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall    ConditionVar = cast<VarDecl>(CondVar);
1072586596fd7f7a336a2847b300c80614dcf39ab6d5Douglas Gregor    CondResult = CheckConditionVariable(ConditionVar, WhileLoc, true);
107399e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor    if (CondResult.isInvalid())
107499e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor      return StmtError();
10755656e14d91405417182171a705ed3e3d2d6d7aa3Douglas Gregor  }
10769ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  Expr *ConditionExpr = CondResult.take();
107799e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor  if (!ConditionExpr)
107899e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor    return StmtError();
1079dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
10809ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  DiagnoseUnusedExprResult(Body);
10811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
1082625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  if (isa<NullStmt>(Body))
1083625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko    getCurCompoundScope().setHasEmptyLoopBodies();
1084625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko
108543dec6bbde2d0a16c35978983761c8b7030c8e18Douglas Gregor  return Owned(new (Context) WhileStmt(Context, ConditionVar, ConditionExpr,
10869ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                                       Body, WhileLoc));
10875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
10885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
108960d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
10909ae2f076ca5ab1feb3ba95629099ec2319833701John McCallSema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
1091989135901c750af61ef012b6b0a0368be415bc46Chris Lattner                  SourceLocation WhileLoc, SourceLocation CondLParen,
10929ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                  Expr *Cond, SourceLocation CondRParen) {
10939ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  assert(Cond && "ActOnDoStmt(): missing expression");
1094f05b1520d6f175acbfc3913489f4dfa842875ec4Sebastian Redl
1095429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley  ExprResult CondResult = CheckBooleanCondition(Cond, DoLoc);
1096429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley  if (CondResult.isInvalid() || CondResult.isInvalid())
10975a881bb09928b7ade891efc680088aaad276f8d6John McCall    return StmtError();
1098429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley  Cond = CondResult.take();
10995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
1100b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall  CheckImplicitConversions(Cond, DoLoc);
1101429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley  CondResult = MaybeCreateExprWithCleanups(Cond);
11029ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  if (CondResult.isInvalid())
1103586596fd7f7a336a2847b300c80614dcf39ab6d5Douglas Gregor    return StmtError();
11049ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  Cond = CondResult.take();
1105dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
11069ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  DiagnoseUnusedExprResult(Body);
1107754431107b61a0523df5271c2876a73dd5a051e9Anders Carlsson
11089ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  return Owned(new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen));
11095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
11105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
1111694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieunamespace {
1112694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  // This visitor will traverse a conditional statement and store all
1113694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  // the evaluated decls into a vector.  Simple is set to true if none
1114694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  // of the excluded constructs are used.
1115694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  class DeclExtractor : public EvaluatedExprVisitor<DeclExtractor> {
1116694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    llvm::SmallPtrSet<VarDecl*, 8> &Decls;
1117694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    llvm::SmallVector<SourceRange, 10> &Ranges;
1118694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    bool Simple;
1119694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieupublic:
1120694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  typedef EvaluatedExprVisitor<DeclExtractor> Inherited;
1121694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1122694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  DeclExtractor(Sema &S, llvm::SmallPtrSet<VarDecl*, 8> &Decls,
1123facde171ae4b8926622a1bffa833732a06f1875bBenjamin Kramer                llvm::SmallVector<SourceRange, 10> &Ranges) :
1124694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      Inherited(S.Context),
1125694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      Decls(Decls),
1126694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      Ranges(Ranges),
1127facde171ae4b8926622a1bffa833732a06f1875bBenjamin Kramer      Simple(true) {}
1128694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1129694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  bool isSimple() { return Simple; }
1130694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1131694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  // Replaces the method in EvaluatedExprVisitor.
1132694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitMemberExpr(MemberExpr* E) {
1133694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Simple = false;
1134694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1135694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1136694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  // Any Stmt not whitelisted will cause the condition to be marked complex.
1137694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitStmt(Stmt *S) {
1138694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Simple = false;
1139694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1140694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1141694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitBinaryOperator(BinaryOperator *E) {
1142694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Visit(E->getLHS());
1143694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Visit(E->getRHS());
1144694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1145694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1146694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitCastExpr(CastExpr *E) {
1147694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Visit(E->getSubExpr());
1148694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1149694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1150694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitUnaryOperator(UnaryOperator *E) {
1151694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    // Skip checking conditionals with derefernces.
1152694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (E->getOpcode() == UO_Deref)
1153694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      Simple = false;
1154694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    else
1155694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      Visit(E->getSubExpr());
1156694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1157694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1158694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitConditionalOperator(ConditionalOperator *E) {
1159694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Visit(E->getCond());
1160694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Visit(E->getTrueExpr());
1161694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Visit(E->getFalseExpr());
1162694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1163694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1164694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitParenExpr(ParenExpr *E) {
1165694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Visit(E->getSubExpr());
1166694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1167694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1168694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1169694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Visit(E->getOpaqueValue()->getSourceExpr());
1170694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Visit(E->getFalseExpr());
1171694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1172694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1173694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitIntegerLiteral(IntegerLiteral *E) { }
1174694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitFloatingLiteral(FloatingLiteral *E) { }
1175694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { }
1176694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitCharacterLiteral(CharacterLiteral *E) { }
1177694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitGNUNullExpr(GNUNullExpr *E) { }
1178694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitImaginaryLiteral(ImaginaryLiteral *E) { }
1179694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1180694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitDeclRefExpr(DeclRefExpr *E) {
1181694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    VarDecl *VD = dyn_cast<VarDecl>(E->getDecl());
1182694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (!VD) return;
1183694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1184694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Ranges.push_back(E->getSourceRange());
1185694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1186694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Decls.insert(VD);
1187694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1188694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1189694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }; // end class DeclExtractor
1190694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1191694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  // DeclMatcher checks to see if the decls are used in a non-evauluated
1192694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  // context.
1193694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  class DeclMatcher : public EvaluatedExprVisitor<DeclMatcher> {
1194694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    llvm::SmallPtrSet<VarDecl*, 8> &Decls;
1195694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    bool FoundDecl;
1196694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1197694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieupublic:
1198694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  typedef EvaluatedExprVisitor<DeclMatcher> Inherited;
1199694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1200694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  DeclMatcher(Sema &S, llvm::SmallPtrSet<VarDecl*, 8> &Decls, Stmt *Statement) :
1201694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      Inherited(S.Context), Decls(Decls), FoundDecl(false) {
1202694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (!Statement) return;
1203694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1204694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Visit(Statement);
1205694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1206694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1207694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitReturnStmt(ReturnStmt *S) {
1208694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    FoundDecl = true;
1209694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1210694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1211694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitBreakStmt(BreakStmt *S) {
1212694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    FoundDecl = true;
1213694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1214694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1215694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitGotoStmt(GotoStmt *S) {
1216694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    FoundDecl = true;
1217694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1218694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1219694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitCastExpr(CastExpr *E) {
1220694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (E->getCastKind() == CK_LValueToRValue)
1221694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      CheckLValueToRValueCast(E->getSubExpr());
1222694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    else
1223694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      Visit(E->getSubExpr());
1224694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1225694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1226694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void CheckLValueToRValueCast(Expr *E) {
1227694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    E = E->IgnoreParenImpCasts();
1228694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1229694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (isa<DeclRefExpr>(E)) {
1230694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      return;
1231694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    }
1232694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1233694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
1234694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      Visit(CO->getCond());
1235694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      CheckLValueToRValueCast(CO->getTrueExpr());
1236694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      CheckLValueToRValueCast(CO->getFalseExpr());
1237694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      return;
1238694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    }
1239694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1240694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (BinaryConditionalOperator *BCO =
1241694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu            dyn_cast<BinaryConditionalOperator>(E)) {
1242694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      CheckLValueToRValueCast(BCO->getOpaqueValue()->getSourceExpr());
1243694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      CheckLValueToRValueCast(BCO->getFalseExpr());
1244694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      return;
1245694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    }
1246694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1247694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    Visit(E);
1248694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1249694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1250694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void VisitDeclRefExpr(DeclRefExpr *E) {
1251694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
1252694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      if (Decls.count(VD))
1253694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu        FoundDecl = true;
1254694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1255694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1256694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  bool FoundDeclInUse() { return FoundDecl; }
1257694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1258694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  };  // end class DeclMatcher
1259694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1260694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  void CheckForLoopConditionalStatement(Sema &S, Expr *Second,
1261694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu                                        Expr *Third, Stmt *Body) {
1262694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    // Condition is empty
1263694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (!Second) return;
1264694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1265694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (S.Diags.getDiagnosticLevel(diag::warn_variables_not_in_loop_body,
1266694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu                                   Second->getLocStart())
1267694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu        == DiagnosticsEngine::Ignored)
1268694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      return;
1269694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1270694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    PartialDiagnostic PDiag = S.PDiag(diag::warn_variables_not_in_loop_body);
1271694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    llvm::SmallPtrSet<VarDecl*, 8> Decls;
1272694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    llvm::SmallVector<SourceRange, 10> Ranges;
1273facde171ae4b8926622a1bffa833732a06f1875bBenjamin Kramer    DeclExtractor DE(S, Decls, Ranges);
1274694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    DE.Visit(Second);
1275694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1276694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    // Don't analyze complex conditionals.
1277694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (!DE.isSimple()) return;
1278694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1279694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    // No decls found.
1280694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (Decls.size() == 0) return;
1281694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
12829087599e5ee64ecd30194b3d89f8748ac95c62f7Richard Trieu    // Don't warn on volatile, static, or global variables.
1283694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    for (llvm::SmallPtrSet<VarDecl*, 8>::iterator I = Decls.begin(),
1284694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu                                                  E = Decls.end();
1285694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu         I != E; ++I)
12869087599e5ee64ecd30194b3d89f8748ac95c62f7Richard Trieu      if ((*I)->getType().isVolatileQualified() ||
12879087599e5ee64ecd30194b3d89f8748ac95c62f7Richard Trieu          (*I)->hasGlobalStorage()) return;
1288694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1289694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (DeclMatcher(S, Decls, Second).FoundDeclInUse() ||
1290694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu        DeclMatcher(S, Decls, Third).FoundDeclInUse() ||
1291694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu        DeclMatcher(S, Decls, Body).FoundDeclInUse())
1292694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      return;
1293694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1294694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    // Load decl names into diagnostic.
1295694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (Decls.size() > 4)
1296694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      PDiag << 0;
1297694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    else {
1298694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      PDiag << Decls.size();
1299694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      for (llvm::SmallPtrSet<VarDecl*, 8>::iterator I = Decls.begin(),
1300694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu                                                    E = Decls.end();
1301694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu           I != E; ++I)
1302694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu        PDiag << (*I)->getDeclName();
1303694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    }
1304694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1305694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    // Load SourceRanges into diagnostic if there is room.
1306694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    // Otherwise, load the SourceRange of the conditional expression.
1307694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    if (Ranges.size() <= PartialDiagnostic::MaxArguments)
1308694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      for (llvm::SmallVector<SourceRange, 10>::iterator I = Ranges.begin(),
1309694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu                                                        E = Ranges.end();
1310694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu           I != E; ++I)
1311694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu        PDiag << *I;
1312694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    else
1313694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu      PDiag << Second->getSourceRange();
1314694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1315694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu    S.Diag(Ranges.begin()->getBegin(), PDiag);
1316694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  }
1317694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
1318694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu} // end namespace
1319694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
132060d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
1321f05b1520d6f175acbfc3913489f4dfa842875ec4Sebastian RedlSema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
13229ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                   Stmt *First, FullExprArg second, Decl *secondVar,
132399e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor                   FullExprArg third,
13249ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                   SourceLocation RParenLoc, Stmt *Body) {
13254e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie  if (!getLangOpts().CPlusPlus) {
13265921093cf1c2e9a8bd1a22b6f612e551bae7476bArgyrios Kyrtzidis    if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) {
1327f3a41af4d5c98a72a1d6720bbbfd658e57ef2541Chris Lattner      // C99 6.8.5p3: The declaration part of a 'for' statement shall only
1328f3a41af4d5c98a72a1d6720bbbfd658e57ef2541Chris Lattner      // declare identifiers for objects having storage class 'auto' or
1329f3a41af4d5c98a72a1d6720bbbfd658e57ef2541Chris Lattner      // 'register'.
13305921093cf1c2e9a8bd1a22b6f612e551bae7476bArgyrios Kyrtzidis      for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end();
13315921093cf1c2e9a8bd1a22b6f612e551bae7476bArgyrios Kyrtzidis           DI!=DE; ++DI) {
13325921093cf1c2e9a8bd1a22b6f612e551bae7476bArgyrios Kyrtzidis        VarDecl *VD = dyn_cast<VarDecl>(*DI);
1333b6bbcc9995186799a60ce17d0c1acff31601653aJohn McCall        if (VD && VD->isLocalVarDecl() && !VD->hasLocalStorage())
13345921093cf1c2e9a8bd1a22b6f612e551bae7476bArgyrios Kyrtzidis          VD = 0;
13355921093cf1c2e9a8bd1a22b6f612e551bae7476bArgyrios Kyrtzidis        if (VD == 0)
13365921093cf1c2e9a8bd1a22b6f612e551bae7476bArgyrios Kyrtzidis          Diag((*DI)->getLocation(), diag::err_non_variable_decl_in_for);
13375921093cf1c2e9a8bd1a22b6f612e551bae7476bArgyrios Kyrtzidis        // FIXME: mark decl erroneous!
13385921093cf1c2e9a8bd1a22b6f612e551bae7476bArgyrios Kyrtzidis      }
1339ae3b701f59e78e058b83344be17206af3bf5d277Chris Lattner    }
13405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer  }
134199e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor
1342694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu  CheckForLoopConditionalStatement(*this, second.get(), third.get(), Body);
1343694e796f462748ab4dc7ecdf4be5da44dd2c8c94Richard Trieu
134460d7b3a319d84d688752be3870615ac0f111fb16John McCall  ExprResult SecondResult(second.release());
134599e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor  VarDecl *ConditionVar = 0;
1346d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall  if (secondVar) {
1347d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall    ConditionVar = cast<VarDecl>(secondVar);
1348586596fd7f7a336a2847b300c80614dcf39ab6d5Douglas Gregor    SecondResult = CheckConditionVariable(ConditionVar, ForLoc, true);
134999e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor    if (SecondResult.isInvalid())
135099e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor      return StmtError();
135199e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor  }
1352dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
135399e9b4d172f6877e6ba5ebe75bb8238721f5e01cDouglas Gregor  Expr *Third  = third.release().takeAs<Expr>();
1354dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
13553af708ff19e4ae2bf9e40550548361b00e5916bfAnders Carlsson  DiagnoseUnusedExprResult(First);
13563af708ff19e4ae2bf9e40550548361b00e5916bfAnders Carlsson  DiagnoseUnusedExprResult(Third);
1357754431107b61a0523df5271c2876a73dd5a051e9Anders Carlsson  DiagnoseUnusedExprResult(Body);
1358754431107b61a0523df5271c2876a73dd5a051e9Anders Carlsson
1359625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  if (isa<NullStmt>(Body))
1360625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko    getCurCompoundScope().setHasEmptyLoopBodies();
1361625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko
1362dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi  return Owned(new (Context) ForStmt(Context, First,
1363dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi                                     SecondResult.take(), ConditionVar,
1364dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi                                     Third, Body, ForLoc, LParenLoc,
136543dec6bbde2d0a16c35978983761c8b7030c8e18Douglas Gregor                                     RParenLoc));
13665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
13675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
1368f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall/// In an Objective C collection iteration statement:
1369f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall///   for (x in y)
1370f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall/// x can be an arbitrary l-value expression.  Bind it up as a
1371f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall/// full-expression.
1372f6a1648197562e0b133440d612d9af297d0a86ccJohn McCallStmtResult Sema::ActOnForEachLValueExpr(Expr *E) {
137329bbd1a33edfd3c81c35d5076530c2867a05bddcJohn McCall  // Reduce placeholder expressions here.  Note that this rejects the
137429bbd1a33edfd3c81c35d5076530c2867a05bddcJohn McCall  // use of pseudo-object l-values in this position.
137529bbd1a33edfd3c81c35d5076530c2867a05bddcJohn McCall  ExprResult result = CheckPlaceholderExpr(E);
137629bbd1a33edfd3c81c35d5076530c2867a05bddcJohn McCall  if (result.isInvalid()) return StmtError();
137729bbd1a33edfd3c81c35d5076530c2867a05bddcJohn McCall  E = result.take();
137829bbd1a33edfd3c81c35d5076530c2867a05bddcJohn McCall
1379f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall  CheckImplicitConversions(E);
138029bbd1a33edfd3c81c35d5076530c2867a05bddcJohn McCall
138129bbd1a33edfd3c81c35d5076530c2867a05bddcJohn McCall  result = MaybeCreateExprWithCleanups(E);
138229bbd1a33edfd3c81c35d5076530c2867a05bddcJohn McCall  if (result.isInvalid()) return StmtError();
138329bbd1a33edfd3c81c35d5076530c2867a05bddcJohn McCall
138429bbd1a33edfd3c81c35d5076530c2867a05bddcJohn McCall  return Owned(static_cast<Stmt*>(result.take()));
1385f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall}
1386f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall
1387990567cb60e8530ba01b41d4e056e32b44b95ec0John McCallExprResult
1388a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz JahanianSema::CheckObjCForCollectionOperand(SourceLocation forLoc, Expr *collection) {
1389a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian  if (!collection)
1390a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian    return ExprError();
1391a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian
1392990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  // Bail out early if we've got a type-dependent expression.
1393990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  if (collection->isTypeDependent()) return Owned(collection);
1394990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall
1395990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  // Perform normal l-value conversion.
1396990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  ExprResult result = DefaultFunctionArrayLvalueConversion(collection);
1397990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  if (result.isInvalid())
1398990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    return ExprError();
1399990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  collection = result.take();
1400990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall
1401990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  // The operand needs to have object-pointer type.
1402990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  // TODO: should we do a contextual conversion?
1403990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  const ObjCObjectPointerType *pointerType =
1404990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    collection->getType()->getAs<ObjCObjectPointerType>();
1405990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  if (!pointerType)
1406990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    return Diag(forLoc, diag::err_collection_expr_type)
1407990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall             << collection->getType() << collection->getSourceRange();
1408990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall
1409990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  // Check that the operand provides
1410990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  //   - countByEnumeratingWithState:objects:count:
1411990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  const ObjCObjectType *objectType = pointerType->getObjectType();
1412990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  ObjCInterfaceDecl *iface = objectType->getInterface();
1413990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall
1414990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  // If we have a forward-declared type, we can't do this check.
1415b3029960632ca8a3248e74770eda64d6c16f7246Douglas Gregor  // Under ARC, it is an error not to have a forward-declared class.
1416b3029960632ca8a3248e74770eda64d6c16f7246Douglas Gregor  if (iface &&
1417b3029960632ca8a3248e74770eda64d6c16f7246Douglas Gregor      RequireCompleteType(forLoc, QualType(objectType, 0),
14184e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie                          getLangOpts().ObjCAutoRefCount
1419d10099e5c8238fa0327f03921cf2e3c8975c881eDouglas Gregor                            ? diag::err_arc_collection_forward
1420d10099e5c8238fa0327f03921cf2e3c8975c881eDouglas Gregor                            : 0,
1421d10099e5c8238fa0327f03921cf2e3c8975c881eDouglas Gregor                          collection)) {
1422990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    // Otherwise, if we have any useful type information, check that
1423990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    // the type declares the appropriate method.
1424990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  } else if (iface || !objectType->qual_empty()) {
1425990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    IdentifierInfo *selectorIdents[] = {
1426990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall      &Context.Idents.get("countByEnumeratingWithState"),
1427990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall      &Context.Idents.get("objects"),
1428990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall      &Context.Idents.get("count")
1429990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    };
1430990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    Selector selector = Context.Selectors.getSelector(3, &selectorIdents[0]);
1431990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall
1432990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    ObjCMethodDecl *method = 0;
1433990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall
1434990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    // If there's an interface, look in both the public and private APIs.
1435990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    if (iface) {
1436990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall      method = iface->lookupInstanceMethod(selector);
1437990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall      if (!method) method = LookupPrivateInstanceMethod(selector, iface);
1438990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    }
1439990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall
1440990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    // Also check protocol qualifiers.
1441990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    if (!method)
1442990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall      method = LookupMethodInQualifiedType(selector, pointerType,
1443990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall                                           /*instance*/ true);
1444990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall
1445990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    // If we didn't find it anywhere, give up.
1446990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    if (!method) {
1447990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall      Diag(forLoc, diag::warn_collection_expr_type)
1448990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall        << collection->getType() << selector << collection->getSourceRange();
1449990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    }
1450990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall
1451990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall    // TODO: check for an incompatible signature?
1452990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  }
1453990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall
1454990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  // Wrap up any cleanups in the expression.
1455990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall  return Owned(MaybeCreateExprWithCleanups(collection));
1456990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall}
1457990567cb60e8530ba01b41d4e056e32b44b95ec0John McCall
145860d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
1459f05b1520d6f175acbfc3913489f4dfa842875ec4Sebastian RedlSema::ActOnObjCForCollectionStmt(SourceLocation ForLoc,
1460f05b1520d6f175acbfc3913489f4dfa842875ec4Sebastian Redl                                 SourceLocation LParenLoc,
1461a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian                                 Stmt *First, Expr *collection,
1462a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian                                 SourceLocation RParenLoc) {
1463a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian
1464a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian  ExprResult CollectionExprResult =
1465a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian    CheckObjCForCollectionOperand(ForLoc, collection);
1466a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian
146720552d2842245692b649e0d25380670922f954a2Fariborz Jahanian  if (First) {
146820552d2842245692b649e0d25380670922f954a2Fariborz Jahanian    QualType FirstType;
146920552d2842245692b649e0d25380670922f954a2Fariborz Jahanian    if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) {
14707e24e82a70a2c681f4291a3397bcd1e1005f251aChris Lattner      if (!DS->isSingleDecl())
1471f05b1520d6f175acbfc3913489f4dfa842875ec4Sebastian Redl        return StmtError(Diag((*DS->decl_begin())->getLocation(),
1472f05b1520d6f175acbfc3913489f4dfa842875ec4Sebastian Redl                         diag::err_toomany_element_decls));
1473f05b1520d6f175acbfc3913489f4dfa842875ec4Sebastian Redl
1474f85e193739c953358c865005855253af4f68a497John McCall      VarDecl *D = cast<VarDecl>(DS->getSingleDecl());
1475f85e193739c953358c865005855253af4f68a497John McCall      FirstType = D->getType();
1476f3a41af4d5c98a72a1d6720bbbfd658e57ef2541Chris Lattner      // C99 6.8.5p3: The declaration part of a 'for' statement shall only
1477f3a41af4d5c98a72a1d6720bbbfd658e57ef2541Chris Lattner      // declare identifiers for objects having storage class 'auto' or
1478f3a41af4d5c98a72a1d6720bbbfd658e57ef2541Chris Lattner      // 'register'.
1479f85e193739c953358c865005855253af4f68a497John McCall      if (!D->hasLocalStorage())
1480f85e193739c953358c865005855253af4f68a497John McCall        return StmtError(Diag(D->getLocation(),
1481f05b1520d6f175acbfc3913489f4dfa842875ec4Sebastian Redl                              diag::err_non_variable_decl_in_for));
14821fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson    } else {
1483c3203e7ee1464a096f341c2e2a83a10be2da000aDouglas Gregor      Expr *FirstE = cast<Expr>(First);
14847eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall      if (!FirstE->isTypeDependent() && !FirstE->isLValue())
1485f05b1520d6f175acbfc3913489f4dfa842875ec4Sebastian Redl        return StmtError(Diag(First->getLocStart(),
1486f05b1520d6f175acbfc3913489f4dfa842875ec4Sebastian Redl                   diag::err_selector_element_not_lvalue)
1487f05b1520d6f175acbfc3913489f4dfa842875ec4Sebastian Redl          << First->getSourceRange());
14881fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson
14891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump      FirstType = static_cast<Expr*>(First)->getType();
14901fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson    }
1491c3203e7ee1464a096f341c2e2a83a10be2da000aDouglas Gregor    if (!FirstType->isDependentType() &&
1492c3203e7ee1464a096f341c2e2a83a10be2da000aDouglas Gregor        !FirstType->isObjCObjectPointerType() &&
1493a5e42a82ce055f29f3733f3a1f10da6cb9877deeFariborz Jahanian        !FirstType->isBlockPointerType())
1494a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian        return StmtError(Diag(ForLoc, diag::err_selector_element_type)
1495a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian                           << FirstType << First->getSourceRange());
14963ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian  }
1497a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian
1498a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian  if (CollectionExprResult.isInvalid())
1499a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian    return StmtError();
1500a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian
1501a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian  return Owned(new (Context) ObjCForCollectionStmt(First,
1502a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian                                                   CollectionExprResult.take(), 0,
15038189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek                                                   ForLoc, RParenLoc));
15043ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian}
15055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
1506ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smithnamespace {
1507ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1508ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smithenum BeginEndFunction {
1509ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  BEF_begin,
1510ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  BEF_end
1511ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith};
1512ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1513ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// Build a variable declaration for a for-range statement.
1514ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smithstatic VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc,
1515ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                     QualType Type, const char *Name) {
1516ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  DeclContext *DC = SemaRef.CurContext;
1517ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
1518ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
1519ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type,
1520ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                  TInfo, SC_Auto, SC_None);
1521b403d6d746239095a2c7bac958c924d92434e2b4Richard Smith  Decl->setImplicit();
1522ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  return Decl;
1523ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith}
1524ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1525ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// Finish building a variable declaration for a for-range statement.
1526ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// \return true if an error occurs.
1527ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smithstatic bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init,
1528ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                  SourceLocation Loc, int diag) {
1529ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  // Deduce the type for the iterator variable now rather than leaving it to
1530ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  // AddInitializerToDecl, so we can produce a more suitable diagnostic.
1531ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  TypeSourceInfo *InitTSI = 0;
153262b7cfb73e202051e7ab0dad42ba213acd0dec7eSebastian Redl  if ((!isa<InitListExpr>(Init) && Init->getType()->isVoidType()) ||
1533b832f6dea893f25b40500a04781286236281cb20Sebastian Redl      SemaRef.DeduceAutoType(Decl->getTypeSourceInfo(), Init, InitTSI) ==
1534b832f6dea893f25b40500a04781286236281cb20Sebastian Redl          Sema::DAR_Failed)
1535ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    SemaRef.Diag(Loc, diag) << Init->getType();
1536ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (!InitTSI) {
1537ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    Decl->setInvalidDecl();
1538ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    return true;
1539ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  }
1540ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  Decl->setTypeSourceInfo(InitTSI);
1541ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  Decl->setType(InitTSI->getType());
1542ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1543f85e193739c953358c865005855253af4f68a497John McCall  // In ARC, infer lifetime.
1544f85e193739c953358c865005855253af4f68a497John McCall  // FIXME: ARC may want to turn this into 'const __unsafe_unretained' if
1545f85e193739c953358c865005855253af4f68a497John McCall  // we're doing the equivalent of fast iteration.
15464e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie  if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1547f85e193739c953358c865005855253af4f68a497John McCall      SemaRef.inferObjCARCLifetime(Decl))
1548f85e193739c953358c865005855253af4f68a497John McCall    Decl->setInvalidDecl();
1549f85e193739c953358c865005855253af4f68a497John McCall
1550ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  SemaRef.AddInitializerToDecl(Decl, Init, /*DirectInit=*/false,
1551ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                               /*TypeMayContainAuto=*/false);
1552ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  SemaRef.FinalizeDeclaration(Decl);
1553b403d6d746239095a2c7bac958c924d92434e2b4Richard Smith  SemaRef.CurContext->addHiddenDecl(Decl);
1554ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  return false;
1555ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith}
1556ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1557ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// Produce a note indicating which begin/end function was implicitly called
1558ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// by a C++0x for-range statement. This is often not obvious from the code,
1559ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// nor from the diagnostics produced when analysing the implicit expressions
1560ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// required in a for-range statement.
1561ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smithvoid NoteForRangeBeginEndFunction(Sema &SemaRef, Expr *E,
1562ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                  BeginEndFunction BEF) {
1563ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  CallExpr *CE = dyn_cast<CallExpr>(E);
1564ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (!CE)
1565ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    return;
1566ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  FunctionDecl *D = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
1567ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (!D)
1568ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    return;
1569ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  SourceLocation Loc = D->getLocation();
1570ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1571ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  std::string Description;
1572ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  bool IsTemplate = false;
1573ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (FunctionTemplateDecl *FunTmpl = D->getPrimaryTemplate()) {
1574ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    Description = SemaRef.getTemplateArgumentBindingsText(
1575ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      FunTmpl->getTemplateParameters(), *D->getTemplateSpecializationArgs());
1576ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    IsTemplate = true;
1577ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  }
1578ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1579ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  SemaRef.Diag(Loc, diag::note_for_range_begin_end)
1580ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    << BEF << IsTemplate << Description << E->getType();
1581ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith}
1582ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1583ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// Build a call to 'begin' or 'end' for a C++0x for-range statement. If the
1584ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// given LookupResult is non-empty, it is assumed to describe a member which
1585ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// will be invoked. Otherwise, the function will be found via argument
1586ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// dependent lookup.
1587ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smithstatic ExprResult BuildForRangeBeginEndCall(Sema &SemaRef, Scope *S,
1588ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                            SourceLocation Loc,
1589ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                            VarDecl *Decl,
1590ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                            BeginEndFunction BEF,
1591ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                            const DeclarationNameInfo &NameInfo,
1592ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                            LookupResult &MemberLookup,
1593ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                            Expr *Range) {
1594ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  ExprResult CallExpr;
1595ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (!MemberLookup.empty()) {
1596ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    ExprResult MemberRef =
1597ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      SemaRef.BuildMemberReferenceExpr(Range, Range->getType(), Loc,
1598ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                       /*IsPtr=*/false, CXXScopeSpec(),
1599e4b92761b43ced611c417ae478568610f1ad7b1eAbramo Bagnara                                       /*TemplateKWLoc=*/SourceLocation(),
1600e4b92761b43ced611c417ae478568610f1ad7b1eAbramo Bagnara                                       /*FirstQualifierInScope=*/0,
1601e4b92761b43ced611c417ae478568610f1ad7b1eAbramo Bagnara                                       MemberLookup,
1602ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                       /*TemplateArgs=*/0);
1603ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    if (MemberRef.isInvalid())
1604ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      return ExprError();
1605ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    CallExpr = SemaRef.ActOnCallExpr(S, MemberRef.get(), Loc, MultiExprArg(),
1606ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                     Loc, 0);
1607ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    if (CallExpr.isInvalid())
1608ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      return ExprError();
1609ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  } else {
1610ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    UnresolvedSet<0> FoundNames;
1611ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    // C++0x [stmt.ranged]p1: For the purposes of this name lookup, namespace
1612ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    // std is an associated namespace.
1613ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    UnresolvedLookupExpr *Fn =
1614ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      UnresolvedLookupExpr::Create(SemaRef.Context, /*NamingClass=*/0,
1615ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                   NestedNameSpecifierLoc(), NameInfo,
1616ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                   /*NeedsADL=*/true, /*Overloaded=*/false,
1617ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                   FoundNames.begin(), FoundNames.end(),
1618ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                   /*LookInStdNamespace=*/true);
1619ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    CallExpr = SemaRef.BuildOverloadedCallExpr(S, Fn, Fn, Loc, &Range, 1, Loc,
16203943b1c0215da2a4171dd6c696cb75d19e5a04a9Kaelyn Uhrain                                               0, /*AllowTypoCorrection=*/false);
1621ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    if (CallExpr.isInvalid()) {
1622ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      SemaRef.Diag(Range->getLocStart(), diag::note_for_range_type)
1623ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        << Range->getType();
1624ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      return ExprError();
1625ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    }
1626ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  }
1627ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (FinishForRangeVarDecl(SemaRef, Decl, CallExpr.get(), Loc,
1628ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                            diag::err_for_range_iter_deduction_failure)) {
1629ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    NoteForRangeBeginEndFunction(SemaRef, CallExpr.get(), BEF);
1630ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    return ExprError();
1631ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  }
1632ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  return CallExpr;
1633ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith}
1634ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1635ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith}
1636ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
16374d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanianstatic bool ObjCEnumerationCollection(Expr *Collection) {
16384d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanian  return !Collection->isTypeDependent()
16394d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanian          && Collection->getType()->getAs<ObjCObjectPointerType>() != 0;
16404d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanian}
16414d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanian
1642ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// ActOnCXXForRangeStmt - Check and build a C++0x for-range statement.
1643ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///
1644ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// C++0x [stmt.ranged]:
1645ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///   A range-based for statement is equivalent to
1646ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///
1647ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///   {
1648ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///     auto && __range = range-init;
1649ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///     for ( auto __begin = begin-expr,
1650ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///           __end = end-expr;
1651ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///           __begin != __end;
1652ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///           ++__begin ) {
1653ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///       for-range-declaration = *__begin;
1654ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///       statement
1655ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///     }
1656ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///   }
1657ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith///
1658ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// The body of the loop is not available yet, since it cannot be analysed until
1659ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// we have determined the type of the for-range-declaration.
1660ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithStmtResult
1661ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithSema::ActOnCXXForRangeStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1662ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                           Stmt *First, SourceLocation ColonLoc, Expr *Range,
1663ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                           SourceLocation RParenLoc) {
1664ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (!First || !Range)
1665ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    return StmtError();
16664d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanian
16674d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanian  if (ObjCEnumerationCollection(Range))
16684d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanian    return ActOnObjCForCollectionStmt(ForLoc, LParenLoc, First, Range,
16694d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanian                                      RParenLoc);
1670ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1671ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  DeclStmt *DS = dyn_cast<DeclStmt>(First);
1672ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  assert(DS && "first part of for range not a decl stmt");
1673ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1674ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (!DS->isSingleDecl()) {
1675ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    Diag(DS->getStartLoc(), diag::err_type_defined_in_for_range);
1676ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    return StmtError();
1677ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  }
1678ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (DS->getSingleDecl()->isInvalidDecl())
1679ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    return StmtError();
1680ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1681ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (DiagnoseUnexpandedParameterPack(Range, UPPC_Expression))
1682ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    return StmtError();
1683ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1684ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  // Build  auto && __range = range-init
1685ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  SourceLocation RangeLoc = Range->getLocStart();
1686ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  VarDecl *RangeVar = BuildForRangeVarDecl(*this, RangeLoc,
1687ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                           Context.getAutoRRefDeductType(),
1688ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                           "__range");
1689ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (FinishForRangeVarDecl(*this, RangeVar, Range, RangeLoc,
1690ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                            diag::err_for_range_deduction_failure))
1691ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    return StmtError();
1692ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1693ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  // Claim the type doesn't contain auto: we've already done the checking.
1694ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  DeclGroupPtrTy RangeGroup =
1695ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    BuildDeclaratorGroup((Decl**)&RangeVar, 1, /*TypeMayContainAuto=*/false);
1696ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  StmtResult RangeDecl = ActOnDeclStmt(RangeGroup, RangeLoc, RangeLoc);
1697ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (RangeDecl.isInvalid())
1698ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    return StmtError();
1699ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1700ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  return BuildCXXForRangeStmt(ForLoc, ColonLoc, RangeDecl.get(),
1701ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                              /*BeginEndDecl=*/0, /*Cond=*/0, /*Inc=*/0, DS,
1702ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                              RParenLoc);
1703ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith}
1704ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1705ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// BuildCXXForRangeStmt - Build or instantiate a C++0x for-range statement.
1706ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithStmtResult
1707ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithSema::BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation ColonLoc,
1708ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                           Stmt *RangeDecl, Stmt *BeginEnd, Expr *Cond,
1709ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                           Expr *Inc, Stmt *LoopVarDecl,
1710ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                           SourceLocation RParenLoc) {
1711ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  Scope *S = getCurScope();
1712ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1713ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl);
1714ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  VarDecl *RangeVar = cast<VarDecl>(RangeDS->getSingleDecl());
1715ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  QualType RangeVarType = RangeVar->getType();
1716ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1717ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl);
1718ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  VarDecl *LoopVar = cast<VarDecl>(LoopVarDS->getSingleDecl());
1719ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1720ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  StmtResult BeginEndDecl = BeginEnd;
1721ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  ExprResult NotEqExpr = Cond, IncrExpr = Inc;
1722ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1723ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (!BeginEndDecl.get() && !RangeVarType->isDependentType()) {
1724ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    SourceLocation RangeLoc = RangeVar->getLocation();
1725ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1726e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    const QualType RangeVarNonRefType = RangeVarType.getNonReferenceType();
1727e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek
1728e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    ExprResult BeginRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
1729e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek                                                VK_LValue, ColonLoc);
1730e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    if (BeginRangeRef.isInvalid())
1731e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek      return StmtError();
1732e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek
1733e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    ExprResult EndRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
1734e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek                                              VK_LValue, ColonLoc);
1735e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    if (EndRangeRef.isInvalid())
1736ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      return StmtError();
1737ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1738ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    QualType AutoType = Context.getAutoDeductType();
1739ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    Expr *Range = RangeVar->getInit();
1740ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    if (!Range)
1741ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      return StmtError();
1742ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    QualType RangeType = Range->getType();
1743ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1744ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    if (RequireCompleteType(RangeLoc, RangeType,
1745d10099e5c8238fa0327f03921cf2e3c8975c881eDouglas Gregor                            diag::err_for_range_incomplete_type))
1746ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      return StmtError();
1747ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1748ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    // Build auto __begin = begin-expr, __end = end-expr.
1749ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1750ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                             "__begin");
1751ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    VarDecl *EndVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1752ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                           "__end");
1753ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1754ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    // Build begin-expr and end-expr and attach to __begin and __end variables.
1755ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    ExprResult BeginExpr, EndExpr;
1756ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {
1757ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      // - if _RangeT is an array type, begin-expr and end-expr are __range and
1758ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      //   __range + __bound, respectively, where __bound is the array bound. If
1759ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      //   _RangeT is an array of unknown size or an array of incomplete type,
1760ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      //   the program is ill-formed;
1761ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1762ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      // begin-expr is __range.
1763e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek      BeginExpr = BeginRangeRef;
1764e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek      if (FinishForRangeVarDecl(*this, BeginVar, BeginRangeRef.get(), ColonLoc,
1765ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                diag::err_for_range_iter_deduction_failure)) {
1766ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1767ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        return StmtError();
1768ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      }
1769ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1770ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      // Find the array bound.
1771ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      ExprResult BoundExpr;
1772ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(UnqAT))
1773ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        BoundExpr = Owned(IntegerLiteral::Create(Context, CAT->getSize(),
17741dd986dff9ddfbec687975700770bb377988e9edRichard Trieu                                                 Context.getPointerDiffType(),
17751dd986dff9ddfbec687975700770bb377988e9edRichard Trieu                                                 RangeLoc));
1776ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      else if (const VariableArrayType *VAT =
1777ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith               dyn_cast<VariableArrayType>(UnqAT))
1778ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        BoundExpr = VAT->getSizeExpr();
1779ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      else {
1780ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        // Can't be a DependentSizedArrayType or an IncompleteArrayType since
1781ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        // UnqAT is not incomplete and Range is not type-dependent.
1782b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie        llvm_unreachable("Unexpected array type in for-range");
1783ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      }
1784ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1785ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      // end-expr is __range + __bound.
1786e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek      EndExpr = ActOnBinOp(S, ColonLoc, tok::plus, EndRangeRef.get(),
1787ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                           BoundExpr.get());
1788ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      if (EndExpr.isInvalid())
1789ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        return StmtError();
1790ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      if (FinishForRangeVarDecl(*this, EndVar, EndExpr.get(), ColonLoc,
1791ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                diag::err_for_range_iter_deduction_failure)) {
1792ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1793ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        return StmtError();
1794ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      }
1795ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    } else {
1796ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      DeclarationNameInfo BeginNameInfo(&PP.getIdentifierTable().get("begin"),
1797ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                        ColonLoc);
1798ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      DeclarationNameInfo EndNameInfo(&PP.getIdentifierTable().get("end"),
1799ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                      ColonLoc);
1800ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1801ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      LookupResult BeginMemberLookup(*this, BeginNameInfo, LookupMemberName);
1802ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      LookupResult EndMemberLookup(*this, EndNameInfo, LookupMemberName);
1803ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1804ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      if (CXXRecordDecl *D = RangeType->getAsCXXRecordDecl()) {
1805ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        // - if _RangeT is a class type, the unqualified-ids begin and end are
1806ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        //   looked up in the scope of class _RangeT as if by class member access
1807ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        //   lookup (3.4.5), and if either (or both) finds at least one
1808ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        //   declaration, begin-expr and end-expr are __range.begin() and
1809ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        //   __range.end(), respectively;
1810ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        LookupQualifiedName(BeginMemberLookup, D);
1811ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        LookupQualifiedName(EndMemberLookup, D);
1812ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1813ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        if (BeginMemberLookup.empty() != EndMemberLookup.empty()) {
1814ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith          Diag(ColonLoc, diag::err_for_range_member_begin_end_mismatch)
1815ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith            << RangeType << BeginMemberLookup.empty();
1816ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith          return StmtError();
1817ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        }
1818ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      } else {
1819ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        // - otherwise, begin-expr and end-expr are begin(__range) and
1820ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        //   end(__range), respectively, where begin and end are looked up with
1821ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        //   argument-dependent lookup (3.4.2). For the purposes of this name
1822ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        //   lookup, namespace std is an associated namespace.
1823ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      }
1824ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1825ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      BeginExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, BeginVar,
1826ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                            BEF_begin, BeginNameInfo,
1827e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek                                            BeginMemberLookup,
1828e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek                                            BeginRangeRef.get());
1829ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      if (BeginExpr.isInvalid())
1830ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        return StmtError();
1831ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1832ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      EndExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, EndVar,
1833ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                          BEF_end, EndNameInfo,
1834e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek                                          EndMemberLookup, EndRangeRef.get());
1835ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      if (EndExpr.isInvalid())
1836ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        return StmtError();
1837ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    }
1838ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1839ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    // C++0x [decl.spec.auto]p6: BeginType and EndType must be the same.
1840ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    QualType BeginType = BeginVar->getType(), EndType = EndVar->getType();
1841ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    if (!Context.hasSameType(BeginType, EndType)) {
1842ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      Diag(RangeLoc, diag::err_for_range_begin_end_types_differ)
1843ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        << BeginType << EndType;
1844ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1845ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1846ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    }
1847ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1848ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    Decl *BeginEndDecls[] = { BeginVar, EndVar };
1849ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    // Claim the type doesn't contain auto: we've already done the checking.
1850ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    DeclGroupPtrTy BeginEndGroup =
1851ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      BuildDeclaratorGroup(BeginEndDecls, 2, /*TypeMayContainAuto=*/false);
1852ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    BeginEndDecl = ActOnDeclStmt(BeginEndGroup, ColonLoc, ColonLoc);
1853ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1854e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    const QualType BeginRefNonRefType = BeginType.getNonReferenceType();
1855e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    ExprResult BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1856ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                           VK_LValue, ColonLoc);
1857e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    if (BeginRef.isInvalid())
1858e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek      return StmtError();
1859e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek
1860ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    ExprResult EndRef = BuildDeclRefExpr(EndVar, EndType.getNonReferenceType(),
1861ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                         VK_LValue, ColonLoc);
1862e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    if (EndRef.isInvalid())
1863e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek      return StmtError();
1864ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1865ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    // Build and check __begin != __end expression.
1866ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    NotEqExpr = ActOnBinOp(S, ColonLoc, tok::exclaimequal,
1867ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                           BeginRef.get(), EndRef.get());
1868ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    NotEqExpr = ActOnBooleanCondition(S, ColonLoc, NotEqExpr.get());
1869ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    NotEqExpr = ActOnFinishFullExpr(NotEqExpr.get());
1870ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    if (NotEqExpr.isInvalid()) {
1871ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1872ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      if (!Context.hasSameType(BeginType, EndType))
1873ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1874ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      return StmtError();
1875ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    }
1876ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1877ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    // Build and check ++__begin expression.
1878e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1879e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek                                VK_LValue, ColonLoc);
1880e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    if (BeginRef.isInvalid())
1881e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek      return StmtError();
1882e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek
1883ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    IncrExpr = ActOnUnaryOp(S, ColonLoc, tok::plusplus, BeginRef.get());
1884ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    IncrExpr = ActOnFinishFullExpr(IncrExpr.get());
1885ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    if (IncrExpr.isInvalid()) {
1886ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1887ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      return StmtError();
1888ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    }
1889ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1890ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    // Build and check *__begin  expression.
1891e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1892e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek                                VK_LValue, ColonLoc);
1893e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek    if (BeginRef.isInvalid())
1894e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek      return StmtError();
1895e50b01531afcb4afc40d27720afa09613ddcdfa2Ted Kremenek
1896ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    ExprResult DerefExpr = ActOnUnaryOp(S, ColonLoc, tok::star, BeginRef.get());
1897ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    if (DerefExpr.isInvalid()) {
1898ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1899ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      return StmtError();
1900ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    }
1901ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1902ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    // Attach  *__begin  as initializer for VD.
1903ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    if (!LoopVar->isInvalidDecl()) {
1904ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      AddInitializerToDecl(LoopVar, DerefExpr.get(), /*DirectInit=*/false,
1905ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                           /*TypeMayContainAuto=*/true);
1906ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith      if (LoopVar->isInvalidDecl())
1907ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith        NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1908ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    }
1909cd6f36693ed40cef8c8639c04438d865187c1f73Richard Smith  } else {
1910cd6f36693ed40cef8c8639c04438d865187c1f73Richard Smith    // The range is implicitly used as a placeholder when it is dependent.
1911cd6f36693ed40cef8c8639c04438d865187c1f73Richard Smith    RangeVar->setUsed();
1912ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  }
1913ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1914ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  return Owned(new (Context) CXXForRangeStmt(RangeDS,
1915ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                     cast_or_null<DeclStmt>(BeginEndDecl.get()),
1916ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                             NotEqExpr.take(), IncrExpr.take(),
1917ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                             LoopVarDS, /*Body=*/0, ForLoc,
1918ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith                                             ColonLoc, RParenLoc));
1919ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith}
1920ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
1921a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian/// FinishObjCForCollectionStmt - Attach the body to a objective-C foreach
1922a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian/// statement.
1923a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz JahanianStmtResult Sema::FinishObjCForCollectionStmt(Stmt *S, Stmt *B) {
1924a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian  if (!S || !B)
1925a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian    return StmtError();
1926a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian  ObjCForCollectionStmt * ForStmt = cast<ObjCForCollectionStmt>(S);
1927a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian
1928a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian  ForStmt->setBody(B);
1929a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian  return S;
1930a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian}
1931a1eec4bd198b96ef40a7c15cd0e131ca94511ad8Fariborz Jahanian
1932ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
1933ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// This is a separate step from ActOnCXXForRangeStmt because analysis of the
1934ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// body cannot be performed until after the type of the range variable is
1935ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith/// determined.
1936ad762fcdc16b9e4705b12b09d92b8c026212b906Richard SmithStmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
1937ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  if (!S || !B)
1938ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith    return StmtError();
1939ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
19404d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanian  if (isa<ObjCForCollectionStmt>(S))
19414d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanian    return FinishObjCForCollectionStmt(S, B);
19424d3db4eb6caa49a7cdbfe1798728ce4b23cd0b53Fariborz Jahanian
1943625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  CXXForRangeStmt *ForStmt = cast<CXXForRangeStmt>(S);
1944625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  ForStmt->setBody(B);
1945625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko
1946625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko  DiagnoseEmptyStmtBody(ForStmt->getRParenLoc(), B,
1947625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko                        diag::warn_empty_range_based_for_body);
1948625bb569df0c34feec0d52c0ec5215f21ef2e054Dmitri Gribenko
1949ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith  return S;
1950ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith}
1951ad762fcdc16b9e4705b12b09d92b8c026212b906Richard Smith
195257ad37823e198f977cac605dbfbaefb4daf325e9Chris LattnerStmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc,
195357ad37823e198f977cac605dbfbaefb4daf325e9Chris Lattner                               SourceLocation LabelLoc,
195457ad37823e198f977cac605dbfbaefb4daf325e9Chris Lattner                               LabelDecl *TheDecl) {
195557ad37823e198f977cac605dbfbaefb4daf325e9Chris Lattner  getCurFunction()->setHasBranchIntoScope();
1956ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattner  TheDecl->setUsed();
1957ad8dcf4a9df0e24051dc31bf9e6f3cd138a34298Chris Lattner  return Owned(new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc));
19585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
19595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
196060d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
1961ad56d684259f706b7c0ae5ad9c23adb4f2926817Chris LattnerSema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc,
19629ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                            Expr *E) {
1963bbf462314b1dc8e422b7c4dd4cac47e566aedf6dEli Friedman  // Convert operand to void*
19645f1b9e689fa5c101512aef99225f2afea1673449Douglas Gregor  if (!E->isTypeDependent()) {
19655f1b9e689fa5c101512aef99225f2afea1673449Douglas Gregor    QualType ETy = E->getType();
19662877998bd8db2fac1c56430a4edcfa0ce138aff9Chandler Carruth    QualType DestTy = Context.getPointerType(Context.VoidTy.withConst());
1967429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley    ExprResult ExprRes = Owned(E);
19685f1b9e689fa5c101512aef99225f2afea1673449Douglas Gregor    AssignConvertType ConvTy =
1969429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley      CheckSingleAssignmentConstraints(DestTy, ExprRes);
1970429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley    if (ExprRes.isInvalid())
1971429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley      return StmtError();
1972429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley    E = ExprRes.take();
19732877998bd8db2fac1c56430a4edcfa0ce138aff9Chandler Carruth    if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E, AA_Passing))
19745f1b9e689fa5c101512aef99225f2afea1673449Douglas Gregor      return StmtError();
1975d29975fd08713eb9d1777e60536addaa62df8995Eli Friedman    E = MaybeCreateExprWithCleanups(E);
19765f1b9e689fa5c101512aef99225f2afea1673449Douglas Gregor  }
1977b60a77e453d32db0ab1914d28e175c2defc0eb65John McCall
1978781472fe99a120098c631b0cbe33c89f8cef5e70John McCall  getCurFunction()->setHasIndirectGoto();
1979b60a77e453d32db0ab1914d28e175c2defc0eb65John McCall
19805f1b9e689fa5c101512aef99225f2afea1673449Douglas Gregor  return Owned(new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E));
19815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
19825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
198360d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
19841b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) {
19855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer  Scope *S = CurScope->getContinueParent();
19865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer  if (!S) {
19875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer    // C99 6.8.6.2p1: A break shall appear only in or as a loop body.
19884cffe2fd5c23168bc08f0453c684cbd3f79471d3Sebastian Redl    return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop));
19895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer  }
19904cffe2fd5c23168bc08f0453c684cbd3f79471d3Sebastian Redl
19918189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek  return Owned(new (Context) ContinueStmt(ContinueLoc));
19925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
19935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
199460d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
19951b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
19965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer  Scope *S = CurScope->getBreakParent();
19975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer  if (!S) {
19985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer    // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
19994cffe2fd5c23168bc08f0453c684cbd3f79471d3Sebastian Redl    return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
20005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer  }
20014cffe2fd5c23168bc08f0453c684cbd3f79471d3Sebastian Redl
20028189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek  return Owned(new (Context) BreakStmt(BreakLoc));
20035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
20045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
2005dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi/// \brief Determine whether the given expression is a candidate for
2006f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor/// copy elision in either a return statement or a throw expression.
20075077c3876beeaed32280af88244e8050078619a8Douglas Gregor///
2008f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor/// \param ReturnType If we're determining the copy elision candidate for
2009f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor/// a return statement, this is the return type of the function. If we're
2010f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor/// determining the copy elision candidate for a throw expression, this will
2011f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor/// be a NULL type.
20125077c3876beeaed32280af88244e8050078619a8Douglas Gregor///
2013f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor/// \param E The expression being returned from the function or block, or
2014f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor/// being thrown.
20155077c3876beeaed32280af88244e8050078619a8Douglas Gregor///
20164926d832aa2f0af9d7c00633727d49e7967eb978Douglas Gregor/// \param AllowFunctionParameter Whether we allow function parameters to
20174926d832aa2f0af9d7c00633727d49e7967eb978Douglas Gregor/// be considered NRVO candidates. C++ prohibits this for NRVO itself, but
20184926d832aa2f0af9d7c00633727d49e7967eb978Douglas Gregor/// we re-use this logic to determine whether we should try to move as part of
20194926d832aa2f0af9d7c00633727d49e7967eb978Douglas Gregor/// a return or throw (which does allow function parameters).
20205077c3876beeaed32280af88244e8050078619a8Douglas Gregor///
20215077c3876beeaed32280af88244e8050078619a8Douglas Gregor/// \returns The NRVO candidate variable, if the return statement may use the
20225077c3876beeaed32280af88244e8050078619a8Douglas Gregor/// NRVO, or NULL if there is no such candidate.
2023f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregorconst VarDecl *Sema::getCopyElisionCandidate(QualType ReturnType,
2024f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor                                             Expr *E,
2025f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor                                             bool AllowFunctionParameter) {
2026f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor  QualType ExprType = E->getType();
20273c9034cb7ff1d6c1e4ecd1b44c98f553df013c7cDouglas Gregor  // - in a return statement in a function with ...
20283c9034cb7ff1d6c1e4ecd1b44c98f553df013c7cDouglas Gregor  // ... a class return type ...
2029f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor  if (!ReturnType.isNull()) {
2030f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor    if (!ReturnType->isRecordType())
2031f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor      return 0;
2032f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor    // ... the same cv-unqualified type as the function return type ...
2033f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor    if (!Context.hasSameUnqualifiedType(ReturnType, ExprType))
2034f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor      return 0;
2035f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor  }
2036dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2037dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi  // ... the expression is the name of a non-volatile automatic object
2038f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor  // (other than a function or catch-clause parameter)) ...
2039f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor  const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
20403c9034cb7ff1d6c1e4ecd1b44c98f553df013c7cDouglas Gregor  if (!DR)
20415077c3876beeaed32280af88244e8050078619a8Douglas Gregor    return 0;
20423c9034cb7ff1d6c1e4ecd1b44c98f553df013c7cDouglas Gregor  const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
20433c9034cb7ff1d6c1e4ecd1b44c98f553df013c7cDouglas Gregor  if (!VD)
20445077c3876beeaed32280af88244e8050078619a8Douglas Gregor    return 0;
2045dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
20461cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  // ...object (other than a function or catch-clause parameter)...
20471cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  if (VD->getKind() != Decl::Var &&
20481cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall      !(AllowFunctionParameter && VD->getKind() == Decl::ParmVar))
20491cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall    return 0;
20501cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  if (VD->isExceptionVariable()) return 0;
20511cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall
20521cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  // ...automatic...
20531cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  if (!VD->hasLocalStorage()) return 0;
20541cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall
20551cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  // ...non-volatile...
20561cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  if (VD->getType().isVolatileQualified()) return 0;
20571cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  if (VD->getType()->isReferenceType()) return 0;
20581cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall
20591cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  // __block variables can't be allocated in a way that permits NRVO.
20601cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  if (VD->hasAttr<BlocksAttr>()) return 0;
20611cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall
20621cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  // Variables with higher required alignment than their type's ABI
20631cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  // alignment cannot use NRVO.
20641cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  if (VD->hasAttr<AlignedAttr>() &&
20651cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall      Context.getDeclAlign(VD) > Context.getTypeAlignInChars(VD->getType()))
20661cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall    return 0;
2067dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
20681cd76e8ca8f890a4defadcae3372c025ebe7607cJohn McCall  return VD;
20693c9034cb7ff1d6c1e4ecd1b44c98f553df013c7cDouglas Gregor}
20703c9034cb7ff1d6c1e4ecd1b44c98f553df013c7cDouglas Gregor
207107f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor/// \brief Perform the initialization of a potentially-movable value, which
207207f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor/// is the result of return value.
2073cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor///
2074cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor/// This routine implements C++0x [class.copy]p33, which attempts to treat
2075cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor/// returned lvalues as rvalues in certain cases (to prefer move construction),
2076cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor/// then falls back to treating them as lvalues if that failed.
2077dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA TakumiExprResult
207807f402cff25354c5f06f307f19b0c57c09d964bdDouglas GregorSema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
207907f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor                                      const VarDecl *NRVOCandidate,
208007f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor                                      QualType ResultType,
2081bca01b46850f867b2f4137f25c882022b58f8471Douglas Gregor                                      Expr *Value,
2082bca01b46850f867b2f4137f25c882022b58f8471Douglas Gregor                                      bool AllowNRVO) {
2083cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor  // C++0x [class.copy]p33:
2084dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi  //   When the criteria for elision of a copy operation are met or would
2085dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi  //   be met save for the fact that the source object is a function
2086dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi  //   parameter, and the object to be copied is designated by an lvalue,
2087cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor  //   overload resolution to select the constructor for the copy is first
2088cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor  //   performed as if the object were designated by an rvalue.
2089cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor  ExprResult Res = ExprError();
2090bca01b46850f867b2f4137f25c882022b58f8471Douglas Gregor  if (AllowNRVO &&
2091bca01b46850f867b2f4137f25c882022b58f8471Douglas Gregor      (NRVOCandidate || getCopyElisionCandidate(ResultType, Value, true))) {
2092dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi    ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack,
2093dbbecccb8431bb4545fc01c6401abc4253667360Richard Smith                              Value->getType(), CK_NoOp, Value, VK_XValue);
2094dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2095cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor    Expr *InitExpr = &AsRvalue;
2096dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi    InitializationKind Kind
209707f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor      = InitializationKind::CreateCopy(Value->getLocStart(),
209807f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor                                       Value->getLocStart());
209907f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor    InitializationSequence Seq(*this, Entity, Kind, &InitExpr, 1);
2100dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2101dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi    //   [...] If overload resolution fails, or if the type of the first
2102cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor    //   parameter of the selected constructor is not an rvalue reference
21030099530a2288df7c2140dd8992b7310b9f6930a9NAKAMURA Takumi    //   to the object's type (possibly cv-qualified), overload resolution
2104cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor    //   is performed again, considering the object as an lvalue.
2105383616cd2e61131a534afd9364ef53f643e1f834Sebastian Redl    if (Seq) {
2106cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor      for (InitializationSequence::step_iterator Step = Seq.step_begin(),
2107cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor           StepEnd = Seq.step_end();
2108cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor           Step != StepEnd; ++Step) {
2109383616cd2e61131a534afd9364ef53f643e1f834Sebastian Redl        if (Step->Kind != InitializationSequence::SK_ConstructorInitialization)
2110cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor          continue;
2111dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2112dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi        CXXConstructorDecl *Constructor
2113cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor        = cast<CXXConstructorDecl>(Step->Function.Function);
2114dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2115cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor        const RValueReferenceType *RRefType
211607f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor          = Constructor->getParamDecl(0)->getType()
211707f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor                                                 ->getAs<RValueReferenceType>();
2118dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2119cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor        // If we don't meet the criteria, break out now.
2120dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi        if (!RRefType ||
212107f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor            !Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
212207f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor                            Context.getTypeDeclType(Constructor->getParent())))
2123cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor          break;
2124dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2125cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor        // Promote "AsRvalue" to the heap, since we now need this
2126cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor        // expression node to persist.
212707f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor        Value = ImplicitCastExpr::Create(Context, Value->getType(),
2128dbbecccb8431bb4545fc01c6401abc4253667360Richard Smith                                         CK_NoOp, Value, 0, VK_XValue);
2129dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2130cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor        // Complete type-checking the initialization of the return type
2131cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor        // using the constructor we found.
213207f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor        Res = Seq.Perform(*this, Entity, Kind, MultiExprArg(&Value, 1));
2133cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor      }
2134cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor    }
2135cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor  }
2136dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2137cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor  // Either we didn't meet the criteria for treating an lvalue as an rvalue,
2138dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi  // above, or overload resolution failed. Either way, we need to try
2139cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor  // (again) now with the return value expression as written.
2140cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor  if (Res.isInvalid())
214107f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor    Res = PerformCopyInitialization(Entity, SourceLocation(), Value);
2142dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2143cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor  return Res;
2144cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor}
2145cc15f010672a13b38104a32e3cefc7adc07ffbf7Douglas Gregor
214684b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman/// ActOnCapScopeReturnStmt - Utility routine to type-check return statements
214784b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman/// for capturing scopes.
21484eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff///
214960d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
215084b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli FriedmanSema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
215184b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman  // If this is the first return we've seen, infer the return type.
215284b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman  // [expr.prim.lambda]p4 in C++11; block literals follow a superset of those
215384b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman  // rules which allows multiple return statements.
215484b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman  CapturingScopeInfo *CurCap = cast<CapturingScopeInfo>(getCurFunction());
21557dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose  QualType FnRetType = CurCap->ReturnType;
21567dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose
21577dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose  // For blocks/lambdas with implicit return types, we check each return
21587dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose  // statement individually, and deduce the common return type when the block
21597dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose  // or lambda is completed.
216084b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman  if (CurCap->HasImplicitReturnType) {
2161a0c2b21e0d84ad289781e08e14148da6b8b8b76dDouglas Gregor    if (RetValExp && !isa<InitListExpr>(RetValExp)) {
2162429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley      ExprResult Result = DefaultFunctionArrayLvalueConversion(RetValExp);
2163429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley      if (Result.isInvalid())
2164429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley        return StmtError();
2165429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley      RetValExp = Result.take();
21666a576ab708d3aa7d40e5d867ab1de5d3cb507553Douglas Gregor
21677dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose      if (!RetValExp->isTypeDependent())
21687dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose        FnRetType = RetValExp->getType();
21697dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose      else
21707dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose        FnRetType = CurCap->ReturnType = Context.DependentTy;
2171a0c2b21e0d84ad289781e08e14148da6b8b8b76dDouglas Gregor    } else {
2172a0c2b21e0d84ad289781e08e14148da6b8b8b76dDouglas Gregor      if (RetValExp) {
2173a0c2b21e0d84ad289781e08e14148da6b8b8b76dDouglas Gregor        // C++11 [expr.lambda.prim]p4 bans inferring the result from an
2174a0c2b21e0d84ad289781e08e14148da6b8b8b76dDouglas Gregor        // initializer list, because it is not an expression (even
2175a0c2b21e0d84ad289781e08e14148da6b8b8b76dDouglas Gregor        // though we represent it as one). We still deduce 'void'.
2176a0c2b21e0d84ad289781e08e14148da6b8b8b76dDouglas Gregor        Diag(ReturnLoc, diag::err_lambda_return_init_list)
2177a0c2b21e0d84ad289781e08e14148da6b8b8b76dDouglas Gregor          << RetValExp->getSourceRange();
2178a0c2b21e0d84ad289781e08e14148da6b8b8b76dDouglas Gregor      }
2179a0c2b21e0d84ad289781e08e14148da6b8b8b76dDouglas Gregor
21807dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose      FnRetType = Context.VoidTy;
2181649657e7d6c150136cae5ab22e39b9794cff80ccFariborz Jahanian    }
21827dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose
21837dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose    // Although we'll properly infer the type of the block once it's completed,
21847dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose    // make sure we provide a return type now for better error recovery.
21857dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose    if (CurCap->ReturnType.isNull())
21867dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose      CurCap->ReturnType = FnRetType;
21874eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff  }
218884b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman  assert(!FnRetType.isNull());
21894cffe2fd5c23168bc08f0453c684cbd3f79471d3Sebastian Redl
2190793cd1c4cdfaafc52e2c2ad9dae959befe4bb166Douglas Gregor  if (BlockScopeInfo *CurBlock = dyn_cast<BlockScopeInfo>(CurCap)) {
219184b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman    if (CurBlock->FunctionType->getAs<FunctionType>()->getNoReturnAttr()) {
219284b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman      Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr);
219384b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman      return StmtError();
219484b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman    }
2195793cd1c4cdfaafc52e2c2ad9dae959befe4bb166Douglas Gregor  } else {
2196793cd1c4cdfaafc52e2c2ad9dae959befe4bb166Douglas Gregor    LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CurCap);
2197793cd1c4cdfaafc52e2c2ad9dae959befe4bb166Douglas Gregor    if (LSI->CallOperator->getType()->getAs<FunctionType>()->getNoReturnAttr()){
2198793cd1c4cdfaafc52e2c2ad9dae959befe4bb166Douglas Gregor      Diag(ReturnLoc, diag::err_noreturn_lambda_has_return_expr);
2199793cd1c4cdfaafc52e2c2ad9dae959befe4bb166Douglas Gregor      return StmtError();
2200793cd1c4cdfaafc52e2c2ad9dae959befe4bb166Douglas Gregor    }
2201793cd1c4cdfaafc52e2c2ad9dae959befe4bb166Douglas Gregor  }
22026c92fa75e62937f9738696840efcb258560f4568Mike Stump
22034eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff  // Otherwise, verify that this result type matches the previous one.  We are
22044eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff  // pickier with blocks than for normal functions because we don't have GCC
22054eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff  // compatibility to worry about here.
2206d963c37eb912342c8325048749e449861cf0a6e3John McCall  const VarDecl *NRVOCandidate = 0;
22070a7efe1142d241678c91bf93ee6adb51289863a4John McCall  if (FnRetType->isDependentType()) {
22080a7efe1142d241678c91bf93ee6adb51289863a4John McCall    // Delay processing for now.  TODO: there are lots of dependent
22090a7efe1142d241678c91bf93ee6adb51289863a4John McCall    // types we can conclusively prove aren't void.
22100a7efe1142d241678c91bf93ee6adb51289863a4John McCall  } else if (FnRetType->isVoidType()) {
22115b38a0f98e4420dae1bd3e13959bc207c97a9e98Sebastian Redl    if (RetValExp && !isa<InitListExpr>(RetValExp) &&
22124e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie        !(getLangOpts().CPlusPlus &&
22130a7efe1142d241678c91bf93ee6adb51289863a4John McCall          (RetValExp->isTypeDependent() ||
22140a7efe1142d241678c91bf93ee6adb51289863a4John McCall           RetValExp->getType()->isVoidType()))) {
22154e648e4770d85febaf15ad8b7bad458bd7338ae2Fariborz Jahanian      if (!getLangOpts().CPlusPlus &&
22164e648e4770d85febaf15ad8b7bad458bd7338ae2Fariborz Jahanian          RetValExp->getType()->isVoidType())
22179354f6aaa70e1543d122644fee0c3f834324d2fcFariborz Jahanian        Diag(ReturnLoc, diag::ext_return_has_void_expr) << "literal" << 2;
22184e648e4770d85febaf15ad8b7bad458bd7338ae2Fariborz Jahanian      else {
22194e648e4770d85febaf15ad8b7bad458bd7338ae2Fariborz Jahanian        Diag(ReturnLoc, diag::err_return_block_has_expr);
22204e648e4770d85febaf15ad8b7bad458bd7338ae2Fariborz Jahanian        RetValExp = 0;
22214e648e4770d85febaf15ad8b7bad458bd7338ae2Fariborz Jahanian      }
22224eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff    }
22235077c3876beeaed32280af88244e8050078619a8Douglas Gregor  } else if (!RetValExp) {
22240a7efe1142d241678c91bf93ee6adb51289863a4John McCall    return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr));
22250a7efe1142d241678c91bf93ee6adb51289863a4John McCall  } else if (!RetValExp->isTypeDependent()) {
22260a7efe1142d241678c91bf93ee6adb51289863a4John McCall    // we have a non-void block with an expression, continue checking
22270a7efe1142d241678c91bf93ee6adb51289863a4John McCall
22280a7efe1142d241678c91bf93ee6adb51289863a4John McCall    // C99 6.8.6.4p3(136): The return statement is not an assignment. The
22290a7efe1142d241678c91bf93ee6adb51289863a4John McCall    // overlap restriction of subclause 6.5.16.1 does not apply to the case of
22300a7efe1142d241678c91bf93ee6adb51289863a4John McCall    // function return.
22310a7efe1142d241678c91bf93ee6adb51289863a4John McCall
22320a7efe1142d241678c91bf93ee6adb51289863a4John McCall    // In C++ the return statement is handled via a copy initialization.
22330a7efe1142d241678c91bf93ee6adb51289863a4John McCall    // the C version of which boils down to CheckSingleAssignmentConstraints.
22340a7efe1142d241678c91bf93ee6adb51289863a4John McCall    NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
22350a7efe1142d241678c91bf93ee6adb51289863a4John McCall    InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
22360a7efe1142d241678c91bf93ee6adb51289863a4John McCall                                                                   FnRetType,
22370586520acb2f368c874943353a222be7f00c3068Fariborz Jahanian                                                          NRVOCandidate != 0);
22380a7efe1142d241678c91bf93ee6adb51289863a4John McCall    ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
22390a7efe1142d241678c91bf93ee6adb51289863a4John McCall                                                     FnRetType, RetValExp);
22400a7efe1142d241678c91bf93ee6adb51289863a4John McCall    if (Res.isInvalid()) {
22410a7efe1142d241678c91bf93ee6adb51289863a4John McCall      // FIXME: Cleanup temporaries here, anyway?
22420a7efe1142d241678c91bf93ee6adb51289863a4John McCall      return StmtError();
2243c6acbc58a7aef0a3382775424c80e9534b54b2edAnders Carlsson    }
22440a7efe1142d241678c91bf93ee6adb51289863a4John McCall    RetValExp = Res.take();
22450a7efe1142d241678c91bf93ee6adb51289863a4John McCall    CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
2246d963c37eb912342c8325048749e449861cf0a6e3John McCall  }
2247dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2248d963c37eb912342c8325048749e449861cf0a6e3John McCall  if (RetValExp) {
2249d963c37eb912342c8325048749e449861cf0a6e3John McCall    CheckImplicitConversions(RetValExp, ReturnLoc);
2250d963c37eb912342c8325048749e449861cf0a6e3John McCall    RetValExp = MaybeCreateExprWithCleanups(RetValExp);
225198eb8a7a702b95183ed015706b1f1c66f5cb27a4Mike Stump  }
22520a7efe1142d241678c91bf93ee6adb51289863a4John McCall  ReturnStmt *Result = new (Context) ReturnStmt(ReturnLoc, RetValExp,
22530a7efe1142d241678c91bf93ee6adb51289863a4John McCall                                                NRVOCandidate);
22544cffe2fd5c23168bc08f0453c684cbd3f79471d3Sebastian Redl
22557dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose  // If we need to check for the named return value optimization,
22567dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose  // or if we need to infer the return type,
22577dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose  // save the return statement in our scope for later processing.
22587dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose  if (CurCap->HasImplicitReturnType ||
22597dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose      (getLangOpts().CPlusPlus && FnRetType->isRecordType() &&
22607dd900ed308506f9cf1cb72c70db1652f94cab37Jordan Rose       !CurContext->isDependentContext()))
22615077c3876beeaed32280af88244e8050078619a8Douglas Gregor    FunctionScopes.back()->Returns.push_back(Result);
2262dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
22635077c3876beeaed32280af88244e8050078619a8Douglas Gregor  return Owned(Result);
22644eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff}
22655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
226660d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
22679ae2f076ca5ab1feb3ba95629099ec2319833701John McCallSema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
2268fc92137eee708b632c00a9b0934ff87aeae234a5Douglas Gregor  // Check for unexpanded parameter packs.
2269fc92137eee708b632c00a9b0934ff87aeae234a5Douglas Gregor  if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
2270fc92137eee708b632c00a9b0934ff87aeae234a5Douglas Gregor    return StmtError();
2271fc92137eee708b632c00a9b0934ff87aeae234a5Douglas Gregor
227284b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman  if (isa<CapturingScopeInfo>(getCurFunction()))
227384b007fae6c0cd30fa07074d34fbe2bf61fa44f9Eli Friedman    return ActOnCapScopeReturnStmt(ReturnLoc, RetValExp);
22744cffe2fd5c23168bc08f0453c684cbd3f79471d3Sebastian Redl
2275371f258e61e1365b951b17931a3c5ac1530fd1a0Chris Lattner  QualType FnRetType;
227638ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman  QualType RelatedRetType;
2277f7c41dab1a8de29b0991e853b8822bb0d1ddc01cMike Stump  if (const FunctionDecl *FD = getCurFunctionDecl()) {
2278371f258e61e1365b951b17931a3c5ac1530fd1a0Chris Lattner    FnRetType = FD->getResultType();
227904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall    if (FD->hasAttr<NoReturnAttr>() ||
228004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall        FD->getType()->getAs<FunctionType>()->getNoReturnAttr())
22818662587fa75d3fb04f873e265841c9314c7f5523Chris Lattner      Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr)
228279430e9983f5e67a378fc1f50cd6278f2cea8259Eli Friedman        << FD->getDeclName();
2283926df6cfabf3eaa4afc990c097fa4619b76a9b57Douglas Gregor  } else if (ObjCMethodDecl *MD = getCurMethodDecl()) {
228438ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman    FnRetType = MD->getResultType();
2285926df6cfabf3eaa4afc990c097fa4619b76a9b57Douglas Gregor    if (MD->hasRelatedResultType() && MD->getClassInterface()) {
2286926df6cfabf3eaa4afc990c097fa4619b76a9b57Douglas Gregor      // In the implementation of a method with a related return type, the
2287926df6cfabf3eaa4afc990c097fa4619b76a9b57Douglas Gregor      // type used to type-check the validity of return statements within the
2288926df6cfabf3eaa4afc990c097fa4619b76a9b57Douglas Gregor      // method body is a pointer to the type of the class being implemented.
228938ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman      RelatedRetType = Context.getObjCInterfaceType(MD->getClassInterface());
229038ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman      RelatedRetType = Context.getObjCObjectPointerType(RelatedRetType);
2291926df6cfabf3eaa4afc990c097fa4619b76a9b57Douglas Gregor    }
2292926df6cfabf3eaa4afc990c097fa4619b76a9b57Douglas Gregor  } else // If we don't have a function/method context, bail.
2293c97fb9a394ce2cc5e664fcb472e93553528378adSteve Naroff    return StmtError();
22941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
22955077c3876beeaed32280af88244e8050078619a8Douglas Gregor  ReturnStmt *Result = 0;
22965cf216b7fa64b933b60743b0b26053e8e7aa87beChris Lattner  if (FnRetType->isVoidType()) {
22978d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky    if (RetValExp) {
229833deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl      if (isa<InitListExpr>(RetValExp)) {
229933deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        // We simply never allow init lists as the return value of void
230033deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        // functions. This is compatible because this was never allowed before,
230133deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        // so there's no legacy code to deal with.
230233deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
230333deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        int FunctionKind = 0;
230433deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        if (isa<ObjCMethodDecl>(CurDecl))
230533deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl          FunctionKind = 1;
230633deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        else if (isa<CXXConstructorDecl>(CurDecl))
230733deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl          FunctionKind = 2;
230833deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        else if (isa<CXXDestructorDecl>(CurDecl))
230933deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl          FunctionKind = 3;
231033deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl
231133deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        Diag(ReturnLoc, diag::err_return_init_list)
231233deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl          << CurDecl->getDeclName() << FunctionKind
231333deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl          << RetValExp->getSourceRange();
231433deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl
231533deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        // Drop the expression.
231633deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        RetValExp = 0;
231733deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl      } else if (!RetValExp->isTypeDependent()) {
23188d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky        // C99 6.8.6.4p1 (ext_ since GCC warns)
23198d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky        unsigned D = diag::ext_return_has_expr;
23208d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky        if (RetValExp->getType()->isVoidType())
23218d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky          D = diag::ext_return_has_void_expr;
23228d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky        else {
23238d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky          ExprResult Result = Owned(RetValExp);
23248d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky          Result = IgnoredValueConversions(Result.take());
23258d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky          if (Result.isInvalid())
23268d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky            return StmtError();
23278d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky          RetValExp = Result.take();
23288d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky          RetValExp = ImpCastExprToType(RetValExp,
23298d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky                                        Context.VoidTy, CK_ToVoid).take();
23308d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky        }
23314cffe2fd5c23168bc08f0453c684cbd3f79471d3Sebastian Redl
23328d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky        // return (some void expression); is legal in C++.
23338d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky        if (D != diag::ext_return_has_void_expr ||
23344e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie            !getLangOpts().CPlusPlus) {
23358d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky          NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
2336ca0d0d4a0d6ecd256d4bf8c1a0dc183a83119833Chandler Carruth
2337ca0d0d4a0d6ecd256d4bf8c1a0dc183a83119833Chandler Carruth          int FunctionKind = 0;
2338ca0d0d4a0d6ecd256d4bf8c1a0dc183a83119833Chandler Carruth          if (isa<ObjCMethodDecl>(CurDecl))
2339ca0d0d4a0d6ecd256d4bf8c1a0dc183a83119833Chandler Carruth            FunctionKind = 1;
2340ca0d0d4a0d6ecd256d4bf8c1a0dc183a83119833Chandler Carruth          else if (isa<CXXConstructorDecl>(CurDecl))
2341ca0d0d4a0d6ecd256d4bf8c1a0dc183a83119833Chandler Carruth            FunctionKind = 2;
2342ca0d0d4a0d6ecd256d4bf8c1a0dc183a83119833Chandler Carruth          else if (isa<CXXDestructorDecl>(CurDecl))
2343ca0d0d4a0d6ecd256d4bf8c1a0dc183a83119833Chandler Carruth            FunctionKind = 3;
2344ca0d0d4a0d6ecd256d4bf8c1a0dc183a83119833Chandler Carruth
23458d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky          Diag(ReturnLoc, D)
2346ca0d0d4a0d6ecd256d4bf8c1a0dc183a83119833Chandler Carruth            << CurDecl->getDeclName() << FunctionKind
23478d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky            << RetValExp->getSourceRange();
23488d7946151cd15c0e7c34250c122d59b2f5027999Nick Lewycky        }
2349e878eb035b343d7d819c092102364ec9849716aeChris Lattner      }
23501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
235133deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl      if (RetValExp) {
235233deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        CheckImplicitConversions(RetValExp, ReturnLoc);
235333deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl        RetValExp = MaybeCreateExprWithCleanups(RetValExp);
235433deb35535aebe81bed0eaf5c14f3032276a086eSebastian Redl      }
23555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer    }
2356dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
23575077c3876beeaed32280af88244e8050078619a8Douglas Gregor    Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 0);
23585077c3876beeaed32280af88244e8050078619a8Douglas Gregor  } else if (!RetValExp && !FnRetType->isDependentType()) {
23593c73c41cefcfe76f36b7bed72c9f1ec195490951Chris Lattner    unsigned DiagID = diag::warn_return_missing_expr;  // C90 6.6.6.4p4
23603c73c41cefcfe76f36b7bed72c9f1ec195490951Chris Lattner    // C99 6.8.6.4p1 (ext_ since GCC warns)
23614e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie    if (getLangOpts().C99) DiagID = diag::ext_return_missing_expr;
23623c73c41cefcfe76f36b7bed72c9f1ec195490951Chris Lattner
23633c73c41cefcfe76f36b7bed72c9f1ec195490951Chris Lattner    if (FunctionDecl *FD = getCurFunctionDecl())
236408631c5fa053867146b5ee8be658c229f6bf127cChris Lattner      Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/;
23653c73c41cefcfe76f36b7bed72c9f1ec195490951Chris Lattner    else
236608631c5fa053867146b5ee8be658c229f6bf127cChris Lattner      Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/;
23675077c3876beeaed32280af88244e8050078619a8Douglas Gregor    Result = new (Context) ReturnStmt(ReturnLoc);
23685077c3876beeaed32280af88244e8050078619a8Douglas Gregor  } else {
23695077c3876beeaed32280af88244e8050078619a8Douglas Gregor    const VarDecl *NRVOCandidate = 0;
23705077c3876beeaed32280af88244e8050078619a8Douglas Gregor    if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
23715077c3876beeaed32280af88244e8050078619a8Douglas Gregor      // we have a non-void function with an expression, continue checking
23725077c3876beeaed32280af88244e8050078619a8Douglas Gregor
237338ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman      if (!RelatedRetType.isNull()) {
237438ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman        // If we have a related result type, perform an extra conversion here.
237538ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman        // FIXME: The diagnostics here don't really describe what is happening.
237638ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman        InitializedEntity Entity =
237738ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman            InitializedEntity::InitializeTemporary(RelatedRetType);
23788e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
237938ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman        ExprResult Res = PerformCopyInitialization(Entity, SourceLocation(),
238038ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman                                                   RetValExp);
238138ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman        if (Res.isInvalid()) {
238238ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman          // FIXME: Cleanup temporaries here, anyway?
238338ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman          return StmtError();
238438ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman        }
238538ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman        RetValExp = Res.takeAs<Expr>();
238638ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman      }
238738ac243e300798e8cd9fe05888cd97beabfb94e6Eli Friedman
23885077c3876beeaed32280af88244e8050078619a8Douglas Gregor      // C99 6.8.6.4p3(136): The return statement is not an assignment. The
23895077c3876beeaed32280af88244e8050078619a8Douglas Gregor      // overlap restriction of subclause 6.5.16.1 does not apply to the case of
23905077c3876beeaed32280af88244e8050078619a8Douglas Gregor      // function return.
23915077c3876beeaed32280af88244e8050078619a8Douglas Gregor
2392856d3798af7c2f7251e4a295f3da7a09ce4c62abJohn McCall      // In C++ the return statement is handled via a copy initialization,
23935077c3876beeaed32280af88244e8050078619a8Douglas Gregor      // the C version of which boils down to CheckSingleAssignmentConstraints.
2394f5d8f466c3eebaffc51468812bdcbe7f0fe4891aDouglas Gregor      NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
2395dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi      InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
239607f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor                                                                     FnRetType,
239758f14c012e5d739b09532bb12645dc161f88cfcfFrancois Pichet                                                            NRVOCandidate != 0);
2398dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi      ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
239907f402cff25354c5f06f307f19b0c57c09d964bdDouglas Gregor                                                       FnRetType, RetValExp);
24005077c3876beeaed32280af88244e8050078619a8Douglas Gregor      if (Res.isInvalid()) {
24015077c3876beeaed32280af88244e8050078619a8Douglas Gregor        // FIXME: Cleanup temporaries here, anyway?
24025077c3876beeaed32280af88244e8050078619a8Douglas Gregor        return StmtError();
24035077c3876beeaed32280af88244e8050078619a8Douglas Gregor      }
24044cffe2fd5c23168bc08f0453c684cbd3f79471d3Sebastian Redl
24055077c3876beeaed32280af88244e8050078619a8Douglas Gregor      RetValExp = Res.takeAs<Expr>();
2406dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi      if (RetValExp)
24075077c3876beeaed32280af88244e8050078619a8Douglas Gregor        CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
240866724ea67d7d598b937d86fa66f03f09a1c758f3Douglas Gregor    }
2409dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2410b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall    if (RetValExp) {
2411b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall      CheckImplicitConversions(RetValExp, ReturnLoc);
24124765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall      RetValExp = MaybeCreateExprWithCleanups(RetValExp);
2413b4eb64d8426c0eaa58d398961e0e74ff85063d7cJohn McCall    }
24145077c3876beeaed32280af88244e8050078619a8Douglas Gregor    Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
2415898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor  }
2416dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2417dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi  // If we need to check for the named return value optimization, save the
24185077c3876beeaed32280af88244e8050078619a8Douglas Gregor  // return statement in our scope for later processing.
24194e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie  if (getLangOpts().CPlusPlus && FnRetType->isRecordType() &&
24205077c3876beeaed32280af88244e8050078619a8Douglas Gregor      !CurContext->isDependentContext())
24215077c3876beeaed32280af88244e8050078619a8Douglas Gregor    FunctionScopes.back()->Returns.push_back(Result);
24228e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
24235077c3876beeaed32280af88244e8050078619a8Douglas Gregor  return Owned(Result);
24245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}
24255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer
2426810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner/// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently
2427810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner/// ignore "noop" casts in places where an lvalue is required by an inline asm.
2428810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner/// We emulate this behavior when -fheinous-gnu-extensions is specified, but
2429810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner/// provide a strong guidance to not use it.
2430810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner///
2431810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner/// This method checks to see if the argument is an acceptable l-value and
2432810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner/// returns false if it is a case we can handle.
2433810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattnerstatic bool CheckAsmLValue(const Expr *E, Sema &S) {
2434703e39486689d6660e75f6b6de0068db031a51c7Anders Carlsson  // Type dependent expressions will be checked during instantiation.
2435703e39486689d6660e75f6b6de0068db031a51c7Anders Carlsson  if (E->isTypeDependent())
2436703e39486689d6660e75f6b6de0068db031a51c7Anders Carlsson    return false;
2437dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
24387eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall  if (E->isLValue())
2439810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner    return false;  // Cool, this is an lvalue.
2440810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner
2441810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner  // Okay, this is not an lvalue, but perhaps it is the result of a cast that we
2442810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner  // are supposed to allow.
2443810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner  const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
24447eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall  if (E != E2 && E2->isLValue()) {
24454e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie    if (!S.getLangOpts().HeinousExtensions)
2446810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner      S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue)
2447810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner        << E->getSourceRange();
2448810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner    else
2449810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner      S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
2450810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner        << E->getSourceRange();
2451810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner    // Accept, even if we emitted an error diagnostic.
2452810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner    return false;
2453810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner  }
2454810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner
2455810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner  // None of the above, just randomly invalid non-lvalue.
2456810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner  return true;
2457810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner}
2458810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner
2459ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner/// isOperandMentioned - Return true if the specified operand # is mentioned
2460ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner/// anywhere in the decomposed asm string.
2461ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattnerstatic bool isOperandMentioned(unsigned OpNo,
24622d3ba4f5a923a90c3fc290ddfba5e36c2d0a9b46Chris Lattner                         ArrayRef<AsmStmt::AsmStringPiece> AsmStrPieces) {
2463ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner  for (unsigned p = 0, e = AsmStrPieces.size(); p != e; ++p) {
2464ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner    const AsmStmt::AsmStringPiece &Piece = AsmStrPieces[p];
2465ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner    if (!Piece.isOperand()) continue;
24668e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
2467ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner    // If this is a reference to the input and if the input was the smaller
2468ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner    // one, then we have to reject this asm.
2469ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner    if (Piece.getOperandNo() == OpNo)
2470ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner      return true;
2471ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner  }
2472ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner  return false;
2473ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner}
2474810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner
2475ca57b4b7658a031b74cda5ac504311998be8e343Chris LattnerStmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, bool IsSimple,
2476ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner                              bool IsVolatile, unsigned NumOutputs,
2477ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner                              unsigned NumInputs, IdentifierInfo **Names,
2478ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner                              MultiExprArg constraints, MultiExprArg exprs,
2479ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner                              Expr *asmString, MultiExprArg clobbers,
2480ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner                              SourceLocation RParenLoc, bool MSAsm) {
24813037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl  unsigned NumClobbers = clobbers.size();
24823037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl  StringLiteral **Constraints =
24833037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl    reinterpret_cast<StringLiteral**>(constraints.get());
24849ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  Expr **Exprs = exprs.get();
24859ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  StringLiteral *AsmString = cast<StringLiteral>(asmString);
24863037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl  StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.get());
24873037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
24885f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner  SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
24891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
24901708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner  // The parser verifies that there is a string literal here.
24915cee1195584fa8672253139c86e922daeda69b9eDouglas Gregor  if (!AsmString->isAscii())
24923037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl    return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character)
24933037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl      << AsmString->getSourceRange());
24943037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
24951708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner  for (unsigned i = 0; i != NumOutputs; i++) {
24961708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner    StringLiteral *Literal = Constraints[i];
24975cee1195584fa8672253139c86e922daeda69b9eDouglas Gregor    if (!Literal->isAscii())
24983037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl      return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
24993037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl        << Literal->getSourceRange());
25003037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
25015f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner    StringRef OutputName;
2502ff93dbd887e40588ed55d135037bb9287488b285Anders Carlsson    if (Names[i])
2503ff93dbd887e40588ed55d135037bb9287488b285Anders Carlsson      OutputName = Names[i]->getName();
2504ff93dbd887e40588ed55d135037bb9287488b285Anders Carlsson
2505ff93dbd887e40588ed55d135037bb9287488b285Anders Carlsson    TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName);
2506bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor    if (!Context.getTargetInfo().validateOutputConstraint(Info))
25073037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl      return StmtError(Diag(Literal->getLocStart(),
2508432c86969eced2ce658b3f3f2aa7407c8864f21bChris Lattner                            diag::err_asm_invalid_output_constraint)
2509432c86969eced2ce658b3f3f2aa7407c8864f21bChris Lattner                       << Info.getConstraintStr());
25103037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
2511d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson    // Check that the output exprs are valid lvalues.
251272056a237c536ee63285ab0850cb50f299281767Eli Friedman    Expr *OutputExpr = Exprs[i];
2513810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner    if (CheckAsmLValue(OutputExpr, *this)) {
251472056a237c536ee63285ab0850cb50f299281767Eli Friedman      return StmtError(Diag(OutputExpr->getLocStart(),
2515dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner                  diag::err_asm_invalid_lvalue_in_output)
251672056a237c536ee63285ab0850cb50f299281767Eli Friedman        << OutputExpr->getSourceRange());
251704728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson    }
25181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
251944def070435a2b5d67f0534f7a3a85a7389d60f2Chris Lattner    OutputConstraintInfos.push_back(Info);
252004728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson  }
25213037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
25225f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner  SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
2523806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner
252404728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson  for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
25251708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner    StringLiteral *Literal = Constraints[i];
25265cee1195584fa8672253139c86e922daeda69b9eDouglas Gregor    if (!Literal->isAscii())
25273037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl      return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
25283037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl        << Literal->getSourceRange());
25293037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
25305f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner    StringRef InputName;
2531ff93dbd887e40588ed55d135037bb9287488b285Anders Carlsson    if (Names[i])
2532ff93dbd887e40588ed55d135037bb9287488b285Anders Carlsson      InputName = Names[i]->getName();
2533ff93dbd887e40588ed55d135037bb9287488b285Anders Carlsson
2534ff93dbd887e40588ed55d135037bb9287488b285Anders Carlsson    TargetInfo::ConstraintInfo Info(Literal->getString(), InputName);
2535bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor    if (!Context.getTargetInfo().validateInputConstraint(OutputConstraintInfos.data(),
25362819fa85651526d59ade4fdc9da2cadd7b132973Chris Lattner                                                NumOutputs, Info)) {
25373037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl      return StmtError(Diag(Literal->getLocStart(),
2538432c86969eced2ce658b3f3f2aa7407c8864f21bChris Lattner                            diag::err_asm_invalid_input_constraint)
2539432c86969eced2ce658b3f3f2aa7407c8864f21bChris Lattner                       << Info.getConstraintStr());
2540d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson    }
25413037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
254272056a237c536ee63285ab0850cb50f299281767Eli Friedman    Expr *InputExpr = Exprs[i];
25433037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
2544d9fca6e3950346ea503f92f27ed0f9d8edde9febAnders Carlsson    // Only allow void types for memory constraints.
254544def070435a2b5d67f0534f7a3a85a7389d60f2Chris Lattner    if (Info.allowsMemory() && !Info.allowsRegister()) {
2546810f6d5d6223adaab0ccf0139f40de6484ad1bb5Chris Lattner      if (CheckAsmLValue(InputExpr, *this))
254772056a237c536ee63285ab0850cb50f299281767Eli Friedman        return StmtError(Diag(InputExpr->getLocStart(),
2548d9fca6e3950346ea503f92f27ed0f9d8edde9febAnders Carlsson                              diag::err_asm_invalid_lvalue_in_input)
2549432c86969eced2ce658b3f3f2aa7407c8864f21bChris Lattner                         << Info.getConstraintStr()
255072056a237c536ee63285ab0850cb50f299281767Eli Friedman                         << InputExpr->getSourceRange());
255104728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson    }
25523037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
255344def070435a2b5d67f0534f7a3a85a7389d60f2Chris Lattner    if (Info.allowsRegister()) {
2554d9fca6e3950346ea503f92f27ed0f9d8edde9febAnders Carlsson      if (InputExpr->getType()->isVoidType()) {
255572056a237c536ee63285ab0850cb50f299281767Eli Friedman        return StmtError(Diag(InputExpr->getLocStart(),
2556d9fca6e3950346ea503f92f27ed0f9d8edde9febAnders Carlsson                              diag::err_asm_invalid_type_in_input)
25571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump          << InputExpr->getType() << Info.getConstraintStr()
255872056a237c536ee63285ab0850cb50f299281767Eli Friedman          << InputExpr->getSourceRange());
2559d9fca6e3950346ea503f92f27ed0f9d8edde9febAnders Carlsson      }
2560d9fca6e3950346ea503f92f27ed0f9d8edde9febAnders Carlsson    }
25611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2562429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley    ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]);
2563429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley    if (Result.isInvalid())
2564429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley      return StmtError();
25651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2566429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley    Exprs[i] = Result.take();
2567806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner    InputConstraintInfos.push_back(Info);
256804728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson  }
25693037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
25706fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson  // Check that the clobbers are valid.
25711708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner  for (unsigned i = 0; i != NumClobbers; i++) {
25721708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner    StringLiteral *Literal = Clobbers[i];
25735cee1195584fa8672253139c86e922daeda69b9eDouglas Gregor    if (!Literal->isAscii())
25743037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl      return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
25753037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl        << Literal->getSourceRange());
25763037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
25775f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner    StringRef Clobber = Literal->getString();
25783037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
2579bcfd1f55bfbb3e5944cd5e03d07b343e280838c4Douglas Gregor    if (!Context.getTargetInfo().isValidClobber(Clobber))
25803037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl      return StmtError(Diag(Literal->getLocStart(),
25817765934ad7e157b5fcf925792a38e01b1edbcf8aDaniel Dunbar                  diag::err_asm_unknown_register_name) << Clobber);
25826fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson  }
25833037ed0a27dba62e522304183718efc149e8b6d9Sebastian Redl
2584fb5058ef67c054296c88db18ab1b3717845cb71dChris Lattner  AsmStmt *NS =
2585dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi    new (Context) AsmStmt(Context, AsmLoc, IsSimple, IsVolatile, MSAsm,
2586dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi                          NumOutputs, NumInputs, Names, Constraints, Exprs,
2587966146e89141804ff6492739a2a6e6592ca671c7Anders Carlsson                          AsmString, NumClobbers, Clobbers, RParenLoc);
2588fb5058ef67c054296c88db18ab1b3717845cb71dChris Lattner  // Validate the asm string, ensuring it makes sense given the operands we
2589fb5058ef67c054296c88db18ab1b3717845cb71dChris Lattner  // have.
25905f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner  SmallVector<AsmStmt::AsmStringPiece, 8> Pieces;
2591fb5058ef67c054296c88db18ab1b3717845cb71dChris Lattner  unsigned DiagOffs;
2592fb5058ef67c054296c88db18ab1b3717845cb71dChris Lattner  if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
25932ff0f42a962fec5a6300b5986297b417db173e6aChris Lattner    Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
25942ff0f42a962fec5a6300b5986297b417db173e6aChris Lattner           << AsmString->getSourceRange();
2595fb5058ef67c054296c88db18ab1b3717845cb71dChris Lattner    return StmtError();
2596fb5058ef67c054296c88db18ab1b3717845cb71dChris Lattner  }
25971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2598806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner  // Validate tied input operands for type mismatches.
2599806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner  for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
2600806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner    TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
26011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2602806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner    // If this is a tied constraint, verify that the output and input have
2603806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner    // either exactly the same type, or that they are int/ptr operands with the
2604806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner    // same size (int/long, int*/long, are ok etc).
2605806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner    if (!Info.hasTiedOperand()) continue;
26061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2607806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner    unsigned TiedTo = Info.getTiedOperand();
2608935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner    unsigned InputOpNo = i+NumOutputs;
2609f69fcaeb3843297757251a19f0a6f5bbffed7f32Chris Lattner    Expr *OutputExpr = Exprs[TiedTo];
2610935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner    Expr *InputExpr = Exprs[InputOpNo];
2611f45b357c0d0df99e160a6320e279ef788dd91ba6Eli Friedman
2612f45b357c0d0df99e160a6320e279ef788dd91ba6Eli Friedman    if (OutputExpr->isTypeDependent() || InputExpr->isTypeDependent())
2613f45b357c0d0df99e160a6320e279ef788dd91ba6Eli Friedman      continue;
2614f45b357c0d0df99e160a6320e279ef788dd91ba6Eli Friedman
26157adaa18ef3be65971cd41cc61dd739baeb02af10Chris Lattner    QualType InTy = InputExpr->getType();
26167adaa18ef3be65971cd41cc61dd739baeb02af10Chris Lattner    QualType OutTy = OutputExpr->getType();
26177adaa18ef3be65971cd41cc61dd739baeb02af10Chris Lattner    if (Context.hasSameType(InTy, OutTy))
2618806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner      continue;  // All types can be tied to themselves.
26191eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2620aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    // Decide if the input and output are in the same domain (integer/ptr or
2621aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    // floating point.
2622aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    enum AsmDomain {
2623aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner      AD_Int, AD_FP, AD_Other
2624aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    } InputDomain, OutputDomain;
2625dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2626aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    if (InTy->isIntegerType() || InTy->isPointerType())
2627aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner      InputDomain = AD_Int;
26280c293ea13d452c1a47a05ada5a5ee9acc69c66ccDouglas Gregor    else if (InTy->isRealFloatingType())
2629aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner      InputDomain = AD_FP;
2630aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    else
2631aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner      InputDomain = AD_Other;
26323351f1145aa91ddd8022fcd3ca16c219db9e8277Chris Lattner
2633aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    if (OutTy->isIntegerType() || OutTy->isPointerType())
2634aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner      OutputDomain = AD_Int;
26350c293ea13d452c1a47a05ada5a5ee9acc69c66ccDouglas Gregor    else if (OutTy->isRealFloatingType())
2636aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner      OutputDomain = AD_FP;
2637aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    else
2638aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner      OutputDomain = AD_Other;
2639dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2640aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    // They are ok if they are the same size and in the same domain.  This
2641aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    // allows tying things like:
2642aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    //   void* to int*
2643aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    //   void* to int            if they are the same size.
2644aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    //   double to long double   if they are the same size.
2645dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi    //
2646aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    uint64_t OutSize = Context.getTypeSize(OutTy);
2647aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    uint64_t InSize = Context.getTypeSize(InTy);
2648aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    if (OutSize == InSize && InputDomain == OutputDomain &&
2649aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner        InputDomain != AD_Other)
2650aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner      continue;
2651dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
2652aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    // If the smaller input/output operand is not mentioned in the asm string,
2653f0c4d28020fb13fdbf7d6fccfab1b7b6a118ad0eChris Lattner    // then we can promote the smaller one to a larger input and the asm string
2654f0c4d28020fb13fdbf7d6fccfab1b7b6a118ad0eChris Lattner    // won't notice.
2655aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    bool SmallerValueMentioned = false;
26568e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
2657ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner    // If this is a reference to the input and if the input was the smaller
2658ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner    // one, then we have to reject this asm.
2659935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner    if (isOperandMentioned(InputOpNo, Pieces)) {
2660ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner      // This is a use in the asm string of the smaller operand.  Since we
2661ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner      // codegen this by promoting to a wider value, the asm will get printed
2662ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner      // "wrong".
2663f0c4d28020fb13fdbf7d6fccfab1b7b6a118ad0eChris Lattner      SmallerValueMentioned |= InSize < OutSize;
2664ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner    }
2665f0c4d28020fb13fdbf7d6fccfab1b7b6a118ad0eChris Lattner    if (isOperandMentioned(TiedTo, Pieces)) {
2666ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner      // If this is a reference to the output, and if the output is the larger
2667ca57b4b7658a031b74cda5ac504311998be8e343Chris Lattner      // value, then it's ok because we'll promote the input to the larger type.
2668f0c4d28020fb13fdbf7d6fccfab1b7b6a118ad0eChris Lattner      SmallerValueMentioned |= OutSize < InSize;
2669806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner    }
26701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2671aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    // If the smaller value wasn't mentioned in the asm string, and if the
2672aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    // output was a register, just extend the shorter one to the size of the
2673aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    // larger one.
2674aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner    if (!SmallerValueMentioned && InputDomain != AD_Other &&
2675aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner        OutputConstraintInfos[TiedTo].allowsRegister())
2676aab64d0b7f41ed30b15ba9210ed859424cbc7455Chris Lattner      continue;
26778e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
2678935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner    // Either both of the operands were mentioned or the smaller one was
2679935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner    // mentioned.  One more special case that we'll allow: if the tied input is
2680935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner    // integer, unmentioned, and is a constant, then we'll allow truncating it
2681935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner    // down to the size of the destination.
2682935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner    if (InputDomain == AD_Int && OutputDomain == AD_Int &&
2683935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner        !isOperandMentioned(InputOpNo, Pieces) &&
2684935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner        InputExpr->isEvaluatable(Context)) {
26854da89c87b2b6ca31f1015ec19aae65a02971ea9aJohn McCall      CastKind castKind =
26864da89c87b2b6ca31f1015ec19aae65a02971ea9aJohn McCall        (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast);
26874da89c87b2b6ca31f1015ec19aae65a02971ea9aJohn McCall      InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).take();
2688935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner      Exprs[InputOpNo] = InputExpr;
2689935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner      NS->setInputExpr(i, InputExpr);
2690935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner      continue;
2691935f0f01c1ed3c2052b797ac035d57a85b78adc4Chris Lattner    }
26928e1e0543cc3b63e0bc116bae0d2f1e8fc530b436Chad Rosier
2693c1f3b28004a032f4cd13721d4d884c6dcec29c31Chris Lattner    Diag(InputExpr->getLocStart(),
2694806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner         diag::err_asm_tying_incompatible_types)
26957adaa18ef3be65971cd41cc61dd739baeb02af10Chris Lattner      << InTy << OutTy << OutputExpr->getSourceRange()
2696806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner      << InputExpr->getSourceRange();
2697806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner    return StmtError();
2698806503f8c839d7f5ebf3fbf7ee848c179be76dd2Chris Lattner  }
26991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2700fb5058ef67c054296c88db18ab1b3717845cb71dChris Lattner  return Owned(NS);
2701fe795956194141c91ae555985c9b930595bff43fChris Lattner}
27023b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz Jahanian
27038cd64b4c5553fa6284d248336cb7c82dc960a394Chad RosierStmtResult Sema::ActOnMSAsmStmt(SourceLocation AsmLoc,
27048cd64b4c5553fa6284d248336cb7c82dc960a394Chad Rosier                                std::string &AsmString,
27058cd64b4c5553fa6284d248336cb7c82dc960a394Chad Rosier                                SourceLocation EndLoc) {
270652e4ed949ba52958db1e938860e3b49944ce8680Chad Rosier  // MS-style inline assembly is not fully supported, so emit a warning.
270752e4ed949ba52958db1e938860e3b49944ce8680Chad Rosier  Diag(AsmLoc, diag::warn_unsupported_msasm);
270852e4ed949ba52958db1e938860e3b49944ce8680Chad Rosier
27098cd64b4c5553fa6284d248336cb7c82dc960a394Chad Rosier  MSAsmStmt *NS =
27108cd64b4c5553fa6284d248336cb7c82dc960a394Chad Rosier    new (Context) MSAsmStmt(Context, AsmLoc, AsmString, EndLoc);
27118cd64b4c5553fa6284d248336cb7c82dc960a394Chad Rosier
27128cd64b4c5553fa6284d248336cb7c82dc960a394Chad Rosier  return Owned(NS);
27138cd64b4c5553fa6284d248336cb7c82dc960a394Chad Rosier}
27148cd64b4c5553fa6284d248336cb7c82dc960a394Chad Rosier
271560d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
2716431e90e887c21c0d0d56fc12a2d359df8d53ea66Sebastian RedlSema::ActOnObjCAtCatchStmt(SourceLocation AtLoc,
2717d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall                           SourceLocation RParen, Decl *Parm,
27189ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                           Stmt *Body) {
2719d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall  VarDecl *Var = cast_or_null<VarDecl>(Parm);
2720160b5630aa781ac348303e1ae088d27016637778Douglas Gregor  if (Var && Var->isInvalidDecl())
2721160b5630aa781ac348303e1ae088d27016637778Douglas Gregor    return StmtError();
2722dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
27239ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  return Owned(new (Context) ObjCAtCatchStmt(AtLoc, RParen, Var, Body));
27243b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz Jahanian}
27253b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz Jahanian
272660d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
27279ae2f076ca5ab1feb3ba95629099ec2319833701John McCallSema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body) {
27289ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  return Owned(new (Context) ObjCAtFinallyStmt(AtLoc, Body));
2729161a9c5afaafb4d527b7efba9675a8b2cbbe32e0Fariborz Jahanian}
2730bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian
273160d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
2732dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA TakumiSema::ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
27339ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                         MultiStmtArg CatchStmts, Stmt *Finally) {
27344e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie  if (!getLangOpts().ObjCExceptions)
2735da4b7cf09ebfd4e4098b516081fa9dae2f5c99e0Anders Carlsson    Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@try";
2736da4b7cf09ebfd4e4098b516081fa9dae2f5c99e0Anders Carlsson
2737781472fe99a120098c631b0cbe33c89f8cef5e70John McCall  getCurFunction()->setHasBranchProtectedScope();
27388f5e3dd32e443768d9dbbad7191e123e6733750cDouglas Gregor  unsigned NumCatchStmts = CatchStmts.size();
27399ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  return Owned(ObjCAtTryStmt::Create(Context, AtLoc, Try,
27409ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                                     CatchStmts.release(),
27418f5e3dd32e443768d9dbbad7191e123e6733750cDouglas Gregor                                     NumCatchStmts,
27429ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                                     Finally));
2743bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian}
2744bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian
2745d1376ee0945a4eba0590ae33d14bade860b08a7dJohn McCallStmtResult Sema::BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw) {
2746d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor  if (Throw) {
2747429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley    ExprResult Result = DefaultLvalueConversion(Throw);
2748429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley    if (Result.isInvalid())
2749429bb276991ff2dbc7c5b438828b9b7737cb15ebJohn Wiegley      return StmtError();
27505e3c67b4bd894a926282d24b4d0cbc0e123c9f4aJohn McCall
2751d1376ee0945a4eba0590ae33d14bade860b08a7dJohn McCall    Throw = MaybeCreateExprWithCleanups(Result.take());
2752d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor    QualType ThrowType = Throw->getType();
2753d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor    // Make sure the expression type is an ObjC pointer or "void *".
2754d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor    if (!ThrowType->isDependentType() &&
2755d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor        !ThrowType->isObjCObjectPointerType()) {
2756d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor      const PointerType *PT = ThrowType->getAs<PointerType>();
2757d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor      if (!PT || !PT->getPointeeType()->isVoidType())
2758d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor        return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object)
2759d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor                         << Throw->getType() << Throw->getSourceRange());
2760d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor    }
2761d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor  }
2762dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi
27639ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  return Owned(new (Context) ObjCAtThrowStmt(AtLoc, Throw));
2764d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor}
2765d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor
276660d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
2767dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA TakumiSema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
2768d1377b25a36adfe6604f78cbd3a23a07cf0f29e6Douglas Gregor                           Scope *CurScope) {
27694e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie  if (!getLangOpts().ObjCExceptions)
2770da4b7cf09ebfd4e4098b516081fa9dae2f5c99e0Anders Carlsson    Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@throw";
2771da4b7cf09ebfd4e4098b516081fa9dae2f5c99e0Anders Carlsson
27729ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  if (!Throw) {
2773e21dd6ffef4585fa43cd3586ed971217d65bf56cSteve Naroff    // @throw without an expression designates a rethrow (which much occur
2774e21dd6ffef4585fa43cd3586ed971217d65bf56cSteve Naroff    // in the context of an @catch clause).
2775e21dd6ffef4585fa43cd3586ed971217d65bf56cSteve Naroff    Scope *AtCatchParent = CurScope;
2776e21dd6ffef4585fa43cd3586ed971217d65bf56cSteve Naroff    while (AtCatchParent && !AtCatchParent->isAtCatchScope())
2777e21dd6ffef4585fa43cd3586ed971217d65bf56cSteve Naroff      AtCatchParent = AtCatchParent->getParent();
2778e21dd6ffef4585fa43cd3586ed971217d65bf56cSteve Naroff    if (!AtCatchParent)
27794ab2414f297fab1b290e77bfc3b049ccf45eda81Steve Naroff      return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch));
2780dfbb02a16ac8c764b5ba1742450513d6212d2f9fNAKAMURA Takumi  }
27819ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  return BuildObjCAtThrowStmt(AtLoc, Throw);
278239f8f159c488a900e5958d5aab3e467af9ec8a2bFariborz Jahanian}
2783bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian
278407524039dce5c820f111a1b3f772b4261f004b4aJohn McCallExprResult
278507524039dce5c820f111a1b3f772b4261f004b4aJohn McCallSema::ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, Expr *operand) {
278607524039dce5c820f111a1b3f772b4261f004b4aJohn McCall  ExprResult result = DefaultLvalueConversion(operand);
278707524039dce5c820f111a1b3f772b4261f004b4aJohn McCall  if (result.isInvalid())
278807524039dce5c820f111a1b3f772b4261f004b4aJohn McCall    return ExprError();
278907524039dce5c820f111a1b3f772b4261f004b4aJohn McCall  operand = result.take();
27905e3c67b4bd894a926282d24b4d0cbc0e123c9f4aJohn McCall
2791a868a203a18571d091e5d226f5f100d4440f3d94Chris Lattner  // Make sure the expression type is an ObjC pointer or "void *".
279207524039dce5c820f111a1b3f772b4261f004b4aJohn McCall  QualType type = operand->getType();
279307524039dce5c820f111a1b3f772b4261f004b4aJohn McCall  if (!type->isDependentType() &&
279407524039dce5c820f111a1b3f772b4261f004b4aJohn McCall      !type->isObjCObjectPointerType()) {
279507524039dce5c820f111a1b3f772b4261f004b4aJohn McCall    const PointerType *pointerType = type->getAs<PointerType>();
279607524039dce5c820f111a1b3f772b4261f004b4aJohn McCall    if (!pointerType || !pointerType->getPointeeType()->isVoidType())
279707524039dce5c820f111a1b3f772b4261f004b4aJohn McCall      return Diag(atLoc, diag::error_objc_synchronized_expects_object)
279807524039dce5c820f111a1b3f772b4261f004b4aJohn McCall               << type << operand->getSourceRange();
2799a868a203a18571d091e5d226f5f100d4440f3d94Chris Lattner  }
28001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
280107524039dce5c820f111a1b3f772b4261f004b4aJohn McCall  // The operand to @synchronized is a full-expression.
280207524039dce5c820f111a1b3f772b4261f004b4aJohn McCall  return MaybeCreateExprWithCleanups(operand);
280307524039dce5c820f111a1b3f772b4261f004b4aJohn McCall}
280407524039dce5c820f111a1b3f772b4261f004b4aJohn McCall
280507524039dce5c820f111a1b3f772b4261f004b4aJohn McCallStmtResult
280607524039dce5c820f111a1b3f772b4261f004b4aJohn McCallSema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SyncExpr,
280707524039dce5c820f111a1b3f772b4261f004b4aJohn McCall                                  Stmt *SyncBody) {
280807524039dce5c820f111a1b3f772b4261f004b4aJohn McCall  // We can't jump into or indirect-jump out of a @synchronized block.
280907524039dce5c820f111a1b3f772b4261f004b4aJohn McCall  getCurFunction()->setHasBranchProtectedScope();
28109ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc, SyncExpr, SyncBody));
2811fa3ee8e6776634caf064ba5928ca7699d317a280Fariborz Jahanian}
28124b07b2968f87f3cd5a3d8c76145f1cbfd718d42dSebastian Redl
28134b07b2968f87f3cd5a3d8c76145f1cbfd718d42dSebastian Redl/// ActOnCXXCatchBlock - Takes an exception declaration and a handler block
28144b07b2968f87f3cd5a3d8c76145f1cbfd718d42dSebastian Redl/// and creates a proper catch handler from them.
281560d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
2816d226f65006733ed7f709c3174f22ce33391cb58fJohn McCallSema::ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl,
28179ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                         Stmt *HandlerBlock) {
28184b07b2968f87f3cd5a3d8c76145f1cbfd718d42dSebastian Redl  // There's nothing to test that ActOnExceptionDecl didn't already test.
28198189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek  return Owned(new (Context) CXXCatchStmt(CatchLoc,
2820d226f65006733ed7f709c3174f22ce33391cb58fJohn McCall                                          cast_or_null<VarDecl>(ExDecl),
28219ae2f076ca5ab1feb3ba95629099ec2319833701John McCall                                          HandlerBlock));
28224b07b2968f87f3cd5a3d8c76145f1cbfd718d42dSebastian Redl}
28238351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl
2824f85e193739c953358c865005855253af4f68a497John McCallStmtResult
2825f85e193739c953358c865005855253af4f68a497John McCallSema::ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body) {
2826f85e193739c953358c865005855253af4f68a497John McCall  getCurFunction()->setHasBranchProtectedScope();
2827f85e193739c953358c865005855253af4f68a497John McCall  return Owned(new (Context) ObjCAutoreleasePoolStmt(AtLoc, Body));
2828f85e193739c953358c865005855253af4f68a497John McCall}
2829f85e193739c953358c865005855253af4f68a497John McCall
28303c46e8db99196179b30e7ac5c20c4efd5f3926d7Dan Gohmannamespace {
28313c46e8db99196179b30e7ac5c20c4efd5f3926d7Dan Gohman
2832c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redlclass TypeWithHandler {
2833c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  QualType t;
2834c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  CXXCatchStmt *stmt;
2835c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redlpublic:
2836c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  TypeWithHandler(const QualType &type, CXXCatchStmt *statement)
2837c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  : t(type), stmt(statement) {}
2838c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl
28390953e767ff7817f97b3ab20896b229891eeff45bJohn McCall  // An arbitrary order is fine as long as it places identical
28400953e767ff7817f97b3ab20896b229891eeff45bJohn McCall  // types next to each other.
2841c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  bool operator<(const TypeWithHandler &y) const {
28420953e767ff7817f97b3ab20896b229891eeff45bJohn McCall    if (t.getAsOpaquePtr() < y.t.getAsOpaquePtr())
2843c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl      return true;
28440953e767ff7817f97b3ab20896b229891eeff45bJohn McCall    if (t.getAsOpaquePtr() > y.t.getAsOpaquePtr())
2845c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl      return false;
2846c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl    else
2847c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl      return getTypeSpecStartLoc() < y.getTypeSpecStartLoc();
2848c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  }
28491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2850c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  bool operator==(const TypeWithHandler& other) const {
28510953e767ff7817f97b3ab20896b229891eeff45bJohn McCall    return t == other.t;
2852c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  }
28531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2854c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  CXXCatchStmt *getCatchStmt() const { return stmt; }
2855c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  SourceLocation getTypeSpecStartLoc() const {
2856c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl    return stmt->getExceptionDecl()->getTypeSpecStartLoc();
2857c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  }
2858c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl};
2859c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl
28603c46e8db99196179b30e7ac5c20c4efd5f3926d7Dan Gohman}
28613c46e8db99196179b30e7ac5c20c4efd5f3926d7Dan Gohman
28628351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl/// ActOnCXXTryBlock - Takes a try compound-statement and a number of
28638351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl/// handlers and creates a try statement from them.
286460d7b3a319d84d688752be3870615ac0f111fb16John McCallStmtResult
28659ae2f076ca5ab1feb3ba95629099ec2319833701John McCallSema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
28668351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl                       MultiStmtArg RawHandlers) {
2867729b853f4bfa83e53c638a06a9dccf83b4e1f720Anders Carlsson  // Don't report an error if 'try' is used in system headers.
28684e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie  if (!getLangOpts().CXXExceptions &&
2869729b853f4bfa83e53c638a06a9dccf83b4e1f720Anders Carlsson      !getSourceManager().isInSystemHeader(TryLoc))
2870729b853f4bfa83e53c638a06a9dccf83b4e1f720Anders Carlsson      Diag(TryLoc, diag::err_exceptions_disabled) << "try";
28717f11d9cf5df1f8ce82af46eabc4ec5cec7d580b0Anders Carlsson
28728351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl  unsigned NumHandlers = RawHandlers.size();
28738351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl  assert(NumHandlers > 0 &&
28748351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl         "The parser shouldn't call this if there are no handlers.");
28759ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  Stmt **Handlers = RawHandlers.get();
28768351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl
28775f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner  SmallVector<TypeWithHandler, 8> TypesWithHandlers;
28781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
28791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump  for (unsigned i = 0; i < NumHandlers; ++i) {
28805f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner    CXXCatchStmt *Handler = cast<CXXCatchStmt>(Handlers[i]);
2881c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl    if (!Handler->getExceptionDecl()) {
2882c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl      if (i < NumHandlers - 1)
2883c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl        return StmtError(Diag(Handler->getLocStart(),
2884c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl                              diag::err_early_catch_all));
28851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2886c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl      continue;
2887c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl    }
28881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2889c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl    const QualType CaughtType = Handler->getCaughtType();
2890c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl    const QualType CanonicalCaughtType = Context.getCanonicalType(CaughtType);
2891c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl    TypesWithHandlers.push_back(TypeWithHandler(CanonicalCaughtType, Handler));
2892c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  }
2893c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl
2894c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  // Detect handlers for the same type as an earlier one.
2895c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl  if (NumHandlers > 1) {
2896c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl    llvm::array_pod_sort(TypesWithHandlers.begin(), TypesWithHandlers.end());
28971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2898c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl    TypeWithHandler prev = TypesWithHandlers[0];
2899c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl    for (unsigned i = 1; i < TypesWithHandlers.size(); ++i) {
2900c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl      TypeWithHandler curr = TypesWithHandlers[i];
29011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2902c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl      if (curr == prev) {
2903c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl        Diag(curr.getTypeSpecStartLoc(),
2904c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl             diag::warn_exception_caught_by_earlier_handler)
2905c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl          << curr.getCatchStmt()->getCaughtType().getAsString();
2906c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl        Diag(prev.getTypeSpecStartLoc(),
2907c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl             diag::note_previous_exception_handler)
2908c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl          << prev.getCatchStmt()->getCaughtType().getAsString();
2909c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl      }
29101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2911c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl      prev = curr;
2912c447aba04527a71d254b151f79f444d1cbe83ce9Sebastian Redl    }
29138351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl  }
29141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump
2915781472fe99a120098c631b0cbe33c89f8cef5e70John McCall  getCurFunction()->setHasBranchProtectedScope();
2916b60a77e453d32db0ab1914d28e175c2defc0eb65John McCall
29178351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl  // FIXME: We should detect handlers that cannot catch anything because an
29188351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl  // earlier handler catches a superclass. Need to find a method that is not
29198351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl  // quadratic for this.
29208351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl  // Neither of these are explicitly forbidden, but every compiler detects them
29218351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl  // and warns.
29228351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl
29239ae2f076ca5ab1feb3ba95629099ec2319833701John McCall  return Owned(CXXTryStmt::Create(Context, TryLoc, TryBlock,
2924a1a396df16c02b22983b5c9592022fd9237d4866Sam Weinig                                  Handlers, NumHandlers));
29258351da06ca3082dfd49dd8e3c1785a986920f57cSebastian Redl}
292628bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley
292728bbe4b8acc338476fe0825769b41fb32b423c72John WiegleyStmtResult
292828bbe4b8acc338476fe0825769b41fb32b423c72John WiegleySema::ActOnSEHTryBlock(bool IsCXXTry,
292928bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley                       SourceLocation TryLoc,
293028bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley                       Stmt *TryBlock,
293128bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley                       Stmt *Handler) {
293228bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley  assert(TryBlock && Handler);
293328bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley
293428bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley  getCurFunction()->setHasBranchProtectedScope();
293528bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley
293628bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley  return Owned(SEHTryStmt::Create(Context,IsCXXTry,TryLoc,TryBlock,Handler));
293728bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley}
293828bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley
293928bbe4b8acc338476fe0825769b41fb32b423c72John WiegleyStmtResult
294028bbe4b8acc338476fe0825769b41fb32b423c72John WiegleySema::ActOnSEHExceptBlock(SourceLocation Loc,
294128bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley                          Expr *FilterExpr,
294228bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley                          Stmt *Block) {
294328bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley  assert(FilterExpr && Block);
294428bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley
294528bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley  if(!FilterExpr->getType()->isIntegerType()) {
294658f14c012e5d739b09532bb12645dc161f88cfcfFrancois Pichet    return StmtError(Diag(FilterExpr->getExprLoc(),
294758f14c012e5d739b09532bb12645dc161f88cfcfFrancois Pichet                     diag::err_filter_expression_integral)
294858f14c012e5d739b09532bb12645dc161f88cfcfFrancois Pichet                     << FilterExpr->getType());
294928bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley  }
295028bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley
295128bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley  return Owned(SEHExceptStmt::Create(Context,Loc,FilterExpr,Block));
295228bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley}
295328bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley
295428bbe4b8acc338476fe0825769b41fb32b423c72John WiegleyStmtResult
295528bbe4b8acc338476fe0825769b41fb32b423c72John WiegleySema::ActOnSEHFinallyBlock(SourceLocation Loc,
295628bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley                           Stmt *Block) {
295728bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley  assert(Block);
295828bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley  return Owned(SEHFinallyStmt::Create(Context,Loc,Block));
295928bbe4b8acc338476fe0825769b41fb32b423c72John Wiegley}
2960ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor
2961ba0513de93d2fab6db5ab30b6927209fcc883078Douglas GregorStmtResult Sema::BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
2962ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                            bool IsIfExists,
2963ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                            NestedNameSpecifierLoc QualifierLoc,
2964ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                            DeclarationNameInfo NameInfo,
2965ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                            Stmt *Nested)
2966ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor{
2967ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor  return new (Context) MSDependentExistsStmt(KeywordLoc, IsIfExists,
2968ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                             QualifierLoc, NameInfo,
2969ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                             cast<CompoundStmt>(Nested));
2970ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor}
2971ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor
2972ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor
2973ba0513de93d2fab6db5ab30b6927209fcc883078Douglas GregorStmtResult Sema::ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,
2974ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                            bool IsIfExists,
2975ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                            CXXScopeSpec &SS,
2976ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                            UnqualifiedId &Name,
2977ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                            Stmt *Nested) {
2978ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor  return BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
2979ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                    SS.getWithLocInContext(Context),
2980ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                    GetNameFromUnqualifiedId(Name),
2981ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor                                    Nested);
2982ba0513de93d2fab6db5ab30b6927209fcc883078Douglas Gregor}
2983