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