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