ParseExpr.cpp revision ae7902c4293d9de8b9591759513f0d075f45022a
1//===--- ParseExpr.cpp - Expression Parsing -------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Expression parsing implementation. Expressions in 11// C99 basically consist of a bunch of binary operators with unary operators and 12// other random stuff at the leaves. 13// 14// In the C99 grammar, these unary operators bind tightest and are represented 15// as the 'cast-expression' production. Everything else is either a binary 16// operator (e.g. '/') or a ternary operator ("?:"). The unary leaves are 17// handled by ParseCastExpression, the higher level pieces are handled by 18// ParseBinaryExpression. 19// 20//===----------------------------------------------------------------------===// 21 22#include "clang/Parse/Parser.h" 23#include "clang/Sema/DeclSpec.h" 24#include "clang/Sema/Scope.h" 25#include "clang/Sema/ParsedTemplate.h" 26#include "clang/Basic/PrettyStackTrace.h" 27#include "RAIIObjectsForParser.h" 28#include "llvm/ADT/SmallVector.h" 29#include "llvm/ADT/SmallString.h" 30using namespace clang; 31 32/// getBinOpPrecedence - Return the precedence of the specified binary operator 33/// token. 34static prec::Level getBinOpPrecedence(tok::TokenKind Kind, 35 bool GreaterThanIsOperator, 36 bool CPlusPlus0x) { 37 switch (Kind) { 38 case tok::greater: 39 // C++ [temp.names]p3: 40 // [...] When parsing a template-argument-list, the first 41 // non-nested > is taken as the ending delimiter rather than a 42 // greater-than operator. [...] 43 if (GreaterThanIsOperator) 44 return prec::Relational; 45 return prec::Unknown; 46 47 case tok::greatergreater: 48 // C++0x [temp.names]p3: 49 // 50 // [...] Similarly, the first non-nested >> is treated as two 51 // consecutive but distinct > tokens, the first of which is 52 // taken as the end of the template-argument-list and completes 53 // the template-id. [...] 54 if (GreaterThanIsOperator || !CPlusPlus0x) 55 return prec::Shift; 56 return prec::Unknown; 57 58 default: return prec::Unknown; 59 case tok::comma: return prec::Comma; 60 case tok::equal: 61 case tok::starequal: 62 case tok::slashequal: 63 case tok::percentequal: 64 case tok::plusequal: 65 case tok::minusequal: 66 case tok::lesslessequal: 67 case tok::greatergreaterequal: 68 case tok::ampequal: 69 case tok::caretequal: 70 case tok::pipeequal: return prec::Assignment; 71 case tok::question: return prec::Conditional; 72 case tok::pipepipe: return prec::LogicalOr; 73 case tok::ampamp: return prec::LogicalAnd; 74 case tok::pipe: return prec::InclusiveOr; 75 case tok::caret: return prec::ExclusiveOr; 76 case tok::amp: return prec::And; 77 case tok::exclaimequal: 78 case tok::equalequal: return prec::Equality; 79 case tok::lessequal: 80 case tok::less: 81 case tok::greaterequal: return prec::Relational; 82 case tok::lessless: return prec::Shift; 83 case tok::plus: 84 case tok::minus: return prec::Additive; 85 case tok::percent: 86 case tok::slash: 87 case tok::star: return prec::Multiplicative; 88 case tok::periodstar: 89 case tok::arrowstar: return prec::PointerToMember; 90 } 91} 92 93 94/// ParseExpression - Simple precedence-based parser for binary/ternary 95/// operators. 96/// 97/// Note: we diverge from the C99 grammar when parsing the assignment-expression 98/// production. C99 specifies that the LHS of an assignment operator should be 99/// parsed as a unary-expression, but consistency dictates that it be a 100/// conditional-expession. In practice, the important thing here is that the 101/// LHS of an assignment has to be an l-value, which productions between 102/// unary-expression and conditional-expression don't produce. Because we want 103/// consistency, we parse the LHS as a conditional-expression, then check for 104/// l-value-ness in semantic analysis stages. 105/// 106/// pm-expression: [C++ 5.5] 107/// cast-expression 108/// pm-expression '.*' cast-expression 109/// pm-expression '->*' cast-expression 110/// 111/// multiplicative-expression: [C99 6.5.5] 112/// Note: in C++, apply pm-expression instead of cast-expression 113/// cast-expression 114/// multiplicative-expression '*' cast-expression 115/// multiplicative-expression '/' cast-expression 116/// multiplicative-expression '%' cast-expression 117/// 118/// additive-expression: [C99 6.5.6] 119/// multiplicative-expression 120/// additive-expression '+' multiplicative-expression 121/// additive-expression '-' multiplicative-expression 122/// 123/// shift-expression: [C99 6.5.7] 124/// additive-expression 125/// shift-expression '<<' additive-expression 126/// shift-expression '>>' additive-expression 127/// 128/// relational-expression: [C99 6.5.8] 129/// shift-expression 130/// relational-expression '<' shift-expression 131/// relational-expression '>' shift-expression 132/// relational-expression '<=' shift-expression 133/// relational-expression '>=' shift-expression 134/// 135/// equality-expression: [C99 6.5.9] 136/// relational-expression 137/// equality-expression '==' relational-expression 138/// equality-expression '!=' relational-expression 139/// 140/// AND-expression: [C99 6.5.10] 141/// equality-expression 142/// AND-expression '&' equality-expression 143/// 144/// exclusive-OR-expression: [C99 6.5.11] 145/// AND-expression 146/// exclusive-OR-expression '^' AND-expression 147/// 148/// inclusive-OR-expression: [C99 6.5.12] 149/// exclusive-OR-expression 150/// inclusive-OR-expression '|' exclusive-OR-expression 151/// 152/// logical-AND-expression: [C99 6.5.13] 153/// inclusive-OR-expression 154/// logical-AND-expression '&&' inclusive-OR-expression 155/// 156/// logical-OR-expression: [C99 6.5.14] 157/// logical-AND-expression 158/// logical-OR-expression '||' logical-AND-expression 159/// 160/// conditional-expression: [C99 6.5.15] 161/// logical-OR-expression 162/// logical-OR-expression '?' expression ':' conditional-expression 163/// [GNU] logical-OR-expression '?' ':' conditional-expression 164/// [C++] the third operand is an assignment-expression 165/// 166/// assignment-expression: [C99 6.5.16] 167/// conditional-expression 168/// unary-expression assignment-operator assignment-expression 169/// [C++] throw-expression [C++ 15] 170/// 171/// assignment-operator: one of 172/// = *= /= %= += -= <<= >>= &= ^= |= 173/// 174/// expression: [C99 6.5.17] 175/// assignment-expression ...[opt] 176/// expression ',' assignment-expression ...[opt] 177ExprResult Parser::ParseExpression() { 178 ExprResult LHS(ParseAssignmentExpression()); 179 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma); 180} 181 182/// This routine is called when the '@' is seen and consumed. 183/// Current token is an Identifier and is not a 'try'. This 184/// routine is necessary to disambiguate @try-statement from, 185/// for example, @encode-expression. 186/// 187ExprResult 188Parser::ParseExpressionWithLeadingAt(SourceLocation AtLoc) { 189 ExprResult LHS(ParseObjCAtExpression(AtLoc)); 190 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma); 191} 192 193/// This routine is called when a leading '__extension__' is seen and 194/// consumed. This is necessary because the token gets consumed in the 195/// process of disambiguating between an expression and a declaration. 196ExprResult 197Parser::ParseExpressionWithLeadingExtension(SourceLocation ExtLoc) { 198 ExprResult LHS(true); 199 { 200 // Silence extension warnings in the sub-expression 201 ExtensionRAIIObject O(Diags); 202 203 LHS = ParseCastExpression(false); 204 } 205 206 if (!LHS.isInvalid()) 207 LHS = Actions.ActOnUnaryOp(getCurScope(), ExtLoc, tok::kw___extension__, 208 LHS.take()); 209 210 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma); 211} 212 213/// ParseAssignmentExpression - Parse an expr that doesn't include commas. 214ExprResult Parser::ParseAssignmentExpression() { 215 if (Tok.is(tok::code_completion)) { 216 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression); 217 ConsumeCodeCompletionToken(); 218 } 219 220 if (Tok.is(tok::kw_throw)) 221 return ParseThrowExpression(); 222 223 ExprResult LHS = ParseCastExpression(/*isUnaryExpression=*/false); 224 return ParseRHSOfBinaryExpression(move(LHS), prec::Assignment); 225} 226 227/// ParseAssignmentExprWithObjCMessageExprStart - Parse an assignment expression 228/// where part of an objc message send has already been parsed. In this case 229/// LBracLoc indicates the location of the '[' of the message send, and either 230/// ReceiverName or ReceiverExpr is non-null indicating the receiver of the 231/// message. 232/// 233/// Since this handles full assignment-expression's, it handles postfix 234/// expressions and other binary operators for these expressions as well. 235ExprResult 236Parser::ParseAssignmentExprWithObjCMessageExprStart(SourceLocation LBracLoc, 237 SourceLocation SuperLoc, 238 ParsedType ReceiverType, 239 Expr *ReceiverExpr) { 240 ExprResult R 241 = ParseObjCMessageExpressionBody(LBracLoc, SuperLoc, 242 ReceiverType, ReceiverExpr); 243 R = ParsePostfixExpressionSuffix(R); 244 return ParseRHSOfBinaryExpression(R, prec::Assignment); 245} 246 247 248ExprResult Parser::ParseConstantExpression() { 249 // C++ [basic.def.odr]p2: 250 // An expression is potentially evaluated unless it appears where an 251 // integral constant expression is required (see 5.19) [...]. 252 EnterExpressionEvaluationContext Unevaluated(Actions, 253 Sema::Unevaluated); 254 255 ExprResult LHS(ParseCastExpression(false)); 256 return ParseRHSOfBinaryExpression(LHS, prec::Conditional); 257} 258 259/// ParseRHSOfBinaryExpression - Parse a binary expression that starts with 260/// LHS and has a precedence of at least MinPrec. 261ExprResult 262Parser::ParseRHSOfBinaryExpression(ExprResult LHS, prec::Level MinPrec) { 263 prec::Level NextTokPrec = getBinOpPrecedence(Tok.getKind(), 264 GreaterThanIsOperator, 265 getLang().CPlusPlus0x); 266 SourceLocation ColonLoc; 267 268 while (1) { 269 // If this token has a lower precedence than we are allowed to parse (e.g. 270 // because we are called recursively, or because the token is not a binop), 271 // then we are done! 272 if (NextTokPrec < MinPrec) 273 return move(LHS); 274 275 // Consume the operator, saving the operator token for error reporting. 276 Token OpToken = Tok; 277 ConsumeToken(); 278 279 // Special case handling for the ternary operator. 280 ExprResult TernaryMiddle(true); 281 if (NextTokPrec == prec::Conditional) { 282 if (Tok.isNot(tok::colon)) { 283 // Don't parse FOO:BAR as if it were a typo for FOO::BAR. 284 ColonProtectionRAIIObject X(*this); 285 286 // Handle this production specially: 287 // logical-OR-expression '?' expression ':' conditional-expression 288 // In particular, the RHS of the '?' is 'expression', not 289 // 'logical-OR-expression' as we might expect. 290 TernaryMiddle = ParseExpression(); 291 if (TernaryMiddle.isInvalid()) { 292 LHS = ExprError(); 293 TernaryMiddle = 0; 294 } 295 } else { 296 // Special case handling of "X ? Y : Z" where Y is empty: 297 // logical-OR-expression '?' ':' conditional-expression [GNU] 298 TernaryMiddle = 0; 299 Diag(Tok, diag::ext_gnu_conditional_expr); 300 } 301 302 if (Tok.is(tok::colon)) { 303 // Eat the colon. 304 ColonLoc = ConsumeToken(); 305 } else { 306 // Otherwise, we're missing a ':'. Assume that this was a typo that 307 // the user forgot. If we're not in a macro expansion, we can suggest 308 // a fixit hint. If there were two spaces before the current token, 309 // suggest inserting the colon in between them, otherwise insert ": ". 310 SourceLocation FILoc = Tok.getLocation(); 311 const char *FIText = ": "; 312 const SourceManager &SM = PP.getSourceManager(); 313 if (FILoc.isFileID() || PP.isAtStartOfMacroExpansion(FILoc)) { 314 FILoc = SM.getExpansionLoc(FILoc); 315 bool IsInvalid = false; 316 const char *SourcePtr = 317 SM.getCharacterData(FILoc.getFileLocWithOffset(-1), &IsInvalid); 318 if (!IsInvalid && *SourcePtr == ' ') { 319 SourcePtr = 320 SM.getCharacterData(FILoc.getFileLocWithOffset(-2), &IsInvalid); 321 if (!IsInvalid && *SourcePtr == ' ') { 322 FILoc = FILoc.getFileLocWithOffset(-1); 323 FIText = ":"; 324 } 325 } 326 } 327 328 Diag(Tok, diag::err_expected_colon) 329 << FixItHint::CreateInsertion(FILoc, FIText); 330 Diag(OpToken, diag::note_matching) << "?"; 331 ColonLoc = Tok.getLocation(); 332 } 333 } 334 335 // Code completion for the right-hand side of an assignment expression 336 // goes through a special hook that takes the left-hand side into account. 337 if (Tok.is(tok::code_completion) && NextTokPrec == prec::Assignment) { 338 Actions.CodeCompleteAssignmentRHS(getCurScope(), LHS.get()); 339 ConsumeCodeCompletionToken(); 340 return ExprError(); 341 } 342 343 // Parse another leaf here for the RHS of the operator. 344 // ParseCastExpression works here because all RHS expressions in C have it 345 // as a prefix, at least. However, in C++, an assignment-expression could 346 // be a throw-expression, which is not a valid cast-expression. 347 // Therefore we need some special-casing here. 348 // Also note that the third operand of the conditional operator is 349 // an assignment-expression in C++. 350 ExprResult RHS; 351 if (getLang().CPlusPlus && NextTokPrec <= prec::Conditional) 352 RHS = ParseAssignmentExpression(); 353 else 354 RHS = ParseCastExpression(false); 355 356 if (RHS.isInvalid()) 357 LHS = ExprError(); 358 359 // Remember the precedence of this operator and get the precedence of the 360 // operator immediately to the right of the RHS. 361 prec::Level ThisPrec = NextTokPrec; 362 NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator, 363 getLang().CPlusPlus0x); 364 365 // Assignment and conditional expressions are right-associative. 366 bool isRightAssoc = ThisPrec == prec::Conditional || 367 ThisPrec == prec::Assignment; 368 369 // Get the precedence of the operator to the right of the RHS. If it binds 370 // more tightly with RHS than we do, evaluate it completely first. 371 if (ThisPrec < NextTokPrec || 372 (ThisPrec == NextTokPrec && isRightAssoc)) { 373 // If this is left-associative, only parse things on the RHS that bind 374 // more tightly than the current operator. If it is left-associative, it 375 // is okay, to bind exactly as tightly. For example, compile A=B=C=D as 376 // A=(B=(C=D)), where each paren is a level of recursion here. 377 // The function takes ownership of the RHS. 378 RHS = ParseRHSOfBinaryExpression(RHS, 379 static_cast<prec::Level>(ThisPrec + !isRightAssoc)); 380 381 if (RHS.isInvalid()) 382 LHS = ExprError(); 383 384 NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator, 385 getLang().CPlusPlus0x); 386 } 387 assert(NextTokPrec <= ThisPrec && "Recursion didn't work!"); 388 389 if (!LHS.isInvalid()) { 390 // Combine the LHS and RHS into the LHS (e.g. build AST). 391 if (TernaryMiddle.isInvalid()) { 392 // If we're using '>>' as an operator within a template 393 // argument list (in C++98), suggest the addition of 394 // parentheses so that the code remains well-formed in C++0x. 395 if (!GreaterThanIsOperator && OpToken.is(tok::greatergreater)) 396 SuggestParentheses(OpToken.getLocation(), 397 diag::warn_cxx0x_right_shift_in_template_arg, 398 SourceRange(Actions.getExprRange(LHS.get()).getBegin(), 399 Actions.getExprRange(RHS.get()).getEnd())); 400 401 LHS = Actions.ActOnBinOp(getCurScope(), OpToken.getLocation(), 402 OpToken.getKind(), LHS.take(), RHS.take()); 403 } else 404 LHS = Actions.ActOnConditionalOp(OpToken.getLocation(), ColonLoc, 405 LHS.take(), TernaryMiddle.take(), 406 RHS.take()); 407 } 408 } 409} 410 411/// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is 412/// true, parse a unary-expression. isAddressOfOperand exists because an 413/// id-expression that is the operand of address-of gets special treatment 414/// due to member pointers. 415/// 416ExprResult Parser::ParseCastExpression(bool isUnaryExpression, 417 bool isAddressOfOperand, 418 bool isTypeCast) { 419 bool NotCastExpr; 420 ExprResult Res = ParseCastExpression(isUnaryExpression, 421 isAddressOfOperand, 422 NotCastExpr, 423 isTypeCast); 424 if (NotCastExpr) 425 Diag(Tok, diag::err_expected_expression); 426 return move(Res); 427} 428 429/// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is 430/// true, parse a unary-expression. isAddressOfOperand exists because an 431/// id-expression that is the operand of address-of gets special treatment 432/// due to member pointers. NotCastExpr is set to true if the token is not the 433/// start of a cast-expression, and no diagnostic is emitted in this case. 434/// 435/// cast-expression: [C99 6.5.4] 436/// unary-expression 437/// '(' type-name ')' cast-expression 438/// 439/// unary-expression: [C99 6.5.3] 440/// postfix-expression 441/// '++' unary-expression 442/// '--' unary-expression 443/// unary-operator cast-expression 444/// 'sizeof' unary-expression 445/// 'sizeof' '(' type-name ')' 446/// [C++0x] 'sizeof' '...' '(' identifier ')' 447/// [GNU] '__alignof' unary-expression 448/// [GNU] '__alignof' '(' type-name ')' 449/// [C++0x] 'alignof' '(' type-id ')' 450/// [GNU] '&&' identifier 451/// [C++] new-expression 452/// [C++] delete-expression 453/// [C++0x] 'noexcept' '(' expression ')' 454/// 455/// unary-operator: one of 456/// '&' '*' '+' '-' '~' '!' 457/// [GNU] '__extension__' '__real' '__imag' 458/// 459/// primary-expression: [C99 6.5.1] 460/// [C99] identifier 461/// [C++] id-expression 462/// constant 463/// string-literal 464/// [C++] boolean-literal [C++ 2.13.5] 465/// [C++0x] 'nullptr' [C++0x 2.14.7] 466/// '(' expression ')' 467/// [C1X] generic-selection 468/// '__func__' [C99 6.4.2.2] 469/// [GNU] '__FUNCTION__' 470/// [GNU] '__PRETTY_FUNCTION__' 471/// [GNU] '(' compound-statement ')' 472/// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')' 473/// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')' 474/// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ',' 475/// assign-expr ')' 476/// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')' 477/// [GNU] '__null' 478/// [OBJC] '[' objc-message-expr ']' 479/// [OBJC] '@selector' '(' objc-selector-arg ')' 480/// [OBJC] '@protocol' '(' identifier ')' 481/// [OBJC] '@encode' '(' type-name ')' 482/// [OBJC] objc-string-literal 483/// [C++] simple-type-specifier '(' expression-list[opt] ')' [C++ 5.2.3] 484/// [C++0x] simple-type-specifier braced-init-list [C++ 5.2.3] 485/// [C++] typename-specifier '(' expression-list[opt] ')' [C++ 5.2.3] 486/// [C++0x] typename-specifier braced-init-list [C++ 5.2.3] 487/// [C++] 'const_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 488/// [C++] 'dynamic_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 489/// [C++] 'reinterpret_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 490/// [C++] 'static_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 491/// [C++] 'typeid' '(' expression ')' [C++ 5.2p1] 492/// [C++] 'typeid' '(' type-id ')' [C++ 5.2p1] 493/// [C++] 'this' [C++ 9.3.2] 494/// [G++] unary-type-trait '(' type-id ')' 495/// [G++] binary-type-trait '(' type-id ',' type-id ')' [TODO] 496/// [EMBT] array-type-trait '(' type-id ',' integer ')' 497/// [clang] '^' block-literal 498/// 499/// constant: [C99 6.4.4] 500/// integer-constant 501/// floating-constant 502/// enumeration-constant -> identifier 503/// character-constant 504/// 505/// id-expression: [C++ 5.1] 506/// unqualified-id 507/// qualified-id 508/// 509/// unqualified-id: [C++ 5.1] 510/// identifier 511/// operator-function-id 512/// conversion-function-id 513/// '~' class-name 514/// template-id 515/// 516/// new-expression: [C++ 5.3.4] 517/// '::'[opt] 'new' new-placement[opt] new-type-id 518/// new-initializer[opt] 519/// '::'[opt] 'new' new-placement[opt] '(' type-id ')' 520/// new-initializer[opt] 521/// 522/// delete-expression: [C++ 5.3.5] 523/// '::'[opt] 'delete' cast-expression 524/// '::'[opt] 'delete' '[' ']' cast-expression 525/// 526/// [GNU/Embarcadero] unary-type-trait: 527/// '__is_arithmetic' 528/// '__is_floating_point' 529/// '__is_integral' 530/// '__is_lvalue_expr' 531/// '__is_rvalue_expr' 532/// '__is_complete_type' 533/// '__is_void' 534/// '__is_array' 535/// '__is_function' 536/// '__is_reference' 537/// '__is_lvalue_reference' 538/// '__is_rvalue_reference' 539/// '__is_fundamental' 540/// '__is_object' 541/// '__is_scalar' 542/// '__is_compound' 543/// '__is_pointer' 544/// '__is_member_object_pointer' 545/// '__is_member_function_pointer' 546/// '__is_member_pointer' 547/// '__is_const' 548/// '__is_volatile' 549/// '__is_trivial' 550/// '__is_standard_layout' 551/// '__is_signed' 552/// '__is_unsigned' 553/// 554/// [GNU] unary-type-trait: 555/// '__has_nothrow_assign' 556/// '__has_nothrow_copy' 557/// '__has_nothrow_constructor' 558/// '__has_trivial_assign' [TODO] 559/// '__has_trivial_copy' [TODO] 560/// '__has_trivial_constructor' 561/// '__has_trivial_destructor' 562/// '__has_virtual_destructor' 563/// '__is_abstract' [TODO] 564/// '__is_class' 565/// '__is_empty' [TODO] 566/// '__is_enum' 567/// '__is_pod' 568/// '__is_polymorphic' 569/// '__is_trivial' 570/// '__is_union' 571/// 572/// [Clang] unary-type-trait: 573/// '__trivially_copyable' 574/// 575/// binary-type-trait: 576/// [GNU] '__is_base_of' 577/// [MS] '__is_convertible_to' 578/// '__is_convertible' 579/// '__is_same' 580/// 581/// [Embarcadero] array-type-trait: 582/// '__array_rank' 583/// '__array_extent' 584/// 585/// [Embarcadero] expression-trait: 586/// '__is_lvalue_expr' 587/// '__is_rvalue_expr' 588/// 589ExprResult Parser::ParseCastExpression(bool isUnaryExpression, 590 bool isAddressOfOperand, 591 bool &NotCastExpr, 592 bool isTypeCast) { 593 ExprResult Res; 594 tok::TokenKind SavedKind = Tok.getKind(); 595 NotCastExpr = false; 596 597 // This handles all of cast-expression, unary-expression, postfix-expression, 598 // and primary-expression. We handle them together like this for efficiency 599 // and to simplify handling of an expression starting with a '(' token: which 600 // may be one of a parenthesized expression, cast-expression, compound literal 601 // expression, or statement expression. 602 // 603 // If the parsed tokens consist of a primary-expression, the cases below 604 // break out of the switch; at the end we call ParsePostfixExpressionSuffix 605 // to handle the postfix expression suffixes. Cases that cannot be followed 606 // by postfix exprs should return without invoking 607 // ParsePostfixExpressionSuffix. 608 switch (SavedKind) { 609 case tok::l_paren: { 610 // If this expression is limited to being a unary-expression, the parent can 611 // not start a cast expression. 612 ParenParseOption ParenExprType = 613 (isUnaryExpression && !getLang().CPlusPlus)? CompoundLiteral : CastExpr; 614 ParsedType CastTy; 615 SourceLocation RParenLoc; 616 617 { 618 // The inside of the parens don't need to be a colon protected scope, and 619 // isn't immediately a message send. 620 ColonProtectionRAIIObject X(*this, false); 621 622 Res = ParseParenExpression(ParenExprType, false/*stopIfCastExr*/, 623 isTypeCast, CastTy, RParenLoc); 624 } 625 626 switch (ParenExprType) { 627 case SimpleExpr: break; // Nothing else to do. 628 case CompoundStmt: break; // Nothing else to do. 629 case CompoundLiteral: 630 // We parsed '(' type-name ')' '{' ... '}'. If any suffixes of 631 // postfix-expression exist, parse them now. 632 break; 633 case CastExpr: 634 // We have parsed the cast-expression and no postfix-expr pieces are 635 // following. 636 return move(Res); 637 } 638 639 break; 640 } 641 642 // primary-expression 643 case tok::numeric_constant: 644 // constant: integer-constant 645 // constant: floating-constant 646 647 Res = Actions.ActOnNumericConstant(Tok); 648 ConsumeToken(); 649 break; 650 651 case tok::kw_true: 652 case tok::kw_false: 653 return ParseCXXBoolLiteral(); 654 655 case tok::kw_nullptr: 656 return Actions.ActOnCXXNullPtrLiteral(ConsumeToken()); 657 658 case tok::annot_primary_expr: 659 assert(Res.get() == 0 && "Stray primary-expression annotation?"); 660 Res = getExprAnnotation(Tok); 661 ConsumeToken(); 662 break; 663 664 case tok::identifier: { // primary-expression: identifier 665 // unqualified-id: identifier 666 // constant: enumeration-constant 667 // Turn a potentially qualified name into a annot_typename or 668 // annot_cxxscope if it would be valid. This handles things like x::y, etc. 669 if (getLang().CPlusPlus) { 670 // Avoid the unnecessary parse-time lookup in the common case 671 // where the syntax forbids a type. 672 const Token &Next = NextToken(); 673 if (Next.is(tok::coloncolon) || 674 (!ColonIsSacred && Next.is(tok::colon)) || 675 Next.is(tok::less) || 676 Next.is(tok::l_paren)) { 677 // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse. 678 if (TryAnnotateTypeOrScopeToken()) 679 return ExprError(); 680 if (!Tok.is(tok::identifier)) 681 return ParseCastExpression(isUnaryExpression, isAddressOfOperand); 682 } 683 } 684 685 // Consume the identifier so that we can see if it is followed by a '(' or 686 // '.'. 687 IdentifierInfo &II = *Tok.getIdentifierInfo(); 688 SourceLocation ILoc = ConsumeToken(); 689 690 // Support 'Class.property' and 'super.property' notation. 691 if (getLang().ObjC1 && Tok.is(tok::period) && 692 (Actions.getTypeName(II, ILoc, getCurScope()) || 693 // Allow the base to be 'super' if in an objc-method. 694 (&II == Ident_super && getCurScope()->isInObjcMethodScope()))) { 695 ConsumeToken(); 696 697 if (Tok.isNot(tok::identifier)) { 698 Diag(Tok, diag::err_expected_property_name); 699 return ExprError(); 700 } 701 IdentifierInfo &PropertyName = *Tok.getIdentifierInfo(); 702 SourceLocation PropertyLoc = ConsumeToken(); 703 704 Res = Actions.ActOnClassPropertyRefExpr(II, PropertyName, 705 ILoc, PropertyLoc); 706 break; 707 } 708 709 // In an Objective-C method, if we have "super" followed by an identifier, 710 // the token sequence is ill-formed. However, if there's a ':' or ']' after 711 // that identifier, this is probably a message send with a missing open 712 // bracket. Treat it as such. 713 if (getLang().ObjC1 && &II == Ident_super && !InMessageExpression && 714 getCurScope()->isInObjcMethodScope() && 715 ((Tok.is(tok::identifier) && 716 (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) || 717 Tok.is(tok::code_completion))) { 718 Res = ParseObjCMessageExpressionBody(SourceLocation(), ILoc, ParsedType(), 719 0); 720 break; 721 } 722 723 // If we have an Objective-C class name followed by an identifier 724 // and either ':' or ']', this is an Objective-C class message 725 // send that's missing the opening '['. Recovery 726 // appropriately. Also take this path if we're performing code 727 // completion after an Objective-C class name. 728 if (getLang().ObjC1 && 729 ((Tok.is(tok::identifier) && !InMessageExpression) || 730 Tok.is(tok::code_completion))) { 731 const Token& Next = NextToken(); 732 if (Tok.is(tok::code_completion) || 733 Next.is(tok::colon) || Next.is(tok::r_square)) 734 if (ParsedType Typ = Actions.getTypeName(II, ILoc, getCurScope())) 735 if (Typ.get()->isObjCObjectOrInterfaceType()) { 736 // Fake up a Declarator to use with ActOnTypeName. 737 DeclSpec DS(AttrFactory); 738 DS.SetRangeStart(ILoc); 739 DS.SetRangeEnd(ILoc); 740 const char *PrevSpec = 0; 741 unsigned DiagID; 742 DS.SetTypeSpecType(TST_typename, ILoc, PrevSpec, DiagID, Typ); 743 744 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); 745 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), 746 DeclaratorInfo); 747 if (Ty.isInvalid()) 748 break; 749 750 Res = ParseObjCMessageExpressionBody(SourceLocation(), 751 SourceLocation(), 752 Ty.get(), 0); 753 break; 754 } 755 } 756 757 // Make sure to pass down the right value for isAddressOfOperand. 758 if (isAddressOfOperand && isPostfixExpressionSuffixStart()) 759 isAddressOfOperand = false; 760 761 // Function designators are allowed to be undeclared (C99 6.5.1p2), so we 762 // need to know whether or not this identifier is a function designator or 763 // not. 764 UnqualifiedId Name; 765 CXXScopeSpec ScopeSpec; 766 Name.setIdentifier(&II, ILoc); 767 Res = Actions.ActOnIdExpression(getCurScope(), ScopeSpec, Name, 768 Tok.is(tok::l_paren), isAddressOfOperand); 769 break; 770 } 771 case tok::char_constant: // constant: character-constant 772 case tok::wide_char_constant: 773 case tok::utf16_char_constant: 774 case tok::utf32_char_constant: 775 Res = Actions.ActOnCharacterConstant(Tok); 776 ConsumeToken(); 777 break; 778 case tok::kw___func__: // primary-expression: __func__ [C99 6.4.2.2] 779 case tok::kw___FUNCTION__: // primary-expression: __FUNCTION__ [GNU] 780 case tok::kw___PRETTY_FUNCTION__: // primary-expression: __P..Y_F..N__ [GNU] 781 Res = Actions.ActOnPredefinedExpr(Tok.getLocation(), SavedKind); 782 ConsumeToken(); 783 break; 784 case tok::string_literal: // primary-expression: string-literal 785 case tok::wide_string_literal: 786 case tok::utf8_string_literal: 787 case tok::utf16_string_literal: 788 case tok::utf32_string_literal: 789 Res = ParseStringLiteralExpression(); 790 break; 791 case tok::kw__Generic: // primary-expression: generic-selection [C1X 6.5.1] 792 Res = ParseGenericSelectionExpression(); 793 break; 794 case tok::kw___builtin_va_arg: 795 case tok::kw___builtin_offsetof: 796 case tok::kw___builtin_choose_expr: 797 case tok::kw___builtin_astype: // primary-expression: [OCL] as_type() 798 return ParseBuiltinPrimaryExpression(); 799 case tok::kw___null: 800 return Actions.ActOnGNUNullExpr(ConsumeToken()); 801 802 case tok::plusplus: // unary-expression: '++' unary-expression [C99] 803 case tok::minusminus: { // unary-expression: '--' unary-expression [C99] 804 // C++ [expr.unary] has: 805 // unary-expression: 806 // ++ cast-expression 807 // -- cast-expression 808 SourceLocation SavedLoc = ConsumeToken(); 809 Res = ParseCastExpression(!getLang().CPlusPlus); 810 if (!Res.isInvalid()) 811 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get()); 812 return move(Res); 813 } 814 case tok::amp: { // unary-expression: '&' cast-expression 815 // Special treatment because of member pointers 816 SourceLocation SavedLoc = ConsumeToken(); 817 Res = ParseCastExpression(false, true); 818 if (!Res.isInvalid()) 819 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get()); 820 return move(Res); 821 } 822 823 case tok::star: // unary-expression: '*' cast-expression 824 case tok::plus: // unary-expression: '+' cast-expression 825 case tok::minus: // unary-expression: '-' cast-expression 826 case tok::tilde: // unary-expression: '~' cast-expression 827 case tok::exclaim: // unary-expression: '!' cast-expression 828 case tok::kw___real: // unary-expression: '__real' cast-expression [GNU] 829 case tok::kw___imag: { // unary-expression: '__imag' cast-expression [GNU] 830 SourceLocation SavedLoc = ConsumeToken(); 831 Res = ParseCastExpression(false); 832 if (!Res.isInvalid()) 833 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get()); 834 return move(Res); 835 } 836 837 case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU] 838 // __extension__ silences extension warnings in the subexpression. 839 ExtensionRAIIObject O(Diags); // Use RAII to do this. 840 SourceLocation SavedLoc = ConsumeToken(); 841 Res = ParseCastExpression(false); 842 if (!Res.isInvalid()) 843 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get()); 844 return move(Res); 845 } 846 case tok::kw_sizeof: // unary-expression: 'sizeof' unary-expression 847 // unary-expression: 'sizeof' '(' type-name ')' 848 case tok::kw_alignof: 849 case tok::kw___alignof: // unary-expression: '__alignof' unary-expression 850 // unary-expression: '__alignof' '(' type-name ')' 851 // unary-expression: 'alignof' '(' type-id ')' 852 case tok::kw_vec_step: // unary-expression: OpenCL 'vec_step' expression 853 return ParseUnaryExprOrTypeTraitExpression(); 854 case tok::ampamp: { // unary-expression: '&&' identifier 855 SourceLocation AmpAmpLoc = ConsumeToken(); 856 if (Tok.isNot(tok::identifier)) 857 return ExprError(Diag(Tok, diag::err_expected_ident)); 858 859 if (getCurScope()->getFnParent() == 0) 860 return ExprError(Diag(Tok, diag::err_address_of_label_outside_fn)); 861 862 Diag(AmpAmpLoc, diag::ext_gnu_address_of_label); 863 LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(), 864 Tok.getLocation()); 865 Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(), LD); 866 ConsumeToken(); 867 return move(Res); 868 } 869 case tok::kw_const_cast: 870 case tok::kw_dynamic_cast: 871 case tok::kw_reinterpret_cast: 872 case tok::kw_static_cast: 873 Res = ParseCXXCasts(); 874 break; 875 case tok::kw_typeid: 876 Res = ParseCXXTypeid(); 877 break; 878 case tok::kw___uuidof: 879 Res = ParseCXXUuidof(); 880 break; 881 case tok::kw_this: 882 Res = ParseCXXThis(); 883 break; 884 885 case tok::annot_typename: 886 if (isStartOfObjCClassMessageMissingOpenBracket()) { 887 ParsedType Type = getTypeAnnotation(Tok); 888 889 // Fake up a Declarator to use with ActOnTypeName. 890 DeclSpec DS(AttrFactory); 891 DS.SetRangeStart(Tok.getLocation()); 892 DS.SetRangeEnd(Tok.getLastLoc()); 893 894 const char *PrevSpec = 0; 895 unsigned DiagID; 896 DS.SetTypeSpecType(TST_typename, Tok.getAnnotationEndLoc(), 897 PrevSpec, DiagID, Type); 898 899 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); 900 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 901 if (Ty.isInvalid()) 902 break; 903 904 ConsumeToken(); 905 Res = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(), 906 Ty.get(), 0); 907 break; 908 } 909 // Fall through 910 911 case tok::kw_char: 912 case tok::kw_wchar_t: 913 case tok::kw_char16_t: 914 case tok::kw_char32_t: 915 case tok::kw_bool: 916 case tok::kw_short: 917 case tok::kw_int: 918 case tok::kw_long: 919 case tok::kw___int64: 920 case tok::kw_signed: 921 case tok::kw_unsigned: 922 case tok::kw_float: 923 case tok::kw_double: 924 case tok::kw_void: 925 case tok::kw_typename: 926 case tok::kw_typeof: 927 case tok::kw___vector: { 928 if (!getLang().CPlusPlus) { 929 Diag(Tok, diag::err_expected_expression); 930 return ExprError(); 931 } 932 933 if (SavedKind == tok::kw_typename) { 934 // postfix-expression: typename-specifier '(' expression-list[opt] ')' 935 // typename-specifier braced-init-list 936 if (TryAnnotateTypeOrScopeToken()) 937 return ExprError(); 938 } 939 940 // postfix-expression: simple-type-specifier '(' expression-list[opt] ')' 941 // simple-type-specifier braced-init-list 942 // 943 DeclSpec DS(AttrFactory); 944 ParseCXXSimpleTypeSpecifier(DS); 945 if (Tok.isNot(tok::l_paren) && 946 (!getLang().CPlusPlus0x || Tok.isNot(tok::l_brace))) 947 return ExprError(Diag(Tok, diag::err_expected_lparen_after_type) 948 << DS.getSourceRange()); 949 950 Res = ParseCXXTypeConstructExpression(DS); 951 break; 952 } 953 954 case tok::annot_cxxscope: { // [C++] id-expression: qualified-id 955 // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse. 956 // (We can end up in this situation after tentative parsing.) 957 if (TryAnnotateTypeOrScopeToken()) 958 return ExprError(); 959 if (!Tok.is(tok::annot_cxxscope)) 960 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 961 NotCastExpr, isTypeCast); 962 963 Token Next = NextToken(); 964 if (Next.is(tok::annot_template_id)) { 965 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Next); 966 if (TemplateId->Kind == TNK_Type_template) { 967 // We have a qualified template-id that we know refers to a 968 // type, translate it into a type and continue parsing as a 969 // cast expression. 970 CXXScopeSpec SS; 971 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false); 972 AnnotateTemplateIdTokenAsType(); 973 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 974 NotCastExpr, isTypeCast); 975 } 976 } 977 978 // Parse as an id-expression. 979 Res = ParseCXXIdExpression(isAddressOfOperand); 980 break; 981 } 982 983 case tok::annot_template_id: { // [C++] template-id 984 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); 985 if (TemplateId->Kind == TNK_Type_template) { 986 // We have a template-id that we know refers to a type, 987 // translate it into a type and continue parsing as a cast 988 // expression. 989 AnnotateTemplateIdTokenAsType(); 990 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 991 NotCastExpr, isTypeCast); 992 } 993 994 // Fall through to treat the template-id as an id-expression. 995 } 996 997 case tok::kw_operator: // [C++] id-expression: operator/conversion-function-id 998 Res = ParseCXXIdExpression(isAddressOfOperand); 999 break; 1000 1001 case tok::coloncolon: { 1002 // ::foo::bar -> global qualified name etc. If TryAnnotateTypeOrScopeToken 1003 // annotates the token, tail recurse. 1004 if (TryAnnotateTypeOrScopeToken()) 1005 return ExprError(); 1006 if (!Tok.is(tok::coloncolon)) 1007 return ParseCastExpression(isUnaryExpression, isAddressOfOperand); 1008 1009 // ::new -> [C++] new-expression 1010 // ::delete -> [C++] delete-expression 1011 SourceLocation CCLoc = ConsumeToken(); 1012 if (Tok.is(tok::kw_new)) 1013 return ParseCXXNewExpression(true, CCLoc); 1014 if (Tok.is(tok::kw_delete)) 1015 return ParseCXXDeleteExpression(true, CCLoc); 1016 1017 // This is not a type name or scope specifier, it is an invalid expression. 1018 Diag(CCLoc, diag::err_expected_expression); 1019 return ExprError(); 1020 } 1021 1022 case tok::kw_new: // [C++] new-expression 1023 return ParseCXXNewExpression(false, Tok.getLocation()); 1024 1025 case tok::kw_delete: // [C++] delete-expression 1026 return ParseCXXDeleteExpression(false, Tok.getLocation()); 1027 1028 case tok::kw_noexcept: { // [C++0x] 'noexcept' '(' expression ')' 1029 SourceLocation KeyLoc = ConsumeToken(); 1030 SourceLocation LParen = Tok.getLocation(); 1031 if (ExpectAndConsume(tok::l_paren, 1032 diag::err_expected_lparen_after, "noexcept")) 1033 return ExprError(); 1034 // C++ [expr.unary.noexcept]p1: 1035 // The noexcept operator determines whether the evaluation of its operand, 1036 // which is an unevaluated operand, can throw an exception. 1037 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated); 1038 ExprResult Result = ParseExpression(); 1039 SourceLocation RParen = MatchRHSPunctuation(tok::r_paren, LParen); 1040 if (!Result.isInvalid()) 1041 Result = Actions.ActOnNoexceptExpr(KeyLoc, LParen, Result.take(), RParen); 1042 return move(Result); 1043 } 1044 1045 case tok::kw___is_abstract: // [GNU] unary-type-trait 1046 case tok::kw___is_class: 1047 case tok::kw___is_empty: 1048 case tok::kw___is_enum: 1049 case tok::kw___is_literal: 1050 case tok::kw___is_arithmetic: 1051 case tok::kw___is_integral: 1052 case tok::kw___is_floating_point: 1053 case tok::kw___is_complete_type: 1054 case tok::kw___is_void: 1055 case tok::kw___is_array: 1056 case tok::kw___is_function: 1057 case tok::kw___is_reference: 1058 case tok::kw___is_lvalue_reference: 1059 case tok::kw___is_rvalue_reference: 1060 case tok::kw___is_fundamental: 1061 case tok::kw___is_object: 1062 case tok::kw___is_scalar: 1063 case tok::kw___is_compound: 1064 case tok::kw___is_pointer: 1065 case tok::kw___is_member_object_pointer: 1066 case tok::kw___is_member_function_pointer: 1067 case tok::kw___is_member_pointer: 1068 case tok::kw___is_const: 1069 case tok::kw___is_volatile: 1070 case tok::kw___is_standard_layout: 1071 case tok::kw___is_signed: 1072 case tok::kw___is_unsigned: 1073 case tok::kw___is_literal_type: 1074 case tok::kw___is_pod: 1075 case tok::kw___is_polymorphic: 1076 case tok::kw___is_trivial: 1077 case tok::kw___is_trivially_copyable: 1078 case tok::kw___is_union: 1079 case tok::kw___has_trivial_constructor: 1080 case tok::kw___has_trivial_copy: 1081 case tok::kw___has_trivial_assign: 1082 case tok::kw___has_trivial_destructor: 1083 case tok::kw___has_nothrow_assign: 1084 case tok::kw___has_nothrow_copy: 1085 case tok::kw___has_nothrow_constructor: 1086 case tok::kw___has_virtual_destructor: 1087 return ParseUnaryTypeTrait(); 1088 1089 case tok::kw___builtin_types_compatible_p: 1090 case tok::kw___is_base_of: 1091 case tok::kw___is_same: 1092 case tok::kw___is_convertible: 1093 case tok::kw___is_convertible_to: 1094 return ParseBinaryTypeTrait(); 1095 1096 case tok::kw___array_rank: 1097 case tok::kw___array_extent: 1098 return ParseArrayTypeTrait(); 1099 1100 case tok::kw___is_lvalue_expr: 1101 case tok::kw___is_rvalue_expr: 1102 return ParseExpressionTrait(); 1103 1104 case tok::at: { 1105 SourceLocation AtLoc = ConsumeToken(); 1106 return ParseObjCAtExpression(AtLoc); 1107 } 1108 case tok::caret: 1109 Res = ParseBlockLiteralExpression(); 1110 break; 1111 case tok::code_completion: { 1112 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression); 1113 ConsumeCodeCompletionToken(); 1114 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 1115 NotCastExpr, isTypeCast); 1116 } 1117 case tok::l_square: 1118 if (getLang().CPlusPlus0x) { 1119 if (getLang().ObjC1) { 1120 Res = TryParseLambdaExpression(); 1121 if (Res.isInvalid()) 1122 Res = ParseObjCMessageExpression(); 1123 break; 1124 } 1125 Res = ParseLambdaExpression(); 1126 break; 1127 } 1128 if (getLang().ObjC1) { 1129 Res = ParseObjCMessageExpression(); 1130 break; 1131 } 1132 // FALL THROUGH. 1133 default: 1134 NotCastExpr = true; 1135 return ExprError(); 1136 } 1137 1138 // These can be followed by postfix-expr pieces. 1139 return ParsePostfixExpressionSuffix(Res); 1140} 1141 1142/// ParsePostfixExpressionSuffix - Once the leading part of a postfix-expression 1143/// is parsed, this method parses any suffixes that apply. 1144/// 1145/// postfix-expression: [C99 6.5.2] 1146/// primary-expression 1147/// postfix-expression '[' expression ']' 1148/// postfix-expression '[' braced-init-list ']' 1149/// postfix-expression '(' argument-expression-list[opt] ')' 1150/// postfix-expression '.' identifier 1151/// postfix-expression '->' identifier 1152/// postfix-expression '++' 1153/// postfix-expression '--' 1154/// '(' type-name ')' '{' initializer-list '}' 1155/// '(' type-name ')' '{' initializer-list ',' '}' 1156/// 1157/// argument-expression-list: [C99 6.5.2] 1158/// argument-expression ...[opt] 1159/// argument-expression-list ',' assignment-expression ...[opt] 1160/// 1161ExprResult 1162Parser::ParsePostfixExpressionSuffix(ExprResult LHS) { 1163 // Now that the primary-expression piece of the postfix-expression has been 1164 // parsed, see if there are any postfix-expression pieces here. 1165 SourceLocation Loc; 1166 while (1) { 1167 switch (Tok.getKind()) { 1168 case tok::code_completion: 1169 if (InMessageExpression) 1170 return move(LHS); 1171 1172 Actions.CodeCompletePostfixExpression(getCurScope(), LHS); 1173 ConsumeCodeCompletionToken(); 1174 LHS = ExprError(); 1175 break; 1176 1177 case tok::identifier: 1178 // If we see identifier: after an expression, and we're not already in a 1179 // message send, then this is probably a message send with a missing 1180 // opening bracket '['. 1181 if (getLang().ObjC1 && !InMessageExpression && 1182 (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) { 1183 LHS = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(), 1184 ParsedType(), LHS.get()); 1185 break; 1186 } 1187 1188 // Fall through; this isn't a message send. 1189 1190 default: // Not a postfix-expression suffix. 1191 return move(LHS); 1192 case tok::l_square: { // postfix-expression: p-e '[' expression ']' 1193 // If we have a array postfix expression that starts on a new line and 1194 // Objective-C is enabled, it is highly likely that the user forgot a 1195 // semicolon after the base expression and that the array postfix-expr is 1196 // actually another message send. In this case, do some look-ahead to see 1197 // if the contents of the square brackets are obviously not a valid 1198 // expression and recover by pretending there is no suffix. 1199 if (getLang().ObjC1 && Tok.isAtStartOfLine() && 1200 isSimpleObjCMessageExpression()) 1201 return move(LHS); 1202 1203 Loc = ConsumeBracket(); 1204 ExprResult Idx; 1205 if (getLang().CPlusPlus0x && Tok.is(tok::l_brace)) 1206 Idx = ParseBraceInitializer(); 1207 else 1208 Idx = ParseExpression(); 1209 1210 SourceLocation RLoc = Tok.getLocation(); 1211 1212 if (!LHS.isInvalid() && !Idx.isInvalid() && Tok.is(tok::r_square)) { 1213 LHS = Actions.ActOnArraySubscriptExpr(getCurScope(), LHS.take(), Loc, 1214 Idx.take(), RLoc); 1215 } else 1216 LHS = ExprError(); 1217 1218 // Match the ']'. 1219 MatchRHSPunctuation(tok::r_square, Loc); 1220 break; 1221 } 1222 1223 case tok::l_paren: // p-e: p-e '(' argument-expression-list[opt] ')' 1224 case tok::lesslessless: { // p-e: p-e '<<<' argument-expression-list '>>>' 1225 // '(' argument-expression-list[opt] ')' 1226 tok::TokenKind OpKind = Tok.getKind(); 1227 InMessageExpressionRAIIObject InMessage(*this, false); 1228 1229 Expr *ExecConfig = 0; 1230 1231 if (OpKind == tok::lesslessless) { 1232 ExprVector ExecConfigExprs(Actions); 1233 CommaLocsTy ExecConfigCommaLocs; 1234 SourceLocation LLLLoc, GGGLoc; 1235 1236 LLLLoc = ConsumeToken(); 1237 1238 if (ParseExpressionList(ExecConfigExprs, ExecConfigCommaLocs)) { 1239 LHS = ExprError(); 1240 } 1241 1242 if (LHS.isInvalid()) { 1243 SkipUntil(tok::greatergreatergreater); 1244 } else if (Tok.isNot(tok::greatergreatergreater)) { 1245 MatchRHSPunctuation(tok::greatergreatergreater, LLLLoc); 1246 LHS = ExprError(); 1247 } else { 1248 GGGLoc = ConsumeToken(); 1249 } 1250 1251 if (!LHS.isInvalid()) { 1252 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen, "")) 1253 LHS = ExprError(); 1254 else 1255 Loc = PrevTokLocation; 1256 } 1257 1258 if (!LHS.isInvalid()) { 1259 ExprResult ECResult = Actions.ActOnCUDAExecConfigExpr(getCurScope(), 1260 LLLLoc, move_arg(ExecConfigExprs), GGGLoc); 1261 if (ECResult.isInvalid()) 1262 LHS = ExprError(); 1263 else 1264 ExecConfig = ECResult.get(); 1265 } 1266 } else { 1267 Loc = ConsumeParen(); 1268 } 1269 1270 ExprVector ArgExprs(Actions); 1271 CommaLocsTy CommaLocs; 1272 1273 if (Tok.is(tok::code_completion)) { 1274 Actions.CodeCompleteCall(getCurScope(), LHS.get(), 0, 0); 1275 ConsumeCodeCompletionToken(); 1276 } 1277 1278 if (OpKind == tok::l_paren || !LHS.isInvalid()) { 1279 if (Tok.isNot(tok::r_paren)) { 1280 if (ParseExpressionList(ArgExprs, CommaLocs, &Sema::CodeCompleteCall, 1281 LHS.get())) { 1282 LHS = ExprError(); 1283 } 1284 } 1285 } 1286 1287 // Match the ')'. 1288 if (LHS.isInvalid()) { 1289 SkipUntil(tok::r_paren); 1290 } else if (Tok.isNot(tok::r_paren)) { 1291 MatchRHSPunctuation(tok::r_paren, Loc); 1292 LHS = ExprError(); 1293 } else { 1294 assert((ArgExprs.size() == 0 || 1295 ArgExprs.size()-1 == CommaLocs.size())&& 1296 "Unexpected number of commas!"); 1297 LHS = Actions.ActOnCallExpr(getCurScope(), LHS.take(), Loc, 1298 move_arg(ArgExprs), Tok.getLocation(), 1299 ExecConfig); 1300 ConsumeParen(); 1301 } 1302 1303 break; 1304 } 1305 case tok::arrow: 1306 case tok::period: { 1307 // postfix-expression: p-e '->' template[opt] id-expression 1308 // postfix-expression: p-e '.' template[opt] id-expression 1309 tok::TokenKind OpKind = Tok.getKind(); 1310 SourceLocation OpLoc = ConsumeToken(); // Eat the "." or "->" token. 1311 1312 CXXScopeSpec SS; 1313 ParsedType ObjectType; 1314 bool MayBePseudoDestructor = false; 1315 if (getLang().CPlusPlus && !LHS.isInvalid()) { 1316 LHS = Actions.ActOnStartCXXMemberReference(getCurScope(), LHS.take(), 1317 OpLoc, OpKind, ObjectType, 1318 MayBePseudoDestructor); 1319 if (LHS.isInvalid()) 1320 break; 1321 1322 ParseOptionalCXXScopeSpecifier(SS, ObjectType, false, 1323 &MayBePseudoDestructor); 1324 if (SS.isNotEmpty()) 1325 ObjectType = ParsedType(); 1326 } 1327 1328 if (Tok.is(tok::code_completion)) { 1329 // Code completion for a member access expression. 1330 Actions.CodeCompleteMemberReferenceExpr(getCurScope(), LHS.get(), 1331 OpLoc, OpKind == tok::arrow); 1332 1333 ConsumeCodeCompletionToken(); 1334 } 1335 1336 if (MayBePseudoDestructor && !LHS.isInvalid()) { 1337 LHS = ParseCXXPseudoDestructor(LHS.take(), OpLoc, OpKind, SS, 1338 ObjectType); 1339 break; 1340 } 1341 1342 // Either the action has told is that this cannot be a 1343 // pseudo-destructor expression (based on the type of base 1344 // expression), or we didn't see a '~' in the right place. We 1345 // can still parse a destructor name here, but in that case it 1346 // names a real destructor. 1347 // Allow explicit constructor calls in Microsoft mode. 1348 // FIXME: Add support for explicit call of template constructor. 1349 UnqualifiedId Name; 1350 if (ParseUnqualifiedId(SS, 1351 /*EnteringContext=*/false, 1352 /*AllowDestructorName=*/true, 1353 /*AllowConstructorName=*/ getLang().Microsoft, 1354 ObjectType, 1355 Name)) 1356 LHS = ExprError(); 1357 1358 if (!LHS.isInvalid()) 1359 LHS = Actions.ActOnMemberAccessExpr(getCurScope(), LHS.take(), OpLoc, 1360 OpKind, SS, Name, ObjCImpDecl, 1361 Tok.is(tok::l_paren)); 1362 break; 1363 } 1364 case tok::plusplus: // postfix-expression: postfix-expression '++' 1365 case tok::minusminus: // postfix-expression: postfix-expression '--' 1366 if (!LHS.isInvalid()) { 1367 LHS = Actions.ActOnPostfixUnaryOp(getCurScope(), Tok.getLocation(), 1368 Tok.getKind(), LHS.take()); 1369 } 1370 ConsumeToken(); 1371 break; 1372 } 1373 } 1374} 1375 1376/// ParseExprAfterUnaryExprOrTypeTrait - We parsed a typeof/sizeof/alignof/ 1377/// vec_step and we are at the start of an expression or a parenthesized 1378/// type-id. OpTok is the operand token (typeof/sizeof/alignof). Returns the 1379/// expression (isCastExpr == false) or the type (isCastExpr == true). 1380/// 1381/// unary-expression: [C99 6.5.3] 1382/// 'sizeof' unary-expression 1383/// 'sizeof' '(' type-name ')' 1384/// [GNU] '__alignof' unary-expression 1385/// [GNU] '__alignof' '(' type-name ')' 1386/// [C++0x] 'alignof' '(' type-id ')' 1387/// 1388/// [GNU] typeof-specifier: 1389/// typeof ( expressions ) 1390/// typeof ( type-name ) 1391/// [GNU/C++] typeof unary-expression 1392/// 1393/// [OpenCL 1.1 6.11.12] vec_step built-in function: 1394/// vec_step ( expressions ) 1395/// vec_step ( type-name ) 1396/// 1397ExprResult 1398Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok, 1399 bool &isCastExpr, 1400 ParsedType &CastTy, 1401 SourceRange &CastRange) { 1402 1403 assert((OpTok.is(tok::kw_typeof) || OpTok.is(tok::kw_sizeof) || 1404 OpTok.is(tok::kw___alignof) || OpTok.is(tok::kw_alignof) || 1405 OpTok.is(tok::kw_vec_step)) && 1406 "Not a typeof/sizeof/alignof/vec_step expression!"); 1407 1408 ExprResult Operand; 1409 1410 // If the operand doesn't start with an '(', it must be an expression. 1411 if (Tok.isNot(tok::l_paren)) { 1412 isCastExpr = false; 1413 if (OpTok.is(tok::kw_typeof) && !getLang().CPlusPlus) { 1414 Diag(Tok,diag::err_expected_lparen_after_id) << OpTok.getIdentifierInfo(); 1415 return ExprError(); 1416 } 1417 1418 // C++0x [expr.sizeof]p1: 1419 // [...] The operand is either an expression, which is an unevaluated 1420 // operand (Clause 5) [...] 1421 // 1422 // The GNU typeof and alignof extensions also behave as unevaluated 1423 // operands. 1424 EnterExpressionEvaluationContext Unevaluated(Actions, 1425 Sema::Unevaluated); 1426 Operand = ParseCastExpression(true/*isUnaryExpression*/); 1427 } else { 1428 // If it starts with a '(', we know that it is either a parenthesized 1429 // type-name, or it is a unary-expression that starts with a compound 1430 // literal, or starts with a primary-expression that is a parenthesized 1431 // expression. 1432 ParenParseOption ExprType = CastExpr; 1433 SourceLocation LParenLoc = Tok.getLocation(), RParenLoc; 1434 1435 // C++0x [expr.sizeof]p1: 1436 // [...] The operand is either an expression, which is an unevaluated 1437 // operand (Clause 5) [...] 1438 // 1439 // The GNU typeof and alignof extensions also behave as unevaluated 1440 // operands. 1441 EnterExpressionEvaluationContext Unevaluated(Actions, 1442 Sema::Unevaluated); 1443 Operand = ParseParenExpression(ExprType, true/*stopIfCastExpr*/, 1444 false, CastTy, RParenLoc); 1445 CastRange = SourceRange(LParenLoc, RParenLoc); 1446 1447 // If ParseParenExpression parsed a '(typename)' sequence only, then this is 1448 // a type. 1449 if (ExprType == CastExpr) { 1450 isCastExpr = true; 1451 return ExprEmpty(); 1452 } 1453 1454 if (getLang().CPlusPlus || OpTok.isNot(tok::kw_typeof)) { 1455 // GNU typeof in C requires the expression to be parenthesized. Not so for 1456 // sizeof/alignof or in C++. Therefore, the parenthesized expression is 1457 // the start of a unary-expression, but doesn't include any postfix 1458 // pieces. Parse these now if present. 1459 if (!Operand.isInvalid()) 1460 Operand = ParsePostfixExpressionSuffix(Operand.get()); 1461 } 1462 } 1463 1464 // If we get here, the operand to the typeof/sizeof/alignof was an expresion. 1465 isCastExpr = false; 1466 return move(Operand); 1467} 1468 1469 1470/// ParseUnaryExprOrTypeTraitExpression - Parse a sizeof or alignof expression. 1471/// unary-expression: [C99 6.5.3] 1472/// 'sizeof' unary-expression 1473/// 'sizeof' '(' type-name ')' 1474/// [C++0x] 'sizeof' '...' '(' identifier ')' 1475/// [GNU] '__alignof' unary-expression 1476/// [GNU] '__alignof' '(' type-name ')' 1477/// [C++0x] 'alignof' '(' type-id ')' 1478ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() { 1479 assert((Tok.is(tok::kw_sizeof) || Tok.is(tok::kw___alignof) 1480 || Tok.is(tok::kw_alignof) || Tok.is(tok::kw_vec_step)) && 1481 "Not a sizeof/alignof/vec_step expression!"); 1482 Token OpTok = Tok; 1483 ConsumeToken(); 1484 1485 // [C++0x] 'sizeof' '...' '(' identifier ')' 1486 if (Tok.is(tok::ellipsis) && OpTok.is(tok::kw_sizeof)) { 1487 SourceLocation EllipsisLoc = ConsumeToken(); 1488 SourceLocation LParenLoc, RParenLoc; 1489 IdentifierInfo *Name = 0; 1490 SourceLocation NameLoc; 1491 if (Tok.is(tok::l_paren)) { 1492 LParenLoc = ConsumeParen(); 1493 if (Tok.is(tok::identifier)) { 1494 Name = Tok.getIdentifierInfo(); 1495 NameLoc = ConsumeToken(); 1496 RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 1497 if (RParenLoc.isInvalid()) 1498 RParenLoc = PP.getLocForEndOfToken(NameLoc); 1499 } else { 1500 Diag(Tok, diag::err_expected_parameter_pack); 1501 SkipUntil(tok::r_paren); 1502 } 1503 } else if (Tok.is(tok::identifier)) { 1504 Name = Tok.getIdentifierInfo(); 1505 NameLoc = ConsumeToken(); 1506 LParenLoc = PP.getLocForEndOfToken(EllipsisLoc); 1507 RParenLoc = PP.getLocForEndOfToken(NameLoc); 1508 Diag(LParenLoc, diag::err_paren_sizeof_parameter_pack) 1509 << Name 1510 << FixItHint::CreateInsertion(LParenLoc, "(") 1511 << FixItHint::CreateInsertion(RParenLoc, ")"); 1512 } else { 1513 Diag(Tok, diag::err_sizeof_parameter_pack); 1514 } 1515 1516 if (!Name) 1517 return ExprError(); 1518 1519 return Actions.ActOnSizeofParameterPackExpr(getCurScope(), 1520 OpTok.getLocation(), 1521 *Name, NameLoc, 1522 RParenLoc); 1523 } 1524 1525 bool isCastExpr; 1526 ParsedType CastTy; 1527 SourceRange CastRange; 1528 ExprResult Operand = ParseExprAfterUnaryExprOrTypeTrait(OpTok, 1529 isCastExpr, 1530 CastTy, 1531 CastRange); 1532 1533 UnaryExprOrTypeTrait ExprKind = UETT_SizeOf; 1534 if (OpTok.is(tok::kw_alignof) || OpTok.is(tok::kw___alignof)) 1535 ExprKind = UETT_AlignOf; 1536 else if (OpTok.is(tok::kw_vec_step)) 1537 ExprKind = UETT_VecStep; 1538 1539 if (isCastExpr) 1540 return Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(), 1541 ExprKind, 1542 /*isType=*/true, 1543 CastTy.getAsOpaquePtr(), 1544 CastRange); 1545 1546 // If we get here, the operand to the sizeof/alignof was an expresion. 1547 if (!Operand.isInvalid()) 1548 Operand = Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(), 1549 ExprKind, 1550 /*isType=*/false, 1551 Operand.release(), 1552 CastRange); 1553 return move(Operand); 1554} 1555 1556/// ParseBuiltinPrimaryExpression 1557/// 1558/// primary-expression: [C99 6.5.1] 1559/// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')' 1560/// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')' 1561/// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ',' 1562/// assign-expr ')' 1563/// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')' 1564/// [OCL] '__builtin_astype' '(' type-name expr ')' 1565/// 1566/// [GNU] offsetof-member-designator: 1567/// [GNU] identifier 1568/// [GNU] offsetof-member-designator '.' identifier 1569/// [GNU] offsetof-member-designator '[' expression ']' 1570/// 1571ExprResult Parser::ParseBuiltinPrimaryExpression() { 1572 ExprResult Res; 1573 const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo(); 1574 1575 tok::TokenKind T = Tok.getKind(); 1576 SourceLocation StartLoc = ConsumeToken(); // Eat the builtin identifier. 1577 1578 // All of these start with an open paren. 1579 if (Tok.isNot(tok::l_paren)) 1580 return ExprError(Diag(Tok, diag::err_expected_lparen_after_id) 1581 << BuiltinII); 1582 1583 SourceLocation LParenLoc = ConsumeParen(); 1584 // TODO: Build AST. 1585 1586 switch (T) { 1587 default: assert(0 && "Not a builtin primary expression!"); 1588 case tok::kw___builtin_va_arg: { 1589 ExprResult Expr(ParseAssignmentExpression()); 1590 1591 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1592 Expr = ExprError(); 1593 1594 TypeResult Ty = ParseTypeName(); 1595 1596 if (Tok.isNot(tok::r_paren)) { 1597 Diag(Tok, diag::err_expected_rparen); 1598 Expr = ExprError(); 1599 } 1600 1601 if (Expr.isInvalid() || Ty.isInvalid()) 1602 Res = ExprError(); 1603 else 1604 Res = Actions.ActOnVAArg(StartLoc, Expr.take(), Ty.get(), ConsumeParen()); 1605 break; 1606 } 1607 case tok::kw___builtin_offsetof: { 1608 SourceLocation TypeLoc = Tok.getLocation(); 1609 TypeResult Ty = ParseTypeName(); 1610 if (Ty.isInvalid()) { 1611 SkipUntil(tok::r_paren); 1612 return ExprError(); 1613 } 1614 1615 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1616 return ExprError(); 1617 1618 // We must have at least one identifier here. 1619 if (Tok.isNot(tok::identifier)) { 1620 Diag(Tok, diag::err_expected_ident); 1621 SkipUntil(tok::r_paren); 1622 return ExprError(); 1623 } 1624 1625 // Keep track of the various subcomponents we see. 1626 SmallVector<Sema::OffsetOfComponent, 4> Comps; 1627 1628 Comps.push_back(Sema::OffsetOfComponent()); 1629 Comps.back().isBrackets = false; 1630 Comps.back().U.IdentInfo = Tok.getIdentifierInfo(); 1631 Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken(); 1632 1633 // FIXME: This loop leaks the index expressions on error. 1634 while (1) { 1635 if (Tok.is(tok::period)) { 1636 // offsetof-member-designator: offsetof-member-designator '.' identifier 1637 Comps.push_back(Sema::OffsetOfComponent()); 1638 Comps.back().isBrackets = false; 1639 Comps.back().LocStart = ConsumeToken(); 1640 1641 if (Tok.isNot(tok::identifier)) { 1642 Diag(Tok, diag::err_expected_ident); 1643 SkipUntil(tok::r_paren); 1644 return ExprError(); 1645 } 1646 Comps.back().U.IdentInfo = Tok.getIdentifierInfo(); 1647 Comps.back().LocEnd = ConsumeToken(); 1648 1649 } else if (Tok.is(tok::l_square)) { 1650 // offsetof-member-designator: offsetof-member-design '[' expression ']' 1651 Comps.push_back(Sema::OffsetOfComponent()); 1652 Comps.back().isBrackets = true; 1653 Comps.back().LocStart = ConsumeBracket(); 1654 Res = ParseExpression(); 1655 if (Res.isInvalid()) { 1656 SkipUntil(tok::r_paren); 1657 return move(Res); 1658 } 1659 Comps.back().U.E = Res.release(); 1660 1661 Comps.back().LocEnd = 1662 MatchRHSPunctuation(tok::r_square, Comps.back().LocStart); 1663 } else { 1664 if (Tok.isNot(tok::r_paren)) { 1665 MatchRHSPunctuation(tok::r_paren, LParenLoc); 1666 Res = ExprError(); 1667 } else if (Ty.isInvalid()) { 1668 Res = ExprError(); 1669 } else { 1670 Res = Actions.ActOnBuiltinOffsetOf(getCurScope(), StartLoc, TypeLoc, 1671 Ty.get(), &Comps[0], 1672 Comps.size(), ConsumeParen()); 1673 } 1674 break; 1675 } 1676 } 1677 break; 1678 } 1679 case tok::kw___builtin_choose_expr: { 1680 ExprResult Cond(ParseAssignmentExpression()); 1681 if (Cond.isInvalid()) { 1682 SkipUntil(tok::r_paren); 1683 return move(Cond); 1684 } 1685 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1686 return ExprError(); 1687 1688 ExprResult Expr1(ParseAssignmentExpression()); 1689 if (Expr1.isInvalid()) { 1690 SkipUntil(tok::r_paren); 1691 return move(Expr1); 1692 } 1693 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1694 return ExprError(); 1695 1696 ExprResult Expr2(ParseAssignmentExpression()); 1697 if (Expr2.isInvalid()) { 1698 SkipUntil(tok::r_paren); 1699 return move(Expr2); 1700 } 1701 if (Tok.isNot(tok::r_paren)) { 1702 Diag(Tok, diag::err_expected_rparen); 1703 return ExprError(); 1704 } 1705 Res = Actions.ActOnChooseExpr(StartLoc, Cond.take(), Expr1.take(), 1706 Expr2.take(), ConsumeParen()); 1707 break; 1708 } 1709 case tok::kw___builtin_astype: { 1710 // The first argument is an expression to be converted, followed by a comma. 1711 ExprResult Expr(ParseAssignmentExpression()); 1712 if (Expr.isInvalid()) { 1713 SkipUntil(tok::r_paren); 1714 return ExprError(); 1715 } 1716 1717 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", 1718 tok::r_paren)) 1719 return ExprError(); 1720 1721 // Second argument is the type to bitcast to. 1722 TypeResult DestTy = ParseTypeName(); 1723 if (DestTy.isInvalid()) 1724 return ExprError(); 1725 1726 // Attempt to consume the r-paren. 1727 if (Tok.isNot(tok::r_paren)) { 1728 Diag(Tok, diag::err_expected_rparen); 1729 SkipUntil(tok::r_paren); 1730 return ExprError(); 1731 } 1732 1733 Res = Actions.ActOnAsTypeExpr(Expr.take(), DestTy.get(), StartLoc, 1734 ConsumeParen()); 1735 break; 1736 } 1737 } 1738 1739 if (Res.isInvalid()) 1740 return ExprError(); 1741 1742 // These can be followed by postfix-expr pieces because they are 1743 // primary-expressions. 1744 return ParsePostfixExpressionSuffix(Res.take()); 1745} 1746 1747/// ParseParenExpression - This parses the unit that starts with a '(' token, 1748/// based on what is allowed by ExprType. The actual thing parsed is returned 1749/// in ExprType. If stopIfCastExpr is true, it will only return the parsed type, 1750/// not the parsed cast-expression. 1751/// 1752/// primary-expression: [C99 6.5.1] 1753/// '(' expression ')' 1754/// [GNU] '(' compound-statement ')' (if !ParenExprOnly) 1755/// postfix-expression: [C99 6.5.2] 1756/// '(' type-name ')' '{' initializer-list '}' 1757/// '(' type-name ')' '{' initializer-list ',' '}' 1758/// cast-expression: [C99 6.5.4] 1759/// '(' type-name ')' cast-expression 1760/// [ARC] bridged-cast-expression 1761/// 1762/// [ARC] bridged-cast-expression: 1763/// (__bridge type-name) cast-expression 1764/// (__bridge_transfer type-name) cast-expression 1765/// (__bridge_retained type-name) cast-expression 1766ExprResult 1767Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr, 1768 bool isTypeCast, ParsedType &CastTy, 1769 SourceLocation &RParenLoc) { 1770 assert(Tok.is(tok::l_paren) && "Not a paren expr!"); 1771 GreaterThanIsOperatorScope G(GreaterThanIsOperator, true); 1772 SourceLocation OpenLoc = ConsumeParen(); 1773 ExprResult Result(true); 1774 bool isAmbiguousTypeId; 1775 CastTy = ParsedType(); 1776 1777 if (Tok.is(tok::code_completion)) { 1778 Actions.CodeCompleteOrdinaryName(getCurScope(), 1779 ExprType >= CompoundLiteral? Sema::PCC_ParenthesizedExpression 1780 : Sema::PCC_Expression); 1781 ConsumeCodeCompletionToken(); 1782 return ExprError(); 1783 } 1784 1785 // None of these cases should fall through with an invalid Result 1786 // unless they've already reported an error. 1787 1788 if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) { 1789 Diag(Tok, diag::ext_gnu_statement_expr); 1790 ParsedAttributes attrs(AttrFactory); 1791 StmtResult Stmt(ParseCompoundStatement(attrs, true)); 1792 ExprType = CompoundStmt; 1793 1794 // If the substmt parsed correctly, build the AST node. 1795 if (!Stmt.isInvalid()) 1796 Result = Actions.ActOnStmtExpr(OpenLoc, Stmt.take(), Tok.getLocation()); 1797 } else if (ExprType >= CompoundLiteral && 1798 (Tok.is(tok::kw___bridge) || 1799 Tok.is(tok::kw___bridge_transfer) || 1800 Tok.is(tok::kw___bridge_retained) || 1801 Tok.is(tok::kw___bridge_retain))) { 1802 tok::TokenKind tokenKind = Tok.getKind(); 1803 SourceLocation BridgeKeywordLoc = ConsumeToken(); 1804 1805 // Parse an Objective-C ARC ownership cast expression. 1806 ObjCBridgeCastKind Kind; 1807 if (tokenKind == tok::kw___bridge) 1808 Kind = OBC_Bridge; 1809 else if (tokenKind == tok::kw___bridge_transfer) 1810 Kind = OBC_BridgeTransfer; 1811 else if (tokenKind == tok::kw___bridge_retained) 1812 Kind = OBC_BridgeRetained; 1813 else { 1814 // As a hopefully temporary workaround, allow __bridge_retain as 1815 // a synonym for __bridge_retained, but only in system headers. 1816 assert(tokenKind == tok::kw___bridge_retain); 1817 Kind = OBC_BridgeRetained; 1818 if (!PP.getSourceManager().isInSystemHeader(BridgeKeywordLoc)) 1819 Diag(BridgeKeywordLoc, diag::err_arc_bridge_retain) 1820 << FixItHint::CreateReplacement(BridgeKeywordLoc, 1821 "__bridge_retained"); 1822 } 1823 1824 TypeResult Ty = ParseTypeName(); 1825 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, OpenLoc); 1826 ExprResult SubExpr = ParseCastExpression(/*isUnaryExpression=*/false); 1827 1828 if (Ty.isInvalid() || SubExpr.isInvalid()) 1829 return ExprError(); 1830 1831 return Actions.ActOnObjCBridgedCast(getCurScope(), OpenLoc, Kind, 1832 BridgeKeywordLoc, Ty.get(), 1833 RParenLoc, SubExpr.get()); 1834 } else if (ExprType >= CompoundLiteral && 1835 isTypeIdInParens(isAmbiguousTypeId)) { 1836 1837 // Otherwise, this is a compound literal expression or cast expression. 1838 1839 // In C++, if the type-id is ambiguous we disambiguate based on context. 1840 // If stopIfCastExpr is true the context is a typeof/sizeof/alignof 1841 // in which case we should treat it as type-id. 1842 // if stopIfCastExpr is false, we need to determine the context past the 1843 // parens, so we defer to ParseCXXAmbiguousParenExpression for that. 1844 if (isAmbiguousTypeId && !stopIfCastExpr) 1845 return ParseCXXAmbiguousParenExpression(ExprType, CastTy, 1846 OpenLoc, RParenLoc); 1847 1848 // Parse the type declarator. 1849 DeclSpec DS(AttrFactory); 1850 ParseSpecifierQualifierList(DS); 1851 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); 1852 ParseDeclarator(DeclaratorInfo); 1853 1854 // If our type is followed by an identifier and either ':' or ']', then 1855 // this is probably an Objective-C message send where the leading '[' is 1856 // missing. Recover as if that were the case. 1857 if (!DeclaratorInfo.isInvalidType() && Tok.is(tok::identifier) && 1858 !InMessageExpression && getLang().ObjC1 && 1859 (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) { 1860 TypeResult Ty; 1861 { 1862 InMessageExpressionRAIIObject InMessage(*this, false); 1863 Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 1864 } 1865 Result = ParseObjCMessageExpressionBody(SourceLocation(), 1866 SourceLocation(), 1867 Ty.get(), 0); 1868 } else { 1869 // Match the ')'. 1870 if (Tok.is(tok::r_paren)) 1871 RParenLoc = ConsumeParen(); 1872 else 1873 MatchRHSPunctuation(tok::r_paren, OpenLoc); 1874 1875 if (Tok.is(tok::l_brace)) { 1876 ExprType = CompoundLiteral; 1877 TypeResult Ty; 1878 { 1879 InMessageExpressionRAIIObject InMessage(*this, false); 1880 Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 1881 } 1882 return ParseCompoundLiteralExpression(Ty.get(), OpenLoc, RParenLoc); 1883 } 1884 1885 if (ExprType == CastExpr) { 1886 // We parsed '(' type-name ')' and the thing after it wasn't a '{'. 1887 1888 if (DeclaratorInfo.isInvalidType()) 1889 return ExprError(); 1890 1891 // Note that this doesn't parse the subsequent cast-expression, it just 1892 // returns the parsed type to the callee. 1893 if (stopIfCastExpr) { 1894 TypeResult Ty; 1895 { 1896 InMessageExpressionRAIIObject InMessage(*this, false); 1897 Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 1898 } 1899 CastTy = Ty.get(); 1900 return ExprResult(); 1901 } 1902 1903 // Reject the cast of super idiom in ObjC. 1904 if (Tok.is(tok::identifier) && getLang().ObjC1 && 1905 Tok.getIdentifierInfo() == Ident_super && 1906 getCurScope()->isInObjcMethodScope() && 1907 GetLookAheadToken(1).isNot(tok::period)) { 1908 Diag(Tok.getLocation(), diag::err_illegal_super_cast) 1909 << SourceRange(OpenLoc, RParenLoc); 1910 return ExprError(); 1911 } 1912 1913 // Parse the cast-expression that follows it next. 1914 // TODO: For cast expression with CastTy. 1915 Result = ParseCastExpression(/*isUnaryExpression=*/false, 1916 /*isAddressOfOperand=*/false, 1917 /*isTypeCast=*/true); 1918 if (!Result.isInvalid()) { 1919 Result = Actions.ActOnCastExpr(getCurScope(), OpenLoc, 1920 DeclaratorInfo, CastTy, 1921 RParenLoc, Result.take()); 1922 } 1923 return move(Result); 1924 } 1925 1926 Diag(Tok, diag::err_expected_lbrace_in_compound_literal); 1927 return ExprError(); 1928 } 1929 } else if (isTypeCast) { 1930 // Parse the expression-list. 1931 InMessageExpressionRAIIObject InMessage(*this, false); 1932 1933 ExprVector ArgExprs(Actions); 1934 CommaLocsTy CommaLocs; 1935 1936 if (!ParseExpressionList(ArgExprs, CommaLocs)) { 1937 ExprType = SimpleExpr; 1938 Result = Actions.ActOnParenOrParenListExpr(OpenLoc, Tok.getLocation(), 1939 move_arg(ArgExprs)); 1940 } 1941 } else { 1942 InMessageExpressionRAIIObject InMessage(*this, false); 1943 1944 Result = ParseExpression(); 1945 ExprType = SimpleExpr; 1946 1947 // Don't build a paren expression unless we actually match a ')'. 1948 if (!Result.isInvalid() && Tok.is(tok::r_paren)) 1949 Result = Actions.ActOnParenExpr(OpenLoc, Tok.getLocation(), Result.take()); 1950 } 1951 1952 // Match the ')'. 1953 if (Result.isInvalid()) { 1954 SkipUntil(tok::r_paren); 1955 return ExprError(); 1956 } 1957 1958 if (Tok.is(tok::r_paren)) 1959 RParenLoc = ConsumeParen(); 1960 else 1961 MatchRHSPunctuation(tok::r_paren, OpenLoc); 1962 1963 return move(Result); 1964} 1965 1966/// ParseCompoundLiteralExpression - We have parsed the parenthesized type-name 1967/// and we are at the left brace. 1968/// 1969/// postfix-expression: [C99 6.5.2] 1970/// '(' type-name ')' '{' initializer-list '}' 1971/// '(' type-name ')' '{' initializer-list ',' '}' 1972/// 1973ExprResult 1974Parser::ParseCompoundLiteralExpression(ParsedType Ty, 1975 SourceLocation LParenLoc, 1976 SourceLocation RParenLoc) { 1977 assert(Tok.is(tok::l_brace) && "Not a compound literal!"); 1978 if (!getLang().C99) // Compound literals don't exist in C90. 1979 Diag(LParenLoc, diag::ext_c99_compound_literal); 1980 ExprResult Result = ParseInitializer(); 1981 if (!Result.isInvalid() && Ty) 1982 return Actions.ActOnCompoundLiteral(LParenLoc, Ty, RParenLoc, Result.take()); 1983 return move(Result); 1984} 1985 1986/// ParseStringLiteralExpression - This handles the various token types that 1987/// form string literals, and also handles string concatenation [C99 5.1.1.2, 1988/// translation phase #6]. 1989/// 1990/// primary-expression: [C99 6.5.1] 1991/// string-literal 1992ExprResult Parser::ParseStringLiteralExpression() { 1993 assert(isTokenStringLiteral() && "Not a string literal!"); 1994 1995 // String concat. Note that keywords like __func__ and __FUNCTION__ are not 1996 // considered to be strings for concatenation purposes. 1997 SmallVector<Token, 4> StringToks; 1998 1999 do { 2000 StringToks.push_back(Tok); 2001 ConsumeStringToken(); 2002 } while (isTokenStringLiteral()); 2003 2004 // Pass the set of string tokens, ready for concatenation, to the actions. 2005 return Actions.ActOnStringLiteral(&StringToks[0], StringToks.size()); 2006} 2007 2008/// ParseGenericSelectionExpression - Parse a C1X generic-selection 2009/// [C1X 6.5.1.1]. 2010/// 2011/// generic-selection: 2012/// _Generic ( assignment-expression , generic-assoc-list ) 2013/// generic-assoc-list: 2014/// generic-association 2015/// generic-assoc-list , generic-association 2016/// generic-association: 2017/// type-name : assignment-expression 2018/// default : assignment-expression 2019ExprResult Parser::ParseGenericSelectionExpression() { 2020 assert(Tok.is(tok::kw__Generic) && "_Generic keyword expected"); 2021 SourceLocation KeyLoc = ConsumeToken(); 2022 2023 if (!getLang().C1X) 2024 Diag(KeyLoc, diag::ext_c1x_generic_selection); 2025 2026 SourceLocation LParenLoc = Tok.getLocation(); 2027 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen, "")) 2028 return ExprError(); 2029 2030 ExprResult ControllingExpr; 2031 { 2032 // C1X 6.5.1.1p3 "The controlling expression of a generic selection is 2033 // not evaluated." 2034 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated); 2035 ControllingExpr = ParseAssignmentExpression(); 2036 if (ControllingExpr.isInvalid()) { 2037 SkipUntil(tok::r_paren); 2038 return ExprError(); 2039 } 2040 } 2041 2042 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "")) { 2043 SkipUntil(tok::r_paren); 2044 return ExprError(); 2045 } 2046 2047 SourceLocation DefaultLoc; 2048 TypeVector Types(Actions); 2049 ExprVector Exprs(Actions); 2050 while (1) { 2051 ParsedType Ty; 2052 if (Tok.is(tok::kw_default)) { 2053 // C1X 6.5.1.1p2 "A generic selection shall have no more than one default 2054 // generic association." 2055 if (!DefaultLoc.isInvalid()) { 2056 Diag(Tok, diag::err_duplicate_default_assoc); 2057 Diag(DefaultLoc, diag::note_previous_default_assoc); 2058 SkipUntil(tok::r_paren); 2059 return ExprError(); 2060 } 2061 DefaultLoc = ConsumeToken(); 2062 Ty = ParsedType(); 2063 } else { 2064 ColonProtectionRAIIObject X(*this); 2065 TypeResult TR = ParseTypeName(); 2066 if (TR.isInvalid()) { 2067 SkipUntil(tok::r_paren); 2068 return ExprError(); 2069 } 2070 Ty = TR.release(); 2071 } 2072 Types.push_back(Ty); 2073 2074 if (ExpectAndConsume(tok::colon, diag::err_expected_colon, "")) { 2075 SkipUntil(tok::r_paren); 2076 return ExprError(); 2077 } 2078 2079 // FIXME: These expressions should be parsed in a potentially potentially 2080 // evaluated context. 2081 ExprResult ER(ParseAssignmentExpression()); 2082 if (ER.isInvalid()) { 2083 SkipUntil(tok::r_paren); 2084 return ExprError(); 2085 } 2086 Exprs.push_back(ER.release()); 2087 2088 if (Tok.isNot(tok::comma)) 2089 break; 2090 ConsumeToken(); 2091 } 2092 2093 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 2094 if (RParenLoc.isInvalid()) 2095 return ExprError(); 2096 2097 return Actions.ActOnGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, 2098 ControllingExpr.release(), 2099 move_arg(Types), move_arg(Exprs)); 2100} 2101 2102/// ParseExpressionList - Used for C/C++ (argument-)expression-list. 2103/// 2104/// argument-expression-list: 2105/// assignment-expression 2106/// argument-expression-list , assignment-expression 2107/// 2108/// [C++] expression-list: 2109/// [C++] assignment-expression 2110/// [C++] expression-list , assignment-expression 2111/// 2112/// [C++0x] expression-list: 2113/// [C++0x] initializer-list 2114/// 2115/// [C++0x] initializer-list 2116/// [C++0x] initializer-clause ...[opt] 2117/// [C++0x] initializer-list , initializer-clause ...[opt] 2118/// 2119/// [C++0x] initializer-clause: 2120/// [C++0x] assignment-expression 2121/// [C++0x] braced-init-list 2122/// 2123bool Parser::ParseExpressionList(SmallVectorImpl<Expr*> &Exprs, 2124 SmallVectorImpl<SourceLocation> &CommaLocs, 2125 void (Sema::*Completer)(Scope *S, 2126 Expr *Data, 2127 Expr **Args, 2128 unsigned NumArgs), 2129 Expr *Data) { 2130 while (1) { 2131 if (Tok.is(tok::code_completion)) { 2132 if (Completer) 2133 (Actions.*Completer)(getCurScope(), Data, Exprs.data(), Exprs.size()); 2134 else 2135 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression); 2136 ConsumeCodeCompletionToken(); 2137 } 2138 2139 ExprResult Expr; 2140 if (getLang().CPlusPlus0x && Tok.is(tok::l_brace)) 2141 Expr = ParseBraceInitializer(); 2142 else 2143 Expr = ParseAssignmentExpression(); 2144 2145 if (Tok.is(tok::ellipsis)) 2146 Expr = Actions.ActOnPackExpansion(Expr.get(), ConsumeToken()); 2147 if (Expr.isInvalid()) 2148 return true; 2149 2150 Exprs.push_back(Expr.release()); 2151 2152 if (Tok.isNot(tok::comma)) 2153 return false; 2154 // Move to the next argument, remember where the comma was. 2155 CommaLocs.push_back(ConsumeToken()); 2156 } 2157} 2158 2159/// ParseBlockId - Parse a block-id, which roughly looks like int (int x). 2160/// 2161/// [clang] block-id: 2162/// [clang] specifier-qualifier-list block-declarator 2163/// 2164void Parser::ParseBlockId() { 2165 if (Tok.is(tok::code_completion)) { 2166 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type); 2167 ConsumeCodeCompletionToken(); 2168 } 2169 2170 // Parse the specifier-qualifier-list piece. 2171 DeclSpec DS(AttrFactory); 2172 ParseSpecifierQualifierList(DS); 2173 2174 // Parse the block-declarator. 2175 Declarator DeclaratorInfo(DS, Declarator::BlockLiteralContext); 2176 ParseDeclarator(DeclaratorInfo); 2177 2178 // We do this for: ^ __attribute__((noreturn)) {, as DS has the attributes. 2179 DeclaratorInfo.takeAttributes(DS.getAttributes(), SourceLocation()); 2180 2181 MaybeParseGNUAttributes(DeclaratorInfo); 2182 2183 // Inform sema that we are starting a block. 2184 Actions.ActOnBlockArguments(DeclaratorInfo, getCurScope()); 2185} 2186 2187/// ParseBlockLiteralExpression - Parse a block literal, which roughly looks 2188/// like ^(int x){ return x+1; } 2189/// 2190/// block-literal: 2191/// [clang] '^' block-args[opt] compound-statement 2192/// [clang] '^' block-id compound-statement 2193/// [clang] block-args: 2194/// [clang] '(' parameter-list ')' 2195/// 2196ExprResult Parser::ParseBlockLiteralExpression() { 2197 assert(Tok.is(tok::caret) && "block literal starts with ^"); 2198 SourceLocation CaretLoc = ConsumeToken(); 2199 2200 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), CaretLoc, 2201 "block literal parsing"); 2202 2203 // Enter a scope to hold everything within the block. This includes the 2204 // argument decls, decls within the compound expression, etc. This also 2205 // allows determining whether a variable reference inside the block is 2206 // within or outside of the block. 2207 ParseScope BlockScope(this, Scope::BlockScope | Scope::FnScope | 2208 Scope::BreakScope | Scope::ContinueScope | 2209 Scope::DeclScope); 2210 2211 // Inform sema that we are starting a block. 2212 Actions.ActOnBlockStart(CaretLoc, getCurScope()); 2213 2214 // Parse the return type if present. 2215 DeclSpec DS(AttrFactory); 2216 Declarator ParamInfo(DS, Declarator::BlockLiteralContext); 2217 // FIXME: Since the return type isn't actually parsed, it can't be used to 2218 // fill ParamInfo with an initial valid range, so do it manually. 2219 ParamInfo.SetSourceRange(SourceRange(Tok.getLocation(), Tok.getLocation())); 2220 2221 // If this block has arguments, parse them. There is no ambiguity here with 2222 // the expression case, because the expression case requires a parameter list. 2223 if (Tok.is(tok::l_paren)) { 2224 ParseParenDeclarator(ParamInfo); 2225 // Parse the pieces after the identifier as if we had "int(...)". 2226 // SetIdentifier sets the source range end, but in this case we're past 2227 // that location. 2228 SourceLocation Tmp = ParamInfo.getSourceRange().getEnd(); 2229 ParamInfo.SetIdentifier(0, CaretLoc); 2230 ParamInfo.SetRangeEnd(Tmp); 2231 if (ParamInfo.isInvalidType()) { 2232 // If there was an error parsing the arguments, they may have 2233 // tried to use ^(x+y) which requires an argument list. Just 2234 // skip the whole block literal. 2235 Actions.ActOnBlockError(CaretLoc, getCurScope()); 2236 return ExprError(); 2237 } 2238 2239 MaybeParseGNUAttributes(ParamInfo); 2240 2241 // Inform sema that we are starting a block. 2242 Actions.ActOnBlockArguments(ParamInfo, getCurScope()); 2243 } else if (!Tok.is(tok::l_brace)) { 2244 ParseBlockId(); 2245 } else { 2246 // Otherwise, pretend we saw (void). 2247 ParsedAttributes attrs(AttrFactory); 2248 ParamInfo.AddTypeInfo(DeclaratorChunk::getFunction(true, false, 2249 SourceLocation(), 2250 0, 0, 0, 2251 true, SourceLocation(), 2252 SourceLocation(), 2253 EST_None, 2254 SourceLocation(), 2255 0, 0, 0, 0, 2256 CaretLoc, CaretLoc, 2257 ParamInfo), 2258 attrs, CaretLoc); 2259 2260 MaybeParseGNUAttributes(ParamInfo); 2261 2262 // Inform sema that we are starting a block. 2263 Actions.ActOnBlockArguments(ParamInfo, getCurScope()); 2264 } 2265 2266 2267 ExprResult Result(true); 2268 if (!Tok.is(tok::l_brace)) { 2269 // Saw something like: ^expr 2270 Diag(Tok, diag::err_expected_expression); 2271 Actions.ActOnBlockError(CaretLoc, getCurScope()); 2272 return ExprError(); 2273 } 2274 2275 StmtResult Stmt(ParseCompoundStatementBody()); 2276 BlockScope.Exit(); 2277 if (!Stmt.isInvalid()) 2278 Result = Actions.ActOnBlockStmtExpr(CaretLoc, Stmt.take(), getCurScope()); 2279 else 2280 Actions.ActOnBlockError(CaretLoc, getCurScope()); 2281 return move(Result); 2282} 2283