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