1 //===--- ParseStmt.cpp - Statement and Block Parser -----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Statement and Block portions of the Parser
13 //===----------------------------------------------------------------------===//
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"
27 using namespace clang;
29 //===----------------------------------------------------------------------===//
30 // C99 6.8: Statements and Blocks.
31 //===----------------------------------------------------------------------===//
33 /// \brief Parse a standalone statement (for instance, as the body of an 'if',
34 /// 'while', or 'for').
35 StmtResult Parser::ParseStatement(SourceLocation *TrailingElseLoc) {
38 // We may get back a null statement if we found a #pragma. Keep going until
39 // we get an actual statement.
42 Res = ParseStatementOrDeclaration(Stmts, true, TrailingElseLoc);
43 } while (!Res.isInvalid() && !Res.get());
48 /// ParseStatementOrDeclaration - Read 'statement' or 'declaration'.
49 /// StatementOrDeclaration:
55 /// compound-statement
56 /// expression-statement
57 /// selection-statement
58 /// iteration-statement
60 /// [C++] declaration-statement
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]
69 /// labeled-statement:
70 /// identifier ':' statement
71 /// 'case' constant-expression ':' statement
72 /// 'default' ':' statement
74 /// selection-statement:
78 /// iteration-statement:
83 /// expression-statement:
84 /// expression[opt] ';'
87 /// 'goto' identifier ';'
90 /// 'return' expression[opt] ';'
91 /// [GNU] 'goto' '*' expression ';'
93 /// [OBC] objc-throw-statement:
94 /// [OBC] '@' 'throw' expression ';'
95 /// [OBC] '@' 'throw' ';'
98 Parser::ParseStatementOrDeclaration(StmtVector &Stmts, bool OnlyStatement,
99 SourceLocation *TrailingElseLoc) {
101 ParenBraceBracketBalancer BalancerRAIIObj(*this);
103 ParsedAttributesWithRange Attrs(AttrFactory);
104 MaybeParseCXX11Attributes(Attrs, nullptr, /*MightBeObjCMessageSend*/ true);
106 StmtResult Res = ParseStatementOrDeclarationAfterAttributes(Stmts,
107 OnlyStatement, TrailingElseLoc, Attrs);
109 assert((Attrs.empty() || Res.isInvalid() || Res.isUsable()) &&
110 "attributes on empty statement");
112 if (Attrs.empty() || Res.isInvalid())
115 return Actions.ProcessStmtAttributes(Res.get(), Attrs.getList(), Attrs.Range);
119 class StatementFilterCCC : public CorrectionCandidateCallback {
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;
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>())
142 return CorrectionCandidateCallback::ValidateCandidate(candidate);
151 Parser::ParseStatementOrDeclarationAfterAttributes(StmtVector &Stmts,
152 bool OnlyStatement, SourceLocation *TrailingElseLoc,
153 ParsedAttributesWithRange &Attrs) {
154 const char *SemiError = nullptr;
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.
161 tok::TokenKind Kind = Tok.getKind();
162 SourceLocation AtLoc;
164 case tok::at: // May be a @try or @throw statement
166 ProhibitAttributes(Attrs); // TODO: is it correct?
167 AtLoc = ConsumeToken(); // consume @
168 return ParseObjCAtStatement(AtLoc);
171 case tok::code_completion:
172 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Statement);
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);
183 // Look up the identifier, and typo-correct it to a keyword if it's not
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 StatementFilterCCC Validator(Next);
189 if (TryAnnotateName(/*IsAddressOfOperand*/false, &Validator)
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))
199 // If the identifier was typo-corrected, try again.
200 if (Tok.isNot(tok::identifier))
208 if ((getLangOpts().CPlusPlus || !OnlyStatement) && isDeclarationStatement()) {
209 SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
210 DeclGroupPtrTy Decl = ParseDeclaration(Stmts, Declarator::BlockContext,
212 return Actions.ActOnDeclStmt(Decl, DeclStart, DeclEnd);
215 if (Tok.is(tok::r_brace)) {
216 Diag(Tok, diag::err_expected_statement);
220 return ParseExprStatement();
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();
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);
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);
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";
246 case tok::kw_for: // C99 6.8.5.3: for-statement
247 return ParseForStatement(TrailingElseLoc);
249 case tok::kw_goto: // C99 6.8.6.1: goto-statement
250 Res = ParseGotoStatement();
253 case tok::kw_continue: // C99 6.8.6.2: continue-statement
254 Res = ParseContinueStatement();
255 SemiError = "continue";
257 case tok::kw_break: // C99 6.8.6.3: break-statement
258 Res = ParseBreakStatement();
261 case tok::kw_return: // C99 6.8.6.4: return-statement
262 Res = ParseReturnStatement();
263 SemiError = "return";
267 ProhibitAttributes(Attrs);
269 Res = ParseAsmStatement(msAsm);
270 Res = Actions.ActOnFinishFullStmt(Res.get());
271 if (msAsm) return Res;
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
284 case tok::kw_try: // C++ 15: try-block
285 return ParseCXXTryBlock();
288 ProhibitAttributes(Attrs); // TODO: is it correct?
289 return ParseSEHTryBlock();
291 case tok::kw___leave:
292 Res = ParseSEHLeaveStatement();
293 SemiError = "__leave";
296 case tok::annot_pragma_vis:
297 ProhibitAttributes(Attrs);
298 HandlePragmaVisibility();
301 case tok::annot_pragma_pack:
302 ProhibitAttributes(Attrs);
306 case tok::annot_pragma_msstruct:
307 ProhibitAttributes(Attrs);
308 HandlePragmaMSStruct();
311 case tok::annot_pragma_align:
312 ProhibitAttributes(Attrs);
316 case tok::annot_pragma_weak:
317 ProhibitAttributes(Attrs);
321 case tok::annot_pragma_weakalias:
322 ProhibitAttributes(Attrs);
323 HandlePragmaWeakAlias();
326 case tok::annot_pragma_redefine_extname:
327 ProhibitAttributes(Attrs);
328 HandlePragmaRedefineExtname();
331 case tok::annot_pragma_fp_contract:
332 ProhibitAttributes(Attrs);
333 Diag(Tok, diag::err_pragma_fp_contract_scope);
337 case tok::annot_pragma_opencl_extension:
338 ProhibitAttributes(Attrs);
339 HandlePragmaOpenCLExtension();
342 case tok::annot_pragma_captured:
343 ProhibitAttributes(Attrs);
344 return HandlePragmaCaptured();
346 case tok::annot_pragma_openmp:
347 ProhibitAttributes(Attrs);
348 return ParseOpenMPDeclarativeOrExecutableDirective(!OnlyStatement);
350 case tok::annot_pragma_ms_pointers_to_members:
351 ProhibitAttributes(Attrs);
352 HandlePragmaMSPointersToMembers();
355 case tok::annot_pragma_ms_pragma:
356 ProhibitAttributes(Attrs);
357 HandlePragmaMSPragma();
360 case tok::annot_pragma_loop_hint:
361 ProhibitAttributes(Attrs);
362 return ParsePragmaLoopHint(Stmts, OnlyStatement, TrailingElseLoc, Attrs);
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
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);
378 /// \brief Parse an expression statement.
379 StmtResult Parser::ParseExprStatement() {
380 // If a case keyword is missing, this is where it should be inserted.
381 Token OldToken = Tok;
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))
392 return Actions.ActOnExprStmtError();
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 ");
402 // Recover parsing as a case statement.
403 return ParseCaseStatement(/*MissingCase=*/true, Expr);
406 // Otherwise, eat the semicolon.
407 ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
408 return Actions.ActOnExprStmt(Expr);
411 StmtResult Parser::ParseSEHTryBlock() {
412 assert(Tok.is(tok::kw___try) && "Expected '__try'");
413 SourceLocation Loc = ConsumeToken();
414 return ParseSEHTryBlockCommon(Loc);
417 /// ParseSEHTryBlockCommon
420 /// '__try' compound-statement seh-handler
424 /// seh-finally-block
426 StmtResult Parser::ParseSEHTryBlockCommon(SourceLocation TryLoc) {
427 if (Tok.isNot(tok::l_brace))
428 return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
430 int SEHTryIndex, SEHTryParentIndex;
433 assert(Tok.is(tok::l_brace) && "Not a compount stmt!");
435 // Enter a scope to hold everything within the compound stmt. Compound
436 // statements can always hold declarations.
437 ParseScope CompoundScope(this, Scope::DeclScope | Scope::SEHTryScope);
438 SEHTryIndex = getCurScope()->getSEHTryIndex();
439 SEHTryParentIndex = getCurScope()->getSEHTryParentIndex();
441 // Parse the statements in the body.
442 TryBlock = ParseCompoundStatementBody();
445 //StmtResult TryBlock(ParseCompoundStatement(/*isStmtExpr=*/false,
446 // Scope::DeclScope | Scope::SEHTryScope));
448 if(TryBlock.isInvalid())
452 if (Tok.is(tok::identifier) &&
453 Tok.getIdentifierInfo() == getSEHExceptKeyword()) {
454 SourceLocation Loc = ConsumeToken();
455 Handler = ParseSEHExceptBlock(Loc);
456 } else if (Tok.is(tok::kw___finally)) {
457 SourceLocation Loc = ConsumeToken();
458 Handler = ParseSEHFinallyBlock(Loc);
460 return StmtError(Diag(Tok,diag::err_seh_expected_handler));
463 if(Handler.isInvalid())
466 return Actions.ActOnSEHTryBlock(false /* IsCXXTry */,
474 /// ParseSEHExceptBlock - Handle __except
476 /// seh-except-block:
477 /// '__except' '(' seh-filter-expression ')' compound-statement
479 StmtResult Parser::ParseSEHExceptBlock(SourceLocation ExceptLoc) {
480 PoisonIdentifierRAIIObject raii(Ident__exception_code, false),
481 raii2(Ident___exception_code, false),
482 raii3(Ident_GetExceptionCode, false);
484 if (ExpectAndConsume(tok::l_paren))
487 ParseScope ExpectScope(this, Scope::DeclScope | Scope::ControlScope);
489 if (getLangOpts().Borland) {
490 Ident__exception_info->setIsPoisoned(false);
491 Ident___exception_info->setIsPoisoned(false);
492 Ident_GetExceptionInfo->setIsPoisoned(false);
494 ExprResult FilterExpr(ParseExpression());
496 if (getLangOpts().Borland) {
497 Ident__exception_info->setIsPoisoned(true);
498 Ident___exception_info->setIsPoisoned(true);
499 Ident_GetExceptionInfo->setIsPoisoned(true);
502 if(FilterExpr.isInvalid())
505 if (ExpectAndConsume(tok::r_paren))
508 StmtResult Block(ParseCompoundStatement());
510 if(Block.isInvalid())
513 return Actions.ActOnSEHExceptBlock(ExceptLoc, FilterExpr.get(), Block.get());
516 /// ParseSEHFinallyBlock - Handle __finally
518 /// seh-finally-block:
519 /// '__finally' compound-statement
521 StmtResult Parser::ParseSEHFinallyBlock(SourceLocation FinallyBlock) {
522 PoisonIdentifierRAIIObject raii(Ident__abnormal_termination, false),
523 raii2(Ident___abnormal_termination, false),
524 raii3(Ident_AbnormalTermination, false);
526 StmtResult Block(ParseCompoundStatement());
527 if(Block.isInvalid())
530 return Actions.ActOnSEHFinallyBlock(FinallyBlock,Block.get());
535 /// seh-leave-statement:
538 StmtResult Parser::ParseSEHLeaveStatement() {
539 SourceLocation LeaveLoc = ConsumeToken(); // eat the '__leave'.
540 return Actions.ActOnSEHLeaveStmt(LeaveLoc, getCurScope());
543 /// ParseLabeledStatement - We have an identifier and a ':' after it.
545 /// labeled-statement:
546 /// identifier ':' statement
547 /// [GNU] identifier ':' attributes[opt] statement
549 StmtResult Parser::ParseLabeledStatement(ParsedAttributesWithRange &attrs) {
550 assert(Tok.is(tok::identifier) && Tok.getIdentifierInfo() &&
551 "Not an identifier!");
553 Token IdentTok = Tok; // Save the whole token.
554 ConsumeToken(); // eat the identifier.
556 assert(Tok.is(tok::colon) && "Not a label!");
558 // identifier ':' statement
559 SourceLocation ColonLoc = ConsumeToken();
561 // Read label attributes, if present.
563 if (Tok.is(tok::kw___attribute)) {
564 ParsedAttributesWithRange TempAttrs(AttrFactory);
565 ParseGNUAttributes(TempAttrs);
567 // In C++, GNU attributes only apply to the label if they are followed by a
568 // semicolon, to disambiguate label attributes from attributes on a labeled
571 // This doesn't quite match what GCC does; if the attribute list is empty
572 // and followed by a semicolon, GCC will reject (it appears to parse the
573 // attributes as part of a statement in that case). That looks like a bug.
574 if (!getLangOpts().CPlusPlus || Tok.is(tok::semi))
575 attrs.takeAllFrom(TempAttrs);
576 else if (isDeclarationStatement()) {
578 // FIXME: We should do this whether or not we have a declaration
579 // statement, but that doesn't work correctly (because ProhibitAttributes
580 // can't handle GNU attributes), so only call it in the one case where
581 // GNU attributes are allowed.
582 SubStmt = ParseStatementOrDeclarationAfterAttributes(
583 Stmts, /*OnlyStmts*/ true, nullptr, TempAttrs);
584 if (!TempAttrs.empty() && !SubStmt.isInvalid())
585 SubStmt = Actions.ProcessStmtAttributes(
586 SubStmt.get(), TempAttrs.getList(), TempAttrs.Range);
588 Diag(Tok, diag::err_expected_after) << "__attribute__" << tok::semi;
592 // If we've not parsed a statement yet, parse one now.
593 if (!SubStmt.isInvalid() && !SubStmt.isUsable())
594 SubStmt = ParseStatement();
596 // Broken substmt shouldn't prevent the label from being added to the AST.
597 if (SubStmt.isInvalid())
598 SubStmt = Actions.ActOnNullStmt(ColonLoc);
600 LabelDecl *LD = Actions.LookupOrCreateLabel(IdentTok.getIdentifierInfo(),
601 IdentTok.getLocation());
602 if (AttributeList *Attrs = attrs.getList()) {
603 Actions.ProcessDeclAttributeList(Actions.CurScope, LD, Attrs);
607 return Actions.ActOnLabelStmt(IdentTok.getLocation(), LD, ColonLoc,
611 /// ParseCaseStatement
612 /// labeled-statement:
613 /// 'case' constant-expression ':' statement
614 /// [GNU] 'case' constant-expression '...' constant-expression ':' statement
616 StmtResult Parser::ParseCaseStatement(bool MissingCase, ExprResult Expr) {
617 assert((MissingCase || Tok.is(tok::kw_case)) && "Not a case stmt!");
619 // It is very very common for code to contain many case statements recursively
620 // nested, as in (but usually without indentation):
627 // Parsing this naively works, but is both inefficient and can cause us to run
628 // out of stack space in our recursive descent parser. As a special case,
629 // flatten this recursion into an iterative loop. This is complex and gross,
630 // but all the grossness is constrained to ParseCaseStatement (and some
631 // weirdness in the actions), so this is just local grossness :).
633 // TopLevelCase - This is the highest level we have parsed. 'case 1' in the
635 StmtResult TopLevelCase(true);
637 // DeepestParsedCaseStmt - This is the deepest statement we have parsed, which
638 // gets updated each time a new case is parsed, and whose body is unset so
639 // far. When parsing 'case 4', this is the 'case 3' node.
640 Stmt *DeepestParsedCaseStmt = nullptr;
642 // While we have case statements, eat and stack them.
643 SourceLocation ColonLoc;
645 SourceLocation CaseLoc = MissingCase ? Expr.get()->getExprLoc() :
646 ConsumeToken(); // eat the 'case'.
647 ColonLoc = SourceLocation();
649 if (Tok.is(tok::code_completion)) {
650 Actions.CodeCompleteCase(getCurScope());
655 /// We don't want to treat 'case x : y' as a potential typo for 'case x::y'.
656 /// Disable this form of error recovery while we're parsing the case
658 ColonProtectionRAIIObject ColonProtection(*this);
662 LHS = ParseConstantExpression();
663 if (LHS.isInvalid()) {
664 // If constant-expression is parsed unsuccessfully, recover by skipping
665 // current case statement (moving to the colon that ends it).
666 if (SkipUntil(tok::colon, tok::r_brace, StopAtSemi | StopBeforeMatch)) {
667 TryConsumeToken(tok::colon, ColonLoc);
677 // GNU case range extension.
678 SourceLocation DotDotDotLoc;
680 if (TryConsumeToken(tok::ellipsis, DotDotDotLoc)) {
681 Diag(DotDotDotLoc, diag::ext_gnu_case_range);
682 RHS = ParseConstantExpression();
683 if (RHS.isInvalid()) {
684 if (SkipUntil(tok::colon, tok::r_brace, StopAtSemi | StopBeforeMatch)) {
685 TryConsumeToken(tok::colon, ColonLoc);
692 ColonProtection.restore();
694 if (TryConsumeToken(tok::colon, ColonLoc)) {
695 } else if (TryConsumeToken(tok::semi, ColonLoc) ||
696 TryConsumeToken(tok::coloncolon, ColonLoc)) {
697 // Treat "case blah;" or "case blah::" as a typo for "case blah:".
698 Diag(ColonLoc, diag::err_expected_after)
699 << "'case'" << tok::colon
700 << FixItHint::CreateReplacement(ColonLoc, ":");
702 SourceLocation ExpectedLoc = PP.getLocForEndOfToken(PrevTokLocation);
703 Diag(ExpectedLoc, diag::err_expected_after)
704 << "'case'" << tok::colon
705 << FixItHint::CreateInsertion(ExpectedLoc, ":");
706 ColonLoc = ExpectedLoc;
710 Actions.ActOnCaseStmt(CaseLoc, LHS.get(), DotDotDotLoc,
711 RHS.get(), ColonLoc);
713 // If we had a sema error parsing this case, then just ignore it and
714 // continue parsing the sub-stmt.
715 if (Case.isInvalid()) {
716 if (TopLevelCase.isInvalid()) // No parsed case stmts.
717 return ParseStatement();
718 // Otherwise, just don't add it as a nested case.
720 // If this is the first case statement we parsed, it becomes TopLevelCase.
721 // Otherwise we link it into the current chain.
722 Stmt *NextDeepest = Case.get();
723 if (TopLevelCase.isInvalid())
726 Actions.ActOnCaseStmtBody(DeepestParsedCaseStmt, Case.get());
727 DeepestParsedCaseStmt = NextDeepest;
730 // Handle all case statements.
731 } while (Tok.is(tok::kw_case));
733 // If we found a non-case statement, start by parsing it.
736 if (Tok.isNot(tok::r_brace)) {
737 SubStmt = ParseStatement();
739 // Nicely diagnose the common error "switch (X) { case 4: }", which is
740 // not valid. If ColonLoc doesn't point to a valid text location, there was
741 // another parsing error, so avoid producing extra diagnostics.
742 if (ColonLoc.isValid()) {
743 SourceLocation AfterColonLoc = PP.getLocForEndOfToken(ColonLoc);
744 Diag(AfterColonLoc, diag::err_label_end_of_compound_statement)
745 << FixItHint::CreateInsertion(AfterColonLoc, " ;");
747 SubStmt = StmtError();
750 // Install the body into the most deeply-nested case.
751 if (DeepestParsedCaseStmt) {
752 // Broken sub-stmt shouldn't prevent forming the case statement properly.
753 if (SubStmt.isInvalid())
754 SubStmt = Actions.ActOnNullStmt(SourceLocation());
755 Actions.ActOnCaseStmtBody(DeepestParsedCaseStmt, SubStmt.get());
758 // Return the top level parsed statement tree.
762 /// ParseDefaultStatement
763 /// labeled-statement:
764 /// 'default' ':' statement
765 /// Note that this does not parse the 'statement' at the end.
767 StmtResult Parser::ParseDefaultStatement() {
768 assert(Tok.is(tok::kw_default) && "Not a default stmt!");
769 SourceLocation DefaultLoc = ConsumeToken(); // eat the 'default'.
771 SourceLocation ColonLoc;
772 if (TryConsumeToken(tok::colon, ColonLoc)) {
773 } else if (TryConsumeToken(tok::semi, ColonLoc)) {
774 // Treat "default;" as a typo for "default:".
775 Diag(ColonLoc, diag::err_expected_after)
776 << "'default'" << tok::colon
777 << FixItHint::CreateReplacement(ColonLoc, ":");
779 SourceLocation ExpectedLoc = PP.getLocForEndOfToken(PrevTokLocation);
780 Diag(ExpectedLoc, diag::err_expected_after)
781 << "'default'" << tok::colon
782 << FixItHint::CreateInsertion(ExpectedLoc, ":");
783 ColonLoc = ExpectedLoc;
788 if (Tok.isNot(tok::r_brace)) {
789 SubStmt = ParseStatement();
791 // Diagnose the common error "switch (X) {... default: }", which is
793 SourceLocation AfterColonLoc = PP.getLocForEndOfToken(ColonLoc);
794 Diag(AfterColonLoc, diag::err_label_end_of_compound_statement)
795 << FixItHint::CreateInsertion(AfterColonLoc, " ;");
799 // Broken sub-stmt shouldn't prevent forming the case statement properly.
800 if (SubStmt.isInvalid())
801 SubStmt = Actions.ActOnNullStmt(ColonLoc);
803 return Actions.ActOnDefaultStmt(DefaultLoc, ColonLoc,
804 SubStmt.get(), getCurScope());
807 StmtResult Parser::ParseCompoundStatement(bool isStmtExpr) {
808 return ParseCompoundStatement(isStmtExpr, Scope::DeclScope);
811 /// ParseCompoundStatement - Parse a "{}" block.
813 /// compound-statement: [C99 6.8.2]
814 /// { block-item-list[opt] }
815 /// [GNU] { label-declarations block-item-list } [TODO]
819 /// block-item-list block-item
823 /// [GNU] '__extension__' declaration
826 /// [GNU] label-declarations:
827 /// [GNU] label-declaration
828 /// [GNU] label-declarations label-declaration
830 /// [GNU] label-declaration:
831 /// [GNU] '__label__' identifier-list ';'
833 StmtResult Parser::ParseCompoundStatement(bool isStmtExpr,
834 unsigned ScopeFlags) {
835 assert(Tok.is(tok::l_brace) && "Not a compount stmt!");
837 // Enter a scope to hold everything within the compound stmt. Compound
838 // statements can always hold declarations.
839 ParseScope CompoundScope(this, ScopeFlags);
841 // Parse the statements in the body.
842 return ParseCompoundStatementBody(isStmtExpr);
845 /// Parse any pragmas at the start of the compound expression. We handle these
846 /// separately since some pragmas (FP_CONTRACT) must appear before any C
847 /// statement in the compound, but may be intermingled with other pragmas.
848 void Parser::ParseCompoundStatementLeadingPragmas() {
849 bool checkForPragmas = true;
850 while (checkForPragmas) {
851 switch (Tok.getKind()) {
852 case tok::annot_pragma_vis:
853 HandlePragmaVisibility();
855 case tok::annot_pragma_pack:
858 case tok::annot_pragma_msstruct:
859 HandlePragmaMSStruct();
861 case tok::annot_pragma_align:
864 case tok::annot_pragma_weak:
867 case tok::annot_pragma_weakalias:
868 HandlePragmaWeakAlias();
870 case tok::annot_pragma_redefine_extname:
871 HandlePragmaRedefineExtname();
873 case tok::annot_pragma_opencl_extension:
874 HandlePragmaOpenCLExtension();
876 case tok::annot_pragma_fp_contract:
877 HandlePragmaFPContract();
879 case tok::annot_pragma_ms_pointers_to_members:
880 HandlePragmaMSPointersToMembers();
882 case tok::annot_pragma_ms_pragma:
883 HandlePragmaMSPragma();
886 checkForPragmas = false;
893 /// ParseCompoundStatementBody - Parse a sequence of statements and invoke the
894 /// ActOnCompoundStmt action. This expects the '{' to be the current token, and
895 /// consume the '}' at the end of the block. It does not manipulate the scope
897 StmtResult Parser::ParseCompoundStatementBody(bool isStmtExpr) {
898 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(),
900 "in compound statement ('{}')");
902 // Record the state of the FP_CONTRACT pragma, restore on leaving the
903 // compound statement.
904 Sema::FPContractStateRAII SaveFPContractState(Actions);
906 InMessageExpressionRAIIObject InMessage(*this, false);
907 BalancedDelimiterTracker T(*this, tok::l_brace);
911 Sema::CompoundScopeRAII CompoundScope(Actions);
913 // Parse any pragmas at the beginning of the compound statement.
914 ParseCompoundStatementLeadingPragmas();
918 // "__label__ X, Y, Z;" is the GNU "Local Label" extension. These are
919 // only allowed at the start of a compound stmt regardless of the language.
920 while (Tok.is(tok::kw___label__)) {
921 SourceLocation LabelLoc = ConsumeToken();
923 SmallVector<Decl *, 8> DeclsInGroup;
925 if (Tok.isNot(tok::identifier)) {
926 Diag(Tok, diag::err_expected) << tok::identifier;
930 IdentifierInfo *II = Tok.getIdentifierInfo();
931 SourceLocation IdLoc = ConsumeToken();
932 DeclsInGroup.push_back(Actions.LookupOrCreateLabel(II, IdLoc, LabelLoc));
934 if (!TryConsumeToken(tok::comma))
938 DeclSpec DS(AttrFactory);
940 Actions.FinalizeDeclaratorGroup(getCurScope(), DS, DeclsInGroup);
941 StmtResult R = Actions.ActOnDeclStmt(Res, LabelLoc, Tok.getLocation());
943 ExpectAndConsumeSemi(diag::err_expected_semi_declaration);
945 Stmts.push_back(R.get());
948 while (Tok.isNot(tok::r_brace) && !isEofOrEom()) {
949 if (Tok.is(tok::annot_pragma_unused)) {
950 HandlePragmaUnused();
955 if (Tok.isNot(tok::kw___extension__)) {
956 R = ParseStatementOrDeclaration(Stmts, false);
958 // __extension__ can start declarations and it can also be a unary
959 // operator for expressions. Consume multiple __extension__ markers here
960 // until we can determine which is which.
961 // FIXME: This loses extension expressions in the AST!
962 SourceLocation ExtLoc = ConsumeToken();
963 while (Tok.is(tok::kw___extension__))
966 ParsedAttributesWithRange attrs(AttrFactory);
967 MaybeParseCXX11Attributes(attrs, nullptr,
968 /*MightBeObjCMessageSend*/ true);
970 // If this is the start of a declaration, parse it as such.
971 if (isDeclarationStatement()) {
972 // __extension__ silences extension warnings in the subdeclaration.
973 // FIXME: Save the __extension__ on the decl as a node somehow?
974 ExtensionRAIIObject O(Diags);
976 SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
977 DeclGroupPtrTy Res = ParseDeclaration(Stmts,
978 Declarator::BlockContext, DeclEnd,
980 R = Actions.ActOnDeclStmt(Res, DeclStart, DeclEnd);
982 // Otherwise this was a unary __extension__ marker.
983 ExprResult Res(ParseExpressionWithLeadingExtension(ExtLoc));
985 if (Res.isInvalid()) {
986 SkipUntil(tok::semi);
990 // FIXME: Use attributes?
991 // Eat the semicolon at the end of stmt and convert the expr into a
993 ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
994 R = Actions.ActOnExprStmt(Res);
999 Stmts.push_back(R.get());
1002 SourceLocation CloseLoc = Tok.getLocation();
1004 // We broke out of the while loop because we found a '}' or EOF.
1005 if (!T.consumeClose())
1006 // Recover by creating a compound statement with what we parsed so far,
1007 // instead of dropping everything and returning StmtError();
1008 CloseLoc = T.getCloseLocation();
1010 return Actions.ActOnCompoundStmt(T.getOpenLocation(), CloseLoc,
1014 /// ParseParenExprOrCondition:
1015 /// [C ] '(' expression ')'
1016 /// [C++] '(' condition ')' [not allowed if OnlyAllowCondition=true]
1018 /// This function parses and performs error recovery on the specified condition
1019 /// or expression (depending on whether we're in C++ or C mode). This function
1020 /// goes out of its way to recover well. It returns true if there was a parser
1021 /// error (the right paren couldn't be found), which indicates that the caller
1022 /// should try to recover harder. It returns false if the condition is
1023 /// successfully parsed. Note that a successful parse can still have semantic
1024 /// errors in the condition.
1025 bool Parser::ParseParenExprOrCondition(ExprResult &ExprResult,
1028 bool ConvertToBoolean) {
1029 BalancedDelimiterTracker T(*this, tok::l_paren);
1032 if (getLangOpts().CPlusPlus)
1033 ParseCXXCondition(ExprResult, DeclResult, Loc, ConvertToBoolean);
1035 ExprResult = ParseExpression();
1036 DeclResult = nullptr;
1038 // If required, convert to a boolean value.
1039 if (!ExprResult.isInvalid() && ConvertToBoolean)
1041 = Actions.ActOnBooleanCondition(getCurScope(), Loc, ExprResult.get());
1044 // If the parser was confused by the condition and we don't have a ')', try to
1045 // recover by skipping ahead to a semi and bailing out. If condexp is
1046 // semantically invalid but we have well formed code, keep going.
1047 if (ExprResult.isInvalid() && !DeclResult && Tok.isNot(tok::r_paren)) {
1048 SkipUntil(tok::semi);
1049 // Skipping may have stopped if it found the containing ')'. If so, we can
1050 // continue parsing the if statement.
1051 if (Tok.isNot(tok::r_paren))
1055 // Otherwise the condition is valid or the rparen is present.
1058 // Check for extraneous ')'s to catch things like "if (foo())) {". We know
1059 // that all callers are looking for a statement after the condition, so ")"
1061 while (Tok.is(tok::r_paren)) {
1062 Diag(Tok, diag::err_extraneous_rparen_in_condition)
1063 << FixItHint::CreateRemoval(Tok.getLocation());
1071 /// ParseIfStatement
1072 /// if-statement: [C99 6.8.4.1]
1073 /// 'if' '(' expression ')' statement
1074 /// 'if' '(' expression ')' statement 'else' statement
1075 /// [C++] 'if' '(' condition ')' statement
1076 /// [C++] 'if' '(' condition ')' statement 'else' statement
1078 StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
1079 assert(Tok.is(tok::kw_if) && "Not an if stmt!");
1080 SourceLocation IfLoc = ConsumeToken(); // eat the 'if'.
1082 if (Tok.isNot(tok::l_paren)) {
1083 Diag(Tok, diag::err_expected_lparen_after) << "if";
1084 SkipUntil(tok::semi);
1088 bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1090 // C99 6.8.4p3 - In C99, the if statement is a block. This is not
1091 // the case for C90.
1094 // A name introduced by a declaration in a condition is in scope from its
1095 // point of declaration until the end of the substatements controlled by the
1098 // Names declared in the for-init-statement, and in the condition of if,
1099 // while, for, and switch statements are local to the if, while, for, or
1100 // switch statement (including the controlled statement).
1102 ParseScope IfScope(this, Scope::DeclScope | Scope::ControlScope, C99orCXX);
1104 // Parse the condition.
1106 Decl *CondVar = nullptr;
1107 if (ParseParenExprOrCondition(CondExp, CondVar, IfLoc, true))
1110 FullExprArg FullCondExp(Actions.MakeFullExpr(CondExp.get(), IfLoc));
1112 // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
1113 // there is no compound stmt. C90 does not have this clause. We only do this
1114 // if the body isn't a compound statement to avoid push/pop in common cases.
1117 // The substatement in a selection-statement (each substatement, in the else
1118 // form of the if statement) implicitly defines a local scope.
1120 // For C++ we create a scope for the condition and a new scope for
1121 // substatements because:
1122 // -When the 'then' scope exits, we want the condition declaration to still be
1123 // active for the 'else' scope too.
1124 // -Sema will detect name clashes by considering declarations of a
1125 // 'ControlScope' as part of its direct subscope.
1126 // -If we wanted the condition and substatement to be in the same scope, we
1127 // would have to notify ParseStatement not to create a new scope. It's
1128 // simpler to let it create a new scope.
1130 ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1132 // Read the 'then' stmt.
1133 SourceLocation ThenStmtLoc = Tok.getLocation();
1135 SourceLocation InnerStatementTrailingElseLoc;
1136 StmtResult ThenStmt(ParseStatement(&InnerStatementTrailingElseLoc));
1138 // Pop the 'if' scope if needed.
1141 // If it has an else, parse it.
1142 SourceLocation ElseLoc;
1143 SourceLocation ElseStmtLoc;
1144 StmtResult ElseStmt;
1146 if (Tok.is(tok::kw_else)) {
1147 if (TrailingElseLoc)
1148 *TrailingElseLoc = Tok.getLocation();
1150 ElseLoc = ConsumeToken();
1151 ElseStmtLoc = Tok.getLocation();
1153 // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
1154 // there is no compound stmt. C90 does not have this clause. We only do
1155 // this if the body isn't a compound statement to avoid push/pop in common
1159 // The substatement in a selection-statement (each substatement, in the else
1160 // form of the if statement) implicitly defines a local scope.
1162 ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1164 ElseStmt = ParseStatement();
1166 // Pop the 'else' scope if needed.
1168 } else if (Tok.is(tok::code_completion)) {
1169 Actions.CodeCompleteAfterIf(getCurScope());
1172 } else if (InnerStatementTrailingElseLoc.isValid()) {
1173 Diag(InnerStatementTrailingElseLoc, diag::warn_dangling_else);
1178 // If the then or else stmt is invalid and the other is valid (and present),
1179 // make turn the invalid one into a null stmt to avoid dropping the other
1180 // part. If both are invalid, return error.
1181 if ((ThenStmt.isInvalid() && ElseStmt.isInvalid()) ||
1182 (ThenStmt.isInvalid() && ElseStmt.get() == nullptr) ||
1183 (ThenStmt.get() == nullptr && ElseStmt.isInvalid())) {
1184 // Both invalid, or one is invalid and other is non-present: return error.
1188 // Now if either are invalid, replace with a ';'.
1189 if (ThenStmt.isInvalid())
1190 ThenStmt = Actions.ActOnNullStmt(ThenStmtLoc);
1191 if (ElseStmt.isInvalid())
1192 ElseStmt = Actions.ActOnNullStmt(ElseStmtLoc);
1194 return Actions.ActOnIfStmt(IfLoc, FullCondExp, CondVar, ThenStmt.get(),
1195 ElseLoc, ElseStmt.get());
1198 /// ParseSwitchStatement
1199 /// switch-statement:
1200 /// 'switch' '(' expression ')' statement
1201 /// [C++] 'switch' '(' condition ')' statement
1202 StmtResult Parser::ParseSwitchStatement(SourceLocation *TrailingElseLoc) {
1203 assert(Tok.is(tok::kw_switch) && "Not a switch stmt!");
1204 SourceLocation SwitchLoc = ConsumeToken(); // eat the 'switch'.
1206 if (Tok.isNot(tok::l_paren)) {
1207 Diag(Tok, diag::err_expected_lparen_after) << "switch";
1208 SkipUntil(tok::semi);
1212 bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1214 // C99 6.8.4p3 - In C99, the switch statement is a block. This is
1215 // not the case for C90. Start the switch scope.
1218 // A name introduced by a declaration in a condition is in scope from its
1219 // point of declaration until the end of the substatements controlled by the
1222 // Names declared in the for-init-statement, and in the condition of if,
1223 // while, for, and switch statements are local to the if, while, for, or
1224 // switch statement (including the controlled statement).
1226 unsigned ScopeFlags = Scope::SwitchScope;
1228 ScopeFlags |= Scope::DeclScope | Scope::ControlScope;
1229 ParseScope SwitchScope(this, ScopeFlags);
1231 // Parse the condition.
1233 Decl *CondVar = nullptr;
1234 if (ParseParenExprOrCondition(Cond, CondVar, SwitchLoc, false))
1238 = Actions.ActOnStartOfSwitchStmt(SwitchLoc, Cond.get(), CondVar);
1240 if (Switch.isInvalid()) {
1241 // Skip the switch body.
1242 // FIXME: This is not optimal recovery, but parsing the body is more
1243 // dangerous due to the presence of case and default statements, which
1244 // will have no place to connect back with the switch.
1245 if (Tok.is(tok::l_brace)) {
1247 SkipUntil(tok::r_brace);
1249 SkipUntil(tok::semi);
1253 // C99 6.8.4p3 - In C99, the body of the switch statement is a scope, even if
1254 // there is no compound stmt. C90 does not have this clause. We only do this
1255 // if the body isn't a compound statement to avoid push/pop in common cases.
1258 // The substatement in a selection-statement (each substatement, in the else
1259 // form of the if statement) implicitly defines a local scope.
1261 // See comments in ParseIfStatement for why we create a scope for the
1262 // condition and a new scope for substatement in C++.
1264 getCurScope()->AddFlags(Scope::BreakScope);
1265 ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1267 // We have incremented the mangling number for the SwitchScope and the
1268 // InnerScope, which is one too many.
1270 getCurScope()->decrementMSLocalManglingNumber();
1272 // Read the body statement.
1273 StmtResult Body(ParseStatement(TrailingElseLoc));
1279 return Actions.ActOnFinishSwitchStmt(SwitchLoc, Switch.get(), Body.get());
1282 /// ParseWhileStatement
1283 /// while-statement: [C99 6.8.5.1]
1284 /// 'while' '(' expression ')' statement
1285 /// [C++] 'while' '(' condition ')' statement
1286 StmtResult Parser::ParseWhileStatement(SourceLocation *TrailingElseLoc) {
1287 assert(Tok.is(tok::kw_while) && "Not a while stmt!");
1288 SourceLocation WhileLoc = Tok.getLocation();
1289 ConsumeToken(); // eat the 'while'.
1291 if (Tok.isNot(tok::l_paren)) {
1292 Diag(Tok, diag::err_expected_lparen_after) << "while";
1293 SkipUntil(tok::semi);
1297 bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1299 // C99 6.8.5p5 - In C99, the while statement is a block. This is not
1300 // the case for C90. Start the loop scope.
1303 // A name introduced by a declaration in a condition is in scope from its
1304 // point of declaration until the end of the substatements controlled by the
1307 // Names declared in the for-init-statement, and in the condition of if,
1308 // while, for, and switch statements are local to the if, while, for, or
1309 // switch statement (including the controlled statement).
1311 unsigned ScopeFlags;
1313 ScopeFlags = Scope::BreakScope | Scope::ContinueScope |
1314 Scope::DeclScope | Scope::ControlScope;
1316 ScopeFlags = Scope::BreakScope | Scope::ContinueScope;
1317 ParseScope WhileScope(this, ScopeFlags);
1319 // Parse the condition.
1321 Decl *CondVar = nullptr;
1322 if (ParseParenExprOrCondition(Cond, CondVar, WhileLoc, true))
1325 FullExprArg FullCond(Actions.MakeFullExpr(Cond.get(), WhileLoc));
1327 // C99 6.8.5p5 - In C99, the body of the while statement is a scope, even if
1328 // there is no compound stmt. C90 does not have this clause. We only do this
1329 // if the body isn't a compound statement to avoid push/pop in common cases.
1332 // The substatement in an iteration-statement implicitly defines a local scope
1333 // which is entered and exited each time through the loop.
1335 // See comments in ParseIfStatement for why we create a scope for the
1336 // condition and a new scope for substatement in C++.
1338 ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1340 // Read the body statement.
1341 StmtResult Body(ParseStatement(TrailingElseLoc));
1343 // Pop the body scope if needed.
1347 if ((Cond.isInvalid() && !CondVar) || Body.isInvalid())
1350 return Actions.ActOnWhileStmt(WhileLoc, FullCond, CondVar, Body.get());
1353 /// ParseDoStatement
1354 /// do-statement: [C99 6.8.5.2]
1355 /// 'do' statement 'while' '(' expression ')' ';'
1356 /// Note: this lets the caller parse the end ';'.
1357 StmtResult Parser::ParseDoStatement() {
1358 assert(Tok.is(tok::kw_do) && "Not a do stmt!");
1359 SourceLocation DoLoc = ConsumeToken(); // eat the 'do'.
1361 // C99 6.8.5p5 - In C99, the do statement is a block. This is not
1362 // the case for C90. Start the loop scope.
1363 unsigned ScopeFlags;
1364 if (getLangOpts().C99)
1365 ScopeFlags = Scope::BreakScope | Scope::ContinueScope | Scope::DeclScope;
1367 ScopeFlags = Scope::BreakScope | Scope::ContinueScope;
1369 ParseScope DoScope(this, ScopeFlags);
1371 // C99 6.8.5p5 - In C99, the body of the do statement is a scope, even if
1372 // there is no compound stmt. C90 does not have this clause. We only do this
1373 // if the body isn't a compound statement to avoid push/pop in common cases.
1376 // The substatement in an iteration-statement implicitly defines a local scope
1377 // which is entered and exited each time through the loop.
1379 bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1380 ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1382 // Read the body statement.
1383 StmtResult Body(ParseStatement());
1385 // Pop the body scope if needed.
1388 if (Tok.isNot(tok::kw_while)) {
1389 if (!Body.isInvalid()) {
1390 Diag(Tok, diag::err_expected_while);
1391 Diag(DoLoc, diag::note_matching) << "'do'";
1392 SkipUntil(tok::semi, StopBeforeMatch);
1396 SourceLocation WhileLoc = ConsumeToken();
1398 if (Tok.isNot(tok::l_paren)) {
1399 Diag(Tok, diag::err_expected_lparen_after) << "do/while";
1400 SkipUntil(tok::semi, StopBeforeMatch);
1404 // Parse the parenthesized expression.
1405 BalancedDelimiterTracker T(*this, tok::l_paren);
1408 // A do-while expression is not a condition, so can't have attributes.
1409 DiagnoseAndSkipCXX11Attributes();
1411 ExprResult Cond = ParseExpression();
1415 if (Cond.isInvalid() || Body.isInvalid())
1418 return Actions.ActOnDoStmt(DoLoc, Body.get(), WhileLoc, T.getOpenLocation(),
1419 Cond.get(), T.getCloseLocation());
1422 bool Parser::isForRangeIdentifier() {
1423 assert(Tok.is(tok::identifier));
1425 const Token &Next = NextToken();
1426 if (Next.is(tok::colon))
1429 if (Next.is(tok::l_square) || Next.is(tok::kw_alignas)) {
1430 TentativeParsingAction PA(*this);
1432 SkipCXX11Attributes();
1433 bool Result = Tok.is(tok::colon);
1441 /// ParseForStatement
1442 /// for-statement: [C99 6.8.5.3]
1443 /// 'for' '(' expr[opt] ';' expr[opt] ';' expr[opt] ')' statement
1444 /// 'for' '(' declaration expr[opt] ';' expr[opt] ')' statement
1445 /// [C++] 'for' '(' for-init-statement condition[opt] ';' expression[opt] ')'
1447 /// [C++0x] 'for' '(' for-range-declaration : for-range-initializer ) statement
1448 /// [OBJC2] 'for' '(' declaration 'in' expr ')' statement
1449 /// [OBJC2] 'for' '(' expr 'in' expr ')' statement
1451 /// [C++] for-init-statement:
1452 /// [C++] expression-statement
1453 /// [C++] simple-declaration
1455 /// [C++0x] for-range-declaration:
1456 /// [C++0x] attribute-specifier-seq[opt] type-specifier-seq declarator
1457 /// [C++0x] for-range-initializer:
1458 /// [C++0x] expression
1459 /// [C++0x] braced-init-list [TODO]
1460 StmtResult Parser::ParseForStatement(SourceLocation *TrailingElseLoc) {
1461 assert(Tok.is(tok::kw_for) && "Not a for stmt!");
1462 SourceLocation ForLoc = ConsumeToken(); // eat the 'for'.
1464 if (Tok.isNot(tok::l_paren)) {
1465 Diag(Tok, diag::err_expected_lparen_after) << "for";
1466 SkipUntil(tok::semi);
1470 bool C99orCXXorObjC = getLangOpts().C99 || getLangOpts().CPlusPlus ||
1471 getLangOpts().ObjC1;
1473 // C99 6.8.5p5 - In C99, the for statement is a block. This is not
1474 // the case for C90. Start the loop scope.
1477 // A name introduced by a declaration in a condition is in scope from its
1478 // point of declaration until the end of the substatements controlled by the
1481 // Names declared in the for-init-statement, and in the condition of if,
1482 // while, for, and switch statements are local to the if, while, for, or
1483 // switch statement (including the controlled statement).
1485 // Names declared in the for-init-statement are in the same declarative-region
1486 // as those declared in the condition.
1488 unsigned ScopeFlags = 0;
1490 ScopeFlags = Scope::DeclScope | Scope::ControlScope;
1492 ParseScope ForScope(this, ScopeFlags);
1494 BalancedDelimiterTracker T(*this, tok::l_paren);
1499 bool ForEach = false, ForRange = false;
1500 StmtResult FirstPart;
1501 bool SecondPartIsInvalid = false;
1502 FullExprArg SecondPart(Actions);
1503 ExprResult Collection;
1504 ForRangeInit ForRangeInit;
1505 FullExprArg ThirdPart(Actions);
1506 Decl *SecondVar = nullptr;
1508 if (Tok.is(tok::code_completion)) {
1509 Actions.CodeCompleteOrdinaryName(getCurScope(),
1510 C99orCXXorObjC? Sema::PCC_ForInit
1511 : Sema::PCC_Expression);
1516 ParsedAttributesWithRange attrs(AttrFactory);
1517 MaybeParseCXX11Attributes(attrs);
1519 // Parse the first part of the for specifier.
1520 if (Tok.is(tok::semi)) { // for (;
1521 ProhibitAttributes(attrs);
1522 // no first part, eat the ';'.
1524 } else if (getLangOpts().CPlusPlus && Tok.is(tok::identifier) &&
1525 isForRangeIdentifier()) {
1526 ProhibitAttributes(attrs);
1527 IdentifierInfo *Name = Tok.getIdentifierInfo();
1528 SourceLocation Loc = ConsumeToken();
1529 MaybeParseCXX11Attributes(attrs);
1531 ForRangeInit.ColonLoc = ConsumeToken();
1532 if (Tok.is(tok::l_brace))
1533 ForRangeInit.RangeExpr = ParseBraceInitializer();
1535 ForRangeInit.RangeExpr = ParseExpression();
1537 Diag(Loc, getLangOpts().CPlusPlus1z
1538 ? diag::warn_cxx1y_compat_for_range_identifier
1539 : diag::ext_for_range_identifier)
1540 << ((getLangOpts().CPlusPlus11 && !getLangOpts().CPlusPlus1z)
1541 ? FixItHint::CreateInsertion(Loc, "auto &&")
1544 FirstPart = Actions.ActOnCXXForRangeIdentifier(getCurScope(), Loc, Name,
1545 attrs, attrs.Range.getEnd());
1547 } else if (isForInitDeclaration()) { // for (int X = 4;
1548 // Parse declaration, which eats the ';'.
1549 if (!C99orCXXorObjC) // Use of C99-style for loops in C90 mode?
1550 Diag(Tok, diag::ext_c99_variable_decl_in_for_loop);
1552 // In C++0x, "for (T NS:a" might not be a typo for ::
1553 bool MightBeForRangeStmt = getLangOpts().CPlusPlus;
1554 ColonProtectionRAIIObject ColonProtection(*this, MightBeForRangeStmt);
1556 SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
1558 DeclGroupPtrTy DG = ParseSimpleDeclaration(
1559 Stmts, Declarator::ForContext, DeclEnd, attrs, false,
1560 MightBeForRangeStmt ? &ForRangeInit : nullptr);
1561 FirstPart = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
1562 if (ForRangeInit.ParsedForRangeDecl()) {
1563 Diag(ForRangeInit.ColonLoc, getLangOpts().CPlusPlus11 ?
1564 diag::warn_cxx98_compat_for_range : diag::ext_for_range);
1567 } else if (Tok.is(tok::semi)) { // for (int x = 4;
1569 } else if ((ForEach = isTokIdentifier_in())) {
1570 Actions.ActOnForEachDeclStmt(DG);
1571 // ObjC: for (id x in expr)
1572 ConsumeToken(); // consume 'in'
1574 if (Tok.is(tok::code_completion)) {
1575 Actions.CodeCompleteObjCForCollection(getCurScope(), DG);
1579 Collection = ParseExpression();
1581 Diag(Tok, diag::err_expected_semi_for);
1584 ProhibitAttributes(attrs);
1585 Value = ParseExpression();
1587 ForEach = isTokIdentifier_in();
1589 // Turn the expression into a stmt.
1590 if (!Value.isInvalid()) {
1592 FirstPart = Actions.ActOnForEachLValueExpr(Value.get());
1594 FirstPart = Actions.ActOnExprStmt(Value);
1597 if (Tok.is(tok::semi)) {
1599 } else if (ForEach) {
1600 ConsumeToken(); // consume 'in'
1602 if (Tok.is(tok::code_completion)) {
1603 Actions.CodeCompleteObjCForCollection(getCurScope(), DeclGroupPtrTy());
1607 Collection = ParseExpression();
1608 } else if (getLangOpts().CPlusPlus11 && Tok.is(tok::colon) && FirstPart.get()) {
1609 // User tried to write the reasonable, but ill-formed, for-range-statement
1610 // for (expr : expr) { ... }
1611 Diag(Tok, diag::err_for_range_expected_decl)
1612 << FirstPart.get()->getSourceRange();
1613 SkipUntil(tok::r_paren, StopBeforeMatch);
1614 SecondPartIsInvalid = true;
1616 if (!Value.isInvalid()) {
1617 Diag(Tok, diag::err_expected_semi_for);
1619 // Skip until semicolon or rparen, don't consume it.
1620 SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch);
1621 if (Tok.is(tok::semi))
1627 // Parse the second part of the for specifier.
1628 getCurScope()->AddFlags(Scope::BreakScope | Scope::ContinueScope);
1629 if (!ForEach && !ForRange) {
1630 assert(!SecondPart.get() && "Shouldn't have a second expression yet.");
1631 // Parse the second part of the for specifier.
1632 if (Tok.is(tok::semi)) { // for (...;;
1634 } else if (Tok.is(tok::r_paren)) {
1635 // missing both semicolons.
1638 if (getLangOpts().CPlusPlus)
1639 ParseCXXCondition(Second, SecondVar, ForLoc, true);
1641 Second = ParseExpression();
1642 if (!Second.isInvalid())
1643 Second = Actions.ActOnBooleanCondition(getCurScope(), ForLoc,
1646 SecondPartIsInvalid = Second.isInvalid();
1647 SecondPart = Actions.MakeFullExpr(Second.get(), ForLoc);
1650 if (Tok.isNot(tok::semi)) {
1651 if (!SecondPartIsInvalid || SecondVar)
1652 Diag(Tok, diag::err_expected_semi_for);
1654 // Skip until semicolon or rparen, don't consume it.
1655 SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch);
1658 if (Tok.is(tok::semi)) {
1662 // Parse the third part of the for specifier.
1663 if (Tok.isNot(tok::r_paren)) { // for (...;...;)
1664 ExprResult Third = ParseExpression();
1665 // FIXME: The C++11 standard doesn't actually say that this is a
1666 // discarded-value expression, but it clearly should be.
1667 ThirdPart = Actions.MakeFullDiscardedValueExpr(Third.get());
1673 // We need to perform most of the semantic analysis for a C++0x for-range
1674 // statememt before parsing the body, in order to be able to deduce the type
1675 // of an auto-typed loop variable.
1676 StmtResult ForRangeStmt;
1677 StmtResult ForEachStmt;
1680 ForRangeStmt = Actions.ActOnCXXForRangeStmt(ForLoc, FirstPart.get(),
1681 ForRangeInit.ColonLoc,
1682 ForRangeInit.RangeExpr.get(),
1683 T.getCloseLocation(),
1687 // Similarly, we need to do the semantic analysis for a for-range
1688 // statement immediately in order to close over temporaries correctly.
1689 } else if (ForEach) {
1690 ForEachStmt = Actions.ActOnObjCForCollectionStmt(ForLoc,
1693 T.getCloseLocation());
1696 // C99 6.8.5p5 - In C99, the body of the for statement is a scope, even if
1697 // there is no compound stmt. C90 does not have this clause. We only do this
1698 // if the body isn't a compound statement to avoid push/pop in common cases.
1701 // The substatement in an iteration-statement implicitly defines a local scope
1702 // which is entered and exited each time through the loop.
1704 // See comments in ParseIfStatement for why we create a scope for
1705 // for-init-statement/condition and a new scope for substatement in C++.
1707 ParseScope InnerScope(this, Scope::DeclScope, C99orCXXorObjC,
1708 Tok.is(tok::l_brace));
1710 // The body of the for loop has the same local mangling number as the
1711 // for-init-statement.
1712 // It will only be incremented if the body contains other things that would
1713 // normally increment the mangling number (like a compound statement).
1715 getCurScope()->decrementMSLocalManglingNumber();
1717 // Read the body statement.
1718 StmtResult Body(ParseStatement(TrailingElseLoc));
1720 // Pop the body scope if needed.
1723 // Leave the for-scope.
1726 if (Body.isInvalid())
1730 return Actions.FinishObjCForCollectionStmt(ForEachStmt.get(),
1734 return Actions.FinishCXXForRangeStmt(ForRangeStmt.get(), Body.get());
1736 return Actions.ActOnForStmt(ForLoc, T.getOpenLocation(), FirstPart.get(),
1737 SecondPart, SecondVar, ThirdPart,
1738 T.getCloseLocation(), Body.get());
1741 /// ParseGotoStatement
1743 /// 'goto' identifier ';'
1744 /// [GNU] 'goto' '*' expression ';'
1746 /// Note: this lets the caller parse the end ';'.
1748 StmtResult Parser::ParseGotoStatement() {
1749 assert(Tok.is(tok::kw_goto) && "Not a goto stmt!");
1750 SourceLocation GotoLoc = ConsumeToken(); // eat the 'goto'.
1753 if (Tok.is(tok::identifier)) {
1754 LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
1756 Res = Actions.ActOnGotoStmt(GotoLoc, Tok.getLocation(), LD);
1758 } else if (Tok.is(tok::star)) {
1759 // GNU indirect goto extension.
1760 Diag(Tok, diag::ext_gnu_indirect_goto);
1761 SourceLocation StarLoc = ConsumeToken();
1762 ExprResult R(ParseExpression());
1763 if (R.isInvalid()) { // Skip to the semicolon, but don't consume it.
1764 SkipUntil(tok::semi, StopBeforeMatch);
1767 Res = Actions.ActOnIndirectGotoStmt(GotoLoc, StarLoc, R.get());
1769 Diag(Tok, diag::err_expected) << tok::identifier;
1776 /// ParseContinueStatement
1780 /// Note: this lets the caller parse the end ';'.
1782 StmtResult Parser::ParseContinueStatement() {
1783 SourceLocation ContinueLoc = ConsumeToken(); // eat the 'continue'.
1784 return Actions.ActOnContinueStmt(ContinueLoc, getCurScope());
1787 /// ParseBreakStatement
1791 /// Note: this lets the caller parse the end ';'.
1793 StmtResult Parser::ParseBreakStatement() {
1794 SourceLocation BreakLoc = ConsumeToken(); // eat the 'break'.
1795 return Actions.ActOnBreakStmt(BreakLoc, getCurScope());
1798 /// ParseReturnStatement
1800 /// 'return' expression[opt] ';'
1801 StmtResult Parser::ParseReturnStatement() {
1802 assert(Tok.is(tok::kw_return) && "Not a return stmt!");
1803 SourceLocation ReturnLoc = ConsumeToken(); // eat the 'return'.
1806 if (Tok.isNot(tok::semi)) {
1807 if (Tok.is(tok::code_completion)) {
1808 Actions.CodeCompleteReturn(getCurScope());
1813 if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus) {
1814 R = ParseInitializer();
1816 Diag(R.get()->getLocStart(), getLangOpts().CPlusPlus11 ?
1817 diag::warn_cxx98_compat_generalized_initializer_lists :
1818 diag::ext_generalized_initializer_lists)
1819 << R.get()->getSourceRange();
1821 R = ParseExpression();
1822 if (R.isInvalid()) {
1823 SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
1827 return Actions.ActOnReturnStmt(ReturnLoc, R.get(), getCurScope());
1830 StmtResult Parser::ParsePragmaLoopHint(StmtVector &Stmts, bool OnlyStatement,
1831 SourceLocation *TrailingElseLoc,
1832 ParsedAttributesWithRange &Attrs) {
1833 // Create temporary attribute list.
1834 ParsedAttributesWithRange TempAttrs(AttrFactory);
1836 // Get loop hints and consume annotated token.
1837 while (Tok.is(tok::annot_pragma_loop_hint)) {
1838 LoopHint Hint = HandlePragmaLoopHint();
1841 ArgsUnion ArgHints[] = {Hint.PragmaNameLoc, Hint.OptionLoc, Hint.ValueLoc,
1842 ArgsUnion(Hint.ValueExpr)};
1843 TempAttrs.addNew(Hint.PragmaNameLoc->Ident, Hint.Range, nullptr,
1844 Hint.PragmaNameLoc->Loc, ArgHints, 4,
1845 AttributeList::AS_Pragma);
1848 // Get the next statement.
1849 MaybeParseCXX11Attributes(Attrs);
1851 StmtResult S = ParseStatementOrDeclarationAfterAttributes(
1852 Stmts, OnlyStatement, TrailingElseLoc, Attrs);
1854 Attrs.takeAllFrom(TempAttrs);
1858 Decl *Parser::ParseFunctionStatementBody(Decl *Decl, ParseScope &BodyScope) {
1859 assert(Tok.is(tok::l_brace));
1860 SourceLocation LBraceLoc = Tok.getLocation();
1862 if (SkipFunctionBodies && (!Decl || Actions.canSkipFunctionBody(Decl)) &&
1863 trySkippingFunctionBody()) {
1865 return Actions.ActOnSkippedFunctionBody(Decl);
1868 PrettyDeclStackTraceEntry CrashInfo(Actions, Decl, LBraceLoc,
1869 "parsing function body");
1871 // Do not enter a scope for the brace, as the arguments are in the same scope
1872 // (the function body) as the body itself. Instead, just read the statement
1873 // list and put it into a CompoundStmt for safe keeping.
1874 StmtResult FnBody(ParseCompoundStatementBody());
1876 // If the function body could not be parsed, make a bogus compoundstmt.
1877 if (FnBody.isInvalid()) {
1878 Sema::CompoundScopeRAII CompoundScope(Actions);
1879 FnBody = Actions.ActOnCompoundStmt(LBraceLoc, LBraceLoc, None, false);
1883 return Actions.ActOnFinishFunctionBody(Decl, FnBody.get());
1886 /// ParseFunctionTryBlock - Parse a C++ function-try-block.
1888 /// function-try-block:
1889 /// 'try' ctor-initializer[opt] compound-statement handler-seq
1891 Decl *Parser::ParseFunctionTryBlock(Decl *Decl, ParseScope &BodyScope) {
1892 assert(Tok.is(tok::kw_try) && "Expected 'try'");
1893 SourceLocation TryLoc = ConsumeToken();
1895 PrettyDeclStackTraceEntry CrashInfo(Actions, Decl, TryLoc,
1896 "parsing function try block");
1898 // Constructor initializer list?
1899 if (Tok.is(tok::colon))
1900 ParseConstructorInitializer(Decl);
1902 Actions.ActOnDefaultCtorInitializers(Decl);
1904 if (SkipFunctionBodies && Actions.canSkipFunctionBody(Decl) &&
1905 trySkippingFunctionBody()) {
1907 return Actions.ActOnSkippedFunctionBody(Decl);
1910 SourceLocation LBraceLoc = Tok.getLocation();
1911 StmtResult FnBody(ParseCXXTryBlockCommon(TryLoc, /*FnTry*/true));
1912 // If we failed to parse the try-catch, we just give the function an empty
1913 // compound statement as the body.
1914 if (FnBody.isInvalid()) {
1915 Sema::CompoundScopeRAII CompoundScope(Actions);
1916 FnBody = Actions.ActOnCompoundStmt(LBraceLoc, LBraceLoc, None, false);
1920 return Actions.ActOnFinishFunctionBody(Decl, FnBody.get());
1923 bool Parser::trySkippingFunctionBody() {
1924 assert(Tok.is(tok::l_brace));
1925 assert(SkipFunctionBodies &&
1926 "Should only be called when SkipFunctionBodies is enabled");
1928 if (!PP.isCodeCompletionEnabled()) {
1930 SkipUntil(tok::r_brace);
1934 // We're in code-completion mode. Skip parsing for all function bodies unless
1935 // the body contains the code-completion point.
1936 TentativeParsingAction PA(*this);
1938 if (SkipUntil(tok::r_brace, StopAtCodeCompletion)) {
1947 /// ParseCXXTryBlock - Parse a C++ try-block.
1950 /// 'try' compound-statement handler-seq
1952 StmtResult Parser::ParseCXXTryBlock() {
1953 assert(Tok.is(tok::kw_try) && "Expected 'try'");
1955 SourceLocation TryLoc = ConsumeToken();
1956 return ParseCXXTryBlockCommon(TryLoc);
1959 /// ParseCXXTryBlockCommon - Parse the common part of try-block and
1960 /// function-try-block.
1963 /// 'try' compound-statement handler-seq
1965 /// function-try-block:
1966 /// 'try' ctor-initializer[opt] compound-statement handler-seq
1969 /// handler handler-seq[opt]
1971 /// [Borland] try-block:
1972 /// 'try' compound-statement seh-except-block
1973 /// 'try' compound-statement seh-finally-block
1975 StmtResult Parser::ParseCXXTryBlockCommon(SourceLocation TryLoc, bool FnTry) {
1976 if (Tok.isNot(tok::l_brace))
1977 return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
1978 // FIXME: Possible draft standard bug: attribute-specifier should be allowed?
1980 int SEHTryIndex, SEHTryParentIndex;
1981 StmtResult TryBlock;
1983 assert(Tok.is(tok::l_brace) && "Not a compount stmt!");
1985 // Enter a scope to hold everything within the compound stmt. Compound
1986 // statements can always hold declarations.
1987 ParseScope CompoundScope(this, Scope::DeclScope | Scope::TryScope |
1988 (FnTry ? Scope::FnTryCatchScope : 0));
1989 SEHTryIndex = getCurScope()->getSEHTryIndex();
1990 SEHTryParentIndex = getCurScope()->getSEHTryParentIndex();
1992 // Parse the statements in the body.
1993 TryBlock = ParseCompoundStatementBody();
1995 if (TryBlock.isInvalid())
1998 // Borland allows SEH-handlers with 'try'
2000 if ((Tok.is(tok::identifier) &&
2001 Tok.getIdentifierInfo() == getSEHExceptKeyword()) ||
2002 Tok.is(tok::kw___finally)) {
2003 // TODO: Factor into common return ParseSEHHandlerCommon(...)
2005 if(Tok.getIdentifierInfo() == getSEHExceptKeyword()) {
2006 SourceLocation Loc = ConsumeToken();
2007 Handler = ParseSEHExceptBlock(Loc);
2010 SourceLocation Loc = ConsumeToken();
2011 Handler = ParseSEHFinallyBlock(Loc);
2013 if(Handler.isInvalid())
2016 return Actions.ActOnSEHTryBlock(true /* IsCXXTry */,
2024 StmtVector Handlers;
2026 // C++11 attributes can't appear here, despite this context seeming
2028 DiagnoseAndSkipCXX11Attributes();
2030 if (Tok.isNot(tok::kw_catch))
2031 return StmtError(Diag(Tok, diag::err_expected_catch));
2032 while (Tok.is(tok::kw_catch)) {
2033 StmtResult Handler(ParseCXXCatchBlock(FnTry));
2034 if (!Handler.isInvalid())
2035 Handlers.push_back(Handler.get());
2037 // Don't bother creating the full statement if we don't have any usable
2039 if (Handlers.empty())
2042 return Actions.ActOnCXXTryBlock(TryLoc, TryBlock.get(), Handlers);
2046 /// ParseCXXCatchBlock - Parse a C++ catch block, called handler in the standard
2049 /// 'catch' '(' exception-declaration ')' compound-statement
2051 /// exception-declaration:
2052 /// attribute-specifier-seq[opt] type-specifier-seq declarator
2053 /// attribute-specifier-seq[opt] type-specifier-seq abstract-declarator[opt]
2056 StmtResult Parser::ParseCXXCatchBlock(bool FnCatch) {
2057 assert(Tok.is(tok::kw_catch) && "Expected 'catch'");
2059 SourceLocation CatchLoc = ConsumeToken();
2061 BalancedDelimiterTracker T(*this, tok::l_paren);
2062 if (T.expectAndConsume())
2066 // The name in a catch exception-declaration is local to the handler and
2067 // shall not be redeclared in the outermost block of the handler.
2068 ParseScope CatchScope(this, Scope::DeclScope | Scope::ControlScope |
2069 (FnCatch ? Scope::FnTryCatchScope : 0));
2071 // exception-declaration is equivalent to '...' or a parameter-declaration
2072 // without default arguments.
2073 Decl *ExceptionDecl = nullptr;
2074 if (Tok.isNot(tok::ellipsis)) {
2075 ParsedAttributesWithRange Attributes(AttrFactory);
2076 MaybeParseCXX11Attributes(Attributes);
2078 DeclSpec DS(AttrFactory);
2079 DS.takeAttributesFrom(Attributes);
2081 if (ParseCXXTypeSpecifierSeq(DS))
2084 Declarator ExDecl(DS, Declarator::CXXCatchContext);
2085 ParseDeclarator(ExDecl);
2086 ExceptionDecl = Actions.ActOnExceptionDeclarator(getCurScope(), ExDecl);
2091 if (T.getCloseLocation().isInvalid())
2094 if (Tok.isNot(tok::l_brace))
2095 return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
2097 // FIXME: Possible draft standard bug: attribute-specifier should be allowed?
2098 StmtResult Block(ParseCompoundStatement());
2099 if (Block.isInvalid())
2102 return Actions.ActOnCXXCatchBlock(CatchLoc, ExceptionDecl, Block.get());
2105 void Parser::ParseMicrosoftIfExistsStatement(StmtVector &Stmts) {
2106 IfExistsCondition Result;
2107 if (ParseMicrosoftIfExistsCondition(Result))
2110 // Handle dependent statements by parsing the braces as a compound statement.
2111 // This is not the same behavior as Visual C++, which don't treat this as a
2112 // compound statement, but for Clang's type checking we can't have anything
2113 // inside these braces escaping to the surrounding code.
2114 if (Result.Behavior == IEB_Dependent) {
2115 if (!Tok.is(tok::l_brace)) {
2116 Diag(Tok, diag::err_expected) << tok::l_brace;
2120 StmtResult Compound = ParseCompoundStatement();
2121 if (Compound.isInvalid())
2124 StmtResult DepResult = Actions.ActOnMSDependentExistsStmt(Result.KeywordLoc,
2129 if (DepResult.isUsable())
2130 Stmts.push_back(DepResult.get());
2134 BalancedDelimiterTracker Braces(*this, tok::l_brace);
2135 if (Braces.consumeOpen()) {
2136 Diag(Tok, diag::err_expected) << tok::l_brace;
2140 switch (Result.Behavior) {
2142 // Parse the statements below.
2146 llvm_unreachable("Dependent case handled above");
2153 // Condition is true, parse the statements.
2154 while (Tok.isNot(tok::r_brace)) {
2155 StmtResult R = ParseStatementOrDeclaration(Stmts, false);
2157 Stmts.push_back(R.get());
2159 Braces.consumeClose();