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