1//===--- ParseStmt.cpp - Statement and Block Parser -----------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Statement and Block portions of the Parser
11// interface.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/Parse/Parser.h"
16#include "RAIIObjectsForParser.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/Basic/Attributes.h"
19#include "clang/Basic/Diagnostic.h"
20#include "clang/Basic/PrettyStackTrace.h"
21#include "clang/Sema/DeclSpec.h"
22#include "clang/Sema/LoopHint.h"
23#include "clang/Sema/PrettyDeclStackTrace.h"
24#include "clang/Sema/Scope.h"
25#include "clang/Sema/TypoCorrection.h"
26#include "llvm/ADT/SmallString.h"
27using namespace clang;
28
29//===----------------------------------------------------------------------===//
30// C99 6.8: Statements and Blocks.
31//===----------------------------------------------------------------------===//
32
33/// \brief Parse a standalone statement (for instance, as the body of an 'if',
34/// 'while', or 'for').
35StmtResult Parser::ParseStatement(SourceLocation *TrailingElseLoc) {
36  StmtResult Res;
37
38  // We may get back a null statement if we found a #pragma. Keep going until
39  // we get an actual statement.
40  do {
41    StmtVector Stmts;
42    Res = ParseStatementOrDeclaration(Stmts, true, TrailingElseLoc);
43  } while (!Res.isInvalid() && !Res.get());
44
45  return Res;
46}
47
48/// ParseStatementOrDeclaration - Read 'statement' or 'declaration'.
49///       StatementOrDeclaration:
50///         statement
51///         declaration
52///
53///       statement:
54///         labeled-statement
55///         compound-statement
56///         expression-statement
57///         selection-statement
58///         iteration-statement
59///         jump-statement
60/// [C++]   declaration-statement
61/// [C++]   try-block
62/// [MS]    seh-try-block
63/// [OBC]   objc-throw-statement
64/// [OBC]   objc-try-catch-statement
65/// [OBC]   objc-synchronized-statement
66/// [GNU]   asm-statement
67/// [OMP]   openmp-construct             [TODO]
68///
69///       labeled-statement:
70///         identifier ':' statement
71///         'case' constant-expression ':' statement
72///         'default' ':' statement
73///
74///       selection-statement:
75///         if-statement
76///         switch-statement
77///
78///       iteration-statement:
79///         while-statement
80///         do-statement
81///         for-statement
82///
83///       expression-statement:
84///         expression[opt] ';'
85///
86///       jump-statement:
87///         'goto' identifier ';'
88///         'continue' ';'
89///         'break' ';'
90///         'return' expression[opt] ';'
91/// [GNU]   'goto' '*' expression ';'
92///
93/// [OBC] objc-throw-statement:
94/// [OBC]   '@' 'throw' expression ';'
95/// [OBC]   '@' 'throw' ';'
96///
97StmtResult
98Parser::ParseStatementOrDeclaration(StmtVector &Stmts, bool OnlyStatement,
99                                    SourceLocation *TrailingElseLoc) {
100
101  ParenBraceBracketBalancer BalancerRAIIObj(*this);
102
103  ParsedAttributesWithRange Attrs(AttrFactory);
104  MaybeParseCXX11Attributes(Attrs, nullptr, /*MightBeObjCMessageSend*/ true);
105
106  StmtResult Res = ParseStatementOrDeclarationAfterAttributes(Stmts,
107                                 OnlyStatement, TrailingElseLoc, Attrs);
108
109  assert((Attrs.empty() || Res.isInvalid() || Res.isUsable()) &&
110         "attributes on empty statement");
111
112  if (Attrs.empty() || Res.isInvalid())
113    return Res;
114
115  return Actions.ProcessStmtAttributes(Res.get(), Attrs.getList(), Attrs.Range);
116}
117
118namespace {
119class StatementFilterCCC : public CorrectionCandidateCallback {
120public:
121  StatementFilterCCC(Token nextTok) : NextToken(nextTok) {
122    WantTypeSpecifiers = nextTok.is(tok::l_paren) || nextTok.is(tok::less) ||
123                         nextTok.is(tok::identifier) || nextTok.is(tok::star) ||
124                         nextTok.is(tok::amp) || nextTok.is(tok::l_square);
125    WantExpressionKeywords = nextTok.is(tok::l_paren) ||
126                             nextTok.is(tok::identifier) ||
127                             nextTok.is(tok::arrow) || nextTok.is(tok::period);
128    WantRemainingKeywords = nextTok.is(tok::l_paren) || nextTok.is(tok::semi) ||
129                            nextTok.is(tok::identifier) ||
130                            nextTok.is(tok::l_brace);
131    WantCXXNamedCasts = false;
132  }
133
134  bool ValidateCandidate(const TypoCorrection &candidate) override {
135    if (FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>())
136      return !candidate.getCorrectionSpecifier() || isa<ObjCIvarDecl>(FD);
137    if (NextToken.is(tok::equal))
138      return candidate.getCorrectionDeclAs<VarDecl>();
139    if (NextToken.is(tok::period) &&
140        candidate.getCorrectionDeclAs<NamespaceDecl>())
141      return false;
142    return CorrectionCandidateCallback::ValidateCandidate(candidate);
143  }
144
145private:
146  Token NextToken;
147};
148}
149
150StmtResult
151Parser::ParseStatementOrDeclarationAfterAttributes(StmtVector &Stmts,
152          bool OnlyStatement, SourceLocation *TrailingElseLoc,
153          ParsedAttributesWithRange &Attrs) {
154  const char *SemiError = nullptr;
155  StmtResult Res;
156
157  // Cases in this switch statement should fall through if the parser expects
158  // the token to end in a semicolon (in which case SemiError should be set),
159  // or they directly 'return;' if not.
160Retry:
161  tok::TokenKind Kind  = Tok.getKind();
162  SourceLocation AtLoc;
163  switch (Kind) {
164  case tok::at: // May be a @try or @throw statement
165    {
166      ProhibitAttributes(Attrs); // TODO: is it correct?
167      AtLoc = ConsumeToken();  // consume @
168      return ParseObjCAtStatement(AtLoc);
169    }
170
171  case tok::code_completion:
172    Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Statement);
173    cutOffParsing();
174    return StmtError();
175
176  case tok::identifier: {
177    Token Next = NextToken();
178    if (Next.is(tok::colon)) { // C99 6.8.1: labeled-statement
179      // identifier ':' statement
180      return ParseLabeledStatement(Attrs);
181    }
182
183    // Look up the identifier, and typo-correct it to a keyword if it's not
184    // found.
185    if (Next.isNot(tok::coloncolon)) {
186      // Try to limit which sets of keywords should be included in typo
187      // correction based on what the next token is.
188      if (TryAnnotateName(/*IsAddressOfOperand*/ false,
189                          llvm::make_unique<StatementFilterCCC>(Next)) ==
190          ANK_Error) {
191        // Handle errors here by skipping up to the next semicolon or '}', and
192        // eat the semicolon if that's what stopped us.
193        SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
194        if (Tok.is(tok::semi))
195          ConsumeToken();
196        return StmtError();
197      }
198
199      // If the identifier was typo-corrected, try again.
200      if (Tok.isNot(tok::identifier))
201        goto Retry;
202    }
203
204    // Fall through
205  }
206
207  default: {
208    if ((getLangOpts().CPlusPlus || !OnlyStatement) && isDeclarationStatement()) {
209      SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
210      DeclGroupPtrTy Decl = ParseDeclaration(Declarator::BlockContext,
211                                             DeclEnd, Attrs);
212      return Actions.ActOnDeclStmt(Decl, DeclStart, DeclEnd);
213    }
214
215    if (Tok.is(tok::r_brace)) {
216      Diag(Tok, diag::err_expected_statement);
217      return StmtError();
218    }
219
220    return ParseExprStatement();
221  }
222
223  case tok::kw_case:                // C99 6.8.1: labeled-statement
224    return ParseCaseStatement();
225  case tok::kw_default:             // C99 6.8.1: labeled-statement
226    return ParseDefaultStatement();
227
228  case tok::l_brace:                // C99 6.8.2: compound-statement
229    return ParseCompoundStatement();
230  case tok::semi: {                 // C99 6.8.3p3: expression[opt] ';'
231    bool HasLeadingEmptyMacro = Tok.hasLeadingEmptyMacro();
232    return Actions.ActOnNullStmt(ConsumeToken(), HasLeadingEmptyMacro);
233  }
234
235  case tok::kw_if:                  // C99 6.8.4.1: if-statement
236    return ParseIfStatement(TrailingElseLoc);
237  case tok::kw_switch:              // C99 6.8.4.2: switch-statement
238    return ParseSwitchStatement(TrailingElseLoc);
239
240  case tok::kw_while:               // C99 6.8.5.1: while-statement
241    return ParseWhileStatement(TrailingElseLoc);
242  case tok::kw_do:                  // C99 6.8.5.2: do-statement
243    Res = ParseDoStatement();
244    SemiError = "do/while";
245    break;
246  case tok::kw_for:                 // C99 6.8.5.3: for-statement
247    return ParseForStatement(TrailingElseLoc);
248
249  case tok::kw_goto:                // C99 6.8.6.1: goto-statement
250    Res = ParseGotoStatement();
251    SemiError = "goto";
252    break;
253  case tok::kw_continue:            // C99 6.8.6.2: continue-statement
254    Res = ParseContinueStatement();
255    SemiError = "continue";
256    break;
257  case tok::kw_break:               // C99 6.8.6.3: break-statement
258    Res = ParseBreakStatement();
259    SemiError = "break";
260    break;
261  case tok::kw_return:              // C99 6.8.6.4: return-statement
262    Res = ParseReturnStatement();
263    SemiError = "return";
264    break;
265
266  case tok::kw_asm: {
267    ProhibitAttributes(Attrs);
268    bool msAsm = false;
269    Res = ParseAsmStatement(msAsm);
270    Res = Actions.ActOnFinishFullStmt(Res.get());
271    if (msAsm) return Res;
272    SemiError = "asm";
273    break;
274  }
275
276  case tok::kw___if_exists:
277  case tok::kw___if_not_exists:
278    ProhibitAttributes(Attrs);
279    ParseMicrosoftIfExistsStatement(Stmts);
280    // An __if_exists block is like a compound statement, but it doesn't create
281    // a new scope.
282    return StmtEmpty();
283
284  case tok::kw_try:                 // C++ 15: try-block
285    return ParseCXXTryBlock();
286
287  case tok::kw___try:
288    ProhibitAttributes(Attrs); // TODO: is it correct?
289    return ParseSEHTryBlock();
290
291  case tok::kw___leave:
292    Res = ParseSEHLeaveStatement();
293    SemiError = "__leave";
294    break;
295
296  case tok::annot_pragma_vis:
297    ProhibitAttributes(Attrs);
298    HandlePragmaVisibility();
299    return StmtEmpty();
300
301  case tok::annot_pragma_pack:
302    ProhibitAttributes(Attrs);
303    HandlePragmaPack();
304    return StmtEmpty();
305
306  case tok::annot_pragma_msstruct:
307    ProhibitAttributes(Attrs);
308    HandlePragmaMSStruct();
309    return StmtEmpty();
310
311  case tok::annot_pragma_align:
312    ProhibitAttributes(Attrs);
313    HandlePragmaAlign();
314    return StmtEmpty();
315
316  case tok::annot_pragma_weak:
317    ProhibitAttributes(Attrs);
318    HandlePragmaWeak();
319    return StmtEmpty();
320
321  case tok::annot_pragma_weakalias:
322    ProhibitAttributes(Attrs);
323    HandlePragmaWeakAlias();
324    return StmtEmpty();
325
326  case tok::annot_pragma_redefine_extname:
327    ProhibitAttributes(Attrs);
328    HandlePragmaRedefineExtname();
329    return StmtEmpty();
330
331  case tok::annot_pragma_fp_contract:
332    ProhibitAttributes(Attrs);
333    Diag(Tok, diag::err_pragma_fp_contract_scope);
334    ConsumeToken();
335    return StmtError();
336
337  case tok::annot_pragma_opencl_extension:
338    ProhibitAttributes(Attrs);
339    HandlePragmaOpenCLExtension();
340    return StmtEmpty();
341
342  case tok::annot_pragma_captured:
343    ProhibitAttributes(Attrs);
344    return HandlePragmaCaptured();
345
346  case tok::annot_pragma_openmp:
347    ProhibitAttributes(Attrs);
348    return ParseOpenMPDeclarativeOrExecutableDirective(!OnlyStatement);
349
350  case tok::annot_pragma_ms_pointers_to_members:
351    ProhibitAttributes(Attrs);
352    HandlePragmaMSPointersToMembers();
353    return StmtEmpty();
354
355  case tok::annot_pragma_ms_pragma:
356    ProhibitAttributes(Attrs);
357    HandlePragmaMSPragma();
358    return StmtEmpty();
359
360  case tok::annot_pragma_loop_hint:
361    ProhibitAttributes(Attrs);
362    return ParsePragmaLoopHint(Stmts, OnlyStatement, TrailingElseLoc, Attrs);
363  }
364
365  // If we reached this code, the statement must end in a semicolon.
366  if (!TryConsumeToken(tok::semi) && !Res.isInvalid()) {
367    // If the result was valid, then we do want to diagnose this.  Use
368    // ExpectAndConsume to emit the diagnostic, even though we know it won't
369    // succeed.
370    ExpectAndConsume(tok::semi, diag::err_expected_semi_after_stmt, SemiError);
371    // Skip until we see a } or ;, but don't eat it.
372    SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
373  }
374
375  return Res;
376}
377
378/// \brief Parse an expression statement.
379StmtResult Parser::ParseExprStatement() {
380  // If a case keyword is missing, this is where it should be inserted.
381  Token OldToken = Tok;
382
383  // expression[opt] ';'
384  ExprResult Expr(ParseExpression());
385  if (Expr.isInvalid()) {
386    // If the expression is invalid, skip ahead to the next semicolon or '}'.
387    // Not doing this opens us up to the possibility of infinite loops if
388    // ParseExpression does not consume any tokens.
389    SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
390    if (Tok.is(tok::semi))
391      ConsumeToken();
392    return Actions.ActOnExprStmtError();
393  }
394
395  if (Tok.is(tok::colon) && getCurScope()->isSwitchScope() &&
396      Actions.CheckCaseExpression(Expr.get())) {
397    // If a constant expression is followed by a colon inside a switch block,
398    // suggest a missing case keyword.
399    Diag(OldToken, diag::err_expected_case_before_expression)
400      << FixItHint::CreateInsertion(OldToken.getLocation(), "case ");
401
402    // Recover parsing as a case statement.
403    return ParseCaseStatement(/*MissingCase=*/true, Expr);
404  }
405
406  // Otherwise, eat the semicolon.
407  ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
408  return Actions.ActOnExprStmt(Expr);
409}
410
411/// ParseSEHTryBlockCommon
412///
413/// seh-try-block:
414///   '__try' compound-statement seh-handler
415///
416/// seh-handler:
417///   seh-except-block
418///   seh-finally-block
419///
420StmtResult Parser::ParseSEHTryBlock() {
421  assert(Tok.is(tok::kw___try) && "Expected '__try'");
422  SourceLocation TryLoc = ConsumeToken();
423
424  if (Tok.isNot(tok::l_brace))
425    return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
426
427  StmtResult TryBlock(ParseCompoundStatement(/*isStmtExpr=*/false,
428                      Scope::DeclScope | Scope::SEHTryScope));
429  if(TryBlock.isInvalid())
430    return TryBlock;
431
432  StmtResult Handler;
433  if (Tok.is(tok::identifier) &&
434      Tok.getIdentifierInfo() == getSEHExceptKeyword()) {
435    SourceLocation Loc = ConsumeToken();
436    Handler = ParseSEHExceptBlock(Loc);
437  } else if (Tok.is(tok::kw___finally)) {
438    SourceLocation Loc = ConsumeToken();
439    Handler = ParseSEHFinallyBlock(Loc);
440  } else {
441    return StmtError(Diag(Tok, diag::err_seh_expected_handler));
442  }
443
444  if(Handler.isInvalid())
445    return Handler;
446
447  return Actions.ActOnSEHTryBlock(false /* IsCXXTry */,
448                                  TryLoc,
449                                  TryBlock.get(),
450                                  Handler.get());
451}
452
453/// ParseSEHExceptBlock - Handle __except
454///
455/// seh-except-block:
456///   '__except' '(' seh-filter-expression ')' compound-statement
457///
458StmtResult Parser::ParseSEHExceptBlock(SourceLocation ExceptLoc) {
459  PoisonIdentifierRAIIObject raii(Ident__exception_code, false),
460    raii2(Ident___exception_code, false),
461    raii3(Ident_GetExceptionCode, false);
462
463  if (ExpectAndConsume(tok::l_paren))
464    return StmtError();
465
466  ParseScope ExpectScope(this, Scope::DeclScope | Scope::ControlScope |
467                                   Scope::SEHExceptScope);
468
469  if (getLangOpts().Borland) {
470    Ident__exception_info->setIsPoisoned(false);
471    Ident___exception_info->setIsPoisoned(false);
472    Ident_GetExceptionInfo->setIsPoisoned(false);
473  }
474
475  ExprResult FilterExpr;
476  {
477    ParseScopeFlags FilterScope(this, getCurScope()->getFlags() |
478                                          Scope::SEHFilterScope);
479    FilterExpr = Actions.CorrectDelayedTyposInExpr(ParseExpression());
480  }
481
482  if (getLangOpts().Borland) {
483    Ident__exception_info->setIsPoisoned(true);
484    Ident___exception_info->setIsPoisoned(true);
485    Ident_GetExceptionInfo->setIsPoisoned(true);
486  }
487
488  if(FilterExpr.isInvalid())
489    return StmtError();
490
491  if (ExpectAndConsume(tok::r_paren))
492    return StmtError();
493
494  if (Tok.isNot(tok::l_brace))
495    return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
496
497  StmtResult Block(ParseCompoundStatement());
498
499  if(Block.isInvalid())
500    return Block;
501
502  return Actions.ActOnSEHExceptBlock(ExceptLoc, FilterExpr.get(), Block.get());
503}
504
505/// ParseSEHFinallyBlock - Handle __finally
506///
507/// seh-finally-block:
508///   '__finally' compound-statement
509///
510StmtResult Parser::ParseSEHFinallyBlock(SourceLocation FinallyLoc) {
511  PoisonIdentifierRAIIObject raii(Ident__abnormal_termination, false),
512    raii2(Ident___abnormal_termination, false),
513    raii3(Ident_AbnormalTermination, false);
514
515  if (Tok.isNot(tok::l_brace))
516    return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
517
518  ParseScope FinallyScope(this, 0);
519  Actions.ActOnStartSEHFinallyBlock();
520
521  StmtResult Block(ParseCompoundStatement());
522  if(Block.isInvalid()) {
523    Actions.ActOnAbortSEHFinallyBlock();
524    return Block;
525  }
526
527  return Actions.ActOnFinishSEHFinallyBlock(FinallyLoc, Block.get());
528}
529
530/// Handle __leave
531///
532/// seh-leave-statement:
533///   '__leave' ';'
534///
535StmtResult Parser::ParseSEHLeaveStatement() {
536  SourceLocation LeaveLoc = ConsumeToken();  // eat the '__leave'.
537  return Actions.ActOnSEHLeaveStmt(LeaveLoc, getCurScope());
538}
539
540/// ParseLabeledStatement - We have an identifier and a ':' after it.
541///
542///       labeled-statement:
543///         identifier ':' statement
544/// [GNU]   identifier ':' attributes[opt] statement
545///
546StmtResult Parser::ParseLabeledStatement(ParsedAttributesWithRange &attrs) {
547  assert(Tok.is(tok::identifier) && Tok.getIdentifierInfo() &&
548         "Not an identifier!");
549
550  Token IdentTok = Tok;  // Save the whole token.
551  ConsumeToken();  // eat the identifier.
552
553  assert(Tok.is(tok::colon) && "Not a label!");
554
555  // identifier ':' statement
556  SourceLocation ColonLoc = ConsumeToken();
557
558  // Read label attributes, if present.
559  StmtResult SubStmt;
560  if (Tok.is(tok::kw___attribute)) {
561    ParsedAttributesWithRange TempAttrs(AttrFactory);
562    ParseGNUAttributes(TempAttrs);
563
564    // In C++, GNU attributes only apply to the label if they are followed by a
565    // semicolon, to disambiguate label attributes from attributes on a labeled
566    // declaration.
567    //
568    // This doesn't quite match what GCC does; if the attribute list is empty
569    // and followed by a semicolon, GCC will reject (it appears to parse the
570    // attributes as part of a statement in that case). That looks like a bug.
571    if (!getLangOpts().CPlusPlus || Tok.is(tok::semi))
572      attrs.takeAllFrom(TempAttrs);
573    else if (isDeclarationStatement()) {
574      StmtVector Stmts;
575      // FIXME: We should do this whether or not we have a declaration
576      // statement, but that doesn't work correctly (because ProhibitAttributes
577      // can't handle GNU attributes), so only call it in the one case where
578      // GNU attributes are allowed.
579      SubStmt = ParseStatementOrDeclarationAfterAttributes(
580          Stmts, /*OnlyStmts*/ true, nullptr, TempAttrs);
581      if (!TempAttrs.empty() && !SubStmt.isInvalid())
582        SubStmt = Actions.ProcessStmtAttributes(
583            SubStmt.get(), TempAttrs.getList(), TempAttrs.Range);
584    } else {
585      Diag(Tok, diag::err_expected_after) << "__attribute__" << tok::semi;
586    }
587  }
588
589  // If we've not parsed a statement yet, parse one now.
590  if (!SubStmt.isInvalid() && !SubStmt.isUsable())
591    SubStmt = ParseStatement();
592
593  // Broken substmt shouldn't prevent the label from being added to the AST.
594  if (SubStmt.isInvalid())
595    SubStmt = Actions.ActOnNullStmt(ColonLoc);
596
597  LabelDecl *LD = Actions.LookupOrCreateLabel(IdentTok.getIdentifierInfo(),
598                                              IdentTok.getLocation());
599  if (AttributeList *Attrs = attrs.getList()) {
600    Actions.ProcessDeclAttributeList(Actions.CurScope, LD, Attrs);
601    attrs.clear();
602  }
603
604  return Actions.ActOnLabelStmt(IdentTok.getLocation(), LD, ColonLoc,
605                                SubStmt.get());
606}
607
608/// ParseCaseStatement
609///       labeled-statement:
610///         'case' constant-expression ':' statement
611/// [GNU]   'case' constant-expression '...' constant-expression ':' statement
612///
613StmtResult Parser::ParseCaseStatement(bool MissingCase, ExprResult Expr) {
614  assert((MissingCase || Tok.is(tok::kw_case)) && "Not a case stmt!");
615
616  // It is very very common for code to contain many case statements recursively
617  // nested, as in (but usually without indentation):
618  //  case 1:
619  //    case 2:
620  //      case 3:
621  //         case 4:
622  //           case 5: etc.
623  //
624  // Parsing this naively works, but is both inefficient and can cause us to run
625  // out of stack space in our recursive descent parser.  As a special case,
626  // flatten this recursion into an iterative loop.  This is complex and gross,
627  // but all the grossness is constrained to ParseCaseStatement (and some
628  // weirdness in the actions), so this is just local grossness :).
629
630  // TopLevelCase - This is the highest level we have parsed.  'case 1' in the
631  // example above.
632  StmtResult TopLevelCase(true);
633
634  // DeepestParsedCaseStmt - This is the deepest statement we have parsed, which
635  // gets updated each time a new case is parsed, and whose body is unset so
636  // far.  When parsing 'case 4', this is the 'case 3' node.
637  Stmt *DeepestParsedCaseStmt = nullptr;
638
639  // While we have case statements, eat and stack them.
640  SourceLocation ColonLoc;
641  do {
642    SourceLocation CaseLoc = MissingCase ? Expr.get()->getExprLoc() :
643                                           ConsumeToken();  // eat the 'case'.
644    ColonLoc = SourceLocation();
645
646    if (Tok.is(tok::code_completion)) {
647      Actions.CodeCompleteCase(getCurScope());
648      cutOffParsing();
649      return StmtError();
650    }
651
652    /// We don't want to treat 'case x : y' as a potential typo for 'case x::y'.
653    /// Disable this form of error recovery while we're parsing the case
654    /// expression.
655    ColonProtectionRAIIObject ColonProtection(*this);
656
657    ExprResult LHS;
658    if (!MissingCase) {
659      LHS = ParseConstantExpression();
660      if (!getLangOpts().CPlusPlus11) {
661        LHS = Actions.CorrectDelayedTyposInExpr(LHS, [this](class Expr *E) {
662          return Actions.VerifyIntegerConstantExpression(E);
663        });
664      }
665      if (LHS.isInvalid()) {
666        // If constant-expression is parsed unsuccessfully, recover by skipping
667        // current case statement (moving to the colon that ends it).
668        if (SkipUntil(tok::colon, tok::r_brace, StopAtSemi | StopBeforeMatch)) {
669          TryConsumeToken(tok::colon, ColonLoc);
670          continue;
671        }
672        return StmtError();
673      }
674    } else {
675      LHS = Expr;
676      MissingCase = false;
677    }
678
679    // GNU case range extension.
680    SourceLocation DotDotDotLoc;
681    ExprResult RHS;
682    if (TryConsumeToken(tok::ellipsis, DotDotDotLoc)) {
683      Diag(DotDotDotLoc, diag::ext_gnu_case_range);
684      RHS = ParseConstantExpression();
685      if (RHS.isInvalid()) {
686        if (SkipUntil(tok::colon, tok::r_brace, StopAtSemi | StopBeforeMatch)) {
687          TryConsumeToken(tok::colon, ColonLoc);
688          continue;
689        }
690        return StmtError();
691      }
692    }
693
694    ColonProtection.restore();
695
696    if (TryConsumeToken(tok::colon, ColonLoc)) {
697    } else if (TryConsumeToken(tok::semi, ColonLoc) ||
698               TryConsumeToken(tok::coloncolon, ColonLoc)) {
699      // Treat "case blah;" or "case blah::" as a typo for "case blah:".
700      Diag(ColonLoc, diag::err_expected_after)
701          << "'case'" << tok::colon
702          << FixItHint::CreateReplacement(ColonLoc, ":");
703    } else {
704      SourceLocation ExpectedLoc = PP.getLocForEndOfToken(PrevTokLocation);
705      Diag(ExpectedLoc, diag::err_expected_after)
706          << "'case'" << tok::colon
707          << FixItHint::CreateInsertion(ExpectedLoc, ":");
708      ColonLoc = ExpectedLoc;
709    }
710
711    StmtResult Case =
712      Actions.ActOnCaseStmt(CaseLoc, LHS.get(), DotDotDotLoc,
713                            RHS.get(), ColonLoc);
714
715    // If we had a sema error parsing this case, then just ignore it and
716    // continue parsing the sub-stmt.
717    if (Case.isInvalid()) {
718      if (TopLevelCase.isInvalid())  // No parsed case stmts.
719        return ParseStatement();
720      // Otherwise, just don't add it as a nested case.
721    } else {
722      // If this is the first case statement we parsed, it becomes TopLevelCase.
723      // Otherwise we link it into the current chain.
724      Stmt *NextDeepest = Case.get();
725      if (TopLevelCase.isInvalid())
726        TopLevelCase = Case;
727      else
728        Actions.ActOnCaseStmtBody(DeepestParsedCaseStmt, Case.get());
729      DeepestParsedCaseStmt = NextDeepest;
730    }
731
732    // Handle all case statements.
733  } while (Tok.is(tok::kw_case));
734
735  // If we found a non-case statement, start by parsing it.
736  StmtResult SubStmt;
737
738  if (Tok.isNot(tok::r_brace)) {
739    SubStmt = ParseStatement();
740  } else {
741    // Nicely diagnose the common error "switch (X) { case 4: }", which is
742    // not valid.  If ColonLoc doesn't point to a valid text location, there was
743    // another parsing error, so avoid producing extra diagnostics.
744    if (ColonLoc.isValid()) {
745      SourceLocation AfterColonLoc = PP.getLocForEndOfToken(ColonLoc);
746      Diag(AfterColonLoc, diag::err_label_end_of_compound_statement)
747        << FixItHint::CreateInsertion(AfterColonLoc, " ;");
748    }
749    SubStmt = StmtError();
750  }
751
752  // Install the body into the most deeply-nested case.
753  if (DeepestParsedCaseStmt) {
754    // Broken sub-stmt shouldn't prevent forming the case statement properly.
755    if (SubStmt.isInvalid())
756      SubStmt = Actions.ActOnNullStmt(SourceLocation());
757    Actions.ActOnCaseStmtBody(DeepestParsedCaseStmt, SubStmt.get());
758  }
759
760  // Return the top level parsed statement tree.
761  return TopLevelCase;
762}
763
764/// ParseDefaultStatement
765///       labeled-statement:
766///         'default' ':' statement
767/// Note that this does not parse the 'statement' at the end.
768///
769StmtResult Parser::ParseDefaultStatement() {
770  assert(Tok.is(tok::kw_default) && "Not a default stmt!");
771  SourceLocation DefaultLoc = ConsumeToken();  // eat the 'default'.
772
773  SourceLocation ColonLoc;
774  if (TryConsumeToken(tok::colon, ColonLoc)) {
775  } else if (TryConsumeToken(tok::semi, ColonLoc)) {
776    // Treat "default;" as a typo for "default:".
777    Diag(ColonLoc, diag::err_expected_after)
778        << "'default'" << tok::colon
779        << FixItHint::CreateReplacement(ColonLoc, ":");
780  } else {
781    SourceLocation ExpectedLoc = PP.getLocForEndOfToken(PrevTokLocation);
782    Diag(ExpectedLoc, diag::err_expected_after)
783        << "'default'" << tok::colon
784        << FixItHint::CreateInsertion(ExpectedLoc, ":");
785    ColonLoc = ExpectedLoc;
786  }
787
788  StmtResult SubStmt;
789
790  if (Tok.isNot(tok::r_brace)) {
791    SubStmt = ParseStatement();
792  } else {
793    // Diagnose the common error "switch (X) {... default: }", which is
794    // not valid.
795    SourceLocation AfterColonLoc = PP.getLocForEndOfToken(ColonLoc);
796    Diag(AfterColonLoc, diag::err_label_end_of_compound_statement)
797      << FixItHint::CreateInsertion(AfterColonLoc, " ;");
798    SubStmt = true;
799  }
800
801  // Broken sub-stmt shouldn't prevent forming the case statement properly.
802  if (SubStmt.isInvalid())
803    SubStmt = Actions.ActOnNullStmt(ColonLoc);
804
805  return Actions.ActOnDefaultStmt(DefaultLoc, ColonLoc,
806                                  SubStmt.get(), getCurScope());
807}
808
809StmtResult Parser::ParseCompoundStatement(bool isStmtExpr) {
810  return ParseCompoundStatement(isStmtExpr, Scope::DeclScope);
811}
812
813/// ParseCompoundStatement - Parse a "{}" block.
814///
815///       compound-statement: [C99 6.8.2]
816///         { block-item-list[opt] }
817/// [GNU]   { label-declarations block-item-list } [TODO]
818///
819///       block-item-list:
820///         block-item
821///         block-item-list block-item
822///
823///       block-item:
824///         declaration
825/// [GNU]   '__extension__' declaration
826///         statement
827///
828/// [GNU] label-declarations:
829/// [GNU]   label-declaration
830/// [GNU]   label-declarations label-declaration
831///
832/// [GNU] label-declaration:
833/// [GNU]   '__label__' identifier-list ';'
834///
835StmtResult Parser::ParseCompoundStatement(bool isStmtExpr,
836                                          unsigned ScopeFlags) {
837  assert(Tok.is(tok::l_brace) && "Not a compount stmt!");
838
839  // Enter a scope to hold everything within the compound stmt.  Compound
840  // statements can always hold declarations.
841  ParseScope CompoundScope(this, ScopeFlags);
842
843  // Parse the statements in the body.
844  return ParseCompoundStatementBody(isStmtExpr);
845}
846
847/// Parse any pragmas at the start of the compound expression. We handle these
848/// separately since some pragmas (FP_CONTRACT) must appear before any C
849/// statement in the compound, but may be intermingled with other pragmas.
850void Parser::ParseCompoundStatementLeadingPragmas() {
851  bool checkForPragmas = true;
852  while (checkForPragmas) {
853    switch (Tok.getKind()) {
854    case tok::annot_pragma_vis:
855      HandlePragmaVisibility();
856      break;
857    case tok::annot_pragma_pack:
858      HandlePragmaPack();
859      break;
860    case tok::annot_pragma_msstruct:
861      HandlePragmaMSStruct();
862      break;
863    case tok::annot_pragma_align:
864      HandlePragmaAlign();
865      break;
866    case tok::annot_pragma_weak:
867      HandlePragmaWeak();
868      break;
869    case tok::annot_pragma_weakalias:
870      HandlePragmaWeakAlias();
871      break;
872    case tok::annot_pragma_redefine_extname:
873      HandlePragmaRedefineExtname();
874      break;
875    case tok::annot_pragma_opencl_extension:
876      HandlePragmaOpenCLExtension();
877      break;
878    case tok::annot_pragma_fp_contract:
879      HandlePragmaFPContract();
880      break;
881    case tok::annot_pragma_ms_pointers_to_members:
882      HandlePragmaMSPointersToMembers();
883      break;
884    case tok::annot_pragma_ms_pragma:
885      HandlePragmaMSPragma();
886      break;
887    default:
888      checkForPragmas = false;
889      break;
890    }
891  }
892
893}
894
895/// ParseCompoundStatementBody - Parse a sequence of statements and invoke the
896/// ActOnCompoundStmt action.  This expects the '{' to be the current token, and
897/// consume the '}' at the end of the block.  It does not manipulate the scope
898/// stack.
899StmtResult Parser::ParseCompoundStatementBody(bool isStmtExpr) {
900  PrettyStackTraceLoc CrashInfo(PP.getSourceManager(),
901                                Tok.getLocation(),
902                                "in compound statement ('{}')");
903
904  // Record the state of the FP_CONTRACT pragma, restore on leaving the
905  // compound statement.
906  Sema::FPContractStateRAII SaveFPContractState(Actions);
907
908  InMessageExpressionRAIIObject InMessage(*this, false);
909  BalancedDelimiterTracker T(*this, tok::l_brace);
910  if (T.consumeOpen())
911    return StmtError();
912
913  Sema::CompoundScopeRAII CompoundScope(Actions);
914
915  // Parse any pragmas at the beginning of the compound statement.
916  ParseCompoundStatementLeadingPragmas();
917
918  StmtVector Stmts;
919
920  // "__label__ X, Y, Z;" is the GNU "Local Label" extension.  These are
921  // only allowed at the start of a compound stmt regardless of the language.
922  while (Tok.is(tok::kw___label__)) {
923    SourceLocation LabelLoc = ConsumeToken();
924
925    SmallVector<Decl *, 8> DeclsInGroup;
926    while (1) {
927      if (Tok.isNot(tok::identifier)) {
928        Diag(Tok, diag::err_expected) << tok::identifier;
929        break;
930      }
931
932      IdentifierInfo *II = Tok.getIdentifierInfo();
933      SourceLocation IdLoc = ConsumeToken();
934      DeclsInGroup.push_back(Actions.LookupOrCreateLabel(II, IdLoc, LabelLoc));
935
936      if (!TryConsumeToken(tok::comma))
937        break;
938    }
939
940    DeclSpec DS(AttrFactory);
941    DeclGroupPtrTy Res =
942        Actions.FinalizeDeclaratorGroup(getCurScope(), DS, DeclsInGroup);
943    StmtResult R = Actions.ActOnDeclStmt(Res, LabelLoc, Tok.getLocation());
944
945    ExpectAndConsumeSemi(diag::err_expected_semi_declaration);
946    if (R.isUsable())
947      Stmts.push_back(R.get());
948  }
949
950  while (Tok.isNot(tok::r_brace) && !isEofOrEom()) {
951    if (Tok.is(tok::annot_pragma_unused)) {
952      HandlePragmaUnused();
953      continue;
954    }
955
956    StmtResult R;
957    if (Tok.isNot(tok::kw___extension__)) {
958      R = ParseStatementOrDeclaration(Stmts, false);
959    } else {
960      // __extension__ can start declarations and it can also be a unary
961      // operator for expressions.  Consume multiple __extension__ markers here
962      // until we can determine which is which.
963      // FIXME: This loses extension expressions in the AST!
964      SourceLocation ExtLoc = ConsumeToken();
965      while (Tok.is(tok::kw___extension__))
966        ConsumeToken();
967
968      ParsedAttributesWithRange attrs(AttrFactory);
969      MaybeParseCXX11Attributes(attrs, nullptr,
970                                /*MightBeObjCMessageSend*/ true);
971
972      // If this is the start of a declaration, parse it as such.
973      if (isDeclarationStatement()) {
974        // __extension__ silences extension warnings in the subdeclaration.
975        // FIXME: Save the __extension__ on the decl as a node somehow?
976        ExtensionRAIIObject O(Diags);
977
978        SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
979        DeclGroupPtrTy Res = ParseDeclaration(Declarator::BlockContext, DeclEnd,
980                                              attrs);
981        R = Actions.ActOnDeclStmt(Res, DeclStart, DeclEnd);
982      } else {
983        // Otherwise this was a unary __extension__ marker.
984        ExprResult Res(ParseExpressionWithLeadingExtension(ExtLoc));
985
986        if (Res.isInvalid()) {
987          SkipUntil(tok::semi);
988          continue;
989        }
990
991        // FIXME: Use attributes?
992        // Eat the semicolon at the end of stmt and convert the expr into a
993        // statement.
994        ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
995        R = Actions.ActOnExprStmt(Res);
996      }
997    }
998
999    if (R.isUsable())
1000      Stmts.push_back(R.get());
1001  }
1002
1003  SourceLocation CloseLoc = Tok.getLocation();
1004
1005  // We broke out of the while loop because we found a '}' or EOF.
1006  if (!T.consumeClose())
1007    // Recover by creating a compound statement with what we parsed so far,
1008    // instead of dropping everything and returning StmtError();
1009    CloseLoc = T.getCloseLocation();
1010
1011  return Actions.ActOnCompoundStmt(T.getOpenLocation(), CloseLoc,
1012                                   Stmts, isStmtExpr);
1013}
1014
1015/// ParseParenExprOrCondition:
1016/// [C  ]     '(' expression ')'
1017/// [C++]     '(' condition ')'       [not allowed if OnlyAllowCondition=true]
1018///
1019/// This function parses and performs error recovery on the specified condition
1020/// or expression (depending on whether we're in C++ or C mode).  This function
1021/// goes out of its way to recover well.  It returns true if there was a parser
1022/// error (the right paren couldn't be found), which indicates that the caller
1023/// should try to recover harder.  It returns false if the condition is
1024/// successfully parsed.  Note that a successful parse can still have semantic
1025/// errors in the condition.
1026bool Parser::ParseParenExprOrCondition(ExprResult &ExprResult,
1027                                       Decl *&DeclResult,
1028                                       SourceLocation Loc,
1029                                       bool ConvertToBoolean) {
1030  BalancedDelimiterTracker T(*this, tok::l_paren);
1031  T.consumeOpen();
1032
1033  if (getLangOpts().CPlusPlus)
1034    ParseCXXCondition(ExprResult, DeclResult, Loc, ConvertToBoolean);
1035  else {
1036    ExprResult = ParseExpression();
1037    DeclResult = nullptr;
1038
1039    // If required, convert to a boolean value.
1040    if (!ExprResult.isInvalid() && ConvertToBoolean)
1041      ExprResult
1042        = Actions.ActOnBooleanCondition(getCurScope(), Loc, ExprResult.get());
1043  }
1044
1045  // If the parser was confused by the condition and we don't have a ')', try to
1046  // recover by skipping ahead to a semi and bailing out.  If condexp is
1047  // semantically invalid but we have well formed code, keep going.
1048  if (ExprResult.isInvalid() && !DeclResult && Tok.isNot(tok::r_paren)) {
1049    SkipUntil(tok::semi);
1050    // Skipping may have stopped if it found the containing ')'.  If so, we can
1051    // continue parsing the if statement.
1052    if (Tok.isNot(tok::r_paren))
1053      return true;
1054  }
1055
1056  // Otherwise the condition is valid or the rparen is present.
1057  T.consumeClose();
1058
1059  // Check for extraneous ')'s to catch things like "if (foo())) {".  We know
1060  // that all callers are looking for a statement after the condition, so ")"
1061  // isn't valid.
1062  while (Tok.is(tok::r_paren)) {
1063    Diag(Tok, diag::err_extraneous_rparen_in_condition)
1064      << FixItHint::CreateRemoval(Tok.getLocation());
1065    ConsumeParen();
1066  }
1067
1068  return false;
1069}
1070
1071
1072/// ParseIfStatement
1073///       if-statement: [C99 6.8.4.1]
1074///         'if' '(' expression ')' statement
1075///         'if' '(' expression ')' statement 'else' statement
1076/// [C++]   'if' '(' condition ')' statement
1077/// [C++]   'if' '(' condition ')' statement 'else' statement
1078///
1079StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
1080  assert(Tok.is(tok::kw_if) && "Not an if stmt!");
1081  SourceLocation IfLoc = ConsumeToken();  // eat the 'if'.
1082
1083  if (Tok.isNot(tok::l_paren)) {
1084    Diag(Tok, diag::err_expected_lparen_after) << "if";
1085    SkipUntil(tok::semi);
1086    return StmtError();
1087  }
1088
1089  bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1090
1091  // C99 6.8.4p3 - In C99, the if statement is a block.  This is not
1092  // the case for C90.
1093  //
1094  // C++ 6.4p3:
1095  // A name introduced by a declaration in a condition is in scope from its
1096  // point of declaration until the end of the substatements controlled by the
1097  // condition.
1098  // C++ 3.3.2p4:
1099  // Names declared in the for-init-statement, and in the condition of if,
1100  // while, for, and switch statements are local to the if, while, for, or
1101  // switch statement (including the controlled statement).
1102  //
1103  ParseScope IfScope(this, Scope::DeclScope | Scope::ControlScope, C99orCXX);
1104
1105  // Parse the condition.
1106  ExprResult CondExp;
1107  Decl *CondVar = nullptr;
1108  if (ParseParenExprOrCondition(CondExp, CondVar, IfLoc, true))
1109    return StmtError();
1110
1111  FullExprArg FullCondExp(Actions.MakeFullExpr(CondExp.get(), IfLoc));
1112
1113  // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
1114  // there is no compound stmt.  C90 does not have this clause.  We only do this
1115  // if the body isn't a compound statement to avoid push/pop in common cases.
1116  //
1117  // C++ 6.4p1:
1118  // The substatement in a selection-statement (each substatement, in the else
1119  // form of the if statement) implicitly defines a local scope.
1120  //
1121  // For C++ we create a scope for the condition and a new scope for
1122  // substatements because:
1123  // -When the 'then' scope exits, we want the condition declaration to still be
1124  //    active for the 'else' scope too.
1125  // -Sema will detect name clashes by considering declarations of a
1126  //    'ControlScope' as part of its direct subscope.
1127  // -If we wanted the condition and substatement to be in the same scope, we
1128  //    would have to notify ParseStatement not to create a new scope. It's
1129  //    simpler to let it create a new scope.
1130  //
1131  ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1132
1133  // Read the 'then' stmt.
1134  SourceLocation ThenStmtLoc = Tok.getLocation();
1135
1136  SourceLocation InnerStatementTrailingElseLoc;
1137  StmtResult ThenStmt(ParseStatement(&InnerStatementTrailingElseLoc));
1138
1139  // Pop the 'if' scope if needed.
1140  InnerScope.Exit();
1141
1142  // If it has an else, parse it.
1143  SourceLocation ElseLoc;
1144  SourceLocation ElseStmtLoc;
1145  StmtResult ElseStmt;
1146
1147  if (Tok.is(tok::kw_else)) {
1148    if (TrailingElseLoc)
1149      *TrailingElseLoc = Tok.getLocation();
1150
1151    ElseLoc = ConsumeToken();
1152    ElseStmtLoc = Tok.getLocation();
1153
1154    // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
1155    // there is no compound stmt.  C90 does not have this clause.  We only do
1156    // this if the body isn't a compound statement to avoid push/pop in common
1157    // cases.
1158    //
1159    // C++ 6.4p1:
1160    // The substatement in a selection-statement (each substatement, in the else
1161    // form of the if statement) implicitly defines a local scope.
1162    //
1163    ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1164
1165    ElseStmt = ParseStatement();
1166
1167    // Pop the 'else' scope if needed.
1168    InnerScope.Exit();
1169  } else if (Tok.is(tok::code_completion)) {
1170    Actions.CodeCompleteAfterIf(getCurScope());
1171    cutOffParsing();
1172    return StmtError();
1173  } else if (InnerStatementTrailingElseLoc.isValid()) {
1174    Diag(InnerStatementTrailingElseLoc, diag::warn_dangling_else);
1175  }
1176
1177  IfScope.Exit();
1178
1179  // If the then or else stmt is invalid and the other is valid (and present),
1180  // make turn the invalid one into a null stmt to avoid dropping the other
1181  // part.  If both are invalid, return error.
1182  if ((ThenStmt.isInvalid() && ElseStmt.isInvalid()) ||
1183      (ThenStmt.isInvalid() && ElseStmt.get() == nullptr) ||
1184      (ThenStmt.get() == nullptr && ElseStmt.isInvalid())) {
1185    // Both invalid, or one is invalid and other is non-present: return error.
1186    return StmtError();
1187  }
1188
1189  // Now if either are invalid, replace with a ';'.
1190  if (ThenStmt.isInvalid())
1191    ThenStmt = Actions.ActOnNullStmt(ThenStmtLoc);
1192  if (ElseStmt.isInvalid())
1193    ElseStmt = Actions.ActOnNullStmt(ElseStmtLoc);
1194
1195  return Actions.ActOnIfStmt(IfLoc, FullCondExp, CondVar, ThenStmt.get(),
1196                             ElseLoc, ElseStmt.get());
1197}
1198
1199/// ParseSwitchStatement
1200///       switch-statement:
1201///         'switch' '(' expression ')' statement
1202/// [C++]   'switch' '(' condition ')' statement
1203StmtResult Parser::ParseSwitchStatement(SourceLocation *TrailingElseLoc) {
1204  assert(Tok.is(tok::kw_switch) && "Not a switch stmt!");
1205  SourceLocation SwitchLoc = ConsumeToken();  // eat the 'switch'.
1206
1207  if (Tok.isNot(tok::l_paren)) {
1208    Diag(Tok, diag::err_expected_lparen_after) << "switch";
1209    SkipUntil(tok::semi);
1210    return StmtError();
1211  }
1212
1213  bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1214
1215  // C99 6.8.4p3 - In C99, the switch statement is a block.  This is
1216  // not the case for C90.  Start the switch scope.
1217  //
1218  // C++ 6.4p3:
1219  // A name introduced by a declaration in a condition is in scope from its
1220  // point of declaration until the end of the substatements controlled by the
1221  // condition.
1222  // C++ 3.3.2p4:
1223  // Names declared in the for-init-statement, and in the condition of if,
1224  // while, for, and switch statements are local to the if, while, for, or
1225  // switch statement (including the controlled statement).
1226  //
1227  unsigned ScopeFlags = Scope::SwitchScope;
1228  if (C99orCXX)
1229    ScopeFlags |= Scope::DeclScope | Scope::ControlScope;
1230  ParseScope SwitchScope(this, ScopeFlags);
1231
1232  // Parse the condition.
1233  ExprResult Cond;
1234  Decl *CondVar = nullptr;
1235  if (ParseParenExprOrCondition(Cond, CondVar, SwitchLoc, false))
1236    return StmtError();
1237
1238  StmtResult Switch
1239    = Actions.ActOnStartOfSwitchStmt(SwitchLoc, Cond.get(), CondVar);
1240
1241  if (Switch.isInvalid()) {
1242    // Skip the switch body.
1243    // FIXME: This is not optimal recovery, but parsing the body is more
1244    // dangerous due to the presence of case and default statements, which
1245    // will have no place to connect back with the switch.
1246    if (Tok.is(tok::l_brace)) {
1247      ConsumeBrace();
1248      SkipUntil(tok::r_brace);
1249    } else
1250      SkipUntil(tok::semi);
1251    return Switch;
1252  }
1253
1254  // C99 6.8.4p3 - In C99, the body of the switch statement is a scope, even if
1255  // there is no compound stmt.  C90 does not have this clause.  We only do this
1256  // if the body isn't a compound statement to avoid push/pop in common cases.
1257  //
1258  // C++ 6.4p1:
1259  // The substatement in a selection-statement (each substatement, in the else
1260  // form of the if statement) implicitly defines a local scope.
1261  //
1262  // See comments in ParseIfStatement for why we create a scope for the
1263  // condition and a new scope for substatement in C++.
1264  //
1265  getCurScope()->AddFlags(Scope::BreakScope);
1266  ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1267
1268  // We have incremented the mangling number for the SwitchScope and the
1269  // InnerScope, which is one too many.
1270  if (C99orCXX)
1271    getCurScope()->decrementMSManglingNumber();
1272
1273  // Read the body statement.
1274  StmtResult Body(ParseStatement(TrailingElseLoc));
1275
1276  // Pop the scopes.
1277  InnerScope.Exit();
1278  SwitchScope.Exit();
1279
1280  return Actions.ActOnFinishSwitchStmt(SwitchLoc, Switch.get(), Body.get());
1281}
1282
1283/// ParseWhileStatement
1284///       while-statement: [C99 6.8.5.1]
1285///         'while' '(' expression ')' statement
1286/// [C++]   'while' '(' condition ')' statement
1287StmtResult Parser::ParseWhileStatement(SourceLocation *TrailingElseLoc) {
1288  assert(Tok.is(tok::kw_while) && "Not a while stmt!");
1289  SourceLocation WhileLoc = Tok.getLocation();
1290  ConsumeToken();  // eat the 'while'.
1291
1292  if (Tok.isNot(tok::l_paren)) {
1293    Diag(Tok, diag::err_expected_lparen_after) << "while";
1294    SkipUntil(tok::semi);
1295    return StmtError();
1296  }
1297
1298  bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1299
1300  // C99 6.8.5p5 - In C99, the while statement is a block.  This is not
1301  // the case for C90.  Start the loop scope.
1302  //
1303  // C++ 6.4p3:
1304  // A name introduced by a declaration in a condition is in scope from its
1305  // point of declaration until the end of the substatements controlled by the
1306  // condition.
1307  // C++ 3.3.2p4:
1308  // Names declared in the for-init-statement, and in the condition of if,
1309  // while, for, and switch statements are local to the if, while, for, or
1310  // switch statement (including the controlled statement).
1311  //
1312  unsigned ScopeFlags;
1313  if (C99orCXX)
1314    ScopeFlags = Scope::BreakScope | Scope::ContinueScope |
1315                 Scope::DeclScope  | Scope::ControlScope;
1316  else
1317    ScopeFlags = Scope::BreakScope | Scope::ContinueScope;
1318  ParseScope WhileScope(this, ScopeFlags);
1319
1320  // Parse the condition.
1321  ExprResult Cond;
1322  Decl *CondVar = nullptr;
1323  if (ParseParenExprOrCondition(Cond, CondVar, WhileLoc, true))
1324    return StmtError();
1325
1326  FullExprArg FullCond(Actions.MakeFullExpr(Cond.get(), WhileLoc));
1327
1328  // C99 6.8.5p5 - In C99, the body of the while statement is a scope, even if
1329  // there is no compound stmt.  C90 does not have this clause.  We only do this
1330  // if the body isn't a compound statement to avoid push/pop in common cases.
1331  //
1332  // C++ 6.5p2:
1333  // The substatement in an iteration-statement implicitly defines a local scope
1334  // which is entered and exited each time through the loop.
1335  //
1336  // See comments in ParseIfStatement for why we create a scope for the
1337  // condition and a new scope for substatement in C++.
1338  //
1339  ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1340
1341  // Read the body statement.
1342  StmtResult Body(ParseStatement(TrailingElseLoc));
1343
1344  // Pop the body scope if needed.
1345  InnerScope.Exit();
1346  WhileScope.Exit();
1347
1348  if ((Cond.isInvalid() && !CondVar) || Body.isInvalid())
1349    return StmtError();
1350
1351  return Actions.ActOnWhileStmt(WhileLoc, FullCond, CondVar, Body.get());
1352}
1353
1354/// ParseDoStatement
1355///       do-statement: [C99 6.8.5.2]
1356///         'do' statement 'while' '(' expression ')' ';'
1357/// Note: this lets the caller parse the end ';'.
1358StmtResult Parser::ParseDoStatement() {
1359  assert(Tok.is(tok::kw_do) && "Not a do stmt!");
1360  SourceLocation DoLoc = ConsumeToken();  // eat the 'do'.
1361
1362  // C99 6.8.5p5 - In C99, the do statement is a block.  This is not
1363  // the case for C90.  Start the loop scope.
1364  unsigned ScopeFlags;
1365  if (getLangOpts().C99)
1366    ScopeFlags = Scope::BreakScope | Scope::ContinueScope | Scope::DeclScope;
1367  else
1368    ScopeFlags = Scope::BreakScope | Scope::ContinueScope;
1369
1370  ParseScope DoScope(this, ScopeFlags);
1371
1372  // C99 6.8.5p5 - In C99, the body of the do statement is a scope, even if
1373  // there is no compound stmt.  C90 does not have this clause. We only do this
1374  // if the body isn't a compound statement to avoid push/pop in common cases.
1375  //
1376  // C++ 6.5p2:
1377  // The substatement in an iteration-statement implicitly defines a local scope
1378  // which is entered and exited each time through the loop.
1379  //
1380  bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1381  ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1382
1383  // Read the body statement.
1384  StmtResult Body(ParseStatement());
1385
1386  // Pop the body scope if needed.
1387  InnerScope.Exit();
1388
1389  if (Tok.isNot(tok::kw_while)) {
1390    if (!Body.isInvalid()) {
1391      Diag(Tok, diag::err_expected_while);
1392      Diag(DoLoc, diag::note_matching) << "'do'";
1393      SkipUntil(tok::semi, StopBeforeMatch);
1394    }
1395    return StmtError();
1396  }
1397  SourceLocation WhileLoc = ConsumeToken();
1398
1399  if (Tok.isNot(tok::l_paren)) {
1400    Diag(Tok, diag::err_expected_lparen_after) << "do/while";
1401    SkipUntil(tok::semi, StopBeforeMatch);
1402    return StmtError();
1403  }
1404
1405  // Parse the parenthesized expression.
1406  BalancedDelimiterTracker T(*this, tok::l_paren);
1407  T.consumeOpen();
1408
1409  // A do-while expression is not a condition, so can't have attributes.
1410  DiagnoseAndSkipCXX11Attributes();
1411
1412  ExprResult Cond = ParseExpression();
1413  T.consumeClose();
1414  DoScope.Exit();
1415
1416  if (Cond.isInvalid() || Body.isInvalid())
1417    return StmtError();
1418
1419  return Actions.ActOnDoStmt(DoLoc, Body.get(), WhileLoc, T.getOpenLocation(),
1420                             Cond.get(), T.getCloseLocation());
1421}
1422
1423bool Parser::isForRangeIdentifier() {
1424  assert(Tok.is(tok::identifier));
1425
1426  const Token &Next = NextToken();
1427  if (Next.is(tok::colon))
1428    return true;
1429
1430  if (Next.is(tok::l_square) || Next.is(tok::kw_alignas)) {
1431    TentativeParsingAction PA(*this);
1432    ConsumeToken();
1433    SkipCXX11Attributes();
1434    bool Result = Tok.is(tok::colon);
1435    PA.Revert();
1436    return Result;
1437  }
1438
1439  return false;
1440}
1441
1442/// ParseForStatement
1443///       for-statement: [C99 6.8.5.3]
1444///         'for' '(' expr[opt] ';' expr[opt] ';' expr[opt] ')' statement
1445///         'for' '(' declaration expr[opt] ';' expr[opt] ')' statement
1446/// [C++]   'for' '(' for-init-statement condition[opt] ';' expression[opt] ')'
1447/// [C++]       statement
1448/// [C++0x] 'for' '(' for-range-declaration : for-range-initializer ) statement
1449/// [OBJC2] 'for' '(' declaration 'in' expr ')' statement
1450/// [OBJC2] 'for' '(' expr 'in' expr ')' statement
1451///
1452/// [C++] for-init-statement:
1453/// [C++]   expression-statement
1454/// [C++]   simple-declaration
1455///
1456/// [C++0x] for-range-declaration:
1457/// [C++0x]   attribute-specifier-seq[opt] type-specifier-seq declarator
1458/// [C++0x] for-range-initializer:
1459/// [C++0x]   expression
1460/// [C++0x]   braced-init-list            [TODO]
1461StmtResult Parser::ParseForStatement(SourceLocation *TrailingElseLoc) {
1462  assert(Tok.is(tok::kw_for) && "Not a for stmt!");
1463  SourceLocation ForLoc = ConsumeToken();  // eat the 'for'.
1464
1465  if (Tok.isNot(tok::l_paren)) {
1466    Diag(Tok, diag::err_expected_lparen_after) << "for";
1467    SkipUntil(tok::semi);
1468    return StmtError();
1469  }
1470
1471  bool C99orCXXorObjC = getLangOpts().C99 || getLangOpts().CPlusPlus ||
1472    getLangOpts().ObjC1;
1473
1474  // C99 6.8.5p5 - In C99, the for statement is a block.  This is not
1475  // the case for C90.  Start the loop scope.
1476  //
1477  // C++ 6.4p3:
1478  // A name introduced by a declaration in a condition is in scope from its
1479  // point of declaration until the end of the substatements controlled by the
1480  // condition.
1481  // C++ 3.3.2p4:
1482  // Names declared in the for-init-statement, and in the condition of if,
1483  // while, for, and switch statements are local to the if, while, for, or
1484  // switch statement (including the controlled statement).
1485  // C++ 6.5.3p1:
1486  // Names declared in the for-init-statement are in the same declarative-region
1487  // as those declared in the condition.
1488  //
1489  unsigned ScopeFlags = 0;
1490  if (C99orCXXorObjC)
1491    ScopeFlags = Scope::DeclScope | Scope::ControlScope;
1492
1493  ParseScope ForScope(this, ScopeFlags);
1494
1495  BalancedDelimiterTracker T(*this, tok::l_paren);
1496  T.consumeOpen();
1497
1498  ExprResult Value;
1499
1500  bool ForEach = false, ForRange = false;
1501  StmtResult FirstPart;
1502  bool SecondPartIsInvalid = false;
1503  FullExprArg SecondPart(Actions);
1504  ExprResult Collection;
1505  ForRangeInit ForRangeInit;
1506  FullExprArg ThirdPart(Actions);
1507  Decl *SecondVar = nullptr;
1508
1509  if (Tok.is(tok::code_completion)) {
1510    Actions.CodeCompleteOrdinaryName(getCurScope(),
1511                                     C99orCXXorObjC? Sema::PCC_ForInit
1512                                                   : Sema::PCC_Expression);
1513    cutOffParsing();
1514    return StmtError();
1515  }
1516
1517  ParsedAttributesWithRange attrs(AttrFactory);
1518  MaybeParseCXX11Attributes(attrs);
1519
1520  // Parse the first part of the for specifier.
1521  if (Tok.is(tok::semi)) {  // for (;
1522    ProhibitAttributes(attrs);
1523    // no first part, eat the ';'.
1524    ConsumeToken();
1525  } else if (getLangOpts().CPlusPlus && Tok.is(tok::identifier) &&
1526             isForRangeIdentifier()) {
1527    ProhibitAttributes(attrs);
1528    IdentifierInfo *Name = Tok.getIdentifierInfo();
1529    SourceLocation Loc = ConsumeToken();
1530    MaybeParseCXX11Attributes(attrs);
1531
1532    ForRangeInit.ColonLoc = ConsumeToken();
1533    if (Tok.is(tok::l_brace))
1534      ForRangeInit.RangeExpr = ParseBraceInitializer();
1535    else
1536      ForRangeInit.RangeExpr = ParseExpression();
1537
1538    Diag(Loc, diag::err_for_range_identifier)
1539      << ((getLangOpts().CPlusPlus11 && !getLangOpts().CPlusPlus1z)
1540              ? FixItHint::CreateInsertion(Loc, "auto &&")
1541              : FixItHint());
1542
1543    FirstPart = Actions.ActOnCXXForRangeIdentifier(getCurScope(), Loc, Name,
1544                                                   attrs, attrs.Range.getEnd());
1545    ForRange = true;
1546  } else if (isForInitDeclaration()) {  // for (int X = 4;
1547    // Parse declaration, which eats the ';'.
1548    if (!C99orCXXorObjC)   // Use of C99-style for loops in C90 mode?
1549      Diag(Tok, diag::ext_c99_variable_decl_in_for_loop);
1550
1551    // In C++0x, "for (T NS:a" might not be a typo for ::
1552    bool MightBeForRangeStmt = getLangOpts().CPlusPlus;
1553    ColonProtectionRAIIObject ColonProtection(*this, MightBeForRangeStmt);
1554
1555    SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
1556    DeclGroupPtrTy DG = ParseSimpleDeclaration(
1557        Declarator::ForContext, DeclEnd, attrs, false,
1558        MightBeForRangeStmt ? &ForRangeInit : nullptr);
1559    FirstPart = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
1560    if (ForRangeInit.ParsedForRangeDecl()) {
1561      Diag(ForRangeInit.ColonLoc, getLangOpts().CPlusPlus11 ?
1562           diag::warn_cxx98_compat_for_range : diag::ext_for_range);
1563
1564      ForRange = true;
1565    } else if (Tok.is(tok::semi)) {  // for (int x = 4;
1566      ConsumeToken();
1567    } else if ((ForEach = isTokIdentifier_in())) {
1568      Actions.ActOnForEachDeclStmt(DG);
1569      // ObjC: for (id x in expr)
1570      ConsumeToken(); // consume 'in'
1571
1572      if (Tok.is(tok::code_completion)) {
1573        Actions.CodeCompleteObjCForCollection(getCurScope(), DG);
1574        cutOffParsing();
1575        return StmtError();
1576      }
1577      Collection = ParseExpression();
1578    } else {
1579      Diag(Tok, diag::err_expected_semi_for);
1580    }
1581  } else {
1582    ProhibitAttributes(attrs);
1583    Value = Actions.CorrectDelayedTyposInExpr(ParseExpression());
1584
1585    ForEach = isTokIdentifier_in();
1586
1587    // Turn the expression into a stmt.
1588    if (!Value.isInvalid()) {
1589      if (ForEach)
1590        FirstPart = Actions.ActOnForEachLValueExpr(Value.get());
1591      else
1592        FirstPart = Actions.ActOnExprStmt(Value);
1593    }
1594
1595    if (Tok.is(tok::semi)) {
1596      ConsumeToken();
1597    } else if (ForEach) {
1598      ConsumeToken(); // consume 'in'
1599
1600      if (Tok.is(tok::code_completion)) {
1601        Actions.CodeCompleteObjCForCollection(getCurScope(), DeclGroupPtrTy());
1602        cutOffParsing();
1603        return StmtError();
1604      }
1605      Collection = ParseExpression();
1606    } else if (getLangOpts().CPlusPlus11 && Tok.is(tok::colon) && FirstPart.get()) {
1607      // User tried to write the reasonable, but ill-formed, for-range-statement
1608      //   for (expr : expr) { ... }
1609      Diag(Tok, diag::err_for_range_expected_decl)
1610        << FirstPart.get()->getSourceRange();
1611      SkipUntil(tok::r_paren, StopBeforeMatch);
1612      SecondPartIsInvalid = true;
1613    } else {
1614      if (!Value.isInvalid()) {
1615        Diag(Tok, diag::err_expected_semi_for);
1616      } else {
1617        // Skip until semicolon or rparen, don't consume it.
1618        SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch);
1619        if (Tok.is(tok::semi))
1620          ConsumeToken();
1621      }
1622    }
1623  }
1624
1625  // Parse the second part of the for specifier.
1626  getCurScope()->AddFlags(Scope::BreakScope | Scope::ContinueScope);
1627  if (!ForEach && !ForRange) {
1628    assert(!SecondPart.get() && "Shouldn't have a second expression yet.");
1629    // Parse the second part of the for specifier.
1630    if (Tok.is(tok::semi)) {  // for (...;;
1631      // no second part.
1632    } else if (Tok.is(tok::r_paren)) {
1633      // missing both semicolons.
1634    } else {
1635      ExprResult Second;
1636      if (getLangOpts().CPlusPlus)
1637        ParseCXXCondition(Second, SecondVar, ForLoc, true);
1638      else {
1639        Second = ParseExpression();
1640        if (!Second.isInvalid())
1641          Second = Actions.ActOnBooleanCondition(getCurScope(), ForLoc,
1642                                                 Second.get());
1643      }
1644      SecondPartIsInvalid = Second.isInvalid();
1645      SecondPart = Actions.MakeFullExpr(Second.get(), ForLoc);
1646    }
1647
1648    if (Tok.isNot(tok::semi)) {
1649      if (!SecondPartIsInvalid || SecondVar)
1650        Diag(Tok, diag::err_expected_semi_for);
1651      else
1652        // Skip until semicolon or rparen, don't consume it.
1653        SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch);
1654    }
1655
1656    if (Tok.is(tok::semi)) {
1657      ConsumeToken();
1658    }
1659
1660    // Parse the third part of the for specifier.
1661    if (Tok.isNot(tok::r_paren)) {   // for (...;...;)
1662      ExprResult Third = ParseExpression();
1663      // FIXME: The C++11 standard doesn't actually say that this is a
1664      // discarded-value expression, but it clearly should be.
1665      ThirdPart = Actions.MakeFullDiscardedValueExpr(Third.get());
1666    }
1667  }
1668  // Match the ')'.
1669  T.consumeClose();
1670
1671  // We need to perform most of the semantic analysis for a C++0x for-range
1672  // statememt before parsing the body, in order to be able to deduce the type
1673  // of an auto-typed loop variable.
1674  StmtResult ForRangeStmt;
1675  StmtResult ForEachStmt;
1676
1677  if (ForRange) {
1678    ForRangeStmt = Actions.ActOnCXXForRangeStmt(ForLoc, FirstPart.get(),
1679                                                ForRangeInit.ColonLoc,
1680                                                ForRangeInit.RangeExpr.get(),
1681                                                T.getCloseLocation(),
1682                                                Sema::BFRK_Build);
1683
1684
1685  // Similarly, we need to do the semantic analysis for a for-range
1686  // statement immediately in order to close over temporaries correctly.
1687  } else if (ForEach) {
1688    ForEachStmt = Actions.ActOnObjCForCollectionStmt(ForLoc,
1689                                                     FirstPart.get(),
1690                                                     Collection.get(),
1691                                                     T.getCloseLocation());
1692  }
1693
1694  // C99 6.8.5p5 - In C99, the body of the for statement is a scope, even if
1695  // there is no compound stmt.  C90 does not have this clause.  We only do this
1696  // if the body isn't a compound statement to avoid push/pop in common cases.
1697  //
1698  // C++ 6.5p2:
1699  // The substatement in an iteration-statement implicitly defines a local scope
1700  // which is entered and exited each time through the loop.
1701  //
1702  // See comments in ParseIfStatement for why we create a scope for
1703  // for-init-statement/condition and a new scope for substatement in C++.
1704  //
1705  ParseScope InnerScope(this, Scope::DeclScope, C99orCXXorObjC,
1706                        Tok.is(tok::l_brace));
1707
1708  // The body of the for loop has the same local mangling number as the
1709  // for-init-statement.
1710  // It will only be incremented if the body contains other things that would
1711  // normally increment the mangling number (like a compound statement).
1712  if (C99orCXXorObjC)
1713    getCurScope()->decrementMSManglingNumber();
1714
1715  // Read the body statement.
1716  StmtResult Body(ParseStatement(TrailingElseLoc));
1717
1718  // Pop the body scope if needed.
1719  InnerScope.Exit();
1720
1721  // Leave the for-scope.
1722  ForScope.Exit();
1723
1724  if (Body.isInvalid())
1725    return StmtError();
1726
1727  if (ForEach)
1728   return Actions.FinishObjCForCollectionStmt(ForEachStmt.get(),
1729                                              Body.get());
1730
1731  if (ForRange)
1732    return Actions.FinishCXXForRangeStmt(ForRangeStmt.get(), Body.get());
1733
1734  return Actions.ActOnForStmt(ForLoc, T.getOpenLocation(), FirstPart.get(),
1735                              SecondPart, SecondVar, ThirdPart,
1736                              T.getCloseLocation(), Body.get());
1737}
1738
1739/// ParseGotoStatement
1740///       jump-statement:
1741///         'goto' identifier ';'
1742/// [GNU]   'goto' '*' expression ';'
1743///
1744/// Note: this lets the caller parse the end ';'.
1745///
1746StmtResult Parser::ParseGotoStatement() {
1747  assert(Tok.is(tok::kw_goto) && "Not a goto stmt!");
1748  SourceLocation GotoLoc = ConsumeToken();  // eat the 'goto'.
1749
1750  StmtResult Res;
1751  if (Tok.is(tok::identifier)) {
1752    LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
1753                                                Tok.getLocation());
1754    Res = Actions.ActOnGotoStmt(GotoLoc, Tok.getLocation(), LD);
1755    ConsumeToken();
1756  } else if (Tok.is(tok::star)) {
1757    // GNU indirect goto extension.
1758    Diag(Tok, diag::ext_gnu_indirect_goto);
1759    SourceLocation StarLoc = ConsumeToken();
1760    ExprResult R(ParseExpression());
1761    if (R.isInvalid()) {  // Skip to the semicolon, but don't consume it.
1762      SkipUntil(tok::semi, StopBeforeMatch);
1763      return StmtError();
1764    }
1765    Res = Actions.ActOnIndirectGotoStmt(GotoLoc, StarLoc, R.get());
1766  } else {
1767    Diag(Tok, diag::err_expected) << tok::identifier;
1768    return StmtError();
1769  }
1770
1771  return Res;
1772}
1773
1774/// ParseContinueStatement
1775///       jump-statement:
1776///         'continue' ';'
1777///
1778/// Note: this lets the caller parse the end ';'.
1779///
1780StmtResult Parser::ParseContinueStatement() {
1781  SourceLocation ContinueLoc = ConsumeToken();  // eat the 'continue'.
1782  return Actions.ActOnContinueStmt(ContinueLoc, getCurScope());
1783}
1784
1785/// ParseBreakStatement
1786///       jump-statement:
1787///         'break' ';'
1788///
1789/// Note: this lets the caller parse the end ';'.
1790///
1791StmtResult Parser::ParseBreakStatement() {
1792  SourceLocation BreakLoc = ConsumeToken();  // eat the 'break'.
1793  return Actions.ActOnBreakStmt(BreakLoc, getCurScope());
1794}
1795
1796/// ParseReturnStatement
1797///       jump-statement:
1798///         'return' expression[opt] ';'
1799StmtResult Parser::ParseReturnStatement() {
1800  assert(Tok.is(tok::kw_return) && "Not a return stmt!");
1801  SourceLocation ReturnLoc = ConsumeToken();  // eat the 'return'.
1802
1803  ExprResult R;
1804  if (Tok.isNot(tok::semi)) {
1805    if (Tok.is(tok::code_completion)) {
1806      Actions.CodeCompleteReturn(getCurScope());
1807      cutOffParsing();
1808      return StmtError();
1809    }
1810
1811    if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus) {
1812      R = ParseInitializer();
1813      if (R.isUsable())
1814        Diag(R.get()->getLocStart(), getLangOpts().CPlusPlus11 ?
1815             diag::warn_cxx98_compat_generalized_initializer_lists :
1816             diag::ext_generalized_initializer_lists)
1817          << R.get()->getSourceRange();
1818    } else
1819      R = ParseExpression();
1820    if (R.isInvalid()) {
1821      SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
1822      return StmtError();
1823    }
1824  }
1825  return Actions.ActOnReturnStmt(ReturnLoc, R.get(), getCurScope());
1826}
1827
1828StmtResult Parser::ParsePragmaLoopHint(StmtVector &Stmts, bool OnlyStatement,
1829                                       SourceLocation *TrailingElseLoc,
1830                                       ParsedAttributesWithRange &Attrs) {
1831  // Create temporary attribute list.
1832  ParsedAttributesWithRange TempAttrs(AttrFactory);
1833
1834  // Get loop hints and consume annotated token.
1835  while (Tok.is(tok::annot_pragma_loop_hint)) {
1836    LoopHint Hint;
1837    if (!HandlePragmaLoopHint(Hint))
1838      continue;
1839
1840    ArgsUnion ArgHints[] = {Hint.PragmaNameLoc, Hint.OptionLoc, Hint.StateLoc,
1841                            ArgsUnion(Hint.ValueExpr)};
1842    TempAttrs.addNew(Hint.PragmaNameLoc->Ident, Hint.Range, nullptr,
1843                     Hint.PragmaNameLoc->Loc, ArgHints, 4,
1844                     AttributeList::AS_Pragma);
1845  }
1846
1847  // Get the next statement.
1848  MaybeParseCXX11Attributes(Attrs);
1849
1850  StmtResult S = ParseStatementOrDeclarationAfterAttributes(
1851      Stmts, OnlyStatement, TrailingElseLoc, Attrs);
1852
1853  Attrs.takeAllFrom(TempAttrs);
1854  return S;
1855}
1856
1857Decl *Parser::ParseFunctionStatementBody(Decl *Decl, ParseScope &BodyScope) {
1858  assert(Tok.is(tok::l_brace));
1859  SourceLocation LBraceLoc = Tok.getLocation();
1860
1861  if (SkipFunctionBodies && (!Decl || Actions.canSkipFunctionBody(Decl)) &&
1862      trySkippingFunctionBody()) {
1863    BodyScope.Exit();
1864    return Actions.ActOnSkippedFunctionBody(Decl);
1865  }
1866
1867  PrettyDeclStackTraceEntry CrashInfo(Actions, Decl, LBraceLoc,
1868                                      "parsing function body");
1869
1870  // Do not enter a scope for the brace, as the arguments are in the same scope
1871  // (the function body) as the body itself.  Instead, just read the statement
1872  // list and put it into a CompoundStmt for safe keeping.
1873  StmtResult FnBody(ParseCompoundStatementBody());
1874
1875  // If the function body could not be parsed, make a bogus compoundstmt.
1876  if (FnBody.isInvalid()) {
1877    Sema::CompoundScopeRAII CompoundScope(Actions);
1878    FnBody = Actions.ActOnCompoundStmt(LBraceLoc, LBraceLoc, None, false);
1879  }
1880
1881  BodyScope.Exit();
1882  return Actions.ActOnFinishFunctionBody(Decl, FnBody.get());
1883}
1884
1885/// ParseFunctionTryBlock - Parse a C++ function-try-block.
1886///
1887///       function-try-block:
1888///         'try' ctor-initializer[opt] compound-statement handler-seq
1889///
1890Decl *Parser::ParseFunctionTryBlock(Decl *Decl, ParseScope &BodyScope) {
1891  assert(Tok.is(tok::kw_try) && "Expected 'try'");
1892  SourceLocation TryLoc = ConsumeToken();
1893
1894  PrettyDeclStackTraceEntry CrashInfo(Actions, Decl, TryLoc,
1895                                      "parsing function try block");
1896
1897  // Constructor initializer list?
1898  if (Tok.is(tok::colon))
1899    ParseConstructorInitializer(Decl);
1900  else
1901    Actions.ActOnDefaultCtorInitializers(Decl);
1902
1903  if (SkipFunctionBodies && Actions.canSkipFunctionBody(Decl) &&
1904      trySkippingFunctionBody()) {
1905    BodyScope.Exit();
1906    return Actions.ActOnSkippedFunctionBody(Decl);
1907  }
1908
1909  SourceLocation LBraceLoc = Tok.getLocation();
1910  StmtResult FnBody(ParseCXXTryBlockCommon(TryLoc, /*FnTry*/true));
1911  // If we failed to parse the try-catch, we just give the function an empty
1912  // compound statement as the body.
1913  if (FnBody.isInvalid()) {
1914    Sema::CompoundScopeRAII CompoundScope(Actions);
1915    FnBody = Actions.ActOnCompoundStmt(LBraceLoc, LBraceLoc, None, false);
1916  }
1917
1918  BodyScope.Exit();
1919  return Actions.ActOnFinishFunctionBody(Decl, FnBody.get());
1920}
1921
1922bool Parser::trySkippingFunctionBody() {
1923  assert(Tok.is(tok::l_brace));
1924  assert(SkipFunctionBodies &&
1925         "Should only be called when SkipFunctionBodies is enabled");
1926
1927  if (!PP.isCodeCompletionEnabled()) {
1928    ConsumeBrace();
1929    SkipUntil(tok::r_brace);
1930    return true;
1931  }
1932
1933  // We're in code-completion mode. Skip parsing for all function bodies unless
1934  // the body contains the code-completion point.
1935  TentativeParsingAction PA(*this);
1936  ConsumeBrace();
1937  if (SkipUntil(tok::r_brace, StopAtCodeCompletion)) {
1938    PA.Commit();
1939    return true;
1940  }
1941
1942  PA.Revert();
1943  return false;
1944}
1945
1946/// ParseCXXTryBlock - Parse a C++ try-block.
1947///
1948///       try-block:
1949///         'try' compound-statement handler-seq
1950///
1951StmtResult Parser::ParseCXXTryBlock() {
1952  assert(Tok.is(tok::kw_try) && "Expected 'try'");
1953
1954  SourceLocation TryLoc = ConsumeToken();
1955  return ParseCXXTryBlockCommon(TryLoc);
1956}
1957
1958/// ParseCXXTryBlockCommon - Parse the common part of try-block and
1959/// function-try-block.
1960///
1961///       try-block:
1962///         'try' compound-statement handler-seq
1963///
1964///       function-try-block:
1965///         'try' ctor-initializer[opt] compound-statement handler-seq
1966///
1967///       handler-seq:
1968///         handler handler-seq[opt]
1969///
1970///       [Borland] try-block:
1971///         'try' compound-statement seh-except-block
1972///         'try' compound-statement seh-finally-block
1973///
1974StmtResult Parser::ParseCXXTryBlockCommon(SourceLocation TryLoc, bool FnTry) {
1975  if (Tok.isNot(tok::l_brace))
1976    return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
1977
1978  StmtResult TryBlock(ParseCompoundStatement(/*isStmtExpr=*/false,
1979                      Scope::DeclScope | Scope::TryScope |
1980                        (FnTry ? Scope::FnTryCatchScope : 0)));
1981  if (TryBlock.isInvalid())
1982    return TryBlock;
1983
1984  // Borland allows SEH-handlers with 'try'
1985
1986  if ((Tok.is(tok::identifier) &&
1987       Tok.getIdentifierInfo() == getSEHExceptKeyword()) ||
1988      Tok.is(tok::kw___finally)) {
1989    // TODO: Factor into common return ParseSEHHandlerCommon(...)
1990    StmtResult Handler;
1991    if(Tok.getIdentifierInfo() == getSEHExceptKeyword()) {
1992      SourceLocation Loc = ConsumeToken();
1993      Handler = ParseSEHExceptBlock(Loc);
1994    }
1995    else {
1996      SourceLocation Loc = ConsumeToken();
1997      Handler = ParseSEHFinallyBlock(Loc);
1998    }
1999    if(Handler.isInvalid())
2000      return Handler;
2001
2002    return Actions.ActOnSEHTryBlock(true /* IsCXXTry */,
2003                                    TryLoc,
2004                                    TryBlock.get(),
2005                                    Handler.get());
2006  }
2007  else {
2008    StmtVector Handlers;
2009
2010    // C++11 attributes can't appear here, despite this context seeming
2011    // statement-like.
2012    DiagnoseAndSkipCXX11Attributes();
2013
2014    if (Tok.isNot(tok::kw_catch))
2015      return StmtError(Diag(Tok, diag::err_expected_catch));
2016    while (Tok.is(tok::kw_catch)) {
2017      StmtResult Handler(ParseCXXCatchBlock(FnTry));
2018      if (!Handler.isInvalid())
2019        Handlers.push_back(Handler.get());
2020    }
2021    // Don't bother creating the full statement if we don't have any usable
2022    // handlers.
2023    if (Handlers.empty())
2024      return StmtError();
2025
2026    return Actions.ActOnCXXTryBlock(TryLoc, TryBlock.get(), Handlers);
2027  }
2028}
2029
2030/// ParseCXXCatchBlock - Parse a C++ catch block, called handler in the standard
2031///
2032///   handler:
2033///     'catch' '(' exception-declaration ')' compound-statement
2034///
2035///   exception-declaration:
2036///     attribute-specifier-seq[opt] type-specifier-seq declarator
2037///     attribute-specifier-seq[opt] type-specifier-seq abstract-declarator[opt]
2038///     '...'
2039///
2040StmtResult Parser::ParseCXXCatchBlock(bool FnCatch) {
2041  assert(Tok.is(tok::kw_catch) && "Expected 'catch'");
2042
2043  SourceLocation CatchLoc = ConsumeToken();
2044
2045  BalancedDelimiterTracker T(*this, tok::l_paren);
2046  if (T.expectAndConsume())
2047    return StmtError();
2048
2049  // C++ 3.3.2p3:
2050  // The name in a catch exception-declaration is local to the handler and
2051  // shall not be redeclared in the outermost block of the handler.
2052  ParseScope CatchScope(this, Scope::DeclScope | Scope::ControlScope |
2053                          (FnCatch ? Scope::FnTryCatchScope : 0));
2054
2055  // exception-declaration is equivalent to '...' or a parameter-declaration
2056  // without default arguments.
2057  Decl *ExceptionDecl = nullptr;
2058  if (Tok.isNot(tok::ellipsis)) {
2059    ParsedAttributesWithRange Attributes(AttrFactory);
2060    MaybeParseCXX11Attributes(Attributes);
2061
2062    DeclSpec DS(AttrFactory);
2063    DS.takeAttributesFrom(Attributes);
2064
2065    if (ParseCXXTypeSpecifierSeq(DS))
2066      return StmtError();
2067
2068    Declarator ExDecl(DS, Declarator::CXXCatchContext);
2069    ParseDeclarator(ExDecl);
2070    ExceptionDecl = Actions.ActOnExceptionDeclarator(getCurScope(), ExDecl);
2071  } else
2072    ConsumeToken();
2073
2074  T.consumeClose();
2075  if (T.getCloseLocation().isInvalid())
2076    return StmtError();
2077
2078  if (Tok.isNot(tok::l_brace))
2079    return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
2080
2081  // FIXME: Possible draft standard bug: attribute-specifier should be allowed?
2082  StmtResult Block(ParseCompoundStatement());
2083  if (Block.isInvalid())
2084    return Block;
2085
2086  return Actions.ActOnCXXCatchBlock(CatchLoc, ExceptionDecl, Block.get());
2087}
2088
2089void Parser::ParseMicrosoftIfExistsStatement(StmtVector &Stmts) {
2090  IfExistsCondition Result;
2091  if (ParseMicrosoftIfExistsCondition(Result))
2092    return;
2093
2094  // Handle dependent statements by parsing the braces as a compound statement.
2095  // This is not the same behavior as Visual C++, which don't treat this as a
2096  // compound statement, but for Clang's type checking we can't have anything
2097  // inside these braces escaping to the surrounding code.
2098  if (Result.Behavior == IEB_Dependent) {
2099    if (!Tok.is(tok::l_brace)) {
2100      Diag(Tok, diag::err_expected) << tok::l_brace;
2101      return;
2102    }
2103
2104    StmtResult Compound = ParseCompoundStatement();
2105    if (Compound.isInvalid())
2106      return;
2107
2108    StmtResult DepResult = Actions.ActOnMSDependentExistsStmt(Result.KeywordLoc,
2109                                                              Result.IsIfExists,
2110                                                              Result.SS,
2111                                                              Result.Name,
2112                                                              Compound.get());
2113    if (DepResult.isUsable())
2114      Stmts.push_back(DepResult.get());
2115    return;
2116  }
2117
2118  BalancedDelimiterTracker Braces(*this, tok::l_brace);
2119  if (Braces.consumeOpen()) {
2120    Diag(Tok, diag::err_expected) << tok::l_brace;
2121    return;
2122  }
2123
2124  switch (Result.Behavior) {
2125  case IEB_Parse:
2126    // Parse the statements below.
2127    break;
2128
2129  case IEB_Dependent:
2130    llvm_unreachable("Dependent case handled above");
2131
2132  case IEB_Skip:
2133    Braces.skipToEnd();
2134    return;
2135  }
2136
2137  // Condition is true, parse the statements.
2138  while (Tok.isNot(tok::r_brace)) {
2139    StmtResult R = ParseStatementOrDeclaration(Stmts, false);
2140    if (R.isUsable())
2141      Stmts.push_back(R.get());
2142  }
2143  Braces.consumeClose();
2144}
2145