clang 8.0.0

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