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