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