clang  3.9.0
ParseExpr.cpp
Go to the documentation of this file.
1 //===--- ParseExpr.cpp - Expression Parsing -------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// \file
11 /// \brief Provides the Expression parsing implementation.
12 ///
13 /// Expressions in C99 basically consist of a bunch of binary operators with
14 /// unary operators and other random stuff at the leaves.
15 ///
16 /// In the C99 grammar, these unary operators bind tightest and are represented
17 /// as the 'cast-expression' production. Everything else is either a binary
18 /// operator (e.g. '/') or a ternary operator ("?:"). The unary leaves are
19 /// handled by ParseCastExpression, the higher level pieces are handled by
20 /// ParseBinaryExpression.
21 ///
22 //===----------------------------------------------------------------------===//
23 
24 #include "clang/Parse/Parser.h"
25 #include "RAIIObjectsForParser.h"
26 #include "clang/AST/ASTContext.h"
28 #include "clang/Sema/DeclSpec.h"
30 #include "clang/Sema/Scope.h"
32 #include "llvm/ADT/SmallString.h"
33 #include "llvm/ADT/SmallVector.h"
34 using namespace clang;
35 
36 /// \brief Simple precedence-based parser for binary/ternary operators.
37 ///
38 /// Note: we diverge from the C99 grammar when parsing the assignment-expression
39 /// production. C99 specifies that the LHS of an assignment operator should be
40 /// parsed as a unary-expression, but consistency dictates that it be a
41 /// conditional-expession. In practice, the important thing here is that the
42 /// LHS of an assignment has to be an l-value, which productions between
43 /// unary-expression and conditional-expression don't produce. Because we want
44 /// consistency, we parse the LHS as a conditional-expression, then check for
45 /// l-value-ness in semantic analysis stages.
46 ///
47 /// \verbatim
48 /// pm-expression: [C++ 5.5]
49 /// cast-expression
50 /// pm-expression '.*' cast-expression
51 /// pm-expression '->*' cast-expression
52 ///
53 /// multiplicative-expression: [C99 6.5.5]
54 /// Note: in C++, apply pm-expression instead of cast-expression
55 /// cast-expression
56 /// multiplicative-expression '*' cast-expression
57 /// multiplicative-expression '/' cast-expression
58 /// multiplicative-expression '%' cast-expression
59 ///
60 /// additive-expression: [C99 6.5.6]
61 /// multiplicative-expression
62 /// additive-expression '+' multiplicative-expression
63 /// additive-expression '-' multiplicative-expression
64 ///
65 /// shift-expression: [C99 6.5.7]
66 /// additive-expression
67 /// shift-expression '<<' additive-expression
68 /// shift-expression '>>' additive-expression
69 ///
70 /// relational-expression: [C99 6.5.8]
71 /// shift-expression
72 /// relational-expression '<' shift-expression
73 /// relational-expression '>' shift-expression
74 /// relational-expression '<=' shift-expression
75 /// relational-expression '>=' shift-expression
76 ///
77 /// equality-expression: [C99 6.5.9]
78 /// relational-expression
79 /// equality-expression '==' relational-expression
80 /// equality-expression '!=' relational-expression
81 ///
82 /// AND-expression: [C99 6.5.10]
83 /// equality-expression
84 /// AND-expression '&' equality-expression
85 ///
86 /// exclusive-OR-expression: [C99 6.5.11]
87 /// AND-expression
88 /// exclusive-OR-expression '^' AND-expression
89 ///
90 /// inclusive-OR-expression: [C99 6.5.12]
91 /// exclusive-OR-expression
92 /// inclusive-OR-expression '|' exclusive-OR-expression
93 ///
94 /// logical-AND-expression: [C99 6.5.13]
95 /// inclusive-OR-expression
96 /// logical-AND-expression '&&' inclusive-OR-expression
97 ///
98 /// logical-OR-expression: [C99 6.5.14]
99 /// logical-AND-expression
100 /// logical-OR-expression '||' logical-AND-expression
101 ///
102 /// conditional-expression: [C99 6.5.15]
103 /// logical-OR-expression
104 /// logical-OR-expression '?' expression ':' conditional-expression
105 /// [GNU] logical-OR-expression '?' ':' conditional-expression
106 /// [C++] the third operand is an assignment-expression
107 ///
108 /// assignment-expression: [C99 6.5.16]
109 /// conditional-expression
110 /// unary-expression assignment-operator assignment-expression
111 /// [C++] throw-expression [C++ 15]
112 ///
113 /// assignment-operator: one of
114 /// = *= /= %= += -= <<= >>= &= ^= |=
115 ///
116 /// expression: [C99 6.5.17]
117 /// assignment-expression ...[opt]
118 /// expression ',' assignment-expression ...[opt]
119 /// \endverbatim
121  ExprResult LHS(ParseAssignmentExpression(isTypeCast));
122  return ParseRHSOfBinaryExpression(LHS, prec::Comma);
123 }
124 
125 /// This routine is called when the '@' is seen and consumed.
126 /// Current token is an Identifier and is not a 'try'. This
127 /// routine is necessary to disambiguate \@try-statement from,
128 /// for example, \@encode-expression.
129 ///
131 Parser::ParseExpressionWithLeadingAt(SourceLocation AtLoc) {
132  ExprResult LHS(ParseObjCAtExpression(AtLoc));
133  return ParseRHSOfBinaryExpression(LHS, prec::Comma);
134 }
135 
136 /// This routine is called when a leading '__extension__' is seen and
137 /// consumed. This is necessary because the token gets consumed in the
138 /// process of disambiguating between an expression and a declaration.
140 Parser::ParseExpressionWithLeadingExtension(SourceLocation ExtLoc) {
141  ExprResult LHS(true);
142  {
143  // Silence extension warnings in the sub-expression
144  ExtensionRAIIObject O(Diags);
145 
146  LHS = ParseCastExpression(false);
147  }
148 
149  if (!LHS.isInvalid())
150  LHS = Actions.ActOnUnaryOp(getCurScope(), ExtLoc, tok::kw___extension__,
151  LHS.get());
152 
153  return ParseRHSOfBinaryExpression(LHS, prec::Comma);
154 }
155 
156 /// \brief Parse an expr that doesn't include (top-level) commas.
158  if (Tok.is(tok::code_completion)) {
160  cutOffParsing();
161  return ExprError();
162  }
163 
164  if (Tok.is(tok::kw_throw))
165  return ParseThrowExpression();
166  if (Tok.is(tok::kw_co_yield))
167  return ParseCoyieldExpression();
168 
169  ExprResult LHS = ParseCastExpression(/*isUnaryExpression=*/false,
170  /*isAddressOfOperand=*/false,
171  isTypeCast);
172  return ParseRHSOfBinaryExpression(LHS, prec::Assignment);
173 }
174 
175 /// \brief Parse an assignment expression where part of an Objective-C message
176 /// send has already been parsed.
177 ///
178 /// In this case \p LBracLoc indicates the location of the '[' of the message
179 /// send, and either \p ReceiverName or \p ReceiverExpr is non-null indicating
180 /// the receiver of the message.
181 ///
182 /// Since this handles full assignment-expression's, it handles postfix
183 /// expressions and other binary operators for these expressions as well.
185 Parser::ParseAssignmentExprWithObjCMessageExprStart(SourceLocation LBracLoc,
186  SourceLocation SuperLoc,
187  ParsedType ReceiverType,
188  Expr *ReceiverExpr) {
189  ExprResult R
190  = ParseObjCMessageExpressionBody(LBracLoc, SuperLoc,
191  ReceiverType, ReceiverExpr);
192  R = ParsePostfixExpressionSuffix(R);
193  return ParseRHSOfBinaryExpression(R, prec::Assignment);
194 }
195 
196 
198  // C++03 [basic.def.odr]p2:
199  // An expression is potentially evaluated unless it appears where an
200  // integral constant expression is required (see 5.19) [...].
201  // C++98 and C++11 have no such rule, but this is only a defect in C++98.
202  EnterExpressionEvaluationContext Unevaluated(Actions,
204 
205  ExprResult LHS(ParseCastExpression(false, false, isTypeCast));
206  ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::Conditional));
207  return Actions.ActOnConstantExpression(Res);
208 }
209 
210 /// \brief Parse a constraint-expression.
211 ///
212 /// \verbatim
213 /// constraint-expression: [Concepts TS temp.constr.decl p1]
214 /// logical-or-expression
215 /// \endverbatim
217  // FIXME: this may erroneously consume a function-body as the braced
218  // initializer list of a compound literal
219  //
220  // FIXME: this may erroneously consume a parenthesized rvalue reference
221  // declarator as a parenthesized address-of-label expression
222  ExprResult LHS(ParseCastExpression(/*isUnaryExpression=*/false));
223  ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::LogicalOr));
224 
225  return Res;
226 }
227 
228 bool Parser::isNotExpressionStart() {
229  tok::TokenKind K = Tok.getKind();
230  if (K == tok::l_brace || K == tok::r_brace ||
231  K == tok::kw_for || K == tok::kw_while ||
232  K == tok::kw_if || K == tok::kw_else ||
233  K == tok::kw_goto || K == tok::kw_try)
234  return true;
235  // If this is a decl-specifier, we can't be at the start of an expression.
236  return isKnownToBeDeclarationSpecifier();
237 }
238 
240  return Level > prec::Unknown && Level != prec::Conditional;
241 }
243  return isFoldOperator(getBinOpPrecedence(Kind, false, true));
244 }
245 
246 /// \brief Parse a binary expression that starts with \p LHS and has a
247 /// precedence of at least \p MinPrec.
249 Parser::ParseRHSOfBinaryExpression(ExprResult LHS, prec::Level MinPrec) {
250  prec::Level NextTokPrec = getBinOpPrecedence(Tok.getKind(),
251  GreaterThanIsOperator,
252  getLangOpts().CPlusPlus11);
254 
255  while (1) {
256  // If this token has a lower precedence than we are allowed to parse (e.g.
257  // because we are called recursively, or because the token is not a binop),
258  // then we are done!
259  if (NextTokPrec < MinPrec)
260  return LHS;
261 
262  // Consume the operator, saving the operator token for error reporting.
263  Token OpToken = Tok;
264  ConsumeToken();
265 
266  if (OpToken.is(tok::caretcaret)) {
267  return ExprError(Diag(Tok, diag::err_opencl_logical_exclusive_or));
268  }
269  // Bail out when encountering a comma followed by a token which can't
270  // possibly be the start of an expression. For instance:
271  // int f() { return 1, }
272  // We can't do this before consuming the comma, because
273  // isNotExpressionStart() looks at the token stream.
274  if (OpToken.is(tok::comma) && isNotExpressionStart()) {
275  PP.EnterToken(Tok);
276  Tok = OpToken;
277  return LHS;
278  }
279 
280  // If the next token is an ellipsis, then this is a fold-expression. Leave
281  // it alone so we can handle it in the paren expression.
282  if (isFoldOperator(NextTokPrec) && Tok.is(tok::ellipsis)) {
283  // FIXME: We can't check this via lookahead before we consume the token
284  // because that tickles a lexer bug.
285  PP.EnterToken(Tok);
286  Tok = OpToken;
287  return LHS;
288  }
289 
290  // Special case handling for the ternary operator.
291  ExprResult TernaryMiddle(true);
292  if (NextTokPrec == prec::Conditional) {
293  if (Tok.isNot(tok::colon)) {
294  // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
296 
297  // Handle this production specially:
298  // logical-OR-expression '?' expression ':' conditional-expression
299  // In particular, the RHS of the '?' is 'expression', not
300  // 'logical-OR-expression' as we might expect.
301  TernaryMiddle = ParseExpression();
302  if (TernaryMiddle.isInvalid()) {
303  Actions.CorrectDelayedTyposInExpr(LHS);
304  LHS = ExprError();
305  TernaryMiddle = nullptr;
306  }
307  } else {
308  // Special case handling of "X ? Y : Z" where Y is empty:
309  // logical-OR-expression '?' ':' conditional-expression [GNU]
310  TernaryMiddle = nullptr;
311  Diag(Tok, diag::ext_gnu_conditional_expr);
312  }
313 
314  if (!TryConsumeToken(tok::colon, ColonLoc)) {
315  // Otherwise, we're missing a ':'. Assume that this was a typo that
316  // the user forgot. If we're not in a macro expansion, we can suggest
317  // a fixit hint. If there were two spaces before the current token,
318  // suggest inserting the colon in between them, otherwise insert ": ".
319  SourceLocation FILoc = Tok.getLocation();
320  const char *FIText = ": ";
321  const SourceManager &SM = PP.getSourceManager();
322  if (FILoc.isFileID() || PP.isAtStartOfMacroExpansion(FILoc, &FILoc)) {
323  assert(FILoc.isFileID());
324  bool IsInvalid = false;
325  const char *SourcePtr =
326  SM.getCharacterData(FILoc.getLocWithOffset(-1), &IsInvalid);
327  if (!IsInvalid && *SourcePtr == ' ') {
328  SourcePtr =
329  SM.getCharacterData(FILoc.getLocWithOffset(-2), &IsInvalid);
330  if (!IsInvalid && *SourcePtr == ' ') {
331  FILoc = FILoc.getLocWithOffset(-1);
332  FIText = ":";
333  }
334  }
335  }
336 
337  Diag(Tok, diag::err_expected)
338  << tok::colon << FixItHint::CreateInsertion(FILoc, FIText);
339  Diag(OpToken, diag::note_matching) << tok::question;
340  ColonLoc = Tok.getLocation();
341  }
342  }
343 
344  // Code completion for the right-hand side of an assignment expression
345  // goes through a special hook that takes the left-hand side into account.
346  if (Tok.is(tok::code_completion) && NextTokPrec == prec::Assignment) {
347  Actions.CodeCompleteAssignmentRHS(getCurScope(), LHS.get());
348  cutOffParsing();
349  return ExprError();
350  }
351 
352  // Parse another leaf here for the RHS of the operator.
353  // ParseCastExpression works here because all RHS expressions in C have it
354  // as a prefix, at least. However, in C++, an assignment-expression could
355  // be a throw-expression, which is not a valid cast-expression.
356  // Therefore we need some special-casing here.
357  // Also note that the third operand of the conditional operator is
358  // an assignment-expression in C++, and in C++11, we can have a
359  // braced-init-list on the RHS of an assignment. For better diagnostics,
360  // parse as if we were allowed braced-init-lists everywhere, and check that
361  // they only appear on the RHS of assignments later.
362  ExprResult RHS;
363  bool RHSIsInitList = false;
364  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
365  RHS = ParseBraceInitializer();
366  RHSIsInitList = true;
367  } else if (getLangOpts().CPlusPlus && NextTokPrec <= prec::Conditional)
369  else
370  RHS = ParseCastExpression(false);
371 
372  if (RHS.isInvalid()) {
373  // FIXME: Errors generated by the delayed typo correction should be
374  // printed before errors from parsing the RHS, not after.
375  Actions.CorrectDelayedTyposInExpr(LHS);
376  if (TernaryMiddle.isUsable())
377  TernaryMiddle = Actions.CorrectDelayedTyposInExpr(TernaryMiddle);
378  LHS = ExprError();
379  }
380 
381  // Remember the precedence of this operator and get the precedence of the
382  // operator immediately to the right of the RHS.
383  prec::Level ThisPrec = NextTokPrec;
384  NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator,
385  getLangOpts().CPlusPlus11);
386 
387  // Assignment and conditional expressions are right-associative.
388  bool isRightAssoc = ThisPrec == prec::Conditional ||
389  ThisPrec == prec::Assignment;
390 
391  // Get the precedence of the operator to the right of the RHS. If it binds
392  // more tightly with RHS than we do, evaluate it completely first.
393  if (ThisPrec < NextTokPrec ||
394  (ThisPrec == NextTokPrec && isRightAssoc)) {
395  if (!RHS.isInvalid() && RHSIsInitList) {
396  Diag(Tok, diag::err_init_list_bin_op)
397  << /*LHS*/0 << PP.getSpelling(Tok) << Actions.getExprRange(RHS.get());
398  RHS = ExprError();
399  }
400  // If this is left-associative, only parse things on the RHS that bind
401  // more tightly than the current operator. If it is left-associative, it
402  // is okay, to bind exactly as tightly. For example, compile A=B=C=D as
403  // A=(B=(C=D)), where each paren is a level of recursion here.
404  // The function takes ownership of the RHS.
405  RHS = ParseRHSOfBinaryExpression(RHS,
406  static_cast<prec::Level>(ThisPrec + !isRightAssoc));
407  RHSIsInitList = false;
408 
409  if (RHS.isInvalid()) {
410  // FIXME: Errors generated by the delayed typo correction should be
411  // printed before errors from ParseRHSOfBinaryExpression, not after.
412  Actions.CorrectDelayedTyposInExpr(LHS);
413  if (TernaryMiddle.isUsable())
414  TernaryMiddle = Actions.CorrectDelayedTyposInExpr(TernaryMiddle);
415  LHS = ExprError();
416  }
417 
418  NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator,
419  getLangOpts().CPlusPlus11);
420  }
421 
422  if (!RHS.isInvalid() && RHSIsInitList) {
423  if (ThisPrec == prec::Assignment) {
424  Diag(OpToken, diag::warn_cxx98_compat_generalized_initializer_lists)
425  << Actions.getExprRange(RHS.get());
426  } else {
427  Diag(OpToken, diag::err_init_list_bin_op)
428  << /*RHS*/1 << PP.getSpelling(OpToken)
429  << Actions.getExprRange(RHS.get());
430  LHS = ExprError();
431  }
432  }
433 
434  ExprResult OrigLHS = LHS;
435  if (!LHS.isInvalid()) {
436  // Combine the LHS and RHS into the LHS (e.g. build AST).
437  if (TernaryMiddle.isInvalid()) {
438  // If we're using '>>' as an operator within a template
439  // argument list (in C++98), suggest the addition of
440  // parentheses so that the code remains well-formed in C++0x.
441  if (!GreaterThanIsOperator && OpToken.is(tok::greatergreater))
442  SuggestParentheses(OpToken.getLocation(),
443  diag::warn_cxx11_right_shift_in_template_arg,
444  SourceRange(Actions.getExprRange(LHS.get()).getBegin(),
445  Actions.getExprRange(RHS.get()).getEnd()));
446 
447  LHS = Actions.ActOnBinOp(getCurScope(), OpToken.getLocation(),
448  OpToken.getKind(), LHS.get(), RHS.get());
449 
450  } else {
451  LHS = Actions.ActOnConditionalOp(OpToken.getLocation(), ColonLoc,
452  LHS.get(), TernaryMiddle.get(),
453  RHS.get());
454  }
455  // In this case, ActOnBinOp or ActOnConditionalOp performed the
456  // CorrectDelayedTyposInExpr check.
457  if (!getLangOpts().CPlusPlus)
458  continue;
459  }
460  // Ensure potential typos aren't left undiagnosed.
461  if (LHS.isInvalid()) {
462  Actions.CorrectDelayedTyposInExpr(OrigLHS);
463  Actions.CorrectDelayedTyposInExpr(TernaryMiddle);
464  Actions.CorrectDelayedTyposInExpr(RHS);
465  }
466  }
467 }
468 
469 /// \brief Parse a cast-expression, or, if \p isUnaryExpression is true,
470 /// parse a unary-expression.
471 ///
472 /// \p isAddressOfOperand exists because an id-expression that is the
473 /// operand of address-of gets special treatment due to member pointers.
474 ///
475 ExprResult Parser::ParseCastExpression(bool isUnaryExpression,
476  bool isAddressOfOperand,
477  TypeCastState isTypeCast) {
478  bool NotCastExpr;
479  ExprResult Res = ParseCastExpression(isUnaryExpression,
480  isAddressOfOperand,
481  NotCastExpr,
482  isTypeCast);
483  if (NotCastExpr)
484  Diag(Tok, diag::err_expected_expression);
485  return Res;
486 }
487 
488 namespace {
489 class CastExpressionIdValidator : public CorrectionCandidateCallback {
490  public:
491  CastExpressionIdValidator(Token Next, bool AllowTypes, bool AllowNonTypes)
492  : NextToken(Next), AllowNonTypes(AllowNonTypes) {
493  WantTypeSpecifiers = WantFunctionLikeCasts = AllowTypes;
494  }
495 
496  bool ValidateCandidate(const TypoCorrection &candidate) override {
497  NamedDecl *ND = candidate.getCorrectionDecl();
498  if (!ND)
499  return candidate.isKeyword();
500 
501  if (isa<TypeDecl>(ND))
502  return WantTypeSpecifiers;
503 
504  if (!AllowNonTypes || !CorrectionCandidateCallback::ValidateCandidate(candidate))
505  return false;
506 
507  if (!NextToken.isOneOf(tok::equal, tok::arrow, tok::period))
508  return true;
509 
510  for (auto *C : candidate) {
511  NamedDecl *ND = C->getUnderlyingDecl();
512  if (isa<ValueDecl>(ND) && !isa<FunctionDecl>(ND))
513  return true;
514  }
515  return false;
516  }
517 
518  private:
519  Token NextToken;
520  bool AllowNonTypes;
521 };
522 }
523 
524 /// \brief Parse a cast-expression, or, if \pisUnaryExpression is true, parse
525 /// a unary-expression.
526 ///
527 /// \p isAddressOfOperand exists because an id-expression that is the operand
528 /// of address-of gets special treatment due to member pointers. NotCastExpr
529 /// is set to true if the token is not the start of a cast-expression, and no
530 /// diagnostic is emitted in this case and no tokens are consumed.
531 ///
532 /// \verbatim
533 /// cast-expression: [C99 6.5.4]
534 /// unary-expression
535 /// '(' type-name ')' cast-expression
536 ///
537 /// unary-expression: [C99 6.5.3]
538 /// postfix-expression
539 /// '++' unary-expression
540 /// '--' unary-expression
541 /// [Coro] 'co_await' cast-expression
542 /// unary-operator cast-expression
543 /// 'sizeof' unary-expression
544 /// 'sizeof' '(' type-name ')'
545 /// [C++11] 'sizeof' '...' '(' identifier ')'
546 /// [GNU] '__alignof' unary-expression
547 /// [GNU] '__alignof' '(' type-name ')'
548 /// [C11] '_Alignof' '(' type-name ')'
549 /// [C++11] 'alignof' '(' type-id ')'
550 /// [GNU] '&&' identifier
551 /// [C++11] 'noexcept' '(' expression ')' [C++11 5.3.7]
552 /// [C++] new-expression
553 /// [C++] delete-expression
554 ///
555 /// unary-operator: one of
556 /// '&' '*' '+' '-' '~' '!'
557 /// [GNU] '__extension__' '__real' '__imag'
558 ///
559 /// primary-expression: [C99 6.5.1]
560 /// [C99] identifier
561 /// [C++] id-expression
562 /// constant
563 /// string-literal
564 /// [C++] boolean-literal [C++ 2.13.5]
565 /// [C++11] 'nullptr' [C++11 2.14.7]
566 /// [C++11] user-defined-literal
567 /// '(' expression ')'
568 /// [C11] generic-selection
569 /// '__func__' [C99 6.4.2.2]
570 /// [GNU] '__FUNCTION__'
571 /// [MS] '__FUNCDNAME__'
572 /// [MS] 'L__FUNCTION__'
573 /// [GNU] '__PRETTY_FUNCTION__'
574 /// [GNU] '(' compound-statement ')'
575 /// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
576 /// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
577 /// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
578 /// assign-expr ')'
579 /// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
580 /// [GNU] '__null'
581 /// [OBJC] '[' objc-message-expr ']'
582 /// [OBJC] '\@selector' '(' objc-selector-arg ')'
583 /// [OBJC] '\@protocol' '(' identifier ')'
584 /// [OBJC] '\@encode' '(' type-name ')'
585 /// [OBJC] objc-string-literal
586 /// [C++] simple-type-specifier '(' expression-list[opt] ')' [C++ 5.2.3]
587 /// [C++11] simple-type-specifier braced-init-list [C++11 5.2.3]
588 /// [C++] typename-specifier '(' expression-list[opt] ')' [C++ 5.2.3]
589 /// [C++11] typename-specifier braced-init-list [C++11 5.2.3]
590 /// [C++] 'const_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
591 /// [C++] 'dynamic_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
592 /// [C++] 'reinterpret_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
593 /// [C++] 'static_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
594 /// [C++] 'typeid' '(' expression ')' [C++ 5.2p1]
595 /// [C++] 'typeid' '(' type-id ')' [C++ 5.2p1]
596 /// [C++] 'this' [C++ 9.3.2]
597 /// [G++] unary-type-trait '(' type-id ')'
598 /// [G++] binary-type-trait '(' type-id ',' type-id ')' [TODO]
599 /// [EMBT] array-type-trait '(' type-id ',' integer ')'
600 /// [clang] '^' block-literal
601 ///
602 /// constant: [C99 6.4.4]
603 /// integer-constant
604 /// floating-constant
605 /// enumeration-constant -> identifier
606 /// character-constant
607 ///
608 /// id-expression: [C++ 5.1]
609 /// unqualified-id
610 /// qualified-id
611 ///
612 /// unqualified-id: [C++ 5.1]
613 /// identifier
614 /// operator-function-id
615 /// conversion-function-id
616 /// '~' class-name
617 /// template-id
618 ///
619 /// new-expression: [C++ 5.3.4]
620 /// '::'[opt] 'new' new-placement[opt] new-type-id
621 /// new-initializer[opt]
622 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
623 /// new-initializer[opt]
624 ///
625 /// delete-expression: [C++ 5.3.5]
626 /// '::'[opt] 'delete' cast-expression
627 /// '::'[opt] 'delete' '[' ']' cast-expression
628 ///
629 /// [GNU/Embarcadero] unary-type-trait:
630 /// '__is_arithmetic'
631 /// '__is_floating_point'
632 /// '__is_integral'
633 /// '__is_lvalue_expr'
634 /// '__is_rvalue_expr'
635 /// '__is_complete_type'
636 /// '__is_void'
637 /// '__is_array'
638 /// '__is_function'
639 /// '__is_reference'
640 /// '__is_lvalue_reference'
641 /// '__is_rvalue_reference'
642 /// '__is_fundamental'
643 /// '__is_object'
644 /// '__is_scalar'
645 /// '__is_compound'
646 /// '__is_pointer'
647 /// '__is_member_object_pointer'
648 /// '__is_member_function_pointer'
649 /// '__is_member_pointer'
650 /// '__is_const'
651 /// '__is_volatile'
652 /// '__is_trivial'
653 /// '__is_standard_layout'
654 /// '__is_signed'
655 /// '__is_unsigned'
656 ///
657 /// [GNU] unary-type-trait:
658 /// '__has_nothrow_assign'
659 /// '__has_nothrow_copy'
660 /// '__has_nothrow_constructor'
661 /// '__has_trivial_assign' [TODO]
662 /// '__has_trivial_copy' [TODO]
663 /// '__has_trivial_constructor'
664 /// '__has_trivial_destructor'
665 /// '__has_virtual_destructor'
666 /// '__is_abstract' [TODO]
667 /// '__is_class'
668 /// '__is_empty' [TODO]
669 /// '__is_enum'
670 /// '__is_final'
671 /// '__is_pod'
672 /// '__is_polymorphic'
673 /// '__is_sealed' [MS]
674 /// '__is_trivial'
675 /// '__is_union'
676 ///
677 /// [Clang] unary-type-trait:
678 /// '__trivially_copyable'
679 ///
680 /// binary-type-trait:
681 /// [GNU] '__is_base_of'
682 /// [MS] '__is_convertible_to'
683 /// '__is_convertible'
684 /// '__is_same'
685 ///
686 /// [Embarcadero] array-type-trait:
687 /// '__array_rank'
688 /// '__array_extent'
689 ///
690 /// [Embarcadero] expression-trait:
691 /// '__is_lvalue_expr'
692 /// '__is_rvalue_expr'
693 /// \endverbatim
694 ///
695 ExprResult Parser::ParseCastExpression(bool isUnaryExpression,
696  bool isAddressOfOperand,
697  bool &NotCastExpr,
698  TypeCastState isTypeCast) {
699  ExprResult Res;
700  tok::TokenKind SavedKind = Tok.getKind();
701  NotCastExpr = false;
702 
703  // This handles all of cast-expression, unary-expression, postfix-expression,
704  // and primary-expression. We handle them together like this for efficiency
705  // and to simplify handling of an expression starting with a '(' token: which
706  // may be one of a parenthesized expression, cast-expression, compound literal
707  // expression, or statement expression.
708  //
709  // If the parsed tokens consist of a primary-expression, the cases below
710  // break out of the switch; at the end we call ParsePostfixExpressionSuffix
711  // to handle the postfix expression suffixes. Cases that cannot be followed
712  // by postfix exprs should return without invoking
713  // ParsePostfixExpressionSuffix.
714  switch (SavedKind) {
715  case tok::l_paren: {
716  // If this expression is limited to being a unary-expression, the parent can
717  // not start a cast expression.
718  ParenParseOption ParenExprType =
719  (isUnaryExpression && !getLangOpts().CPlusPlus) ? CompoundLiteral
720  : CastExpr;
721  ParsedType CastTy;
722  SourceLocation RParenLoc;
723  Res = ParseParenExpression(ParenExprType, false/*stopIfCastExr*/,
724  isTypeCast == IsTypeCast, CastTy, RParenLoc);
725 
726  switch (ParenExprType) {
727  case SimpleExpr: break; // Nothing else to do.
728  case CompoundStmt: break; // Nothing else to do.
729  case CompoundLiteral:
730  // We parsed '(' type-name ')' '{' ... '}'. If any suffixes of
731  // postfix-expression exist, parse them now.
732  break;
733  case CastExpr:
734  // We have parsed the cast-expression and no postfix-expr pieces are
735  // following.
736  return Res;
737  }
738 
739  break;
740  }
741 
742  // primary-expression
743  case tok::numeric_constant:
744  // constant: integer-constant
745  // constant: floating-constant
746 
747  Res = Actions.ActOnNumericConstant(Tok, /*UDLScope*/getCurScope());
748  ConsumeToken();
749  break;
750 
751  case tok::kw_true:
752  case tok::kw_false:
753  return ParseCXXBoolLiteral();
754 
755  case tok::kw___objc_yes:
756  case tok::kw___objc_no:
757  return ParseObjCBoolLiteral();
758 
759  case tok::kw_nullptr:
760  Diag(Tok, diag::warn_cxx98_compat_nullptr);
761  return Actions.ActOnCXXNullPtrLiteral(ConsumeToken());
762 
763  case tok::annot_primary_expr:
764  assert(Res.get() == nullptr && "Stray primary-expression annotation?");
765  Res = getExprAnnotation(Tok);
766  ConsumeToken();
767  break;
768 
769  case tok::kw___super:
770  case tok::kw_decltype:
771  // Annotate the token and tail recurse.
773  return ExprError();
774  assert(Tok.isNot(tok::kw_decltype) && Tok.isNot(tok::kw___super));
775  return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
776 
777  case tok::identifier: { // primary-expression: identifier
778  // unqualified-id: identifier
779  // constant: enumeration-constant
780  // Turn a potentially qualified name into a annot_typename or
781  // annot_cxxscope if it would be valid. This handles things like x::y, etc.
782  if (getLangOpts().CPlusPlus) {
783  // Avoid the unnecessary parse-time lookup in the common case
784  // where the syntax forbids a type.
785  const Token &Next = NextToken();
786 
787  // If this identifier was reverted from a token ID, and the next token
788  // is a parenthesis, this is likely to be a use of a type trait. Check
789  // those tokens.
790  if (Next.is(tok::l_paren) &&
791  Tok.is(tok::identifier) &&
793  IdentifierInfo *II = Tok.getIdentifierInfo();
794  // Build up the mapping of revertible type traits, for future use.
795  if (RevertibleTypeTraits.empty()) {
796 #define RTT_JOIN(X,Y) X##Y
797 #define REVERTIBLE_TYPE_TRAIT(Name) \
798  RevertibleTypeTraits[PP.getIdentifierInfo(#Name)] \
799  = RTT_JOIN(tok::kw_,Name)
800 
801  REVERTIBLE_TYPE_TRAIT(__is_abstract);
802  REVERTIBLE_TYPE_TRAIT(__is_arithmetic);
803  REVERTIBLE_TYPE_TRAIT(__is_array);
804  REVERTIBLE_TYPE_TRAIT(__is_assignable);
805  REVERTIBLE_TYPE_TRAIT(__is_base_of);
806  REVERTIBLE_TYPE_TRAIT(__is_class);
807  REVERTIBLE_TYPE_TRAIT(__is_complete_type);
808  REVERTIBLE_TYPE_TRAIT(__is_compound);
809  REVERTIBLE_TYPE_TRAIT(__is_const);
810  REVERTIBLE_TYPE_TRAIT(__is_constructible);
811  REVERTIBLE_TYPE_TRAIT(__is_convertible);
812  REVERTIBLE_TYPE_TRAIT(__is_convertible_to);
813  REVERTIBLE_TYPE_TRAIT(__is_destructible);
814  REVERTIBLE_TYPE_TRAIT(__is_empty);
815  REVERTIBLE_TYPE_TRAIT(__is_enum);
816  REVERTIBLE_TYPE_TRAIT(__is_floating_point);
817  REVERTIBLE_TYPE_TRAIT(__is_final);
818  REVERTIBLE_TYPE_TRAIT(__is_function);
819  REVERTIBLE_TYPE_TRAIT(__is_fundamental);
820  REVERTIBLE_TYPE_TRAIT(__is_integral);
821  REVERTIBLE_TYPE_TRAIT(__is_interface_class);
822  REVERTIBLE_TYPE_TRAIT(__is_literal);
823  REVERTIBLE_TYPE_TRAIT(__is_lvalue_expr);
824  REVERTIBLE_TYPE_TRAIT(__is_lvalue_reference);
825  REVERTIBLE_TYPE_TRAIT(__is_member_function_pointer);
826  REVERTIBLE_TYPE_TRAIT(__is_member_object_pointer);
827  REVERTIBLE_TYPE_TRAIT(__is_member_pointer);
828  REVERTIBLE_TYPE_TRAIT(__is_nothrow_assignable);
829  REVERTIBLE_TYPE_TRAIT(__is_nothrow_constructible);
830  REVERTIBLE_TYPE_TRAIT(__is_nothrow_destructible);
831  REVERTIBLE_TYPE_TRAIT(__is_object);
832  REVERTIBLE_TYPE_TRAIT(__is_pod);
833  REVERTIBLE_TYPE_TRAIT(__is_pointer);
834  REVERTIBLE_TYPE_TRAIT(__is_polymorphic);
835  REVERTIBLE_TYPE_TRAIT(__is_reference);
836  REVERTIBLE_TYPE_TRAIT(__is_rvalue_expr);
837  REVERTIBLE_TYPE_TRAIT(__is_rvalue_reference);
838  REVERTIBLE_TYPE_TRAIT(__is_same);
839  REVERTIBLE_TYPE_TRAIT(__is_scalar);
840  REVERTIBLE_TYPE_TRAIT(__is_sealed);
841  REVERTIBLE_TYPE_TRAIT(__is_signed);
842  REVERTIBLE_TYPE_TRAIT(__is_standard_layout);
843  REVERTIBLE_TYPE_TRAIT(__is_trivial);
844  REVERTIBLE_TYPE_TRAIT(__is_trivially_assignable);
845  REVERTIBLE_TYPE_TRAIT(__is_trivially_constructible);
846  REVERTIBLE_TYPE_TRAIT(__is_trivially_copyable);
847  REVERTIBLE_TYPE_TRAIT(__is_union);
848  REVERTIBLE_TYPE_TRAIT(__is_unsigned);
849  REVERTIBLE_TYPE_TRAIT(__is_void);
850  REVERTIBLE_TYPE_TRAIT(__is_volatile);
851 #undef REVERTIBLE_TYPE_TRAIT
852 #undef RTT_JOIN
853  }
854 
855  // If we find that this is in fact the name of a type trait,
856  // update the token kind in place and parse again to treat it as
857  // the appropriate kind of type trait.
859  = RevertibleTypeTraits.find(II);
860  if (Known != RevertibleTypeTraits.end()) {
861  Tok.setKind(Known->second);
862  return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
863  NotCastExpr, isTypeCast);
864  }
865  }
866 
867  if ((!ColonIsSacred && Next.is(tok::colon)) ||
868  Next.isOneOf(tok::coloncolon, tok::less, tok::l_paren,
869  tok::l_brace)) {
870  // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse.
872  return ExprError();
873  if (!Tok.is(tok::identifier))
874  return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
875  }
876  }
877 
878  // Consume the identifier so that we can see if it is followed by a '(' or
879  // '.'.
880  IdentifierInfo &II = *Tok.getIdentifierInfo();
881  SourceLocation ILoc = ConsumeToken();
882 
883  // Support 'Class.property' and 'super.property' notation.
884  if (getLangOpts().ObjC1 && Tok.is(tok::period) &&
885  (Actions.getTypeName(II, ILoc, getCurScope()) ||
886  // Allow the base to be 'super' if in an objc-method.
887  (&II == Ident_super && getCurScope()->isInObjcMethodScope()))) {
888  ConsumeToken();
889 
890  // Allow either an identifier or the keyword 'class' (in C++).
891  if (Tok.isNot(tok::identifier) &&
892  !(getLangOpts().CPlusPlus && Tok.is(tok::kw_class))) {
893  Diag(Tok, diag::err_expected_property_name);
894  return ExprError();
895  }
896  IdentifierInfo &PropertyName = *Tok.getIdentifierInfo();
897  SourceLocation PropertyLoc = ConsumeToken();
898 
899  Res = Actions.ActOnClassPropertyRefExpr(II, PropertyName,
900  ILoc, PropertyLoc);
901  break;
902  }
903 
904  // In an Objective-C method, if we have "super" followed by an identifier,
905  // the token sequence is ill-formed. However, if there's a ':' or ']' after
906  // that identifier, this is probably a message send with a missing open
907  // bracket. Treat it as such.
908  if (getLangOpts().ObjC1 && &II == Ident_super && !InMessageExpression &&
909  getCurScope()->isInObjcMethodScope() &&
910  ((Tok.is(tok::identifier) &&
911  (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) ||
912  Tok.is(tok::code_completion))) {
913  Res = ParseObjCMessageExpressionBody(SourceLocation(), ILoc, nullptr,
914  nullptr);
915  break;
916  }
917 
918  // If we have an Objective-C class name followed by an identifier
919  // and either ':' or ']', this is an Objective-C class message
920  // send that's missing the opening '['. Recovery
921  // appropriately. Also take this path if we're performing code
922  // completion after an Objective-C class name.
923  if (getLangOpts().ObjC1 &&
924  ((Tok.is(tok::identifier) && !InMessageExpression) ||
925  Tok.is(tok::code_completion))) {
926  const Token& Next = NextToken();
927  if (Tok.is(tok::code_completion) ||
928  Next.is(tok::colon) || Next.is(tok::r_square))
929  if (ParsedType Typ = Actions.getTypeName(II, ILoc, getCurScope()))
930  if (Typ.get()->isObjCObjectOrInterfaceType()) {
931  // Fake up a Declarator to use with ActOnTypeName.
932  DeclSpec DS(AttrFactory);
933  DS.SetRangeStart(ILoc);
934  DS.SetRangeEnd(ILoc);
935  const char *PrevSpec = nullptr;
936  unsigned DiagID;
937  DS.SetTypeSpecType(TST_typename, ILoc, PrevSpec, DiagID, Typ,
938  Actions.getASTContext().getPrintingPolicy());
939 
940  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
941  TypeResult Ty = Actions.ActOnTypeName(getCurScope(),
942  DeclaratorInfo);
943  if (Ty.isInvalid())
944  break;
945 
946  Res = ParseObjCMessageExpressionBody(SourceLocation(),
947  SourceLocation(),
948  Ty.get(), nullptr);
949  break;
950  }
951  }
952 
953  // Make sure to pass down the right value for isAddressOfOperand.
954  if (isAddressOfOperand && isPostfixExpressionSuffixStart())
955  isAddressOfOperand = false;
956 
957  // Function designators are allowed to be undeclared (C99 6.5.1p2), so we
958  // need to know whether or not this identifier is a function designator or
959  // not.
961  CXXScopeSpec ScopeSpec;
962  SourceLocation TemplateKWLoc;
964  auto Validator = llvm::make_unique<CastExpressionIdValidator>(
965  Tok, isTypeCast != NotTypeCast, isTypeCast != IsTypeCast);
966  Validator->IsAddressOfOperand = isAddressOfOperand;
967  if (Tok.isOneOf(tok::periodstar, tok::arrowstar)) {
968  Validator->WantExpressionKeywords = false;
969  Validator->WantRemainingKeywords = false;
970  } else {
971  Validator->WantRemainingKeywords = Tok.isNot(tok::r_paren);
972  }
973  Name.setIdentifier(&II, ILoc);
974  Res = Actions.ActOnIdExpression(
975  getCurScope(), ScopeSpec, TemplateKWLoc, Name, Tok.is(tok::l_paren),
976  isAddressOfOperand, std::move(Validator),
977  /*IsInlineAsmIdentifier=*/false,
978  Tok.is(tok::r_paren) ? nullptr : &Replacement);
979  if (!Res.isInvalid() && !Res.get()) {
980  UnconsumeToken(Replacement);
981  return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
982  NotCastExpr, isTypeCast);
983  }
984  break;
985  }
986  case tok::char_constant: // constant: character-constant
987  case tok::wide_char_constant:
988  case tok::utf8_char_constant:
989  case tok::utf16_char_constant:
990  case tok::utf32_char_constant:
991  Res = Actions.ActOnCharacterConstant(Tok, /*UDLScope*/getCurScope());
992  ConsumeToken();
993  break;
994  case tok::kw___func__: // primary-expression: __func__ [C99 6.4.2.2]
995  case tok::kw___FUNCTION__: // primary-expression: __FUNCTION__ [GNU]
996  case tok::kw___FUNCDNAME__: // primary-expression: __FUNCDNAME__ [MS]
997  case tok::kw___FUNCSIG__: // primary-expression: __FUNCSIG__ [MS]
998  case tok::kw_L__FUNCTION__: // primary-expression: L__FUNCTION__ [MS]
999  case tok::kw___PRETTY_FUNCTION__: // primary-expression: __P..Y_F..N__ [GNU]
1000  Res = Actions.ActOnPredefinedExpr(Tok.getLocation(), SavedKind);
1001  ConsumeToken();
1002  break;
1003  case tok::string_literal: // primary-expression: string-literal
1004  case tok::wide_string_literal:
1005  case tok::utf8_string_literal:
1006  case tok::utf16_string_literal:
1007  case tok::utf32_string_literal:
1008  Res = ParseStringLiteralExpression(true);
1009  break;
1010  case tok::kw__Generic: // primary-expression: generic-selection [C11 6.5.1]
1011  Res = ParseGenericSelectionExpression();
1012  break;
1013  case tok::kw___builtin_available:
1014  return ParseAvailabilityCheckExpr(Tok.getLocation());
1015  case tok::kw___builtin_va_arg:
1016  case tok::kw___builtin_offsetof:
1017  case tok::kw___builtin_choose_expr:
1018  case tok::kw___builtin_astype: // primary-expression: [OCL] as_type()
1019  case tok::kw___builtin_convertvector:
1020  return ParseBuiltinPrimaryExpression();
1021  case tok::kw___null:
1022  return Actions.ActOnGNUNullExpr(ConsumeToken());
1023 
1024  case tok::plusplus: // unary-expression: '++' unary-expression [C99]
1025  case tok::minusminus: { // unary-expression: '--' unary-expression [C99]
1026  // C++ [expr.unary] has:
1027  // unary-expression:
1028  // ++ cast-expression
1029  // -- cast-expression
1030  Token SavedTok = Tok;
1031  ConsumeToken();
1032  // One special case is implicitly handled here: if the preceding tokens are
1033  // an ambiguous cast expression, such as "(T())++", then we recurse to
1034  // determine whether the '++' is prefix or postfix.
1035  Res = ParseCastExpression(!getLangOpts().CPlusPlus,
1036  /*isAddressOfOperand*/false, NotCastExpr,
1037  NotTypeCast);
1038  if (NotCastExpr) {
1039  // If we return with NotCastExpr = true, we must not consume any tokens,
1040  // so put the token back where we found it.
1041  assert(Res.isInvalid());
1042  UnconsumeToken(SavedTok);
1043  return ExprError();
1044  }
1045  if (!Res.isInvalid())
1046  Res = Actions.ActOnUnaryOp(getCurScope(), SavedTok.getLocation(),
1047  SavedKind, Res.get());
1048  return Res;
1049  }
1050  case tok::amp: { // unary-expression: '&' cast-expression
1051  // Special treatment because of member pointers
1052  SourceLocation SavedLoc = ConsumeToken();
1053  Res = ParseCastExpression(false, true);
1054  if (!Res.isInvalid())
1055  Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
1056  return Res;
1057  }
1058 
1059  case tok::star: // unary-expression: '*' cast-expression
1060  case tok::plus: // unary-expression: '+' cast-expression
1061  case tok::minus: // unary-expression: '-' cast-expression
1062  case tok::tilde: // unary-expression: '~' cast-expression
1063  case tok::exclaim: // unary-expression: '!' cast-expression
1064  case tok::kw___real: // unary-expression: '__real' cast-expression [GNU]
1065  case tok::kw___imag: { // unary-expression: '__imag' cast-expression [GNU]
1066  SourceLocation SavedLoc = ConsumeToken();
1067  Res = ParseCastExpression(false);
1068  if (!Res.isInvalid())
1069  Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
1070  return Res;
1071  }
1072 
1073  case tok::kw_co_await: { // unary-expression: 'co_await' cast-expression
1074  SourceLocation CoawaitLoc = ConsumeToken();
1075  Res = ParseCastExpression(false);
1076  if (!Res.isInvalid())
1077  Res = Actions.ActOnCoawaitExpr(getCurScope(), CoawaitLoc, Res.get());
1078  return Res;
1079  }
1080 
1081  case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU]
1082  // __extension__ silences extension warnings in the subexpression.
1083  ExtensionRAIIObject O(Diags); // Use RAII to do this.
1084  SourceLocation SavedLoc = ConsumeToken();
1085  Res = ParseCastExpression(false);
1086  if (!Res.isInvalid())
1087  Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
1088  return Res;
1089  }
1090  case tok::kw__Alignof: // unary-expression: '_Alignof' '(' type-name ')'
1091  if (!getLangOpts().C11)
1092  Diag(Tok, diag::ext_c11_alignment) << Tok.getName();
1093  // fallthrough
1094  case tok::kw_alignof: // unary-expression: 'alignof' '(' type-id ')'
1095  case tok::kw___alignof: // unary-expression: '__alignof' unary-expression
1096  // unary-expression: '__alignof' '(' type-name ')'
1097  case tok::kw_sizeof: // unary-expression: 'sizeof' unary-expression
1098  // unary-expression: 'sizeof' '(' type-name ')'
1099  case tok::kw_vec_step: // unary-expression: OpenCL 'vec_step' expression
1100  // unary-expression: '__builtin_omp_required_simd_align' '(' type-name ')'
1101  case tok::kw___builtin_omp_required_simd_align:
1102  return ParseUnaryExprOrTypeTraitExpression();
1103  case tok::ampamp: { // unary-expression: '&&' identifier
1104  SourceLocation AmpAmpLoc = ConsumeToken();
1105  if (Tok.isNot(tok::identifier))
1106  return ExprError(Diag(Tok, diag::err_expected) << tok::identifier);
1107 
1108  if (getCurScope()->getFnParent() == nullptr)
1109  return ExprError(Diag(Tok, diag::err_address_of_label_outside_fn));
1110 
1111  Diag(AmpAmpLoc, diag::ext_gnu_address_of_label);
1112  LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
1113  Tok.getLocation());
1114  Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(), LD);
1115  ConsumeToken();
1116  return Res;
1117  }
1118  case tok::kw_const_cast:
1119  case tok::kw_dynamic_cast:
1120  case tok::kw_reinterpret_cast:
1121  case tok::kw_static_cast:
1122  Res = ParseCXXCasts();
1123  break;
1124  case tok::kw_typeid:
1125  Res = ParseCXXTypeid();
1126  break;
1127  case tok::kw___uuidof:
1128  Res = ParseCXXUuidof();
1129  break;
1130  case tok::kw_this:
1131  Res = ParseCXXThis();
1132  break;
1133 
1134  case tok::annot_typename:
1135  if (isStartOfObjCClassMessageMissingOpenBracket()) {
1137 
1138  // Fake up a Declarator to use with ActOnTypeName.
1139  DeclSpec DS(AttrFactory);
1140  DS.SetRangeStart(Tok.getLocation());
1141  DS.SetRangeEnd(Tok.getLastLoc());
1142 
1143  const char *PrevSpec = nullptr;
1144  unsigned DiagID;
1145  DS.SetTypeSpecType(TST_typename, Tok.getAnnotationEndLoc(),
1146  PrevSpec, DiagID, Type,
1147  Actions.getASTContext().getPrintingPolicy());
1148 
1149  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1150  TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
1151  if (Ty.isInvalid())
1152  break;
1153 
1154  ConsumeToken();
1155  Res = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(),
1156  Ty.get(), nullptr);
1157  break;
1158  }
1159  // Fall through
1160 
1161  case tok::annot_decltype:
1162  case tok::kw_char:
1163  case tok::kw_wchar_t:
1164  case tok::kw_char16_t:
1165  case tok::kw_char32_t:
1166  case tok::kw_bool:
1167  case tok::kw_short:
1168  case tok::kw_int:
1169  case tok::kw_long:
1170  case tok::kw___int64:
1171  case tok::kw___int128:
1172  case tok::kw_signed:
1173  case tok::kw_unsigned:
1174  case tok::kw_half:
1175  case tok::kw_float:
1176  case tok::kw_double:
1177  case tok::kw___float128:
1178  case tok::kw_void:
1179  case tok::kw_typename:
1180  case tok::kw_typeof:
1181  case tok::kw___vector:
1182 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
1183 #include "clang/Basic/OpenCLImageTypes.def"
1184  {
1185  if (!getLangOpts().CPlusPlus) {
1186  Diag(Tok, diag::err_expected_expression);
1187  return ExprError();
1188  }
1189 
1190  if (SavedKind == tok::kw_typename) {
1191  // postfix-expression: typename-specifier '(' expression-list[opt] ')'
1192  // typename-specifier braced-init-list
1194  return ExprError();
1195 
1196  if (!Actions.isSimpleTypeSpecifier(Tok.getKind()))
1197  // We are trying to parse a simple-type-specifier but might not get such
1198  // a token after error recovery.
1199  return ExprError();
1200  }
1201 
1202  // postfix-expression: simple-type-specifier '(' expression-list[opt] ')'
1203  // simple-type-specifier braced-init-list
1204  //
1205  DeclSpec DS(AttrFactory);
1206 
1207  ParseCXXSimpleTypeSpecifier(DS);
1208  if (Tok.isNot(tok::l_paren) &&
1209  (!getLangOpts().CPlusPlus11 || Tok.isNot(tok::l_brace)))
1210  return ExprError(Diag(Tok, diag::err_expected_lparen_after_type)
1211  << DS.getSourceRange());
1212 
1213  if (Tok.is(tok::l_brace))
1214  Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
1215 
1216  Res = ParseCXXTypeConstructExpression(DS);
1217  break;
1218  }
1219 
1220  case tok::annot_cxxscope: { // [C++] id-expression: qualified-id
1221  // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse.
1222  // (We can end up in this situation after tentative parsing.)
1224  return ExprError();
1225  if (!Tok.is(tok::annot_cxxscope))
1226  return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
1227  NotCastExpr, isTypeCast);
1228 
1229  Token Next = NextToken();
1230  if (Next.is(tok::annot_template_id)) {
1231  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Next);
1232  if (TemplateId->Kind == TNK_Type_template) {
1233  // We have a qualified template-id that we know refers to a
1234  // type, translate it into a type and continue parsing as a
1235  // cast expression.
1236  CXXScopeSpec SS;
1237  ParseOptionalCXXScopeSpecifier(SS, nullptr,
1238  /*EnteringContext=*/false);
1239  AnnotateTemplateIdTokenAsType();
1240  return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
1241  NotCastExpr, isTypeCast);
1242  }
1243  }
1244 
1245  // Parse as an id-expression.
1246  Res = ParseCXXIdExpression(isAddressOfOperand);
1247  break;
1248  }
1249 
1250  case tok::annot_template_id: { // [C++] template-id
1251  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1252  if (TemplateId->Kind == TNK_Type_template) {
1253  // We have a template-id that we know refers to a type,
1254  // translate it into a type and continue parsing as a cast
1255  // expression.
1256  AnnotateTemplateIdTokenAsType();
1257  return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
1258  NotCastExpr, isTypeCast);
1259  }
1260 
1261  // Fall through to treat the template-id as an id-expression.
1262  }
1263 
1264  case tok::kw_operator: // [C++] id-expression: operator/conversion-function-id
1265  Res = ParseCXXIdExpression(isAddressOfOperand);
1266  break;
1267 
1268  case tok::coloncolon: {
1269  // ::foo::bar -> global qualified name etc. If TryAnnotateTypeOrScopeToken
1270  // annotates the token, tail recurse.
1272  return ExprError();
1273  if (!Tok.is(tok::coloncolon))
1274  return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
1275 
1276  // ::new -> [C++] new-expression
1277  // ::delete -> [C++] delete-expression
1278  SourceLocation CCLoc = ConsumeToken();
1279  if (Tok.is(tok::kw_new))
1280  return ParseCXXNewExpression(true, CCLoc);
1281  if (Tok.is(tok::kw_delete))
1282  return ParseCXXDeleteExpression(true, CCLoc);
1283 
1284  // This is not a type name or scope specifier, it is an invalid expression.
1285  Diag(CCLoc, diag::err_expected_expression);
1286  return ExprError();
1287  }
1288 
1289  case tok::kw_new: // [C++] new-expression
1290  return ParseCXXNewExpression(false, Tok.getLocation());
1291 
1292  case tok::kw_delete: // [C++] delete-expression
1293  return ParseCXXDeleteExpression(false, Tok.getLocation());
1294 
1295  case tok::kw_noexcept: { // [C++0x] 'noexcept' '(' expression ')'
1296  Diag(Tok, diag::warn_cxx98_compat_noexcept_expr);
1297  SourceLocation KeyLoc = ConsumeToken();
1298  BalancedDelimiterTracker T(*this, tok::l_paren);
1299 
1300  if (T.expectAndConsume(diag::err_expected_lparen_after, "noexcept"))
1301  return ExprError();
1302  // C++11 [expr.unary.noexcept]p1:
1303  // The noexcept operator determines whether the evaluation of its operand,
1304  // which is an unevaluated operand, can throw an exception.
1307 
1308  T.consumeClose();
1309 
1310  if (!Result.isInvalid())
1311  Result = Actions.ActOnNoexceptExpr(KeyLoc, T.getOpenLocation(),
1312  Result.get(), T.getCloseLocation());
1313  return Result;
1314  }
1315 
1316 #define TYPE_TRAIT(N,Spelling,K) \
1317  case tok::kw_##Spelling:
1318 #include "clang/Basic/TokenKinds.def"
1319  return ParseTypeTrait();
1320 
1321  case tok::kw___array_rank:
1322  case tok::kw___array_extent:
1323  return ParseArrayTypeTrait();
1324 
1325  case tok::kw___is_lvalue_expr:
1326  case tok::kw___is_rvalue_expr:
1327  return ParseExpressionTrait();
1328 
1329  case tok::at: {
1330  SourceLocation AtLoc = ConsumeToken();
1331  return ParseObjCAtExpression(AtLoc);
1332  }
1333  case tok::caret:
1334  Res = ParseBlockLiteralExpression();
1335  break;
1336  case tok::code_completion: {
1338  cutOffParsing();
1339  return ExprError();
1340  }
1341  case tok::l_square:
1342  if (getLangOpts().CPlusPlus11) {
1343  if (getLangOpts().ObjC1) {
1344  // C++11 lambda expressions and Objective-C message sends both start with a
1345  // square bracket. There are three possibilities here:
1346  // we have a valid lambda expression, we have an invalid lambda
1347  // expression, or we have something that doesn't appear to be a lambda.
1348  // If we're in the last case, we fall back to ParseObjCMessageExpression.
1349  Res = TryParseLambdaExpression();
1350  if (!Res.isInvalid() && !Res.get())
1351  Res = ParseObjCMessageExpression();
1352  break;
1353  }
1354  Res = ParseLambdaExpression();
1355  break;
1356  }
1357  if (getLangOpts().ObjC1) {
1358  Res = ParseObjCMessageExpression();
1359  break;
1360  }
1361  // FALL THROUGH.
1362  default:
1363  NotCastExpr = true;
1364  return ExprError();
1365  }
1366 
1367  // Check to see whether Res is a function designator only. If it is and we
1368  // are compiling for OpenCL, we need to return an error as this implies
1369  // that the address of the function is being taken, which is illegal in CL.
1370 
1371  // These can be followed by postfix-expr pieces.
1372  Res = ParsePostfixExpressionSuffix(Res);
1373  if (getLangOpts().OpenCL)
1374  if (Expr *PostfixExpr = Res.get()) {
1375  QualType Ty = PostfixExpr->getType();
1376  if (!Ty.isNull() && Ty->isFunctionType()) {
1377  Diag(PostfixExpr->getExprLoc(),
1378  diag::err_opencl_taking_function_address_parser);
1379  return ExprError();
1380  }
1381  }
1382 
1383  return Res;
1384 }
1385 
1386 /// \brief Once the leading part of a postfix-expression is parsed, this
1387 /// method parses any suffixes that apply.
1388 ///
1389 /// \verbatim
1390 /// postfix-expression: [C99 6.5.2]
1391 /// primary-expression
1392 /// postfix-expression '[' expression ']'
1393 /// postfix-expression '[' braced-init-list ']'
1394 /// postfix-expression '(' argument-expression-list[opt] ')'
1395 /// postfix-expression '.' identifier
1396 /// postfix-expression '->' identifier
1397 /// postfix-expression '++'
1398 /// postfix-expression '--'
1399 /// '(' type-name ')' '{' initializer-list '}'
1400 /// '(' type-name ')' '{' initializer-list ',' '}'
1401 ///
1402 /// argument-expression-list: [C99 6.5.2]
1403 /// argument-expression ...[opt]
1404 /// argument-expression-list ',' assignment-expression ...[opt]
1405 /// \endverbatim
1406 ExprResult
1407 Parser::ParsePostfixExpressionSuffix(ExprResult LHS) {
1408  // Now that the primary-expression piece of the postfix-expression has been
1409  // parsed, see if there are any postfix-expression pieces here.
1410  SourceLocation Loc;
1411  while (1) {
1412  switch (Tok.getKind()) {
1413  case tok::code_completion:
1414  if (InMessageExpression)
1415  return LHS;
1416 
1418  cutOffParsing();
1419  return ExprError();
1420 
1421  case tok::identifier:
1422  // If we see identifier: after an expression, and we're not already in a
1423  // message send, then this is probably a message send with a missing
1424  // opening bracket '['.
1425  if (getLangOpts().ObjC1 && !InMessageExpression &&
1426  (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) {
1427  LHS = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(),
1428  nullptr, LHS.get());
1429  break;
1430  }
1431 
1432  // Fall through; this isn't a message send.
1433 
1434  default: // Not a postfix-expression suffix.
1435  return LHS;
1436  case tok::l_square: { // postfix-expression: p-e '[' expression ']'
1437  // If we have a array postfix expression that starts on a new line and
1438  // Objective-C is enabled, it is highly likely that the user forgot a
1439  // semicolon after the base expression and that the array postfix-expr is
1440  // actually another message send. In this case, do some look-ahead to see
1441  // if the contents of the square brackets are obviously not a valid
1442  // expression and recover by pretending there is no suffix.
1443  if (getLangOpts().ObjC1 && Tok.isAtStartOfLine() &&
1444  isSimpleObjCMessageExpression())
1445  return LHS;
1446 
1447  // Reject array indices starting with a lambda-expression. '[[' is
1448  // reserved for attributes.
1449  if (CheckProhibitedCXX11Attribute()) {
1450  (void)Actions.CorrectDelayedTyposInExpr(LHS);
1451  return ExprError();
1452  }
1453 
1454  BalancedDelimiterTracker T(*this, tok::l_square);
1455  T.consumeOpen();
1456  Loc = T.getOpenLocation();
1457  ExprResult Idx, Length;
1459  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
1460  Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
1461  Idx = ParseBraceInitializer();
1462  } else if (getLangOpts().OpenMP) {
1463  ColonProtectionRAIIObject RAII(*this);
1464  // Parse [: or [ expr or [ expr :
1465  if (!Tok.is(tok::colon)) {
1466  // [ expr
1467  Idx = ParseExpression();
1468  }
1469  if (Tok.is(tok::colon)) {
1470  // Consume ':'
1471  ColonLoc = ConsumeToken();
1472  if (Tok.isNot(tok::r_square))
1473  Length = ParseExpression();
1474  }
1475  } else
1476  Idx = ParseExpression();
1477 
1478  SourceLocation RLoc = Tok.getLocation();
1479 
1480  ExprResult OrigLHS = LHS;
1481  if (!LHS.isInvalid() && !Idx.isInvalid() && !Length.isInvalid() &&
1482  Tok.is(tok::r_square)) {
1483  if (ColonLoc.isValid()) {
1484  LHS = Actions.ActOnOMPArraySectionExpr(LHS.get(), Loc, Idx.get(),
1485  ColonLoc, Length.get(), RLoc);
1486  } else {
1487  LHS = Actions.ActOnArraySubscriptExpr(getCurScope(), LHS.get(), Loc,
1488  Idx.get(), RLoc);
1489  }
1490  } else {
1491  LHS = ExprError();
1492  }
1493  if (LHS.isInvalid()) {
1494  (void)Actions.CorrectDelayedTyposInExpr(OrigLHS);
1495  (void)Actions.CorrectDelayedTyposInExpr(Idx);
1496  (void)Actions.CorrectDelayedTyposInExpr(Length);
1497  LHS = ExprError();
1498  Idx = ExprError();
1499  }
1500 
1501  // Match the ']'.
1502  T.consumeClose();
1503  break;
1504  }
1505 
1506  case tok::l_paren: // p-e: p-e '(' argument-expression-list[opt] ')'
1507  case tok::lesslessless: { // p-e: p-e '<<<' argument-expression-list '>>>'
1508  // '(' argument-expression-list[opt] ')'
1509  tok::TokenKind OpKind = Tok.getKind();
1510  InMessageExpressionRAIIObject InMessage(*this, false);
1511 
1512  Expr *ExecConfig = nullptr;
1513 
1514  BalancedDelimiterTracker PT(*this, tok::l_paren);
1515 
1516  if (OpKind == tok::lesslessless) {
1517  ExprVector ExecConfigExprs;
1518  CommaLocsTy ExecConfigCommaLocs;
1519  SourceLocation OpenLoc = ConsumeToken();
1520 
1521  if (ParseSimpleExpressionList(ExecConfigExprs, ExecConfigCommaLocs)) {
1522  (void)Actions.CorrectDelayedTyposInExpr(LHS);
1523  LHS = ExprError();
1524  }
1525 
1526  SourceLocation CloseLoc;
1527  if (TryConsumeToken(tok::greatergreatergreater, CloseLoc)) {
1528  } else if (LHS.isInvalid()) {
1529  SkipUntil(tok::greatergreatergreater, StopAtSemi);
1530  } else {
1531  // There was an error closing the brackets
1532  Diag(Tok, diag::err_expected) << tok::greatergreatergreater;
1533  Diag(OpenLoc, diag::note_matching) << tok::lesslessless;
1534  SkipUntil(tok::greatergreatergreater, StopAtSemi);
1535  LHS = ExprError();
1536  }
1537 
1538  if (!LHS.isInvalid()) {
1539  if (ExpectAndConsume(tok::l_paren))
1540  LHS = ExprError();
1541  else
1542  Loc = PrevTokLocation;
1543  }
1544 
1545  if (!LHS.isInvalid()) {
1546  ExprResult ECResult = Actions.ActOnCUDAExecConfigExpr(getCurScope(),
1547  OpenLoc,
1548  ExecConfigExprs,
1549  CloseLoc);
1550  if (ECResult.isInvalid())
1551  LHS = ExprError();
1552  else
1553  ExecConfig = ECResult.get();
1554  }
1555  } else {
1556  PT.consumeOpen();
1557  Loc = PT.getOpenLocation();
1558  }
1559 
1560  ExprVector ArgExprs;
1561  CommaLocsTy CommaLocs;
1562 
1563  if (Tok.is(tok::code_completion)) {
1564  Actions.CodeCompleteCall(getCurScope(), LHS.get(), None);
1565  cutOffParsing();
1566  return ExprError();
1567  }
1568 
1569  if (OpKind == tok::l_paren || !LHS.isInvalid()) {
1570  if (Tok.isNot(tok::r_paren)) {
1571  if (ParseExpressionList(ArgExprs, CommaLocs, [&] {
1572  Actions.CodeCompleteCall(getCurScope(), LHS.get(), ArgExprs);
1573  })) {
1574  (void)Actions.CorrectDelayedTyposInExpr(LHS);
1575  LHS = ExprError();
1576  } else if (LHS.isInvalid()) {
1577  for (auto &E : ArgExprs)
1578  Actions.CorrectDelayedTyposInExpr(E);
1579  }
1580  }
1581  }
1582 
1583  // Match the ')'.
1584  if (LHS.isInvalid()) {
1585  SkipUntil(tok::r_paren, StopAtSemi);
1586  } else if (Tok.isNot(tok::r_paren)) {
1587  bool HadDelayedTypo = false;
1588  if (Actions.CorrectDelayedTyposInExpr(LHS).get() != LHS.get())
1589  HadDelayedTypo = true;
1590  for (auto &E : ArgExprs)
1591  if (Actions.CorrectDelayedTyposInExpr(E).get() != E)
1592  HadDelayedTypo = true;
1593  // If there were delayed typos in the LHS or ArgExprs, call SkipUntil
1594  // instead of PT.consumeClose() to avoid emitting extra diagnostics for
1595  // the unmatched l_paren.
1596  if (HadDelayedTypo)
1597  SkipUntil(tok::r_paren, StopAtSemi);
1598  else
1599  PT.consumeClose();
1600  LHS = ExprError();
1601  } else {
1602  assert((ArgExprs.size() == 0 ||
1603  ArgExprs.size()-1 == CommaLocs.size())&&
1604  "Unexpected number of commas!");
1605  LHS = Actions.ActOnCallExpr(getCurScope(), LHS.get(), Loc,
1606  ArgExprs, Tok.getLocation(),
1607  ExecConfig);
1608  PT.consumeClose();
1609  }
1610 
1611  break;
1612  }
1613  case tok::arrow:
1614  case tok::period: {
1615  // postfix-expression: p-e '->' template[opt] id-expression
1616  // postfix-expression: p-e '.' template[opt] id-expression
1617  tok::TokenKind OpKind = Tok.getKind();
1618  SourceLocation OpLoc = ConsumeToken(); // Eat the "." or "->" token.
1619 
1620  CXXScopeSpec SS;
1621  ParsedType ObjectType;
1622  bool MayBePseudoDestructor = false;
1623  if (getLangOpts().CPlusPlus && !LHS.isInvalid()) {
1624  Expr *Base = LHS.get();
1625  const Type* BaseType = Base->getType().getTypePtrOrNull();
1626  if (BaseType && Tok.is(tok::l_paren) &&
1627  (BaseType->isFunctionType() ||
1628  BaseType->isSpecificPlaceholderType(BuiltinType::BoundMember))) {
1629  Diag(OpLoc, diag::err_function_is_not_record)
1630  << OpKind << Base->getSourceRange()
1631  << FixItHint::CreateRemoval(OpLoc);
1632  return ParsePostfixExpressionSuffix(Base);
1633  }
1634 
1635  LHS = Actions.ActOnStartCXXMemberReference(getCurScope(), Base,
1636  OpLoc, OpKind, ObjectType,
1637  MayBePseudoDestructor);
1638  if (LHS.isInvalid())
1639  break;
1640 
1641  ParseOptionalCXXScopeSpecifier(SS, ObjectType,
1642  /*EnteringContext=*/false,
1643  &MayBePseudoDestructor);
1644  if (SS.isNotEmpty())
1645  ObjectType = nullptr;
1646  }
1647 
1648  if (Tok.is(tok::code_completion)) {
1649  // Code completion for a member access expression.
1651  OpLoc, OpKind == tok::arrow);
1652 
1653  cutOffParsing();
1654  return ExprError();
1655  }
1656 
1657  if (MayBePseudoDestructor && !LHS.isInvalid()) {
1658  LHS = ParseCXXPseudoDestructor(LHS.get(), OpLoc, OpKind, SS,
1659  ObjectType);
1660  break;
1661  }
1662 
1663  // Either the action has told us that this cannot be a
1664  // pseudo-destructor expression (based on the type of base
1665  // expression), or we didn't see a '~' in the right place. We
1666  // can still parse a destructor name here, but in that case it
1667  // names a real destructor.
1668  // Allow explicit constructor calls in Microsoft mode.
1669  // FIXME: Add support for explicit call of template constructor.
1670  SourceLocation TemplateKWLoc;
1672  if (getLangOpts().ObjC2 && OpKind == tok::period &&
1673  Tok.is(tok::kw_class)) {
1674  // Objective-C++:
1675  // After a '.' in a member access expression, treat the keyword
1676  // 'class' as if it were an identifier.
1677  //
1678  // This hack allows property access to the 'class' method because it is
1679  // such a common method name. For other C++ keywords that are
1680  // Objective-C method names, one must use the message send syntax.
1681  IdentifierInfo *Id = Tok.getIdentifierInfo();
1682  SourceLocation Loc = ConsumeToken();
1683  Name.setIdentifier(Id, Loc);
1684  } else if (ParseUnqualifiedId(SS,
1685  /*EnteringContext=*/false,
1686  /*AllowDestructorName=*/true,
1687  /*AllowConstructorName=*/
1688  getLangOpts().MicrosoftExt,
1689  ObjectType, TemplateKWLoc, Name)) {
1690  (void)Actions.CorrectDelayedTyposInExpr(LHS);
1691  LHS = ExprError();
1692  }
1693 
1694  if (!LHS.isInvalid())
1695  LHS = Actions.ActOnMemberAccessExpr(getCurScope(), LHS.get(), OpLoc,
1696  OpKind, SS, TemplateKWLoc, Name,
1697  CurParsedObjCImpl ? CurParsedObjCImpl->Dcl
1698  : nullptr);
1699  break;
1700  }
1701  case tok::plusplus: // postfix-expression: postfix-expression '++'
1702  case tok::minusminus: // postfix-expression: postfix-expression '--'
1703  if (!LHS.isInvalid()) {
1704  LHS = Actions.ActOnPostfixUnaryOp(getCurScope(), Tok.getLocation(),
1705  Tok.getKind(), LHS.get());
1706  }
1707  ConsumeToken();
1708  break;
1709  }
1710  }
1711 }
1712 
1713 /// ParseExprAfterUnaryExprOrTypeTrait - We parsed a typeof/sizeof/alignof/
1714 /// vec_step and we are at the start of an expression or a parenthesized
1715 /// type-id. OpTok is the operand token (typeof/sizeof/alignof). Returns the
1716 /// expression (isCastExpr == false) or the type (isCastExpr == true).
1717 ///
1718 /// \verbatim
1719 /// unary-expression: [C99 6.5.3]
1720 /// 'sizeof' unary-expression
1721 /// 'sizeof' '(' type-name ')'
1722 /// [GNU] '__alignof' unary-expression
1723 /// [GNU] '__alignof' '(' type-name ')'
1724 /// [C11] '_Alignof' '(' type-name ')'
1725 /// [C++0x] 'alignof' '(' type-id ')'
1726 ///
1727 /// [GNU] typeof-specifier:
1728 /// typeof ( expressions )
1729 /// typeof ( type-name )
1730 /// [GNU/C++] typeof unary-expression
1731 ///
1732 /// [OpenCL 1.1 6.11.12] vec_step built-in function:
1733 /// vec_step ( expressions )
1734 /// vec_step ( type-name )
1735 /// \endverbatim
1736 ExprResult
1737 Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok,
1738  bool &isCastExpr,
1739  ParsedType &CastTy,
1740  SourceRange &CastRange) {
1741 
1742  assert(OpTok.isOneOf(tok::kw_typeof, tok::kw_sizeof, tok::kw___alignof,
1743  tok::kw_alignof, tok::kw__Alignof, tok::kw_vec_step,
1744  tok::kw___builtin_omp_required_simd_align) &&
1745  "Not a typeof/sizeof/alignof/vec_step expression!");
1746 
1747  ExprResult Operand;
1748 
1749  // If the operand doesn't start with an '(', it must be an expression.
1750  if (Tok.isNot(tok::l_paren)) {
1751  // If construct allows a form without parenthesis, user may forget to put
1752  // pathenthesis around type name.
1753  if (OpTok.isOneOf(tok::kw_sizeof, tok::kw___alignof, tok::kw_alignof,
1754  tok::kw__Alignof)) {
1755  if (isTypeIdUnambiguously()) {
1756  DeclSpec DS(AttrFactory);
1757  ParseSpecifierQualifierList(DS);
1758  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1759  ParseDeclarator(DeclaratorInfo);
1760 
1761  SourceLocation LParenLoc = PP.getLocForEndOfToken(OpTok.getLocation());
1762  SourceLocation RParenLoc = PP.getLocForEndOfToken(PrevTokLocation);
1763  Diag(LParenLoc, diag::err_expected_parentheses_around_typename)
1764  << OpTok.getName()
1765  << FixItHint::CreateInsertion(LParenLoc, "(")
1766  << FixItHint::CreateInsertion(RParenLoc, ")");
1767  isCastExpr = true;
1768  return ExprEmpty();
1769  }
1770  }
1771 
1772  isCastExpr = false;
1773  if (OpTok.is(tok::kw_typeof) && !getLangOpts().CPlusPlus) {
1774  Diag(Tok, diag::err_expected_after) << OpTok.getIdentifierInfo()
1775  << tok::l_paren;
1776  return ExprError();
1777  }
1778 
1779  Operand = ParseCastExpression(true/*isUnaryExpression*/);
1780  } else {
1781  // If it starts with a '(', we know that it is either a parenthesized
1782  // type-name, or it is a unary-expression that starts with a compound
1783  // literal, or starts with a primary-expression that is a parenthesized
1784  // expression.
1785  ParenParseOption ExprType = CastExpr;
1786  SourceLocation LParenLoc = Tok.getLocation(), RParenLoc;
1787 
1788  Operand = ParseParenExpression(ExprType, true/*stopIfCastExpr*/,
1789  false, CastTy, RParenLoc);
1790  CastRange = SourceRange(LParenLoc, RParenLoc);
1791 
1792  // If ParseParenExpression parsed a '(typename)' sequence only, then this is
1793  // a type.
1794  if (ExprType == CastExpr) {
1795  isCastExpr = true;
1796  return ExprEmpty();
1797  }
1798 
1799  if (getLangOpts().CPlusPlus || OpTok.isNot(tok::kw_typeof)) {
1800  // GNU typeof in C requires the expression to be parenthesized. Not so for
1801  // sizeof/alignof or in C++. Therefore, the parenthesized expression is
1802  // the start of a unary-expression, but doesn't include any postfix
1803  // pieces. Parse these now if present.
1804  if (!Operand.isInvalid())
1805  Operand = ParsePostfixExpressionSuffix(Operand.get());
1806  }
1807  }
1808 
1809  // If we get here, the operand to the typeof/sizeof/alignof was an expresion.
1810  isCastExpr = false;
1811  return Operand;
1812 }
1813 
1814 
1815 /// \brief Parse a sizeof or alignof expression.
1816 ///
1817 /// \verbatim
1818 /// unary-expression: [C99 6.5.3]
1819 /// 'sizeof' unary-expression
1820 /// 'sizeof' '(' type-name ')'
1821 /// [C++11] 'sizeof' '...' '(' identifier ')'
1822 /// [GNU] '__alignof' unary-expression
1823 /// [GNU] '__alignof' '(' type-name ')'
1824 /// [C11] '_Alignof' '(' type-name ')'
1825 /// [C++11] 'alignof' '(' type-id ')'
1826 /// \endverbatim
1827 ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() {
1828  assert(Tok.isOneOf(tok::kw_sizeof, tok::kw___alignof, tok::kw_alignof,
1829  tok::kw__Alignof, tok::kw_vec_step,
1830  tok::kw___builtin_omp_required_simd_align) &&
1831  "Not a sizeof/alignof/vec_step expression!");
1832  Token OpTok = Tok;
1833  ConsumeToken();
1834 
1835  // [C++11] 'sizeof' '...' '(' identifier ')'
1836  if (Tok.is(tok::ellipsis) && OpTok.is(tok::kw_sizeof)) {
1837  SourceLocation EllipsisLoc = ConsumeToken();
1838  SourceLocation LParenLoc, RParenLoc;
1839  IdentifierInfo *Name = nullptr;
1840  SourceLocation NameLoc;
1841  if (Tok.is(tok::l_paren)) {
1842  BalancedDelimiterTracker T(*this, tok::l_paren);
1843  T.consumeOpen();
1844  LParenLoc = T.getOpenLocation();
1845  if (Tok.is(tok::identifier)) {
1846  Name = Tok.getIdentifierInfo();
1847  NameLoc = ConsumeToken();
1848  T.consumeClose();
1849  RParenLoc = T.getCloseLocation();
1850  if (RParenLoc.isInvalid())
1851  RParenLoc = PP.getLocForEndOfToken(NameLoc);
1852  } else {
1853  Diag(Tok, diag::err_expected_parameter_pack);
1854  SkipUntil(tok::r_paren, StopAtSemi);
1855  }
1856  } else if (Tok.is(tok::identifier)) {
1857  Name = Tok.getIdentifierInfo();
1858  NameLoc = ConsumeToken();
1859  LParenLoc = PP.getLocForEndOfToken(EllipsisLoc);
1860  RParenLoc = PP.getLocForEndOfToken(NameLoc);
1861  Diag(LParenLoc, diag::err_paren_sizeof_parameter_pack)
1862  << Name
1863  << FixItHint::CreateInsertion(LParenLoc, "(")
1864  << FixItHint::CreateInsertion(RParenLoc, ")");
1865  } else {
1866  Diag(Tok, diag::err_sizeof_parameter_pack);
1867  }
1868 
1869  if (!Name)
1870  return ExprError();
1871 
1874 
1875  return Actions.ActOnSizeofParameterPackExpr(getCurScope(),
1876  OpTok.getLocation(),
1877  *Name, NameLoc,
1878  RParenLoc);
1879  }
1880 
1881  if (OpTok.isOneOf(tok::kw_alignof, tok::kw__Alignof))
1882  Diag(OpTok, diag::warn_cxx98_compat_alignof);
1883 
1886 
1887  bool isCastExpr;
1888  ParsedType CastTy;
1889  SourceRange CastRange;
1890  ExprResult Operand = ParseExprAfterUnaryExprOrTypeTrait(OpTok,
1891  isCastExpr,
1892  CastTy,
1893  CastRange);
1894 
1895  UnaryExprOrTypeTrait ExprKind = UETT_SizeOf;
1896  if (OpTok.isOneOf(tok::kw_alignof, tok::kw___alignof, tok::kw__Alignof))
1897  ExprKind = UETT_AlignOf;
1898  else if (OpTok.is(tok::kw_vec_step))
1899  ExprKind = UETT_VecStep;
1900  else if (OpTok.is(tok::kw___builtin_omp_required_simd_align))
1901  ExprKind = UETT_OpenMPRequiredSimdAlign;
1902 
1903  if (isCastExpr)
1904  return Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(),
1905  ExprKind,
1906  /*isType=*/true,
1907  CastTy.getAsOpaquePtr(),
1908  CastRange);
1909 
1910  if (OpTok.isOneOf(tok::kw_alignof, tok::kw__Alignof))
1911  Diag(OpTok, diag::ext_alignof_expr) << OpTok.getIdentifierInfo();
1912 
1913  // If we get here, the operand to the sizeof/alignof was an expresion.
1914  if (!Operand.isInvalid())
1915  Operand = Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(),
1916  ExprKind,
1917  /*isType=*/false,
1918  Operand.get(),
1919  CastRange);
1920  return Operand;
1921 }
1922 
1923 /// ParseBuiltinPrimaryExpression
1924 ///
1925 /// \verbatim
1926 /// primary-expression: [C99 6.5.1]
1927 /// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
1928 /// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
1929 /// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
1930 /// assign-expr ')'
1931 /// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
1932 /// [OCL] '__builtin_astype' '(' assignment-expression ',' type-name ')'
1933 ///
1934 /// [GNU] offsetof-member-designator:
1935 /// [GNU] identifier
1936 /// [GNU] offsetof-member-designator '.' identifier
1937 /// [GNU] offsetof-member-designator '[' expression ']'
1938 /// \endverbatim
1939 ExprResult Parser::ParseBuiltinPrimaryExpression() {
1940  ExprResult Res;
1941  const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo();
1942 
1943  tok::TokenKind T = Tok.getKind();
1944  SourceLocation StartLoc = ConsumeToken(); // Eat the builtin identifier.
1945 
1946  // All of these start with an open paren.
1947  if (Tok.isNot(tok::l_paren))
1948  return ExprError(Diag(Tok, diag::err_expected_after) << BuiltinII
1949  << tok::l_paren);
1950 
1951  BalancedDelimiterTracker PT(*this, tok::l_paren);
1952  PT.consumeOpen();
1953 
1954  // TODO: Build AST.
1955 
1956  switch (T) {
1957  default: llvm_unreachable("Not a builtin primary expression!");
1958  case tok::kw___builtin_va_arg: {
1960 
1961  if (ExpectAndConsume(tok::comma)) {
1962  SkipUntil(tok::r_paren, StopAtSemi);
1963  Expr = ExprError();
1964  }
1965 
1966  TypeResult Ty = ParseTypeName();
1967 
1968  if (Tok.isNot(tok::r_paren)) {
1969  Diag(Tok, diag::err_expected) << tok::r_paren;
1970  Expr = ExprError();
1971  }
1972 
1973  if (Expr.isInvalid() || Ty.isInvalid())
1974  Res = ExprError();
1975  else
1976  Res = Actions.ActOnVAArg(StartLoc, Expr.get(), Ty.get(), ConsumeParen());
1977  break;
1978  }
1979  case tok::kw___builtin_offsetof: {
1980  SourceLocation TypeLoc = Tok.getLocation();
1981  TypeResult Ty = ParseTypeName();
1982  if (Ty.isInvalid()) {
1983  SkipUntil(tok::r_paren, StopAtSemi);
1984  return ExprError();
1985  }
1986 
1987  if (ExpectAndConsume(tok::comma)) {
1988  SkipUntil(tok::r_paren, StopAtSemi);
1989  return ExprError();
1990  }
1991 
1992  // We must have at least one identifier here.
1993  if (Tok.isNot(tok::identifier)) {
1994  Diag(Tok, diag::err_expected) << tok::identifier;
1995  SkipUntil(tok::r_paren, StopAtSemi);
1996  return ExprError();
1997  }
1998 
1999  // Keep track of the various subcomponents we see.
2001 
2002  Comps.push_back(Sema::OffsetOfComponent());
2003  Comps.back().isBrackets = false;
2004  Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
2005  Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken();
2006 
2007  // FIXME: This loop leaks the index expressions on error.
2008  while (1) {
2009  if (Tok.is(tok::period)) {
2010  // offsetof-member-designator: offsetof-member-designator '.' identifier
2011  Comps.push_back(Sema::OffsetOfComponent());
2012  Comps.back().isBrackets = false;
2013  Comps.back().LocStart = ConsumeToken();
2014 
2015  if (Tok.isNot(tok::identifier)) {
2016  Diag(Tok, diag::err_expected) << tok::identifier;
2017  SkipUntil(tok::r_paren, StopAtSemi);
2018  return ExprError();
2019  }
2020  Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
2021  Comps.back().LocEnd = ConsumeToken();
2022 
2023  } else if (Tok.is(tok::l_square)) {
2024  if (CheckProhibitedCXX11Attribute())
2025  return ExprError();
2026 
2027  // offsetof-member-designator: offsetof-member-design '[' expression ']'
2028  Comps.push_back(Sema::OffsetOfComponent());
2029  Comps.back().isBrackets = true;
2030  BalancedDelimiterTracker ST(*this, tok::l_square);
2031  ST.consumeOpen();
2032  Comps.back().LocStart = ST.getOpenLocation();
2033  Res = ParseExpression();
2034  if (Res.isInvalid()) {
2035  SkipUntil(tok::r_paren, StopAtSemi);
2036  return Res;
2037  }
2038  Comps.back().U.E = Res.get();
2039 
2040  ST.consumeClose();
2041  Comps.back().LocEnd = ST.getCloseLocation();
2042  } else {
2043  if (Tok.isNot(tok::r_paren)) {
2044  PT.consumeClose();
2045  Res = ExprError();
2046  } else if (Ty.isInvalid()) {
2047  Res = ExprError();
2048  } else {
2049  PT.consumeClose();
2050  Res = Actions.ActOnBuiltinOffsetOf(getCurScope(), StartLoc, TypeLoc,
2051  Ty.get(), Comps,
2052  PT.getCloseLocation());
2053  }
2054  break;
2055  }
2056  }
2057  break;
2058  }
2059  case tok::kw___builtin_choose_expr: {
2061  if (Cond.isInvalid()) {
2062  SkipUntil(tok::r_paren, StopAtSemi);
2063  return Cond;
2064  }
2065  if (ExpectAndConsume(tok::comma)) {
2066  SkipUntil(tok::r_paren, StopAtSemi);
2067  return ExprError();
2068  }
2069 
2071  if (Expr1.isInvalid()) {
2072  SkipUntil(tok::r_paren, StopAtSemi);
2073  return Expr1;
2074  }
2075  if (ExpectAndConsume(tok::comma)) {
2076  SkipUntil(tok::r_paren, StopAtSemi);
2077  return ExprError();
2078  }
2079 
2081  if (Expr2.isInvalid()) {
2082  SkipUntil(tok::r_paren, StopAtSemi);
2083  return Expr2;
2084  }
2085  if (Tok.isNot(tok::r_paren)) {
2086  Diag(Tok, diag::err_expected) << tok::r_paren;
2087  return ExprError();
2088  }
2089  Res = Actions.ActOnChooseExpr(StartLoc, Cond.get(), Expr1.get(),
2090  Expr2.get(), ConsumeParen());
2091  break;
2092  }
2093  case tok::kw___builtin_astype: {
2094  // The first argument is an expression to be converted, followed by a comma.
2096  if (Expr.isInvalid()) {
2097  SkipUntil(tok::r_paren, StopAtSemi);
2098  return ExprError();
2099  }
2100 
2101  if (ExpectAndConsume(tok::comma)) {
2102  SkipUntil(tok::r_paren, StopAtSemi);
2103  return ExprError();
2104  }
2105 
2106  // Second argument is the type to bitcast to.
2107  TypeResult DestTy = ParseTypeName();
2108  if (DestTy.isInvalid())
2109  return ExprError();
2110 
2111  // Attempt to consume the r-paren.
2112  if (Tok.isNot(tok::r_paren)) {
2113  Diag(Tok, diag::err_expected) << tok::r_paren;
2114  SkipUntil(tok::r_paren, StopAtSemi);
2115  return ExprError();
2116  }
2117 
2118  Res = Actions.ActOnAsTypeExpr(Expr.get(), DestTy.get(), StartLoc,
2119  ConsumeParen());
2120  break;
2121  }
2122  case tok::kw___builtin_convertvector: {
2123  // The first argument is an expression to be converted, followed by a comma.
2125  if (Expr.isInvalid()) {
2126  SkipUntil(tok::r_paren, StopAtSemi);
2127  return ExprError();
2128  }
2129 
2130  if (ExpectAndConsume(tok::comma)) {
2131  SkipUntil(tok::r_paren, StopAtSemi);
2132  return ExprError();
2133  }
2134 
2135  // Second argument is the type to bitcast to.
2136  TypeResult DestTy = ParseTypeName();
2137  if (DestTy.isInvalid())
2138  return ExprError();
2139 
2140  // Attempt to consume the r-paren.
2141  if (Tok.isNot(tok::r_paren)) {
2142  Diag(Tok, diag::err_expected) << tok::r_paren;
2143  SkipUntil(tok::r_paren, StopAtSemi);
2144  return ExprError();
2145  }
2146 
2147  Res = Actions.ActOnConvertVectorExpr(Expr.get(), DestTy.get(), StartLoc,
2148  ConsumeParen());
2149  break;
2150  }
2151  }
2152 
2153  if (Res.isInvalid())
2154  return ExprError();
2155 
2156  // These can be followed by postfix-expr pieces because they are
2157  // primary-expressions.
2158  return ParsePostfixExpressionSuffix(Res.get());
2159 }
2160 
2161 /// ParseParenExpression - This parses the unit that starts with a '(' token,
2162 /// based on what is allowed by ExprType. The actual thing parsed is returned
2163 /// in ExprType. If stopIfCastExpr is true, it will only return the parsed type,
2164 /// not the parsed cast-expression.
2165 ///
2166 /// \verbatim
2167 /// primary-expression: [C99 6.5.1]
2168 /// '(' expression ')'
2169 /// [GNU] '(' compound-statement ')' (if !ParenExprOnly)
2170 /// postfix-expression: [C99 6.5.2]
2171 /// '(' type-name ')' '{' initializer-list '}'
2172 /// '(' type-name ')' '{' initializer-list ',' '}'
2173 /// cast-expression: [C99 6.5.4]
2174 /// '(' type-name ')' cast-expression
2175 /// [ARC] bridged-cast-expression
2176 /// [ARC] bridged-cast-expression:
2177 /// (__bridge type-name) cast-expression
2178 /// (__bridge_transfer type-name) cast-expression
2179 /// (__bridge_retained type-name) cast-expression
2180 /// fold-expression: [C++1z]
2181 /// '(' cast-expression fold-operator '...' ')'
2182 /// '(' '...' fold-operator cast-expression ')'
2183 /// '(' cast-expression fold-operator '...'
2184 /// fold-operator cast-expression ')'
2185 /// \endverbatim
2186 ExprResult
2187 Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr,
2188  bool isTypeCast, ParsedType &CastTy,
2189  SourceLocation &RParenLoc) {
2190  assert(Tok.is(tok::l_paren) && "Not a paren expr!");
2191  ColonProtectionRAIIObject ColonProtection(*this, false);
2192  BalancedDelimiterTracker T(*this, tok::l_paren);
2193  if (T.consumeOpen())
2194  return ExprError();
2195  SourceLocation OpenLoc = T.getOpenLocation();
2196 
2197  ExprResult Result(true);
2198  bool isAmbiguousTypeId;
2199  CastTy = nullptr;
2200 
2201  if (Tok.is(tok::code_completion)) {
2203  ExprType >= CompoundLiteral? Sema::PCC_ParenthesizedExpression
2205  cutOffParsing();
2206  return ExprError();
2207  }
2208 
2209  // Diagnose use of bridge casts in non-arc mode.
2210  bool BridgeCast = (getLangOpts().ObjC2 &&
2211  Tok.isOneOf(tok::kw___bridge,
2212  tok::kw___bridge_transfer,
2213  tok::kw___bridge_retained,
2214  tok::kw___bridge_retain));
2215  if (BridgeCast && !getLangOpts().ObjCAutoRefCount) {
2216  if (!TryConsumeToken(tok::kw___bridge)) {
2217  StringRef BridgeCastName = Tok.getName();
2218  SourceLocation BridgeKeywordLoc = ConsumeToken();
2219  if (!PP.getSourceManager().isInSystemHeader(BridgeKeywordLoc))
2220  Diag(BridgeKeywordLoc, diag::warn_arc_bridge_cast_nonarc)
2221  << BridgeCastName
2222  << FixItHint::CreateReplacement(BridgeKeywordLoc, "");
2223  }
2224  BridgeCast = false;
2225  }
2226 
2227  // None of these cases should fall through with an invalid Result
2228  // unless they've already reported an error.
2229  if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) {
2230  Diag(Tok, diag::ext_gnu_statement_expr);
2231 
2232  if (!getCurScope()->getFnParent() && !getCurScope()->getBlockParent()) {
2233  Result = ExprError(Diag(OpenLoc, diag::err_stmtexpr_file_scope));
2234  } else {
2235  // Find the nearest non-record decl context. Variables declared in a
2236  // statement expression behave as if they were declared in the enclosing
2237  // function, block, or other code construct.
2238  DeclContext *CodeDC = Actions.CurContext;
2239  while (CodeDC->isRecord() || isa<EnumDecl>(CodeDC)) {
2240  CodeDC = CodeDC->getParent();
2241  assert(CodeDC && !CodeDC->isFileContext() &&
2242  "statement expr not in code context");
2243  }
2244  Sema::ContextRAII SavedContext(Actions, CodeDC, /*NewThisContext=*/false);
2245 
2246  Actions.ActOnStartStmtExpr();
2247 
2248  StmtResult Stmt(ParseCompoundStatement(true));
2249  ExprType = CompoundStmt;
2250 
2251  // If the substmt parsed correctly, build the AST node.
2252  if (!Stmt.isInvalid()) {
2253  Result = Actions.ActOnStmtExpr(OpenLoc, Stmt.get(), Tok.getLocation());
2254  } else {
2255  Actions.ActOnStmtExprError();
2256  }
2257  }
2258  } else if (ExprType >= CompoundLiteral && BridgeCast) {
2259  tok::TokenKind tokenKind = Tok.getKind();
2260  SourceLocation BridgeKeywordLoc = ConsumeToken();
2261 
2262  // Parse an Objective-C ARC ownership cast expression.
2264  if (tokenKind == tok::kw___bridge)
2265  Kind = OBC_Bridge;
2266  else if (tokenKind == tok::kw___bridge_transfer)
2267  Kind = OBC_BridgeTransfer;
2268  else if (tokenKind == tok::kw___bridge_retained)
2269  Kind = OBC_BridgeRetained;
2270  else {
2271  // As a hopefully temporary workaround, allow __bridge_retain as
2272  // a synonym for __bridge_retained, but only in system headers.
2273  assert(tokenKind == tok::kw___bridge_retain);
2274  Kind = OBC_BridgeRetained;
2275  if (!PP.getSourceManager().isInSystemHeader(BridgeKeywordLoc))
2276  Diag(BridgeKeywordLoc, diag::err_arc_bridge_retain)
2277  << FixItHint::CreateReplacement(BridgeKeywordLoc,
2278  "__bridge_retained");
2279  }
2280 
2281  TypeResult Ty = ParseTypeName();
2282  T.consumeClose();
2283  ColonProtection.restore();
2284  RParenLoc = T.getCloseLocation();
2285  ExprResult SubExpr = ParseCastExpression(/*isUnaryExpression=*/false);
2286 
2287  if (Ty.isInvalid() || SubExpr.isInvalid())
2288  return ExprError();
2289 
2290  return Actions.ActOnObjCBridgedCast(getCurScope(), OpenLoc, Kind,
2291  BridgeKeywordLoc, Ty.get(),
2292  RParenLoc, SubExpr.get());
2293  } else if (ExprType >= CompoundLiteral &&
2294  isTypeIdInParens(isAmbiguousTypeId)) {
2295 
2296  // Otherwise, this is a compound literal expression or cast expression.
2297 
2298  // In C++, if the type-id is ambiguous we disambiguate based on context.
2299  // If stopIfCastExpr is true the context is a typeof/sizeof/alignof
2300  // in which case we should treat it as type-id.
2301  // if stopIfCastExpr is false, we need to determine the context past the
2302  // parens, so we defer to ParseCXXAmbiguousParenExpression for that.
2303  if (isAmbiguousTypeId && !stopIfCastExpr) {
2304  ExprResult res = ParseCXXAmbiguousParenExpression(ExprType, CastTy, T,
2305  ColonProtection);
2306  RParenLoc = T.getCloseLocation();
2307  return res;
2308  }
2309 
2310  // Parse the type declarator.
2311  DeclSpec DS(AttrFactory);
2312  ParseSpecifierQualifierList(DS);
2313  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
2314  ParseDeclarator(DeclaratorInfo);
2315 
2316  // If our type is followed by an identifier and either ':' or ']', then
2317  // this is probably an Objective-C message send where the leading '[' is
2318  // missing. Recover as if that were the case.
2319  if (!DeclaratorInfo.isInvalidType() && Tok.is(tok::identifier) &&
2320  !InMessageExpression && getLangOpts().ObjC1 &&
2321  (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) {
2322  TypeResult Ty;
2323  {
2324  InMessageExpressionRAIIObject InMessage(*this, false);
2325  Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
2326  }
2327  Result = ParseObjCMessageExpressionBody(SourceLocation(),
2328  SourceLocation(),
2329  Ty.get(), nullptr);
2330  } else {
2331  // Match the ')'.
2332  T.consumeClose();
2333  ColonProtection.restore();
2334  RParenLoc = T.getCloseLocation();
2335  if (Tok.is(tok::l_brace)) {
2336  ExprType = CompoundLiteral;
2337  TypeResult Ty;
2338  {
2339  InMessageExpressionRAIIObject InMessage(*this, false);
2340  Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
2341  }
2342  return ParseCompoundLiteralExpression(Ty.get(), OpenLoc, RParenLoc);
2343  }
2344 
2345  if (ExprType == CastExpr) {
2346  // We parsed '(' type-name ')' and the thing after it wasn't a '{'.
2347 
2348  if (DeclaratorInfo.isInvalidType())
2349  return ExprError();
2350 
2351  // Note that this doesn't parse the subsequent cast-expression, it just
2352  // returns the parsed type to the callee.
2353  if (stopIfCastExpr) {
2354  TypeResult Ty;
2355  {
2356  InMessageExpressionRAIIObject InMessage(*this, false);
2357  Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
2358  }
2359  CastTy = Ty.get();
2360  return ExprResult();
2361  }
2362 
2363  // Reject the cast of super idiom in ObjC.
2364  if (Tok.is(tok::identifier) && getLangOpts().ObjC1 &&
2365  Tok.getIdentifierInfo() == Ident_super &&
2367  GetLookAheadToken(1).isNot(tok::period)) {
2368  Diag(Tok.getLocation(), diag::err_illegal_super_cast)
2369  << SourceRange(OpenLoc, RParenLoc);
2370  return ExprError();
2371  }
2372 
2373  // Parse the cast-expression that follows it next.
2374  // TODO: For cast expression with CastTy.
2375  Result = ParseCastExpression(/*isUnaryExpression=*/false,
2376  /*isAddressOfOperand=*/false,
2377  /*isTypeCast=*/IsTypeCast);
2378  if (!Result.isInvalid()) {
2379  Result = Actions.ActOnCastExpr(getCurScope(), OpenLoc,
2380  DeclaratorInfo, CastTy,
2381  RParenLoc, Result.get());
2382  }
2383  return Result;
2384  }
2385 
2386  Diag(Tok, diag::err_expected_lbrace_in_compound_literal);
2387  return ExprError();
2388  }
2389  } else if (Tok.is(tok::ellipsis) &&
2391  return ParseFoldExpression(ExprResult(), T);
2392  } else if (isTypeCast) {
2393  // Parse the expression-list.
2394  InMessageExpressionRAIIObject InMessage(*this, false);
2395 
2396  ExprVector ArgExprs;
2397  CommaLocsTy CommaLocs;
2398 
2399  if (!ParseSimpleExpressionList(ArgExprs, CommaLocs)) {
2400  // FIXME: If we ever support comma expressions as operands to
2401  // fold-expressions, we'll need to allow multiple ArgExprs here.
2402  if (ArgExprs.size() == 1 && isFoldOperator(Tok.getKind()) &&
2403  NextToken().is(tok::ellipsis))
2404  return ParseFoldExpression(Result, T);
2405 
2406  ExprType = SimpleExpr;
2407  Result = Actions.ActOnParenListExpr(OpenLoc, Tok.getLocation(),
2408  ArgExprs);
2409  }
2410  } else {
2411  InMessageExpressionRAIIObject InMessage(*this, false);
2412 
2413  Result = ParseExpression(MaybeTypeCast);
2414  if (!getLangOpts().CPlusPlus && MaybeTypeCast && Result.isUsable()) {
2415  // Correct typos in non-C++ code earlier so that implicit-cast-like
2416  // expressions are parsed correctly.
2417  Result = Actions.CorrectDelayedTyposInExpr(Result);
2418  }
2419  ExprType = SimpleExpr;
2420 
2421  if (isFoldOperator(Tok.getKind()) && NextToken().is(tok::ellipsis))
2422  return ParseFoldExpression(Result, T);
2423 
2424  // Don't build a paren expression unless we actually match a ')'.
2425  if (!Result.isInvalid() && Tok.is(tok::r_paren))
2426  Result =
2427  Actions.ActOnParenExpr(OpenLoc, Tok.getLocation(), Result.get());
2428  }
2429 
2430  // Match the ')'.
2431  if (Result.isInvalid()) {
2432  SkipUntil(tok::r_paren, StopAtSemi);
2433  return ExprError();
2434  }
2435 
2436  T.consumeClose();
2437  RParenLoc = T.getCloseLocation();
2438  return Result;
2439 }
2440 
2441 /// ParseCompoundLiteralExpression - We have parsed the parenthesized type-name
2442 /// and we are at the left brace.
2443 ///
2444 /// \verbatim
2445 /// postfix-expression: [C99 6.5.2]
2446 /// '(' type-name ')' '{' initializer-list '}'
2447 /// '(' type-name ')' '{' initializer-list ',' '}'
2448 /// \endverbatim
2449 ExprResult
2450 Parser::ParseCompoundLiteralExpression(ParsedType Ty,
2451  SourceLocation LParenLoc,
2452  SourceLocation RParenLoc) {
2453  assert(Tok.is(tok::l_brace) && "Not a compound literal!");
2454  if (!getLangOpts().C99) // Compound literals don't exist in C90.
2455  Diag(LParenLoc, diag::ext_c99_compound_literal);
2456  ExprResult Result = ParseInitializer();
2457  if (!Result.isInvalid() && Ty)
2458  return Actions.ActOnCompoundLiteral(LParenLoc, Ty, RParenLoc, Result.get());
2459  return Result;
2460 }
2461 
2462 /// ParseStringLiteralExpression - This handles the various token types that
2463 /// form string literals, and also handles string concatenation [C99 5.1.1.2,
2464 /// translation phase #6].
2465 ///
2466 /// \verbatim
2467 /// primary-expression: [C99 6.5.1]
2468 /// string-literal
2469 /// \verbatim
2470 ExprResult Parser::ParseStringLiteralExpression(bool AllowUserDefinedLiteral) {
2471  assert(isTokenStringLiteral() && "Not a string literal!");
2472 
2473  // String concat. Note that keywords like __func__ and __FUNCTION__ are not
2474  // considered to be strings for concatenation purposes.
2475  SmallVector<Token, 4> StringToks;
2476 
2477  do {
2478  StringToks.push_back(Tok);
2479  ConsumeStringToken();
2480  } while (isTokenStringLiteral());
2481 
2482  // Pass the set of string tokens, ready for concatenation, to the actions.
2483  return Actions.ActOnStringLiteral(StringToks,
2484  AllowUserDefinedLiteral ? getCurScope()
2485  : nullptr);
2486 }
2487 
2488 /// ParseGenericSelectionExpression - Parse a C11 generic-selection
2489 /// [C11 6.5.1.1].
2490 ///
2491 /// \verbatim
2492 /// generic-selection:
2493 /// _Generic ( assignment-expression , generic-assoc-list )
2494 /// generic-assoc-list:
2495 /// generic-association
2496 /// generic-assoc-list , generic-association
2497 /// generic-association:
2498 /// type-name : assignment-expression
2499 /// default : assignment-expression
2500 /// \endverbatim
2501 ExprResult Parser::ParseGenericSelectionExpression() {
2502  assert(Tok.is(tok::kw__Generic) && "_Generic keyword expected");
2503  SourceLocation KeyLoc = ConsumeToken();
2504 
2505  if (!getLangOpts().C11)
2506  Diag(KeyLoc, diag::ext_c11_generic_selection);
2507 
2508  BalancedDelimiterTracker T(*this, tok::l_paren);
2509  if (T.expectAndConsume())
2510  return ExprError();
2511 
2512  ExprResult ControllingExpr;
2513  {
2514  // C11 6.5.1.1p3 "The controlling expression of a generic selection is
2515  // not evaluated."
2517  ControllingExpr =
2519  if (ControllingExpr.isInvalid()) {
2520  SkipUntil(tok::r_paren, StopAtSemi);
2521  return ExprError();
2522  }
2523  }
2524 
2525  if (ExpectAndConsume(tok::comma)) {
2526  SkipUntil(tok::r_paren, StopAtSemi);
2527  return ExprError();
2528  }
2529 
2530  SourceLocation DefaultLoc;
2531  TypeVector Types;
2532  ExprVector Exprs;
2533  do {
2534  ParsedType Ty;
2535  if (Tok.is(tok::kw_default)) {
2536  // C11 6.5.1.1p2 "A generic selection shall have no more than one default
2537  // generic association."
2538  if (!DefaultLoc.isInvalid()) {
2539  Diag(Tok, diag::err_duplicate_default_assoc);
2540  Diag(DefaultLoc, diag::note_previous_default_assoc);
2541  SkipUntil(tok::r_paren, StopAtSemi);
2542  return ExprError();
2543  }
2544  DefaultLoc = ConsumeToken();
2545  Ty = nullptr;
2546  } else {
2548  TypeResult TR = ParseTypeName();
2549  if (TR.isInvalid()) {
2550  SkipUntil(tok::r_paren, StopAtSemi);
2551  return ExprError();
2552  }
2553  Ty = TR.get();
2554  }
2555  Types.push_back(Ty);
2556 
2557  if (ExpectAndConsume(tok::colon)) {
2558  SkipUntil(tok::r_paren, StopAtSemi);
2559  return ExprError();
2560  }
2561 
2562  // FIXME: These expressions should be parsed in a potentially potentially
2563  // evaluated context.
2564  ExprResult ER(
2566  if (ER.isInvalid()) {
2567  SkipUntil(tok::r_paren, StopAtSemi);
2568  return ExprError();
2569  }
2570  Exprs.push_back(ER.get());
2571  } while (TryConsumeToken(tok::comma));
2572 
2573  T.consumeClose();
2574  if (T.getCloseLocation().isInvalid())
2575  return ExprError();
2576 
2577  return Actions.ActOnGenericSelectionExpr(KeyLoc, DefaultLoc,
2578  T.getCloseLocation(),
2579  ControllingExpr.get(),
2580  Types, Exprs);
2581 }
2582 
2583 /// \brief Parse A C++1z fold-expression after the opening paren and optional
2584 /// left-hand-side expression.
2585 ///
2586 /// \verbatim
2587 /// fold-expression:
2588 /// ( cast-expression fold-operator ... )
2589 /// ( ... fold-operator cast-expression )
2590 /// ( cast-expression fold-operator ... fold-operator cast-expression )
2591 ExprResult Parser::ParseFoldExpression(ExprResult LHS,
2593  if (LHS.isInvalid()) {
2594  T.skipToEnd();
2595  return true;
2596  }
2597 
2598  tok::TokenKind Kind = tok::unknown;
2599  SourceLocation FirstOpLoc;
2600  if (LHS.isUsable()) {
2601  Kind = Tok.getKind();
2602  assert(isFoldOperator(Kind) && "missing fold-operator");
2603  FirstOpLoc = ConsumeToken();
2604  }
2605 
2606  assert(Tok.is(tok::ellipsis) && "not a fold-expression");
2607  SourceLocation EllipsisLoc = ConsumeToken();
2608 
2609  ExprResult RHS;
2610  if (Tok.isNot(tok::r_paren)) {
2611  if (!isFoldOperator(Tok.getKind()))
2612  return Diag(Tok.getLocation(), diag::err_expected_fold_operator);
2613 
2614  if (Kind != tok::unknown && Tok.getKind() != Kind)
2615  Diag(Tok.getLocation(), diag::err_fold_operator_mismatch)
2616  << SourceRange(FirstOpLoc);
2617  Kind = Tok.getKind();
2618  ConsumeToken();
2619 
2620  RHS = ParseExpression();
2621  if (RHS.isInvalid()) {
2622  T.skipToEnd();
2623  return true;
2624  }
2625  }
2626 
2627  Diag(EllipsisLoc, getLangOpts().CPlusPlus1z
2628  ? diag::warn_cxx14_compat_fold_expression
2629  : diag::ext_fold_expression);
2630 
2631  T.consumeClose();
2632  return Actions.ActOnCXXFoldExpr(T.getOpenLocation(), LHS.get(), Kind,
2633  EllipsisLoc, RHS.get(), T.getCloseLocation());
2634 }
2635 
2636 /// ParseExpressionList - Used for C/C++ (argument-)expression-list.
2637 ///
2638 /// \verbatim
2639 /// argument-expression-list:
2640 /// assignment-expression
2641 /// argument-expression-list , assignment-expression
2642 ///
2643 /// [C++] expression-list:
2644 /// [C++] assignment-expression
2645 /// [C++] expression-list , assignment-expression
2646 ///
2647 /// [C++0x] expression-list:
2648 /// [C++0x] initializer-list
2649 ///
2650 /// [C++0x] initializer-list
2651 /// [C++0x] initializer-clause ...[opt]
2652 /// [C++0x] initializer-list , initializer-clause ...[opt]
2653 ///
2654 /// [C++0x] initializer-clause:
2655 /// [C++0x] assignment-expression
2656 /// [C++0x] braced-init-list
2657 /// \endverbatim
2658 bool Parser::ParseExpressionList(SmallVectorImpl<Expr *> &Exprs,
2660  std::function<void()> Completer) {
2661  bool SawError = false;
2662  while (1) {
2663  if (Tok.is(tok::code_completion)) {
2664  if (Completer)
2665  Completer();
2666  else
2668  cutOffParsing();
2669  return true;
2670  }
2671 
2672  ExprResult Expr;
2673  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
2674  Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
2675  Expr = ParseBraceInitializer();
2676  } else
2677  Expr = ParseAssignmentExpression();
2678 
2679  if (Tok.is(tok::ellipsis))
2680  Expr = Actions.ActOnPackExpansion(Expr.get(), ConsumeToken());
2681  if (Expr.isInvalid()) {
2682  SkipUntil(tok::comma, tok::r_paren, StopBeforeMatch);
2683  SawError = true;
2684  } else {
2685  Exprs.push_back(Expr.get());
2686  }
2687 
2688  if (Tok.isNot(tok::comma))
2689  break;
2690  // Move to the next argument, remember where the comma was.
2691  CommaLocs.push_back(ConsumeToken());
2692  }
2693  if (SawError) {
2694  // Ensure typos get diagnosed when errors were encountered while parsing the
2695  // expression list.
2696  for (auto &E : Exprs) {
2697  ExprResult Expr = Actions.CorrectDelayedTyposInExpr(E);
2698  if (Expr.isUsable()) E = Expr.get();
2699  }
2700  }
2701  return SawError;
2702 }
2703 
2704 /// ParseSimpleExpressionList - A simple comma-separated list of expressions,
2705 /// used for misc language extensions.
2706 ///
2707 /// \verbatim
2708 /// simple-expression-list:
2709 /// assignment-expression
2710 /// simple-expression-list , assignment-expression
2711 /// \endverbatim
2712 bool
2713 Parser::ParseSimpleExpressionList(SmallVectorImpl<Expr*> &Exprs,
2714  SmallVectorImpl<SourceLocation> &CommaLocs) {
2715  while (1) {
2717  if (Expr.isInvalid())
2718  return true;
2719 
2720  Exprs.push_back(Expr.get());
2721 
2722  if (Tok.isNot(tok::comma))
2723  return false;
2724 
2725  // Move to the next argument, remember where the comma was.
2726  CommaLocs.push_back(ConsumeToken());
2727  }
2728 }
2729 
2730 /// ParseBlockId - Parse a block-id, which roughly looks like int (int x).
2731 ///
2732 /// \verbatim
2733 /// [clang] block-id:
2734 /// [clang] specifier-qualifier-list block-declarator
2735 /// \endverbatim
2736 void Parser::ParseBlockId(SourceLocation CaretLoc) {
2737  if (Tok.is(tok::code_completion)) {
2739  return cutOffParsing();
2740  }
2741 
2742  // Parse the specifier-qualifier-list piece.
2743  DeclSpec DS(AttrFactory);
2744  ParseSpecifierQualifierList(DS);
2745 
2746  // Parse the block-declarator.
2747  Declarator DeclaratorInfo(DS, Declarator::BlockLiteralContext);
2748  ParseDeclarator(DeclaratorInfo);
2749 
2750  MaybeParseGNUAttributes(DeclaratorInfo);
2751 
2752  // Inform sema that we are starting a block.
2753  Actions.ActOnBlockArguments(CaretLoc, DeclaratorInfo, getCurScope());
2754 }
2755 
2756 /// ParseBlockLiteralExpression - Parse a block literal, which roughly looks
2757 /// like ^(int x){ return x+1; }
2758 ///
2759 /// \verbatim
2760 /// block-literal:
2761 /// [clang] '^' block-args[opt] compound-statement
2762 /// [clang] '^' block-id compound-statement
2763 /// [clang] block-args:
2764 /// [clang] '(' parameter-list ')'
2765 /// \endverbatim
2766 ExprResult Parser::ParseBlockLiteralExpression() {
2767  assert(Tok.is(tok::caret) && "block literal starts with ^");
2768  SourceLocation CaretLoc = ConsumeToken();
2769 
2770  PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), CaretLoc,
2771  "block literal parsing");
2772 
2773  // Enter a scope to hold everything within the block. This includes the
2774  // argument decls, decls within the compound expression, etc. This also
2775  // allows determining whether a variable reference inside the block is
2776  // within or outside of the block.
2777  ParseScope BlockScope(this, Scope::BlockScope | Scope::FnScope |
2779 
2780  // Inform sema that we are starting a block.
2781  Actions.ActOnBlockStart(CaretLoc, getCurScope());
2782 
2783  // Parse the return type if present.
2784  DeclSpec DS(AttrFactory);
2786  // FIXME: Since the return type isn't actually parsed, it can't be used to
2787  // fill ParamInfo with an initial valid range, so do it manually.
2788  ParamInfo.SetSourceRange(SourceRange(Tok.getLocation(), Tok.getLocation()));
2789 
2790  // If this block has arguments, parse them. There is no ambiguity here with
2791  // the expression case, because the expression case requires a parameter list.
2792  if (Tok.is(tok::l_paren)) {
2793  ParseParenDeclarator(ParamInfo);
2794  // Parse the pieces after the identifier as if we had "int(...)".
2795  // SetIdentifier sets the source range end, but in this case we're past
2796  // that location.
2797  SourceLocation Tmp = ParamInfo.getSourceRange().getEnd();
2798  ParamInfo.SetIdentifier(nullptr, CaretLoc);
2799  ParamInfo.SetRangeEnd(Tmp);
2800  if (ParamInfo.isInvalidType()) {
2801  // If there was an error parsing the arguments, they may have
2802  // tried to use ^(x+y) which requires an argument list. Just
2803  // skip the whole block literal.
2804  Actions.ActOnBlockError(CaretLoc, getCurScope());
2805  return ExprError();
2806  }
2807 
2808  MaybeParseGNUAttributes(ParamInfo);
2809 
2810  // Inform sema that we are starting a block.
2811  Actions.ActOnBlockArguments(CaretLoc, ParamInfo, getCurScope());
2812  } else if (!Tok.is(tok::l_brace)) {
2813  ParseBlockId(CaretLoc);
2814  } else {
2815  // Otherwise, pretend we saw (void).
2816  ParsedAttributes attrs(AttrFactory);
2817  SourceLocation NoLoc;
2818  ParamInfo.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/true,
2819  /*IsAmbiguous=*/false,
2820  /*RParenLoc=*/NoLoc,
2821  /*ArgInfo=*/nullptr,
2822  /*NumArgs=*/0,
2823  /*EllipsisLoc=*/NoLoc,
2824  /*RParenLoc=*/NoLoc,
2825  /*TypeQuals=*/0,
2826  /*RefQualifierIsLvalueRef=*/true,
2827  /*RefQualifierLoc=*/NoLoc,
2828  /*ConstQualifierLoc=*/NoLoc,
2829  /*VolatileQualifierLoc=*/NoLoc,
2830  /*RestrictQualifierLoc=*/NoLoc,
2831  /*MutableLoc=*/NoLoc,
2832  EST_None,
2833  /*ESpecRange=*/SourceRange(),
2834  /*Exceptions=*/nullptr,
2835  /*ExceptionRanges=*/nullptr,
2836  /*NumExceptions=*/0,
2837  /*NoexceptExpr=*/nullptr,
2838  /*ExceptionSpecTokens=*/nullptr,
2839  CaretLoc, CaretLoc,
2840  ParamInfo),
2841  attrs, CaretLoc);
2842 
2843  MaybeParseGNUAttributes(ParamInfo);
2844 
2845  // Inform sema that we are starting a block.
2846  Actions.ActOnBlockArguments(CaretLoc, ParamInfo, getCurScope());
2847  }
2848 
2849 
2850  ExprResult Result(true);
2851  if (!Tok.is(tok::l_brace)) {
2852  // Saw something like: ^expr
2853  Diag(Tok, diag::err_expected_expression);
2854  Actions.ActOnBlockError(CaretLoc, getCurScope());
2855  return ExprError();
2856  }
2857 
2858  StmtResult Stmt(ParseCompoundStatementBody());
2859  BlockScope.Exit();
2860  if (!Stmt.isInvalid())
2861  Result = Actions.ActOnBlockStmtExpr(CaretLoc, Stmt.get(), getCurScope());
2862  else
2863  Actions.ActOnBlockError(CaretLoc, getCurScope());
2864  return Result;
2865 }
2866 
2867 /// ParseObjCBoolLiteral - This handles the objective-c Boolean literals.
2868 ///
2869 /// '__objc_yes'
2870 /// '__objc_no'
2871 ExprResult Parser::ParseObjCBoolLiteral() {
2872  tok::TokenKind Kind = Tok.getKind();
2873  return Actions.ActOnObjCBoolLiteral(ConsumeToken(), Kind);
2874 }
2875 
2876 /// Validate availability spec list, emitting diagnostics if necessary. Returns
2877 /// true if invalid.
2879  ArrayRef<AvailabilitySpec> AvailSpecs) {
2880  llvm::SmallSet<StringRef, 4> Platforms;
2881  bool HasOtherPlatformSpec = false;
2882  bool Valid = true;
2883  for (const auto &Spec : AvailSpecs) {
2884  if (Spec.isOtherPlatformSpec()) {
2885  if (HasOtherPlatformSpec) {
2886  P.Diag(Spec.getBeginLoc(), diag::err_availability_query_repeated_star);
2887  Valid = false;
2888  }
2889 
2890  HasOtherPlatformSpec = true;
2891  continue;
2892  }
2893 
2894  bool Inserted = Platforms.insert(Spec.getPlatform()).second;
2895  if (!Inserted) {
2896  // Rule out multiple version specs referring to the same platform.
2897  // For example, we emit an error for:
2898  // @available(macos 10.10, macos 10.11, *)
2899  StringRef Platform = Spec.getPlatform();
2900  P.Diag(Spec.getBeginLoc(), diag::err_availability_query_repeated_platform)
2901  << Spec.getEndLoc() << Platform;
2902  Valid = false;
2903  }
2904  }
2905 
2906  if (!HasOtherPlatformSpec) {
2907  SourceLocation InsertWildcardLoc = AvailSpecs.back().getEndLoc();
2908  P.Diag(InsertWildcardLoc, diag::err_availability_query_wildcard_required)
2909  << FixItHint::CreateInsertion(InsertWildcardLoc, ", *");
2910  return true;
2911  }
2912 
2913  return !Valid;
2914 }
2915 
2916 /// Parse availability query specification.
2917 ///
2918 /// availability-spec:
2919 /// '*'
2920 /// identifier version-tuple
2921 Optional<AvailabilitySpec> Parser::ParseAvailabilitySpec() {
2922  if (Tok.is(tok::star)) {
2923  return AvailabilitySpec(ConsumeToken());
2924  } else {
2925  // Parse the platform name.
2926  if (Tok.isNot(tok::identifier)) {
2927  Diag(Tok, diag::err_avail_query_expected_platform_name);
2928  return None;
2929  }
2930 
2931  IdentifierLoc *PlatformIdentifier = ParseIdentifierLoc();
2932  SourceRange VersionRange;
2933  VersionTuple Version = ParseVersionTuple(VersionRange);
2934 
2935  if (Version.empty())
2936  return None;
2937 
2938  StringRef Platform = PlatformIdentifier->Ident->getName();
2939 
2940  if (AvailabilityAttr::getPrettyPlatformName(Platform).empty()) {
2941  Diag(PlatformIdentifier->Loc,
2942  diag::err_avail_query_unrecognized_platform_name)
2943  << Platform;
2944  return None;
2945  }
2946 
2947  return AvailabilitySpec(Version, Platform, PlatformIdentifier->Loc,
2948  VersionRange.getEnd());
2949  }
2950 }
2951 
2952 ExprResult Parser::ParseAvailabilityCheckExpr(SourceLocation BeginLoc) {
2953  assert(Tok.is(tok::kw___builtin_available) ||
2954  Tok.isObjCAtKeyword(tok::objc_available));
2955 
2956  // Eat the available or __builtin_available.
2957  ConsumeToken();
2958 
2959  BalancedDelimiterTracker Parens(*this, tok::l_paren);
2960  if (Parens.expectAndConsume())
2961  return ExprError();
2962 
2964  bool HasError = false;
2965  while (true) {
2966  Optional<AvailabilitySpec> Spec = ParseAvailabilitySpec();
2967  if (!Spec)
2968  HasError = true;
2969  else
2970  AvailSpecs.push_back(*Spec);
2971 
2972  if (!TryConsumeToken(tok::comma))
2973  break;
2974  }
2975 
2976  if (HasError) {
2977  SkipUntil(tok::r_paren, StopAtSemi);
2978  return ExprError();
2979  }
2980 
2981  CheckAvailabilitySpecList(*this, AvailSpecs);
2982 
2983  if (Parens.consumeClose())
2984  return ExprError();
2985 
2986  return Actions.ActOnObjCAvailabilityCheckExpr(AvailSpecs, BeginLoc,
2987  Parens.getCloseLocation());
2988 }
SourceManager & getSourceManager() const
Definition: Preprocessor.h:694
SourceLocation getCloseLocation() const
Defines the clang::ASTContext interface.
SourceLocation getEnd() const
ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr)
Definition: SemaExpr.cpp:5936
no exception specification
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
Definition: ParseExpr.cpp:120
unsigned Length
A (possibly-)qualified type.
Definition: Type.h:598
Simple class containing the result of Sema::CorrectTypo.
bool isInvalid() const
Definition: Ownership.h:160
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
ExprResult ActOnConditionalOp(SourceLocation QuestionLoc, SourceLocation ColonLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr)
ActOnConditionalOp - Parse a ?: operation.
Definition: SemaExpr.cpp:7007
ObjCBridgeCastKind
The kind of bridging performed by the Objective-C bridge cast.
const LangOptions & getLangOpts() const
Definition: Parse/Parser.h:251
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
Definition: SemaExpr.cpp:6107
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:223
Bridging via __bridge, which does nothing but reinterpret the bits.
ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:4135
void CodeCompleteAssignmentRHS(Scope *S, Expr *LHS)
ActionResult< Expr * > ExprResult
Definition: Ownership.h:253
void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo, Scope *CurScope)
ActOnBlockArguments - This callback allows processing of block arguments.
Definition: SemaExpr.cpp:11959
static bool CheckAvailabilitySpecList(Parser &P, ArrayRef< AvailabilitySpec > AvailSpecs)
Validate availability spec list, emitting diagnostics if necessary.
Definition: ParseExpr.cpp:2878
ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen, Expr *Operand, SourceLocation RParen)
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer...
Defines the PrettyStackTraceEntry class, which is used to make crashes give more contextual informati...
StringRef P
IdentifierInfo * Ident
Definition: AttributeList.h:74
bool isAtStartOfMacroExpansion(SourceLocation loc, SourceLocation *MacroBegin=nullptr) const
Returns true if the given MacroID location points at the first token of the macro expansion...
const char * getName() const
Definition: Token.h:165
PtrTy get() const
Definition: Ownership.h:164
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, unsigned TypeQuals, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation ConstQualifierLoc, SourceLocation VolatileQualifierLoc, SourceLocation RestrictQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult())
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
Definition: DeclSpec.cpp:152
ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty, SourceLocation RPLoc)
Definition: SemaExpr.cpp:12204
The base class of the type hierarchy.
Definition: Type.h:1281
This indicates that the scope corresponds to a function, which means that labels are set here...
Definition: Scope.h:46
ExprResult ActOnObjCBridgedCast(Scope *S, SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, ParsedType Type, SourceLocation RParenLoc, Expr *SubExpr)
TemplateNameKind Kind
The kind of template that Template refers to.
Parser - This implements a parser for the C family of languages.
Definition: Parse/Parser.h:57
TypeCastState
TypeCastState - State whether an expression is or may be a type cast.
ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc)
Definition: SemaExpr.cpp:12319
void CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef< Expr * > Args)
RAII object that enters a new expression evaluation context.
Definition: Sema.h:9606
void EnterToken(const Token &Tok)
Enters a token in the token stream to be lexed next.
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1624
#define REVERTIBLE_TYPE_TRAIT(Name)
void ActOnStartStmtExpr()
Definition: SemaExpr.cpp:11609
ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed...
StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const
Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...
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: Parse/Parser.h:885
SourceLocation Loc
Definition: AttributeList.h:73
Information about a template-id annotation token.
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5115
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parse/Parser.h:558
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parse/Parser.h:300
ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Kind, Expr *Input)
Definition: SemaExpr.cpp:4093
One of these records is kept for each identifier that is lexed.
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
ExprResult ExprEmpty()
Definition: Ownership.h:274
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
bool isFileID() const
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
Definition: TypeTraits.h:93
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc)
ActOnCXXNullPtrLiteral - Parse 'nullptr'.
void setKind(tok::TokenKind K)
Definition: Token.h:90
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ...
ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
Definition: SemaExpr.cpp:15068
SourceRange getExprRange(Expr *E) const
Definition: SemaExpr.cpp:500
Code completion occurs where only a type is permitted.
Definition: Sema.h:9213
ExprResult ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor)
This is a scope that corresponds to a block/closure object.
Definition: Scope.h:70
ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body, Scope *CurScope)
ActOnBlockStmtExpr - This is called when the body of a block statement literal was successfully compl...
Definition: SemaExpr.cpp:12088
ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, Expr *ControllingExpr, ArrayRef< ParsedType > ArgTypes, ArrayRef< Expr * > ArgExprs)
Definition: SemaExpr.cpp:1390
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:884
ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc, MultiExprArg ExecConfig, SourceLocation GGGLoc)
Definition: SemaCUDA.cpp:26
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
Definition: Type.h:5667
void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope)
ActOnBlockStart - This callback is invoked when a block literal is started.
Definition: SemaExpr.cpp:11932
void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool IsArrow)
Code completion occurs within an expression.
Definition: Sema.h:9198
ExprResult ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef< AvailabilitySpec > AvailSpecs, SourceLocation AtLoc, SourceLocation RParen)
Definition: SemaExpr.cpp:15087
If a crash happens while one of these objects are live, the message is printed out along with the spe...
ExprResult ActOnCXXFoldExpr(SourceLocation LParenLoc, Expr *LHS, tok::TokenKind Operator, SourceLocation EllipsisLoc, Expr *RHS, SourceLocation RParenLoc)
Handle a C++1z fold-expression: ( expr op ... op expr ).
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2632
LabelDecl * LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc, SourceLocation GnuLabelLoc=SourceLocation())
LookupOrCreateLabel - Do a name lookup of a label with the specified name.
tok::TokenKind getKind() const
Definition: Token.h:89
ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope=nullptr)
Definition: SemaExpr.cpp:3243
Bridging via __bridge_transfer, which transfers ownership of an Objective-C pointer into ARC...
bool isInvalid() const
void ActOnStmtExprError()
Definition: SemaExpr.cpp:11613
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:551
TypeResult ParseTypeName(SourceRange *Range=nullptr, Declarator::TheContext Context=Declarator::TypeNameContext, AccessSpecifier AS=AS_none, Decl **OwnedType=nullptr, ParsedAttributes *Attrs=nullptr)
ParseTypeName type-name: [C99 6.7.6] specifier-qualifier-list abstract-declarator[opt].
Definition: ParseDecl.cpp:44
ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, SourceLocation RParenLoc, Expr *InitExpr)
Definition: SemaExpr.cpp:5501
virtual bool ValidateCandidate(const TypoCorrection &candidate)
Simple predicate used by the default RankCandidate to determine whether to return an edit distance of...
ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:11191
const Type * getTypePtrOrNull() const
Definition: Type.h:5263
Expr - This represents one expression.
Definition: Expr.h:105
StringRef getName() const
Return the actual identifier string.
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type...
Definition: SemaDecl.cpp:249
This file defines the classes used to store parsed information about declaration-specifiers and decla...
TypeResult ActOnTypeName(Scope *S, Declarator &D)
Definition: SemaType.cpp:5212
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:123
bool isNot(tok::TokenKind K) const
Definition: Token.h:95
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1214
static bool isFoldOperator(prec::Level Level)
Definition: ParseExpr.cpp:239
ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr, SourceLocation RPLoc)
Definition: SemaExpr.cpp:11888
Wraps an identifier and optional source location for the identifier.
Definition: AttributeList.h:72
The result type of a method or function.
ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, SourceLocation EllipsisLoc)
Invoked when parsing a template argument followed by an ellipsis, which creates a pack expansion...
const SourceManager & SM
Definition: Format.cpp:1184
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:553
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
Definition: SemaExpr.cpp:3526
Kind
Stop skipping at semicolon.
Definition: Parse/Parser.h:865
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
Encodes a location in the source.
ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
__builtin_convertvector(...)
Definition: SemaExpr.cpp:5290
const TemplateArgument * iterator
Definition: Type.h:4233
bool isValid() const
Return true if this is a valid SourceLocation object.
ASTContext & getASTContext() const
Definition: Sema.h:1069
LabelDecl - Represents the declaration of a label.
Definition: Decl.h:424
Scope * getCurScope() const
Definition: Parse/Parser.h:258
ExprResult ActOnCharacterConstant(const Token &Tok, Scope *UDLScope=nullptr)
Definition: SemaExpr.cpp:3122
ExtensionRAIIObject - This saves the state of extension warnings when constructed and disables them...
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
ExprResult ActOnClassPropertyRefExpr(IdentifierInfo &receiverName, IdentifierInfo &propertyName, SourceLocation receiverNameLoc, SourceLocation propertyNameLoc)
ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLoc, Expr *Length, SourceLocation RBLoc)
Definition: SemaExpr.cpp:4210
bool isFileContext() const
Definition: DeclBase.h:1279
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:94
bool ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, ParsedType ObjectType, SourceLocation &TemplateKWLoc, UnqualifiedId &Result)
Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.
ExprResult ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, SourceLocation RPLoc)
Definition: SemaExpr.cpp:11622
SourceLocation getOpenLocation() const
QualType getType() const
Definition: Expr.h:126
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1135
ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op, Expr *Input)
Definition: SemaExpr.cpp:11572
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero)...
Definition: VersionTuple.h:69
ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
__builtin_astype(...)
Definition: SemaExpr.cpp:5269
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:104
ExprResult ParseConstraintExpression()
Parse a constraint-expression.
Definition: ParseExpr.cpp:216
detail::InMemoryDirectory::const_iterator E
bool isSimpleTypeSpecifier(tok::TokenKind Kind) const
Determine whether the token kind starts a simple-type-specifier.
Definition: SemaDecl.cpp:95
ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Member, Decl *ObjCImpDecl)
The main callback when the parser finds something like expression .
ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind)
Definition: SemaExpr.cpp:3106
Bridging via __bridge_retain, which makes an ARC object available as a +1 C pointer.
The name refers to a template whose specialization produces a type.
Definition: TemplateKinds.h:30
ExprResult ActOnConstantExpression(ExprResult Res)
Definition: SemaExpr.cpp:13822
bool isKeyword() const
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
bool isInObjcMethodScope() const
isInObjcMethodScope - Return true if this scope is, or is contained in, an Objective-C method body...
Definition: Scope.h:342
ExprResult ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, bool IsType, void *TyOrEx, SourceRange ArgRange)
ActOnUnaryExprOrTypeTraitExpr - Handle sizeof(type) and sizeof expr and the same for alignof and __al...
Definition: SemaExpr.cpp:4039
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:191
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:96
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E)
bool isFunctionType() const
Definition: Type.h:5479
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:254
void * getAsOpaquePtr() const
Definition: Ownership.h:85
ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)
Parse an expr that doesn't include (top-level) commas.
Definition: ParseExpr.cpp:157
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:78
ExprResult ActOnBuiltinOffsetOf(Scope *S, SourceLocation BuiltinLoc, SourceLocation TypeLoc, ParsedType ParsedArgTy, ArrayRef< OffsetOfComponent > Components, SourceLocation RParenLoc)
Definition: SemaExpr.cpp:11869
const Expr * Replacement
Definition: AttributeList.h:58
bool isUsable() const
Definition: Ownership.h:161
This is a scope that can contain a declaration.
Definition: Scope.h:58
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, std::unique_ptr< CorrectionCandidateCallback > CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
Definition: SemaExpr.cpp:2107
static ParsedType getTypeAnnotation(Token &Tok)
getTypeAnnotation - Read a parsed type out of an annotation token.
Definition: Parse/Parser.h:563
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:12171
ExprResult ParseConstantExpression(TypeCastState isTypeCast=NotTypeCast)
Definition: ParseExpr.cpp:197
bool hasRevertedTokenIDToIdentifier() const
True if revertTokenIDToIdentifier() was called.
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
Definition: Parse/Parser.h:292
void CodeCompletePostfixExpression(Scope *S, ExprResult LHS)
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
Definition: Sema.h:814
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, 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...
bool TryAnnotateTypeOrScopeToken(bool EnteringContext=false, bool NeedType=false)
TryAnnotateTypeOrScopeToken - If the current token position is on a typename (possibly qualified in C...
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:311
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:115
ExprResult ExprError()
Definition: Ownership.h:268
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:810
bool isRecord() const
Definition: DeclBase.h:1287
prec::Level getBinOpPrecedence(tok::TokenKind Kind, bool GreaterThanIsOperator, bool CPlusPlus11)
Return the precedence of the specified binary operator token.
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
Definition: Sema.h:799
ExprResult ActOnStringLiteral(ArrayRef< Token > StringToks, Scope *UDLScope=nullptr)
ActOnStringLiteral - The specified tokens were lexed as pasted string fragments (e.g.
Definition: SemaExpr.cpp:1604
A trivial tuple used to represent a source range.
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
Definition: DeclSpec.h:988
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:665
ExprResult ActOnSizeofParameterPackExpr(Scope *S, SourceLocation OpLoc, IdentifierInfo &Name, SourceLocation NameLoc, SourceLocation RParenLoc)
Called when an expression computing the size of a parameter pack is parsed.
ParsedAttributes - A collection of parsed attributes.
SourceLocation ColonLoc
Location of ':'.
Definition: OpenMPClause.h:266
This class handles loading and caching of source files into memory.
Code completion occurs in a parenthesized expression, which might also be a type cast.
Definition: Sema.h:9216
One specifier in an expression.
Definition: Availability.h:31
ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, LabelDecl *TheDecl)
ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Definition: SemaExpr.cpp:11578
void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope)
ActOnBlockError - If there is an error parsing a block, this callback is invoked to pop the informati...
Definition: SemaExpr.cpp:12076
Stop skipping at specified token, but don't skip the token itself.
Definition: Parse/Parser.h:867
A RAII object to temporarily push a declaration context.
Definition: Sema.h:634
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:176