ParseExpr.cpp revision 207619
1238106Sdes//===--- ParseExpr.cpp - Expression Parsing -------------------------------===// 2238106Sdes// 3238106Sdes// The LLVM Compiler Infrastructure 4238106Sdes// 5238106Sdes// This file is distributed under the University of Illinois Open Source 6238106Sdes// License. See LICENSE.TXT for details. 7238106Sdes// 8238106Sdes//===----------------------------------------------------------------------===// 9238106Sdes// 10238106Sdes// This file implements the Expression parsing implementation. Expressions in 11238106Sdes// C99 basically consist of a bunch of binary operators with unary operators and 12238106Sdes// other random stuff at the leaves. 13238106Sdes// 14238106Sdes// In the C99 grammar, these unary operators bind tightest and are represented 15238106Sdes// as the 'cast-expression' production. Everything else is either a binary 16238106Sdes// operator (e.g. '/') or a ternary operator ("?:"). The unary leaves are 17238106Sdes// handled by ParseCastExpression, the higher level pieces are handled by 18238106Sdes// ParseBinaryExpression. 19238106Sdes// 20238106Sdes//===----------------------------------------------------------------------===// 21238106Sdes 22238106Sdes#include "clang/Parse/Parser.h" 23238106Sdes#include "clang/Parse/DeclSpec.h" 24269257Sdes#include "clang/Parse/Scope.h" 25269257Sdes#include "clang/Parse/Template.h" 26269257Sdes#include "clang/Basic/PrettyStackTrace.h" 27269257Sdes#include "RAIIObjectsForParser.h" 28269257Sdes#include "llvm/ADT/SmallVector.h" 29269257Sdes#include "llvm/ADT/SmallString.h" 30269257Sdesusing namespace clang; 31269257Sdes 32269257Sdes/// getBinOpPrecedence - Return the precedence of the specified binary operator 33269257Sdes/// token. This returns: 34238106Sdes/// 35238106Sdesstatic prec::Level getBinOpPrecedence(tok::TokenKind Kind, 36238106Sdes bool GreaterThanIsOperator, 37238106Sdes bool CPlusPlus0x) { 38238106Sdes switch (Kind) { 39238106Sdes case tok::greater: 40238106Sdes // C++ [temp.names]p3: 41238106Sdes // [...] When parsing a template-argument-list, the first 42238106Sdes // non-nested > is taken as the ending delimiter rather than a 43238106Sdes // greater-than operator. [...] 44238106Sdes if (GreaterThanIsOperator) 45291767Sdes return prec::Relational; 46238106Sdes return prec::Unknown; 47238106Sdes 48238106Sdes case tok::greatergreater: 49238106Sdes // C++0x [temp.names]p3: 50238106Sdes // 51238106Sdes // [...] Similarly, the first non-nested >> is treated as two 52238106Sdes // consecutive but distinct > tokens, the first of which is 53238106Sdes // taken as the end of the template-argument-list and completes 54238106Sdes // the template-id. [...] 55238106Sdes if (GreaterThanIsOperator || !CPlusPlus0x) 56238106Sdes return prec::Shift; 57238106Sdes return prec::Unknown; 58238106Sdes 59238106Sdes default: return prec::Unknown; 60238106Sdes case tok::comma: return prec::Comma; 61238106Sdes case tok::equal: 62238106Sdes case tok::starequal: 63238106Sdes case tok::slashequal: 64238106Sdes case tok::percentequal: 65238106Sdes case tok::plusequal: 66238106Sdes case tok::minusequal: 67238106Sdes case tok::lesslessequal: 68238106Sdes case tok::greatergreaterequal: 69238106Sdes case tok::ampequal: 70238106Sdes case tok::caretequal: 71238106Sdes case tok::pipeequal: return prec::Assignment; 72269257Sdes case tok::question: return prec::Conditional; 73238106Sdes case tok::pipepipe: return prec::LogicalOr; 74238106Sdes case tok::ampamp: return prec::LogicalAnd; 75269257Sdes case tok::pipe: return prec::InclusiveOr; 76238106Sdes case tok::caret: return prec::ExclusiveOr; 77238106Sdes case tok::amp: return prec::And; 78238106Sdes case tok::exclaimequal: 79238106Sdes case tok::equalequal: return prec::Equality; 80238106Sdes case tok::lessequal: 81238106Sdes case tok::less: 82238106Sdes case tok::greaterequal: return prec::Relational; 83238106Sdes case tok::lessless: return prec::Shift; 84238106Sdes case tok::plus: 85238106Sdes case tok::minus: return prec::Additive; 86238106Sdes case tok::percent: 87238106Sdes case tok::slash: 88238106Sdes case tok::star: return prec::Multiplicative; 89238106Sdes case tok::periodstar: 90238106Sdes case tok::arrowstar: return prec::PointerToMember; 91238106Sdes } 92238106Sdes} 93238106Sdes 94238106Sdes 95238106Sdes/// ParseExpression - Simple precedence-based parser for binary/ternary 96238106Sdes/// operators. 97238106Sdes/// 98238106Sdes/// Note: we diverge from the C99 grammar when parsing the assignment-expression 99238106Sdes/// production. C99 specifies that the LHS of an assignment operator should be 100238106Sdes/// parsed as a unary-expression, but consistency dictates that it be a 101238106Sdes/// conditional-expession. In practice, the important thing here is that the 102238106Sdes/// LHS of an assignment has to be an l-value, which productions between 103238106Sdes/// unary-expression and conditional-expression don't produce. Because we want 104238106Sdes/// consistency, we parse the LHS as a conditional-expression, then check for 105238106Sdes/// l-value-ness in semantic analysis stages. 106238106Sdes/// 107238106Sdes/// pm-expression: [C++ 5.5] 108238106Sdes/// cast-expression 109238106Sdes/// pm-expression '.*' cast-expression 110238106Sdes/// pm-expression '->*' cast-expression 111238106Sdes/// 112291767Sdes/// multiplicative-expression: [C99 6.5.5] 113291767Sdes/// Note: in C++, apply pm-expression instead of cast-expression 114291767Sdes/// cast-expression 115291767Sdes/// multiplicative-expression '*' cast-expression 116238106Sdes/// multiplicative-expression '/' cast-expression 117238106Sdes/// multiplicative-expression '%' cast-expression 118291767Sdes/// 119291767Sdes/// additive-expression: [C99 6.5.6] 120291767Sdes/// multiplicative-expression 121291767Sdes/// additive-expression '+' multiplicative-expression 122291767Sdes/// additive-expression '-' multiplicative-expression 123291767Sdes/// 124291767Sdes/// shift-expression: [C99 6.5.7] 125291767Sdes/// additive-expression 126291767Sdes/// shift-expression '<<' additive-expression 127291767Sdes/// shift-expression '>>' additive-expression 128291767Sdes/// 129291767Sdes/// relational-expression: [C99 6.5.8] 130291767Sdes/// shift-expression 131291767Sdes/// relational-expression '<' shift-expression 132291767Sdes/// relational-expression '>' shift-expression 133291767Sdes/// relational-expression '<=' shift-expression 134291767Sdes/// relational-expression '>=' shift-expression 135291767Sdes/// 136291767Sdes/// equality-expression: [C99 6.5.9] 137291767Sdes/// relational-expression 138291767Sdes/// equality-expression '==' relational-expression 139291767Sdes/// equality-expression '!=' relational-expression 140291767Sdes/// 141291767Sdes/// AND-expression: [C99 6.5.10] 142291767Sdes/// equality-expression 143291767Sdes/// AND-expression '&' equality-expression 144291767Sdes/// 145291767Sdes/// exclusive-OR-expression: [C99 6.5.11] 146291767Sdes/// AND-expression 147291767Sdes/// exclusive-OR-expression '^' AND-expression 148291767Sdes/// 149291767Sdes/// inclusive-OR-expression: [C99 6.5.12] 150291767Sdes/// exclusive-OR-expression 151291767Sdes/// inclusive-OR-expression '|' exclusive-OR-expression 152291767Sdes/// 153291767Sdes/// logical-AND-expression: [C99 6.5.13] 154291767Sdes/// inclusive-OR-expression 155291767Sdes/// logical-AND-expression '&&' inclusive-OR-expression 156291767Sdes/// 157291767Sdes/// logical-OR-expression: [C99 6.5.14] 158291767Sdes/// logical-AND-expression 159291767Sdes/// logical-OR-expression '||' logical-AND-expression 160291767Sdes/// 161291767Sdes/// conditional-expression: [C99 6.5.15] 162291767Sdes/// logical-OR-expression 163238106Sdes/// logical-OR-expression '?' expression ':' conditional-expression 164238106Sdes/// [GNU] logical-OR-expression '?' ':' conditional-expression 165238106Sdes/// [C++] the third operand is an assignment-expression 166238106Sdes/// 167238106Sdes/// assignment-expression: [C99 6.5.16] 168238106Sdes/// conditional-expression 169238106Sdes/// unary-expression assignment-operator assignment-expression 170238106Sdes/// [C++] throw-expression [C++ 15] 171238106Sdes/// 172238106Sdes/// assignment-operator: one of 173238106Sdes/// = *= /= %= += -= <<= >>= &= ^= |= 174238106Sdes/// 175238106Sdes/// expression: [C99 6.5.17] 176238106Sdes/// assignment-expression 177238106Sdes/// expression ',' assignment-expression 178238106Sdes/// 179238106SdesParser::OwningExprResult Parser::ParseExpression() { 180238106Sdes OwningExprResult LHS(ParseAssignmentExpression()); 181238106Sdes if (LHS.isInvalid()) return move(LHS); 182238106Sdes 183238106Sdes return ParseRHSOfBinaryExpression(move(LHS), prec::Comma); 184238106Sdes} 185238106Sdes 186238106Sdes/// This routine is called when the '@' is seen and consumed. 187238106Sdes/// Current token is an Identifier and is not a 'try'. This 188238106Sdes/// routine is necessary to disambiguate @try-statement from, 189238106Sdes/// for example, @encode-expression. 190238106Sdes/// 191238106SdesParser::OwningExprResult 192238106SdesParser::ParseExpressionWithLeadingAt(SourceLocation AtLoc) { 193238106Sdes OwningExprResult LHS(ParseObjCAtExpression(AtLoc)); 194238106Sdes if (LHS.isInvalid()) return move(LHS); 195238106Sdes 196238106Sdes return ParseRHSOfBinaryExpression(move(LHS), prec::Comma); 197238106Sdes} 198238106Sdes 199238106Sdes/// This routine is called when a leading '__extension__' is seen and 200238106Sdes/// consumed. This is necessary because the token gets consumed in the 201238106Sdes/// process of disambiguating between an expression and a declaration. 202238106SdesParser::OwningExprResult 203238106SdesParser::ParseExpressionWithLeadingExtension(SourceLocation ExtLoc) { 204238106Sdes OwningExprResult LHS(Actions, true); 205238106Sdes { 206238106Sdes // Silence extension warnings in the sub-expression 207238106Sdes ExtensionRAIIObject O(Diags); 208238106Sdes 209238106Sdes LHS = ParseCastExpression(false); 210238106Sdes if (LHS.isInvalid()) return move(LHS); 211238106Sdes } 212238106Sdes 213238106Sdes LHS = Actions.ActOnUnaryOp(CurScope, ExtLoc, tok::kw___extension__, 214238106Sdes move(LHS)); 215238106Sdes if (LHS.isInvalid()) return move(LHS); 216238106Sdes 217238106Sdes return ParseRHSOfBinaryExpression(move(LHS), prec::Comma); 218238106Sdes} 219238106Sdes 220238106Sdes/// ParseAssignmentExpression - Parse an expr that doesn't include commas. 221238106Sdes/// 222238106SdesParser::OwningExprResult Parser::ParseAssignmentExpression() { 223238106Sdes if (Tok.is(tok::code_completion)) { 224238106Sdes Actions.CodeCompleteOrdinaryName(CurScope, Action::CCC_Expression); 225238106Sdes ConsumeToken(); 226269257Sdes } 227238106Sdes 228238106Sdes if (Tok.is(tok::kw_throw)) 229238106Sdes return ParseThrowExpression(); 230238106Sdes 231238106Sdes OwningExprResult LHS(ParseCastExpression(false)); 232238106Sdes if (LHS.isInvalid()) return move(LHS); 233238106Sdes 234238106Sdes return ParseRHSOfBinaryExpression(move(LHS), prec::Assignment); 235238106Sdes} 236238106Sdes 237238106Sdes/// ParseAssignmentExprWithObjCMessageExprStart - Parse an assignment expression 238238106Sdes/// where part of an objc message send has already been parsed. In this case 239238106Sdes/// LBracLoc indicates the location of the '[' of the message send, and either 240238106Sdes/// ReceiverName or ReceiverExpr is non-null indicating the receiver of the 241238106Sdes/// message. 242238106Sdes/// 243238106Sdes/// Since this handles full assignment-expression's, it handles postfix 244238106Sdes/// expressions and other binary operators for these expressions as well. 245269257SdesParser::OwningExprResult 246238106SdesParser::ParseAssignmentExprWithObjCMessageExprStart(SourceLocation LBracLoc, 247238106Sdes SourceLocation SuperLoc, 248238106Sdes TypeTy *ReceiverType, 249238106Sdes ExprArg ReceiverExpr) { 250238106Sdes OwningExprResult R(ParseObjCMessageExpressionBody(LBracLoc, SuperLoc, 251238106Sdes ReceiverType, 252238106Sdes move(ReceiverExpr))); 253238106Sdes if (R.isInvalid()) return move(R); 254238106Sdes R = ParsePostfixExpressionSuffix(move(R)); 255238106Sdes if (R.isInvalid()) return move(R); 256238106Sdes return ParseRHSOfBinaryExpression(move(R), prec::Assignment); 257238106Sdes} 258238106Sdes 259238106Sdes 260238106SdesParser::OwningExprResult Parser::ParseConstantExpression() { 261238106Sdes // C++ [basic.def.odr]p2: 262238106Sdes // An expression is potentially evaluated unless it appears where an 263238106Sdes // integral constant expression is required (see 5.19) [...]. 264238106Sdes EnterExpressionEvaluationContext Unevaluated(Actions, 265269257Sdes Action::Unevaluated); 266238106Sdes 267238106Sdes OwningExprResult LHS(ParseCastExpression(false)); 268238106Sdes if (LHS.isInvalid()) return move(LHS); 269238106Sdes 270238106Sdes return ParseRHSOfBinaryExpression(move(LHS), prec::Conditional); 271238106Sdes} 272238106Sdes 273238106Sdes/// ParseRHSOfBinaryExpression - Parse a binary expression that starts with 274238106Sdes/// LHS and has a precedence of at least MinPrec. 275238106SdesParser::OwningExprResult 276238106SdesParser::ParseRHSOfBinaryExpression(OwningExprResult LHS, prec::Level MinPrec) { 277238106Sdes prec::Level NextTokPrec = getBinOpPrecedence(Tok.getKind(), 278238106Sdes GreaterThanIsOperator, 279238106Sdes getLang().CPlusPlus0x); 280238106Sdes SourceLocation ColonLoc; 281238106Sdes 282238106Sdes while (1) { 283238106Sdes // If this token has a lower precedence than we are allowed to parse (e.g. 284238106Sdes // because we are called recursively, or because the token is not a binop), 285238106Sdes // then we are done! 286238106Sdes if (NextTokPrec < MinPrec) 287238106Sdes return move(LHS); 288238106Sdes 289238106Sdes // Consume the operator, saving the operator token for error reporting. 290238106Sdes Token OpToken = Tok; 291238106Sdes ConsumeToken(); 292238106Sdes 293269257Sdes // Special case handling for the ternary operator. 294238106Sdes OwningExprResult TernaryMiddle(Actions, true); 295238106Sdes if (NextTokPrec == prec::Conditional) { 296238106Sdes if (Tok.isNot(tok::colon)) { 297238106Sdes // Don't parse FOO:BAR as if it were a typo for FOO::BAR. 298238106Sdes ColonProtectionRAIIObject X(*this); 299238106Sdes 300238106Sdes // Handle this production specially: 301238106Sdes // logical-OR-expression '?' expression ':' conditional-expression 302238106Sdes // In particular, the RHS of the '?' is 'expression', not 303238106Sdes // 'logical-OR-expression' as we might expect. 304238106Sdes TernaryMiddle = ParseExpression(); 305238106Sdes if (TernaryMiddle.isInvalid()) 306238106Sdes return move(TernaryMiddle); 307238106Sdes } else { 308238106Sdes // Special case handling of "X ? Y : Z" where Y is empty: 309238106Sdes // logical-OR-expression '?' ':' conditional-expression [GNU] 310238106Sdes TernaryMiddle = 0; 311238106Sdes Diag(Tok, diag::ext_gnu_conditional_expr); 312238106Sdes } 313238106Sdes 314238106Sdes if (Tok.is(tok::colon)) { 315238106Sdes // Eat the colon. 316269257Sdes ColonLoc = ConsumeToken(); 317238106Sdes } else { 318238106Sdes Diag(Tok, diag::err_expected_colon) 319238106Sdes << FixItHint::CreateInsertion(Tok.getLocation(), ": "); 320238106Sdes Diag(OpToken, diag::note_matching) << "?"; 321238106Sdes ColonLoc = Tok.getLocation(); 322238106Sdes } 323238106Sdes } 324238106Sdes 325238106Sdes // Parse another leaf here for the RHS of the operator. 326238106Sdes // ParseCastExpression works here because all RHS expressions in C have it 327238106Sdes // as a prefix, at least. However, in C++, an assignment-expression could 328238106Sdes // be a throw-expression, which is not a valid cast-expression. 329238106Sdes // Therefore we need some special-casing here. 330238106Sdes // Also note that the third operand of the conditional operator is 331238106Sdes // an assignment-expression in C++. 332238106Sdes OwningExprResult RHS(Actions); 333238106Sdes if (getLang().CPlusPlus && NextTokPrec <= prec::Conditional) 334269257Sdes RHS = ParseAssignmentExpression(); 335238106Sdes else 336269257Sdes RHS = ParseCastExpression(false); 337238106Sdes if (RHS.isInvalid()) 338238106Sdes return move(RHS); 339238106Sdes 340291767Sdes // Remember the precedence of this operator and get the precedence of the 341291767Sdes // operator immediately to the right of the RHS. 342291767Sdes prec::Level ThisPrec = NextTokPrec; 343291767Sdes NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator, 344291767Sdes getLang().CPlusPlus0x); 345291767Sdes 346291767Sdes // Assignment and conditional expressions are right-associative. 347291767Sdes bool isRightAssoc = ThisPrec == prec::Conditional || 348291767Sdes ThisPrec == prec::Assignment; 349291767Sdes 350291767Sdes // Get the precedence of the operator to the right of the RHS. If it binds 351291767Sdes // more tightly with RHS than we do, evaluate it completely first. 352291767Sdes if (ThisPrec < NextTokPrec || 353291767Sdes (ThisPrec == NextTokPrec && isRightAssoc)) { 354291767Sdes // If this is left-associative, only parse things on the RHS that bind 355291767Sdes // more tightly than the current operator. If it is left-associative, it 356291767Sdes // is okay, to bind exactly as tightly. For example, compile A=B=C=D as 357291767Sdes // A=(B=(C=D)), where each paren is a level of recursion here. 358291767Sdes // The function takes ownership of the RHS. 359291767Sdes RHS = ParseRHSOfBinaryExpression(move(RHS), 360291767Sdes static_cast<prec::Level>(ThisPrec + !isRightAssoc)); 361291767Sdes if (RHS.isInvalid()) 362291767Sdes return move(RHS); 363291767Sdes 364291767Sdes NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator, 365291767Sdes getLang().CPlusPlus0x); 366291767Sdes } 367291767Sdes assert(NextTokPrec <= ThisPrec && "Recursion didn't work!"); 368291767Sdes 369291767Sdes if (!LHS.isInvalid()) { 370291767Sdes // Combine the LHS and RHS into the LHS (e.g. build AST). 371291767Sdes if (TernaryMiddle.isInvalid()) { 372291767Sdes // If we're using '>>' as an operator within a template 373291767Sdes // argument list (in C++98), suggest the addition of 374291767Sdes // parentheses so that the code remains well-formed in C++0x. 375291767Sdes if (!GreaterThanIsOperator && OpToken.is(tok::greatergreater)) 376291767Sdes SuggestParentheses(OpToken.getLocation(), 377291767Sdes diag::warn_cxx0x_right_shift_in_template_arg, 378291767Sdes SourceRange(Actions.getExprRange(LHS.get()).getBegin(), 379291767Sdes Actions.getExprRange(RHS.get()).getEnd())); 380291767Sdes 381291767Sdes LHS = Actions.ActOnBinOp(CurScope, OpToken.getLocation(), 382291767Sdes OpToken.getKind(), move(LHS), move(RHS)); 383291767Sdes } else 384291767Sdes LHS = Actions.ActOnConditionalOp(OpToken.getLocation(), ColonLoc, 385238106Sdes move(LHS), move(TernaryMiddle), 386238106Sdes move(RHS)); 387238106Sdes } 388238106Sdes } 389238106Sdes} 390238106Sdes 391238106Sdes/// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is 392238106Sdes/// true, parse a unary-expression. isAddressOfOperand exists because an 393238106Sdes/// id-expression that is the operand of address-of gets special treatment 394238106Sdes/// due to member pointers. 395238106Sdes/// 396238106SdesParser::OwningExprResult Parser::ParseCastExpression(bool isUnaryExpression, 397238106Sdes bool isAddressOfOperand, 398238106Sdes TypeTy *TypeOfCast) { 399238106Sdes bool NotCastExpr; 400238106Sdes OwningExprResult Res = ParseCastExpression(isUnaryExpression, 401238106Sdes isAddressOfOperand, 402238106Sdes NotCastExpr, 403238106Sdes TypeOfCast); 404291767Sdes if (NotCastExpr) 405291767Sdes Diag(Tok, diag::err_expected_expression); 406291767Sdes return move(Res); 407291767Sdes} 408291767Sdes 409291767Sdes/// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is 410291767Sdes/// true, parse a unary-expression. isAddressOfOperand exists because an 411291767Sdes/// id-expression that is the operand of address-of gets special treatment 412291767Sdes/// due to member pointers. NotCastExpr is set to true if the token is not the 413291767Sdes/// start of a cast-expression, and no diagnostic is emitted in this case. 414291767Sdes/// 415291767Sdes/// cast-expression: [C99 6.5.4] 416238106Sdes/// unary-expression 417/// '(' type-name ')' cast-expression 418/// 419/// unary-expression: [C99 6.5.3] 420/// postfix-expression 421/// '++' unary-expression 422/// '--' unary-expression 423/// unary-operator cast-expression 424/// 'sizeof' unary-expression 425/// 'sizeof' '(' type-name ')' 426/// [GNU] '__alignof' unary-expression 427/// [GNU] '__alignof' '(' type-name ')' 428/// [C++0x] 'alignof' '(' type-id ')' 429/// [GNU] '&&' identifier 430/// [C++] new-expression 431/// [C++] delete-expression 432/// 433/// unary-operator: one of 434/// '&' '*' '+' '-' '~' '!' 435/// [GNU] '__extension__' '__real' '__imag' 436/// 437/// primary-expression: [C99 6.5.1] 438/// [C99] identifier 439/// [C++] id-expression 440/// constant 441/// string-literal 442/// [C++] boolean-literal [C++ 2.13.5] 443/// [C++0x] 'nullptr' [C++0x 2.14.7] 444/// '(' expression ')' 445/// '__func__' [C99 6.4.2.2] 446/// [GNU] '__FUNCTION__' 447/// [GNU] '__PRETTY_FUNCTION__' 448/// [GNU] '(' compound-statement ')' 449/// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')' 450/// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')' 451/// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ',' 452/// assign-expr ')' 453/// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')' 454/// [GNU] '__null' 455/// [OBJC] '[' objc-message-expr ']' 456/// [OBJC] '@selector' '(' objc-selector-arg ')' 457/// [OBJC] '@protocol' '(' identifier ')' 458/// [OBJC] '@encode' '(' type-name ')' 459/// [OBJC] objc-string-literal 460/// [C++] simple-type-specifier '(' expression-list[opt] ')' [C++ 5.2.3] 461/// [C++] typename-specifier '(' expression-list[opt] ')' [C++ 5.2.3] 462/// [C++] 'const_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 463/// [C++] 'dynamic_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 464/// [C++] 'reinterpret_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 465/// [C++] 'static_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 466/// [C++] 'typeid' '(' expression ')' [C++ 5.2p1] 467/// [C++] 'typeid' '(' type-id ')' [C++ 5.2p1] 468/// [C++] 'this' [C++ 9.3.2] 469/// [G++] unary-type-trait '(' type-id ')' 470/// [G++] binary-type-trait '(' type-id ',' type-id ')' [TODO] 471/// [clang] '^' block-literal 472/// 473/// constant: [C99 6.4.4] 474/// integer-constant 475/// floating-constant 476/// enumeration-constant -> identifier 477/// character-constant 478/// 479/// id-expression: [C++ 5.1] 480/// unqualified-id 481/// qualified-id 482/// 483/// unqualified-id: [C++ 5.1] 484/// identifier 485/// operator-function-id 486/// conversion-function-id 487/// '~' class-name 488/// template-id 489/// 490/// new-expression: [C++ 5.3.4] 491/// '::'[opt] 'new' new-placement[opt] new-type-id 492/// new-initializer[opt] 493/// '::'[opt] 'new' new-placement[opt] '(' type-id ')' 494/// new-initializer[opt] 495/// 496/// delete-expression: [C++ 5.3.5] 497/// '::'[opt] 'delete' cast-expression 498/// '::'[opt] 'delete' '[' ']' cast-expression 499/// 500/// [GNU] unary-type-trait: 501/// '__has_nothrow_assign' [TODO] 502/// '__has_nothrow_copy' [TODO] 503/// '__has_nothrow_constructor' [TODO] 504/// '__has_trivial_assign' [TODO] 505/// '__has_trivial_copy' [TODO] 506/// '__has_trivial_constructor' 507/// '__has_trivial_destructor' 508/// '__has_virtual_destructor' [TODO] 509/// '__is_abstract' [TODO] 510/// '__is_class' 511/// '__is_empty' [TODO] 512/// '__is_enum' 513/// '__is_pod' 514/// '__is_polymorphic' 515/// '__is_union' 516/// 517/// [GNU] binary-type-trait: 518/// '__is_base_of' [TODO] 519/// 520Parser::OwningExprResult Parser::ParseCastExpression(bool isUnaryExpression, 521 bool isAddressOfOperand, 522 bool &NotCastExpr, 523 TypeTy *TypeOfCast) { 524 OwningExprResult Res(Actions); 525 tok::TokenKind SavedKind = Tok.getKind(); 526 NotCastExpr = false; 527 528 // This handles all of cast-expression, unary-expression, postfix-expression, 529 // and primary-expression. We handle them together like this for efficiency 530 // and to simplify handling of an expression starting with a '(' token: which 531 // may be one of a parenthesized expression, cast-expression, compound literal 532 // expression, or statement expression. 533 // 534 // If the parsed tokens consist of a primary-expression, the cases below 535 // call ParsePostfixExpressionSuffix to handle the postfix expression 536 // suffixes. Cases that cannot be followed by postfix exprs should 537 // return without invoking ParsePostfixExpressionSuffix. 538 switch (SavedKind) { 539 case tok::l_paren: { 540 // If this expression is limited to being a unary-expression, the parent can 541 // not start a cast expression. 542 ParenParseOption ParenExprType = 543 isUnaryExpression ? CompoundLiteral : CastExpr; 544 TypeTy *CastTy; 545 SourceLocation LParenLoc = Tok.getLocation(); 546 SourceLocation RParenLoc; 547 548 { 549 // The inside of the parens don't need to be a colon protected scope. 550 ColonProtectionRAIIObject X(*this, false); 551 552 Res = ParseParenExpression(ParenExprType, false/*stopIfCastExr*/, 553 TypeOfCast, CastTy, RParenLoc); 554 if (Res.isInvalid()) return move(Res); 555 } 556 557 switch (ParenExprType) { 558 case SimpleExpr: break; // Nothing else to do. 559 case CompoundStmt: break; // Nothing else to do. 560 case CompoundLiteral: 561 // We parsed '(' type-name ')' '{' ... '}'. If any suffixes of 562 // postfix-expression exist, parse them now. 563 break; 564 case CastExpr: 565 // We have parsed the cast-expression and no postfix-expr pieces are 566 // following. 567 return move(Res); 568 } 569 570 // These can be followed by postfix-expr pieces. 571 return ParsePostfixExpressionSuffix(move(Res)); 572 } 573 574 // primary-expression 575 case tok::numeric_constant: 576 // constant: integer-constant 577 // constant: floating-constant 578 579 Res = Actions.ActOnNumericConstant(Tok); 580 ConsumeToken(); 581 582 // These can be followed by postfix-expr pieces. 583 return ParsePostfixExpressionSuffix(move(Res)); 584 585 case tok::kw_true: 586 case tok::kw_false: 587 return ParseCXXBoolLiteral(); 588 589 case tok::kw_nullptr: 590 return Actions.ActOnCXXNullPtrLiteral(ConsumeToken()); 591 592 case tok::identifier: { // primary-expression: identifier 593 // unqualified-id: identifier 594 // constant: enumeration-constant 595 // Turn a potentially qualified name into a annot_typename or 596 // annot_cxxscope if it would be valid. This handles things like x::y, etc. 597 if (getLang().CPlusPlus) { 598 // Avoid the unnecessary parse-time lookup in the common case 599 // where the syntax forbids a type. 600 const Token &Next = NextToken(); 601 if (Next.is(tok::coloncolon) || 602 (!ColonIsSacred && Next.is(tok::colon)) || 603 Next.is(tok::less) || 604 Next.is(tok::l_paren)) { 605 // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse. 606 if (TryAnnotateTypeOrScopeToken()) 607 return ExprError(); 608 if (!Tok.is(tok::identifier)) 609 return ParseCastExpression(isUnaryExpression, isAddressOfOperand); 610 } 611 } 612 613 // Consume the identifier so that we can see if it is followed by a '(' or 614 // '.'. 615 IdentifierInfo &II = *Tok.getIdentifierInfo(); 616 SourceLocation ILoc = ConsumeToken(); 617 618 // Support 'Class.property' and 'super.property' notation. 619 if (getLang().ObjC1 && Tok.is(tok::period) && 620 (Actions.getTypeName(II, ILoc, CurScope) || 621 // Allow the base to be 'super' if in an objc-method. 622 (&II == Ident_super && CurScope->isInObjcMethodScope()))) { 623 SourceLocation DotLoc = ConsumeToken(); 624 625 if (Tok.isNot(tok::identifier)) { 626 Diag(Tok, diag::err_expected_property_name); 627 return ExprError(); 628 } 629 IdentifierInfo &PropertyName = *Tok.getIdentifierInfo(); 630 SourceLocation PropertyLoc = ConsumeToken(); 631 632 Res = Actions.ActOnClassPropertyRefExpr(II, PropertyName, 633 ILoc, PropertyLoc); 634 // These can be followed by postfix-expr pieces. 635 return ParsePostfixExpressionSuffix(move(Res)); 636 } 637 638 // Function designators are allowed to be undeclared (C99 6.5.1p2), so we 639 // need to know whether or not this identifier is a function designator or 640 // not. 641 UnqualifiedId Name; 642 CXXScopeSpec ScopeSpec; 643 Name.setIdentifier(&II, ILoc); 644 Res = Actions.ActOnIdExpression(CurScope, ScopeSpec, Name, 645 Tok.is(tok::l_paren), false); 646 // These can be followed by postfix-expr pieces. 647 return ParsePostfixExpressionSuffix(move(Res)); 648 } 649 case tok::char_constant: // constant: character-constant 650 Res = Actions.ActOnCharacterConstant(Tok); 651 ConsumeToken(); 652 // These can be followed by postfix-expr pieces. 653 return ParsePostfixExpressionSuffix(move(Res)); 654 case tok::kw___func__: // primary-expression: __func__ [C99 6.4.2.2] 655 case tok::kw___FUNCTION__: // primary-expression: __FUNCTION__ [GNU] 656 case tok::kw___PRETTY_FUNCTION__: // primary-expression: __P..Y_F..N__ [GNU] 657 Res = Actions.ActOnPredefinedExpr(Tok.getLocation(), SavedKind); 658 ConsumeToken(); 659 // These can be followed by postfix-expr pieces. 660 return ParsePostfixExpressionSuffix(move(Res)); 661 case tok::string_literal: // primary-expression: string-literal 662 case tok::wide_string_literal: 663 Res = ParseStringLiteralExpression(); 664 if (Res.isInvalid()) return move(Res); 665 // This can be followed by postfix-expr pieces (e.g. "foo"[1]). 666 return ParsePostfixExpressionSuffix(move(Res)); 667 case tok::kw___builtin_va_arg: 668 case tok::kw___builtin_offsetof: 669 case tok::kw___builtin_choose_expr: 670 case tok::kw___builtin_types_compatible_p: 671 return ParseBuiltinPrimaryExpression(); 672 case tok::kw___null: 673 return Actions.ActOnGNUNullExpr(ConsumeToken()); 674 break; 675 case tok::plusplus: // unary-expression: '++' unary-expression 676 case tok::minusminus: { // unary-expression: '--' unary-expression 677 SourceLocation SavedLoc = ConsumeToken(); 678 Res = ParseCastExpression(true); 679 if (!Res.isInvalid()) 680 Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res)); 681 return move(Res); 682 } 683 case tok::amp: { // unary-expression: '&' cast-expression 684 // Special treatment because of member pointers 685 SourceLocation SavedLoc = ConsumeToken(); 686 Res = ParseCastExpression(false, true); 687 if (!Res.isInvalid()) 688 Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res)); 689 return move(Res); 690 } 691 692 case tok::star: // unary-expression: '*' cast-expression 693 case tok::plus: // unary-expression: '+' cast-expression 694 case tok::minus: // unary-expression: '-' cast-expression 695 case tok::tilde: // unary-expression: '~' cast-expression 696 case tok::exclaim: // unary-expression: '!' cast-expression 697 case tok::kw___real: // unary-expression: '__real' cast-expression [GNU] 698 case tok::kw___imag: { // unary-expression: '__imag' cast-expression [GNU] 699 SourceLocation SavedLoc = ConsumeToken(); 700 Res = ParseCastExpression(false); 701 if (!Res.isInvalid()) 702 Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res)); 703 return move(Res); 704 } 705 706 case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU] 707 // __extension__ silences extension warnings in the subexpression. 708 ExtensionRAIIObject O(Diags); // Use RAII to do this. 709 SourceLocation SavedLoc = ConsumeToken(); 710 Res = ParseCastExpression(false); 711 if (!Res.isInvalid()) 712 Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res)); 713 return move(Res); 714 } 715 case tok::kw_sizeof: // unary-expression: 'sizeof' unary-expression 716 // unary-expression: 'sizeof' '(' type-name ')' 717 case tok::kw_alignof: 718 case tok::kw___alignof: // unary-expression: '__alignof' unary-expression 719 // unary-expression: '__alignof' '(' type-name ')' 720 // unary-expression: 'alignof' '(' type-id ')' 721 return ParseSizeofAlignofExpression(); 722 case tok::ampamp: { // unary-expression: '&&' identifier 723 SourceLocation AmpAmpLoc = ConsumeToken(); 724 if (Tok.isNot(tok::identifier)) 725 return ExprError(Diag(Tok, diag::err_expected_ident)); 726 727 Diag(AmpAmpLoc, diag::ext_gnu_address_of_label); 728 Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(), 729 Tok.getIdentifierInfo()); 730 ConsumeToken(); 731 return move(Res); 732 } 733 case tok::kw_const_cast: 734 case tok::kw_dynamic_cast: 735 case tok::kw_reinterpret_cast: 736 case tok::kw_static_cast: 737 Res = ParseCXXCasts(); 738 // These can be followed by postfix-expr pieces. 739 return ParsePostfixExpressionSuffix(move(Res)); 740 case tok::kw_typeid: 741 Res = ParseCXXTypeid(); 742 // This can be followed by postfix-expr pieces. 743 return ParsePostfixExpressionSuffix(move(Res)); 744 case tok::kw_this: 745 Res = ParseCXXThis(); 746 // This can be followed by postfix-expr pieces. 747 return ParsePostfixExpressionSuffix(move(Res)); 748 749 case tok::kw_char: 750 case tok::kw_wchar_t: 751 case tok::kw_char16_t: 752 case tok::kw_char32_t: 753 case tok::kw_bool: 754 case tok::kw_short: 755 case tok::kw_int: 756 case tok::kw_long: 757 case tok::kw_signed: 758 case tok::kw_unsigned: 759 case tok::kw_float: 760 case tok::kw_double: 761 case tok::kw_void: 762 case tok::kw_typename: 763 case tok::kw_typeof: 764 case tok::kw___vector: 765 case tok::annot_typename: { 766 if (!getLang().CPlusPlus) { 767 Diag(Tok, diag::err_expected_expression); 768 return ExprError(); 769 } 770 771 if (SavedKind == tok::kw_typename) { 772 // postfix-expression: typename-specifier '(' expression-list[opt] ')' 773 if (TryAnnotateTypeOrScopeToken()) 774 return ExprError(); 775 } 776 777 // postfix-expression: simple-type-specifier '(' expression-list[opt] ')' 778 // 779 DeclSpec DS; 780 ParseCXXSimpleTypeSpecifier(DS); 781 if (Tok.isNot(tok::l_paren)) 782 return ExprError(Diag(Tok, diag::err_expected_lparen_after_type) 783 << DS.getSourceRange()); 784 785 Res = ParseCXXTypeConstructExpression(DS); 786 // This can be followed by postfix-expr pieces. 787 return ParsePostfixExpressionSuffix(move(Res)); 788 } 789 790 case tok::annot_cxxscope: { // [C++] id-expression: qualified-id 791 // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse. 792 // (We can end up in this situation after tentative parsing.) 793 if (TryAnnotateTypeOrScopeToken()) 794 return ExprError(); 795 if (!Tok.is(tok::annot_cxxscope)) 796 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 797 NotCastExpr, TypeOfCast); 798 799 Token Next = NextToken(); 800 if (Next.is(tok::annot_template_id)) { 801 TemplateIdAnnotation *TemplateId 802 = static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue()); 803 if (TemplateId->Kind == TNK_Type_template) { 804 // We have a qualified template-id that we know refers to a 805 // type, translate it into a type and continue parsing as a 806 // cast expression. 807 CXXScopeSpec SS; 808 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/0, false); 809 AnnotateTemplateIdTokenAsType(&SS); 810 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 811 NotCastExpr, TypeOfCast); 812 } 813 } 814 815 // Parse as an id-expression. 816 Res = ParseCXXIdExpression(isAddressOfOperand); 817 return ParsePostfixExpressionSuffix(move(Res)); 818 } 819 820 case tok::annot_template_id: { // [C++] template-id 821 TemplateIdAnnotation *TemplateId 822 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 823 if (TemplateId->Kind == TNK_Type_template) { 824 // We have a template-id that we know refers to a type, 825 // translate it into a type and continue parsing as a cast 826 // expression. 827 AnnotateTemplateIdTokenAsType(); 828 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 829 NotCastExpr, TypeOfCast); 830 } 831 832 // Fall through to treat the template-id as an id-expression. 833 } 834 835 case tok::kw_operator: // [C++] id-expression: operator/conversion-function-id 836 Res = ParseCXXIdExpression(isAddressOfOperand); 837 return ParsePostfixExpressionSuffix(move(Res)); 838 839 case tok::coloncolon: { 840 // ::foo::bar -> global qualified name etc. If TryAnnotateTypeOrScopeToken 841 // annotates the token, tail recurse. 842 if (TryAnnotateTypeOrScopeToken()) 843 return ExprError(); 844 if (!Tok.is(tok::coloncolon)) 845 return ParseCastExpression(isUnaryExpression, isAddressOfOperand); 846 847 // ::new -> [C++] new-expression 848 // ::delete -> [C++] delete-expression 849 SourceLocation CCLoc = ConsumeToken(); 850 if (Tok.is(tok::kw_new)) 851 return ParseCXXNewExpression(true, CCLoc); 852 if (Tok.is(tok::kw_delete)) 853 return ParseCXXDeleteExpression(true, CCLoc); 854 855 // This is not a type name or scope specifier, it is an invalid expression. 856 Diag(CCLoc, diag::err_expected_expression); 857 return ExprError(); 858 } 859 860 case tok::kw_new: // [C++] new-expression 861 return ParseCXXNewExpression(false, Tok.getLocation()); 862 863 case tok::kw_delete: // [C++] delete-expression 864 return ParseCXXDeleteExpression(false, Tok.getLocation()); 865 866 case tok::kw___is_pod: // [GNU] unary-type-trait 867 case tok::kw___is_class: 868 case tok::kw___is_enum: 869 case tok::kw___is_union: 870 case tok::kw___is_empty: 871 case tok::kw___is_polymorphic: 872 case tok::kw___is_abstract: 873 case tok::kw___is_literal: 874 case tok::kw___has_trivial_constructor: 875 case tok::kw___has_trivial_copy: 876 case tok::kw___has_trivial_assign: 877 case tok::kw___has_trivial_destructor: 878 return ParseUnaryTypeTrait(); 879 880 case tok::at: { 881 SourceLocation AtLoc = ConsumeToken(); 882 return ParseObjCAtExpression(AtLoc); 883 } 884 case tok::caret: 885 return ParsePostfixExpressionSuffix(ParseBlockLiteralExpression()); 886 case tok::code_completion: 887 Actions.CodeCompleteOrdinaryName(CurScope, Action::CCC_Expression); 888 ConsumeToken(); 889 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 890 NotCastExpr, TypeOfCast); 891 case tok::l_square: 892 // These can be followed by postfix-expr pieces. 893 if (getLang().ObjC1) 894 return ParsePostfixExpressionSuffix(ParseObjCMessageExpression()); 895 // FALL THROUGH. 896 default: 897 NotCastExpr = true; 898 return ExprError(); 899 } 900 901 // unreachable. 902 abort(); 903} 904 905/// ParsePostfixExpressionSuffix - Once the leading part of a postfix-expression 906/// is parsed, this method parses any suffixes that apply. 907/// 908/// postfix-expression: [C99 6.5.2] 909/// primary-expression 910/// postfix-expression '[' expression ']' 911/// postfix-expression '(' argument-expression-list[opt] ')' 912/// postfix-expression '.' identifier 913/// postfix-expression '->' identifier 914/// postfix-expression '++' 915/// postfix-expression '--' 916/// '(' type-name ')' '{' initializer-list '}' 917/// '(' type-name ')' '{' initializer-list ',' '}' 918/// 919/// argument-expression-list: [C99 6.5.2] 920/// argument-expression 921/// argument-expression-list ',' assignment-expression 922/// 923Parser::OwningExprResult 924Parser::ParsePostfixExpressionSuffix(OwningExprResult LHS) { 925 // Now that the primary-expression piece of the postfix-expression has been 926 // parsed, see if there are any postfix-expression pieces here. 927 SourceLocation Loc; 928 while (1) { 929 switch (Tok.getKind()) { 930 default: // Not a postfix-expression suffix. 931 return move(LHS); 932 case tok::l_square: { // postfix-expression: p-e '[' expression ']' 933 Loc = ConsumeBracket(); 934 OwningExprResult Idx(ParseExpression()); 935 936 SourceLocation RLoc = Tok.getLocation(); 937 938 if (!LHS.isInvalid() && !Idx.isInvalid() && Tok.is(tok::r_square)) { 939 LHS = Actions.ActOnArraySubscriptExpr(CurScope, move(LHS), Loc, 940 move(Idx), RLoc); 941 } else 942 LHS = ExprError(); 943 944 // Match the ']'. 945 MatchRHSPunctuation(tok::r_square, Loc); 946 break; 947 } 948 949 case tok::l_paren: { // p-e: p-e '(' argument-expression-list[opt] ')' 950 ExprVector ArgExprs(Actions); 951 CommaLocsTy CommaLocs; 952 953 Loc = ConsumeParen(); 954 955 if (Tok.is(tok::code_completion)) { 956 Actions.CodeCompleteCall(CurScope, LHS.get(), 0, 0); 957 ConsumeToken(); 958 } 959 960 if (Tok.isNot(tok::r_paren)) { 961 if (ParseExpressionList(ArgExprs, CommaLocs, &Action::CodeCompleteCall, 962 LHS.get())) { 963 SkipUntil(tok::r_paren); 964 return ExprError(); 965 } 966 } 967 968 // Match the ')'. 969 if (Tok.isNot(tok::r_paren)) { 970 MatchRHSPunctuation(tok::r_paren, Loc); 971 return ExprError(); 972 } 973 974 if (!LHS.isInvalid()) { 975 assert((ArgExprs.size() == 0 || ArgExprs.size()-1 == CommaLocs.size())&& 976 "Unexpected number of commas!"); 977 LHS = Actions.ActOnCallExpr(CurScope, move(LHS), Loc, 978 move_arg(ArgExprs), CommaLocs.data(), 979 Tok.getLocation()); 980 } 981 982 ConsumeParen(); 983 break; 984 } 985 case tok::arrow: 986 case tok::period: { 987 // postfix-expression: p-e '->' template[opt] id-expression 988 // postfix-expression: p-e '.' template[opt] id-expression 989 tok::TokenKind OpKind = Tok.getKind(); 990 SourceLocation OpLoc = ConsumeToken(); // Eat the "." or "->" token. 991 992 CXXScopeSpec SS; 993 Action::TypeTy *ObjectType = 0; 994 bool MayBePseudoDestructor = false; 995 if (getLang().CPlusPlus && !LHS.isInvalid()) { 996 LHS = Actions.ActOnStartCXXMemberReference(CurScope, move(LHS), 997 OpLoc, OpKind, ObjectType, 998 MayBePseudoDestructor); 999 if (LHS.isInvalid()) 1000 break; 1001 1002 ParseOptionalCXXScopeSpecifier(SS, ObjectType, false, 1003 &MayBePseudoDestructor); 1004 } 1005 1006 if (Tok.is(tok::code_completion)) { 1007 // Code completion for a member access expression. 1008 Actions.CodeCompleteMemberReferenceExpr(CurScope, LHS.get(), 1009 OpLoc, OpKind == tok::arrow); 1010 1011 ConsumeToken(); 1012 } 1013 1014 if (MayBePseudoDestructor) { 1015 LHS = ParseCXXPseudoDestructor(move(LHS), OpLoc, OpKind, SS, 1016 ObjectType); 1017 break; 1018 } 1019 1020 // Either the action has told is that this cannot be a 1021 // pseudo-destructor expression (based on the type of base 1022 // expression), or we didn't see a '~' in the right place. We 1023 // can still parse a destructor name here, but in that case it 1024 // names a real destructor. 1025 UnqualifiedId Name; 1026 if (ParseUnqualifiedId(SS, 1027 /*EnteringContext=*/false, 1028 /*AllowDestructorName=*/true, 1029 /*AllowConstructorName=*/false, 1030 ObjectType, 1031 Name)) 1032 return ExprError(); 1033 1034 if (!LHS.isInvalid()) 1035 LHS = Actions.ActOnMemberAccessExpr(CurScope, move(LHS), OpLoc, 1036 OpKind, SS, Name, ObjCImpDecl, 1037 Tok.is(tok::l_paren)); 1038 break; 1039 } 1040 case tok::plusplus: // postfix-expression: postfix-expression '++' 1041 case tok::minusminus: // postfix-expression: postfix-expression '--' 1042 if (!LHS.isInvalid()) { 1043 LHS = Actions.ActOnPostfixUnaryOp(CurScope, Tok.getLocation(), 1044 Tok.getKind(), move(LHS)); 1045 } 1046 ConsumeToken(); 1047 break; 1048 } 1049 } 1050} 1051 1052/// ParseExprAfterTypeofSizeofAlignof - We parsed a typeof/sizeof/alignof and 1053/// we are at the start of an expression or a parenthesized type-id. 1054/// OpTok is the operand token (typeof/sizeof/alignof). Returns the expression 1055/// (isCastExpr == false) or the type (isCastExpr == true). 1056/// 1057/// unary-expression: [C99 6.5.3] 1058/// 'sizeof' unary-expression 1059/// 'sizeof' '(' type-name ')' 1060/// [GNU] '__alignof' unary-expression 1061/// [GNU] '__alignof' '(' type-name ')' 1062/// [C++0x] 'alignof' '(' type-id ')' 1063/// 1064/// [GNU] typeof-specifier: 1065/// typeof ( expressions ) 1066/// typeof ( type-name ) 1067/// [GNU/C++] typeof unary-expression 1068/// 1069Parser::OwningExprResult 1070Parser::ParseExprAfterTypeofSizeofAlignof(const Token &OpTok, 1071 bool &isCastExpr, 1072 TypeTy *&CastTy, 1073 SourceRange &CastRange) { 1074 1075 assert((OpTok.is(tok::kw_typeof) || OpTok.is(tok::kw_sizeof) || 1076 OpTok.is(tok::kw___alignof) || OpTok.is(tok::kw_alignof)) && 1077 "Not a typeof/sizeof/alignof expression!"); 1078 1079 OwningExprResult Operand(Actions); 1080 1081 // If the operand doesn't start with an '(', it must be an expression. 1082 if (Tok.isNot(tok::l_paren)) { 1083 isCastExpr = false; 1084 if (OpTok.is(tok::kw_typeof) && !getLang().CPlusPlus) { 1085 Diag(Tok,diag::err_expected_lparen_after_id) << OpTok.getIdentifierInfo(); 1086 return ExprError(); 1087 } 1088 1089 // C++0x [expr.sizeof]p1: 1090 // [...] The operand is either an expression, which is an unevaluated 1091 // operand (Clause 5) [...] 1092 // 1093 // The GNU typeof and alignof extensions also behave as unevaluated 1094 // operands. 1095 EnterExpressionEvaluationContext Unevaluated(Actions, 1096 Action::Unevaluated); 1097 Operand = ParseCastExpression(true/*isUnaryExpression*/); 1098 } else { 1099 // If it starts with a '(', we know that it is either a parenthesized 1100 // type-name, or it is a unary-expression that starts with a compound 1101 // literal, or starts with a primary-expression that is a parenthesized 1102 // expression. 1103 ParenParseOption ExprType = CastExpr; 1104 SourceLocation LParenLoc = Tok.getLocation(), RParenLoc; 1105 1106 // C++0x [expr.sizeof]p1: 1107 // [...] The operand is either an expression, which is an unevaluated 1108 // operand (Clause 5) [...] 1109 // 1110 // The GNU typeof and alignof extensions also behave as unevaluated 1111 // operands. 1112 EnterExpressionEvaluationContext Unevaluated(Actions, 1113 Action::Unevaluated); 1114 Operand = ParseParenExpression(ExprType, true/*stopIfCastExpr*/, 1115 0/*TypeOfCast*/, 1116 CastTy, RParenLoc); 1117 CastRange = SourceRange(LParenLoc, RParenLoc); 1118 1119 // If ParseParenExpression parsed a '(typename)' sequence only, then this is 1120 // a type. 1121 if (ExprType == CastExpr) { 1122 isCastExpr = true; 1123 return ExprEmpty(); 1124 } 1125 1126 // If this is a parenthesized expression, it is the start of a 1127 // unary-expression, but doesn't include any postfix pieces. Parse these 1128 // now if present. 1129 Operand = ParsePostfixExpressionSuffix(move(Operand)); 1130 } 1131 1132 // If we get here, the operand to the typeof/sizeof/alignof was an expresion. 1133 isCastExpr = false; 1134 return move(Operand); 1135} 1136 1137 1138/// ParseSizeofAlignofExpression - Parse a sizeof or alignof expression. 1139/// unary-expression: [C99 6.5.3] 1140/// 'sizeof' unary-expression 1141/// 'sizeof' '(' type-name ')' 1142/// [GNU] '__alignof' unary-expression 1143/// [GNU] '__alignof' '(' type-name ')' 1144/// [C++0x] 'alignof' '(' type-id ')' 1145Parser::OwningExprResult Parser::ParseSizeofAlignofExpression() { 1146 assert((Tok.is(tok::kw_sizeof) || Tok.is(tok::kw___alignof) 1147 || Tok.is(tok::kw_alignof)) && 1148 "Not a sizeof/alignof expression!"); 1149 Token OpTok = Tok; 1150 ConsumeToken(); 1151 1152 bool isCastExpr; 1153 TypeTy *CastTy; 1154 SourceRange CastRange; 1155 OwningExprResult Operand = ParseExprAfterTypeofSizeofAlignof(OpTok, 1156 isCastExpr, 1157 CastTy, 1158 CastRange); 1159 1160 if (isCastExpr) 1161 return Actions.ActOnSizeOfAlignOfExpr(OpTok.getLocation(), 1162 OpTok.is(tok::kw_sizeof), 1163 /*isType=*/true, CastTy, 1164 CastRange); 1165 1166 // If we get here, the operand to the sizeof/alignof was an expresion. 1167 if (!Operand.isInvalid()) 1168 Operand = Actions.ActOnSizeOfAlignOfExpr(OpTok.getLocation(), 1169 OpTok.is(tok::kw_sizeof), 1170 /*isType=*/false, 1171 Operand.release(), CastRange); 1172 return move(Operand); 1173} 1174 1175/// ParseBuiltinPrimaryExpression 1176/// 1177/// primary-expression: [C99 6.5.1] 1178/// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')' 1179/// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')' 1180/// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ',' 1181/// assign-expr ')' 1182/// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')' 1183/// 1184/// [GNU] offsetof-member-designator: 1185/// [GNU] identifier 1186/// [GNU] offsetof-member-designator '.' identifier 1187/// [GNU] offsetof-member-designator '[' expression ']' 1188/// 1189Parser::OwningExprResult Parser::ParseBuiltinPrimaryExpression() { 1190 OwningExprResult Res(Actions); 1191 const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo(); 1192 1193 tok::TokenKind T = Tok.getKind(); 1194 SourceLocation StartLoc = ConsumeToken(); // Eat the builtin identifier. 1195 1196 // All of these start with an open paren. 1197 if (Tok.isNot(tok::l_paren)) 1198 return ExprError(Diag(Tok, diag::err_expected_lparen_after_id) 1199 << BuiltinII); 1200 1201 SourceLocation LParenLoc = ConsumeParen(); 1202 // TODO: Build AST. 1203 1204 switch (T) { 1205 default: assert(0 && "Not a builtin primary expression!"); 1206 case tok::kw___builtin_va_arg: { 1207 OwningExprResult Expr(ParseAssignmentExpression()); 1208 if (Expr.isInvalid()) { 1209 SkipUntil(tok::r_paren); 1210 return ExprError(); 1211 } 1212 1213 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1214 return ExprError(); 1215 1216 TypeResult Ty = ParseTypeName(); 1217 1218 if (Tok.isNot(tok::r_paren)) { 1219 Diag(Tok, diag::err_expected_rparen); 1220 return ExprError(); 1221 } 1222 if (Ty.isInvalid()) 1223 Res = ExprError(); 1224 else 1225 Res = Actions.ActOnVAArg(StartLoc, move(Expr), Ty.get(), ConsumeParen()); 1226 break; 1227 } 1228 case tok::kw___builtin_offsetof: { 1229 SourceLocation TypeLoc = Tok.getLocation(); 1230 TypeResult Ty = ParseTypeName(); 1231 if (Ty.isInvalid()) { 1232 SkipUntil(tok::r_paren); 1233 return ExprError(); 1234 } 1235 1236 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1237 return ExprError(); 1238 1239 // We must have at least one identifier here. 1240 if (Tok.isNot(tok::identifier)) { 1241 Diag(Tok, diag::err_expected_ident); 1242 SkipUntil(tok::r_paren); 1243 return ExprError(); 1244 } 1245 1246 // Keep track of the various subcomponents we see. 1247 llvm::SmallVector<Action::OffsetOfComponent, 4> Comps; 1248 1249 Comps.push_back(Action::OffsetOfComponent()); 1250 Comps.back().isBrackets = false; 1251 Comps.back().U.IdentInfo = Tok.getIdentifierInfo(); 1252 Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken(); 1253 1254 // FIXME: This loop leaks the index expressions on error. 1255 while (1) { 1256 if (Tok.is(tok::period)) { 1257 // offsetof-member-designator: offsetof-member-designator '.' identifier 1258 Comps.push_back(Action::OffsetOfComponent()); 1259 Comps.back().isBrackets = false; 1260 Comps.back().LocStart = ConsumeToken(); 1261 1262 if (Tok.isNot(tok::identifier)) { 1263 Diag(Tok, diag::err_expected_ident); 1264 SkipUntil(tok::r_paren); 1265 return ExprError(); 1266 } 1267 Comps.back().U.IdentInfo = Tok.getIdentifierInfo(); 1268 Comps.back().LocEnd = ConsumeToken(); 1269 1270 } else if (Tok.is(tok::l_square)) { 1271 // offsetof-member-designator: offsetof-member-design '[' expression ']' 1272 Comps.push_back(Action::OffsetOfComponent()); 1273 Comps.back().isBrackets = true; 1274 Comps.back().LocStart = ConsumeBracket(); 1275 Res = ParseExpression(); 1276 if (Res.isInvalid()) { 1277 SkipUntil(tok::r_paren); 1278 return move(Res); 1279 } 1280 Comps.back().U.E = Res.release(); 1281 1282 Comps.back().LocEnd = 1283 MatchRHSPunctuation(tok::r_square, Comps.back().LocStart); 1284 } else { 1285 if (Tok.isNot(tok::r_paren)) { 1286 MatchRHSPunctuation(tok::r_paren, LParenLoc); 1287 Res = ExprError(); 1288 } else if (Ty.isInvalid()) { 1289 Res = ExprError(); 1290 } else { 1291 Res = Actions.ActOnBuiltinOffsetOf(CurScope, StartLoc, TypeLoc, 1292 Ty.get(), &Comps[0], 1293 Comps.size(), ConsumeParen()); 1294 } 1295 break; 1296 } 1297 } 1298 break; 1299 } 1300 case tok::kw___builtin_choose_expr: { 1301 OwningExprResult Cond(ParseAssignmentExpression()); 1302 if (Cond.isInvalid()) { 1303 SkipUntil(tok::r_paren); 1304 return move(Cond); 1305 } 1306 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1307 return ExprError(); 1308 1309 OwningExprResult Expr1(ParseAssignmentExpression()); 1310 if (Expr1.isInvalid()) { 1311 SkipUntil(tok::r_paren); 1312 return move(Expr1); 1313 } 1314 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1315 return ExprError(); 1316 1317 OwningExprResult Expr2(ParseAssignmentExpression()); 1318 if (Expr2.isInvalid()) { 1319 SkipUntil(tok::r_paren); 1320 return move(Expr2); 1321 } 1322 if (Tok.isNot(tok::r_paren)) { 1323 Diag(Tok, diag::err_expected_rparen); 1324 return ExprError(); 1325 } 1326 Res = Actions.ActOnChooseExpr(StartLoc, move(Cond), move(Expr1), 1327 move(Expr2), ConsumeParen()); 1328 break; 1329 } 1330 case tok::kw___builtin_types_compatible_p: 1331 TypeResult Ty1 = ParseTypeName(); 1332 1333 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1334 return ExprError(); 1335 1336 TypeResult Ty2 = ParseTypeName(); 1337 1338 if (Tok.isNot(tok::r_paren)) { 1339 Diag(Tok, diag::err_expected_rparen); 1340 return ExprError(); 1341 } 1342 1343 if (Ty1.isInvalid() || Ty2.isInvalid()) 1344 Res = ExprError(); 1345 else 1346 Res = Actions.ActOnTypesCompatibleExpr(StartLoc, Ty1.get(), Ty2.get(), 1347 ConsumeParen()); 1348 break; 1349 } 1350 1351 // These can be followed by postfix-expr pieces because they are 1352 // primary-expressions. 1353 return ParsePostfixExpressionSuffix(move(Res)); 1354} 1355 1356/// ParseParenExpression - This parses the unit that starts with a '(' token, 1357/// based on what is allowed by ExprType. The actual thing parsed is returned 1358/// in ExprType. If stopIfCastExpr is true, it will only return the parsed type, 1359/// not the parsed cast-expression. 1360/// 1361/// primary-expression: [C99 6.5.1] 1362/// '(' expression ')' 1363/// [GNU] '(' compound-statement ')' (if !ParenExprOnly) 1364/// postfix-expression: [C99 6.5.2] 1365/// '(' type-name ')' '{' initializer-list '}' 1366/// '(' type-name ')' '{' initializer-list ',' '}' 1367/// cast-expression: [C99 6.5.4] 1368/// '(' type-name ')' cast-expression 1369/// 1370Parser::OwningExprResult 1371Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr, 1372 TypeTy *TypeOfCast, TypeTy *&CastTy, 1373 SourceLocation &RParenLoc) { 1374 assert(Tok.is(tok::l_paren) && "Not a paren expr!"); 1375 GreaterThanIsOperatorScope G(GreaterThanIsOperator, true); 1376 SourceLocation OpenLoc = ConsumeParen(); 1377 OwningExprResult Result(Actions, true); 1378 bool isAmbiguousTypeId; 1379 CastTy = 0; 1380 1381 if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) { 1382 Diag(Tok, diag::ext_gnu_statement_expr); 1383 OwningStmtResult Stmt(ParseCompoundStatement(0, true)); 1384 ExprType = CompoundStmt; 1385 1386 // If the substmt parsed correctly, build the AST node. 1387 if (!Stmt.isInvalid() && Tok.is(tok::r_paren)) 1388 Result = Actions.ActOnStmtExpr(OpenLoc, move(Stmt), Tok.getLocation()); 1389 1390 } else if (ExprType >= CompoundLiteral && 1391 isTypeIdInParens(isAmbiguousTypeId)) { 1392 1393 // Otherwise, this is a compound literal expression or cast expression. 1394 1395 // In C++, if the type-id is ambiguous we disambiguate based on context. 1396 // If stopIfCastExpr is true the context is a typeof/sizeof/alignof 1397 // in which case we should treat it as type-id. 1398 // if stopIfCastExpr is false, we need to determine the context past the 1399 // parens, so we defer to ParseCXXAmbiguousParenExpression for that. 1400 if (isAmbiguousTypeId && !stopIfCastExpr) 1401 return ParseCXXAmbiguousParenExpression(ExprType, CastTy, 1402 OpenLoc, RParenLoc); 1403 1404 TypeResult Ty = ParseTypeName(); 1405 1406 // Match the ')'. 1407 if (Tok.is(tok::r_paren)) 1408 RParenLoc = ConsumeParen(); 1409 else 1410 MatchRHSPunctuation(tok::r_paren, OpenLoc); 1411 1412 if (Tok.is(tok::l_brace)) { 1413 ExprType = CompoundLiteral; 1414 return ParseCompoundLiteralExpression(Ty.get(), OpenLoc, RParenLoc); 1415 } 1416 1417 if (ExprType == CastExpr) { 1418 // We parsed '(' type-name ')' and the thing after it wasn't a '{'. 1419 1420 if (Ty.isInvalid()) 1421 return ExprError(); 1422 1423 CastTy = Ty.get(); 1424 1425 // Note that this doesn't parse the subsequent cast-expression, it just 1426 // returns the parsed type to the callee. 1427 if (stopIfCastExpr) 1428 return OwningExprResult(Actions); 1429 1430 // Reject the cast of super idiom in ObjC. 1431 if (Tok.is(tok::identifier) && getLang().ObjC1 && 1432 Tok.getIdentifierInfo() == Ident_super && 1433 CurScope->isInObjcMethodScope() && 1434 GetLookAheadToken(1).isNot(tok::period)) { 1435 Diag(Tok.getLocation(), diag::err_illegal_super_cast) 1436 << SourceRange(OpenLoc, RParenLoc); 1437 return ExprError(); 1438 } 1439 1440 // Parse the cast-expression that follows it next. 1441 // TODO: For cast expression with CastTy. 1442 Result = ParseCastExpression(false, false, CastTy); 1443 if (!Result.isInvalid()) 1444 Result = Actions.ActOnCastExpr(CurScope, OpenLoc, CastTy, RParenLoc, 1445 move(Result)); 1446 return move(Result); 1447 } 1448 1449 Diag(Tok, diag::err_expected_lbrace_in_compound_literal); 1450 return ExprError(); 1451 } else if (TypeOfCast) { 1452 // Parse the expression-list. 1453 ExprVector ArgExprs(Actions); 1454 CommaLocsTy CommaLocs; 1455 1456 if (!ParseExpressionList(ArgExprs, CommaLocs)) { 1457 ExprType = SimpleExpr; 1458 Result = Actions.ActOnParenOrParenListExpr(OpenLoc, Tok.getLocation(), 1459 move_arg(ArgExprs), TypeOfCast); 1460 } 1461 } else { 1462 Result = ParseExpression(); 1463 ExprType = SimpleExpr; 1464 if (!Result.isInvalid() && Tok.is(tok::r_paren)) 1465 Result = Actions.ActOnParenExpr(OpenLoc, Tok.getLocation(), move(Result)); 1466 } 1467 1468 // Match the ')'. 1469 if (Result.isInvalid()) { 1470 SkipUntil(tok::r_paren); 1471 return ExprError(); 1472 } 1473 1474 if (Tok.is(tok::r_paren)) 1475 RParenLoc = ConsumeParen(); 1476 else 1477 MatchRHSPunctuation(tok::r_paren, OpenLoc); 1478 1479 return move(Result); 1480} 1481 1482/// ParseCompoundLiteralExpression - We have parsed the parenthesized type-name 1483/// and we are at the left brace. 1484/// 1485/// postfix-expression: [C99 6.5.2] 1486/// '(' type-name ')' '{' initializer-list '}' 1487/// '(' type-name ')' '{' initializer-list ',' '}' 1488/// 1489Parser::OwningExprResult 1490Parser::ParseCompoundLiteralExpression(TypeTy *Ty, 1491 SourceLocation LParenLoc, 1492 SourceLocation RParenLoc) { 1493 assert(Tok.is(tok::l_brace) && "Not a compound literal!"); 1494 if (!getLang().C99) // Compound literals don't exist in C90. 1495 Diag(LParenLoc, diag::ext_c99_compound_literal); 1496 OwningExprResult Result = ParseInitializer(); 1497 if (!Result.isInvalid() && Ty) 1498 return Actions.ActOnCompoundLiteral(LParenLoc, Ty, RParenLoc, move(Result)); 1499 return move(Result); 1500} 1501 1502/// ParseStringLiteralExpression - This handles the various token types that 1503/// form string literals, and also handles string concatenation [C99 5.1.1.2, 1504/// translation phase #6]. 1505/// 1506/// primary-expression: [C99 6.5.1] 1507/// string-literal 1508Parser::OwningExprResult Parser::ParseStringLiteralExpression() { 1509 assert(isTokenStringLiteral() && "Not a string literal!"); 1510 1511 // String concat. Note that keywords like __func__ and __FUNCTION__ are not 1512 // considered to be strings for concatenation purposes. 1513 llvm::SmallVector<Token, 4> StringToks; 1514 1515 do { 1516 StringToks.push_back(Tok); 1517 ConsumeStringToken(); 1518 } while (isTokenStringLiteral()); 1519 1520 // Pass the set of string tokens, ready for concatenation, to the actions. 1521 return Actions.ActOnStringLiteral(&StringToks[0], StringToks.size()); 1522} 1523 1524/// ParseExpressionList - Used for C/C++ (argument-)expression-list. 1525/// 1526/// argument-expression-list: 1527/// assignment-expression 1528/// argument-expression-list , assignment-expression 1529/// 1530/// [C++] expression-list: 1531/// [C++] assignment-expression 1532/// [C++] expression-list , assignment-expression 1533/// 1534bool Parser::ParseExpressionList(ExprListTy &Exprs, CommaLocsTy &CommaLocs, 1535 void (Action::*Completer)(Scope *S, 1536 void *Data, 1537 ExprTy **Args, 1538 unsigned NumArgs), 1539 void *Data) { 1540 while (1) { 1541 if (Tok.is(tok::code_completion)) { 1542 if (Completer) 1543 (Actions.*Completer)(CurScope, Data, Exprs.data(), Exprs.size()); 1544 ConsumeToken(); 1545 } 1546 1547 OwningExprResult Expr(ParseAssignmentExpression()); 1548 if (Expr.isInvalid()) 1549 return true; 1550 1551 Exprs.push_back(Expr.release()); 1552 1553 if (Tok.isNot(tok::comma)) 1554 return false; 1555 // Move to the next argument, remember where the comma was. 1556 CommaLocs.push_back(ConsumeToken()); 1557 } 1558} 1559 1560/// ParseBlockId - Parse a block-id, which roughly looks like int (int x). 1561/// 1562/// [clang] block-id: 1563/// [clang] specifier-qualifier-list block-declarator 1564/// 1565void Parser::ParseBlockId() { 1566 // Parse the specifier-qualifier-list piece. 1567 DeclSpec DS; 1568 ParseSpecifierQualifierList(DS); 1569 1570 // Parse the block-declarator. 1571 Declarator DeclaratorInfo(DS, Declarator::BlockLiteralContext); 1572 ParseDeclarator(DeclaratorInfo); 1573 1574 // We do this for: ^ __attribute__((noreturn)) {, as DS has the attributes. 1575 DeclaratorInfo.AddAttributes(DS.TakeAttributes(), 1576 SourceLocation()); 1577 1578 if (Tok.is(tok::kw___attribute)) { 1579 SourceLocation Loc; 1580 AttributeList *AttrList = ParseGNUAttributes(&Loc); 1581 DeclaratorInfo.AddAttributes(AttrList, Loc); 1582 } 1583 1584 // Inform sema that we are starting a block. 1585 Actions.ActOnBlockArguments(DeclaratorInfo, CurScope); 1586} 1587 1588/// ParseBlockLiteralExpression - Parse a block literal, which roughly looks 1589/// like ^(int x){ return x+1; } 1590/// 1591/// block-literal: 1592/// [clang] '^' block-args[opt] compound-statement 1593/// [clang] '^' block-id compound-statement 1594/// [clang] block-args: 1595/// [clang] '(' parameter-list ')' 1596/// 1597Parser::OwningExprResult Parser::ParseBlockLiteralExpression() { 1598 assert(Tok.is(tok::caret) && "block literal starts with ^"); 1599 SourceLocation CaretLoc = ConsumeToken(); 1600 1601 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), CaretLoc, 1602 "block literal parsing"); 1603 1604 // Enter a scope to hold everything within the block. This includes the 1605 // argument decls, decls within the compound expression, etc. This also 1606 // allows determining whether a variable reference inside the block is 1607 // within or outside of the block. 1608 ParseScope BlockScope(this, Scope::BlockScope | Scope::FnScope | 1609 Scope::BreakScope | Scope::ContinueScope | 1610 Scope::DeclScope); 1611 1612 // Inform sema that we are starting a block. 1613 Actions.ActOnBlockStart(CaretLoc, CurScope); 1614 1615 // Parse the return type if present. 1616 DeclSpec DS; 1617 Declarator ParamInfo(DS, Declarator::BlockLiteralContext); 1618 // FIXME: Since the return type isn't actually parsed, it can't be used to 1619 // fill ParamInfo with an initial valid range, so do it manually. 1620 ParamInfo.SetSourceRange(SourceRange(Tok.getLocation(), Tok.getLocation())); 1621 1622 // If this block has arguments, parse them. There is no ambiguity here with 1623 // the expression case, because the expression case requires a parameter list. 1624 if (Tok.is(tok::l_paren)) { 1625 ParseParenDeclarator(ParamInfo); 1626 // Parse the pieces after the identifier as if we had "int(...)". 1627 // SetIdentifier sets the source range end, but in this case we're past 1628 // that location. 1629 SourceLocation Tmp = ParamInfo.getSourceRange().getEnd(); 1630 ParamInfo.SetIdentifier(0, CaretLoc); 1631 ParamInfo.SetRangeEnd(Tmp); 1632 if (ParamInfo.isInvalidType()) { 1633 // If there was an error parsing the arguments, they may have 1634 // tried to use ^(x+y) which requires an argument list. Just 1635 // skip the whole block literal. 1636 Actions.ActOnBlockError(CaretLoc, CurScope); 1637 return ExprError(); 1638 } 1639 1640 if (Tok.is(tok::kw___attribute)) { 1641 SourceLocation Loc; 1642 AttributeList *AttrList = ParseGNUAttributes(&Loc); 1643 ParamInfo.AddAttributes(AttrList, Loc); 1644 } 1645 1646 // Inform sema that we are starting a block. 1647 Actions.ActOnBlockArguments(ParamInfo, CurScope); 1648 } else if (!Tok.is(tok::l_brace)) { 1649 ParseBlockId(); 1650 } else { 1651 // Otherwise, pretend we saw (void). 1652 ParamInfo.AddTypeInfo(DeclaratorChunk::getFunction(true, false, 1653 SourceLocation(), 1654 0, 0, 0, 1655 false, SourceLocation(), 1656 false, 0, 0, 0, 1657 CaretLoc, CaretLoc, 1658 ParamInfo), 1659 CaretLoc); 1660 1661 if (Tok.is(tok::kw___attribute)) { 1662 SourceLocation Loc; 1663 AttributeList *AttrList = ParseGNUAttributes(&Loc); 1664 ParamInfo.AddAttributes(AttrList, Loc); 1665 } 1666 1667 // Inform sema that we are starting a block. 1668 Actions.ActOnBlockArguments(ParamInfo, CurScope); 1669 } 1670 1671 1672 OwningExprResult Result(Actions, true); 1673 if (!Tok.is(tok::l_brace)) { 1674 // Saw something like: ^expr 1675 Diag(Tok, diag::err_expected_expression); 1676 Actions.ActOnBlockError(CaretLoc, CurScope); 1677 return ExprError(); 1678 } 1679 1680 OwningStmtResult Stmt(ParseCompoundStatementBody()); 1681 if (!Stmt.isInvalid()) 1682 Result = Actions.ActOnBlockStmtExpr(CaretLoc, move(Stmt), CurScope); 1683 else 1684 Actions.ActOnBlockError(CaretLoc, CurScope); 1685 return move(Result); 1686} 1687