xref: /freebsd/contrib/llvm-project/clang/lib/Parse/ParseExpr.cpp (revision 093cf790569775b80662926efea6d9d3464bde94)
1 //===--- ParseExpr.cpp - Expression Parsing -------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// Provides the Expression parsing implementation.
11 ///
12 /// Expressions in C99 basically consist of a bunch of binary operators with
13 /// unary operators and other random stuff at the leaves.
14 ///
15 /// In the C99 grammar, these unary operators bind tightest and are represented
16 /// as the 'cast-expression' production.  Everything else is either a binary
17 /// operator (e.g. '/') or a ternary operator ("?:").  The unary leaves are
18 /// handled by ParseCastExpression, the higher level pieces are handled by
19 /// ParseBinaryExpression.
20 ///
21 //===----------------------------------------------------------------------===//
22 
23 #include "clang/Parse/Parser.h"
24 #include "clang/AST/ASTContext.h"
25 #include "clang/AST/ExprCXX.h"
26 #include "clang/Basic/PrettyStackTrace.h"
27 #include "clang/Parse/RAIIObjectsForParser.h"
28 #include "clang/Sema/DeclSpec.h"
29 #include "clang/Sema/ParsedTemplate.h"
30 #include "clang/Sema/Scope.h"
31 #include "clang/Sema/TypoCorrection.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
123 ExprResult Parser::ParseExpression(TypeCastState isTypeCast) {
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 ///
133 ExprResult
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.
142 ExprResult
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(AnyCastExpr);
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.
160 ExprResult Parser::ParseAssignmentExpression(TypeCastState isTypeCast) {
161   if (Tok.is(tok::code_completion)) {
162     cutOffParsing();
163     Actions.CodeCompleteExpression(getCurScope(),
164                                    PreferredType.get(Tok.getLocation()));
165     return ExprError();
166   }
167 
168   if (Tok.is(tok::kw_throw))
169     return ParseThrowExpression();
170   if (Tok.is(tok::kw_co_yield))
171     return ParseCoyieldExpression();
172 
173   ExprResult LHS = ParseCastExpression(AnyCastExpr,
174                                        /*isAddressOfOperand=*/false,
175                                        isTypeCast);
176   return ParseRHSOfBinaryExpression(LHS, prec::Assignment);
177 }
178 
179 /// Parse an assignment expression where part of an Objective-C message
180 /// send has already been parsed.
181 ///
182 /// In this case \p LBracLoc indicates the location of the '[' of the message
183 /// send, and either \p ReceiverName or \p ReceiverExpr is non-null indicating
184 /// the receiver of the message.
185 ///
186 /// Since this handles full assignment-expression's, it handles postfix
187 /// expressions and other binary operators for these expressions as well.
188 ExprResult
189 Parser::ParseAssignmentExprWithObjCMessageExprStart(SourceLocation LBracLoc,
190                                                     SourceLocation SuperLoc,
191                                                     ParsedType ReceiverType,
192                                                     Expr *ReceiverExpr) {
193   ExprResult R
194     = ParseObjCMessageExpressionBody(LBracLoc, SuperLoc,
195                                      ReceiverType, ReceiverExpr);
196   R = ParsePostfixExpressionSuffix(R);
197   return ParseRHSOfBinaryExpression(R, prec::Assignment);
198 }
199 
200 ExprResult
201 Parser::ParseConstantExpressionInExprEvalContext(TypeCastState isTypeCast) {
202   assert(Actions.ExprEvalContexts.back().Context ==
203              Sema::ExpressionEvaluationContext::ConstantEvaluated &&
204          "Call this function only if your ExpressionEvaluationContext is "
205          "already ConstantEvaluated");
206   ExprResult LHS(ParseCastExpression(AnyCastExpr, false, isTypeCast));
207   ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::Conditional));
208   return Actions.ActOnConstantExpression(Res);
209 }
210 
211 ExprResult Parser::ParseConstantExpression(TypeCastState isTypeCast) {
212   // C++03 [basic.def.odr]p2:
213   //   An expression is potentially evaluated unless it appears where an
214   //   integral constant expression is required (see 5.19) [...].
215   // C++98 and C++11 have no such rule, but this is only a defect in C++98.
216   EnterExpressionEvaluationContext ConstantEvaluated(
217       Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
218   return ParseConstantExpressionInExprEvalContext(isTypeCast);
219 }
220 
221 ExprResult Parser::ParseCaseExpression(SourceLocation CaseLoc) {
222   EnterExpressionEvaluationContext ConstantEvaluated(
223       Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
224   ExprResult LHS(ParseCastExpression(AnyCastExpr, false, NotTypeCast));
225   ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::Conditional));
226   return Actions.ActOnCaseExpr(CaseLoc, Res);
227 }
228 
229 /// Parse a constraint-expression.
230 ///
231 /// \verbatim
232 ///       constraint-expression: C++2a[temp.constr.decl]p1
233 ///         logical-or-expression
234 /// \endverbatim
235 ExprResult Parser::ParseConstraintExpression() {
236   EnterExpressionEvaluationContext ConstantEvaluated(
237       Actions, Sema::ExpressionEvaluationContext::Unevaluated);
238   ExprResult LHS(ParseCastExpression(AnyCastExpr));
239   ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::LogicalOr));
240   if (Res.isUsable() && !Actions.CheckConstraintExpression(Res.get())) {
241     Actions.CorrectDelayedTyposInExpr(Res);
242     return ExprError();
243   }
244   return Res;
245 }
246 
247 /// \brief Parse a constraint-logical-and-expression.
248 ///
249 /// \verbatim
250 ///       C++2a[temp.constr.decl]p1
251 ///       constraint-logical-and-expression:
252 ///         primary-expression
253 ///         constraint-logical-and-expression '&&' primary-expression
254 ///
255 /// \endverbatim
256 ExprResult
257 Parser::ParseConstraintLogicalAndExpression(bool IsTrailingRequiresClause) {
258   EnterExpressionEvaluationContext ConstantEvaluated(
259       Actions, Sema::ExpressionEvaluationContext::Unevaluated);
260   bool NotPrimaryExpression = false;
261   auto ParsePrimary = [&] () {
262     ExprResult E = ParseCastExpression(PrimaryExprOnly,
263                                        /*isAddressOfOperand=*/false,
264                                        /*isTypeCast=*/NotTypeCast,
265                                        /*isVectorLiteral=*/false,
266                                        &NotPrimaryExpression);
267     if (E.isInvalid())
268       return ExprError();
269     auto RecoverFromNonPrimary = [&] (ExprResult E, bool Note) {
270         E = ParsePostfixExpressionSuffix(E);
271         // Use InclusiveOr, the precedence just after '&&' to not parse the
272         // next arguments to the logical and.
273         E = ParseRHSOfBinaryExpression(E, prec::InclusiveOr);
274         if (!E.isInvalid())
275           Diag(E.get()->getExprLoc(),
276                Note
277                ? diag::note_unparenthesized_non_primary_expr_in_requires_clause
278                : diag::err_unparenthesized_non_primary_expr_in_requires_clause)
279                << FixItHint::CreateInsertion(E.get()->getBeginLoc(), "(")
280                << FixItHint::CreateInsertion(
281                    PP.getLocForEndOfToken(E.get()->getEndLoc()), ")")
282                << E.get()->getSourceRange();
283         return E;
284     };
285 
286     if (NotPrimaryExpression ||
287         // Check if the following tokens must be a part of a non-primary
288         // expression
289         getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator,
290                            /*CPlusPlus11=*/true) > prec::LogicalAnd ||
291         // Postfix operators other than '(' (which will be checked for in
292         // CheckConstraintExpression).
293         Tok.isOneOf(tok::period, tok::plusplus, tok::minusminus) ||
294         (Tok.is(tok::l_square) && !NextToken().is(tok::l_square))) {
295       E = RecoverFromNonPrimary(E, /*Note=*/false);
296       if (E.isInvalid())
297         return ExprError();
298       NotPrimaryExpression = false;
299     }
300     bool PossibleNonPrimary;
301     bool IsConstraintExpr =
302         Actions.CheckConstraintExpression(E.get(), Tok, &PossibleNonPrimary,
303                                           IsTrailingRequiresClause);
304     if (!IsConstraintExpr || PossibleNonPrimary) {
305       // Atomic constraint might be an unparenthesized non-primary expression
306       // (such as a binary operator), in which case we might get here (e.g. in
307       // 'requires 0 + 1 && true' we would now be at '+', and parse and ignore
308       // the rest of the addition expression). Try to parse the rest of it here.
309       if (PossibleNonPrimary)
310         E = RecoverFromNonPrimary(E, /*Note=*/!IsConstraintExpr);
311       Actions.CorrectDelayedTyposInExpr(E);
312       return ExprError();
313     }
314     return E;
315   };
316   ExprResult LHS = ParsePrimary();
317   if (LHS.isInvalid())
318     return ExprError();
319   while (Tok.is(tok::ampamp)) {
320     SourceLocation LogicalAndLoc = ConsumeToken();
321     ExprResult RHS = ParsePrimary();
322     if (RHS.isInvalid()) {
323       Actions.CorrectDelayedTyposInExpr(LHS);
324       return ExprError();
325     }
326     ExprResult Op = Actions.ActOnBinOp(getCurScope(), LogicalAndLoc,
327                                        tok::ampamp, LHS.get(), RHS.get());
328     if (!Op.isUsable()) {
329       Actions.CorrectDelayedTyposInExpr(RHS);
330       Actions.CorrectDelayedTyposInExpr(LHS);
331       return ExprError();
332     }
333     LHS = Op;
334   }
335   return LHS;
336 }
337 
338 /// \brief Parse a constraint-logical-or-expression.
339 ///
340 /// \verbatim
341 ///       C++2a[temp.constr.decl]p1
342 ///       constraint-logical-or-expression:
343 ///         constraint-logical-and-expression
344 ///         constraint-logical-or-expression '||'
345 ///             constraint-logical-and-expression
346 ///
347 /// \endverbatim
348 ExprResult
349 Parser::ParseConstraintLogicalOrExpression(bool IsTrailingRequiresClause) {
350   ExprResult LHS(ParseConstraintLogicalAndExpression(IsTrailingRequiresClause));
351   if (!LHS.isUsable())
352     return ExprError();
353   while (Tok.is(tok::pipepipe)) {
354     SourceLocation LogicalOrLoc = ConsumeToken();
355     ExprResult RHS =
356         ParseConstraintLogicalAndExpression(IsTrailingRequiresClause);
357     if (!RHS.isUsable()) {
358       Actions.CorrectDelayedTyposInExpr(LHS);
359       return ExprError();
360     }
361     ExprResult Op = Actions.ActOnBinOp(getCurScope(), LogicalOrLoc,
362                                        tok::pipepipe, LHS.get(), RHS.get());
363     if (!Op.isUsable()) {
364       Actions.CorrectDelayedTyposInExpr(RHS);
365       Actions.CorrectDelayedTyposInExpr(LHS);
366       return ExprError();
367     }
368     LHS = Op;
369   }
370   return LHS;
371 }
372 
373 bool Parser::isNotExpressionStart() {
374   tok::TokenKind K = Tok.getKind();
375   if (K == tok::l_brace || K == tok::r_brace  ||
376       K == tok::kw_for  || K == tok::kw_while ||
377       K == tok::kw_if   || K == tok::kw_else  ||
378       K == tok::kw_goto || K == tok::kw_try)
379     return true;
380   // If this is a decl-specifier, we can't be at the start of an expression.
381   return isKnownToBeDeclarationSpecifier();
382 }
383 
384 bool Parser::isFoldOperator(prec::Level Level) const {
385   return Level > prec::Unknown && Level != prec::Conditional &&
386          Level != prec::Spaceship;
387 }
388 
389 bool Parser::isFoldOperator(tok::TokenKind Kind) const {
390   return isFoldOperator(getBinOpPrecedence(Kind, GreaterThanIsOperator, true));
391 }
392 
393 /// Parse a binary expression that starts with \p LHS and has a
394 /// precedence of at least \p MinPrec.
395 ExprResult
396 Parser::ParseRHSOfBinaryExpression(ExprResult LHS, prec::Level MinPrec) {
397   prec::Level NextTokPrec = getBinOpPrecedence(Tok.getKind(),
398                                                GreaterThanIsOperator,
399                                                getLangOpts().CPlusPlus11);
400   SourceLocation ColonLoc;
401 
402   auto SavedType = PreferredType;
403   while (1) {
404     // Every iteration may rely on a preferred type for the whole expression.
405     PreferredType = SavedType;
406     // If this token has a lower precedence than we are allowed to parse (e.g.
407     // because we are called recursively, or because the token is not a binop),
408     // then we are done!
409     if (NextTokPrec < MinPrec)
410       return LHS;
411 
412     // Consume the operator, saving the operator token for error reporting.
413     Token OpToken = Tok;
414     ConsumeToken();
415 
416     if (OpToken.is(tok::caretcaret)) {
417       return ExprError(Diag(Tok, diag::err_opencl_logical_exclusive_or));
418     }
419 
420     // If we're potentially in a template-id, we may now be able to determine
421     // whether we're actually in one or not.
422     if (OpToken.isOneOf(tok::comma, tok::greater, tok::greatergreater,
423                         tok::greatergreatergreater) &&
424         checkPotentialAngleBracketDelimiter(OpToken))
425       return ExprError();
426 
427     // Bail out when encountering a comma followed by a token which can't
428     // possibly be the start of an expression. For instance:
429     //   int f() { return 1, }
430     // We can't do this before consuming the comma, because
431     // isNotExpressionStart() looks at the token stream.
432     if (OpToken.is(tok::comma) && isNotExpressionStart()) {
433       PP.EnterToken(Tok, /*IsReinject*/true);
434       Tok = OpToken;
435       return LHS;
436     }
437 
438     // If the next token is an ellipsis, then this is a fold-expression. Leave
439     // it alone so we can handle it in the paren expression.
440     if (isFoldOperator(NextTokPrec) && Tok.is(tok::ellipsis)) {
441       // FIXME: We can't check this via lookahead before we consume the token
442       // because that tickles a lexer bug.
443       PP.EnterToken(Tok, /*IsReinject*/true);
444       Tok = OpToken;
445       return LHS;
446     }
447 
448     // In Objective-C++, alternative operator tokens can be used as keyword args
449     // in message expressions. Unconsume the token so that it can reinterpreted
450     // as an identifier in ParseObjCMessageExpressionBody. i.e., we support:
451     //   [foo meth:0 and:0];
452     //   [foo not_eq];
453     if (getLangOpts().ObjC && getLangOpts().CPlusPlus &&
454         Tok.isOneOf(tok::colon, tok::r_square) &&
455         OpToken.getIdentifierInfo() != nullptr) {
456       PP.EnterToken(Tok, /*IsReinject*/true);
457       Tok = OpToken;
458       return LHS;
459     }
460 
461     // Special case handling for the ternary operator.
462     ExprResult TernaryMiddle(true);
463     if (NextTokPrec == prec::Conditional) {
464       if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
465         // Parse a braced-init-list here for error recovery purposes.
466         SourceLocation BraceLoc = Tok.getLocation();
467         TernaryMiddle = ParseBraceInitializer();
468         if (!TernaryMiddle.isInvalid()) {
469           Diag(BraceLoc, diag::err_init_list_bin_op)
470               << /*RHS*/ 1 << PP.getSpelling(OpToken)
471               << Actions.getExprRange(TernaryMiddle.get());
472           TernaryMiddle = ExprError();
473         }
474       } else if (Tok.isNot(tok::colon)) {
475         // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
476         ColonProtectionRAIIObject X(*this);
477 
478         // Handle this production specially:
479         //   logical-OR-expression '?' expression ':' conditional-expression
480         // In particular, the RHS of the '?' is 'expression', not
481         // 'logical-OR-expression' as we might expect.
482         TernaryMiddle = ParseExpression();
483       } else {
484         // Special case handling of "X ? Y : Z" where Y is empty:
485         //   logical-OR-expression '?' ':' conditional-expression   [GNU]
486         TernaryMiddle = nullptr;
487         Diag(Tok, diag::ext_gnu_conditional_expr);
488       }
489 
490       if (TernaryMiddle.isInvalid()) {
491         Actions.CorrectDelayedTyposInExpr(LHS);
492         LHS = ExprError();
493         TernaryMiddle = nullptr;
494       }
495 
496       if (!TryConsumeToken(tok::colon, ColonLoc)) {
497         // Otherwise, we're missing a ':'.  Assume that this was a typo that
498         // the user forgot. If we're not in a macro expansion, we can suggest
499         // a fixit hint. If there were two spaces before the current token,
500         // suggest inserting the colon in between them, otherwise insert ": ".
501         SourceLocation FILoc = Tok.getLocation();
502         const char *FIText = ": ";
503         const SourceManager &SM = PP.getSourceManager();
504         if (FILoc.isFileID() || PP.isAtStartOfMacroExpansion(FILoc, &FILoc)) {
505           assert(FILoc.isFileID());
506           bool IsInvalid = false;
507           const char *SourcePtr =
508             SM.getCharacterData(FILoc.getLocWithOffset(-1), &IsInvalid);
509           if (!IsInvalid && *SourcePtr == ' ') {
510             SourcePtr =
511               SM.getCharacterData(FILoc.getLocWithOffset(-2), &IsInvalid);
512             if (!IsInvalid && *SourcePtr == ' ') {
513               FILoc = FILoc.getLocWithOffset(-1);
514               FIText = ":";
515             }
516           }
517         }
518 
519         Diag(Tok, diag::err_expected)
520             << tok::colon << FixItHint::CreateInsertion(FILoc, FIText);
521         Diag(OpToken, diag::note_matching) << tok::question;
522         ColonLoc = Tok.getLocation();
523       }
524     }
525 
526     PreferredType.enterBinary(Actions, Tok.getLocation(), LHS.get(),
527                               OpToken.getKind());
528     // Parse another leaf here for the RHS of the operator.
529     // ParseCastExpression works here because all RHS expressions in C have it
530     // as a prefix, at least. However, in C++, an assignment-expression could
531     // be a throw-expression, which is not a valid cast-expression.
532     // Therefore we need some special-casing here.
533     // Also note that the third operand of the conditional operator is
534     // an assignment-expression in C++, and in C++11, we can have a
535     // braced-init-list on the RHS of an assignment. For better diagnostics,
536     // parse as if we were allowed braced-init-lists everywhere, and check that
537     // they only appear on the RHS of assignments later.
538     ExprResult RHS;
539     bool RHSIsInitList = false;
540     if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
541       RHS = ParseBraceInitializer();
542       RHSIsInitList = true;
543     } else if (getLangOpts().CPlusPlus && NextTokPrec <= prec::Conditional)
544       RHS = ParseAssignmentExpression();
545     else
546       RHS = ParseCastExpression(AnyCastExpr);
547 
548     if (RHS.isInvalid()) {
549       // FIXME: Errors generated by the delayed typo correction should be
550       // printed before errors from parsing the RHS, not after.
551       Actions.CorrectDelayedTyposInExpr(LHS);
552       if (TernaryMiddle.isUsable())
553         TernaryMiddle = Actions.CorrectDelayedTyposInExpr(TernaryMiddle);
554       LHS = ExprError();
555     }
556 
557     // Remember the precedence of this operator and get the precedence of the
558     // operator immediately to the right of the RHS.
559     prec::Level ThisPrec = NextTokPrec;
560     NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator,
561                                      getLangOpts().CPlusPlus11);
562 
563     // Assignment and conditional expressions are right-associative.
564     bool isRightAssoc = ThisPrec == prec::Conditional ||
565                         ThisPrec == prec::Assignment;
566 
567     // Get the precedence of the operator to the right of the RHS.  If it binds
568     // more tightly with RHS than we do, evaluate it completely first.
569     if (ThisPrec < NextTokPrec ||
570         (ThisPrec == NextTokPrec && isRightAssoc)) {
571       if (!RHS.isInvalid() && RHSIsInitList) {
572         Diag(Tok, diag::err_init_list_bin_op)
573           << /*LHS*/0 << PP.getSpelling(Tok) << Actions.getExprRange(RHS.get());
574         RHS = ExprError();
575       }
576       // If this is left-associative, only parse things on the RHS that bind
577       // more tightly than the current operator.  If it is left-associative, it
578       // is okay, to bind exactly as tightly.  For example, compile A=B=C=D as
579       // A=(B=(C=D)), where each paren is a level of recursion here.
580       // The function takes ownership of the RHS.
581       RHS = ParseRHSOfBinaryExpression(RHS,
582                             static_cast<prec::Level>(ThisPrec + !isRightAssoc));
583       RHSIsInitList = false;
584 
585       if (RHS.isInvalid()) {
586         // FIXME: Errors generated by the delayed typo correction should be
587         // printed before errors from ParseRHSOfBinaryExpression, not after.
588         Actions.CorrectDelayedTyposInExpr(LHS);
589         if (TernaryMiddle.isUsable())
590           TernaryMiddle = Actions.CorrectDelayedTyposInExpr(TernaryMiddle);
591         LHS = ExprError();
592       }
593 
594       NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator,
595                                        getLangOpts().CPlusPlus11);
596     }
597 
598     if (!RHS.isInvalid() && RHSIsInitList) {
599       if (ThisPrec == prec::Assignment) {
600         Diag(OpToken, diag::warn_cxx98_compat_generalized_initializer_lists)
601           << Actions.getExprRange(RHS.get());
602       } else if (ColonLoc.isValid()) {
603         Diag(ColonLoc, diag::err_init_list_bin_op)
604           << /*RHS*/1 << ":"
605           << Actions.getExprRange(RHS.get());
606         LHS = ExprError();
607       } else {
608         Diag(OpToken, diag::err_init_list_bin_op)
609           << /*RHS*/1 << PP.getSpelling(OpToken)
610           << Actions.getExprRange(RHS.get());
611         LHS = ExprError();
612       }
613     }
614 
615     ExprResult OrigLHS = LHS;
616     if (!LHS.isInvalid()) {
617       // Combine the LHS and RHS into the LHS (e.g. build AST).
618       if (TernaryMiddle.isInvalid()) {
619         // If we're using '>>' as an operator within a template
620         // argument list (in C++98), suggest the addition of
621         // parentheses so that the code remains well-formed in C++0x.
622         if (!GreaterThanIsOperator && OpToken.is(tok::greatergreater))
623           SuggestParentheses(OpToken.getLocation(),
624                              diag::warn_cxx11_right_shift_in_template_arg,
625                          SourceRange(Actions.getExprRange(LHS.get()).getBegin(),
626                                      Actions.getExprRange(RHS.get()).getEnd()));
627 
628         ExprResult BinOp =
629             Actions.ActOnBinOp(getCurScope(), OpToken.getLocation(),
630                                OpToken.getKind(), LHS.get(), RHS.get());
631         if (BinOp.isInvalid())
632           BinOp = Actions.CreateRecoveryExpr(LHS.get()->getBeginLoc(),
633                                              RHS.get()->getEndLoc(),
634                                              {LHS.get(), RHS.get()});
635 
636         LHS = BinOp;
637       } else {
638         ExprResult CondOp = Actions.ActOnConditionalOp(
639             OpToken.getLocation(), ColonLoc, LHS.get(), TernaryMiddle.get(),
640             RHS.get());
641         if (CondOp.isInvalid()) {
642           std::vector<clang::Expr *> Args;
643           // TernaryMiddle can be null for the GNU conditional expr extension.
644           if (TernaryMiddle.get())
645             Args = {LHS.get(), TernaryMiddle.get(), RHS.get()};
646           else
647             Args = {LHS.get(), RHS.get()};
648           CondOp = Actions.CreateRecoveryExpr(LHS.get()->getBeginLoc(),
649                                               RHS.get()->getEndLoc(), Args);
650         }
651 
652         LHS = CondOp;
653       }
654       // In this case, ActOnBinOp or ActOnConditionalOp performed the
655       // CorrectDelayedTyposInExpr check.
656       if (!getLangOpts().CPlusPlus)
657         continue;
658     }
659 
660     // Ensure potential typos aren't left undiagnosed.
661     if (LHS.isInvalid()) {
662       Actions.CorrectDelayedTyposInExpr(OrigLHS);
663       Actions.CorrectDelayedTyposInExpr(TernaryMiddle);
664       Actions.CorrectDelayedTyposInExpr(RHS);
665     }
666   }
667 }
668 
669 /// Parse a cast-expression, unary-expression or primary-expression, based
670 /// on \p ExprType.
671 ///
672 /// \p isAddressOfOperand exists because an id-expression that is the
673 /// operand of address-of gets special treatment due to member pointers.
674 ///
675 ExprResult Parser::ParseCastExpression(CastParseKind ParseKind,
676                                        bool isAddressOfOperand,
677                                        TypeCastState isTypeCast,
678                                        bool isVectorLiteral,
679                                        bool *NotPrimaryExpression) {
680   bool NotCastExpr;
681   ExprResult Res = ParseCastExpression(ParseKind,
682                                        isAddressOfOperand,
683                                        NotCastExpr,
684                                        isTypeCast,
685                                        isVectorLiteral,
686                                        NotPrimaryExpression);
687   if (NotCastExpr)
688     Diag(Tok, diag::err_expected_expression);
689   return Res;
690 }
691 
692 namespace {
693 class CastExpressionIdValidator final : public CorrectionCandidateCallback {
694  public:
695   CastExpressionIdValidator(Token Next, bool AllowTypes, bool AllowNonTypes)
696       : NextToken(Next), AllowNonTypes(AllowNonTypes) {
697     WantTypeSpecifiers = WantFunctionLikeCasts = AllowTypes;
698   }
699 
700   bool ValidateCandidate(const TypoCorrection &candidate) override {
701     NamedDecl *ND = candidate.getCorrectionDecl();
702     if (!ND)
703       return candidate.isKeyword();
704 
705     if (isa<TypeDecl>(ND))
706       return WantTypeSpecifiers;
707 
708     if (!AllowNonTypes || !CorrectionCandidateCallback::ValidateCandidate(candidate))
709       return false;
710 
711     if (!NextToken.isOneOf(tok::equal, tok::arrow, tok::period))
712       return true;
713 
714     for (auto *C : candidate) {
715       NamedDecl *ND = C->getUnderlyingDecl();
716       if (isa<ValueDecl>(ND) && !isa<FunctionDecl>(ND))
717         return true;
718     }
719     return false;
720   }
721 
722   std::unique_ptr<CorrectionCandidateCallback> clone() override {
723     return std::make_unique<CastExpressionIdValidator>(*this);
724   }
725 
726  private:
727   Token NextToken;
728   bool AllowNonTypes;
729 };
730 }
731 
732 /// Parse a cast-expression, or, if \pisUnaryExpression is true, parse
733 /// a unary-expression.
734 ///
735 /// \p isAddressOfOperand exists because an id-expression that is the operand
736 /// of address-of gets special treatment due to member pointers. NotCastExpr
737 /// is set to true if the token is not the start of a cast-expression, and no
738 /// diagnostic is emitted in this case and no tokens are consumed.
739 ///
740 /// \verbatim
741 ///       cast-expression: [C99 6.5.4]
742 ///         unary-expression
743 ///         '(' type-name ')' cast-expression
744 ///
745 ///       unary-expression:  [C99 6.5.3]
746 ///         postfix-expression
747 ///         '++' unary-expression
748 ///         '--' unary-expression
749 /// [Coro]  'co_await' cast-expression
750 ///         unary-operator cast-expression
751 ///         'sizeof' unary-expression
752 ///         'sizeof' '(' type-name ')'
753 /// [C++11] 'sizeof' '...' '(' identifier ')'
754 /// [GNU]   '__alignof' unary-expression
755 /// [GNU]   '__alignof' '(' type-name ')'
756 /// [C11]   '_Alignof' '(' type-name ')'
757 /// [C++11] 'alignof' '(' type-id ')'
758 /// [GNU]   '&&' identifier
759 /// [C++11] 'noexcept' '(' expression ')' [C++11 5.3.7]
760 /// [C++]   new-expression
761 /// [C++]   delete-expression
762 ///
763 ///       unary-operator: one of
764 ///         '&'  '*'  '+'  '-'  '~'  '!'
765 /// [GNU]   '__extension__'  '__real'  '__imag'
766 ///
767 ///       primary-expression: [C99 6.5.1]
768 /// [C99]   identifier
769 /// [C++]   id-expression
770 ///         constant
771 ///         string-literal
772 /// [C++]   boolean-literal  [C++ 2.13.5]
773 /// [C++11] 'nullptr'        [C++11 2.14.7]
774 /// [C++11] user-defined-literal
775 ///         '(' expression ')'
776 /// [C11]   generic-selection
777 /// [C++2a] requires-expression
778 ///         '__func__'        [C99 6.4.2.2]
779 /// [GNU]   '__FUNCTION__'
780 /// [MS]    '__FUNCDNAME__'
781 /// [MS]    'L__FUNCTION__'
782 /// [MS]    '__FUNCSIG__'
783 /// [MS]    'L__FUNCSIG__'
784 /// [GNU]   '__PRETTY_FUNCTION__'
785 /// [GNU]   '(' compound-statement ')'
786 /// [GNU]   '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
787 /// [GNU]   '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
788 /// [GNU]   '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
789 ///                                     assign-expr ')'
790 /// [GNU]   '__builtin_FILE' '(' ')'
791 /// [GNU]   '__builtin_FUNCTION' '(' ')'
792 /// [GNU]   '__builtin_LINE' '(' ')'
793 /// [CLANG] '__builtin_COLUMN' '(' ')'
794 /// [GNU]   '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
795 /// [GNU]   '__null'
796 /// [OBJC]  '[' objc-message-expr ']'
797 /// [OBJC]  '\@selector' '(' objc-selector-arg ')'
798 /// [OBJC]  '\@protocol' '(' identifier ')'
799 /// [OBJC]  '\@encode' '(' type-name ')'
800 /// [OBJC]  objc-string-literal
801 /// [C++]   simple-type-specifier '(' expression-list[opt] ')'      [C++ 5.2.3]
802 /// [C++11] simple-type-specifier braced-init-list                  [C++11 5.2.3]
803 /// [C++]   typename-specifier '(' expression-list[opt] ')'         [C++ 5.2.3]
804 /// [C++11] typename-specifier braced-init-list                     [C++11 5.2.3]
805 /// [C++]   'const_cast' '<' type-name '>' '(' expression ')'       [C++ 5.2p1]
806 /// [C++]   'dynamic_cast' '<' type-name '>' '(' expression ')'     [C++ 5.2p1]
807 /// [C++]   'reinterpret_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
808 /// [C++]   'static_cast' '<' type-name '>' '(' expression ')'      [C++ 5.2p1]
809 /// [C++]   'typeid' '(' expression ')'                             [C++ 5.2p1]
810 /// [C++]   'typeid' '(' type-id ')'                                [C++ 5.2p1]
811 /// [C++]   'this'          [C++ 9.3.2]
812 /// [G++]   unary-type-trait '(' type-id ')'
813 /// [G++]   binary-type-trait '(' type-id ',' type-id ')'           [TODO]
814 /// [EMBT]  array-type-trait '(' type-id ',' integer ')'
815 /// [clang] '^' block-literal
816 ///
817 ///       constant: [C99 6.4.4]
818 ///         integer-constant
819 ///         floating-constant
820 ///         enumeration-constant -> identifier
821 ///         character-constant
822 ///
823 ///       id-expression: [C++ 5.1]
824 ///                   unqualified-id
825 ///                   qualified-id
826 ///
827 ///       unqualified-id: [C++ 5.1]
828 ///                   identifier
829 ///                   operator-function-id
830 ///                   conversion-function-id
831 ///                   '~' class-name
832 ///                   template-id
833 ///
834 ///       new-expression: [C++ 5.3.4]
835 ///                   '::'[opt] 'new' new-placement[opt] new-type-id
836 ///                                     new-initializer[opt]
837 ///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
838 ///                                     new-initializer[opt]
839 ///
840 ///       delete-expression: [C++ 5.3.5]
841 ///                   '::'[opt] 'delete' cast-expression
842 ///                   '::'[opt] 'delete' '[' ']' cast-expression
843 ///
844 /// [GNU/Embarcadero] unary-type-trait:
845 ///                   '__is_arithmetic'
846 ///                   '__is_floating_point'
847 ///                   '__is_integral'
848 ///                   '__is_lvalue_expr'
849 ///                   '__is_rvalue_expr'
850 ///                   '__is_complete_type'
851 ///                   '__is_void'
852 ///                   '__is_array'
853 ///                   '__is_function'
854 ///                   '__is_reference'
855 ///                   '__is_lvalue_reference'
856 ///                   '__is_rvalue_reference'
857 ///                   '__is_fundamental'
858 ///                   '__is_object'
859 ///                   '__is_scalar'
860 ///                   '__is_compound'
861 ///                   '__is_pointer'
862 ///                   '__is_member_object_pointer'
863 ///                   '__is_member_function_pointer'
864 ///                   '__is_member_pointer'
865 ///                   '__is_const'
866 ///                   '__is_volatile'
867 ///                   '__is_trivial'
868 ///                   '__is_standard_layout'
869 ///                   '__is_signed'
870 ///                   '__is_unsigned'
871 ///
872 /// [GNU] unary-type-trait:
873 ///                   '__has_nothrow_assign'
874 ///                   '__has_nothrow_copy'
875 ///                   '__has_nothrow_constructor'
876 ///                   '__has_trivial_assign'                  [TODO]
877 ///                   '__has_trivial_copy'                    [TODO]
878 ///                   '__has_trivial_constructor'
879 ///                   '__has_trivial_destructor'
880 ///                   '__has_virtual_destructor'
881 ///                   '__is_abstract'                         [TODO]
882 ///                   '__is_class'
883 ///                   '__is_empty'                            [TODO]
884 ///                   '__is_enum'
885 ///                   '__is_final'
886 ///                   '__is_pod'
887 ///                   '__is_polymorphic'
888 ///                   '__is_sealed'                           [MS]
889 ///                   '__is_trivial'
890 ///                   '__is_union'
891 ///                   '__has_unique_object_representations'
892 ///
893 /// [Clang] unary-type-trait:
894 ///                   '__is_aggregate'
895 ///                   '__trivially_copyable'
896 ///
897 ///       binary-type-trait:
898 /// [GNU]             '__is_base_of'
899 /// [MS]              '__is_convertible_to'
900 ///                   '__is_convertible'
901 ///                   '__is_same'
902 ///
903 /// [Embarcadero] array-type-trait:
904 ///                   '__array_rank'
905 ///                   '__array_extent'
906 ///
907 /// [Embarcadero] expression-trait:
908 ///                   '__is_lvalue_expr'
909 ///                   '__is_rvalue_expr'
910 /// \endverbatim
911 ///
912 ExprResult Parser::ParseCastExpression(CastParseKind ParseKind,
913                                        bool isAddressOfOperand,
914                                        bool &NotCastExpr,
915                                        TypeCastState isTypeCast,
916                                        bool isVectorLiteral,
917                                        bool *NotPrimaryExpression) {
918   ExprResult Res;
919   tok::TokenKind SavedKind = Tok.getKind();
920   auto SavedType = PreferredType;
921   NotCastExpr = false;
922 
923   // Are postfix-expression suffix operators permitted after this
924   // cast-expression? If not, and we find some, we'll parse them anyway and
925   // diagnose them.
926   bool AllowSuffix = true;
927 
928   // This handles all of cast-expression, unary-expression, postfix-expression,
929   // and primary-expression.  We handle them together like this for efficiency
930   // and to simplify handling of an expression starting with a '(' token: which
931   // may be one of a parenthesized expression, cast-expression, compound literal
932   // expression, or statement expression.
933   //
934   // If the parsed tokens consist of a primary-expression, the cases below
935   // break out of the switch;  at the end we call ParsePostfixExpressionSuffix
936   // to handle the postfix expression suffixes.  Cases that cannot be followed
937   // by postfix exprs should set AllowSuffix to false.
938   switch (SavedKind) {
939   case tok::l_paren: {
940     // If this expression is limited to being a unary-expression, the paren can
941     // not start a cast expression.
942     ParenParseOption ParenExprType;
943     switch (ParseKind) {
944       case CastParseKind::UnaryExprOnly:
945         if (!getLangOpts().CPlusPlus)
946           ParenExprType = CompoundLiteral;
947         LLVM_FALLTHROUGH;
948       case CastParseKind::AnyCastExpr:
949         ParenExprType = ParenParseOption::CastExpr;
950         break;
951       case CastParseKind::PrimaryExprOnly:
952         ParenExprType = FoldExpr;
953         break;
954     }
955     ParsedType CastTy;
956     SourceLocation RParenLoc;
957     Res = ParseParenExpression(ParenExprType, false/*stopIfCastExr*/,
958                                isTypeCast == IsTypeCast, CastTy, RParenLoc);
959 
960     // FIXME: What should we do if a vector literal is followed by a
961     // postfix-expression suffix? Usually postfix operators are permitted on
962     // literals.
963     if (isVectorLiteral)
964       return Res;
965 
966     switch (ParenExprType) {
967     case SimpleExpr:   break;    // Nothing else to do.
968     case CompoundStmt: break;  // Nothing else to do.
969     case CompoundLiteral:
970       // We parsed '(' type-name ')' '{' ... '}'.  If any suffixes of
971       // postfix-expression exist, parse them now.
972       break;
973     case CastExpr:
974       // We have parsed the cast-expression and no postfix-expr pieces are
975       // following.
976       return Res;
977     case FoldExpr:
978       // We only parsed a fold-expression. There might be postfix-expr pieces
979       // afterwards; parse them now.
980       break;
981     }
982 
983     break;
984   }
985 
986     // primary-expression
987   case tok::numeric_constant:
988     // constant: integer-constant
989     // constant: floating-constant
990 
991     Res = Actions.ActOnNumericConstant(Tok, /*UDLScope*/getCurScope());
992     ConsumeToken();
993     break;
994 
995   case tok::kw_true:
996   case tok::kw_false:
997     Res = ParseCXXBoolLiteral();
998     break;
999 
1000   case tok::kw___objc_yes:
1001   case tok::kw___objc_no:
1002     Res = ParseObjCBoolLiteral();
1003     break;
1004 
1005   case tok::kw_nullptr:
1006     Diag(Tok, diag::warn_cxx98_compat_nullptr);
1007     Res = Actions.ActOnCXXNullPtrLiteral(ConsumeToken());
1008     break;
1009 
1010   case tok::annot_primary_expr:
1011   case tok::annot_overload_set:
1012     Res = getExprAnnotation(Tok);
1013     if (!Res.isInvalid() && Tok.getKind() == tok::annot_overload_set)
1014       Res = Actions.ActOnNameClassifiedAsOverloadSet(getCurScope(), Res.get());
1015     ConsumeAnnotationToken();
1016     if (!Res.isInvalid() && Tok.is(tok::less))
1017       checkPotentialAngleBracket(Res);
1018     break;
1019 
1020   case tok::annot_non_type:
1021   case tok::annot_non_type_dependent:
1022   case tok::annot_non_type_undeclared: {
1023     CXXScopeSpec SS;
1024     Token Replacement;
1025     Res = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
1026     assert(!Res.isUnset() &&
1027            "should not perform typo correction on annotation token");
1028     break;
1029   }
1030 
1031   case tok::kw___super:
1032   case tok::kw_decltype:
1033     // Annotate the token and tail recurse.
1034     if (TryAnnotateTypeOrScopeToken())
1035       return ExprError();
1036     assert(Tok.isNot(tok::kw_decltype) && Tok.isNot(tok::kw___super));
1037     return ParseCastExpression(ParseKind, isAddressOfOperand, isTypeCast,
1038                                isVectorLiteral, NotPrimaryExpression);
1039 
1040   case tok::identifier: {      // primary-expression: identifier
1041                                // unqualified-id: identifier
1042                                // constant: enumeration-constant
1043     // Turn a potentially qualified name into a annot_typename or
1044     // annot_cxxscope if it would be valid.  This handles things like x::y, etc.
1045     if (getLangOpts().CPlusPlus) {
1046       // Avoid the unnecessary parse-time lookup in the common case
1047       // where the syntax forbids a type.
1048       const Token &Next = NextToken();
1049 
1050       // If this identifier was reverted from a token ID, and the next token
1051       // is a parenthesis, this is likely to be a use of a type trait. Check
1052       // those tokens.
1053       if (Next.is(tok::l_paren) &&
1054           Tok.is(tok::identifier) &&
1055           Tok.getIdentifierInfo()->hasRevertedTokenIDToIdentifier()) {
1056         IdentifierInfo *II = Tok.getIdentifierInfo();
1057         // Build up the mapping of revertible type traits, for future use.
1058         if (RevertibleTypeTraits.empty()) {
1059 #define RTT_JOIN(X,Y) X##Y
1060 #define REVERTIBLE_TYPE_TRAIT(Name)                         \
1061           RevertibleTypeTraits[PP.getIdentifierInfo(#Name)] \
1062             = RTT_JOIN(tok::kw_,Name)
1063 
1064           REVERTIBLE_TYPE_TRAIT(__is_abstract);
1065           REVERTIBLE_TYPE_TRAIT(__is_aggregate);
1066           REVERTIBLE_TYPE_TRAIT(__is_arithmetic);
1067           REVERTIBLE_TYPE_TRAIT(__is_array);
1068           REVERTIBLE_TYPE_TRAIT(__is_assignable);
1069           REVERTIBLE_TYPE_TRAIT(__is_base_of);
1070           REVERTIBLE_TYPE_TRAIT(__is_class);
1071           REVERTIBLE_TYPE_TRAIT(__is_complete_type);
1072           REVERTIBLE_TYPE_TRAIT(__is_compound);
1073           REVERTIBLE_TYPE_TRAIT(__is_const);
1074           REVERTIBLE_TYPE_TRAIT(__is_constructible);
1075           REVERTIBLE_TYPE_TRAIT(__is_convertible);
1076           REVERTIBLE_TYPE_TRAIT(__is_convertible_to);
1077           REVERTIBLE_TYPE_TRAIT(__is_destructible);
1078           REVERTIBLE_TYPE_TRAIT(__is_empty);
1079           REVERTIBLE_TYPE_TRAIT(__is_enum);
1080           REVERTIBLE_TYPE_TRAIT(__is_floating_point);
1081           REVERTIBLE_TYPE_TRAIT(__is_final);
1082           REVERTIBLE_TYPE_TRAIT(__is_function);
1083           REVERTIBLE_TYPE_TRAIT(__is_fundamental);
1084           REVERTIBLE_TYPE_TRAIT(__is_integral);
1085           REVERTIBLE_TYPE_TRAIT(__is_interface_class);
1086           REVERTIBLE_TYPE_TRAIT(__is_literal);
1087           REVERTIBLE_TYPE_TRAIT(__is_lvalue_expr);
1088           REVERTIBLE_TYPE_TRAIT(__is_lvalue_reference);
1089           REVERTIBLE_TYPE_TRAIT(__is_member_function_pointer);
1090           REVERTIBLE_TYPE_TRAIT(__is_member_object_pointer);
1091           REVERTIBLE_TYPE_TRAIT(__is_member_pointer);
1092           REVERTIBLE_TYPE_TRAIT(__is_nothrow_assignable);
1093           REVERTIBLE_TYPE_TRAIT(__is_nothrow_constructible);
1094           REVERTIBLE_TYPE_TRAIT(__is_nothrow_destructible);
1095           REVERTIBLE_TYPE_TRAIT(__is_object);
1096           REVERTIBLE_TYPE_TRAIT(__is_pod);
1097           REVERTIBLE_TYPE_TRAIT(__is_pointer);
1098           REVERTIBLE_TYPE_TRAIT(__is_polymorphic);
1099           REVERTIBLE_TYPE_TRAIT(__is_reference);
1100           REVERTIBLE_TYPE_TRAIT(__is_rvalue_expr);
1101           REVERTIBLE_TYPE_TRAIT(__is_rvalue_reference);
1102           REVERTIBLE_TYPE_TRAIT(__is_same);
1103           REVERTIBLE_TYPE_TRAIT(__is_scalar);
1104           REVERTIBLE_TYPE_TRAIT(__is_sealed);
1105           REVERTIBLE_TYPE_TRAIT(__is_signed);
1106           REVERTIBLE_TYPE_TRAIT(__is_standard_layout);
1107           REVERTIBLE_TYPE_TRAIT(__is_trivial);
1108           REVERTIBLE_TYPE_TRAIT(__is_trivially_assignable);
1109           REVERTIBLE_TYPE_TRAIT(__is_trivially_constructible);
1110           REVERTIBLE_TYPE_TRAIT(__is_trivially_copyable);
1111           REVERTIBLE_TYPE_TRAIT(__is_union);
1112           REVERTIBLE_TYPE_TRAIT(__is_unsigned);
1113           REVERTIBLE_TYPE_TRAIT(__is_void);
1114           REVERTIBLE_TYPE_TRAIT(__is_volatile);
1115 #undef REVERTIBLE_TYPE_TRAIT
1116 #undef RTT_JOIN
1117         }
1118 
1119         // If we find that this is in fact the name of a type trait,
1120         // update the token kind in place and parse again to treat it as
1121         // the appropriate kind of type trait.
1122         llvm::SmallDenseMap<IdentifierInfo *, tok::TokenKind>::iterator Known
1123           = RevertibleTypeTraits.find(II);
1124         if (Known != RevertibleTypeTraits.end()) {
1125           Tok.setKind(Known->second);
1126           return ParseCastExpression(ParseKind, isAddressOfOperand,
1127                                      NotCastExpr, isTypeCast,
1128                                      isVectorLiteral, NotPrimaryExpression);
1129         }
1130       }
1131 
1132       if ((!ColonIsSacred && Next.is(tok::colon)) ||
1133           Next.isOneOf(tok::coloncolon, tok::less, tok::l_paren,
1134                        tok::l_brace)) {
1135         // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse.
1136         if (TryAnnotateTypeOrScopeToken())
1137           return ExprError();
1138         if (!Tok.is(tok::identifier))
1139           return ParseCastExpression(ParseKind, isAddressOfOperand,
1140                                      NotCastExpr, isTypeCast,
1141                                      isVectorLiteral,
1142                                      NotPrimaryExpression);
1143       }
1144     }
1145 
1146     // Consume the identifier so that we can see if it is followed by a '(' or
1147     // '.'.
1148     IdentifierInfo &II = *Tok.getIdentifierInfo();
1149     SourceLocation ILoc = ConsumeToken();
1150 
1151     // Support 'Class.property' and 'super.property' notation.
1152     if (getLangOpts().ObjC && Tok.is(tok::period) &&
1153         (Actions.getTypeName(II, ILoc, getCurScope()) ||
1154          // Allow the base to be 'super' if in an objc-method.
1155          (&II == Ident_super && getCurScope()->isInObjcMethodScope()))) {
1156       ConsumeToken();
1157 
1158       if (Tok.is(tok::code_completion) && &II != Ident_super) {
1159         cutOffParsing();
1160         Actions.CodeCompleteObjCClassPropertyRefExpr(
1161             getCurScope(), II, ILoc, ExprStatementTokLoc == ILoc);
1162         return ExprError();
1163       }
1164       // Allow either an identifier or the keyword 'class' (in C++).
1165       if (Tok.isNot(tok::identifier) &&
1166           !(getLangOpts().CPlusPlus && Tok.is(tok::kw_class))) {
1167         Diag(Tok, diag::err_expected_property_name);
1168         return ExprError();
1169       }
1170       IdentifierInfo &PropertyName = *Tok.getIdentifierInfo();
1171       SourceLocation PropertyLoc = ConsumeToken();
1172 
1173       Res = Actions.ActOnClassPropertyRefExpr(II, PropertyName,
1174                                               ILoc, PropertyLoc);
1175       break;
1176     }
1177 
1178     // In an Objective-C method, if we have "super" followed by an identifier,
1179     // the token sequence is ill-formed. However, if there's a ':' or ']' after
1180     // that identifier, this is probably a message send with a missing open
1181     // bracket. Treat it as such.
1182     if (getLangOpts().ObjC && &II == Ident_super && !InMessageExpression &&
1183         getCurScope()->isInObjcMethodScope() &&
1184         ((Tok.is(tok::identifier) &&
1185          (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) ||
1186          Tok.is(tok::code_completion))) {
1187       Res = ParseObjCMessageExpressionBody(SourceLocation(), ILoc, nullptr,
1188                                            nullptr);
1189       break;
1190     }
1191 
1192     // If we have an Objective-C class name followed by an identifier
1193     // and either ':' or ']', this is an Objective-C class message
1194     // send that's missing the opening '['. Recovery
1195     // appropriately. Also take this path if we're performing code
1196     // completion after an Objective-C class name.
1197     if (getLangOpts().ObjC &&
1198         ((Tok.is(tok::identifier) && !InMessageExpression) ||
1199          Tok.is(tok::code_completion))) {
1200       const Token& Next = NextToken();
1201       if (Tok.is(tok::code_completion) ||
1202           Next.is(tok::colon) || Next.is(tok::r_square))
1203         if (ParsedType Typ = Actions.getTypeName(II, ILoc, getCurScope()))
1204           if (Typ.get()->isObjCObjectOrInterfaceType()) {
1205             // Fake up a Declarator to use with ActOnTypeName.
1206             DeclSpec DS(AttrFactory);
1207             DS.SetRangeStart(ILoc);
1208             DS.SetRangeEnd(ILoc);
1209             const char *PrevSpec = nullptr;
1210             unsigned DiagID;
1211             DS.SetTypeSpecType(TST_typename, ILoc, PrevSpec, DiagID, Typ,
1212                                Actions.getASTContext().getPrintingPolicy());
1213 
1214             Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
1215             TypeResult Ty = Actions.ActOnTypeName(getCurScope(),
1216                                                   DeclaratorInfo);
1217             if (Ty.isInvalid())
1218               break;
1219 
1220             Res = ParseObjCMessageExpressionBody(SourceLocation(),
1221                                                  SourceLocation(),
1222                                                  Ty.get(), nullptr);
1223             break;
1224           }
1225     }
1226 
1227     // Make sure to pass down the right value for isAddressOfOperand.
1228     if (isAddressOfOperand && isPostfixExpressionSuffixStart())
1229       isAddressOfOperand = false;
1230 
1231     // Function designators are allowed to be undeclared (C99 6.5.1p2), so we
1232     // need to know whether or not this identifier is a function designator or
1233     // not.
1234     UnqualifiedId Name;
1235     CXXScopeSpec ScopeSpec;
1236     SourceLocation TemplateKWLoc;
1237     Token Replacement;
1238     CastExpressionIdValidator Validator(
1239         /*Next=*/Tok,
1240         /*AllowTypes=*/isTypeCast != NotTypeCast,
1241         /*AllowNonTypes=*/isTypeCast != IsTypeCast);
1242     Validator.IsAddressOfOperand = isAddressOfOperand;
1243     if (Tok.isOneOf(tok::periodstar, tok::arrowstar)) {
1244       Validator.WantExpressionKeywords = false;
1245       Validator.WantRemainingKeywords = false;
1246     } else {
1247       Validator.WantRemainingKeywords = Tok.isNot(tok::r_paren);
1248     }
1249     Name.setIdentifier(&II, ILoc);
1250     Res = Actions.ActOnIdExpression(
1251         getCurScope(), ScopeSpec, TemplateKWLoc, Name, Tok.is(tok::l_paren),
1252         isAddressOfOperand, &Validator,
1253         /*IsInlineAsmIdentifier=*/false,
1254         Tok.is(tok::r_paren) ? nullptr : &Replacement);
1255     if (!Res.isInvalid() && Res.isUnset()) {
1256       UnconsumeToken(Replacement);
1257       return ParseCastExpression(ParseKind, isAddressOfOperand,
1258                                  NotCastExpr, isTypeCast,
1259                                  /*isVectorLiteral=*/false,
1260                                  NotPrimaryExpression);
1261     }
1262     if (!Res.isInvalid() && Tok.is(tok::less))
1263       checkPotentialAngleBracket(Res);
1264     break;
1265   }
1266   case tok::char_constant:     // constant: character-constant
1267   case tok::wide_char_constant:
1268   case tok::utf8_char_constant:
1269   case tok::utf16_char_constant:
1270   case tok::utf32_char_constant:
1271     Res = Actions.ActOnCharacterConstant(Tok, /*UDLScope*/getCurScope());
1272     ConsumeToken();
1273     break;
1274   case tok::kw___func__:       // primary-expression: __func__ [C99 6.4.2.2]
1275   case tok::kw___FUNCTION__:   // primary-expression: __FUNCTION__ [GNU]
1276   case tok::kw___FUNCDNAME__:   // primary-expression: __FUNCDNAME__ [MS]
1277   case tok::kw___FUNCSIG__:     // primary-expression: __FUNCSIG__ [MS]
1278   case tok::kw_L__FUNCTION__:   // primary-expression: L__FUNCTION__ [MS]
1279   case tok::kw_L__FUNCSIG__:    // primary-expression: L__FUNCSIG__ [MS]
1280   case tok::kw___PRETTY_FUNCTION__:  // primary-expression: __P..Y_F..N__ [GNU]
1281     Res = Actions.ActOnPredefinedExpr(Tok.getLocation(), SavedKind);
1282     ConsumeToken();
1283     break;
1284   case tok::string_literal:    // primary-expression: string-literal
1285   case tok::wide_string_literal:
1286   case tok::utf8_string_literal:
1287   case tok::utf16_string_literal:
1288   case tok::utf32_string_literal:
1289     Res = ParseStringLiteralExpression(true);
1290     break;
1291   case tok::kw__Generic:   // primary-expression: generic-selection [C11 6.5.1]
1292     Res = ParseGenericSelectionExpression();
1293     break;
1294   case tok::kw___builtin_available:
1295     Res = ParseAvailabilityCheckExpr(Tok.getLocation());
1296     break;
1297   case tok::kw___builtin_va_arg:
1298   case tok::kw___builtin_offsetof:
1299   case tok::kw___builtin_choose_expr:
1300   case tok::kw___builtin_astype: // primary-expression: [OCL] as_type()
1301   case tok::kw___builtin_convertvector:
1302   case tok::kw___builtin_COLUMN:
1303   case tok::kw___builtin_FILE:
1304   case tok::kw___builtin_FUNCTION:
1305   case tok::kw___builtin_LINE:
1306     if (NotPrimaryExpression)
1307       *NotPrimaryExpression = true;
1308     // This parses the complete suffix; we can return early.
1309     return ParseBuiltinPrimaryExpression();
1310   case tok::kw___null:
1311     Res = Actions.ActOnGNUNullExpr(ConsumeToken());
1312     break;
1313 
1314   case tok::plusplus:      // unary-expression: '++' unary-expression [C99]
1315   case tok::minusminus: {  // unary-expression: '--' unary-expression [C99]
1316     if (NotPrimaryExpression)
1317       *NotPrimaryExpression = true;
1318     // C++ [expr.unary] has:
1319     //   unary-expression:
1320     //     ++ cast-expression
1321     //     -- cast-expression
1322     Token SavedTok = Tok;
1323     ConsumeToken();
1324 
1325     PreferredType.enterUnary(Actions, Tok.getLocation(), SavedTok.getKind(),
1326                              SavedTok.getLocation());
1327     // One special case is implicitly handled here: if the preceding tokens are
1328     // an ambiguous cast expression, such as "(T())++", then we recurse to
1329     // determine whether the '++' is prefix or postfix.
1330     Res = ParseCastExpression(getLangOpts().CPlusPlus ?
1331                                   UnaryExprOnly : AnyCastExpr,
1332                               /*isAddressOfOperand*/false, NotCastExpr,
1333                               NotTypeCast);
1334     if (NotCastExpr) {
1335       // If we return with NotCastExpr = true, we must not consume any tokens,
1336       // so put the token back where we found it.
1337       assert(Res.isInvalid());
1338       UnconsumeToken(SavedTok);
1339       return ExprError();
1340     }
1341     if (!Res.isInvalid()) {
1342       Expr *Arg = Res.get();
1343       Res = Actions.ActOnUnaryOp(getCurScope(), SavedTok.getLocation(),
1344                                  SavedKind, Arg);
1345       if (Res.isInvalid())
1346         Res = Actions.CreateRecoveryExpr(SavedTok.getLocation(),
1347                                          Arg->getEndLoc(), Arg);
1348     }
1349     return Res;
1350   }
1351   case tok::amp: {         // unary-expression: '&' cast-expression
1352     if (NotPrimaryExpression)
1353       *NotPrimaryExpression = true;
1354     // Special treatment because of member pointers
1355     SourceLocation SavedLoc = ConsumeToken();
1356     PreferredType.enterUnary(Actions, Tok.getLocation(), tok::amp, SavedLoc);
1357     Res = ParseCastExpression(AnyCastExpr, true);
1358     if (!Res.isInvalid()) {
1359       Expr *Arg = Res.get();
1360       Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Arg);
1361       if (Res.isInvalid())
1362         Res = Actions.CreateRecoveryExpr(Tok.getLocation(), Arg->getEndLoc(),
1363                                          Arg);
1364     }
1365     return Res;
1366   }
1367 
1368   case tok::star:          // unary-expression: '*' cast-expression
1369   case tok::plus:          // unary-expression: '+' cast-expression
1370   case tok::minus:         // unary-expression: '-' cast-expression
1371   case tok::tilde:         // unary-expression: '~' cast-expression
1372   case tok::exclaim:       // unary-expression: '!' cast-expression
1373   case tok::kw___real:     // unary-expression: '__real' cast-expression [GNU]
1374   case tok::kw___imag: {   // unary-expression: '__imag' cast-expression [GNU]
1375     if (NotPrimaryExpression)
1376       *NotPrimaryExpression = true;
1377     SourceLocation SavedLoc = ConsumeToken();
1378     PreferredType.enterUnary(Actions, Tok.getLocation(), SavedKind, SavedLoc);
1379     Res = ParseCastExpression(AnyCastExpr);
1380     if (!Res.isInvalid()) {
1381       Expr *Arg = Res.get();
1382       Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Arg);
1383       if (Res.isInvalid())
1384         Res = Actions.CreateRecoveryExpr(SavedLoc, Arg->getEndLoc(), Arg);
1385     }
1386     return Res;
1387   }
1388 
1389   case tok::kw_co_await: {  // unary-expression: 'co_await' cast-expression
1390     if (NotPrimaryExpression)
1391       *NotPrimaryExpression = true;
1392     SourceLocation CoawaitLoc = ConsumeToken();
1393     Res = ParseCastExpression(AnyCastExpr);
1394     if (!Res.isInvalid())
1395       Res = Actions.ActOnCoawaitExpr(getCurScope(), CoawaitLoc, Res.get());
1396     return Res;
1397   }
1398 
1399   case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU]
1400     // __extension__ silences extension warnings in the subexpression.
1401     if (NotPrimaryExpression)
1402       *NotPrimaryExpression = true;
1403     ExtensionRAIIObject O(Diags);  // Use RAII to do this.
1404     SourceLocation SavedLoc = ConsumeToken();
1405     Res = ParseCastExpression(AnyCastExpr);
1406     if (!Res.isInvalid())
1407       Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
1408     return Res;
1409   }
1410   case tok::kw__Alignof:   // unary-expression: '_Alignof' '(' type-name ')'
1411     if (!getLangOpts().C11)
1412       Diag(Tok, diag::ext_c11_feature) << Tok.getName();
1413     LLVM_FALLTHROUGH;
1414   case tok::kw_alignof:    // unary-expression: 'alignof' '(' type-id ')'
1415   case tok::kw___alignof:  // unary-expression: '__alignof' unary-expression
1416                            // unary-expression: '__alignof' '(' type-name ')'
1417   case tok::kw_sizeof:     // unary-expression: 'sizeof' unary-expression
1418                            // unary-expression: 'sizeof' '(' type-name ')'
1419   case tok::kw_vec_step:   // unary-expression: OpenCL 'vec_step' expression
1420   // unary-expression: '__builtin_omp_required_simd_align' '(' type-name ')'
1421   case tok::kw___builtin_omp_required_simd_align:
1422     if (NotPrimaryExpression)
1423       *NotPrimaryExpression = true;
1424     AllowSuffix = false;
1425     Res = ParseUnaryExprOrTypeTraitExpression();
1426     break;
1427   case tok::ampamp: {      // unary-expression: '&&' identifier
1428     if (NotPrimaryExpression)
1429       *NotPrimaryExpression = true;
1430     SourceLocation AmpAmpLoc = ConsumeToken();
1431     if (Tok.isNot(tok::identifier))
1432       return ExprError(Diag(Tok, diag::err_expected) << tok::identifier);
1433 
1434     if (getCurScope()->getFnParent() == nullptr)
1435       return ExprError(Diag(Tok, diag::err_address_of_label_outside_fn));
1436 
1437     Diag(AmpAmpLoc, diag::ext_gnu_address_of_label);
1438     LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
1439                                                 Tok.getLocation());
1440     Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(), LD);
1441     ConsumeToken();
1442     AllowSuffix = false;
1443     break;
1444   }
1445   case tok::kw_const_cast:
1446   case tok::kw_dynamic_cast:
1447   case tok::kw_reinterpret_cast:
1448   case tok::kw_static_cast:
1449   case tok::kw_addrspace_cast:
1450     if (NotPrimaryExpression)
1451       *NotPrimaryExpression = true;
1452     Res = ParseCXXCasts();
1453     break;
1454   case tok::kw___builtin_bit_cast:
1455     if (NotPrimaryExpression)
1456       *NotPrimaryExpression = true;
1457     Res = ParseBuiltinBitCast();
1458     break;
1459   case tok::kw_typeid:
1460     if (NotPrimaryExpression)
1461       *NotPrimaryExpression = true;
1462     Res = ParseCXXTypeid();
1463     break;
1464   case tok::kw___uuidof:
1465     if (NotPrimaryExpression)
1466       *NotPrimaryExpression = true;
1467     Res = ParseCXXUuidof();
1468     break;
1469   case tok::kw_this:
1470     Res = ParseCXXThis();
1471     break;
1472   case tok::kw___builtin_sycl_unique_stable_name:
1473     Res = ParseSYCLUniqueStableNameExpression();
1474     break;
1475 
1476   case tok::annot_typename:
1477     if (isStartOfObjCClassMessageMissingOpenBracket()) {
1478       TypeResult Type = getTypeAnnotation(Tok);
1479 
1480       // Fake up a Declarator to use with ActOnTypeName.
1481       DeclSpec DS(AttrFactory);
1482       DS.SetRangeStart(Tok.getLocation());
1483       DS.SetRangeEnd(Tok.getLastLoc());
1484 
1485       const char *PrevSpec = nullptr;
1486       unsigned DiagID;
1487       DS.SetTypeSpecType(TST_typename, Tok.getAnnotationEndLoc(),
1488                          PrevSpec, DiagID, Type,
1489                          Actions.getASTContext().getPrintingPolicy());
1490 
1491       Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
1492       TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
1493       if (Ty.isInvalid())
1494         break;
1495 
1496       ConsumeAnnotationToken();
1497       Res = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(),
1498                                            Ty.get(), nullptr);
1499       break;
1500     }
1501     LLVM_FALLTHROUGH;
1502 
1503   case tok::annot_decltype:
1504   case tok::kw_char:
1505   case tok::kw_wchar_t:
1506   case tok::kw_char8_t:
1507   case tok::kw_char16_t:
1508   case tok::kw_char32_t:
1509   case tok::kw_bool:
1510   case tok::kw_short:
1511   case tok::kw_int:
1512   case tok::kw_long:
1513   case tok::kw___int64:
1514   case tok::kw___int128:
1515   case tok::kw__ExtInt:
1516   case tok::kw_signed:
1517   case tok::kw_unsigned:
1518   case tok::kw_half:
1519   case tok::kw_float:
1520   case tok::kw_double:
1521   case tok::kw___bf16:
1522   case tok::kw__Float16:
1523   case tok::kw___float128:
1524   case tok::kw_void:
1525   case tok::kw_typename:
1526   case tok::kw_typeof:
1527   case tok::kw___vector:
1528 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
1529 #include "clang/Basic/OpenCLImageTypes.def"
1530   {
1531     if (!getLangOpts().CPlusPlus) {
1532       Diag(Tok, diag::err_expected_expression);
1533       return ExprError();
1534     }
1535 
1536     // Everything henceforth is a postfix-expression.
1537     if (NotPrimaryExpression)
1538       *NotPrimaryExpression = true;
1539 
1540     if (SavedKind == tok::kw_typename) {
1541       // postfix-expression: typename-specifier '(' expression-list[opt] ')'
1542       //                     typename-specifier braced-init-list
1543       if (TryAnnotateTypeOrScopeToken())
1544         return ExprError();
1545 
1546       if (!Actions.isSimpleTypeSpecifier(Tok.getKind()))
1547         // We are trying to parse a simple-type-specifier but might not get such
1548         // a token after error recovery.
1549         return ExprError();
1550     }
1551 
1552     // postfix-expression: simple-type-specifier '(' expression-list[opt] ')'
1553     //                     simple-type-specifier braced-init-list
1554     //
1555     DeclSpec DS(AttrFactory);
1556 
1557     ParseCXXSimpleTypeSpecifier(DS);
1558     if (Tok.isNot(tok::l_paren) &&
1559         (!getLangOpts().CPlusPlus11 || Tok.isNot(tok::l_brace)))
1560       return ExprError(Diag(Tok, diag::err_expected_lparen_after_type)
1561                          << DS.getSourceRange());
1562 
1563     if (Tok.is(tok::l_brace))
1564       Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
1565 
1566     Res = ParseCXXTypeConstructExpression(DS);
1567     break;
1568   }
1569 
1570   case tok::annot_cxxscope: { // [C++] id-expression: qualified-id
1571     // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse.
1572     // (We can end up in this situation after tentative parsing.)
1573     if (TryAnnotateTypeOrScopeToken())
1574       return ExprError();
1575     if (!Tok.is(tok::annot_cxxscope))
1576       return ParseCastExpression(ParseKind, isAddressOfOperand, NotCastExpr,
1577                                  isTypeCast, isVectorLiteral,
1578                                  NotPrimaryExpression);
1579 
1580     Token Next = NextToken();
1581     if (Next.is(tok::annot_template_id)) {
1582       TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Next);
1583       if (TemplateId->Kind == TNK_Type_template) {
1584         // We have a qualified template-id that we know refers to a
1585         // type, translate it into a type and continue parsing as a
1586         // cast expression.
1587         CXXScopeSpec SS;
1588         ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
1589                                        /*ObjectHadErrors=*/false,
1590                                        /*EnteringContext=*/false);
1591         AnnotateTemplateIdTokenAsType(SS);
1592         return ParseCastExpression(ParseKind, isAddressOfOperand, NotCastExpr,
1593                                    isTypeCast, isVectorLiteral,
1594                                    NotPrimaryExpression);
1595       }
1596     }
1597 
1598     // Parse as an id-expression.
1599     Res = ParseCXXIdExpression(isAddressOfOperand);
1600     break;
1601   }
1602 
1603   case tok::annot_template_id: { // [C++]          template-id
1604     TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
1605     if (TemplateId->Kind == TNK_Type_template) {
1606       // We have a template-id that we know refers to a type,
1607       // translate it into a type and continue parsing as a cast
1608       // expression.
1609       CXXScopeSpec SS;
1610       AnnotateTemplateIdTokenAsType(SS);
1611       return ParseCastExpression(ParseKind, isAddressOfOperand,
1612                                  NotCastExpr, isTypeCast, isVectorLiteral,
1613                                  NotPrimaryExpression);
1614     }
1615 
1616     // Fall through to treat the template-id as an id-expression.
1617     LLVM_FALLTHROUGH;
1618   }
1619 
1620   case tok::kw_operator: // [C++] id-expression: operator/conversion-function-id
1621     Res = ParseCXXIdExpression(isAddressOfOperand);
1622     break;
1623 
1624   case tok::coloncolon: {
1625     // ::foo::bar -> global qualified name etc.   If TryAnnotateTypeOrScopeToken
1626     // annotates the token, tail recurse.
1627     if (TryAnnotateTypeOrScopeToken())
1628       return ExprError();
1629     if (!Tok.is(tok::coloncolon))
1630       return ParseCastExpression(ParseKind, isAddressOfOperand, isTypeCast,
1631                                  isVectorLiteral, NotPrimaryExpression);
1632 
1633     // ::new -> [C++] new-expression
1634     // ::delete -> [C++] delete-expression
1635     SourceLocation CCLoc = ConsumeToken();
1636     if (Tok.is(tok::kw_new)) {
1637       if (NotPrimaryExpression)
1638         *NotPrimaryExpression = true;
1639       Res = ParseCXXNewExpression(true, CCLoc);
1640       AllowSuffix = false;
1641       break;
1642     }
1643     if (Tok.is(tok::kw_delete)) {
1644       if (NotPrimaryExpression)
1645         *NotPrimaryExpression = true;
1646       Res = ParseCXXDeleteExpression(true, CCLoc);
1647       AllowSuffix = false;
1648       break;
1649     }
1650 
1651     // This is not a type name or scope specifier, it is an invalid expression.
1652     Diag(CCLoc, diag::err_expected_expression);
1653     return ExprError();
1654   }
1655 
1656   case tok::kw_new: // [C++] new-expression
1657     if (NotPrimaryExpression)
1658       *NotPrimaryExpression = true;
1659     Res = ParseCXXNewExpression(false, Tok.getLocation());
1660     AllowSuffix = false;
1661     break;
1662 
1663   case tok::kw_delete: // [C++] delete-expression
1664     if (NotPrimaryExpression)
1665       *NotPrimaryExpression = true;
1666     Res = ParseCXXDeleteExpression(false, Tok.getLocation());
1667     AllowSuffix = false;
1668     break;
1669 
1670   case tok::kw_requires: // [C++2a] requires-expression
1671     Res = ParseRequiresExpression();
1672     AllowSuffix = false;
1673     break;
1674 
1675   case tok::kw_noexcept: { // [C++0x] 'noexcept' '(' expression ')'
1676     if (NotPrimaryExpression)
1677       *NotPrimaryExpression = true;
1678     Diag(Tok, diag::warn_cxx98_compat_noexcept_expr);
1679     SourceLocation KeyLoc = ConsumeToken();
1680     BalancedDelimiterTracker T(*this, tok::l_paren);
1681 
1682     if (T.expectAndConsume(diag::err_expected_lparen_after, "noexcept"))
1683       return ExprError();
1684     // C++11 [expr.unary.noexcept]p1:
1685     //   The noexcept operator determines whether the evaluation of its operand,
1686     //   which is an unevaluated operand, can throw an exception.
1687     EnterExpressionEvaluationContext Unevaluated(
1688         Actions, Sema::ExpressionEvaluationContext::Unevaluated);
1689     Res = ParseExpression();
1690 
1691     T.consumeClose();
1692 
1693     if (!Res.isInvalid())
1694       Res = Actions.ActOnNoexceptExpr(KeyLoc, T.getOpenLocation(), Res.get(),
1695                                       T.getCloseLocation());
1696     AllowSuffix = false;
1697     break;
1698   }
1699 
1700 #define TYPE_TRAIT(N,Spelling,K) \
1701   case tok::kw_##Spelling:
1702 #include "clang/Basic/TokenKinds.def"
1703     Res = ParseTypeTrait();
1704     break;
1705 
1706   case tok::kw___array_rank:
1707   case tok::kw___array_extent:
1708     if (NotPrimaryExpression)
1709       *NotPrimaryExpression = true;
1710     Res = ParseArrayTypeTrait();
1711     break;
1712 
1713   case tok::kw___is_lvalue_expr:
1714   case tok::kw___is_rvalue_expr:
1715     if (NotPrimaryExpression)
1716       *NotPrimaryExpression = true;
1717     Res = ParseExpressionTrait();
1718     break;
1719 
1720   case tok::at: {
1721     if (NotPrimaryExpression)
1722       *NotPrimaryExpression = true;
1723     SourceLocation AtLoc = ConsumeToken();
1724     return ParseObjCAtExpression(AtLoc);
1725   }
1726   case tok::caret:
1727     Res = ParseBlockLiteralExpression();
1728     break;
1729   case tok::code_completion: {
1730     cutOffParsing();
1731     Actions.CodeCompleteExpression(getCurScope(),
1732                                    PreferredType.get(Tok.getLocation()));
1733     return ExprError();
1734   }
1735   case tok::l_square:
1736     if (getLangOpts().CPlusPlus11) {
1737       if (getLangOpts().ObjC) {
1738         // C++11 lambda expressions and Objective-C message sends both start with a
1739         // square bracket.  There are three possibilities here:
1740         // we have a valid lambda expression, we have an invalid lambda
1741         // expression, or we have something that doesn't appear to be a lambda.
1742         // If we're in the last case, we fall back to ParseObjCMessageExpression.
1743         Res = TryParseLambdaExpression();
1744         if (!Res.isInvalid() && !Res.get()) {
1745           // We assume Objective-C++ message expressions are not
1746           // primary-expressions.
1747           if (NotPrimaryExpression)
1748             *NotPrimaryExpression = true;
1749           Res = ParseObjCMessageExpression();
1750         }
1751         break;
1752       }
1753       Res = ParseLambdaExpression();
1754       break;
1755     }
1756     if (getLangOpts().ObjC) {
1757       Res = ParseObjCMessageExpression();
1758       break;
1759     }
1760     LLVM_FALLTHROUGH;
1761   default:
1762     NotCastExpr = true;
1763     return ExprError();
1764   }
1765 
1766   // Check to see whether Res is a function designator only. If it is and we
1767   // are compiling for OpenCL, we need to return an error as this implies
1768   // that the address of the function is being taken, which is illegal in CL.
1769 
1770   if (ParseKind == PrimaryExprOnly)
1771     // This is strictly a primary-expression - no postfix-expr pieces should be
1772     // parsed.
1773     return Res;
1774 
1775   if (!AllowSuffix) {
1776     // FIXME: Don't parse a primary-expression suffix if we encountered a parse
1777     // error already.
1778     if (Res.isInvalid())
1779       return Res;
1780 
1781     switch (Tok.getKind()) {
1782     case tok::l_square:
1783     case tok::l_paren:
1784     case tok::plusplus:
1785     case tok::minusminus:
1786       // "expected ';'" or similar is probably the right diagnostic here. Let
1787       // the caller decide what to do.
1788       if (Tok.isAtStartOfLine())
1789         return Res;
1790 
1791       LLVM_FALLTHROUGH;
1792     case tok::period:
1793     case tok::arrow:
1794       break;
1795 
1796     default:
1797       return Res;
1798     }
1799 
1800     // This was a unary-expression for which a postfix-expression suffix is
1801     // not permitted by the grammar (eg, a sizeof expression or
1802     // new-expression or similar). Diagnose but parse the suffix anyway.
1803     Diag(Tok.getLocation(), diag::err_postfix_after_unary_requires_parens)
1804         << Tok.getKind() << Res.get()->getSourceRange()
1805         << FixItHint::CreateInsertion(Res.get()->getBeginLoc(), "(")
1806         << FixItHint::CreateInsertion(PP.getLocForEndOfToken(PrevTokLocation),
1807                                       ")");
1808   }
1809 
1810   // These can be followed by postfix-expr pieces.
1811   PreferredType = SavedType;
1812   Res = ParsePostfixExpressionSuffix(Res);
1813   if (getLangOpts().OpenCL &&
1814       !getActions().getOpenCLOptions().isAvailableOption(
1815           "__cl_clang_function_pointers", getLangOpts()))
1816     if (Expr *PostfixExpr = Res.get()) {
1817       QualType Ty = PostfixExpr->getType();
1818       if (!Ty.isNull() && Ty->isFunctionType()) {
1819         Diag(PostfixExpr->getExprLoc(),
1820              diag::err_opencl_taking_function_address_parser);
1821         return ExprError();
1822       }
1823     }
1824 
1825   return Res;
1826 }
1827 
1828 /// Once the leading part of a postfix-expression is parsed, this
1829 /// method parses any suffixes that apply.
1830 ///
1831 /// \verbatim
1832 ///       postfix-expression: [C99 6.5.2]
1833 ///         primary-expression
1834 ///         postfix-expression '[' expression ']'
1835 ///         postfix-expression '[' braced-init-list ']'
1836 ///         postfix-expression '(' argument-expression-list[opt] ')'
1837 ///         postfix-expression '.' identifier
1838 ///         postfix-expression '->' identifier
1839 ///         postfix-expression '++'
1840 ///         postfix-expression '--'
1841 ///         '(' type-name ')' '{' initializer-list '}'
1842 ///         '(' type-name ')' '{' initializer-list ',' '}'
1843 ///
1844 ///       argument-expression-list: [C99 6.5.2]
1845 ///         argument-expression ...[opt]
1846 ///         argument-expression-list ',' assignment-expression ...[opt]
1847 /// \endverbatim
1848 ExprResult
1849 Parser::ParsePostfixExpressionSuffix(ExprResult LHS) {
1850   // Now that the primary-expression piece of the postfix-expression has been
1851   // parsed, see if there are any postfix-expression pieces here.
1852   SourceLocation Loc;
1853   auto SavedType = PreferredType;
1854   while (1) {
1855     // Each iteration relies on preferred type for the whole expression.
1856     PreferredType = SavedType;
1857     switch (Tok.getKind()) {
1858     case tok::code_completion:
1859       if (InMessageExpression)
1860         return LHS;
1861 
1862       cutOffParsing();
1863       Actions.CodeCompletePostfixExpression(
1864           getCurScope(), LHS, PreferredType.get(Tok.getLocation()));
1865       return ExprError();
1866 
1867     case tok::identifier:
1868       // If we see identifier: after an expression, and we're not already in a
1869       // message send, then this is probably a message send with a missing
1870       // opening bracket '['.
1871       if (getLangOpts().ObjC && !InMessageExpression &&
1872           (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) {
1873         LHS = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(),
1874                                              nullptr, LHS.get());
1875         break;
1876       }
1877       // Fall through; this isn't a message send.
1878       LLVM_FALLTHROUGH;
1879 
1880     default:  // Not a postfix-expression suffix.
1881       return LHS;
1882     case tok::l_square: {  // postfix-expression: p-e '[' expression ']'
1883       // If we have a array postfix expression that starts on a new line and
1884       // Objective-C is enabled, it is highly likely that the user forgot a
1885       // semicolon after the base expression and that the array postfix-expr is
1886       // actually another message send.  In this case, do some look-ahead to see
1887       // if the contents of the square brackets are obviously not a valid
1888       // expression and recover by pretending there is no suffix.
1889       if (getLangOpts().ObjC && Tok.isAtStartOfLine() &&
1890           isSimpleObjCMessageExpression())
1891         return LHS;
1892 
1893       // Reject array indices starting with a lambda-expression. '[[' is
1894       // reserved for attributes.
1895       if (CheckProhibitedCXX11Attribute()) {
1896         (void)Actions.CorrectDelayedTyposInExpr(LHS);
1897         return ExprError();
1898       }
1899 
1900       BalancedDelimiterTracker T(*this, tok::l_square);
1901       T.consumeOpen();
1902       Loc = T.getOpenLocation();
1903       ExprResult Idx, Length, Stride;
1904       SourceLocation ColonLocFirst, ColonLocSecond;
1905       PreferredType.enterSubscript(Actions, Tok.getLocation(), LHS.get());
1906       if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
1907         Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
1908         Idx = ParseBraceInitializer();
1909       } else if (getLangOpts().OpenMP) {
1910         ColonProtectionRAIIObject RAII(*this);
1911         // Parse [: or [ expr or [ expr :
1912         if (!Tok.is(tok::colon)) {
1913           // [ expr
1914           Idx = ParseExpression();
1915         }
1916         if (Tok.is(tok::colon)) {
1917           // Consume ':'
1918           ColonLocFirst = ConsumeToken();
1919           if (Tok.isNot(tok::r_square) &&
1920               (getLangOpts().OpenMP < 50 ||
1921                ((Tok.isNot(tok::colon) && getLangOpts().OpenMP >= 50))))
1922             Length = ParseExpression();
1923         }
1924         if (getLangOpts().OpenMP >= 50 &&
1925             (OMPClauseKind == llvm::omp::Clause::OMPC_to ||
1926              OMPClauseKind == llvm::omp::Clause::OMPC_from) &&
1927             Tok.is(tok::colon)) {
1928           // Consume ':'
1929           ColonLocSecond = ConsumeToken();
1930           if (Tok.isNot(tok::r_square)) {
1931             Stride = ParseExpression();
1932           }
1933         }
1934       } else
1935         Idx = ParseExpression();
1936 
1937       SourceLocation RLoc = Tok.getLocation();
1938 
1939       LHS = Actions.CorrectDelayedTyposInExpr(LHS);
1940       Idx = Actions.CorrectDelayedTyposInExpr(Idx);
1941       Length = Actions.CorrectDelayedTyposInExpr(Length);
1942       if (!LHS.isInvalid() && !Idx.isInvalid() && !Length.isInvalid() &&
1943           !Stride.isInvalid() && Tok.is(tok::r_square)) {
1944         if (ColonLocFirst.isValid() || ColonLocSecond.isValid()) {
1945           LHS = Actions.ActOnOMPArraySectionExpr(
1946               LHS.get(), Loc, Idx.get(), ColonLocFirst, ColonLocSecond,
1947               Length.get(), Stride.get(), RLoc);
1948         } else {
1949           LHS = Actions.ActOnArraySubscriptExpr(getCurScope(), LHS.get(), Loc,
1950                                                 Idx.get(), RLoc);
1951         }
1952       } else {
1953         LHS = ExprError();
1954         Idx = ExprError();
1955       }
1956 
1957       // Match the ']'.
1958       T.consumeClose();
1959       break;
1960     }
1961 
1962     case tok::l_paren:         // p-e: p-e '(' argument-expression-list[opt] ')'
1963     case tok::lesslessless: {  // p-e: p-e '<<<' argument-expression-list '>>>'
1964                                //   '(' argument-expression-list[opt] ')'
1965       tok::TokenKind OpKind = Tok.getKind();
1966       InMessageExpressionRAIIObject InMessage(*this, false);
1967 
1968       Expr *ExecConfig = nullptr;
1969 
1970       BalancedDelimiterTracker PT(*this, tok::l_paren);
1971 
1972       if (OpKind == tok::lesslessless) {
1973         ExprVector ExecConfigExprs;
1974         CommaLocsTy ExecConfigCommaLocs;
1975         SourceLocation OpenLoc = ConsumeToken();
1976 
1977         if (ParseSimpleExpressionList(ExecConfigExprs, ExecConfigCommaLocs)) {
1978           (void)Actions.CorrectDelayedTyposInExpr(LHS);
1979           LHS = ExprError();
1980         }
1981 
1982         SourceLocation CloseLoc;
1983         if (TryConsumeToken(tok::greatergreatergreater, CloseLoc)) {
1984         } else if (LHS.isInvalid()) {
1985           SkipUntil(tok::greatergreatergreater, StopAtSemi);
1986         } else {
1987           // There was an error closing the brackets
1988           Diag(Tok, diag::err_expected) << tok::greatergreatergreater;
1989           Diag(OpenLoc, diag::note_matching) << tok::lesslessless;
1990           SkipUntil(tok::greatergreatergreater, StopAtSemi);
1991           LHS = ExprError();
1992         }
1993 
1994         if (!LHS.isInvalid()) {
1995           if (ExpectAndConsume(tok::l_paren))
1996             LHS = ExprError();
1997           else
1998             Loc = PrevTokLocation;
1999         }
2000 
2001         if (!LHS.isInvalid()) {
2002           ExprResult ECResult = Actions.ActOnCUDAExecConfigExpr(getCurScope(),
2003                                     OpenLoc,
2004                                     ExecConfigExprs,
2005                                     CloseLoc);
2006           if (ECResult.isInvalid())
2007             LHS = ExprError();
2008           else
2009             ExecConfig = ECResult.get();
2010         }
2011       } else {
2012         PT.consumeOpen();
2013         Loc = PT.getOpenLocation();
2014       }
2015 
2016       ExprVector ArgExprs;
2017       CommaLocsTy CommaLocs;
2018       auto RunSignatureHelp = [&]() -> QualType {
2019         QualType PreferredType = Actions.ProduceCallSignatureHelp(
2020             getCurScope(), LHS.get(), ArgExprs, PT.getOpenLocation());
2021         CalledSignatureHelp = true;
2022         return PreferredType;
2023       };
2024       if (OpKind == tok::l_paren || !LHS.isInvalid()) {
2025         if (Tok.isNot(tok::r_paren)) {
2026           if (ParseExpressionList(ArgExprs, CommaLocs, [&] {
2027                 PreferredType.enterFunctionArgument(Tok.getLocation(),
2028                                                     RunSignatureHelp);
2029               })) {
2030             (void)Actions.CorrectDelayedTyposInExpr(LHS);
2031             // If we got an error when parsing expression list, we don't call
2032             // the CodeCompleteCall handler inside the parser. So call it here
2033             // to make sure we get overload suggestions even when we are in the
2034             // middle of a parameter.
2035             if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
2036               RunSignatureHelp();
2037             LHS = ExprError();
2038           } else if (LHS.isInvalid()) {
2039             for (auto &E : ArgExprs)
2040               Actions.CorrectDelayedTyposInExpr(E);
2041           }
2042         }
2043       }
2044 
2045       // Match the ')'.
2046       if (LHS.isInvalid()) {
2047         SkipUntil(tok::r_paren, StopAtSemi);
2048       } else if (Tok.isNot(tok::r_paren)) {
2049         bool HadDelayedTypo = false;
2050         if (Actions.CorrectDelayedTyposInExpr(LHS).get() != LHS.get())
2051           HadDelayedTypo = true;
2052         for (auto &E : ArgExprs)
2053           if (Actions.CorrectDelayedTyposInExpr(E).get() != E)
2054             HadDelayedTypo = true;
2055         // If there were delayed typos in the LHS or ArgExprs, call SkipUntil
2056         // instead of PT.consumeClose() to avoid emitting extra diagnostics for
2057         // the unmatched l_paren.
2058         if (HadDelayedTypo)
2059           SkipUntil(tok::r_paren, StopAtSemi);
2060         else
2061           PT.consumeClose();
2062         LHS = ExprError();
2063       } else {
2064         assert(
2065             (ArgExprs.size() == 0 || ArgExprs.size() - 1 == CommaLocs.size()) &&
2066             "Unexpected number of commas!");
2067         Expr *Fn = LHS.get();
2068         SourceLocation RParLoc = Tok.getLocation();
2069         LHS = Actions.ActOnCallExpr(getCurScope(), Fn, Loc, ArgExprs, RParLoc,
2070                                     ExecConfig);
2071         if (LHS.isInvalid()) {
2072           ArgExprs.insert(ArgExprs.begin(), Fn);
2073           LHS =
2074               Actions.CreateRecoveryExpr(Fn->getBeginLoc(), RParLoc, ArgExprs);
2075         }
2076         PT.consumeClose();
2077       }
2078 
2079       break;
2080     }
2081     case tok::arrow:
2082     case tok::period: {
2083       // postfix-expression: p-e '->' template[opt] id-expression
2084       // postfix-expression: p-e '.' template[opt] id-expression
2085       tok::TokenKind OpKind = Tok.getKind();
2086       SourceLocation OpLoc = ConsumeToken();  // Eat the "." or "->" token.
2087 
2088       CXXScopeSpec SS;
2089       ParsedType ObjectType;
2090       bool MayBePseudoDestructor = false;
2091       Expr* OrigLHS = !LHS.isInvalid() ? LHS.get() : nullptr;
2092 
2093       PreferredType.enterMemAccess(Actions, Tok.getLocation(), OrigLHS);
2094 
2095       if (getLangOpts().CPlusPlus && !LHS.isInvalid()) {
2096         Expr *Base = OrigLHS;
2097         const Type* BaseType = Base->getType().getTypePtrOrNull();
2098         if (BaseType && Tok.is(tok::l_paren) &&
2099             (BaseType->isFunctionType() ||
2100              BaseType->isSpecificPlaceholderType(BuiltinType::BoundMember))) {
2101           Diag(OpLoc, diag::err_function_is_not_record)
2102               << OpKind << Base->getSourceRange()
2103               << FixItHint::CreateRemoval(OpLoc);
2104           return ParsePostfixExpressionSuffix(Base);
2105         }
2106 
2107         LHS = Actions.ActOnStartCXXMemberReference(getCurScope(), Base, OpLoc,
2108                                                    OpKind, ObjectType,
2109                                                    MayBePseudoDestructor);
2110         if (LHS.isInvalid()) {
2111           // Clang will try to perform expression based completion as a
2112           // fallback, which is confusing in case of member references. So we
2113           // stop here without any completions.
2114           if (Tok.is(tok::code_completion)) {
2115             cutOffParsing();
2116             return ExprError();
2117           }
2118           break;
2119         }
2120         ParseOptionalCXXScopeSpecifier(
2121             SS, ObjectType, LHS.get() && LHS.get()->containsErrors(),
2122             /*EnteringContext=*/false, &MayBePseudoDestructor);
2123         if (SS.isNotEmpty())
2124           ObjectType = nullptr;
2125       }
2126 
2127       if (Tok.is(tok::code_completion)) {
2128         tok::TokenKind CorrectedOpKind =
2129             OpKind == tok::arrow ? tok::period : tok::arrow;
2130         ExprResult CorrectedLHS(/*Invalid=*/true);
2131         if (getLangOpts().CPlusPlus && OrigLHS) {
2132           // FIXME: Creating a TentativeAnalysisScope from outside Sema is a
2133           // hack.
2134           Sema::TentativeAnalysisScope Trap(Actions);
2135           CorrectedLHS = Actions.ActOnStartCXXMemberReference(
2136               getCurScope(), OrigLHS, OpLoc, CorrectedOpKind, ObjectType,
2137               MayBePseudoDestructor);
2138         }
2139 
2140         Expr *Base = LHS.get();
2141         Expr *CorrectedBase = CorrectedLHS.get();
2142         if (!CorrectedBase && !getLangOpts().CPlusPlus)
2143           CorrectedBase = Base;
2144 
2145         // Code completion for a member access expression.
2146         cutOffParsing();
2147         Actions.CodeCompleteMemberReferenceExpr(
2148             getCurScope(), Base, CorrectedBase, OpLoc, OpKind == tok::arrow,
2149             Base && ExprStatementTokLoc == Base->getBeginLoc(),
2150             PreferredType.get(Tok.getLocation()));
2151 
2152         return ExprError();
2153       }
2154 
2155       if (MayBePseudoDestructor && !LHS.isInvalid()) {
2156         LHS = ParseCXXPseudoDestructor(LHS.get(), OpLoc, OpKind, SS,
2157                                        ObjectType);
2158         break;
2159       }
2160 
2161       // Either the action has told us that this cannot be a
2162       // pseudo-destructor expression (based on the type of base
2163       // expression), or we didn't see a '~' in the right place. We
2164       // can still parse a destructor name here, but in that case it
2165       // names a real destructor.
2166       // Allow explicit constructor calls in Microsoft mode.
2167       // FIXME: Add support for explicit call of template constructor.
2168       SourceLocation TemplateKWLoc;
2169       UnqualifiedId Name;
2170       if (getLangOpts().ObjC && OpKind == tok::period &&
2171           Tok.is(tok::kw_class)) {
2172         // Objective-C++:
2173         //   After a '.' in a member access expression, treat the keyword
2174         //   'class' as if it were an identifier.
2175         //
2176         // This hack allows property access to the 'class' method because it is
2177         // such a common method name. For other C++ keywords that are
2178         // Objective-C method names, one must use the message send syntax.
2179         IdentifierInfo *Id = Tok.getIdentifierInfo();
2180         SourceLocation Loc = ConsumeToken();
2181         Name.setIdentifier(Id, Loc);
2182       } else if (ParseUnqualifiedId(
2183                      SS, ObjectType, LHS.get() && LHS.get()->containsErrors(),
2184                      /*EnteringContext=*/false,
2185                      /*AllowDestructorName=*/true,
2186                      /*AllowConstructorName=*/
2187                      getLangOpts().MicrosoftExt && SS.isNotEmpty(),
2188                      /*AllowDeductionGuide=*/false, &TemplateKWLoc, Name)) {
2189         (void)Actions.CorrectDelayedTyposInExpr(LHS);
2190         LHS = ExprError();
2191       }
2192 
2193       if (!LHS.isInvalid())
2194         LHS = Actions.ActOnMemberAccessExpr(getCurScope(), LHS.get(), OpLoc,
2195                                             OpKind, SS, TemplateKWLoc, Name,
2196                                  CurParsedObjCImpl ? CurParsedObjCImpl->Dcl
2197                                                    : nullptr);
2198       if (!LHS.isInvalid()) {
2199         if (Tok.is(tok::less))
2200           checkPotentialAngleBracket(LHS);
2201       } else if (OrigLHS && Name.isValid()) {
2202         // Preserve the LHS if the RHS is an invalid member.
2203         LHS = Actions.CreateRecoveryExpr(OrigLHS->getBeginLoc(),
2204                                          Name.getEndLoc(), {OrigLHS});
2205       }
2206       break;
2207     }
2208     case tok::plusplus:    // postfix-expression: postfix-expression '++'
2209     case tok::minusminus:  // postfix-expression: postfix-expression '--'
2210       if (!LHS.isInvalid()) {
2211         Expr *Arg = LHS.get();
2212         LHS = Actions.ActOnPostfixUnaryOp(getCurScope(), Tok.getLocation(),
2213                                           Tok.getKind(), Arg);
2214         if (LHS.isInvalid())
2215           LHS = Actions.CreateRecoveryExpr(Arg->getBeginLoc(),
2216                                            Tok.getLocation(), Arg);
2217       }
2218       ConsumeToken();
2219       break;
2220     }
2221   }
2222 }
2223 
2224 /// ParseExprAfterUnaryExprOrTypeTrait - We parsed a typeof/sizeof/alignof/
2225 /// vec_step and we are at the start of an expression or a parenthesized
2226 /// type-id. OpTok is the operand token (typeof/sizeof/alignof). Returns the
2227 /// expression (isCastExpr == false) or the type (isCastExpr == true).
2228 ///
2229 /// \verbatim
2230 ///       unary-expression:  [C99 6.5.3]
2231 ///         'sizeof' unary-expression
2232 ///         'sizeof' '(' type-name ')'
2233 /// [GNU]   '__alignof' unary-expression
2234 /// [GNU]   '__alignof' '(' type-name ')'
2235 /// [C11]   '_Alignof' '(' type-name ')'
2236 /// [C++0x] 'alignof' '(' type-id ')'
2237 ///
2238 /// [GNU]   typeof-specifier:
2239 ///           typeof ( expressions )
2240 ///           typeof ( type-name )
2241 /// [GNU/C++] typeof unary-expression
2242 ///
2243 /// [OpenCL 1.1 6.11.12] vec_step built-in function:
2244 ///           vec_step ( expressions )
2245 ///           vec_step ( type-name )
2246 /// \endverbatim
2247 ExprResult
2248 Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok,
2249                                            bool &isCastExpr,
2250                                            ParsedType &CastTy,
2251                                            SourceRange &CastRange) {
2252 
2253   assert(OpTok.isOneOf(tok::kw_typeof, tok::kw_sizeof, tok::kw___alignof,
2254                        tok::kw_alignof, tok::kw__Alignof, tok::kw_vec_step,
2255                        tok::kw___builtin_omp_required_simd_align) &&
2256          "Not a typeof/sizeof/alignof/vec_step expression!");
2257 
2258   ExprResult Operand;
2259 
2260   // If the operand doesn't start with an '(', it must be an expression.
2261   if (Tok.isNot(tok::l_paren)) {
2262     // If construct allows a form without parenthesis, user may forget to put
2263     // pathenthesis around type name.
2264     if (OpTok.isOneOf(tok::kw_sizeof, tok::kw___alignof, tok::kw_alignof,
2265                       tok::kw__Alignof)) {
2266       if (isTypeIdUnambiguously()) {
2267         DeclSpec DS(AttrFactory);
2268         ParseSpecifierQualifierList(DS);
2269         Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
2270         ParseDeclarator(DeclaratorInfo);
2271 
2272         SourceLocation LParenLoc = PP.getLocForEndOfToken(OpTok.getLocation());
2273         SourceLocation RParenLoc = PP.getLocForEndOfToken(PrevTokLocation);
2274         if (LParenLoc.isInvalid() || RParenLoc.isInvalid()) {
2275           Diag(OpTok.getLocation(),
2276                diag::err_expected_parentheses_around_typename)
2277               << OpTok.getName();
2278         } else {
2279           Diag(LParenLoc, diag::err_expected_parentheses_around_typename)
2280               << OpTok.getName() << FixItHint::CreateInsertion(LParenLoc, "(")
2281               << FixItHint::CreateInsertion(RParenLoc, ")");
2282         }
2283         isCastExpr = true;
2284         return ExprEmpty();
2285       }
2286     }
2287 
2288     isCastExpr = false;
2289     if (OpTok.is(tok::kw_typeof) && !getLangOpts().CPlusPlus) {
2290       Diag(Tok, diag::err_expected_after) << OpTok.getIdentifierInfo()
2291                                           << tok::l_paren;
2292       return ExprError();
2293     }
2294 
2295     Operand = ParseCastExpression(UnaryExprOnly);
2296   } else {
2297     // If it starts with a '(', we know that it is either a parenthesized
2298     // type-name, or it is a unary-expression that starts with a compound
2299     // literal, or starts with a primary-expression that is a parenthesized
2300     // expression.
2301     ParenParseOption ExprType = CastExpr;
2302     SourceLocation LParenLoc = Tok.getLocation(), RParenLoc;
2303 
2304     Operand = ParseParenExpression(ExprType, true/*stopIfCastExpr*/,
2305                                    false, CastTy, RParenLoc);
2306     CastRange = SourceRange(LParenLoc, RParenLoc);
2307 
2308     // If ParseParenExpression parsed a '(typename)' sequence only, then this is
2309     // a type.
2310     if (ExprType == CastExpr) {
2311       isCastExpr = true;
2312       return ExprEmpty();
2313     }
2314 
2315     if (getLangOpts().CPlusPlus || OpTok.isNot(tok::kw_typeof)) {
2316       // GNU typeof in C requires the expression to be parenthesized. Not so for
2317       // sizeof/alignof or in C++. Therefore, the parenthesized expression is
2318       // the start of a unary-expression, but doesn't include any postfix
2319       // pieces. Parse these now if present.
2320       if (!Operand.isInvalid())
2321         Operand = ParsePostfixExpressionSuffix(Operand.get());
2322     }
2323   }
2324 
2325   // If we get here, the operand to the typeof/sizeof/alignof was an expression.
2326   isCastExpr = false;
2327   return Operand;
2328 }
2329 
2330 /// Parse a __builtin_sycl_unique_stable_name expression.  Accepts a type-id as
2331 /// a parameter.
2332 ExprResult Parser::ParseSYCLUniqueStableNameExpression() {
2333   assert(Tok.is(tok::kw___builtin_sycl_unique_stable_name) &&
2334          "Not __bulitin_sycl_unique_stable_name");
2335 
2336   SourceLocation OpLoc = ConsumeToken();
2337   BalancedDelimiterTracker T(*this, tok::l_paren);
2338 
2339   // __builtin_sycl_unique_stable_name expressions are always parenthesized.
2340   if (T.expectAndConsume(diag::err_expected_lparen_after,
2341                          "__builtin_sycl_unique_stable_name"))
2342     return ExprError();
2343 
2344   TypeResult Ty = ParseTypeName();
2345 
2346   if (Ty.isInvalid()) {
2347     T.skipToEnd();
2348     return ExprError();
2349   }
2350 
2351   if (T.consumeClose())
2352     return ExprError();
2353 
2354   return Actions.ActOnSYCLUniqueStableNameExpr(OpLoc, T.getOpenLocation(),
2355                                                T.getCloseLocation(), Ty.get());
2356 }
2357 
2358 /// Parse a sizeof or alignof expression.
2359 ///
2360 /// \verbatim
2361 ///       unary-expression:  [C99 6.5.3]
2362 ///         'sizeof' unary-expression
2363 ///         'sizeof' '(' type-name ')'
2364 /// [C++11] 'sizeof' '...' '(' identifier ')'
2365 /// [GNU]   '__alignof' unary-expression
2366 /// [GNU]   '__alignof' '(' type-name ')'
2367 /// [C11]   '_Alignof' '(' type-name ')'
2368 /// [C++11] 'alignof' '(' type-id ')'
2369 /// \endverbatim
2370 ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() {
2371   assert(Tok.isOneOf(tok::kw_sizeof, tok::kw___alignof, tok::kw_alignof,
2372                      tok::kw__Alignof, tok::kw_vec_step,
2373                      tok::kw___builtin_omp_required_simd_align) &&
2374          "Not a sizeof/alignof/vec_step expression!");
2375   Token OpTok = Tok;
2376   ConsumeToken();
2377 
2378   // [C++11] 'sizeof' '...' '(' identifier ')'
2379   if (Tok.is(tok::ellipsis) && OpTok.is(tok::kw_sizeof)) {
2380     SourceLocation EllipsisLoc = ConsumeToken();
2381     SourceLocation LParenLoc, RParenLoc;
2382     IdentifierInfo *Name = nullptr;
2383     SourceLocation NameLoc;
2384     if (Tok.is(tok::l_paren)) {
2385       BalancedDelimiterTracker T(*this, tok::l_paren);
2386       T.consumeOpen();
2387       LParenLoc = T.getOpenLocation();
2388       if (Tok.is(tok::identifier)) {
2389         Name = Tok.getIdentifierInfo();
2390         NameLoc = ConsumeToken();
2391         T.consumeClose();
2392         RParenLoc = T.getCloseLocation();
2393         if (RParenLoc.isInvalid())
2394           RParenLoc = PP.getLocForEndOfToken(NameLoc);
2395       } else {
2396         Diag(Tok, diag::err_expected_parameter_pack);
2397         SkipUntil(tok::r_paren, StopAtSemi);
2398       }
2399     } else if (Tok.is(tok::identifier)) {
2400       Name = Tok.getIdentifierInfo();
2401       NameLoc = ConsumeToken();
2402       LParenLoc = PP.getLocForEndOfToken(EllipsisLoc);
2403       RParenLoc = PP.getLocForEndOfToken(NameLoc);
2404       Diag(LParenLoc, diag::err_paren_sizeof_parameter_pack)
2405         << Name
2406         << FixItHint::CreateInsertion(LParenLoc, "(")
2407         << FixItHint::CreateInsertion(RParenLoc, ")");
2408     } else {
2409       Diag(Tok, diag::err_sizeof_parameter_pack);
2410     }
2411 
2412     if (!Name)
2413       return ExprError();
2414 
2415     EnterExpressionEvaluationContext Unevaluated(
2416         Actions, Sema::ExpressionEvaluationContext::Unevaluated,
2417         Sema::ReuseLambdaContextDecl);
2418 
2419     return Actions.ActOnSizeofParameterPackExpr(getCurScope(),
2420                                                 OpTok.getLocation(),
2421                                                 *Name, NameLoc,
2422                                                 RParenLoc);
2423   }
2424 
2425   if (OpTok.isOneOf(tok::kw_alignof, tok::kw__Alignof))
2426     Diag(OpTok, diag::warn_cxx98_compat_alignof);
2427 
2428   EnterExpressionEvaluationContext Unevaluated(
2429       Actions, Sema::ExpressionEvaluationContext::Unevaluated,
2430       Sema::ReuseLambdaContextDecl);
2431 
2432   bool isCastExpr;
2433   ParsedType CastTy;
2434   SourceRange CastRange;
2435   ExprResult Operand = ParseExprAfterUnaryExprOrTypeTrait(OpTok,
2436                                                           isCastExpr,
2437                                                           CastTy,
2438                                                           CastRange);
2439 
2440   UnaryExprOrTypeTrait ExprKind = UETT_SizeOf;
2441   if (OpTok.isOneOf(tok::kw_alignof, tok::kw__Alignof))
2442     ExprKind = UETT_AlignOf;
2443   else if (OpTok.is(tok::kw___alignof))
2444     ExprKind = UETT_PreferredAlignOf;
2445   else if (OpTok.is(tok::kw_vec_step))
2446     ExprKind = UETT_VecStep;
2447   else if (OpTok.is(tok::kw___builtin_omp_required_simd_align))
2448     ExprKind = UETT_OpenMPRequiredSimdAlign;
2449 
2450   if (isCastExpr)
2451     return Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(),
2452                                                  ExprKind,
2453                                                  /*IsType=*/true,
2454                                                  CastTy.getAsOpaquePtr(),
2455                                                  CastRange);
2456 
2457   if (OpTok.isOneOf(tok::kw_alignof, tok::kw__Alignof))
2458     Diag(OpTok, diag::ext_alignof_expr) << OpTok.getIdentifierInfo();
2459 
2460   // If we get here, the operand to the sizeof/alignof was an expression.
2461   if (!Operand.isInvalid())
2462     Operand = Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(),
2463                                                     ExprKind,
2464                                                     /*IsType=*/false,
2465                                                     Operand.get(),
2466                                                     CastRange);
2467   return Operand;
2468 }
2469 
2470 /// ParseBuiltinPrimaryExpression
2471 ///
2472 /// \verbatim
2473 ///       primary-expression: [C99 6.5.1]
2474 /// [GNU]   '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
2475 /// [GNU]   '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
2476 /// [GNU]   '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
2477 ///                                     assign-expr ')'
2478 /// [GNU]   '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
2479 /// [GNU]   '__builtin_FILE' '(' ')'
2480 /// [GNU]   '__builtin_FUNCTION' '(' ')'
2481 /// [GNU]   '__builtin_LINE' '(' ')'
2482 /// [CLANG] '__builtin_COLUMN' '(' ')'
2483 /// [OCL]   '__builtin_astype' '(' assignment-expression ',' type-name ')'
2484 ///
2485 /// [GNU] offsetof-member-designator:
2486 /// [GNU]   identifier
2487 /// [GNU]   offsetof-member-designator '.' identifier
2488 /// [GNU]   offsetof-member-designator '[' expression ']'
2489 /// \endverbatim
2490 ExprResult Parser::ParseBuiltinPrimaryExpression() {
2491   ExprResult Res;
2492   const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo();
2493 
2494   tok::TokenKind T = Tok.getKind();
2495   SourceLocation StartLoc = ConsumeToken();   // Eat the builtin identifier.
2496 
2497   // All of these start with an open paren.
2498   if (Tok.isNot(tok::l_paren))
2499     return ExprError(Diag(Tok, diag::err_expected_after) << BuiltinII
2500                                                          << tok::l_paren);
2501 
2502   BalancedDelimiterTracker PT(*this, tok::l_paren);
2503   PT.consumeOpen();
2504 
2505   // TODO: Build AST.
2506 
2507   switch (T) {
2508   default: llvm_unreachable("Not a builtin primary expression!");
2509   case tok::kw___builtin_va_arg: {
2510     ExprResult Expr(ParseAssignmentExpression());
2511 
2512     if (ExpectAndConsume(tok::comma)) {
2513       SkipUntil(tok::r_paren, StopAtSemi);
2514       Expr = ExprError();
2515     }
2516 
2517     TypeResult Ty = ParseTypeName();
2518 
2519     if (Tok.isNot(tok::r_paren)) {
2520       Diag(Tok, diag::err_expected) << tok::r_paren;
2521       Expr = ExprError();
2522     }
2523 
2524     if (Expr.isInvalid() || Ty.isInvalid())
2525       Res = ExprError();
2526     else
2527       Res = Actions.ActOnVAArg(StartLoc, Expr.get(), Ty.get(), ConsumeParen());
2528     break;
2529   }
2530   case tok::kw___builtin_offsetof: {
2531     SourceLocation TypeLoc = Tok.getLocation();
2532     TypeResult Ty = ParseTypeName();
2533     if (Ty.isInvalid()) {
2534       SkipUntil(tok::r_paren, StopAtSemi);
2535       return ExprError();
2536     }
2537 
2538     if (ExpectAndConsume(tok::comma)) {
2539       SkipUntil(tok::r_paren, StopAtSemi);
2540       return ExprError();
2541     }
2542 
2543     // We must have at least one identifier here.
2544     if (Tok.isNot(tok::identifier)) {
2545       Diag(Tok, diag::err_expected) << tok::identifier;
2546       SkipUntil(tok::r_paren, StopAtSemi);
2547       return ExprError();
2548     }
2549 
2550     // Keep track of the various subcomponents we see.
2551     SmallVector<Sema::OffsetOfComponent, 4> Comps;
2552 
2553     Comps.push_back(Sema::OffsetOfComponent());
2554     Comps.back().isBrackets = false;
2555     Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
2556     Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken();
2557 
2558     // FIXME: This loop leaks the index expressions on error.
2559     while (1) {
2560       if (Tok.is(tok::period)) {
2561         // offsetof-member-designator: offsetof-member-designator '.' identifier
2562         Comps.push_back(Sema::OffsetOfComponent());
2563         Comps.back().isBrackets = false;
2564         Comps.back().LocStart = ConsumeToken();
2565 
2566         if (Tok.isNot(tok::identifier)) {
2567           Diag(Tok, diag::err_expected) << tok::identifier;
2568           SkipUntil(tok::r_paren, StopAtSemi);
2569           return ExprError();
2570         }
2571         Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
2572         Comps.back().LocEnd = ConsumeToken();
2573 
2574       } else if (Tok.is(tok::l_square)) {
2575         if (CheckProhibitedCXX11Attribute())
2576           return ExprError();
2577 
2578         // offsetof-member-designator: offsetof-member-design '[' expression ']'
2579         Comps.push_back(Sema::OffsetOfComponent());
2580         Comps.back().isBrackets = true;
2581         BalancedDelimiterTracker ST(*this, tok::l_square);
2582         ST.consumeOpen();
2583         Comps.back().LocStart = ST.getOpenLocation();
2584         Res = ParseExpression();
2585         if (Res.isInvalid()) {
2586           SkipUntil(tok::r_paren, StopAtSemi);
2587           return Res;
2588         }
2589         Comps.back().U.E = Res.get();
2590 
2591         ST.consumeClose();
2592         Comps.back().LocEnd = ST.getCloseLocation();
2593       } else {
2594         if (Tok.isNot(tok::r_paren)) {
2595           PT.consumeClose();
2596           Res = ExprError();
2597         } else if (Ty.isInvalid()) {
2598           Res = ExprError();
2599         } else {
2600           PT.consumeClose();
2601           Res = Actions.ActOnBuiltinOffsetOf(getCurScope(), StartLoc, TypeLoc,
2602                                              Ty.get(), Comps,
2603                                              PT.getCloseLocation());
2604         }
2605         break;
2606       }
2607     }
2608     break;
2609   }
2610   case tok::kw___builtin_choose_expr: {
2611     ExprResult Cond(ParseAssignmentExpression());
2612     if (Cond.isInvalid()) {
2613       SkipUntil(tok::r_paren, StopAtSemi);
2614       return Cond;
2615     }
2616     if (ExpectAndConsume(tok::comma)) {
2617       SkipUntil(tok::r_paren, StopAtSemi);
2618       return ExprError();
2619     }
2620 
2621     ExprResult Expr1(ParseAssignmentExpression());
2622     if (Expr1.isInvalid()) {
2623       SkipUntil(tok::r_paren, StopAtSemi);
2624       return Expr1;
2625     }
2626     if (ExpectAndConsume(tok::comma)) {
2627       SkipUntil(tok::r_paren, StopAtSemi);
2628       return ExprError();
2629     }
2630 
2631     ExprResult Expr2(ParseAssignmentExpression());
2632     if (Expr2.isInvalid()) {
2633       SkipUntil(tok::r_paren, StopAtSemi);
2634       return Expr2;
2635     }
2636     if (Tok.isNot(tok::r_paren)) {
2637       Diag(Tok, diag::err_expected) << tok::r_paren;
2638       return ExprError();
2639     }
2640     Res = Actions.ActOnChooseExpr(StartLoc, Cond.get(), Expr1.get(),
2641                                   Expr2.get(), ConsumeParen());
2642     break;
2643   }
2644   case tok::kw___builtin_astype: {
2645     // The first argument is an expression to be converted, followed by a comma.
2646     ExprResult Expr(ParseAssignmentExpression());
2647     if (Expr.isInvalid()) {
2648       SkipUntil(tok::r_paren, StopAtSemi);
2649       return ExprError();
2650     }
2651 
2652     if (ExpectAndConsume(tok::comma)) {
2653       SkipUntil(tok::r_paren, StopAtSemi);
2654       return ExprError();
2655     }
2656 
2657     // Second argument is the type to bitcast to.
2658     TypeResult DestTy = ParseTypeName();
2659     if (DestTy.isInvalid())
2660       return ExprError();
2661 
2662     // Attempt to consume the r-paren.
2663     if (Tok.isNot(tok::r_paren)) {
2664       Diag(Tok, diag::err_expected) << tok::r_paren;
2665       SkipUntil(tok::r_paren, StopAtSemi);
2666       return ExprError();
2667     }
2668 
2669     Res = Actions.ActOnAsTypeExpr(Expr.get(), DestTy.get(), StartLoc,
2670                                   ConsumeParen());
2671     break;
2672   }
2673   case tok::kw___builtin_convertvector: {
2674     // The first argument is an expression to be converted, followed by a comma.
2675     ExprResult Expr(ParseAssignmentExpression());
2676     if (Expr.isInvalid()) {
2677       SkipUntil(tok::r_paren, StopAtSemi);
2678       return ExprError();
2679     }
2680 
2681     if (ExpectAndConsume(tok::comma)) {
2682       SkipUntil(tok::r_paren, StopAtSemi);
2683       return ExprError();
2684     }
2685 
2686     // Second argument is the type to bitcast to.
2687     TypeResult DestTy = ParseTypeName();
2688     if (DestTy.isInvalid())
2689       return ExprError();
2690 
2691     // Attempt to consume the r-paren.
2692     if (Tok.isNot(tok::r_paren)) {
2693       Diag(Tok, diag::err_expected) << tok::r_paren;
2694       SkipUntil(tok::r_paren, StopAtSemi);
2695       return ExprError();
2696     }
2697 
2698     Res = Actions.ActOnConvertVectorExpr(Expr.get(), DestTy.get(), StartLoc,
2699                                          ConsumeParen());
2700     break;
2701   }
2702   case tok::kw___builtin_COLUMN:
2703   case tok::kw___builtin_FILE:
2704   case tok::kw___builtin_FUNCTION:
2705   case tok::kw___builtin_LINE: {
2706     // Attempt to consume the r-paren.
2707     if (Tok.isNot(tok::r_paren)) {
2708       Diag(Tok, diag::err_expected) << tok::r_paren;
2709       SkipUntil(tok::r_paren, StopAtSemi);
2710       return ExprError();
2711     }
2712     SourceLocExpr::IdentKind Kind = [&] {
2713       switch (T) {
2714       case tok::kw___builtin_FILE:
2715         return SourceLocExpr::File;
2716       case tok::kw___builtin_FUNCTION:
2717         return SourceLocExpr::Function;
2718       case tok::kw___builtin_LINE:
2719         return SourceLocExpr::Line;
2720       case tok::kw___builtin_COLUMN:
2721         return SourceLocExpr::Column;
2722       default:
2723         llvm_unreachable("invalid keyword");
2724       }
2725     }();
2726     Res = Actions.ActOnSourceLocExpr(Kind, StartLoc, ConsumeParen());
2727     break;
2728   }
2729   }
2730 
2731   if (Res.isInvalid())
2732     return ExprError();
2733 
2734   // These can be followed by postfix-expr pieces because they are
2735   // primary-expressions.
2736   return ParsePostfixExpressionSuffix(Res.get());
2737 }
2738 
2739 bool Parser::tryParseOpenMPArrayShapingCastPart() {
2740   assert(Tok.is(tok::l_square) && "Expected open bracket");
2741   bool ErrorFound = true;
2742   TentativeParsingAction TPA(*this);
2743   do {
2744     if (Tok.isNot(tok::l_square))
2745       break;
2746     // Consume '['
2747     ConsumeBracket();
2748     // Skip inner expression.
2749     while (!SkipUntil(tok::r_square, tok::annot_pragma_openmp_end,
2750                       StopAtSemi | StopBeforeMatch))
2751       ;
2752     if (Tok.isNot(tok::r_square))
2753       break;
2754     // Consume ']'
2755     ConsumeBracket();
2756     // Found ')' - done.
2757     if (Tok.is(tok::r_paren)) {
2758       ErrorFound = false;
2759       break;
2760     }
2761   } while (Tok.isNot(tok::annot_pragma_openmp_end));
2762   TPA.Revert();
2763   return !ErrorFound;
2764 }
2765 
2766 /// ParseParenExpression - This parses the unit that starts with a '(' token,
2767 /// based on what is allowed by ExprType.  The actual thing parsed is returned
2768 /// in ExprType. If stopIfCastExpr is true, it will only return the parsed type,
2769 /// not the parsed cast-expression.
2770 ///
2771 /// \verbatim
2772 ///       primary-expression: [C99 6.5.1]
2773 ///         '(' expression ')'
2774 /// [GNU]   '(' compound-statement ')'      (if !ParenExprOnly)
2775 ///       postfix-expression: [C99 6.5.2]
2776 ///         '(' type-name ')' '{' initializer-list '}'
2777 ///         '(' type-name ')' '{' initializer-list ',' '}'
2778 ///       cast-expression: [C99 6.5.4]
2779 ///         '(' type-name ')' cast-expression
2780 /// [ARC]   bridged-cast-expression
2781 /// [ARC] bridged-cast-expression:
2782 ///         (__bridge type-name) cast-expression
2783 ///         (__bridge_transfer type-name) cast-expression
2784 ///         (__bridge_retained type-name) cast-expression
2785 ///       fold-expression: [C++1z]
2786 ///         '(' cast-expression fold-operator '...' ')'
2787 ///         '(' '...' fold-operator cast-expression ')'
2788 ///         '(' cast-expression fold-operator '...'
2789 ///                 fold-operator cast-expression ')'
2790 /// [OPENMP] Array shaping operation
2791 ///       '(' '[' expression ']' { '[' expression ']' } cast-expression
2792 /// \endverbatim
2793 ExprResult
2794 Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr,
2795                              bool isTypeCast, ParsedType &CastTy,
2796                              SourceLocation &RParenLoc) {
2797   assert(Tok.is(tok::l_paren) && "Not a paren expr!");
2798   ColonProtectionRAIIObject ColonProtection(*this, false);
2799   BalancedDelimiterTracker T(*this, tok::l_paren);
2800   if (T.consumeOpen())
2801     return ExprError();
2802   SourceLocation OpenLoc = T.getOpenLocation();
2803 
2804   PreferredType.enterParenExpr(Tok.getLocation(), OpenLoc);
2805 
2806   ExprResult Result(true);
2807   bool isAmbiguousTypeId;
2808   CastTy = nullptr;
2809 
2810   if (Tok.is(tok::code_completion)) {
2811     cutOffParsing();
2812     Actions.CodeCompleteExpression(
2813         getCurScope(), PreferredType.get(Tok.getLocation()),
2814         /*IsParenthesized=*/ExprType >= CompoundLiteral);
2815     return ExprError();
2816   }
2817 
2818   // Diagnose use of bridge casts in non-arc mode.
2819   bool BridgeCast = (getLangOpts().ObjC &&
2820                      Tok.isOneOf(tok::kw___bridge,
2821                                  tok::kw___bridge_transfer,
2822                                  tok::kw___bridge_retained,
2823                                  tok::kw___bridge_retain));
2824   if (BridgeCast && !getLangOpts().ObjCAutoRefCount) {
2825     if (!TryConsumeToken(tok::kw___bridge)) {
2826       StringRef BridgeCastName = Tok.getName();
2827       SourceLocation BridgeKeywordLoc = ConsumeToken();
2828       if (!PP.getSourceManager().isInSystemHeader(BridgeKeywordLoc))
2829         Diag(BridgeKeywordLoc, diag::warn_arc_bridge_cast_nonarc)
2830           << BridgeCastName
2831           << FixItHint::CreateReplacement(BridgeKeywordLoc, "");
2832     }
2833     BridgeCast = false;
2834   }
2835 
2836   // None of these cases should fall through with an invalid Result
2837   // unless they've already reported an error.
2838   if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) {
2839     Diag(Tok, diag::ext_gnu_statement_expr);
2840 
2841     checkCompoundToken(OpenLoc, tok::l_paren, CompoundToken::StmtExprBegin);
2842 
2843     if (!getCurScope()->getFnParent() && !getCurScope()->getBlockParent()) {
2844       Result = ExprError(Diag(OpenLoc, diag::err_stmtexpr_file_scope));
2845     } else {
2846       // Find the nearest non-record decl context. Variables declared in a
2847       // statement expression behave as if they were declared in the enclosing
2848       // function, block, or other code construct.
2849       DeclContext *CodeDC = Actions.CurContext;
2850       while (CodeDC->isRecord() || isa<EnumDecl>(CodeDC)) {
2851         CodeDC = CodeDC->getParent();
2852         assert(CodeDC && !CodeDC->isFileContext() &&
2853                "statement expr not in code context");
2854       }
2855       Sema::ContextRAII SavedContext(Actions, CodeDC, /*NewThisContext=*/false);
2856 
2857       Actions.ActOnStartStmtExpr();
2858 
2859       StmtResult Stmt(ParseCompoundStatement(true));
2860       ExprType = CompoundStmt;
2861 
2862       // If the substmt parsed correctly, build the AST node.
2863       if (!Stmt.isInvalid()) {
2864         Result = Actions.ActOnStmtExpr(getCurScope(), OpenLoc, Stmt.get(),
2865                                        Tok.getLocation());
2866       } else {
2867         Actions.ActOnStmtExprError();
2868       }
2869     }
2870   } else if (ExprType >= CompoundLiteral && BridgeCast) {
2871     tok::TokenKind tokenKind = Tok.getKind();
2872     SourceLocation BridgeKeywordLoc = ConsumeToken();
2873 
2874     // Parse an Objective-C ARC ownership cast expression.
2875     ObjCBridgeCastKind Kind;
2876     if (tokenKind == tok::kw___bridge)
2877       Kind = OBC_Bridge;
2878     else if (tokenKind == tok::kw___bridge_transfer)
2879       Kind = OBC_BridgeTransfer;
2880     else if (tokenKind == tok::kw___bridge_retained)
2881       Kind = OBC_BridgeRetained;
2882     else {
2883       // As a hopefully temporary workaround, allow __bridge_retain as
2884       // a synonym for __bridge_retained, but only in system headers.
2885       assert(tokenKind == tok::kw___bridge_retain);
2886       Kind = OBC_BridgeRetained;
2887       if (!PP.getSourceManager().isInSystemHeader(BridgeKeywordLoc))
2888         Diag(BridgeKeywordLoc, diag::err_arc_bridge_retain)
2889           << FixItHint::CreateReplacement(BridgeKeywordLoc,
2890                                           "__bridge_retained");
2891     }
2892 
2893     TypeResult Ty = ParseTypeName();
2894     T.consumeClose();
2895     ColonProtection.restore();
2896     RParenLoc = T.getCloseLocation();
2897 
2898     PreferredType.enterTypeCast(Tok.getLocation(), Ty.get().get());
2899     ExprResult SubExpr = ParseCastExpression(AnyCastExpr);
2900 
2901     if (Ty.isInvalid() || SubExpr.isInvalid())
2902       return ExprError();
2903 
2904     return Actions.ActOnObjCBridgedCast(getCurScope(), OpenLoc, Kind,
2905                                         BridgeKeywordLoc, Ty.get(),
2906                                         RParenLoc, SubExpr.get());
2907   } else if (ExprType >= CompoundLiteral &&
2908              isTypeIdInParens(isAmbiguousTypeId)) {
2909 
2910     // Otherwise, this is a compound literal expression or cast expression.
2911 
2912     // In C++, if the type-id is ambiguous we disambiguate based on context.
2913     // If stopIfCastExpr is true the context is a typeof/sizeof/alignof
2914     // in which case we should treat it as type-id.
2915     // if stopIfCastExpr is false, we need to determine the context past the
2916     // parens, so we defer to ParseCXXAmbiguousParenExpression for that.
2917     if (isAmbiguousTypeId && !stopIfCastExpr) {
2918       ExprResult res = ParseCXXAmbiguousParenExpression(ExprType, CastTy, T,
2919                                                         ColonProtection);
2920       RParenLoc = T.getCloseLocation();
2921       return res;
2922     }
2923 
2924     // Parse the type declarator.
2925     DeclSpec DS(AttrFactory);
2926     ParseSpecifierQualifierList(DS);
2927     Declarator DeclaratorInfo(DS, DeclaratorContext::TypeName);
2928     ParseDeclarator(DeclaratorInfo);
2929 
2930     // If our type is followed by an identifier and either ':' or ']', then
2931     // this is probably an Objective-C message send where the leading '[' is
2932     // missing. Recover as if that were the case.
2933     if (!DeclaratorInfo.isInvalidType() && Tok.is(tok::identifier) &&
2934         !InMessageExpression && getLangOpts().ObjC &&
2935         (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) {
2936       TypeResult Ty;
2937       {
2938         InMessageExpressionRAIIObject InMessage(*this, false);
2939         Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
2940       }
2941       Result = ParseObjCMessageExpressionBody(SourceLocation(),
2942                                               SourceLocation(),
2943                                               Ty.get(), nullptr);
2944     } else {
2945       // Match the ')'.
2946       T.consumeClose();
2947       ColonProtection.restore();
2948       RParenLoc = T.getCloseLocation();
2949       if (Tok.is(tok::l_brace)) {
2950         ExprType = CompoundLiteral;
2951         TypeResult Ty;
2952         {
2953           InMessageExpressionRAIIObject InMessage(*this, false);
2954           Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
2955         }
2956         return ParseCompoundLiteralExpression(Ty.get(), OpenLoc, RParenLoc);
2957       }
2958 
2959       if (Tok.is(tok::l_paren)) {
2960         // This could be OpenCL vector Literals
2961         if (getLangOpts().OpenCL)
2962         {
2963           TypeResult Ty;
2964           {
2965             InMessageExpressionRAIIObject InMessage(*this, false);
2966             Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
2967           }
2968           if(Ty.isInvalid())
2969           {
2970              return ExprError();
2971           }
2972           QualType QT = Ty.get().get().getCanonicalType();
2973           if (QT->isVectorType())
2974           {
2975             // We parsed '(' vector-type-name ')' followed by '('
2976 
2977             // Parse the cast-expression that follows it next.
2978             // isVectorLiteral = true will make sure we don't parse any
2979             // Postfix expression yet
2980             Result = ParseCastExpression(/*isUnaryExpression=*/AnyCastExpr,
2981                                          /*isAddressOfOperand=*/false,
2982                                          /*isTypeCast=*/IsTypeCast,
2983                                          /*isVectorLiteral=*/true);
2984 
2985             if (!Result.isInvalid()) {
2986               Result = Actions.ActOnCastExpr(getCurScope(), OpenLoc,
2987                                              DeclaratorInfo, CastTy,
2988                                              RParenLoc, Result.get());
2989             }
2990 
2991             // After we performed the cast we can check for postfix-expr pieces.
2992             if (!Result.isInvalid()) {
2993               Result = ParsePostfixExpressionSuffix(Result);
2994             }
2995 
2996             return Result;
2997           }
2998         }
2999       }
3000 
3001       if (ExprType == CastExpr) {
3002         // We parsed '(' type-name ')' and the thing after it wasn't a '{'.
3003 
3004         if (DeclaratorInfo.isInvalidType())
3005           return ExprError();
3006 
3007         // Note that this doesn't parse the subsequent cast-expression, it just
3008         // returns the parsed type to the callee.
3009         if (stopIfCastExpr) {
3010           TypeResult Ty;
3011           {
3012             InMessageExpressionRAIIObject InMessage(*this, false);
3013             Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
3014           }
3015           CastTy = Ty.get();
3016           return ExprResult();
3017         }
3018 
3019         // Reject the cast of super idiom in ObjC.
3020         if (Tok.is(tok::identifier) && getLangOpts().ObjC &&
3021             Tok.getIdentifierInfo() == Ident_super &&
3022             getCurScope()->isInObjcMethodScope() &&
3023             GetLookAheadToken(1).isNot(tok::period)) {
3024           Diag(Tok.getLocation(), diag::err_illegal_super_cast)
3025             << SourceRange(OpenLoc, RParenLoc);
3026           return ExprError();
3027         }
3028 
3029         PreferredType.enterTypeCast(Tok.getLocation(), CastTy.get());
3030         // Parse the cast-expression that follows it next.
3031         // TODO: For cast expression with CastTy.
3032         Result = ParseCastExpression(/*isUnaryExpression=*/AnyCastExpr,
3033                                      /*isAddressOfOperand=*/false,
3034                                      /*isTypeCast=*/IsTypeCast);
3035         if (!Result.isInvalid()) {
3036           Result = Actions.ActOnCastExpr(getCurScope(), OpenLoc,
3037                                          DeclaratorInfo, CastTy,
3038                                          RParenLoc, Result.get());
3039         }
3040         return Result;
3041       }
3042 
3043       Diag(Tok, diag::err_expected_lbrace_in_compound_literal);
3044       return ExprError();
3045     }
3046   } else if (ExprType >= FoldExpr && Tok.is(tok::ellipsis) &&
3047              isFoldOperator(NextToken().getKind())) {
3048     ExprType = FoldExpr;
3049     return ParseFoldExpression(ExprResult(), T);
3050   } else if (isTypeCast) {
3051     // Parse the expression-list.
3052     InMessageExpressionRAIIObject InMessage(*this, false);
3053 
3054     ExprVector ArgExprs;
3055     CommaLocsTy CommaLocs;
3056 
3057     if (!ParseSimpleExpressionList(ArgExprs, CommaLocs)) {
3058       // FIXME: If we ever support comma expressions as operands to
3059       // fold-expressions, we'll need to allow multiple ArgExprs here.
3060       if (ExprType >= FoldExpr && ArgExprs.size() == 1 &&
3061           isFoldOperator(Tok.getKind()) && NextToken().is(tok::ellipsis)) {
3062         ExprType = FoldExpr;
3063         return ParseFoldExpression(ArgExprs[0], T);
3064       }
3065 
3066       ExprType = SimpleExpr;
3067       Result = Actions.ActOnParenListExpr(OpenLoc, Tok.getLocation(),
3068                                           ArgExprs);
3069     }
3070   } else if (getLangOpts().OpenMP >= 50 && OpenMPDirectiveParsing &&
3071              ExprType == CastExpr && Tok.is(tok::l_square) &&
3072              tryParseOpenMPArrayShapingCastPart()) {
3073     bool ErrorFound = false;
3074     SmallVector<Expr *, 4> OMPDimensions;
3075     SmallVector<SourceRange, 4> OMPBracketsRanges;
3076     do {
3077       BalancedDelimiterTracker TS(*this, tok::l_square);
3078       TS.consumeOpen();
3079       ExprResult NumElements =
3080           Actions.CorrectDelayedTyposInExpr(ParseExpression());
3081       if (!NumElements.isUsable()) {
3082         ErrorFound = true;
3083         while (!SkipUntil(tok::r_square, tok::r_paren,
3084                           StopAtSemi | StopBeforeMatch))
3085           ;
3086       }
3087       TS.consumeClose();
3088       OMPDimensions.push_back(NumElements.get());
3089       OMPBracketsRanges.push_back(TS.getRange());
3090     } while (Tok.isNot(tok::r_paren));
3091     // Match the ')'.
3092     T.consumeClose();
3093     RParenLoc = T.getCloseLocation();
3094     Result = Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
3095     if (ErrorFound) {
3096       Result = ExprError();
3097     } else if (!Result.isInvalid()) {
3098       Result = Actions.ActOnOMPArrayShapingExpr(
3099           Result.get(), OpenLoc, RParenLoc, OMPDimensions, OMPBracketsRanges);
3100     }
3101     return Result;
3102   } else {
3103     InMessageExpressionRAIIObject InMessage(*this, false);
3104 
3105     Result = ParseExpression(MaybeTypeCast);
3106     if (!getLangOpts().CPlusPlus && MaybeTypeCast && Result.isUsable()) {
3107       // Correct typos in non-C++ code earlier so that implicit-cast-like
3108       // expressions are parsed correctly.
3109       Result = Actions.CorrectDelayedTyposInExpr(Result);
3110     }
3111 
3112     if (ExprType >= FoldExpr && isFoldOperator(Tok.getKind()) &&
3113         NextToken().is(tok::ellipsis)) {
3114       ExprType = FoldExpr;
3115       return ParseFoldExpression(Result, T);
3116     }
3117     ExprType = SimpleExpr;
3118 
3119     // Don't build a paren expression unless we actually match a ')'.
3120     if (!Result.isInvalid() && Tok.is(tok::r_paren))
3121       Result =
3122           Actions.ActOnParenExpr(OpenLoc, Tok.getLocation(), Result.get());
3123   }
3124 
3125   // Match the ')'.
3126   if (Result.isInvalid()) {
3127     SkipUntil(tok::r_paren, StopAtSemi);
3128     return ExprError();
3129   }
3130 
3131   T.consumeClose();
3132   RParenLoc = T.getCloseLocation();
3133   return Result;
3134 }
3135 
3136 /// ParseCompoundLiteralExpression - We have parsed the parenthesized type-name
3137 /// and we are at the left brace.
3138 ///
3139 /// \verbatim
3140 ///       postfix-expression: [C99 6.5.2]
3141 ///         '(' type-name ')' '{' initializer-list '}'
3142 ///         '(' type-name ')' '{' initializer-list ',' '}'
3143 /// \endverbatim
3144 ExprResult
3145 Parser::ParseCompoundLiteralExpression(ParsedType Ty,
3146                                        SourceLocation LParenLoc,
3147                                        SourceLocation RParenLoc) {
3148   assert(Tok.is(tok::l_brace) && "Not a compound literal!");
3149   if (!getLangOpts().C99)   // Compound literals don't exist in C90.
3150     Diag(LParenLoc, diag::ext_c99_compound_literal);
3151   PreferredType.enterTypeCast(Tok.getLocation(), Ty.get());
3152   ExprResult Result = ParseInitializer();
3153   if (!Result.isInvalid() && Ty)
3154     return Actions.ActOnCompoundLiteral(LParenLoc, Ty, RParenLoc, Result.get());
3155   return Result;
3156 }
3157 
3158 /// ParseStringLiteralExpression - This handles the various token types that
3159 /// form string literals, and also handles string concatenation [C99 5.1.1.2,
3160 /// translation phase #6].
3161 ///
3162 /// \verbatim
3163 ///       primary-expression: [C99 6.5.1]
3164 ///         string-literal
3165 /// \verbatim
3166 ExprResult Parser::ParseStringLiteralExpression(bool AllowUserDefinedLiteral) {
3167   assert(isTokenStringLiteral() && "Not a string literal!");
3168 
3169   // String concat.  Note that keywords like __func__ and __FUNCTION__ are not
3170   // considered to be strings for concatenation purposes.
3171   SmallVector<Token, 4> StringToks;
3172 
3173   do {
3174     StringToks.push_back(Tok);
3175     ConsumeStringToken();
3176   } while (isTokenStringLiteral());
3177 
3178   // Pass the set of string tokens, ready for concatenation, to the actions.
3179   return Actions.ActOnStringLiteral(StringToks,
3180                                     AllowUserDefinedLiteral ? getCurScope()
3181                                                             : nullptr);
3182 }
3183 
3184 /// ParseGenericSelectionExpression - Parse a C11 generic-selection
3185 /// [C11 6.5.1.1].
3186 ///
3187 /// \verbatim
3188 ///    generic-selection:
3189 ///           _Generic ( assignment-expression , generic-assoc-list )
3190 ///    generic-assoc-list:
3191 ///           generic-association
3192 ///           generic-assoc-list , generic-association
3193 ///    generic-association:
3194 ///           type-name : assignment-expression
3195 ///           default : assignment-expression
3196 /// \endverbatim
3197 ExprResult Parser::ParseGenericSelectionExpression() {
3198   assert(Tok.is(tok::kw__Generic) && "_Generic keyword expected");
3199   if (!getLangOpts().C11)
3200     Diag(Tok, diag::ext_c11_feature) << Tok.getName();
3201 
3202   SourceLocation KeyLoc = ConsumeToken();
3203   BalancedDelimiterTracker T(*this, tok::l_paren);
3204   if (T.expectAndConsume())
3205     return ExprError();
3206 
3207   ExprResult ControllingExpr;
3208   {
3209     // C11 6.5.1.1p3 "The controlling expression of a generic selection is
3210     // not evaluated."
3211     EnterExpressionEvaluationContext Unevaluated(
3212         Actions, Sema::ExpressionEvaluationContext::Unevaluated);
3213     ControllingExpr =
3214         Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
3215     if (ControllingExpr.isInvalid()) {
3216       SkipUntil(tok::r_paren, StopAtSemi);
3217       return ExprError();
3218     }
3219   }
3220 
3221   if (ExpectAndConsume(tok::comma)) {
3222     SkipUntil(tok::r_paren, StopAtSemi);
3223     return ExprError();
3224   }
3225 
3226   SourceLocation DefaultLoc;
3227   TypeVector Types;
3228   ExprVector Exprs;
3229   do {
3230     ParsedType Ty;
3231     if (Tok.is(tok::kw_default)) {
3232       // C11 6.5.1.1p2 "A generic selection shall have no more than one default
3233       // generic association."
3234       if (!DefaultLoc.isInvalid()) {
3235         Diag(Tok, diag::err_duplicate_default_assoc);
3236         Diag(DefaultLoc, diag::note_previous_default_assoc);
3237         SkipUntil(tok::r_paren, StopAtSemi);
3238         return ExprError();
3239       }
3240       DefaultLoc = ConsumeToken();
3241       Ty = nullptr;
3242     } else {
3243       ColonProtectionRAIIObject X(*this);
3244       TypeResult TR = ParseTypeName();
3245       if (TR.isInvalid()) {
3246         SkipUntil(tok::r_paren, StopAtSemi);
3247         return ExprError();
3248       }
3249       Ty = TR.get();
3250     }
3251     Types.push_back(Ty);
3252 
3253     if (ExpectAndConsume(tok::colon)) {
3254       SkipUntil(tok::r_paren, StopAtSemi);
3255       return ExprError();
3256     }
3257 
3258     // FIXME: These expressions should be parsed in a potentially potentially
3259     // evaluated context.
3260     ExprResult ER(
3261         Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression()));
3262     if (ER.isInvalid()) {
3263       SkipUntil(tok::r_paren, StopAtSemi);
3264       return ExprError();
3265     }
3266     Exprs.push_back(ER.get());
3267   } while (TryConsumeToken(tok::comma));
3268 
3269   T.consumeClose();
3270   if (T.getCloseLocation().isInvalid())
3271     return ExprError();
3272 
3273   return Actions.ActOnGenericSelectionExpr(KeyLoc, DefaultLoc,
3274                                            T.getCloseLocation(),
3275                                            ControllingExpr.get(),
3276                                            Types, Exprs);
3277 }
3278 
3279 /// Parse A C++1z fold-expression after the opening paren and optional
3280 /// left-hand-side expression.
3281 ///
3282 /// \verbatim
3283 ///   fold-expression:
3284 ///       ( cast-expression fold-operator ... )
3285 ///       ( ... fold-operator cast-expression )
3286 ///       ( cast-expression fold-operator ... fold-operator cast-expression )
3287 ExprResult Parser::ParseFoldExpression(ExprResult LHS,
3288                                        BalancedDelimiterTracker &T) {
3289   if (LHS.isInvalid()) {
3290     T.skipToEnd();
3291     return true;
3292   }
3293 
3294   tok::TokenKind Kind = tok::unknown;
3295   SourceLocation FirstOpLoc;
3296   if (LHS.isUsable()) {
3297     Kind = Tok.getKind();
3298     assert(isFoldOperator(Kind) && "missing fold-operator");
3299     FirstOpLoc = ConsumeToken();
3300   }
3301 
3302   assert(Tok.is(tok::ellipsis) && "not a fold-expression");
3303   SourceLocation EllipsisLoc = ConsumeToken();
3304 
3305   ExprResult RHS;
3306   if (Tok.isNot(tok::r_paren)) {
3307     if (!isFoldOperator(Tok.getKind()))
3308       return Diag(Tok.getLocation(), diag::err_expected_fold_operator);
3309 
3310     if (Kind != tok::unknown && Tok.getKind() != Kind)
3311       Diag(Tok.getLocation(), diag::err_fold_operator_mismatch)
3312         << SourceRange(FirstOpLoc);
3313     Kind = Tok.getKind();
3314     ConsumeToken();
3315 
3316     RHS = ParseExpression();
3317     if (RHS.isInvalid()) {
3318       T.skipToEnd();
3319       return true;
3320     }
3321   }
3322 
3323   Diag(EllipsisLoc, getLangOpts().CPlusPlus17
3324                         ? diag::warn_cxx14_compat_fold_expression
3325                         : diag::ext_fold_expression);
3326 
3327   T.consumeClose();
3328   return Actions.ActOnCXXFoldExpr(getCurScope(), T.getOpenLocation(), LHS.get(),
3329                                   Kind, EllipsisLoc, RHS.get(),
3330                                   T.getCloseLocation());
3331 }
3332 
3333 /// ParseExpressionList - Used for C/C++ (argument-)expression-list.
3334 ///
3335 /// \verbatim
3336 ///       argument-expression-list:
3337 ///         assignment-expression
3338 ///         argument-expression-list , assignment-expression
3339 ///
3340 /// [C++] expression-list:
3341 /// [C++]   assignment-expression
3342 /// [C++]   expression-list , assignment-expression
3343 ///
3344 /// [C++0x] expression-list:
3345 /// [C++0x]   initializer-list
3346 ///
3347 /// [C++0x] initializer-list
3348 /// [C++0x]   initializer-clause ...[opt]
3349 /// [C++0x]   initializer-list , initializer-clause ...[opt]
3350 ///
3351 /// [C++0x] initializer-clause:
3352 /// [C++0x]   assignment-expression
3353 /// [C++0x]   braced-init-list
3354 /// \endverbatim
3355 bool Parser::ParseExpressionList(SmallVectorImpl<Expr *> &Exprs,
3356                                  SmallVectorImpl<SourceLocation> &CommaLocs,
3357                                  llvm::function_ref<void()> ExpressionStarts) {
3358   bool SawError = false;
3359   while (1) {
3360     if (ExpressionStarts)
3361       ExpressionStarts();
3362 
3363     ExprResult Expr;
3364     if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
3365       Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
3366       Expr = ParseBraceInitializer();
3367     } else
3368       Expr = ParseAssignmentExpression();
3369 
3370     if (Tok.is(tok::ellipsis))
3371       Expr = Actions.ActOnPackExpansion(Expr.get(), ConsumeToken());
3372     else if (Tok.is(tok::code_completion)) {
3373       // There's nothing to suggest in here as we parsed a full expression.
3374       // Instead fail and propogate the error since caller might have something
3375       // the suggest, e.g. signature help in function call. Note that this is
3376       // performed before pushing the \p Expr, so that signature help can report
3377       // current argument correctly.
3378       SawError = true;
3379       cutOffParsing();
3380       break;
3381     }
3382     if (Expr.isInvalid()) {
3383       SkipUntil(tok::comma, tok::r_paren, StopBeforeMatch);
3384       SawError = true;
3385     } else {
3386       Exprs.push_back(Expr.get());
3387     }
3388 
3389     if (Tok.isNot(tok::comma))
3390       break;
3391     // Move to the next argument, remember where the comma was.
3392     Token Comma = Tok;
3393     CommaLocs.push_back(ConsumeToken());
3394 
3395     checkPotentialAngleBracketDelimiter(Comma);
3396   }
3397   if (SawError) {
3398     // Ensure typos get diagnosed when errors were encountered while parsing the
3399     // expression list.
3400     for (auto &E : Exprs) {
3401       ExprResult Expr = Actions.CorrectDelayedTyposInExpr(E);
3402       if (Expr.isUsable()) E = Expr.get();
3403     }
3404   }
3405   return SawError;
3406 }
3407 
3408 /// ParseSimpleExpressionList - A simple comma-separated list of expressions,
3409 /// used for misc language extensions.
3410 ///
3411 /// \verbatim
3412 ///       simple-expression-list:
3413 ///         assignment-expression
3414 ///         simple-expression-list , assignment-expression
3415 /// \endverbatim
3416 bool
3417 Parser::ParseSimpleExpressionList(SmallVectorImpl<Expr*> &Exprs,
3418                                   SmallVectorImpl<SourceLocation> &CommaLocs) {
3419   while (1) {
3420     ExprResult Expr = ParseAssignmentExpression();
3421     if (Expr.isInvalid())
3422       return true;
3423 
3424     Exprs.push_back(Expr.get());
3425 
3426     if (Tok.isNot(tok::comma))
3427       return false;
3428 
3429     // Move to the next argument, remember where the comma was.
3430     Token Comma = Tok;
3431     CommaLocs.push_back(ConsumeToken());
3432 
3433     checkPotentialAngleBracketDelimiter(Comma);
3434   }
3435 }
3436 
3437 /// ParseBlockId - Parse a block-id, which roughly looks like int (int x).
3438 ///
3439 /// \verbatim
3440 /// [clang] block-id:
3441 /// [clang]   specifier-qualifier-list block-declarator
3442 /// \endverbatim
3443 void Parser::ParseBlockId(SourceLocation CaretLoc) {
3444   if (Tok.is(tok::code_completion)) {
3445     cutOffParsing();
3446     Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type);
3447     return;
3448   }
3449 
3450   // Parse the specifier-qualifier-list piece.
3451   DeclSpec DS(AttrFactory);
3452   ParseSpecifierQualifierList(DS);
3453 
3454   // Parse the block-declarator.
3455   Declarator DeclaratorInfo(DS, DeclaratorContext::BlockLiteral);
3456   DeclaratorInfo.setFunctionDefinitionKind(FunctionDefinitionKind::Definition);
3457   ParseDeclarator(DeclaratorInfo);
3458 
3459   MaybeParseGNUAttributes(DeclaratorInfo);
3460 
3461   // Inform sema that we are starting a block.
3462   Actions.ActOnBlockArguments(CaretLoc, DeclaratorInfo, getCurScope());
3463 }
3464 
3465 /// ParseBlockLiteralExpression - Parse a block literal, which roughly looks
3466 /// like ^(int x){ return x+1; }
3467 ///
3468 /// \verbatim
3469 ///         block-literal:
3470 /// [clang]   '^' block-args[opt] compound-statement
3471 /// [clang]   '^' block-id compound-statement
3472 /// [clang] block-args:
3473 /// [clang]   '(' parameter-list ')'
3474 /// \endverbatim
3475 ExprResult Parser::ParseBlockLiteralExpression() {
3476   assert(Tok.is(tok::caret) && "block literal starts with ^");
3477   SourceLocation CaretLoc = ConsumeToken();
3478 
3479   PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), CaretLoc,
3480                                 "block literal parsing");
3481 
3482   // Enter a scope to hold everything within the block.  This includes the
3483   // argument decls, decls within the compound expression, etc.  This also
3484   // allows determining whether a variable reference inside the block is
3485   // within or outside of the block.
3486   ParseScope BlockScope(this, Scope::BlockScope | Scope::FnScope |
3487                                   Scope::CompoundStmtScope | Scope::DeclScope);
3488 
3489   // Inform sema that we are starting a block.
3490   Actions.ActOnBlockStart(CaretLoc, getCurScope());
3491 
3492   // Parse the return type if present.
3493   DeclSpec DS(AttrFactory);
3494   Declarator ParamInfo(DS, DeclaratorContext::BlockLiteral);
3495   ParamInfo.setFunctionDefinitionKind(FunctionDefinitionKind::Definition);
3496   // FIXME: Since the return type isn't actually parsed, it can't be used to
3497   // fill ParamInfo with an initial valid range, so do it manually.
3498   ParamInfo.SetSourceRange(SourceRange(Tok.getLocation(), Tok.getLocation()));
3499 
3500   // If this block has arguments, parse them.  There is no ambiguity here with
3501   // the expression case, because the expression case requires a parameter list.
3502   if (Tok.is(tok::l_paren)) {
3503     ParseParenDeclarator(ParamInfo);
3504     // Parse the pieces after the identifier as if we had "int(...)".
3505     // SetIdentifier sets the source range end, but in this case we're past
3506     // that location.
3507     SourceLocation Tmp = ParamInfo.getSourceRange().getEnd();
3508     ParamInfo.SetIdentifier(nullptr, CaretLoc);
3509     ParamInfo.SetRangeEnd(Tmp);
3510     if (ParamInfo.isInvalidType()) {
3511       // If there was an error parsing the arguments, they may have
3512       // tried to use ^(x+y) which requires an argument list.  Just
3513       // skip the whole block literal.
3514       Actions.ActOnBlockError(CaretLoc, getCurScope());
3515       return ExprError();
3516     }
3517 
3518     MaybeParseGNUAttributes(ParamInfo);
3519 
3520     // Inform sema that we are starting a block.
3521     Actions.ActOnBlockArguments(CaretLoc, ParamInfo, getCurScope());
3522   } else if (!Tok.is(tok::l_brace)) {
3523     ParseBlockId(CaretLoc);
3524   } else {
3525     // Otherwise, pretend we saw (void).
3526     SourceLocation NoLoc;
3527     ParamInfo.AddTypeInfo(
3528         DeclaratorChunk::getFunction(/*HasProto=*/true,
3529                                      /*IsAmbiguous=*/false,
3530                                      /*RParenLoc=*/NoLoc,
3531                                      /*ArgInfo=*/nullptr,
3532                                      /*NumParams=*/0,
3533                                      /*EllipsisLoc=*/NoLoc,
3534                                      /*RParenLoc=*/NoLoc,
3535                                      /*RefQualifierIsLvalueRef=*/true,
3536                                      /*RefQualifierLoc=*/NoLoc,
3537                                      /*MutableLoc=*/NoLoc, EST_None,
3538                                      /*ESpecRange=*/SourceRange(),
3539                                      /*Exceptions=*/nullptr,
3540                                      /*ExceptionRanges=*/nullptr,
3541                                      /*NumExceptions=*/0,
3542                                      /*NoexceptExpr=*/nullptr,
3543                                      /*ExceptionSpecTokens=*/nullptr,
3544                                      /*DeclsInPrototype=*/None, CaretLoc,
3545                                      CaretLoc, ParamInfo),
3546         CaretLoc);
3547 
3548     MaybeParseGNUAttributes(ParamInfo);
3549 
3550     // Inform sema that we are starting a block.
3551     Actions.ActOnBlockArguments(CaretLoc, ParamInfo, getCurScope());
3552   }
3553 
3554 
3555   ExprResult Result(true);
3556   if (!Tok.is(tok::l_brace)) {
3557     // Saw something like: ^expr
3558     Diag(Tok, diag::err_expected_expression);
3559     Actions.ActOnBlockError(CaretLoc, getCurScope());
3560     return ExprError();
3561   }
3562 
3563   StmtResult Stmt(ParseCompoundStatementBody());
3564   BlockScope.Exit();
3565   if (!Stmt.isInvalid())
3566     Result = Actions.ActOnBlockStmtExpr(CaretLoc, Stmt.get(), getCurScope());
3567   else
3568     Actions.ActOnBlockError(CaretLoc, getCurScope());
3569   return Result;
3570 }
3571 
3572 /// ParseObjCBoolLiteral - This handles the objective-c Boolean literals.
3573 ///
3574 ///         '__objc_yes'
3575 ///         '__objc_no'
3576 ExprResult Parser::ParseObjCBoolLiteral() {
3577   tok::TokenKind Kind = Tok.getKind();
3578   return Actions.ActOnObjCBoolLiteral(ConsumeToken(), Kind);
3579 }
3580 
3581 /// Validate availability spec list, emitting diagnostics if necessary. Returns
3582 /// true if invalid.
3583 static bool CheckAvailabilitySpecList(Parser &P,
3584                                       ArrayRef<AvailabilitySpec> AvailSpecs) {
3585   llvm::SmallSet<StringRef, 4> Platforms;
3586   bool HasOtherPlatformSpec = false;
3587   bool Valid = true;
3588   for (const auto &Spec : AvailSpecs) {
3589     if (Spec.isOtherPlatformSpec()) {
3590       if (HasOtherPlatformSpec) {
3591         P.Diag(Spec.getBeginLoc(), diag::err_availability_query_repeated_star);
3592         Valid = false;
3593       }
3594 
3595       HasOtherPlatformSpec = true;
3596       continue;
3597     }
3598 
3599     bool Inserted = Platforms.insert(Spec.getPlatform()).second;
3600     if (!Inserted) {
3601       // Rule out multiple version specs referring to the same platform.
3602       // For example, we emit an error for:
3603       // @available(macos 10.10, macos 10.11, *)
3604       StringRef Platform = Spec.getPlatform();
3605       P.Diag(Spec.getBeginLoc(), diag::err_availability_query_repeated_platform)
3606           << Spec.getEndLoc() << Platform;
3607       Valid = false;
3608     }
3609   }
3610 
3611   if (!HasOtherPlatformSpec) {
3612     SourceLocation InsertWildcardLoc = AvailSpecs.back().getEndLoc();
3613     P.Diag(InsertWildcardLoc, diag::err_availability_query_wildcard_required)
3614         << FixItHint::CreateInsertion(InsertWildcardLoc, ", *");
3615     return true;
3616   }
3617 
3618   return !Valid;
3619 }
3620 
3621 /// Parse availability query specification.
3622 ///
3623 ///  availability-spec:
3624 ///     '*'
3625 ///     identifier version-tuple
3626 Optional<AvailabilitySpec> Parser::ParseAvailabilitySpec() {
3627   if (Tok.is(tok::star)) {
3628     return AvailabilitySpec(ConsumeToken());
3629   } else {
3630     // Parse the platform name.
3631     if (Tok.is(tok::code_completion)) {
3632       cutOffParsing();
3633       Actions.CodeCompleteAvailabilityPlatformName();
3634       return None;
3635     }
3636     if (Tok.isNot(tok::identifier)) {
3637       Diag(Tok, diag::err_avail_query_expected_platform_name);
3638       return None;
3639     }
3640 
3641     IdentifierLoc *PlatformIdentifier = ParseIdentifierLoc();
3642     SourceRange VersionRange;
3643     VersionTuple Version = ParseVersionTuple(VersionRange);
3644 
3645     if (Version.empty())
3646       return None;
3647 
3648     StringRef GivenPlatform = PlatformIdentifier->Ident->getName();
3649     StringRef Platform =
3650         AvailabilityAttr::canonicalizePlatformName(GivenPlatform);
3651 
3652     if (AvailabilityAttr::getPrettyPlatformName(Platform).empty()) {
3653       Diag(PlatformIdentifier->Loc,
3654            diag::err_avail_query_unrecognized_platform_name)
3655           << GivenPlatform;
3656       return None;
3657     }
3658 
3659     return AvailabilitySpec(Version, Platform, PlatformIdentifier->Loc,
3660                             VersionRange.getEnd());
3661   }
3662 }
3663 
3664 ExprResult Parser::ParseAvailabilityCheckExpr(SourceLocation BeginLoc) {
3665   assert(Tok.is(tok::kw___builtin_available) ||
3666          Tok.isObjCAtKeyword(tok::objc_available));
3667 
3668   // Eat the available or __builtin_available.
3669   ConsumeToken();
3670 
3671   BalancedDelimiterTracker Parens(*this, tok::l_paren);
3672   if (Parens.expectAndConsume())
3673     return ExprError();
3674 
3675   SmallVector<AvailabilitySpec, 4> AvailSpecs;
3676   bool HasError = false;
3677   while (true) {
3678     Optional<AvailabilitySpec> Spec = ParseAvailabilitySpec();
3679     if (!Spec)
3680       HasError = true;
3681     else
3682       AvailSpecs.push_back(*Spec);
3683 
3684     if (!TryConsumeToken(tok::comma))
3685       break;
3686   }
3687 
3688   if (HasError) {
3689     SkipUntil(tok::r_paren, StopAtSemi);
3690     return ExprError();
3691   }
3692 
3693   CheckAvailabilitySpecList(*this, AvailSpecs);
3694 
3695   if (Parens.consumeClose())
3696     return ExprError();
3697 
3698   return Actions.ActOnObjCAvailabilityCheckExpr(AvailSpecs, BeginLoc,
3699                                                 Parens.getCloseLocation());
3700 }
3701