clang  15.0.0git
ParseStmt.cpp
Go to the documentation of this file.
1 //===--- ParseStmt.cpp - Statement and Block Parser -----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Statement and Block portions of the Parser
10 // interface.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "clang/Basic/Attributes.h"
17 #include "clang/Parse/LoopHint.h"
18 #include "clang/Parse/Parser.h"
20 #include "clang/Sema/DeclSpec.h"
21 #include "clang/Sema/Scope.h"
23 #include "llvm/ADT/STLExtras.h"
24 
25 using namespace clang;
26 
27 //===----------------------------------------------------------------------===//
28 // C99 6.8: Statements and Blocks.
29 //===----------------------------------------------------------------------===//
30 
31 /// Parse a standalone statement (for instance, as the body of an 'if',
32 /// 'while', or 'for').
33 StmtResult Parser::ParseStatement(SourceLocation *TrailingElseLoc,
34  ParsedStmtContext StmtCtx) {
35  StmtResult Res;
36 
37  // We may get back a null statement if we found a #pragma. Keep going until
38  // we get an actual statement.
39  do {
40  StmtVector Stmts;
41  Res = ParseStatementOrDeclaration(Stmts, StmtCtx, TrailingElseLoc);
42  } while (!Res.isInvalid() && !Res.get());
43 
44  return Res;
45 }
46 
47 /// ParseStatementOrDeclaration - Read 'statement' or 'declaration'.
48 /// StatementOrDeclaration:
49 /// statement
50 /// declaration
51 ///
52 /// statement:
53 /// labeled-statement
54 /// compound-statement
55 /// expression-statement
56 /// selection-statement
57 /// iteration-statement
58 /// jump-statement
59 /// [C++] declaration-statement
60 /// [C++] try-block
61 /// [MS] seh-try-block
62 /// [OBC] objc-throw-statement
63 /// [OBC] objc-try-catch-statement
64 /// [OBC] objc-synchronized-statement
65 /// [GNU] asm-statement
66 /// [OMP] openmp-construct [TODO]
67 ///
68 /// labeled-statement:
69 /// identifier ':' statement
70 /// 'case' constant-expression ':' statement
71 /// 'default' ':' statement
72 ///
73 /// selection-statement:
74 /// if-statement
75 /// switch-statement
76 ///
77 /// iteration-statement:
78 /// while-statement
79 /// do-statement
80 /// for-statement
81 ///
82 /// expression-statement:
83 /// expression[opt] ';'
84 ///
85 /// jump-statement:
86 /// 'goto' identifier ';'
87 /// 'continue' ';'
88 /// 'break' ';'
89 /// 'return' expression[opt] ';'
90 /// [GNU] 'goto' '*' expression ';'
91 ///
92 /// [OBC] objc-throw-statement:
93 /// [OBC] '@' 'throw' expression ';'
94 /// [OBC] '@' 'throw' ';'
95 ///
97 Parser::ParseStatementOrDeclaration(StmtVector &Stmts,
98  ParsedStmtContext StmtCtx,
99  SourceLocation *TrailingElseLoc) {
100 
101  ParenBraceBracketBalancer BalancerRAIIObj(*this);
102 
103  // Because we're parsing either a statement or a declaration, the order of
104  // attribute parsing is important. [[]] attributes at the start of a
105  // statement are different from [[]] attributes that follow an __attribute__
106  // at the start of the statement. Thus, we're not using MaybeParseAttributes
107  // here because we don't want to allow arbitrary orderings.
108  ParsedAttributes CXX11Attrs(AttrFactory);
109  MaybeParseCXX11Attributes(CXX11Attrs, /*MightBeObjCMessageSend*/ true);
110  ParsedAttributes GNUAttrs(AttrFactory);
111  if (getLangOpts().OpenCL)
112  MaybeParseGNUAttributes(GNUAttrs);
113 
114  StmtResult Res = ParseStatementOrDeclarationAfterAttributes(
115  Stmts, StmtCtx, TrailingElseLoc, CXX11Attrs, GNUAttrs);
116  MaybeDestroyTemplateIds();
117 
118  // Attributes that are left should all go on the statement, so concatenate the
119  // two lists.
120  ParsedAttributes Attrs(AttrFactory);
121  takeAndConcatenateAttrs(CXX11Attrs, GNUAttrs, Attrs);
122 
123  assert((Attrs.empty() || Res.isInvalid() || Res.isUsable()) &&
124  "attributes on empty statement");
125 
126  if (Attrs.empty() || Res.isInvalid())
127  return Res;
128 
129  return Actions.ActOnAttributedStmt(Attrs, Res.get());
130 }
131 
132 namespace {
133 class StatementFilterCCC final : public CorrectionCandidateCallback {
134 public:
135  StatementFilterCCC(Token nextTok) : NextToken(nextTok) {
136  WantTypeSpecifiers = nextTok.isOneOf(tok::l_paren, tok::less, tok::l_square,
137  tok::identifier, tok::star, tok::amp);
138  WantExpressionKeywords =
139  nextTok.isOneOf(tok::l_paren, tok::identifier, tok::arrow, tok::period);
140  WantRemainingKeywords =
141  nextTok.isOneOf(tok::l_paren, tok::semi, tok::identifier, tok::l_brace);
142  WantCXXNamedCasts = false;
143  }
144 
145  bool ValidateCandidate(const TypoCorrection &candidate) override {
146  if (FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>())
147  return !candidate.getCorrectionSpecifier() || isa<ObjCIvarDecl>(FD);
148  if (NextToken.is(tok::equal))
149  return candidate.getCorrectionDeclAs<VarDecl>();
150  if (NextToken.is(tok::period) &&
151  candidate.getCorrectionDeclAs<NamespaceDecl>())
152  return false;
154  }
155 
156  std::unique_ptr<CorrectionCandidateCallback> clone() override {
157  return std::make_unique<StatementFilterCCC>(*this);
158  }
159 
160 private:
161  Token NextToken;
162 };
163 }
164 
165 StmtResult Parser::ParseStatementOrDeclarationAfterAttributes(
166  StmtVector &Stmts, ParsedStmtContext StmtCtx,
167  SourceLocation *TrailingElseLoc, ParsedAttributes &CXX11Attrs,
168  ParsedAttributes &GNUAttrs) {
169  const char *SemiError = nullptr;
170  StmtResult Res;
171  SourceLocation GNUAttributeLoc;
172 
173  // Cases in this switch statement should fall through if the parser expects
174  // the token to end in a semicolon (in which case SemiError should be set),
175  // or they directly 'return;' if not.
176 Retry:
177  tok::TokenKind Kind = Tok.getKind();
178  SourceLocation AtLoc;
179  switch (Kind) {
180  case tok::at: // May be a @try or @throw statement
181  {
182  AtLoc = ConsumeToken(); // consume @
183  return ParseObjCAtStatement(AtLoc, StmtCtx);
184  }
185 
186  case tok::code_completion:
187  cutOffParsing();
189  return StmtError();
190 
191  case tok::identifier: {
192  Token Next = NextToken();
193  if (Next.is(tok::colon)) { // C99 6.8.1: labeled-statement
194  // Both C++11 and GNU attributes preceding the label appertain to the
195  // label, so put them in a single list to pass on to
196  // ParseLabeledStatement().
197  ParsedAttributes Attrs(AttrFactory);
198  takeAndConcatenateAttrs(CXX11Attrs, GNUAttrs, Attrs);
199 
200  // identifier ':' statement
201  return ParseLabeledStatement(Attrs, StmtCtx);
202  }
203 
204  // Look up the identifier, and typo-correct it to a keyword if it's not
205  // found.
206  if (Next.isNot(tok::coloncolon)) {
207  // Try to limit which sets of keywords should be included in typo
208  // correction based on what the next token is.
209  StatementFilterCCC CCC(Next);
210  if (TryAnnotateName(&CCC) == ANK_Error) {
211  // Handle errors here by skipping up to the next semicolon or '}', and
212  // eat the semicolon if that's what stopped us.
213  SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
214  if (Tok.is(tok::semi))
215  ConsumeToken();
216  return StmtError();
217  }
218 
219  // If the identifier was typo-corrected, try again.
220  if (Tok.isNot(tok::identifier))
221  goto Retry;
222  }
223 
224  // Fall through
225  LLVM_FALLTHROUGH;
226  }
227 
228  default: {
229  bool HaveAttrs = !CXX11Attrs.empty() || !GNUAttrs.empty();
230  auto IsStmtAttr = [](ParsedAttr &Attr) { return Attr.isStmtAttr(); };
231  bool AllAttrsAreStmtAttrs = llvm::all_of(CXX11Attrs, IsStmtAttr) &&
232  llvm::all_of(GNUAttrs, IsStmtAttr);
233  if ((getLangOpts().CPlusPlus || getLangOpts().MicrosoftExt ||
234  (StmtCtx & ParsedStmtContext::AllowDeclarationsInC) !=
235  ParsedStmtContext()) &&
236  ((GNUAttributeLoc.isValid() && !(HaveAttrs && AllAttrsAreStmtAttrs)) ||
237  isDeclarationStatement())) {
238  SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
240  if (GNUAttributeLoc.isValid()) {
241  DeclStart = GNUAttributeLoc;
242  Decl = ParseDeclaration(DeclaratorContext::Block, DeclEnd, CXX11Attrs,
243  GNUAttrs, &GNUAttributeLoc);
244  } else {
245  Decl = ParseDeclaration(DeclaratorContext::Block, DeclEnd, CXX11Attrs,
246  GNUAttrs);
247  }
248  if (CXX11Attrs.Range.getBegin().isValid()) {
249  // The caller must guarantee that the CXX11Attrs appear before the
250  // GNUAttrs, and we rely on that here.
251  assert(GNUAttrs.Range.getBegin().isInvalid() ||
252  GNUAttrs.Range.getBegin() > CXX11Attrs.Range.getBegin());
253  DeclStart = CXX11Attrs.Range.getBegin();
254  } else if (GNUAttrs.Range.getBegin().isValid())
255  DeclStart = GNUAttrs.Range.getBegin();
256  return Actions.ActOnDeclStmt(Decl, DeclStart, DeclEnd);
257  }
258 
259  if (Tok.is(tok::r_brace)) {
260  Diag(Tok, diag::err_expected_statement);
261  return StmtError();
262  }
263 
264  return ParseExprStatement(StmtCtx);
265  }
266 
267  case tok::kw___attribute: {
268  GNUAttributeLoc = Tok.getLocation();
269  ParseGNUAttributes(GNUAttrs);
270  goto Retry;
271  }
272 
273  case tok::kw_case: // C99 6.8.1: labeled-statement
274  return ParseCaseStatement(StmtCtx);
275  case tok::kw_default: // C99 6.8.1: labeled-statement
276  return ParseDefaultStatement(StmtCtx);
277 
278  case tok::l_brace: // C99 6.8.2: compound-statement
279  return ParseCompoundStatement();
280  case tok::semi: { // C99 6.8.3p3: expression[opt] ';'
281  bool HasLeadingEmptyMacro = Tok.hasLeadingEmptyMacro();
282  return Actions.ActOnNullStmt(ConsumeToken(), HasLeadingEmptyMacro);
283  }
284 
285  case tok::kw_if: // C99 6.8.4.1: if-statement
286  return ParseIfStatement(TrailingElseLoc);
287  case tok::kw_switch: // C99 6.8.4.2: switch-statement
288  return ParseSwitchStatement(TrailingElseLoc);
289 
290  case tok::kw_while: // C99 6.8.5.1: while-statement
291  return ParseWhileStatement(TrailingElseLoc);
292  case tok::kw_do: // C99 6.8.5.2: do-statement
293  Res = ParseDoStatement();
294  SemiError = "do/while";
295  break;
296  case tok::kw_for: // C99 6.8.5.3: for-statement
297  return ParseForStatement(TrailingElseLoc);
298 
299  case tok::kw_goto: // C99 6.8.6.1: goto-statement
300  Res = ParseGotoStatement();
301  SemiError = "goto";
302  break;
303  case tok::kw_continue: // C99 6.8.6.2: continue-statement
304  Res = ParseContinueStatement();
305  SemiError = "continue";
306  break;
307  case tok::kw_break: // C99 6.8.6.3: break-statement
308  Res = ParseBreakStatement();
309  SemiError = "break";
310  break;
311  case tok::kw_return: // C99 6.8.6.4: return-statement
312  Res = ParseReturnStatement();
313  SemiError = "return";
314  break;
315  case tok::kw_co_return: // C++ Coroutines: co_return statement
316  Res = ParseReturnStatement();
317  SemiError = "co_return";
318  break;
319 
320  case tok::kw_asm: {
321  for (const ParsedAttr &AL : CXX11Attrs)
322  Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored) << AL;
323  // Prevent these from being interpreted as statement attributes later on.
324  CXX11Attrs.clear();
325  ProhibitAttributes(GNUAttrs);
326  bool msAsm = false;
327  Res = ParseAsmStatement(msAsm);
328  if (msAsm) return Res;
329  SemiError = "asm";
330  break;
331  }
332 
333  case tok::kw___if_exists:
334  case tok::kw___if_not_exists:
335  ProhibitAttributes(CXX11Attrs);
336  ProhibitAttributes(GNUAttrs);
337  ParseMicrosoftIfExistsStatement(Stmts);
338  // An __if_exists block is like a compound statement, but it doesn't create
339  // a new scope.
340  return StmtEmpty();
341 
342  case tok::kw_try: // C++ 15: try-block
343  return ParseCXXTryBlock();
344 
345  case tok::kw___try:
346  ProhibitAttributes(CXX11Attrs);
347  ProhibitAttributes(GNUAttrs);
348  return ParseSEHTryBlock();
349 
350  case tok::kw___leave:
351  Res = ParseSEHLeaveStatement();
352  SemiError = "__leave";
353  break;
354 
355  case tok::annot_pragma_vis:
356  ProhibitAttributes(CXX11Attrs);
357  ProhibitAttributes(GNUAttrs);
358  HandlePragmaVisibility();
359  return StmtEmpty();
360 
361  case tok::annot_pragma_pack:
362  ProhibitAttributes(CXX11Attrs);
363  ProhibitAttributes(GNUAttrs);
364  HandlePragmaPack();
365  return StmtEmpty();
366 
367  case tok::annot_pragma_msstruct:
368  ProhibitAttributes(CXX11Attrs);
369  ProhibitAttributes(GNUAttrs);
370  HandlePragmaMSStruct();
371  return StmtEmpty();
372 
373  case tok::annot_pragma_align:
374  ProhibitAttributes(CXX11Attrs);
375  ProhibitAttributes(GNUAttrs);
376  HandlePragmaAlign();
377  return StmtEmpty();
378 
379  case tok::annot_pragma_weak:
380  ProhibitAttributes(CXX11Attrs);
381  ProhibitAttributes(GNUAttrs);
382  HandlePragmaWeak();
383  return StmtEmpty();
384 
385  case tok::annot_pragma_weakalias:
386  ProhibitAttributes(CXX11Attrs);
387  ProhibitAttributes(GNUAttrs);
388  HandlePragmaWeakAlias();
389  return StmtEmpty();
390 
391  case tok::annot_pragma_redefine_extname:
392  ProhibitAttributes(CXX11Attrs);
393  ProhibitAttributes(GNUAttrs);
394  HandlePragmaRedefineExtname();
395  return StmtEmpty();
396 
397  case tok::annot_pragma_fp_contract:
398  ProhibitAttributes(CXX11Attrs);
399  ProhibitAttributes(GNUAttrs);
400  Diag(Tok, diag::err_pragma_file_or_compound_scope) << "fp_contract";
401  ConsumeAnnotationToken();
402  return StmtError();
403 
404  case tok::annot_pragma_fp:
405  ProhibitAttributes(CXX11Attrs);
406  ProhibitAttributes(GNUAttrs);
407  Diag(Tok, diag::err_pragma_file_or_compound_scope) << "clang fp";
408  ConsumeAnnotationToken();
409  return StmtError();
410 
411  case tok::annot_pragma_fenv_access:
412  case tok::annot_pragma_fenv_access_ms:
413  ProhibitAttributes(CXX11Attrs);
414  ProhibitAttributes(GNUAttrs);
415  Diag(Tok, diag::err_pragma_file_or_compound_scope)
416  << (Kind == tok::annot_pragma_fenv_access ? "STDC FENV_ACCESS"
417  : "fenv_access");
418  ConsumeAnnotationToken();
419  return StmtEmpty();
420 
421  case tok::annot_pragma_fenv_round:
422  ProhibitAttributes(CXX11Attrs);
423  ProhibitAttributes(GNUAttrs);
424  Diag(Tok, diag::err_pragma_file_or_compound_scope) << "STDC FENV_ROUND";
425  ConsumeAnnotationToken();
426  return StmtError();
427 
428  case tok::annot_pragma_float_control:
429  ProhibitAttributes(CXX11Attrs);
430  ProhibitAttributes(GNUAttrs);
431  Diag(Tok, diag::err_pragma_file_or_compound_scope) << "float_control";
432  ConsumeAnnotationToken();
433  return StmtError();
434 
435  case tok::annot_pragma_opencl_extension:
436  ProhibitAttributes(CXX11Attrs);
437  ProhibitAttributes(GNUAttrs);
438  HandlePragmaOpenCLExtension();
439  return StmtEmpty();
440 
441  case tok::annot_pragma_captured:
442  ProhibitAttributes(CXX11Attrs);
443  ProhibitAttributes(GNUAttrs);
444  return HandlePragmaCaptured();
445 
446  case tok::annot_pragma_openmp:
447  // Prohibit attributes that are not OpenMP attributes, but only before
448  // processing a #pragma omp clause.
449  ProhibitAttributes(CXX11Attrs);
450  ProhibitAttributes(GNUAttrs);
451  LLVM_FALLTHROUGH;
452  case tok::annot_attr_openmp:
453  // Do not prohibit attributes if they were OpenMP attributes.
454  return ParseOpenMPDeclarativeOrExecutableDirective(StmtCtx);
455 
456  case tok::annot_pragma_ms_pointers_to_members:
457  ProhibitAttributes(CXX11Attrs);
458  ProhibitAttributes(GNUAttrs);
459  HandlePragmaMSPointersToMembers();
460  return StmtEmpty();
461 
462  case tok::annot_pragma_ms_pragma:
463  ProhibitAttributes(CXX11Attrs);
464  ProhibitAttributes(GNUAttrs);
465  HandlePragmaMSPragma();
466  return StmtEmpty();
467 
468  case tok::annot_pragma_ms_vtordisp:
469  ProhibitAttributes(CXX11Attrs);
470  ProhibitAttributes(GNUAttrs);
471  HandlePragmaMSVtorDisp();
472  return StmtEmpty();
473 
474  case tok::annot_pragma_loop_hint:
475  ProhibitAttributes(CXX11Attrs);
476  ProhibitAttributes(GNUAttrs);
477  return ParsePragmaLoopHint(Stmts, StmtCtx, TrailingElseLoc, CXX11Attrs);
478 
479  case tok::annot_pragma_dump:
480  HandlePragmaDump();
481  return StmtEmpty();
482 
483  case tok::annot_pragma_attribute:
484  HandlePragmaAttribute();
485  return StmtEmpty();
486  }
487 
488  // If we reached this code, the statement must end in a semicolon.
489  if (!TryConsumeToken(tok::semi) && !Res.isInvalid()) {
490  // If the result was valid, then we do want to diagnose this. Use
491  // ExpectAndConsume to emit the diagnostic, even though we know it won't
492  // succeed.
493  ExpectAndConsume(tok::semi, diag::err_expected_semi_after_stmt, SemiError);
494  // Skip until we see a } or ;, but don't eat it.
495  SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
496  }
497 
498  return Res;
499 }
500 
501 /// Parse an expression statement.
502 StmtResult Parser::ParseExprStatement(ParsedStmtContext StmtCtx) {
503  // If a case keyword is missing, this is where it should be inserted.
504  Token OldToken = Tok;
505 
506  ExprStatementTokLoc = Tok.getLocation();
507 
508  // expression[opt] ';'
510  if (Expr.isInvalid()) {
511  // If the expression is invalid, skip ahead to the next semicolon or '}'.
512  // Not doing this opens us up to the possibility of infinite loops if
513  // ParseExpression does not consume any tokens.
514  SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
515  if (Tok.is(tok::semi))
516  ConsumeToken();
517  return Actions.ActOnExprStmtError();
518  }
519 
520  if (Tok.is(tok::colon) && getCurScope()->isSwitchScope() &&
521  Actions.CheckCaseExpression(Expr.get())) {
522  // If a constant expression is followed by a colon inside a switch block,
523  // suggest a missing case keyword.
524  Diag(OldToken, diag::err_expected_case_before_expression)
525  << FixItHint::CreateInsertion(OldToken.getLocation(), "case ");
526 
527  // Recover parsing as a case statement.
528  return ParseCaseStatement(StmtCtx, /*MissingCase=*/true, Expr);
529  }
530 
531  // Otherwise, eat the semicolon.
532  ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
533  return handleExprStmt(Expr, StmtCtx);
534 }
535 
536 /// ParseSEHTryBlockCommon
537 ///
538 /// seh-try-block:
539 /// '__try' compound-statement seh-handler
540 ///
541 /// seh-handler:
542 /// seh-except-block
543 /// seh-finally-block
544 ///
545 StmtResult Parser::ParseSEHTryBlock() {
546  assert(Tok.is(tok::kw___try) && "Expected '__try'");
547  SourceLocation TryLoc = ConsumeToken();
548 
549  if (Tok.isNot(tok::l_brace))
550  return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
551 
552  StmtResult TryBlock(ParseCompoundStatement(
553  /*isStmtExpr=*/false,
555  if (TryBlock.isInvalid())
556  return TryBlock;
557 
558  StmtResult Handler;
559  if (Tok.is(tok::identifier) &&
560  Tok.getIdentifierInfo() == getSEHExceptKeyword()) {
562  Handler = ParseSEHExceptBlock(Loc);
563  } else if (Tok.is(tok::kw___finally)) {
565  Handler = ParseSEHFinallyBlock(Loc);
566  } else {
567  return StmtError(Diag(Tok, diag::err_seh_expected_handler));
568  }
569 
570  if(Handler.isInvalid())
571  return Handler;
572 
573  return Actions.ActOnSEHTryBlock(false /* IsCXXTry */,
574  TryLoc,
575  TryBlock.get(),
576  Handler.get());
577 }
578 
579 /// ParseSEHExceptBlock - Handle __except
580 ///
581 /// seh-except-block:
582 /// '__except' '(' seh-filter-expression ')' compound-statement
583 ///
584 StmtResult Parser::ParseSEHExceptBlock(SourceLocation ExceptLoc) {
585  PoisonIdentifierRAIIObject raii(Ident__exception_code, false),
586  raii2(Ident___exception_code, false),
587  raii3(Ident_GetExceptionCode, false);
588 
589  if (ExpectAndConsume(tok::l_paren))
590  return StmtError();
591 
592  ParseScope ExpectScope(this, Scope::DeclScope | Scope::ControlScope |
594 
595  if (getLangOpts().Borland) {
596  Ident__exception_info->setIsPoisoned(false);
597  Ident___exception_info->setIsPoisoned(false);
598  Ident_GetExceptionInfo->setIsPoisoned(false);
599  }
600 
601  ExprResult FilterExpr;
602  {
603  ParseScopeFlags FilterScope(this, getCurScope()->getFlags() |
605  FilterExpr = Actions.CorrectDelayedTyposInExpr(ParseExpression());
606  }
607 
608  if (getLangOpts().Borland) {
609  Ident__exception_info->setIsPoisoned(true);
610  Ident___exception_info->setIsPoisoned(true);
611  Ident_GetExceptionInfo->setIsPoisoned(true);
612  }
613 
614  if(FilterExpr.isInvalid())
615  return StmtError();
616 
617  if (ExpectAndConsume(tok::r_paren))
618  return StmtError();
619 
620  if (Tok.isNot(tok::l_brace))
621  return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
622 
623  StmtResult Block(ParseCompoundStatement());
624 
625  if(Block.isInvalid())
626  return Block;
627 
628  return Actions.ActOnSEHExceptBlock(ExceptLoc, FilterExpr.get(), Block.get());
629 }
630 
631 /// ParseSEHFinallyBlock - Handle __finally
632 ///
633 /// seh-finally-block:
634 /// '__finally' compound-statement
635 ///
636 StmtResult Parser::ParseSEHFinallyBlock(SourceLocation FinallyLoc) {
637  PoisonIdentifierRAIIObject raii(Ident__abnormal_termination, false),
638  raii2(Ident___abnormal_termination, false),
639  raii3(Ident_AbnormalTermination, false);
640 
641  if (Tok.isNot(tok::l_brace))
642  return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
643 
644  ParseScope FinallyScope(this, 0);
645  Actions.ActOnStartSEHFinallyBlock();
646 
647  StmtResult Block(ParseCompoundStatement());
648  if(Block.isInvalid()) {
649  Actions.ActOnAbortSEHFinallyBlock();
650  return Block;
651  }
652 
653  return Actions.ActOnFinishSEHFinallyBlock(FinallyLoc, Block.get());
654 }
655 
656 /// Handle __leave
657 ///
658 /// seh-leave-statement:
659 /// '__leave' ';'
660 ///
661 StmtResult Parser::ParseSEHLeaveStatement() {
662  SourceLocation LeaveLoc = ConsumeToken(); // eat the '__leave'.
663  return Actions.ActOnSEHLeaveStmt(LeaveLoc, getCurScope());
664 }
665 
666 /// ParseLabeledStatement - We have an identifier and a ':' after it.
667 ///
668 /// labeled-statement:
669 /// identifier ':' statement
670 /// [GNU] identifier ':' attributes[opt] statement
671 ///
672 StmtResult Parser::ParseLabeledStatement(ParsedAttributes &Attrs,
673  ParsedStmtContext StmtCtx) {
674  assert(Tok.is(tok::identifier) && Tok.getIdentifierInfo() &&
675  "Not an identifier!");
676 
677  // The substatement is always a 'statement', not a 'declaration', but is
678  // otherwise in the same context as the labeled-statement.
679  StmtCtx &= ~ParsedStmtContext::AllowDeclarationsInC;
680 
681  Token IdentTok = Tok; // Save the whole token.
682  ConsumeToken(); // eat the identifier.
683 
684  assert(Tok.is(tok::colon) && "Not a label!");
685 
686  // identifier ':' statement
687  SourceLocation ColonLoc = ConsumeToken();
688 
689  // Read label attributes, if present.
690  StmtResult SubStmt;
691  if (Tok.is(tok::kw___attribute)) {
692  ParsedAttributes TempAttrs(AttrFactory);
693  ParseGNUAttributes(TempAttrs);
694 
695  // In C++, GNU attributes only apply to the label if they are followed by a
696  // semicolon, to disambiguate label attributes from attributes on a labeled
697  // declaration.
698  //
699  // This doesn't quite match what GCC does; if the attribute list is empty
700  // and followed by a semicolon, GCC will reject (it appears to parse the
701  // attributes as part of a statement in that case). That looks like a bug.
702  if (!getLangOpts().CPlusPlus || Tok.is(tok::semi))
703  Attrs.takeAllFrom(TempAttrs);
704  else {
705  StmtVector Stmts;
706  ParsedAttributes EmptyCXX11Attrs(AttrFactory);
707  SubStmt = ParseStatementOrDeclarationAfterAttributes(
708  Stmts, StmtCtx, nullptr, EmptyCXX11Attrs, TempAttrs);
709  if (!TempAttrs.empty() && !SubStmt.isInvalid())
710  SubStmt = Actions.ActOnAttributedStmt(TempAttrs, SubStmt.get());
711  }
712  }
713 
714  // If we've not parsed a statement yet, parse one now.
715  if (!SubStmt.isInvalid() && !SubStmt.isUsable())
716  SubStmt = ParseStatement(nullptr, StmtCtx);
717 
718  // Broken substmt shouldn't prevent the label from being added to the AST.
719  if (SubStmt.isInvalid())
720  SubStmt = Actions.ActOnNullStmt(ColonLoc);
721 
722  LabelDecl *LD = Actions.LookupOrCreateLabel(IdentTok.getIdentifierInfo(),
723  IdentTok.getLocation());
724  Actions.ProcessDeclAttributeList(Actions.CurScope, LD, Attrs);
725  Attrs.clear();
726 
727  return Actions.ActOnLabelStmt(IdentTok.getLocation(), LD, ColonLoc,
728  SubStmt.get());
729 }
730 
731 /// ParseCaseStatement
732 /// labeled-statement:
733 /// 'case' constant-expression ':' statement
734 /// [GNU] 'case' constant-expression '...' constant-expression ':' statement
735 ///
736 StmtResult Parser::ParseCaseStatement(ParsedStmtContext StmtCtx,
737  bool MissingCase, ExprResult Expr) {
738  assert((MissingCase || Tok.is(tok::kw_case)) && "Not a case stmt!");
739 
740  // The substatement is always a 'statement', not a 'declaration', but is
741  // otherwise in the same context as the labeled-statement.
742  StmtCtx &= ~ParsedStmtContext::AllowDeclarationsInC;
743 
744  // It is very very common for code to contain many case statements recursively
745  // nested, as in (but usually without indentation):
746  // case 1:
747  // case 2:
748  // case 3:
749  // case 4:
750  // case 5: etc.
751  //
752  // Parsing this naively works, but is both inefficient and can cause us to run
753  // out of stack space in our recursive descent parser. As a special case,
754  // flatten this recursion into an iterative loop. This is complex and gross,
755  // but all the grossness is constrained to ParseCaseStatement (and some
756  // weirdness in the actions), so this is just local grossness :).
757 
758  // TopLevelCase - This is the highest level we have parsed. 'case 1' in the
759  // example above.
760  StmtResult TopLevelCase(true);
761 
762  // DeepestParsedCaseStmt - This is the deepest statement we have parsed, which
763  // gets updated each time a new case is parsed, and whose body is unset so
764  // far. When parsing 'case 4', this is the 'case 3' node.
765  Stmt *DeepestParsedCaseStmt = nullptr;
766 
767  // While we have case statements, eat and stack them.
768  SourceLocation ColonLoc;
769  do {
770  SourceLocation CaseLoc = MissingCase ? Expr.get()->getExprLoc() :
771  ConsumeToken(); // eat the 'case'.
772  ColonLoc = SourceLocation();
773 
774  if (Tok.is(tok::code_completion)) {
775  cutOffParsing();
776  Actions.CodeCompleteCase(getCurScope());
777  return StmtError();
778  }
779 
780  /// We don't want to treat 'case x : y' as a potential typo for 'case x::y'.
781  /// Disable this form of error recovery while we're parsing the case
782  /// expression.
783  ColonProtectionRAIIObject ColonProtection(*this);
784 
785  ExprResult LHS;
786  if (!MissingCase) {
787  LHS = ParseCaseExpression(CaseLoc);
788  if (LHS.isInvalid()) {
789  // If constant-expression is parsed unsuccessfully, recover by skipping
790  // current case statement (moving to the colon that ends it).
791  if (!SkipUntil(tok::colon, tok::r_brace, StopAtSemi | StopBeforeMatch))
792  return StmtError();
793  }
794  } else {
795  LHS = Expr;
796  MissingCase = false;
797  }
798 
799  // GNU case range extension.
800  SourceLocation DotDotDotLoc;
801  ExprResult RHS;
802  if (TryConsumeToken(tok::ellipsis, DotDotDotLoc)) {
803  Diag(DotDotDotLoc, diag::ext_gnu_case_range);
804  RHS = ParseCaseExpression(CaseLoc);
805  if (RHS.isInvalid()) {
806  if (!SkipUntil(tok::colon, tok::r_brace, StopAtSemi | StopBeforeMatch))
807  return StmtError();
808  }
809  }
810 
811  ColonProtection.restore();
812 
813  if (TryConsumeToken(tok::colon, ColonLoc)) {
814  } else if (TryConsumeToken(tok::semi, ColonLoc) ||
815  TryConsumeToken(tok::coloncolon, ColonLoc)) {
816  // Treat "case blah;" or "case blah::" as a typo for "case blah:".
817  Diag(ColonLoc, diag::err_expected_after)
818  << "'case'" << tok::colon
819  << FixItHint::CreateReplacement(ColonLoc, ":");
820  } else {
821  SourceLocation ExpectedLoc = PP.getLocForEndOfToken(PrevTokLocation);
822  Diag(ExpectedLoc, diag::err_expected_after)
823  << "'case'" << tok::colon
824  << FixItHint::CreateInsertion(ExpectedLoc, ":");
825  ColonLoc = ExpectedLoc;
826  }
827 
828  StmtResult Case =
829  Actions.ActOnCaseStmt(CaseLoc, LHS, DotDotDotLoc, RHS, ColonLoc);
830 
831  // If we had a sema error parsing this case, then just ignore it and
832  // continue parsing the sub-stmt.
833  if (Case.isInvalid()) {
834  if (TopLevelCase.isInvalid()) // No parsed case stmts.
835  return ParseStatement(/*TrailingElseLoc=*/nullptr, StmtCtx);
836  // Otherwise, just don't add it as a nested case.
837  } else {
838  // If this is the first case statement we parsed, it becomes TopLevelCase.
839  // Otherwise we link it into the current chain.
840  Stmt *NextDeepest = Case.get();
841  if (TopLevelCase.isInvalid())
842  TopLevelCase = Case;
843  else
844  Actions.ActOnCaseStmtBody(DeepestParsedCaseStmt, Case.get());
845  DeepestParsedCaseStmt = NextDeepest;
846  }
847 
848  // Handle all case statements.
849  } while (Tok.is(tok::kw_case));
850 
851  // If we found a non-case statement, start by parsing it.
852  StmtResult SubStmt;
853 
854  if (Tok.isNot(tok::r_brace)) {
855  SubStmt = ParseStatement(/*TrailingElseLoc=*/nullptr, StmtCtx);
856  } else {
857  // Nicely diagnose the common error "switch (X) { case 4: }", which is
858  // not valid. If ColonLoc doesn't point to a valid text location, there was
859  // another parsing error, so avoid producing extra diagnostics.
860  if (ColonLoc.isValid()) {
861  SourceLocation AfterColonLoc = PP.getLocForEndOfToken(ColonLoc);
862  Diag(AfterColonLoc, diag::err_label_end_of_compound_statement)
863  << FixItHint::CreateInsertion(AfterColonLoc, " ;");
864  }
865  SubStmt = StmtError();
866  }
867 
868  // Install the body into the most deeply-nested case.
869  if (DeepestParsedCaseStmt) {
870  // Broken sub-stmt shouldn't prevent forming the case statement properly.
871  if (SubStmt.isInvalid())
872  SubStmt = Actions.ActOnNullStmt(SourceLocation());
873  Actions.ActOnCaseStmtBody(DeepestParsedCaseStmt, SubStmt.get());
874  }
875 
876  // Return the top level parsed statement tree.
877  return TopLevelCase;
878 }
879 
880 /// ParseDefaultStatement
881 /// labeled-statement:
882 /// 'default' ':' statement
883 /// Note that this does not parse the 'statement' at the end.
884 ///
885 StmtResult Parser::ParseDefaultStatement(ParsedStmtContext StmtCtx) {
886  assert(Tok.is(tok::kw_default) && "Not a default stmt!");
887 
888  // The substatement is always a 'statement', not a 'declaration', but is
889  // otherwise in the same context as the labeled-statement.
890  StmtCtx &= ~ParsedStmtContext::AllowDeclarationsInC;
891 
892  SourceLocation DefaultLoc = ConsumeToken(); // eat the 'default'.
893 
894  SourceLocation ColonLoc;
895  if (TryConsumeToken(tok::colon, ColonLoc)) {
896  } else if (TryConsumeToken(tok::semi, ColonLoc)) {
897  // Treat "default;" as a typo for "default:".
898  Diag(ColonLoc, diag::err_expected_after)
899  << "'default'" << tok::colon
900  << FixItHint::CreateReplacement(ColonLoc, ":");
901  } else {
902  SourceLocation ExpectedLoc = PP.getLocForEndOfToken(PrevTokLocation);
903  Diag(ExpectedLoc, diag::err_expected_after)
904  << "'default'" << tok::colon
905  << FixItHint::CreateInsertion(ExpectedLoc, ":");
906  ColonLoc = ExpectedLoc;
907  }
908 
909  StmtResult SubStmt;
910 
911  if (Tok.isNot(tok::r_brace)) {
912  SubStmt = ParseStatement(/*TrailingElseLoc=*/nullptr, StmtCtx);
913  } else {
914  // Diagnose the common error "switch (X) {... default: }", which is
915  // not valid.
916  SourceLocation AfterColonLoc = PP.getLocForEndOfToken(ColonLoc);
917  Diag(AfterColonLoc, diag::err_label_end_of_compound_statement)
918  << FixItHint::CreateInsertion(AfterColonLoc, " ;");
919  SubStmt = true;
920  }
921 
922  // Broken sub-stmt shouldn't prevent forming the case statement properly.
923  if (SubStmt.isInvalid())
924  SubStmt = Actions.ActOnNullStmt(ColonLoc);
925 
926  return Actions.ActOnDefaultStmt(DefaultLoc, ColonLoc,
927  SubStmt.get(), getCurScope());
928 }
929 
930 StmtResult Parser::ParseCompoundStatement(bool isStmtExpr) {
931  return ParseCompoundStatement(isStmtExpr,
933 }
934 
935 /// ParseCompoundStatement - Parse a "{}" block.
936 ///
937 /// compound-statement: [C99 6.8.2]
938 /// { block-item-list[opt] }
939 /// [GNU] { label-declarations block-item-list } [TODO]
940 ///
941 /// block-item-list:
942 /// block-item
943 /// block-item-list block-item
944 ///
945 /// block-item:
946 /// declaration
947 /// [GNU] '__extension__' declaration
948 /// statement
949 ///
950 /// [GNU] label-declarations:
951 /// [GNU] label-declaration
952 /// [GNU] label-declarations label-declaration
953 ///
954 /// [GNU] label-declaration:
955 /// [GNU] '__label__' identifier-list ';'
956 ///
957 StmtResult Parser::ParseCompoundStatement(bool isStmtExpr,
958  unsigned ScopeFlags) {
959  assert(Tok.is(tok::l_brace) && "Not a compount stmt!");
960 
961  // Enter a scope to hold everything within the compound stmt. Compound
962  // statements can always hold declarations.
963  ParseScope CompoundScope(this, ScopeFlags);
964 
965  // Parse the statements in the body.
966  return ParseCompoundStatementBody(isStmtExpr);
967 }
968 
969 /// Parse any pragmas at the start of the compound expression. We handle these
970 /// separately since some pragmas (FP_CONTRACT) must appear before any C
971 /// statement in the compound, but may be intermingled with other pragmas.
972 void Parser::ParseCompoundStatementLeadingPragmas() {
973  bool checkForPragmas = true;
974  while (checkForPragmas) {
975  switch (Tok.getKind()) {
976  case tok::annot_pragma_vis:
977  HandlePragmaVisibility();
978  break;
979  case tok::annot_pragma_pack:
980  HandlePragmaPack();
981  break;
982  case tok::annot_pragma_msstruct:
983  HandlePragmaMSStruct();
984  break;
985  case tok::annot_pragma_align:
986  HandlePragmaAlign();
987  break;
988  case tok::annot_pragma_weak:
989  HandlePragmaWeak();
990  break;
991  case tok::annot_pragma_weakalias:
992  HandlePragmaWeakAlias();
993  break;
994  case tok::annot_pragma_redefine_extname:
995  HandlePragmaRedefineExtname();
996  break;
997  case tok::annot_pragma_opencl_extension:
998  HandlePragmaOpenCLExtension();
999  break;
1000  case tok::annot_pragma_fp_contract:
1001  HandlePragmaFPContract();
1002  break;
1003  case tok::annot_pragma_fp:
1004  HandlePragmaFP();
1005  break;
1006  case tok::annot_pragma_fenv_access:
1007  case tok::annot_pragma_fenv_access_ms:
1008  HandlePragmaFEnvAccess();
1009  break;
1010  case tok::annot_pragma_fenv_round:
1011  HandlePragmaFEnvRound();
1012  break;
1013  case tok::annot_pragma_float_control:
1014  HandlePragmaFloatControl();
1015  break;
1016  case tok::annot_pragma_ms_pointers_to_members:
1017  HandlePragmaMSPointersToMembers();
1018  break;
1019  case tok::annot_pragma_ms_pragma:
1020  HandlePragmaMSPragma();
1021  break;
1022  case tok::annot_pragma_ms_vtordisp:
1023  HandlePragmaMSVtorDisp();
1024  break;
1025  case tok::annot_pragma_dump:
1026  HandlePragmaDump();
1027  break;
1028  default:
1029  checkForPragmas = false;
1030  break;
1031  }
1032  }
1033 
1034 }
1035 
1036 /// Consume any extra semi-colons resulting in null statements,
1037 /// returning true if any tok::semi were consumed.
1038 bool Parser::ConsumeNullStmt(StmtVector &Stmts) {
1039  if (!Tok.is(tok::semi))
1040  return false;
1041 
1042  SourceLocation StartLoc = Tok.getLocation();
1043  SourceLocation EndLoc;
1044 
1045  while (Tok.is(tok::semi) && !Tok.hasLeadingEmptyMacro() &&
1046  Tok.getLocation().isValid() && !Tok.getLocation().isMacroID()) {
1047  EndLoc = Tok.getLocation();
1048 
1049  // Don't just ConsumeToken() this tok::semi, do store it in AST.
1050  StmtResult R =
1051  ParseStatementOrDeclaration(Stmts, ParsedStmtContext::SubStmt);
1052  if (R.isUsable())
1053  Stmts.push_back(R.get());
1054  }
1055 
1056  // Did not consume any extra semi.
1057  if (EndLoc.isInvalid())
1058  return false;
1059 
1060  Diag(StartLoc, diag::warn_null_statement)
1061  << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc));
1062  return true;
1063 }
1064 
1065 StmtResult Parser::handleExprStmt(ExprResult E, ParsedStmtContext StmtCtx) {
1066  bool IsStmtExprResult = false;
1067  if ((StmtCtx & ParsedStmtContext::InStmtExpr) != ParsedStmtContext()) {
1068  // For GCC compatibility we skip past NullStmts.
1069  unsigned LookAhead = 0;
1070  while (GetLookAheadToken(LookAhead).is(tok::semi)) {
1071  ++LookAhead;
1072  }
1073  // Then look to see if the next two tokens close the statement expression;
1074  // if so, this expression statement is the last statement in a statment
1075  // expression.
1076  IsStmtExprResult = GetLookAheadToken(LookAhead).is(tok::r_brace) &&
1077  GetLookAheadToken(LookAhead + 1).is(tok::r_paren);
1078  }
1079 
1080  if (IsStmtExprResult)
1081  E = Actions.ActOnStmtExprResult(E);
1082  return Actions.ActOnExprStmt(E, /*DiscardedValue=*/!IsStmtExprResult);
1083 }
1084 
1085 /// ParseCompoundStatementBody - Parse a sequence of statements and invoke the
1086 /// ActOnCompoundStmt action. This expects the '{' to be the current token, and
1087 /// consume the '}' at the end of the block. It does not manipulate the scope
1088 /// stack.
1089 StmtResult Parser::ParseCompoundStatementBody(bool isStmtExpr) {
1090  PrettyStackTraceLoc CrashInfo(PP.getSourceManager(),
1091  Tok.getLocation(),
1092  "in compound statement ('{}')");
1093 
1094  // Record the current FPFeatures, restore on leaving the
1095  // compound statement.
1096  Sema::FPFeaturesStateRAII SaveFPFeatures(Actions);
1097 
1098  InMessageExpressionRAIIObject InMessage(*this, false);
1099  BalancedDelimiterTracker T(*this, tok::l_brace);
1100  if (T.consumeOpen())
1101  return StmtError();
1102 
1103  Sema::CompoundScopeRAII CompoundScope(Actions, isStmtExpr);
1104 
1105  // Parse any pragmas at the beginning of the compound statement.
1106  ParseCompoundStatementLeadingPragmas();
1108 
1109  StmtVector Stmts;
1110 
1111  // "__label__ X, Y, Z;" is the GNU "Local Label" extension. These are
1112  // only allowed at the start of a compound stmt regardless of the language.
1113  while (Tok.is(tok::kw___label__)) {
1114  SourceLocation LabelLoc = ConsumeToken();
1115 
1116  SmallVector<Decl *, 8> DeclsInGroup;
1117  while (true) {
1118  if (Tok.isNot(tok::identifier)) {
1119  Diag(Tok, diag::err_expected) << tok::identifier;
1120  break;
1121  }
1122 
1123  IdentifierInfo *II = Tok.getIdentifierInfo();
1124  SourceLocation IdLoc = ConsumeToken();
1125  DeclsInGroup.push_back(Actions.LookupOrCreateLabel(II, IdLoc, LabelLoc));
1126 
1127  if (!TryConsumeToken(tok::comma))
1128  break;
1129  }
1130 
1131  DeclSpec DS(AttrFactory);
1132  DeclGroupPtrTy Res =
1133  Actions.FinalizeDeclaratorGroup(getCurScope(), DS, DeclsInGroup);
1134  StmtResult R = Actions.ActOnDeclStmt(Res, LabelLoc, Tok.getLocation());
1135 
1136  ExpectAndConsumeSemi(diag::err_expected_semi_declaration);
1137  if (R.isUsable())
1138  Stmts.push_back(R.get());
1139  }
1140 
1141  ParsedStmtContext SubStmtCtx =
1142  ParsedStmtContext::Compound |
1143  (isStmtExpr ? ParsedStmtContext::InStmtExpr : ParsedStmtContext());
1144 
1145  while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) &&
1146  Tok.isNot(tok::eof)) {
1147  if (Tok.is(tok::annot_pragma_unused)) {
1148  HandlePragmaUnused();
1149  continue;
1150  }
1151 
1152  if (ConsumeNullStmt(Stmts))
1153  continue;
1154 
1155  StmtResult R;
1156  if (Tok.isNot(tok::kw___extension__)) {
1157  R = ParseStatementOrDeclaration(Stmts, SubStmtCtx);
1158  } else {
1159  // __extension__ can start declarations and it can also be a unary
1160  // operator for expressions. Consume multiple __extension__ markers here
1161  // until we can determine which is which.
1162  // FIXME: This loses extension expressions in the AST!
1163  SourceLocation ExtLoc = ConsumeToken();
1164  while (Tok.is(tok::kw___extension__))
1165  ConsumeToken();
1166 
1167  ParsedAttributes attrs(AttrFactory);
1168  MaybeParseCXX11Attributes(attrs, /*MightBeObjCMessageSend*/ true);
1169 
1170  // If this is the start of a declaration, parse it as such.
1171  if (isDeclarationStatement()) {
1172  // __extension__ silences extension warnings in the subdeclaration.
1173  // FIXME: Save the __extension__ on the decl as a node somehow?
1174  ExtensionRAIIObject O(Diags);
1175 
1176  SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
1177  ParsedAttributes DeclSpecAttrs(AttrFactory);
1178  DeclGroupPtrTy Res = ParseDeclaration(DeclaratorContext::Block, DeclEnd,
1179  attrs, DeclSpecAttrs);
1180  R = Actions.ActOnDeclStmt(Res, DeclStart, DeclEnd);
1181  } else {
1182  // Otherwise this was a unary __extension__ marker.
1183  ExprResult Res(ParseExpressionWithLeadingExtension(ExtLoc));
1184 
1185  if (Res.isInvalid()) {
1186  SkipUntil(tok::semi);
1187  continue;
1188  }
1189 
1190  // Eat the semicolon at the end of stmt and convert the expr into a
1191  // statement.
1192  ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
1193  R = handleExprStmt(Res, SubStmtCtx);
1194  if (R.isUsable())
1195  R = Actions.ActOnAttributedStmt(attrs, R.get());
1196  }
1197  }
1198 
1199  if (R.isUsable())
1200  Stmts.push_back(R.get());
1201  }
1202  // Warn the user that using option `-ffp-eval-method=source` on a
1203  // 32-bit target and feature `sse` disabled, or using
1204  // `pragma clang fp eval_method=source` and feature `sse` disabled, is not
1205  // supported.
1206  if (!PP.getTargetInfo().supportSourceEvalMethod() &&
1208  PP.getCurrentFPEvalMethod() ==
1209  LangOptions::FPEvalMethodKind::FEM_Source))
1210  Diag(Tok.getLocation(),
1211  diag::warn_no_support_for_eval_method_source_on_m32);
1212 
1213  SourceLocation CloseLoc = Tok.getLocation();
1214 
1215  // We broke out of the while loop because we found a '}' or EOF.
1216  if (!T.consumeClose()) {
1217  // If this is the '})' of a statement expression, check that it's written
1218  // in a sensible way.
1219  if (isStmtExpr && Tok.is(tok::r_paren))
1220  checkCompoundToken(CloseLoc, tok::r_brace, CompoundToken::StmtExprEnd);
1221  } else {
1222  // Recover by creating a compound statement with what we parsed so far,
1223  // instead of dropping everything and returning StmtError().
1224  }
1225 
1226  if (T.getCloseLocation().isValid())
1227  CloseLoc = T.getCloseLocation();
1228 
1229  return Actions.ActOnCompoundStmt(T.getOpenLocation(), CloseLoc,
1230  Stmts, isStmtExpr);
1231 }
1232 
1233 /// ParseParenExprOrCondition:
1234 /// [C ] '(' expression ')'
1235 /// [C++] '(' condition ')'
1236 /// [C++1z] '(' init-statement[opt] condition ')'
1237 ///
1238 /// This function parses and performs error recovery on the specified condition
1239 /// or expression (depending on whether we're in C++ or C mode). This function
1240 /// goes out of its way to recover well. It returns true if there was a parser
1241 /// error (the right paren couldn't be found), which indicates that the caller
1242 /// should try to recover harder. It returns false if the condition is
1243 /// successfully parsed. Note that a successful parse can still have semantic
1244 /// errors in the condition.
1245 /// Additionally, if LParenLoc and RParenLoc are non-null, it will assign
1246 /// the location of the outer-most '(' and ')', respectively, to them.
1247 bool Parser::ParseParenExprOrCondition(StmtResult *InitStmt,
1248  Sema::ConditionResult &Cond,
1249  SourceLocation Loc,
1250  Sema::ConditionKind CK, bool MissingOK,
1251  SourceLocation *LParenLoc,
1252  SourceLocation *RParenLoc) {
1253  BalancedDelimiterTracker T(*this, tok::l_paren);
1254  T.consumeOpen();
1255  SourceLocation Start = Tok.getLocation();
1256 
1257  if (getLangOpts().CPlusPlus) {
1258  Cond = ParseCXXCondition(InitStmt, Loc, CK, MissingOK);
1259  } else {
1260  ExprResult CondExpr = ParseExpression();
1261 
1262  // If required, convert to a boolean value.
1263  if (CondExpr.isInvalid())
1264  Cond = Sema::ConditionError();
1265  else
1266  Cond = Actions.ActOnCondition(getCurScope(), Loc, CondExpr.get(), CK,
1267  MissingOK);
1268  }
1269 
1270  // If the parser was confused by the condition and we don't have a ')', try to
1271  // recover by skipping ahead to a semi and bailing out. If condexp is
1272  // semantically invalid but we have well formed code, keep going.
1273  if (Cond.isInvalid() && Tok.isNot(tok::r_paren)) {
1274  SkipUntil(tok::semi);
1275  // Skipping may have stopped if it found the containing ')'. If so, we can
1276  // continue parsing the if statement.
1277  if (Tok.isNot(tok::r_paren))
1278  return true;
1279  }
1280 
1281  if (Cond.isInvalid()) {
1282  ExprResult CondExpr = Actions.CreateRecoveryExpr(
1283  Start, Tok.getLocation() == Start ? Start : PrevTokLocation, {},
1284  Actions.PreferredConditionType(CK));
1285  if (!CondExpr.isInvalid())
1286  Cond = Actions.ActOnCondition(getCurScope(), Loc, CondExpr.get(), CK,
1287  MissingOK);
1288  }
1289 
1290  // Either the condition is valid or the rparen is present.
1291  T.consumeClose();
1292 
1293  if (LParenLoc != nullptr) {
1294  *LParenLoc = T.getOpenLocation();
1295  }
1296  if (RParenLoc != nullptr) {
1297  *RParenLoc = T.getCloseLocation();
1298  }
1299 
1300  // Check for extraneous ')'s to catch things like "if (foo())) {". We know
1301  // that all callers are looking for a statement after the condition, so ")"
1302  // isn't valid.
1303  while (Tok.is(tok::r_paren)) {
1304  Diag(Tok, diag::err_extraneous_rparen_in_condition)
1306  ConsumeParen();
1307  }
1308 
1309  return false;
1310 }
1311 
1312 namespace {
1313 
1314 enum MisleadingStatementKind { MSK_if, MSK_else, MSK_for, MSK_while };
1315 
1316 struct MisleadingIndentationChecker {
1317  Parser &P;
1318  SourceLocation StmtLoc;
1319  SourceLocation PrevLoc;
1320  unsigned NumDirectives;
1321  MisleadingStatementKind Kind;
1322  bool ShouldSkip;
1323  MisleadingIndentationChecker(Parser &P, MisleadingStatementKind K,
1324  SourceLocation SL)
1325  : P(P), StmtLoc(SL), PrevLoc(P.getCurToken().getLocation()),
1326  NumDirectives(P.getPreprocessor().getNumDirectives()), Kind(K),
1327  ShouldSkip(P.getCurToken().is(tok::l_brace)) {
1328  if (!P.MisleadingIndentationElseLoc.isInvalid()) {
1329  StmtLoc = P.MisleadingIndentationElseLoc;
1330  P.MisleadingIndentationElseLoc = SourceLocation();
1331  }
1332  if (Kind == MSK_else && !ShouldSkip)
1333  P.MisleadingIndentationElseLoc = SL;
1334  }
1335 
1336  /// Compute the column number will aligning tabs on TabStop (-ftabstop), this
1337  /// gives the visual indentation of the SourceLocation.
1338  static unsigned getVisualIndentation(SourceManager &SM, SourceLocation Loc) {
1339  unsigned TabStop = SM.getDiagnostics().getDiagnosticOptions().TabStop;
1340 
1341  unsigned ColNo = SM.getSpellingColumnNumber(Loc);
1342  if (ColNo == 0 || TabStop == 1)
1343  return ColNo;
1344 
1345  std::pair<FileID, unsigned> FIDAndOffset = SM.getDecomposedLoc(Loc);
1346 
1347  bool Invalid;
1348  StringRef BufData = SM.getBufferData(FIDAndOffset.first, &Invalid);
1349  if (Invalid)
1350  return 0;
1351 
1352  const char *EndPos = BufData.data() + FIDAndOffset.second;
1353  // FileOffset are 0-based and Column numbers are 1-based
1354  assert(FIDAndOffset.second + 1 >= ColNo &&
1355  "Column number smaller than file offset?");
1356 
1357  unsigned VisualColumn = 0; // Stored as 0-based column, here.
1358  // Loop from beginning of line up to Loc's file position, counting columns,
1359  // expanding tabs.
1360  for (const char *CurPos = EndPos - (ColNo - 1); CurPos != EndPos;
1361  ++CurPos) {
1362  if (*CurPos == '\t')
1363  // Advance visual column to next tabstop.
1364  VisualColumn += (TabStop - VisualColumn % TabStop);
1365  else
1366  VisualColumn++;
1367  }
1368  return VisualColumn + 1;
1369  }
1370 
1371  void Check() {
1372  Token Tok = P.getCurToken();
1373  if (P.getActions().getDiagnostics().isIgnored(
1374  diag::warn_misleading_indentation, Tok.getLocation()) ||
1375  ShouldSkip || NumDirectives != P.getPreprocessor().getNumDirectives() ||
1376  Tok.isOneOf(tok::semi, tok::r_brace) || Tok.isAnnotation() ||
1377  Tok.getLocation().isMacroID() || PrevLoc.isMacroID() ||
1378  StmtLoc.isMacroID() ||
1379  (Kind == MSK_else && P.MisleadingIndentationElseLoc.isInvalid())) {
1380  P.MisleadingIndentationElseLoc = SourceLocation();
1381  return;
1382  }
1383  if (Kind == MSK_else)
1384  P.MisleadingIndentationElseLoc = SourceLocation();
1385 
1386  SourceManager &SM = P.getPreprocessor().getSourceManager();
1387  unsigned PrevColNum = getVisualIndentation(SM, PrevLoc);
1388  unsigned CurColNum = getVisualIndentation(SM, Tok.getLocation());
1389  unsigned StmtColNum = getVisualIndentation(SM, StmtLoc);
1390 
1391  if (PrevColNum != 0 && CurColNum != 0 && StmtColNum != 0 &&
1392  ((PrevColNum > StmtColNum && PrevColNum == CurColNum) ||
1393  !Tok.isAtStartOfLine()) &&
1394  SM.getPresumedLineNumber(StmtLoc) !=
1395  SM.getPresumedLineNumber(Tok.getLocation()) &&
1396  (Tok.isNot(tok::identifier) ||
1397  P.getPreprocessor().LookAhead(0).isNot(tok::colon))) {
1398  P.Diag(Tok.getLocation(), diag::warn_misleading_indentation) << Kind;
1399  P.Diag(StmtLoc, diag::note_previous_statement);
1400  }
1401  }
1402 };
1403 
1404 }
1405 
1406 /// ParseIfStatement
1407 /// if-statement: [C99 6.8.4.1]
1408 /// 'if' '(' expression ')' statement
1409 /// 'if' '(' expression ')' statement 'else' statement
1410 /// [C++] 'if' '(' condition ')' statement
1411 /// [C++] 'if' '(' condition ')' statement 'else' statement
1412 /// [C++23] 'if' '!' [opt] consteval compound-statement
1413 /// [C++23] 'if' '!' [opt] consteval compound-statement 'else' statement
1414 ///
1415 StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
1416  assert(Tok.is(tok::kw_if) && "Not an if stmt!");
1417  SourceLocation IfLoc = ConsumeToken(); // eat the 'if'.
1418 
1419  bool IsConstexpr = false;
1420  bool IsConsteval = false;
1421  SourceLocation NotLocation;
1422  SourceLocation ConstevalLoc;
1423 
1424  if (Tok.is(tok::kw_constexpr)) {
1425  Diag(Tok, getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_constexpr_if
1426  : diag::ext_constexpr_if);
1427  IsConstexpr = true;
1428  ConsumeToken();
1429  } else {
1430  if (Tok.is(tok::exclaim)) {
1431  NotLocation = ConsumeToken();
1432  }
1433 
1434  if (Tok.is(tok::kw_consteval)) {
1435  Diag(Tok, getLangOpts().CPlusPlus2b ? diag::warn_cxx20_compat_consteval_if
1436  : diag::ext_consteval_if);
1437  IsConsteval = true;
1438  ConstevalLoc = ConsumeToken();
1439  }
1440  }
1441  if (!IsConsteval && (NotLocation.isValid() || Tok.isNot(tok::l_paren))) {
1442  Diag(Tok, diag::err_expected_lparen_after) << "if";
1443  SkipUntil(tok::semi);
1444  return StmtError();
1445  }
1446 
1447  bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1448 
1449  // C99 6.8.4p3 - In C99, the if statement is a block. This is not
1450  // the case for C90.
1451  //
1452  // C++ 6.4p3:
1453  // A name introduced by a declaration in a condition is in scope from its
1454  // point of declaration until the end of the substatements controlled by the
1455  // condition.
1456  // C++ 3.3.2p4:
1457  // Names declared in the for-init-statement, and in the condition of if,
1458  // while, for, and switch statements are local to the if, while, for, or
1459  // switch statement (including the controlled statement).
1460  //
1461  ParseScope IfScope(this, Scope::DeclScope | Scope::ControlScope, C99orCXX);
1462 
1463  // Parse the condition.
1464  StmtResult InitStmt;
1465  Sema::ConditionResult Cond;
1466  SourceLocation LParen;
1467  SourceLocation RParen;
1468  llvm::Optional<bool> ConstexprCondition;
1469  if (!IsConsteval) {
1470 
1471  if (ParseParenExprOrCondition(&InitStmt, Cond, IfLoc,
1472  IsConstexpr ? Sema::ConditionKind::ConstexprIf
1474  /*MissingOK=*/false, &LParen, &RParen))
1475  return StmtError();
1476 
1477  if (IsConstexpr)
1478  ConstexprCondition = Cond.getKnownValue();
1479  }
1480 
1481  bool IsBracedThen = Tok.is(tok::l_brace);
1482 
1483  // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
1484  // there is no compound stmt. C90 does not have this clause. We only do this
1485  // if the body isn't a compound statement to avoid push/pop in common cases.
1486  //
1487  // C++ 6.4p1:
1488  // The substatement in a selection-statement (each substatement, in the else
1489  // form of the if statement) implicitly defines a local scope.
1490  //
1491  // For C++ we create a scope for the condition and a new scope for
1492  // substatements because:
1493  // -When the 'then' scope exits, we want the condition declaration to still be
1494  // active for the 'else' scope too.
1495  // -Sema will detect name clashes by considering declarations of a
1496  // 'ControlScope' as part of its direct subscope.
1497  // -If we wanted the condition and substatement to be in the same scope, we
1498  // would have to notify ParseStatement not to create a new scope. It's
1499  // simpler to let it create a new scope.
1500  //
1501  ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, IsBracedThen);
1502 
1503  MisleadingIndentationChecker MIChecker(*this, MSK_if, IfLoc);
1504 
1505  // Read the 'then' stmt.
1506  SourceLocation ThenStmtLoc = Tok.getLocation();
1507 
1508  SourceLocation InnerStatementTrailingElseLoc;
1509  StmtResult ThenStmt;
1510  {
1511  bool ShouldEnter = ConstexprCondition && !*ConstexprCondition;
1514  if (NotLocation.isInvalid() && IsConsteval) {
1516  ShouldEnter = true;
1517  }
1518 
1519  EnterExpressionEvaluationContext PotentiallyDiscarded(
1520  Actions, Context, nullptr,
1522  ThenStmt = ParseStatement(&InnerStatementTrailingElseLoc);
1523  }
1524 
1525  if (Tok.isNot(tok::kw_else))
1526  MIChecker.Check();
1527 
1528  // Pop the 'if' scope if needed.
1529  InnerScope.Exit();
1530 
1531  // If it has an else, parse it.
1532  SourceLocation ElseLoc;
1533  SourceLocation ElseStmtLoc;
1534  StmtResult ElseStmt;
1535 
1536  if (Tok.is(tok::kw_else)) {
1537  if (TrailingElseLoc)
1538  *TrailingElseLoc = Tok.getLocation();
1539 
1540  ElseLoc = ConsumeToken();
1541  ElseStmtLoc = Tok.getLocation();
1542 
1543  // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
1544  // there is no compound stmt. C90 does not have this clause. We only do
1545  // this if the body isn't a compound statement to avoid push/pop in common
1546  // cases.
1547  //
1548  // C++ 6.4p1:
1549  // The substatement in a selection-statement (each substatement, in the else
1550  // form of the if statement) implicitly defines a local scope.
1551  //
1552  ParseScope InnerScope(this, Scope::DeclScope, C99orCXX,
1553  Tok.is(tok::l_brace));
1554 
1555  MisleadingIndentationChecker MIChecker(*this, MSK_else, ElseLoc);
1556  bool ShouldEnter = ConstexprCondition && *ConstexprCondition;
1559  if (NotLocation.isValid() && IsConsteval) {
1561  ShouldEnter = true;
1562  }
1563 
1564  EnterExpressionEvaluationContext PotentiallyDiscarded(
1565  Actions, Context, nullptr,
1567  ElseStmt = ParseStatement();
1568 
1569  if (ElseStmt.isUsable())
1570  MIChecker.Check();
1571 
1572  // Pop the 'else' scope if needed.
1573  InnerScope.Exit();
1574  } else if (Tok.is(tok::code_completion)) {
1575  cutOffParsing();
1576  Actions.CodeCompleteAfterIf(getCurScope(), IsBracedThen);
1577  return StmtError();
1578  } else if (InnerStatementTrailingElseLoc.isValid()) {
1579  Diag(InnerStatementTrailingElseLoc, diag::warn_dangling_else);
1580  }
1581 
1582  IfScope.Exit();
1583 
1584  // If the then or else stmt is invalid and the other is valid (and present),
1585  // make turn the invalid one into a null stmt to avoid dropping the other
1586  // part. If both are invalid, return error.
1587  if ((ThenStmt.isInvalid() && ElseStmt.isInvalid()) ||
1588  (ThenStmt.isInvalid() && ElseStmt.get() == nullptr) ||
1589  (ThenStmt.get() == nullptr && ElseStmt.isInvalid())) {
1590  // Both invalid, or one is invalid and other is non-present: return error.
1591  return StmtError();
1592  }
1593 
1594  if (IsConsteval) {
1595  auto IsCompoundStatement = [](const Stmt *S) {
1596  if (const auto *Outer = dyn_cast_or_null<AttributedStmt>(S))
1597  S = Outer->getSubStmt();
1598  return isa_and_nonnull<clang::CompoundStmt>(S);
1599  };
1600 
1601  if (!IsCompoundStatement(ThenStmt.get())) {
1602  Diag(ConstevalLoc, diag::err_expected_after) << "consteval"
1603  << "{";
1604  return StmtError();
1605  }
1606  if (!ElseStmt.isUnset() && !IsCompoundStatement(ElseStmt.get())) {
1607  Diag(ElseLoc, diag::err_expected_after) << "else"
1608  << "{";
1609  return StmtError();
1610  }
1611  }
1612 
1613  // Now if either are invalid, replace with a ';'.
1614  if (ThenStmt.isInvalid())
1615  ThenStmt = Actions.ActOnNullStmt(ThenStmtLoc);
1616  if (ElseStmt.isInvalid())
1617  ElseStmt = Actions.ActOnNullStmt(ElseStmtLoc);
1618 
1620  if (IsConstexpr)
1622  else if (IsConsteval)
1625 
1626  return Actions.ActOnIfStmt(IfLoc, Kind, LParen, InitStmt.get(), Cond, RParen,
1627  ThenStmt.get(), ElseLoc, ElseStmt.get());
1628 }
1629 
1630 /// ParseSwitchStatement
1631 /// switch-statement:
1632 /// 'switch' '(' expression ')' statement
1633 /// [C++] 'switch' '(' condition ')' statement
1634 StmtResult Parser::ParseSwitchStatement(SourceLocation *TrailingElseLoc) {
1635  assert(Tok.is(tok::kw_switch) && "Not a switch stmt!");
1636  SourceLocation SwitchLoc = ConsumeToken(); // eat the 'switch'.
1637 
1638  if (Tok.isNot(tok::l_paren)) {
1639  Diag(Tok, diag::err_expected_lparen_after) << "switch";
1640  SkipUntil(tok::semi);
1641  return StmtError();
1642  }
1643 
1644  bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1645 
1646  // C99 6.8.4p3 - In C99, the switch statement is a block. This is
1647  // not the case for C90. Start the switch scope.
1648  //
1649  // C++ 6.4p3:
1650  // A name introduced by a declaration in a condition is in scope from its
1651  // point of declaration until the end of the substatements controlled by the
1652  // condition.
1653  // C++ 3.3.2p4:
1654  // Names declared in the for-init-statement, and in the condition of if,
1655  // while, for, and switch statements are local to the if, while, for, or
1656  // switch statement (including the controlled statement).
1657  //
1658  unsigned ScopeFlags = Scope::SwitchScope;
1659  if (C99orCXX)
1660  ScopeFlags |= Scope::DeclScope | Scope::ControlScope;
1661  ParseScope SwitchScope(this, ScopeFlags);
1662 
1663  // Parse the condition.
1664  StmtResult InitStmt;
1665  Sema::ConditionResult Cond;
1666  SourceLocation LParen;
1667  SourceLocation RParen;
1668  if (ParseParenExprOrCondition(&InitStmt, Cond, SwitchLoc,
1670  /*MissingOK=*/false, &LParen, &RParen))
1671  return StmtError();
1672 
1674  SwitchLoc, LParen, InitStmt.get(), Cond, RParen);
1675 
1676  if (Switch.isInvalid()) {
1677  // Skip the switch body.
1678  // FIXME: This is not optimal recovery, but parsing the body is more
1679  // dangerous due to the presence of case and default statements, which
1680  // will have no place to connect back with the switch.
1681  if (Tok.is(tok::l_brace)) {
1682  ConsumeBrace();
1683  SkipUntil(tok::r_brace);
1684  } else
1685  SkipUntil(tok::semi);
1686  return Switch;
1687  }
1688 
1689  // C99 6.8.4p3 - In C99, the body of the switch statement is a scope, even if
1690  // there is no compound stmt. C90 does not have this clause. We only do this
1691  // if the body isn't a compound statement to avoid push/pop in common cases.
1692  //
1693  // C++ 6.4p1:
1694  // The substatement in a selection-statement (each substatement, in the else
1695  // form of the if statement) implicitly defines a local scope.
1696  //
1697  // See comments in ParseIfStatement for why we create a scope for the
1698  // condition and a new scope for substatement in C++.
1699  //
1701  ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1702 
1703  // We have incremented the mangling number for the SwitchScope and the
1704  // InnerScope, which is one too many.
1705  if (C99orCXX)
1707 
1708  // Read the body statement.
1709  StmtResult Body(ParseStatement(TrailingElseLoc));
1710 
1711  // Pop the scopes.
1712  InnerScope.Exit();
1713  SwitchScope.Exit();
1714 
1715  return Actions.ActOnFinishSwitchStmt(SwitchLoc, Switch.get(), Body.get());
1716 }
1717 
1718 /// ParseWhileStatement
1719 /// while-statement: [C99 6.8.5.1]
1720 /// 'while' '(' expression ')' statement
1721 /// [C++] 'while' '(' condition ')' statement
1722 StmtResult Parser::ParseWhileStatement(SourceLocation *TrailingElseLoc) {
1723  assert(Tok.is(tok::kw_while) && "Not a while stmt!");
1724  SourceLocation WhileLoc = Tok.getLocation();
1725  ConsumeToken(); // eat the 'while'.
1726 
1727  if (Tok.isNot(tok::l_paren)) {
1728  Diag(Tok, diag::err_expected_lparen_after) << "while";
1729  SkipUntil(tok::semi);
1730  return StmtError();
1731  }
1732 
1733  bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1734 
1735  // C99 6.8.5p5 - In C99, the while statement is a block. This is not
1736  // the case for C90. Start the loop scope.
1737  //
1738  // C++ 6.4p3:
1739  // A name introduced by a declaration in a condition is in scope from its
1740  // point of declaration until the end of the substatements controlled by the
1741  // condition.
1742  // C++ 3.3.2p4:
1743  // Names declared in the for-init-statement, and in the condition of if,
1744  // while, for, and switch statements are local to the if, while, for, or
1745  // switch statement (including the controlled statement).
1746  //
1747  unsigned ScopeFlags;
1748  if (C99orCXX)
1749  ScopeFlags = Scope::BreakScope | Scope::ContinueScope |
1751  else
1752  ScopeFlags = Scope::BreakScope | Scope::ContinueScope;
1753  ParseScope WhileScope(this, ScopeFlags);
1754 
1755  // Parse the condition.
1756  Sema::ConditionResult Cond;
1757  SourceLocation LParen;
1758  SourceLocation RParen;
1759  if (ParseParenExprOrCondition(nullptr, Cond, WhileLoc,
1761  /*MissingOK=*/false, &LParen, &RParen))
1762  return StmtError();
1763 
1764  // C99 6.8.5p5 - In C99, the body of the while statement is a scope, even if
1765  // there is no compound stmt. C90 does not have this clause. We only do this
1766  // if the body isn't a compound statement to avoid push/pop in common cases.
1767  //
1768  // C++ 6.5p2:
1769  // The substatement in an iteration-statement implicitly defines a local scope
1770  // which is entered and exited each time through the loop.
1771  //
1772  // See comments in ParseIfStatement for why we create a scope for the
1773  // condition and a new scope for substatement in C++.
1774  //
1775  ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1776 
1777  MisleadingIndentationChecker MIChecker(*this, MSK_while, WhileLoc);
1778 
1779  // Read the body statement.
1780  StmtResult Body(ParseStatement(TrailingElseLoc));
1781 
1782  if (Body.isUsable())
1783  MIChecker.Check();
1784  // Pop the body scope if needed.
1785  InnerScope.Exit();
1786  WhileScope.Exit();
1787 
1788  if (Cond.isInvalid() || Body.isInvalid())
1789  return StmtError();
1790 
1791  return Actions.ActOnWhileStmt(WhileLoc, LParen, Cond, RParen, Body.get());
1792 }
1793 
1794 /// ParseDoStatement
1795 /// do-statement: [C99 6.8.5.2]
1796 /// 'do' statement 'while' '(' expression ')' ';'
1797 /// Note: this lets the caller parse the end ';'.
1798 StmtResult Parser::ParseDoStatement() {
1799  assert(Tok.is(tok::kw_do) && "Not a do stmt!");
1800  SourceLocation DoLoc = ConsumeToken(); // eat the 'do'.
1801 
1802  // C99 6.8.5p5 - In C99, the do statement is a block. This is not
1803  // the case for C90. Start the loop scope.
1804  unsigned ScopeFlags;
1805  if (getLangOpts().C99)
1807  else
1808  ScopeFlags = Scope::BreakScope | Scope::ContinueScope;
1809 
1810  ParseScope DoScope(this, ScopeFlags);
1811 
1812  // C99 6.8.5p5 - In C99, the body of the do statement is a scope, even if
1813  // there is no compound stmt. C90 does not have this clause. We only do this
1814  // if the body isn't a compound statement to avoid push/pop in common cases.
1815  //
1816  // C++ 6.5p2:
1817  // The substatement in an iteration-statement implicitly defines a local scope
1818  // which is entered and exited each time through the loop.
1819  //
1820  bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1821  ParseScope InnerScope(this, Scope::DeclScope, C99orCXX, Tok.is(tok::l_brace));
1822 
1823  // Read the body statement.
1824  StmtResult Body(ParseStatement());
1825 
1826  // Pop the body scope if needed.
1827  InnerScope.Exit();
1828 
1829  if (Tok.isNot(tok::kw_while)) {
1830  if (!Body.isInvalid()) {
1831  Diag(Tok, diag::err_expected_while);
1832  Diag(DoLoc, diag::note_matching) << "'do'";
1833  SkipUntil(tok::semi, StopBeforeMatch);
1834  }
1835  return StmtError();
1836  }
1837  SourceLocation WhileLoc = ConsumeToken();
1838 
1839  if (Tok.isNot(tok::l_paren)) {
1840  Diag(Tok, diag::err_expected_lparen_after) << "do/while";
1841  SkipUntil(tok::semi, StopBeforeMatch);
1842  return StmtError();
1843  }
1844 
1845  // Parse the parenthesized expression.
1846  BalancedDelimiterTracker T(*this, tok::l_paren);
1847  T.consumeOpen();
1848 
1849  // A do-while expression is not a condition, so can't have attributes.
1850  DiagnoseAndSkipCXX11Attributes();
1851 
1852  SourceLocation Start = Tok.getLocation();
1853  ExprResult Cond = ParseExpression();
1854  // Correct the typos in condition before closing the scope.
1855  if (Cond.isUsable())
1856  Cond = Actions.CorrectDelayedTyposInExpr(Cond);
1857  else {
1858  if (!Tok.isOneOf(tok::r_paren, tok::r_square, tok::r_brace))
1859  SkipUntil(tok::semi);
1860  Cond = Actions.CreateRecoveryExpr(
1861  Start, Start == Tok.getLocation() ? Start : PrevTokLocation, {},
1862  Actions.getASTContext().BoolTy);
1863  }
1864  T.consumeClose();
1865  DoScope.Exit();
1866 
1867  if (Cond.isInvalid() || Body.isInvalid())
1868  return StmtError();
1869 
1870  return Actions.ActOnDoStmt(DoLoc, Body.get(), WhileLoc, T.getOpenLocation(),
1871  Cond.get(), T.getCloseLocation());
1872 }
1873 
1874 bool Parser::isForRangeIdentifier() {
1875  assert(Tok.is(tok::identifier));
1876 
1877  const Token &Next = NextToken();
1878  if (Next.is(tok::colon))
1879  return true;
1880 
1881  if (Next.isOneOf(tok::l_square, tok::kw_alignas)) {
1882  TentativeParsingAction PA(*this);
1883  ConsumeToken();
1884  SkipCXX11Attributes();
1885  bool Result = Tok.is(tok::colon);
1886  PA.Revert();
1887  return Result;
1888  }
1889 
1890  return false;
1891 }
1892 
1893 /// ParseForStatement
1894 /// for-statement: [C99 6.8.5.3]
1895 /// 'for' '(' expr[opt] ';' expr[opt] ';' expr[opt] ')' statement
1896 /// 'for' '(' declaration expr[opt] ';' expr[opt] ')' statement
1897 /// [C++] 'for' '(' for-init-statement condition[opt] ';' expression[opt] ')'
1898 /// [C++] statement
1899 /// [C++0x] 'for'
1900 /// 'co_await'[opt] [Coroutines]
1901 /// '(' for-range-declaration ':' for-range-initializer ')'
1902 /// statement
1903 /// [OBJC2] 'for' '(' declaration 'in' expr ')' statement
1904 /// [OBJC2] 'for' '(' expr 'in' expr ')' statement
1905 ///
1906 /// [C++] for-init-statement:
1907 /// [C++] expression-statement
1908 /// [C++] simple-declaration
1909 /// [C++2b] alias-declaration
1910 ///
1911 /// [C++0x] for-range-declaration:
1912 /// [C++0x] attribute-specifier-seq[opt] type-specifier-seq declarator
1913 /// [C++0x] for-range-initializer:
1914 /// [C++0x] expression
1915 /// [C++0x] braced-init-list [TODO]
1916 StmtResult Parser::ParseForStatement(SourceLocation *TrailingElseLoc) {
1917  assert(Tok.is(tok::kw_for) && "Not a for stmt!");
1918  SourceLocation ForLoc = ConsumeToken(); // eat the 'for'.
1919 
1920  SourceLocation CoawaitLoc;
1921  if (Tok.is(tok::kw_co_await))
1922  CoawaitLoc = ConsumeToken();
1923 
1924  if (Tok.isNot(tok::l_paren)) {
1925  Diag(Tok, diag::err_expected_lparen_after) << "for";
1926  SkipUntil(tok::semi);
1927  return StmtError();
1928  }
1929 
1930  bool C99orCXXorObjC = getLangOpts().C99 || getLangOpts().CPlusPlus ||
1931  getLangOpts().ObjC;
1932 
1933  // C99 6.8.5p5 - In C99, the for statement is a block. This is not
1934  // the case for C90. Start the loop scope.
1935  //
1936  // C++ 6.4p3:
1937  // A name introduced by a declaration in a condition is in scope from its
1938  // point of declaration until the end of the substatements controlled by the
1939  // condition.
1940  // C++ 3.3.2p4:
1941  // Names declared in the for-init-statement, and in the condition of if,
1942  // while, for, and switch statements are local to the if, while, for, or
1943  // switch statement (including the controlled statement).
1944  // C++ 6.5.3p1:
1945  // Names declared in the for-init-statement are in the same declarative-region
1946  // as those declared in the condition.
1947  //
1948  unsigned ScopeFlags = 0;
1949  if (C99orCXXorObjC)
1950  ScopeFlags = Scope::DeclScope | Scope::ControlScope;
1951 
1952  ParseScope ForScope(this, ScopeFlags);
1953 
1954  BalancedDelimiterTracker T(*this, tok::l_paren);
1955  T.consumeOpen();
1956 
1957  ExprResult Value;
1958 
1959  bool ForEach = false;
1960  StmtResult FirstPart;
1961  Sema::ConditionResult SecondPart;
1962  ExprResult Collection;
1963  ForRangeInfo ForRangeInfo;
1964  FullExprArg ThirdPart(Actions);
1965 
1966  if (Tok.is(tok::code_completion)) {
1967  cutOffParsing();
1969  C99orCXXorObjC? Sema::PCC_ForInit
1971  return StmtError();
1972  }
1973 
1974  ParsedAttributes attrs(AttrFactory);
1975  MaybeParseCXX11Attributes(attrs);
1976 
1977  SourceLocation EmptyInitStmtSemiLoc;
1978 
1979  // Parse the first part of the for specifier.
1980  if (Tok.is(tok::semi)) { // for (;
1981  ProhibitAttributes(attrs);
1982  // no first part, eat the ';'.
1983  SourceLocation SemiLoc = Tok.getLocation();
1984  if (!Tok.hasLeadingEmptyMacro() && !SemiLoc.isMacroID())
1985  EmptyInitStmtSemiLoc = SemiLoc;
1986  ConsumeToken();
1987  } else if (getLangOpts().CPlusPlus && Tok.is(tok::identifier) &&
1988  isForRangeIdentifier()) {
1989  ProhibitAttributes(attrs);
1990  IdentifierInfo *Name = Tok.getIdentifierInfo();
1991  SourceLocation Loc = ConsumeToken();
1992  MaybeParseCXX11Attributes(attrs);
1993 
1994  ForRangeInfo.ColonLoc = ConsumeToken();
1995  if (Tok.is(tok::l_brace))
1996  ForRangeInfo.RangeExpr = ParseBraceInitializer();
1997  else
1998  ForRangeInfo.RangeExpr = ParseExpression();
1999 
2000  Diag(Loc, diag::err_for_range_identifier)
2001  << ((getLangOpts().CPlusPlus11 && !getLangOpts().CPlusPlus17)
2002  ? FixItHint::CreateInsertion(Loc, "auto &&")
2003  : FixItHint());
2004 
2005  ForRangeInfo.LoopVar =
2006  Actions.ActOnCXXForRangeIdentifier(getCurScope(), Loc, Name, attrs);
2007  } else if (isForInitDeclaration()) { // for (int X = 4;
2008  ParenBraceBracketBalancer BalancerRAIIObj(*this);
2009 
2010  // Parse declaration, which eats the ';'.
2011  if (!C99orCXXorObjC) { // Use of C99-style for loops in C90 mode?
2012  Diag(Tok, diag::ext_c99_variable_decl_in_for_loop);
2013  Diag(Tok, diag::warn_gcc_variable_decl_in_for_loop);
2014  }
2015  DeclGroupPtrTy DG;
2016  if (Tok.is(tok::kw_using)) {
2017  DG = ParseAliasDeclarationInInitStatement(DeclaratorContext::ForInit,
2018  attrs);
2019  } else {
2020  // In C++0x, "for (T NS:a" might not be a typo for ::
2021  bool MightBeForRangeStmt = getLangOpts().CPlusPlus;
2022  ColonProtectionRAIIObject ColonProtection(*this, MightBeForRangeStmt);
2023 
2024  SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
2025  ParsedAttributes DeclSpecAttrs(AttrFactory);
2026  DG = ParseSimpleDeclaration(
2027  DeclaratorContext::ForInit, DeclEnd, attrs, DeclSpecAttrs, false,
2028  MightBeForRangeStmt ? &ForRangeInfo : nullptr);
2029  FirstPart = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
2030  if (ForRangeInfo.ParsedForRangeDecl()) {
2031  Diag(ForRangeInfo.ColonLoc, getLangOpts().CPlusPlus11
2032  ? diag::warn_cxx98_compat_for_range
2033  : diag::ext_for_range);
2034  ForRangeInfo.LoopVar = FirstPart;
2035  FirstPart = StmtResult();
2036  } else if (Tok.is(tok::semi)) { // for (int x = 4;
2037  ConsumeToken();
2038  } else if ((ForEach = isTokIdentifier_in())) {
2039  Actions.ActOnForEachDeclStmt(DG);
2040  // ObjC: for (id x in expr)
2041  ConsumeToken(); // consume 'in'
2042 
2043  if (Tok.is(tok::code_completion)) {
2044  cutOffParsing();
2046  return StmtError();
2047  }
2048  Collection = ParseExpression();
2049  } else {
2050  Diag(Tok, diag::err_expected_semi_for);
2051  }
2052  }
2053  } else {
2054  ProhibitAttributes(attrs);
2056 
2057  ForEach = isTokIdentifier_in();
2058 
2059  // Turn the expression into a stmt.
2060  if (!Value.isInvalid()) {
2061  if (ForEach)
2062  FirstPart = Actions.ActOnForEachLValueExpr(Value.get());
2063  else {
2064  // We already know this is not an init-statement within a for loop, so
2065  // if we are parsing a C++11 range-based for loop, we should treat this
2066  // expression statement as being a discarded value expression because
2067  // we will err below. This way we do not warn on an unused expression
2068  // that was an error in the first place, like with: for (expr : expr);
2069  bool IsRangeBasedFor =
2070  getLangOpts().CPlusPlus11 && !ForEach && Tok.is(tok::colon);
2071  FirstPart = Actions.ActOnExprStmt(Value, !IsRangeBasedFor);
2072  }
2073  }
2074 
2075  if (Tok.is(tok::semi)) {
2076  ConsumeToken();
2077  } else if (ForEach) {
2078  ConsumeToken(); // consume 'in'
2079 
2080  if (Tok.is(tok::code_completion)) {
2081  cutOffParsing();
2082  Actions.CodeCompleteObjCForCollection(getCurScope(), nullptr);
2083  return StmtError();
2084  }
2085  Collection = ParseExpression();
2086  } else if (getLangOpts().CPlusPlus11 && Tok.is(tok::colon) && FirstPart.get()) {
2087  // User tried to write the reasonable, but ill-formed, for-range-statement
2088  // for (expr : expr) { ... }
2089  Diag(Tok, diag::err_for_range_expected_decl)
2090  << FirstPart.get()->getSourceRange();
2091  SkipUntil(tok::r_paren, StopBeforeMatch);
2092  SecondPart = Sema::ConditionError();
2093  } else {
2094  if (!Value.isInvalid()) {
2095  Diag(Tok, diag::err_expected_semi_for);
2096  } else {
2097  // Skip until semicolon or rparen, don't consume it.
2098  SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch);
2099  if (Tok.is(tok::semi))
2100  ConsumeToken();
2101  }
2102  }
2103  }
2104 
2105  // Parse the second part of the for specifier.
2106  if (!ForEach && !ForRangeInfo.ParsedForRangeDecl() &&
2107  !SecondPart.isInvalid()) {
2108  // Parse the second part of the for specifier.
2109  if (Tok.is(tok::semi)) { // for (...;;
2110  // no second part.
2111  } else if (Tok.is(tok::r_paren)) {
2112  // missing both semicolons.
2113  } else {
2114  if (getLangOpts().CPlusPlus) {
2115  // C++2a: We've parsed an init-statement; we might have a
2116  // for-range-declaration next.
2117  bool MightBeForRangeStmt = !ForRangeInfo.ParsedForRangeDecl();
2118  ColonProtectionRAIIObject ColonProtection(*this, MightBeForRangeStmt);
2119  SecondPart = ParseCXXCondition(
2120  nullptr, ForLoc, Sema::ConditionKind::Boolean,
2121  // FIXME: recovery if we don't see another semi!
2122  /*MissingOK=*/true, MightBeForRangeStmt ? &ForRangeInfo : nullptr,
2123  /*EnterForConditionScope*/ true);
2124 
2125  if (ForRangeInfo.ParsedForRangeDecl()) {
2126  Diag(FirstPart.get() ? FirstPart.get()->getBeginLoc()
2127  : ForRangeInfo.ColonLoc,
2129  ? diag::warn_cxx17_compat_for_range_init_stmt
2130  : diag::ext_for_range_init_stmt)
2131  << (FirstPart.get() ? FirstPart.get()->getSourceRange()
2132  : SourceRange());
2133  if (EmptyInitStmtSemiLoc.isValid()) {
2134  Diag(EmptyInitStmtSemiLoc, diag::warn_empty_init_statement)
2135  << /*for-loop*/ 2
2136  << FixItHint::CreateRemoval(EmptyInitStmtSemiLoc);
2137  }
2138  }
2139  } else {
2140  // We permit 'continue' and 'break' in the condition of a for loop.
2142 
2143  ExprResult SecondExpr = ParseExpression();
2144  if (SecondExpr.isInvalid())
2145  SecondPart = Sema::ConditionError();
2146  else
2147  SecondPart = Actions.ActOnCondition(
2148  getCurScope(), ForLoc, SecondExpr.get(),
2149  Sema::ConditionKind::Boolean, /*MissingOK=*/true);
2150  }
2151  }
2152  }
2153 
2154  // Enter a break / continue scope, if we didn't already enter one while
2155  // parsing the second part.
2156  if (!getCurScope()->isContinueScope())
2158 
2159  // Parse the third part of the for statement.
2160  if (!ForEach && !ForRangeInfo.ParsedForRangeDecl()) {
2161  if (Tok.isNot(tok::semi)) {
2162  if (!SecondPart.isInvalid())
2163  Diag(Tok, diag::err_expected_semi_for);
2164  else
2165  // Skip until semicolon or rparen, don't consume it.
2166  SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch);
2167  }
2168 
2169  if (Tok.is(tok::semi)) {
2170  ConsumeToken();
2171  }
2172 
2173  if (Tok.isNot(tok::r_paren)) { // for (...;...;)
2174  ExprResult Third = ParseExpression();
2175  // FIXME: The C++11 standard doesn't actually say that this is a
2176  // discarded-value expression, but it clearly should be.
2177  ThirdPart = Actions.MakeFullDiscardedValueExpr(Third.get());
2178  }
2179  }
2180  // Match the ')'.
2181  T.consumeClose();
2182 
2183  // C++ Coroutines [stmt.iter]:
2184  // 'co_await' can only be used for a range-based for statement.
2185  if (CoawaitLoc.isValid() && !ForRangeInfo.ParsedForRangeDecl()) {
2186  Diag(CoawaitLoc, diag::err_for_co_await_not_range_for);
2187  CoawaitLoc = SourceLocation();
2188  }
2189 
2190  if (CoawaitLoc.isValid() && getLangOpts().CPlusPlus20)
2191  Diag(CoawaitLoc, diag::warn_deprecated_for_co_await);
2192 
2193  // We need to perform most of the semantic analysis for a C++0x for-range
2194  // statememt before parsing the body, in order to be able to deduce the type
2195  // of an auto-typed loop variable.
2196  StmtResult ForRangeStmt;
2197  StmtResult ForEachStmt;
2198 
2199  if (ForRangeInfo.ParsedForRangeDecl()) {
2200  ExprResult CorrectedRange =
2201  Actions.CorrectDelayedTyposInExpr(ForRangeInfo.RangeExpr.get());
2202  ForRangeStmt = Actions.ActOnCXXForRangeStmt(
2203  getCurScope(), ForLoc, CoawaitLoc, FirstPart.get(),
2204  ForRangeInfo.LoopVar.get(), ForRangeInfo.ColonLoc, CorrectedRange.get(),
2205  T.getCloseLocation(), Sema::BFRK_Build);
2206 
2207  // Similarly, we need to do the semantic analysis for a for-range
2208  // statement immediately in order to close over temporaries correctly.
2209  } else if (ForEach) {
2210  ForEachStmt = Actions.ActOnObjCForCollectionStmt(ForLoc,
2211  FirstPart.get(),
2212  Collection.get(),
2213  T.getCloseLocation());
2214  } else {
2215  // In OpenMP loop region loop control variable must be captured and be
2216  // private. Perform analysis of first part (if any).
2217  if (getLangOpts().OpenMP && FirstPart.isUsable()) {
2218  Actions.ActOnOpenMPLoopInitialization(ForLoc, FirstPart.get());
2219  }
2220  }
2221 
2222  // C99 6.8.5p5 - In C99, the body of the for statement is a scope, even if
2223  // there is no compound stmt. C90 does not have this clause. We only do this
2224  // if the body isn't a compound statement to avoid push/pop in common cases.
2225  //
2226  // C++ 6.5p2:
2227  // The substatement in an iteration-statement implicitly defines a local scope
2228  // which is entered and exited each time through the loop.
2229  //
2230  // See comments in ParseIfStatement for why we create a scope for
2231  // for-init-statement/condition and a new scope for substatement in C++.
2232  //
2233  ParseScope InnerScope(this, Scope::DeclScope, C99orCXXorObjC,
2234  Tok.is(tok::l_brace));
2235 
2236  // The body of the for loop has the same local mangling number as the
2237  // for-init-statement.
2238  // It will only be incremented if the body contains other things that would
2239  // normally increment the mangling number (like a compound statement).
2240  if (C99orCXXorObjC)
2242 
2243  MisleadingIndentationChecker MIChecker(*this, MSK_for, ForLoc);
2244 
2245  // Read the body statement.
2246  StmtResult Body(ParseStatement(TrailingElseLoc));
2247 
2248  if (Body.isUsable())
2249  MIChecker.Check();
2250 
2251  // Pop the body scope if needed.
2252  InnerScope.Exit();
2253 
2254  // Leave the for-scope.
2255  ForScope.Exit();
2256 
2257  if (Body.isInvalid())
2258  return StmtError();
2259 
2260  if (ForEach)
2261  return Actions.FinishObjCForCollectionStmt(ForEachStmt.get(),
2262  Body.get());
2263 
2264  if (ForRangeInfo.ParsedForRangeDecl())
2265  return Actions.FinishCXXForRangeStmt(ForRangeStmt.get(), Body.get());
2266 
2267  return Actions.ActOnForStmt(ForLoc, T.getOpenLocation(), FirstPart.get(),
2268  SecondPart, ThirdPart, T.getCloseLocation(),
2269  Body.get());
2270 }
2271 
2272 /// ParseGotoStatement
2273 /// jump-statement:
2274 /// 'goto' identifier ';'
2275 /// [GNU] 'goto' '*' expression ';'
2276 ///
2277 /// Note: this lets the caller parse the end ';'.
2278 ///
2279 StmtResult Parser::ParseGotoStatement() {
2280  assert(Tok.is(tok::kw_goto) && "Not a goto stmt!");
2281  SourceLocation GotoLoc = ConsumeToken(); // eat the 'goto'.
2282 
2283  StmtResult Res;
2284  if (Tok.is(tok::identifier)) {
2285  LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
2286  Tok.getLocation());
2287  Res = Actions.ActOnGotoStmt(GotoLoc, Tok.getLocation(), LD);
2288  ConsumeToken();
2289  } else if (Tok.is(tok::star)) {
2290  // GNU indirect goto extension.
2291  Diag(Tok, diag::ext_gnu_indirect_goto);
2292  SourceLocation StarLoc = ConsumeToken();
2294  if (R.isInvalid()) { // Skip to the semicolon, but don't consume it.
2295  SkipUntil(tok::semi, StopBeforeMatch);
2296  return StmtError();
2297  }
2298  Res = Actions.ActOnIndirectGotoStmt(GotoLoc, StarLoc, R.get());
2299  } else {
2300  Diag(Tok, diag::err_expected) << tok::identifier;
2301  return StmtError();
2302  }
2303 
2304  return Res;
2305 }
2306 
2307 /// ParseContinueStatement
2308 /// jump-statement:
2309 /// 'continue' ';'
2310 ///
2311 /// Note: this lets the caller parse the end ';'.
2312 ///
2313 StmtResult Parser::ParseContinueStatement() {
2314  SourceLocation ContinueLoc = ConsumeToken(); // eat the 'continue'.
2315  return Actions.ActOnContinueStmt(ContinueLoc, getCurScope());
2316 }
2317 
2318 /// ParseBreakStatement
2319 /// jump-statement:
2320 /// 'break' ';'
2321 ///
2322 /// Note: this lets the caller parse the end ';'.
2323 ///
2324 StmtResult Parser::ParseBreakStatement() {
2325  SourceLocation BreakLoc = ConsumeToken(); // eat the 'break'.
2326  return Actions.ActOnBreakStmt(BreakLoc, getCurScope());
2327 }
2328 
2329 /// ParseReturnStatement
2330 /// jump-statement:
2331 /// 'return' expression[opt] ';'
2332 /// 'return' braced-init-list ';'
2333 /// 'co_return' expression[opt] ';'
2334 /// 'co_return' braced-init-list ';'
2335 StmtResult Parser::ParseReturnStatement() {
2336  assert((Tok.is(tok::kw_return) || Tok.is(tok::kw_co_return)) &&
2337  "Not a return stmt!");
2338  bool IsCoreturn = Tok.is(tok::kw_co_return);
2339  SourceLocation ReturnLoc = ConsumeToken(); // eat the 'return'.
2340 
2341  ExprResult R;
2342  if (Tok.isNot(tok::semi)) {
2343  if (!IsCoreturn)
2344  PreferredType.enterReturn(Actions, Tok.getLocation());
2345  // FIXME: Code completion for co_return.
2346  if (Tok.is(tok::code_completion) && !IsCoreturn) {
2347  cutOffParsing();
2349  PreferredType.get(Tok.getLocation()));
2350  return StmtError();
2351  }
2352 
2353  if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus) {
2354  R = ParseInitializer();
2355  if (R.isUsable())
2356  Diag(R.get()->getBeginLoc(),
2358  ? diag::warn_cxx98_compat_generalized_initializer_lists
2359  : diag::ext_generalized_initializer_lists)
2360  << R.get()->getSourceRange();
2361  } else
2362  R = ParseExpression();
2363  if (R.isInvalid()) {
2364  SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
2365  return StmtError();
2366  }
2367  }
2368  if (IsCoreturn)
2369  return Actions.ActOnCoreturnStmt(getCurScope(), ReturnLoc, R.get());
2370  return Actions.ActOnReturnStmt(ReturnLoc, R.get(), getCurScope());
2371 }
2372 
2373 StmtResult Parser::ParsePragmaLoopHint(StmtVector &Stmts,
2374  ParsedStmtContext StmtCtx,
2375  SourceLocation *TrailingElseLoc,
2376  ParsedAttributes &Attrs) {
2377  // Create temporary attribute list.
2378  ParsedAttributes TempAttrs(AttrFactory);
2379 
2380  SourceLocation StartLoc = Tok.getLocation();
2381 
2382  // Get loop hints and consume annotated token.
2383  while (Tok.is(tok::annot_pragma_loop_hint)) {
2384  LoopHint Hint;
2385  if (!HandlePragmaLoopHint(Hint))
2386  continue;
2387 
2388  ArgsUnion ArgHints[] = {Hint.PragmaNameLoc, Hint.OptionLoc, Hint.StateLoc,
2389  ArgsUnion(Hint.ValueExpr)};
2390  TempAttrs.addNew(Hint.PragmaNameLoc->Ident, Hint.Range, nullptr,
2391  Hint.PragmaNameLoc->Loc, ArgHints, 4,
2393  }
2394 
2395  // Get the next statement.
2396  MaybeParseCXX11Attributes(Attrs);
2397 
2398  ParsedAttributes EmptyDeclSpecAttrs(AttrFactory);
2399  StmtResult S = ParseStatementOrDeclarationAfterAttributes(
2400  Stmts, StmtCtx, TrailingElseLoc, Attrs, EmptyDeclSpecAttrs);
2401 
2402  Attrs.takeAllFrom(TempAttrs);
2403 
2404  // Start of attribute range may already be set for some invalid input.
2405  // See PR46336.
2406  if (Attrs.Range.getBegin().isInvalid())
2407  Attrs.Range.setBegin(StartLoc);
2408 
2409  return S;
2410 }
2411 
2412 Decl *Parser::ParseFunctionStatementBody(Decl *Decl, ParseScope &BodyScope) {
2413  assert(Tok.is(tok::l_brace));
2414  SourceLocation LBraceLoc = Tok.getLocation();
2415 
2416  PrettyDeclStackTraceEntry CrashInfo(Actions.Context, Decl, LBraceLoc,
2417  "parsing function body");
2418 
2419  // Save and reset current vtordisp stack if we have entered a C++ method body.
2420  bool IsCXXMethod =
2421  getLangOpts().CPlusPlus && Decl && isa<CXXMethodDecl>(Decl);
2423  PragmaStackSentinel(Actions, "InternalPragmaState", IsCXXMethod);
2424 
2425  // Do not enter a scope for the brace, as the arguments are in the same scope
2426  // (the function body) as the body itself. Instead, just read the statement
2427  // list and put it into a CompoundStmt for safe keeping.
2428  StmtResult FnBody(ParseCompoundStatementBody());
2429 
2430  // If the function body could not be parsed, make a bogus compoundstmt.
2431  if (FnBody.isInvalid()) {
2432  Sema::CompoundScopeRAII CompoundScope(Actions);
2433  FnBody = Actions.ActOnCompoundStmt(LBraceLoc, LBraceLoc, None, false);
2434  }
2435 
2436  BodyScope.Exit();
2437  return Actions.ActOnFinishFunctionBody(Decl, FnBody.get());
2438 }
2439 
2440 /// ParseFunctionTryBlock - Parse a C++ function-try-block.
2441 ///
2442 /// function-try-block:
2443 /// 'try' ctor-initializer[opt] compound-statement handler-seq
2444 ///
2445 Decl *Parser::ParseFunctionTryBlock(Decl *Decl, ParseScope &BodyScope) {
2446  assert(Tok.is(tok::kw_try) && "Expected 'try'");
2447  SourceLocation TryLoc = ConsumeToken();
2448 
2449  PrettyDeclStackTraceEntry CrashInfo(Actions.Context, Decl, TryLoc,
2450  "parsing function try block");
2451 
2452  // Constructor initializer list?
2453  if (Tok.is(tok::colon))
2454  ParseConstructorInitializer(Decl);
2455  else
2457 
2458  // Save and reset current vtordisp stack if we have entered a C++ method body.
2459  bool IsCXXMethod =
2460  getLangOpts().CPlusPlus && Decl && isa<CXXMethodDecl>(Decl);
2462  PragmaStackSentinel(Actions, "InternalPragmaState", IsCXXMethod);
2463 
2464  SourceLocation LBraceLoc = Tok.getLocation();
2465  StmtResult FnBody(ParseCXXTryBlockCommon(TryLoc, /*FnTry*/true));
2466  // If we failed to parse the try-catch, we just give the function an empty
2467  // compound statement as the body.
2468  if (FnBody.isInvalid()) {
2469  Sema::CompoundScopeRAII CompoundScope(Actions);
2470  FnBody = Actions.ActOnCompoundStmt(LBraceLoc, LBraceLoc, None, false);
2471  }
2472 
2473  BodyScope.Exit();
2474  return Actions.ActOnFinishFunctionBody(Decl, FnBody.get());
2475 }
2476 
2477 bool Parser::trySkippingFunctionBody() {
2478  assert(SkipFunctionBodies &&
2479  "Should only be called when SkipFunctionBodies is enabled");
2480  if (!PP.isCodeCompletionEnabled()) {
2481  SkipFunctionBody();
2482  return true;
2483  }
2484 
2485  // We're in code-completion mode. Skip parsing for all function bodies unless
2486  // the body contains the code-completion point.
2487  TentativeParsingAction PA(*this);
2488  bool IsTryCatch = Tok.is(tok::kw_try);
2489  CachedTokens Toks;
2490  bool ErrorInPrologue = ConsumeAndStoreFunctionPrologue(Toks);
2491  if (llvm::any_of(Toks, [](const Token &Tok) {
2492  return Tok.is(tok::code_completion);
2493  })) {
2494  PA.Revert();
2495  return false;
2496  }
2497  if (ErrorInPrologue) {
2498  PA.Commit();
2500  return true;
2501  }
2502  if (!SkipUntil(tok::r_brace, StopAtCodeCompletion)) {
2503  PA.Revert();
2504  return false;
2505  }
2506  while (IsTryCatch && Tok.is(tok::kw_catch)) {
2507  if (!SkipUntil(tok::l_brace, StopAtCodeCompletion) ||
2508  !SkipUntil(tok::r_brace, StopAtCodeCompletion)) {
2509  PA.Revert();
2510  return false;
2511  }
2512  }
2513  PA.Commit();
2514  return true;
2515 }
2516 
2517 /// ParseCXXTryBlock - Parse a C++ try-block.
2518 ///
2519 /// try-block:
2520 /// 'try' compound-statement handler-seq
2521 ///
2522 StmtResult Parser::ParseCXXTryBlock() {
2523  assert(Tok.is(tok::kw_try) && "Expected 'try'");
2524 
2525  SourceLocation TryLoc = ConsumeToken();
2526  return ParseCXXTryBlockCommon(TryLoc);
2527 }
2528 
2529 /// ParseCXXTryBlockCommon - Parse the common part of try-block and
2530 /// function-try-block.
2531 ///
2532 /// try-block:
2533 /// 'try' compound-statement handler-seq
2534 ///
2535 /// function-try-block:
2536 /// 'try' ctor-initializer[opt] compound-statement handler-seq
2537 ///
2538 /// handler-seq:
2539 /// handler handler-seq[opt]
2540 ///
2541 /// [Borland] try-block:
2542 /// 'try' compound-statement seh-except-block
2543 /// 'try' compound-statement seh-finally-block
2544 ///
2545 StmtResult Parser::ParseCXXTryBlockCommon(SourceLocation TryLoc, bool FnTry) {
2546  if (Tok.isNot(tok::l_brace))
2547  return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
2548 
2549  StmtResult TryBlock(ParseCompoundStatement(
2550  /*isStmtExpr=*/false, Scope::DeclScope | Scope::TryScope |
2552  (FnTry ? Scope::FnTryCatchScope : 0)));
2553  if (TryBlock.isInvalid())
2554  return TryBlock;
2555 
2556  // Borland allows SEH-handlers with 'try'
2557 
2558  if ((Tok.is(tok::identifier) &&
2559  Tok.getIdentifierInfo() == getSEHExceptKeyword()) ||
2560  Tok.is(tok::kw___finally)) {
2561  // TODO: Factor into common return ParseSEHHandlerCommon(...)
2562  StmtResult Handler;
2563  if(Tok.getIdentifierInfo() == getSEHExceptKeyword()) {
2564  SourceLocation Loc = ConsumeToken();
2565  Handler = ParseSEHExceptBlock(Loc);
2566  }
2567  else {
2568  SourceLocation Loc = ConsumeToken();
2569  Handler = ParseSEHFinallyBlock(Loc);
2570  }
2571  if(Handler.isInvalid())
2572  return Handler;
2573 
2574  return Actions.ActOnSEHTryBlock(true /* IsCXXTry */,
2575  TryLoc,
2576  TryBlock.get(),
2577  Handler.get());
2578  }
2579  else {
2580  StmtVector Handlers;
2581 
2582  // C++11 attributes can't appear here, despite this context seeming
2583  // statement-like.
2584  DiagnoseAndSkipCXX11Attributes();
2585 
2586  if (Tok.isNot(tok::kw_catch))
2587  return StmtError(Diag(Tok, diag::err_expected_catch));
2588  while (Tok.is(tok::kw_catch)) {
2589  StmtResult Handler(ParseCXXCatchBlock(FnTry));
2590  if (!Handler.isInvalid())
2591  Handlers.push_back(Handler.get());
2592  }
2593  // Don't bother creating the full statement if we don't have any usable
2594  // handlers.
2595  if (Handlers.empty())
2596  return StmtError();
2597 
2598  return Actions.ActOnCXXTryBlock(TryLoc, TryBlock.get(), Handlers);
2599  }
2600 }
2601 
2602 /// ParseCXXCatchBlock - Parse a C++ catch block, called handler in the standard
2603 ///
2604 /// handler:
2605 /// 'catch' '(' exception-declaration ')' compound-statement
2606 ///
2607 /// exception-declaration:
2608 /// attribute-specifier-seq[opt] type-specifier-seq declarator
2609 /// attribute-specifier-seq[opt] type-specifier-seq abstract-declarator[opt]
2610 /// '...'
2611 ///
2612 StmtResult Parser::ParseCXXCatchBlock(bool FnCatch) {
2613  assert(Tok.is(tok::kw_catch) && "Expected 'catch'");
2614 
2615  SourceLocation CatchLoc = ConsumeToken();
2616 
2617  BalancedDelimiterTracker T(*this, tok::l_paren);
2618  if (T.expectAndConsume())
2619  return StmtError();
2620 
2621  // C++ 3.3.2p3:
2622  // The name in a catch exception-declaration is local to the handler and
2623  // shall not be redeclared in the outermost block of the handler.
2624  ParseScope CatchScope(this, Scope::DeclScope | Scope::ControlScope |
2626  (FnCatch ? Scope::FnTryCatchScope : 0));
2627 
2628  // exception-declaration is equivalent to '...' or a parameter-declaration
2629  // without default arguments.
2630  Decl *ExceptionDecl = nullptr;
2631  if (Tok.isNot(tok::ellipsis)) {
2632  ParsedAttributes Attributes(AttrFactory);
2633  MaybeParseCXX11Attributes(Attributes);
2634 
2635  DeclSpec DS(AttrFactory);
2636 
2637  if (ParseCXXTypeSpecifierSeq(DS))
2638  return StmtError();
2639 
2640  Declarator ExDecl(DS, Attributes, DeclaratorContext::CXXCatch);
2641  ParseDeclarator(ExDecl);
2642  ExceptionDecl = Actions.ActOnExceptionDeclarator(getCurScope(), ExDecl);
2643  } else
2644  ConsumeToken();
2645 
2646  T.consumeClose();
2647  if (T.getCloseLocation().isInvalid())
2648  return StmtError();
2649 
2650  if (Tok.isNot(tok::l_brace))
2651  return StmtError(Diag(Tok, diag::err_expected) << tok::l_brace);
2652 
2653  // FIXME: Possible draft standard bug: attribute-specifier should be allowed?
2654  StmtResult Block(ParseCompoundStatement());
2655  if (Block.isInvalid())
2656  return Block;
2657 
2658  return Actions.ActOnCXXCatchBlock(CatchLoc, ExceptionDecl, Block.get());
2659 }
2660 
2661 void Parser::ParseMicrosoftIfExistsStatement(StmtVector &Stmts) {
2662  IfExistsCondition Result;
2663  if (ParseMicrosoftIfExistsCondition(Result))
2664  return;
2665 
2666  // Handle dependent statements by parsing the braces as a compound statement.
2667  // This is not the same behavior as Visual C++, which don't treat this as a
2668  // compound statement, but for Clang's type checking we can't have anything
2669  // inside these braces escaping to the surrounding code.
2670  if (Result.Behavior == IEB_Dependent) {
2671  if (!Tok.is(tok::l_brace)) {
2672  Diag(Tok, diag::err_expected) << tok::l_brace;
2673  return;
2674  }
2675 
2676  StmtResult Compound = ParseCompoundStatement();
2677  if (Compound.isInvalid())
2678  return;
2679 
2680  StmtResult DepResult = Actions.ActOnMSDependentExistsStmt(Result.KeywordLoc,
2681  Result.IsIfExists,
2682  Result.SS,
2683  Result.Name,
2684  Compound.get());
2685  if (DepResult.isUsable())
2686  Stmts.push_back(DepResult.get());
2687  return;
2688  }
2689 
2690  BalancedDelimiterTracker Braces(*this, tok::l_brace);
2691  if (Braces.consumeOpen()) {
2692  Diag(Tok, diag::err_expected) << tok::l_brace;
2693  return;
2694  }
2695 
2696  switch (Result.Behavior) {
2697  case IEB_Parse:
2698  // Parse the statements below.
2699  break;
2700 
2701  case IEB_Dependent:
2702  llvm_unreachable("Dependent case handled above");
2703 
2704  case IEB_Skip:
2705  Braces.skipToEnd();
2706  return;
2707  }
2708 
2709  // Condition is true, parse the statements.
2710  while (Tok.isNot(tok::r_brace)) {
2711  StmtResult R =
2712  ParseStatementOrDeclaration(Stmts, ParsedStmtContext::Compound);
2713  if (R.isUsable())
2714  Stmts.push_back(R.get());
2715  }
2716  Braces.consumeClose();
2717 }
clang::OpenCL
@ OpenCL
Definition: LangStandard.h:62
clang::SourceRange::setBegin
void setBegin(SourceLocation b)
Definition: SourceLocation.h:222
clang::Sema::ActOnLabelStmt
StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl, SourceLocation ColonLoc, Stmt *SubStmt)
Definition: SemaStmt.cpp:553
clang::IfStatementKind::ConstevalNonNegated
@ ConstevalNonNegated
clang::LoopHint::ValueExpr
Expr * ValueExpr
Definition: LoopHint.h:35
clang::Preprocessor::getCurrentFPEvalMethod
LangOptions::FPEvalMethodKind getCurrentFPEvalMethod() const
Definition: Preprocessor.h:2165
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:5476
clang::IdentifierLoc::Ident
IdentifierInfo * Ident
Definition: ParsedAttr.h:213
clang::Sema::ConditionKind::Boolean
@ Boolean
A boolean condition, from 'if', 'while', 'for', or 'do'.
clang::Sema::PreferredConditionType
QualType PreferredConditionType(ConditionKind K) const
Definition: Sema.h:12437
clang::Sema::ActOnCXXTryBlock
StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock, ArrayRef< Stmt * > Handlers)
ActOnCXXTryBlock - Takes a try compound-statement and a number of handlers and creates a try statemen...
Definition: SemaStmt.cpp:4449
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
clang::Sema::CodeCompleteCase
void CodeCompleteCase(Scope *S)
Definition: SemaCodeComplete.cpp:5846
clang::TypoCorrection
Simple class containing the result of Sema::CorrectTypo.
Definition: TypoCorrection.h:42
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:97
clang::InMessageExpressionRAIIObject
Definition: RAIIObjectsForParser.h:328
clang::TypoCorrection::getCorrectionSpecifier
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
Definition: TypoCorrection.h:91
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:1219
clang::Sema::getASTContext
ASTContext & getASTContext() const
Definition: Sema.h:1619
clang::Sema::BFRK_Build
@ BFRK_Build
Initial building of a for-range statement.
Definition: Sema.h:4979
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:221
llvm::SmallVector
Definition: LLVM.h:38
clang::Sema::ActOnBreakStmt
StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope)
Definition: SemaStmt.cpp:3335
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:219
clang::Sema::ActOnFinishSEHFinallyBlock
StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block)
Definition: SemaStmt.cpp:4603
clang::Stmt::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:324
clang::Token::getIdentifierInfo
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:178
clang::TypoCorrection::getCorrectionDeclAs
DeclClass * getCorrectionDeclAs() const
Definition: TypoCorrection.h:156
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2862
TypoCorrection.h
clang::Token::isAtStartOfLine
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
Definition: Token.h:267
clang::Sema::ActOnCXXForRangeIdentifier
StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, IdentifierInfo *Ident, ParsedAttributes &Attrs)
Definition: SemaDecl.cpp:13394
clang::C99
@ C99
Definition: LangStandard.h:49
clang::Sema::ActOnAttributedStmt
StmtResult ActOnAttributedStmt(const ParsedAttributes &AttrList, Stmt *SubStmt)
Definition: SemaStmt.cpp:599
clang::Parser
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:60
clang::Sema::ExpressionEvaluationContext::DiscardedStatement
@ DiscardedStatement
The current expression occurs within a discarded statement.
llvm::Optional< bool >
RAIIObjectsForParser.h
clang::Sema::ConditionResult::isInvalid
bool isInvalid() const
Definition: Sema.h:12419
clang::ColonProtectionRAIIObject
ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed.
Definition: RAIIObjectsForParser.h:273
clang::LoopHint::Range
SourceRange Range
Definition: LoopHint.h:22
DeclSpec.h
clang::Parser::FullExprArg
Sema::FullExprArg FullExprArg
Definition: Parser.h:463
clang::Scope::SwitchScope
@ SwitchScope
This is a scope that corresponds to a switch statement.
Definition: Scope.h:98
clang::Sema::FinishObjCForCollectionStmt
StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body)
FinishObjCForCollectionStmt - Attach the body to a objective-C foreach statement.
Definition: SemaStmt.cpp:3062
clang::DeclaratorContext::ForInit
@ ForInit
clang::Token
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
clang::BalancedDelimiterTracker
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ....
Definition: RAIIObjectsForParser.h:388
clang::Sema::ConditionKind
ConditionKind
Definition: Sema.h:12432
clang::Sema::CompoundScopeRAII
A RAII object to enter scope of a compound statement.
Definition: Sema.h:4892
clang::IdentifierLoc::Loc
SourceLocation Loc
Definition: ParsedAttr.h:212
clang::Sema::CheckCaseExpression
bool CheckCaseExpression(Expr *E)
Definition: SemaExpr.cpp:20717
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:627
clang::Sema::Context
ASTContext & Context
Definition: Sema.h:408
clang::Sema::ConditionKind::Switch
@ Switch
An integral condition for a 'switch' statement.
clang::Sema::ActOnDoStmt
StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body, SourceLocation WhileLoc, SourceLocation CondLParen, Expr *Cond, SourceLocation CondRParen)
Definition: SemaStmt.cpp:1705
clang::Sema::MakeFullDiscardedValueExpr
FullExprArg MakeFullDiscardedValueExpr(Expr *Arg)
Definition: Sema.h:4872
clang::CPlusPlus17
@ CPlusPlus17
Definition: LangStandard.h:56
clang::FixItHint
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:71
clang::Scope::SEHTryScope
@ SEHTryScope
This scope corresponds to an SEH try.
Definition: Scope.h:121
clang::Sema::ActOnFinishFunctionBody
Decl * ActOnFinishFunctionBody(Decl *Decl, Stmt *Body)
Definition: SemaDecl.cpp:14854
clang::ParenBraceBracketBalancer
RAII object that makes sure paren/bracket/brace count is correct after declaration/statement parsing,...
Definition: RAIIObjectsForParser.h:346
clang::Scope::decrementMSManglingNumber
void decrementMSManglingNumber()
Definition: Scope.h:321
clang::DeclaratorContext::CXXCatch
@ CXXCatch
clang::Sema::ActOnGotoStmt
StmtResult ActOnGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc, LabelDecl *TheDecl)
Definition: SemaStmt.cpp:3273
clang::Sema::ActOnStartSEHFinallyBlock
void ActOnStartSEHFinallyBlock()
Definition: SemaStmt.cpp:4595
clang::Sema::PragmaStackSentinelRAII
Definition: Sema.h:707
clang::Sema::ActOnCaseStmtBody
void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt)
ActOnCaseStmtBody - This installs a statement as the body of a case.
Definition: SemaStmt.cpp:535
clang::PreferredTypeBuilder::get
QualType get(SourceLocation Tok) const
Get the expected type associated with this location, if any.
Definition: Sema.h:332
clang::Sema::ActOnCXXForRangeStmt
StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, Stmt *LoopVar, SourceLocation ColonLoc, Expr *Collection, SourceLocation RParenLoc, BuildForRangeKind Kind)
ActOnCXXForRangeStmt - Check and build a C++11 for-range statement.
Definition: SemaStmt.cpp:2473
PrettyDeclStackTrace.h
clang::Parser::StopAtCodeCompletion
@ StopAtCodeCompletion
Stop at code completion.
Definition: Parser.h:1201
clang::Token::getKind
tok::TokenKind getKind() const
Definition: Token.h:92
clang::Preprocessor::getLastFPEvalPragmaLocation
SourceLocation getLastFPEvalPragmaLocation() const
Definition: Preprocessor.h:2176
clang::CPlusPlus
@ CPlusPlus
Definition: LangStandard.h:53
clang::Sema::ActOnExprStmt
StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue=true)
Definition: SemaStmt.cpp:46
clang::IdentifierInfo::setIsPoisoned
void setIsPoisoned(bool Value=true)
setIsPoisoned - Mark this identifier as poisoned.
Definition: IdentifierTable.h:345
clang::StmtEmpty
StmtResult StmtEmpty()
Definition: Ownership.h:290
clang::Parser::StopBeforeMatch
@ StopBeforeMatch
Stop skipping at specified token, but don't skip the token itself.
Definition: Parser.h:1200
clang::Scope::CompoundStmtScope
@ CompoundStmtScope
This is a compound statement scope.
Definition: Scope.h:130
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:1951
clang::Sema::CodeCompleteExpression
void CodeCompleteExpression(Scope *S, const CodeCompleteExpressionData &Data)
Perform code-completion in an expression context when we know what type we're looking for.
Definition: SemaCodeComplete.cpp:4722
clang::IfStatementKind::ConstevalNegated
@ ConstevalNegated
clang::Parser::getLangOpts
const LangOptions & getLangOpts() const
Definition: Parser.h:440
clang::LabelDecl
Represents the declaration of a label.
Definition: Decl.h:494
clang::Sema::ConditionError
static ConditionResult ConditionError()
Definition: Sema.h:12430
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:97
clang::Preprocessor::getTargetInfo
const TargetInfo & getTargetInfo() const
Definition: Preprocessor.h:1069
clang::Parser::ParseExpression
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
Definition: ParseExpr.cpp:123
clang::ParsedAttr
ParsedAttr - Represents a syntactic attribute.
Definition: ParsedAttr.h:233
clang::CPlusPlus20
@ CPlusPlus20
Definition: LangStandard.h:57
clang::Sema::CodeCompleteOrdinaryName
void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)
Definition: SemaCodeComplete.cpp:4295
clang::Sema::ActOnContinueStmt
StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope)
Definition: SemaStmt.cpp:3317
clang::Scope::ContinueScope
@ ContinueScope
This is a while, do, for, which can have continue statements embedded into it.
Definition: Scope.h:55
clang::Sema::ActOnNullStmt
StmtResult ActOnNullStmt(SourceLocation SemiLoc, bool HasLeadingEmptyMacro=false)
Definition: SemaStmt.cpp:68
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:874
clang::Scope::ControlScope
@ ControlScope
The controlling scope in a if/switch/while/for statement.
Definition: Scope.h:62
clang::Sema::ActOnSEHExceptBlock
StmtResult ActOnSEHExceptBlock(SourceLocation Loc, Expr *FilterExpr, Stmt *Block)
Definition: SemaStmt.cpp:4583
clang::Sema::PCC_ForInit
@ PCC_ForInit
Code completion occurs at the beginning of the initialization statement (or expression) in a for loop...
Definition: Sema.h:12837
clang::Sema::ActOnObjCForCollectionStmt
StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc, Stmt *First, Expr *collection, SourceLocation RParenLoc)
Definition: SemaStmt.cpp:2282
clang::Parser::getCurScope
Scope * getCurScope() const
Definition: Parser.h:447
clang::Sema::ConditionKind::ConstexprIf
@ ConstexprIf
A constant boolean condition from 'if constexpr'.
clang::Sema::PCC_Expression
@ PCC_Expression
Code completion occurs within an expression.
Definition: Sema.h:12831
clang::Parser::Diag
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Definition: Parser.cpp:73
clang::Token::isNot
bool isNot(tok::TokenKind K) const
Definition: Token.h:98
clang::Sema::ActOnCoreturnStmt
StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E)
Definition: SemaCoroutine.cpp:964
clang::IfStatementKind::Ordinary
@ Ordinary
clang::Sema::ConditionResult
Definition: Sema.h:12398
clang::Parser::StopAtSemi
@ StopAtSemi
Stop skipping at semicolon.
Definition: Parser.h:1198
clang::Sema::ActOnDeclStmt
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
Definition: SemaStmt.cpp:73
PrettyStackTrace.h
clang::Scope::AddFlags
void AddFlags(unsigned Flags)
Sets up the specified scope flags and adjusts the scope state variables accordingly.
Definition: Scope.cpp:107
clang::Sema::ActOnCaseStmt
StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS, SourceLocation DotDotDotLoc, ExprResult RHS, SourceLocation ColonLoc)
Definition: SemaStmt.cpp:510
clang::ParsedAttributesView::empty
bool empty() const
Definition: ParsedAttr.h:921
clang::Preprocessor::getSourceManager
SourceManager & getSourceManager() const
Definition: Preprocessor.h:1072
clang::ParsedAttributesView::Range
SourceRange Range
Definition: ParsedAttr.h:914
clang::CPlusPlus2b
@ CPlusPlus2b
Definition: LangStandard.h:58
clang::LoopHint
Loop optimization hint for loop and unroll pragmas.
Definition: LoopHint.h:20
clang::Sema::ActOnForEachDeclStmt
void ActOnForEachDeclStmt(DeclGroupPtrTy Decl)
Definition: SemaStmt.cpp:83
clang::Sema::FinalizeDeclaratorGroup
DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, ArrayRef< Decl * > Group)
Definition: SemaDecl.cpp:13932
clang::ParsedAttributes::takeAllFrom
void takeAllFrom(ParsedAttributes &Other)
Definition: ParsedAttr.h:1019
clang::Sema::ExpressionEvaluationContext
ExpressionEvaluationContext
Describes how the expressions currently being parsed are evaluated at run-time, if at all.
Definition: Sema.h:1216
clang::Sema::ActOnStmtExprResult
ExprResult ActOnStmtExprResult(ExprResult E)
Definition: SemaExpr.cpp:15893
clang::Sema::ActOnSEHLeaveStmt
StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope)
Definition: SemaStmt.cpp:4610
clang::tok::TokenKind
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
clang::Parser::ParseCaseExpression
ExprResult ParseCaseExpression(SourceLocation CaseLoc)
Definition: ParseExpr.cpp:221
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::Parser::ConsumeToken
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
Definition: Parser.h:490
clang::Sema::ConditionResult::getKnownValue
llvm::Optional< bool > getKnownValue() const
Definition: Sema.h:12424
clang::Sema::ActOnExprStmtError
StmtResult ActOnExprStmtError()
Definition: SemaStmt.cpp:63
clang::ActionResult::get
PtrTy get() const
Definition: Ownership.h:169
clang::Preprocessor::isCodeCompletionEnabled
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
Definition: Preprocessor.h:1787
clang::Expr::getExprLoc
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:247
clang::Sema::ProcessDeclAttributeList
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
Definition: SemaDeclAttr.cpp:9101
Value
Value
Definition: UninitializedValues.cpp:102
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::PrettyDeclStackTraceEntry
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
Definition: PrettyDeclStackTrace.h:29
Scope.h
clang::Sema::ActOnIfStmt
StmtResult ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)
Definition: SemaStmt.cpp:878
clang::EnterExpressionEvaluationContext
RAII object that enters a new expression evaluation context.
Definition: Sema.h:13518
clang::Sema::ActOnOpenMPLoopInitialization
void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init)
Check if the current region is an OpenMP loop region and if it is, mark loop control variable,...
Definition: SemaOpenMP.cpp:8998
clang::Sema::ActOnExceptionDeclarator
Decl * ActOnExceptionDeclarator(Scope *S, Declarator &D)
ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch handler.
Definition: SemaDeclCXX.cpp:16497
clang::Scope::SEHExceptScope
@ SEHExceptScope
This scope corresponds to an SEH except.
Definition: Scope.h:124
clang::Parser::DeclGroupPtrTy
OpaquePtr< DeclGroupRef > DeclGroupPtrTy
Definition: Parser.h:458
clang::ActionResult::isInvalid
bool isInvalid() const
Definition: Ownership.h:165
clang::Parser::TryConsumeToken
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parser.h:498
clang::ParsedAttributes
ParsedAttributes - A collection of parsed attributes.
Definition: ParsedAttr.h:1012
clang::LoopHint::PragmaNameLoc
IdentifierLoc * PragmaNameLoc
Definition: LoopHint.h:26
clang::Sema::ActOnIndirectGotoStmt
StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc, Expr *DestExp)
Definition: SemaStmt.cpp:3282
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::Token::getLocation
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
Definition: Token.h:125
clang::SourceLocation::isMacroID
bool isMacroID() const
Definition: SourceLocation.h:103
Attributes.h
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:26
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::Token::isAnnotation
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
Definition: Token.h:119
clang::PoisonIdentifierRAIIObject
An RAII object for [un]poisoning an identifier within a scope.
Definition: IdentifierTable.h:488
clang::ActionResult< Expr * >
clang::ExtensionRAIIObject
ExtensionRAIIObject - This saves the state of extension warnings when constructed and disables them.
Definition: RAIIObjectsForParser.h:255
clang::LoopHint::OptionLoc
IdentifierLoc * OptionLoc
Definition: LoopHint.h:30
clang::Sema::PCC_Statement
@ PCC_Statement
Code completion occurs within a statement, which may also be an expression or a declaration.
Definition: Sema.h:12834
clang::IfStatementKind
IfStatementKind
In an if statement, this denotes whether the the statement is a constexpr or consteval if statement.
Definition: Specifiers.h:36
clang::Sema::ActOnStartOfSwitchStmt
StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc)
Definition: SemaStmt.cpp:1090
clang::Sema::ActOnSEHTryBlock
StmtResult ActOnSEHTryBlock(bool IsCXXTry, SourceLocation TryLoc, Stmt *TryBlock, Stmt *Handler)
Definition: SemaStmt.cpp:4545
clang::StmtResult
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:263
clang::Sema::ActOnForStmt
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
Definition: SemaStmt.cpp:2131
clang::Sema::ActOnAfterCompoundStatementLeadingPragmas
void ActOnAfterCompoundStatementLeadingPragmas()
Definition: SemaStmt.cpp:393
clang::SourceLocation::isInvalid
bool isInvalid() const
Definition: SourceLocation.h:111
clang
Definition: CalledOnceCheck.h:17
clang::Sema::CreateRecoveryExpr
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
Definition: SemaExpr.cpp:20779
clang::Scope::CatchScope
@ CatchScope
This is the scope of a C++ catch statement.
Definition: Scope.h:137
clang::Sema::ActOnWhileStmt
StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc, ConditionResult Cond, SourceLocation RParenLoc, Stmt *Body)
Definition: SemaStmt.cpp:1684
clang::NeverCalledReason::Switch
@ Switch
clang::Sema::LookupOrCreateLabel
LabelDecl * LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc, SourceLocation GnuLabelLoc=SourceLocation())
LookupOrCreateLabel - Do a name lookup of a label with the specified name.
Definition: SemaLookup.cpp:4355
clang::DeclaratorContext::Block
@ Block
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:70
clang::Sema::ActOnMSDependentExistsStmt
StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists, CXXScopeSpec &SS, UnqualifiedId &Name, Stmt *Nested)
Definition: SemaStmt.cpp:4633
clang::Declarator
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1805
clang::Scope::SEHFilterScope
@ SEHFilterScope
We are currently in the filter expression of an SEH except block.
Definition: Scope.h:127
clang::Sema::ActOnForEachLValueExpr
StmtResult ActOnForEachLValueExpr(Expr *E)
In an Objective C collection iteration statement: for (x in y) x can be an arbitrary l-value expressi...
Definition: SemaStmt.cpp:2193
clang::Sema::ActOnDefaultStmt
StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc, Stmt *SubStmt, Scope *CurScope)
Definition: SemaStmt.cpp:540
clang::Sema::ActOnReturnStmt
StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, Scope *CurScope)
Definition: SemaStmt.cpp:3888
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:110
clang::CorrectionCandidateCallback
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
Definition: TypoCorrection.h:281
clang::Attr
Attr - This represents one attribute.
Definition: Attr.h:41
clang::FixItHint::CreateRemoval
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:123
clang::Sema::CodeCompleteObjCForCollection
void CodeCompleteObjCForCollection(Scope *S, DeclGroupPtrTy IterationVar)
Definition: SemaCodeComplete.cpp:8238
clang::Sema::ActOnDefaultCtorInitializers
void ActOnDefaultCtorInitializers(Decl *CDtorDecl)
Definition: SemaDeclCXX.cpp:5748
clang::Preprocessor::getLocForEndOfToken
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
Definition: Preprocessor.h:2004
clang::Stmt::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:336
clang::Sema::ActOnCondition
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK, bool MissingOK=false)
Definition: SemaExpr.cpp:19999
clang::AttributeCommonInfo::AS_Pragma
@ AS_Pragma
#pragma ...
Definition: AttributeCommonInfo.h:45
clang::Sema::FinishCXXForRangeStmt
StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body)
FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
Definition: SemaStmt.cpp:3255
clang::Token::isOneOf
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:99
clang::TargetInfo::supportSourceEvalMethod
virtual bool supportSourceEvalMethod() const
Definition: TargetInfo.h:744
clang::CPlusPlus11
@ CPlusPlus11
Definition: LangStandard.h:54
clang::Sema::ActOnAbortSEHFinallyBlock
void ActOnAbortSEHFinallyBlock()
Definition: SemaStmt.cpp:4599
clang::comments::tok::eof
@ eof
Definition: CommentLexer.h:33
clang::LoopHint::StateLoc
IdentifierLoc * StateLoc
Definition: LoopHint.h:33
clang::Scope::TryScope
@ TryScope
This is the scope of a C++ try statement.
Definition: Scope.h:101
clang::ParsedAttributes::clear
void clear()
Definition: ParsedAttr.h:1036
clang::Scope::DeclScope
@ DeclScope
This is a scope that can contain a declaration.
Definition: Scope.h:59
clang::Scope::FnTryCatchScope
@ FnTryCatchScope
This is the scope for a function-level C++ try or catch scope.
Definition: Scope.h:104
clang::Sema::ActOnCompoundStmt
StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, ArrayRef< Stmt * > Elts, bool isStmtExpr)
Definition: SemaStmt.cpp:409
clang::Scope::BreakScope
@ BreakScope
This is a while, do, switch, for, etc that can have break statements embedded into it.
Definition: Scope.h:51
clang::Sema::ActOnCXXCatchBlock
StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl, Stmt *HandlerBlock)
ActOnCXXCatchBlock - Takes an exception declaration and a handler block and creates a proper catch ha...
Definition: SemaStmt.cpp:4332
clang::Sema::ExpressionEvaluationContextRecord::EK_Other
@ EK_Other
Definition: Sema.h:1321
clang::Expr
This represents one expression.
Definition: Expr.h:109
SM
#define SM(sm)
Definition: Cuda.cpp:81
clang::Parser::NextToken
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parser.h:807
clang::ASTContext::BoolTy
CanQualType BoolTy
Definition: ASTContext.h:1098
clang::Sema::ActOnFinishSwitchStmt
StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch, Stmt *Body)
Definition: SemaStmt.cpp:1214
clang::RISCV::Invalid
@ Invalid
Definition: RISCVVIntrinsicUtils.h:148
clang::NamespaceDecl
Represent a C++ namespace.
Definition: Decl.h:540
clang::ActionResult::isUsable
bool isUsable() const
Definition: Ownership.h:166
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:134
clang::takeAndConcatenateAttrs
void takeAndConcatenateAttrs(ParsedAttributes &First, ParsedAttributes &Second, ParsedAttributes &Result)
Consumes the attributes from First and Second and concatenates them into Result.
Definition: ParsedAttr.cpp:302
clang::DeclSpec
Captures information about "declaration specifiers".
Definition: DeclSpec.h:229
clang::Sema::CodeCompleteAfterIf
void CodeCompleteAfterIf(Scope *S, bool IsBracedThen)
Definition: SemaCodeComplete.cpp:6437
clang::Sema::FPFeaturesStateRAII
Records and restores the CurFPFeatures state on entry/exit of compound statements.
Definition: Sema.h:1567
clang::Sema::ExpressionEvaluationContext::ImmediateFunctionContext
@ ImmediateFunctionContext
In addition of being constant evaluated, the current expression occurs in an immediate function conte...
clang::StmtError
StmtResult StmtError()
Definition: Ownership.h:279
LoopHint.h
clang::IfStatementKind::Constexpr
@ Constexpr
clang::Sema::CorrectDelayedTyposInExpr
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
Definition: SemaExprCXX.cpp:8715
clang::PreferredTypeBuilder::enterReturn
void enterReturn(Sema &S, SourceLocation Tok)
Definition: SemaCodeComplete.cpp:387
Parser.h
clang::Token::hasLeadingEmptyMacro
bool hasLeadingEmptyMacro() const
Return true if this token has an empty macro before it.
Definition: Token.h:288