1 //===--- ParseExpr.cpp - Expression Parsing -------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
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.
20 //===----------------------------------------------------------------------===//
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"
30 using namespace clang;
32 /// getBinOpPrecedence - Return the precedence of the specified binary operator
34 static prec::Level getBinOpPrecedence(tok::TokenKind Kind,
35 bool GreaterThanIsOperator,
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;
47 case tok::greatergreater:
48 // C++0x [temp.names]p3:
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)
58 default: return prec::Unknown;
59 case tok::comma: return prec::Comma;
63 case tok::percentequal:
66 case tok::lesslessequal:
67 case tok::greatergreaterequal:
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;
81 case tok::greaterequal: return prec::Relational;
82 case tok::lessless: return prec::Shift;
84 case tok::minus: return prec::Additive;
87 case tok::star: return prec::Multiplicative;
89 case tok::arrowstar: return prec::PointerToMember;
94 /// ParseExpression - Simple precedence-based parser for binary/ternary
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.
106 /// pm-expression: [C++ 5.5]
108 /// pm-expression '.*' cast-expression
109 /// pm-expression '->*' cast-expression
111 /// multiplicative-expression: [C99 6.5.5]
112 /// Note: in C++, apply pm-expression instead of cast-expression
114 /// multiplicative-expression '*' cast-expression
115 /// multiplicative-expression '/' cast-expression
116 /// multiplicative-expression '%' cast-expression
118 /// additive-expression: [C99 6.5.6]
119 /// multiplicative-expression
120 /// additive-expression '+' multiplicative-expression
121 /// additive-expression '-' multiplicative-expression
123 /// shift-expression: [C99 6.5.7]
124 /// additive-expression
125 /// shift-expression '<<' additive-expression
126 /// shift-expression '>>' additive-expression
128 /// relational-expression: [C99 6.5.8]
130 /// relational-expression '<' shift-expression
131 /// relational-expression '>' shift-expression
132 /// relational-expression '<=' shift-expression
133 /// relational-expression '>=' shift-expression
135 /// equality-expression: [C99 6.5.9]
136 /// relational-expression
137 /// equality-expression '==' relational-expression
138 /// equality-expression '!=' relational-expression
140 /// AND-expression: [C99 6.5.10]
141 /// equality-expression
142 /// AND-expression '&' equality-expression
144 /// exclusive-OR-expression: [C99 6.5.11]
146 /// exclusive-OR-expression '^' AND-expression
148 /// inclusive-OR-expression: [C99 6.5.12]
149 /// exclusive-OR-expression
150 /// inclusive-OR-expression '|' exclusive-OR-expression
152 /// logical-AND-expression: [C99 6.5.13]
153 /// inclusive-OR-expression
154 /// logical-AND-expression '&&' inclusive-OR-expression
156 /// logical-OR-expression: [C99 6.5.14]
157 /// logical-AND-expression
158 /// logical-OR-expression '||' logical-AND-expression
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
166 /// assignment-expression: [C99 6.5.16]
167 /// conditional-expression
168 /// unary-expression assignment-operator assignment-expression
169 /// [C++] throw-expression [C++ 15]
171 /// assignment-operator: one of
172 /// = *= /= %= += -= <<= >>= &= ^= |=
174 /// expression: [C99 6.5.17]
175 /// assignment-expression ...[opt]
176 /// expression ',' assignment-expression ...[opt]
177 ExprResult Parser::ParseExpression() {
178 ExprResult LHS(ParseAssignmentExpression());
179 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma);
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.
188 Parser::ParseExpressionWithLeadingAt(SourceLocation AtLoc) {
189 ExprResult LHS(ParseObjCAtExpression(AtLoc));
190 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma);
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.
197 Parser::ParseExpressionWithLeadingExtension(SourceLocation ExtLoc) {
198 ExprResult LHS(true);
200 // Silence extension warnings in the sub-expression
201 ExtensionRAIIObject O(Diags);
203 LHS = ParseCastExpression(false);
206 if (!LHS.isInvalid())
207 LHS = Actions.ActOnUnaryOp(getCurScope(), ExtLoc, tok::kw___extension__,
210 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma);
213 /// ParseAssignmentExpression - Parse an expr that doesn't include commas.
214 ExprResult Parser::ParseAssignmentExpression() {
215 if (Tok.is(tok::code_completion)) {
216 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
221 if (Tok.is(tok::kw_throw))
222 return ParseThrowExpression();
224 ExprResult LHS = ParseCastExpression(/*isUnaryExpression=*/false);
225 return ParseRHSOfBinaryExpression(move(LHS), prec::Assignment);
228 /// ParseAssignmentExprWithObjCMessageExprStart - Parse an assignment expression
229 /// where part of an objc message send has already been parsed. In this case
230 /// LBracLoc indicates the location of the '[' of the message send, and either
231 /// ReceiverName or ReceiverExpr is non-null indicating the receiver of the
234 /// Since this handles full assignment-expression's, it handles postfix
235 /// expressions and other binary operators for these expressions as well.
237 Parser::ParseAssignmentExprWithObjCMessageExprStart(SourceLocation LBracLoc,
238 SourceLocation SuperLoc,
239 ParsedType ReceiverType,
240 Expr *ReceiverExpr) {
242 = ParseObjCMessageExpressionBody(LBracLoc, SuperLoc,
243 ReceiverType, ReceiverExpr);
244 R = ParsePostfixExpressionSuffix(R);
245 return ParseRHSOfBinaryExpression(R, prec::Assignment);
249 ExprResult Parser::ParseConstantExpression() {
250 // C++ [basic.def.odr]p2:
251 // An expression is potentially evaluated unless it appears where an
252 // integral constant expression is required (see 5.19) [...].
253 EnterExpressionEvaluationContext Unevaluated(Actions,
256 ExprResult LHS(ParseCastExpression(false));
257 return ParseRHSOfBinaryExpression(LHS, prec::Conditional);
260 /// ParseRHSOfBinaryExpression - Parse a binary expression that starts with
261 /// LHS and has a precedence of at least MinPrec.
263 Parser::ParseRHSOfBinaryExpression(ExprResult LHS, prec::Level MinPrec) {
264 prec::Level NextTokPrec = getBinOpPrecedence(Tok.getKind(),
265 GreaterThanIsOperator,
266 getLang().CPlusPlus0x);
267 SourceLocation ColonLoc;
270 // If this token has a lower precedence than we are allowed to parse (e.g.
271 // because we are called recursively, or because the token is not a binop),
273 if (NextTokPrec < MinPrec)
276 // Consume the operator, saving the operator token for error reporting.
280 // Special case handling for the ternary operator.
281 ExprResult TernaryMiddle(true);
282 if (NextTokPrec == prec::Conditional) {
283 if (Tok.isNot(tok::colon)) {
284 // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
285 ColonProtectionRAIIObject X(*this);
287 // Handle this production specially:
288 // logical-OR-expression '?' expression ':' conditional-expression
289 // In particular, the RHS of the '?' is 'expression', not
290 // 'logical-OR-expression' as we might expect.
291 TernaryMiddle = ParseExpression();
292 if (TernaryMiddle.isInvalid()) {
297 // Special case handling of "X ? Y : Z" where Y is empty:
298 // logical-OR-expression '?' ':' conditional-expression [GNU]
300 Diag(Tok, diag::ext_gnu_conditional_expr);
303 if (Tok.is(tok::colon)) {
305 ColonLoc = ConsumeToken();
307 // Otherwise, we're missing a ':'. Assume that this was a typo that
308 // the user forgot. If we're not in a macro expansion, we can suggest
309 // a fixit hint. If there were two spaces before the current token,
310 // suggest inserting the colon in between them, otherwise insert ": ".
311 SourceLocation FILoc = Tok.getLocation();
312 const char *FIText = ": ";
313 const SourceManager &SM = PP.getSourceManager();
314 if (FILoc.isFileID() || PP.isAtStartOfMacroExpansion(FILoc)) {
315 FILoc = SM.getExpansionLoc(FILoc);
316 bool IsInvalid = false;
317 const char *SourcePtr =
318 SM.getCharacterData(FILoc.getLocWithOffset(-1), &IsInvalid);
319 if (!IsInvalid && *SourcePtr == ' ') {
321 SM.getCharacterData(FILoc.getLocWithOffset(-2), &IsInvalid);
322 if (!IsInvalid && *SourcePtr == ' ') {
323 FILoc = FILoc.getLocWithOffset(-1);
329 Diag(Tok, diag::err_expected_colon)
330 << FixItHint::CreateInsertion(FILoc, FIText);
331 Diag(OpToken, diag::note_matching) << "?";
332 ColonLoc = Tok.getLocation();
336 // Code completion for the right-hand side of an assignment expression
337 // goes through a special hook that takes the left-hand side into account.
338 if (Tok.is(tok::code_completion) && NextTokPrec == prec::Assignment) {
339 Actions.CodeCompleteAssignmentRHS(getCurScope(), LHS.get());
344 // Parse another leaf here for the RHS of the operator.
345 // ParseCastExpression works here because all RHS expressions in C have it
346 // as a prefix, at least. However, in C++, an assignment-expression could
347 // be a throw-expression, which is not a valid cast-expression.
348 // Therefore we need some special-casing here.
349 // Also note that the third operand of the conditional operator is
350 // an assignment-expression in C++.
352 if (getLang().CPlusPlus && NextTokPrec <= prec::Conditional)
353 RHS = ParseAssignmentExpression();
355 RHS = ParseCastExpression(false);
360 // Remember the precedence of this operator and get the precedence of the
361 // operator immediately to the right of the RHS.
362 prec::Level ThisPrec = NextTokPrec;
363 NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator,
364 getLang().CPlusPlus0x);
366 // Assignment and conditional expressions are right-associative.
367 bool isRightAssoc = ThisPrec == prec::Conditional ||
368 ThisPrec == prec::Assignment;
370 // Get the precedence of the operator to the right of the RHS. If it binds
371 // more tightly with RHS than we do, evaluate it completely first.
372 if (ThisPrec < NextTokPrec ||
373 (ThisPrec == NextTokPrec && isRightAssoc)) {
374 // If this is left-associative, only parse things on the RHS that bind
375 // more tightly than the current operator. If it is left-associative, it
376 // is okay, to bind exactly as tightly. For example, compile A=B=C=D as
377 // A=(B=(C=D)), where each paren is a level of recursion here.
378 // The function takes ownership of the RHS.
379 RHS = ParseRHSOfBinaryExpression(RHS,
380 static_cast<prec::Level>(ThisPrec + !isRightAssoc));
385 NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator,
386 getLang().CPlusPlus0x);
388 assert(NextTokPrec <= ThisPrec && "Recursion didn't work!");
390 if (!LHS.isInvalid()) {
391 // Combine the LHS and RHS into the LHS (e.g. build AST).
392 if (TernaryMiddle.isInvalid()) {
393 // If we're using '>>' as an operator within a template
394 // argument list (in C++98), suggest the addition of
395 // parentheses so that the code remains well-formed in C++0x.
396 if (!GreaterThanIsOperator && OpToken.is(tok::greatergreater))
397 SuggestParentheses(OpToken.getLocation(),
398 diag::warn_cxx0x_right_shift_in_template_arg,
399 SourceRange(Actions.getExprRange(LHS.get()).getBegin(),
400 Actions.getExprRange(RHS.get()).getEnd()));
402 LHS = Actions.ActOnBinOp(getCurScope(), OpToken.getLocation(),
403 OpToken.getKind(), LHS.take(), RHS.take());
405 LHS = Actions.ActOnConditionalOp(OpToken.getLocation(), ColonLoc,
406 LHS.take(), TernaryMiddle.take(),
412 /// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is
413 /// true, parse a unary-expression. isAddressOfOperand exists because an
414 /// id-expression that is the operand of address-of gets special treatment
415 /// due to member pointers.
417 ExprResult Parser::ParseCastExpression(bool isUnaryExpression,
418 bool isAddressOfOperand,
421 ExprResult Res = ParseCastExpression(isUnaryExpression,
426 Diag(Tok, diag::err_expected_expression);
430 /// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is
431 /// true, parse a unary-expression. isAddressOfOperand exists because an
432 /// id-expression that is the operand of address-of gets special treatment
433 /// due to member pointers. NotCastExpr is set to true if the token is not the
434 /// start of a cast-expression, and no diagnostic is emitted in this case.
436 /// cast-expression: [C99 6.5.4]
438 /// '(' type-name ')' cast-expression
440 /// unary-expression: [C99 6.5.3]
441 /// postfix-expression
442 /// '++' unary-expression
443 /// '--' unary-expression
444 /// unary-operator cast-expression
445 /// 'sizeof' unary-expression
446 /// 'sizeof' '(' type-name ')'
447 /// [C++0x] 'sizeof' '...' '(' identifier ')'
448 /// [GNU] '__alignof' unary-expression
449 /// [GNU] '__alignof' '(' type-name ')'
450 /// [C++0x] 'alignof' '(' type-id ')'
451 /// [GNU] '&&' identifier
452 /// [C++] new-expression
453 /// [C++] delete-expression
454 /// [C++0x] 'noexcept' '(' expression ')'
456 /// unary-operator: one of
457 /// '&' '*' '+' '-' '~' '!'
458 /// [GNU] '__extension__' '__real' '__imag'
460 /// primary-expression: [C99 6.5.1]
462 /// [C++] id-expression
465 /// [C++] boolean-literal [C++ 2.13.5]
466 /// [C++0x] 'nullptr' [C++0x 2.14.7]
467 /// '(' expression ')'
468 /// [C1X] generic-selection
469 /// '__func__' [C99 6.4.2.2]
470 /// [GNU] '__FUNCTION__'
471 /// [GNU] '__PRETTY_FUNCTION__'
472 /// [GNU] '(' compound-statement ')'
473 /// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
474 /// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
475 /// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
477 /// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
479 /// [OBJC] '[' objc-message-expr ']'
480 /// [OBJC] '@selector' '(' objc-selector-arg ')'
481 /// [OBJC] '@protocol' '(' identifier ')'
482 /// [OBJC] '@encode' '(' type-name ')'
483 /// [OBJC] objc-string-literal
484 /// [C++] simple-type-specifier '(' expression-list[opt] ')' [C++ 5.2.3]
485 /// [C++0x] simple-type-specifier braced-init-list [C++ 5.2.3]
486 /// [C++] typename-specifier '(' expression-list[opt] ')' [C++ 5.2.3]
487 /// [C++0x] typename-specifier braced-init-list [C++ 5.2.3]
488 /// [C++] 'const_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
489 /// [C++] 'dynamic_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
490 /// [C++] 'reinterpret_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
491 /// [C++] 'static_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
492 /// [C++] 'typeid' '(' expression ')' [C++ 5.2p1]
493 /// [C++] 'typeid' '(' type-id ')' [C++ 5.2p1]
494 /// [C++] 'this' [C++ 9.3.2]
495 /// [G++] unary-type-trait '(' type-id ')'
496 /// [G++] binary-type-trait '(' type-id ',' type-id ')' [TODO]
497 /// [EMBT] array-type-trait '(' type-id ',' integer ')'
498 /// [clang] '^' block-literal
500 /// constant: [C99 6.4.4]
502 /// floating-constant
503 /// enumeration-constant -> identifier
504 /// character-constant
506 /// id-expression: [C++ 5.1]
510 /// unqualified-id: [C++ 5.1]
512 /// operator-function-id
513 /// conversion-function-id
517 /// new-expression: [C++ 5.3.4]
518 /// '::'[opt] 'new' new-placement[opt] new-type-id
519 /// new-initializer[opt]
520 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
521 /// new-initializer[opt]
523 /// delete-expression: [C++ 5.3.5]
524 /// '::'[opt] 'delete' cast-expression
525 /// '::'[opt] 'delete' '[' ']' cast-expression
527 /// [GNU/Embarcadero] unary-type-trait:
528 /// '__is_arithmetic'
529 /// '__is_floating_point'
531 /// '__is_lvalue_expr'
532 /// '__is_rvalue_expr'
533 /// '__is_complete_type'
538 /// '__is_lvalue_reference'
539 /// '__is_rvalue_reference'
540 /// '__is_fundamental'
545 /// '__is_member_object_pointer'
546 /// '__is_member_function_pointer'
547 /// '__is_member_pointer'
551 /// '__is_standard_layout'
555 /// [GNU] unary-type-trait:
556 /// '__has_nothrow_assign'
557 /// '__has_nothrow_copy'
558 /// '__has_nothrow_constructor'
559 /// '__has_trivial_assign' [TODO]
560 /// '__has_trivial_copy' [TODO]
561 /// '__has_trivial_constructor'
562 /// '__has_trivial_destructor'
563 /// '__has_virtual_destructor'
564 /// '__is_abstract' [TODO]
566 /// '__is_empty' [TODO]
569 /// '__is_polymorphic'
573 /// [Clang] unary-type-trait:
574 /// '__trivially_copyable'
576 /// binary-type-trait:
577 /// [GNU] '__is_base_of'
578 /// [MS] '__is_convertible_to'
579 /// '__is_convertible'
582 /// [Embarcadero] array-type-trait:
586 /// [Embarcadero] expression-trait:
587 /// '__is_lvalue_expr'
588 /// '__is_rvalue_expr'
590 ExprResult Parser::ParseCastExpression(bool isUnaryExpression,
591 bool isAddressOfOperand,
595 tok::TokenKind SavedKind = Tok.getKind();
598 // This handles all of cast-expression, unary-expression, postfix-expression,
599 // and primary-expression. We handle them together like this for efficiency
600 // and to simplify handling of an expression starting with a '(' token: which
601 // may be one of a parenthesized expression, cast-expression, compound literal
602 // expression, or statement expression.
604 // If the parsed tokens consist of a primary-expression, the cases below
605 // break out of the switch; at the end we call ParsePostfixExpressionSuffix
606 // to handle the postfix expression suffixes. Cases that cannot be followed
607 // by postfix exprs should return without invoking
608 // ParsePostfixExpressionSuffix.
611 // If this expression is limited to being a unary-expression, the parent can
612 // not start a cast expression.
613 ParenParseOption ParenExprType =
614 (isUnaryExpression && !getLang().CPlusPlus)? CompoundLiteral : CastExpr;
616 SourceLocation RParenLoc;
619 // The inside of the parens don't need to be a colon protected scope, and
620 // isn't immediately a message send.
621 ColonProtectionRAIIObject X(*this, false);
623 Res = ParseParenExpression(ParenExprType, false/*stopIfCastExr*/,
624 isTypeCast, CastTy, RParenLoc);
627 switch (ParenExprType) {
628 case SimpleExpr: break; // Nothing else to do.
629 case CompoundStmt: break; // Nothing else to do.
630 case CompoundLiteral:
631 // We parsed '(' type-name ')' '{' ... '}'. If any suffixes of
632 // postfix-expression exist, parse them now.
635 // We have parsed the cast-expression and no postfix-expr pieces are
643 // primary-expression
644 case tok::numeric_constant:
645 // constant: integer-constant
646 // constant: floating-constant
648 Res = Actions.ActOnNumericConstant(Tok);
654 return ParseCXXBoolLiteral();
656 case tok::kw_nullptr:
657 return Actions.ActOnCXXNullPtrLiteral(ConsumeToken());
659 case tok::annot_primary_expr:
660 assert(Res.get() == 0 && "Stray primary-expression annotation?");
661 Res = getExprAnnotation(Tok);
665 case tok::identifier: { // primary-expression: identifier
666 // unqualified-id: identifier
667 // constant: enumeration-constant
668 // Turn a potentially qualified name into a annot_typename or
669 // annot_cxxscope if it would be valid. This handles things like x::y, etc.
670 if (getLang().CPlusPlus) {
671 // Avoid the unnecessary parse-time lookup in the common case
672 // where the syntax forbids a type.
673 const Token &Next = NextToken();
674 if (Next.is(tok::coloncolon) ||
675 (!ColonIsSacred && Next.is(tok::colon)) ||
676 Next.is(tok::less) ||
677 Next.is(tok::l_paren)) {
678 // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse.
679 if (TryAnnotateTypeOrScopeToken())
681 if (!Tok.is(tok::identifier))
682 return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
686 // Consume the identifier so that we can see if it is followed by a '(' or
688 IdentifierInfo &II = *Tok.getIdentifierInfo();
689 SourceLocation ILoc = ConsumeToken();
691 // Support 'Class.property' and 'super.property' notation.
692 if (getLang().ObjC1 && Tok.is(tok::period) &&
693 (Actions.getTypeName(II, ILoc, getCurScope()) ||
694 // Allow the base to be 'super' if in an objc-method.
695 (&II == Ident_super && getCurScope()->isInObjcMethodScope()))) {
698 if (Tok.isNot(tok::identifier)) {
699 Diag(Tok, diag::err_expected_property_name);
702 IdentifierInfo &PropertyName = *Tok.getIdentifierInfo();
703 SourceLocation PropertyLoc = ConsumeToken();
705 Res = Actions.ActOnClassPropertyRefExpr(II, PropertyName,
710 // In an Objective-C method, if we have "super" followed by an identifier,
711 // the token sequence is ill-formed. However, if there's a ':' or ']' after
712 // that identifier, this is probably a message send with a missing open
713 // bracket. Treat it as such.
714 if (getLang().ObjC1 && &II == Ident_super && !InMessageExpression &&
715 getCurScope()->isInObjcMethodScope() &&
716 ((Tok.is(tok::identifier) &&
717 (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) ||
718 Tok.is(tok::code_completion))) {
719 Res = ParseObjCMessageExpressionBody(SourceLocation(), ILoc, ParsedType(),
724 // If we have an Objective-C class name followed by an identifier
725 // and either ':' or ']', this is an Objective-C class message
726 // send that's missing the opening '['. Recovery
727 // appropriately. Also take this path if we're performing code
728 // completion after an Objective-C class name.
729 if (getLang().ObjC1 &&
730 ((Tok.is(tok::identifier) && !InMessageExpression) ||
731 Tok.is(tok::code_completion))) {
732 const Token& Next = NextToken();
733 if (Tok.is(tok::code_completion) ||
734 Next.is(tok::colon) || Next.is(tok::r_square))
735 if (ParsedType Typ = Actions.getTypeName(II, ILoc, getCurScope()))
736 if (Typ.get()->isObjCObjectOrInterfaceType()) {
737 // Fake up a Declarator to use with ActOnTypeName.
738 DeclSpec DS(AttrFactory);
739 DS.SetRangeStart(ILoc);
740 DS.SetRangeEnd(ILoc);
741 const char *PrevSpec = 0;
743 DS.SetTypeSpecType(TST_typename, ILoc, PrevSpec, DiagID, Typ);
745 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
746 TypeResult Ty = Actions.ActOnTypeName(getCurScope(),
751 Res = ParseObjCMessageExpressionBody(SourceLocation(),
758 // Make sure to pass down the right value for isAddressOfOperand.
759 if (isAddressOfOperand && isPostfixExpressionSuffixStart())
760 isAddressOfOperand = false;
762 // Function designators are allowed to be undeclared (C99 6.5.1p2), so we
763 // need to know whether or not this identifier is a function designator or
766 CXXScopeSpec ScopeSpec;
767 Name.setIdentifier(&II, ILoc);
768 Res = Actions.ActOnIdExpression(getCurScope(), ScopeSpec, Name,
769 Tok.is(tok::l_paren), isAddressOfOperand);
772 case tok::char_constant: // constant: character-constant
773 case tok::wide_char_constant:
774 case tok::utf16_char_constant:
775 case tok::utf32_char_constant:
776 Res = Actions.ActOnCharacterConstant(Tok);
779 case tok::kw___func__: // primary-expression: __func__ [C99 6.4.2.2]
780 case tok::kw___FUNCTION__: // primary-expression: __FUNCTION__ [GNU]
781 case tok::kw___PRETTY_FUNCTION__: // primary-expression: __P..Y_F..N__ [GNU]
782 Res = Actions.ActOnPredefinedExpr(Tok.getLocation(), SavedKind);
785 case tok::string_literal: // primary-expression: string-literal
786 case tok::wide_string_literal:
787 case tok::utf8_string_literal:
788 case tok::utf16_string_literal:
789 case tok::utf32_string_literal:
790 Res = ParseStringLiteralExpression();
792 case tok::kw__Generic: // primary-expression: generic-selection [C1X 6.5.1]
793 Res = ParseGenericSelectionExpression();
795 case tok::kw___builtin_va_arg:
796 case tok::kw___builtin_offsetof:
797 case tok::kw___builtin_choose_expr:
798 case tok::kw___builtin_astype: // primary-expression: [OCL] as_type()
799 return ParseBuiltinPrimaryExpression();
801 return Actions.ActOnGNUNullExpr(ConsumeToken());
803 case tok::plusplus: // unary-expression: '++' unary-expression [C99]
804 case tok::minusminus: { // unary-expression: '--' unary-expression [C99]
805 // C++ [expr.unary] has:
807 // ++ cast-expression
808 // -- cast-expression
809 SourceLocation SavedLoc = ConsumeToken();
810 Res = ParseCastExpression(!getLang().CPlusPlus);
811 if (!Res.isInvalid())
812 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
815 case tok::amp: { // unary-expression: '&' cast-expression
816 // Special treatment because of member pointers
817 SourceLocation SavedLoc = ConsumeToken();
818 Res = ParseCastExpression(false, true);
819 if (!Res.isInvalid())
820 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
824 case tok::star: // unary-expression: '*' cast-expression
825 case tok::plus: // unary-expression: '+' cast-expression
826 case tok::minus: // unary-expression: '-' cast-expression
827 case tok::tilde: // unary-expression: '~' cast-expression
828 case tok::exclaim: // unary-expression: '!' cast-expression
829 case tok::kw___real: // unary-expression: '__real' cast-expression [GNU]
830 case tok::kw___imag: { // unary-expression: '__imag' cast-expression [GNU]
831 SourceLocation SavedLoc = ConsumeToken();
832 Res = ParseCastExpression(false);
833 if (!Res.isInvalid())
834 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
838 case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU]
839 // __extension__ silences extension warnings in the subexpression.
840 ExtensionRAIIObject O(Diags); // Use RAII to do this.
841 SourceLocation SavedLoc = ConsumeToken();
842 Res = ParseCastExpression(false);
843 if (!Res.isInvalid())
844 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
847 case tok::kw_sizeof: // unary-expression: 'sizeof' unary-expression
848 // unary-expression: 'sizeof' '(' type-name ')'
849 case tok::kw_alignof:
850 case tok::kw___alignof: // unary-expression: '__alignof' unary-expression
851 // unary-expression: '__alignof' '(' type-name ')'
852 // unary-expression: 'alignof' '(' type-id ')'
853 case tok::kw_vec_step: // unary-expression: OpenCL 'vec_step' expression
854 return ParseUnaryExprOrTypeTraitExpression();
855 case tok::ampamp: { // unary-expression: '&&' identifier
856 SourceLocation AmpAmpLoc = ConsumeToken();
857 if (Tok.isNot(tok::identifier))
858 return ExprError(Diag(Tok, diag::err_expected_ident));
860 if (getCurScope()->getFnParent() == 0)
861 return ExprError(Diag(Tok, diag::err_address_of_label_outside_fn));
863 Diag(AmpAmpLoc, diag::ext_gnu_address_of_label);
864 LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
866 Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(), LD);
870 case tok::kw_const_cast:
871 case tok::kw_dynamic_cast:
872 case tok::kw_reinterpret_cast:
873 case tok::kw_static_cast:
874 Res = ParseCXXCasts();
877 Res = ParseCXXTypeid();
879 case tok::kw___uuidof:
880 Res = ParseCXXUuidof();
883 Res = ParseCXXThis();
886 case tok::annot_typename:
887 if (isStartOfObjCClassMessageMissingOpenBracket()) {
888 ParsedType Type = getTypeAnnotation(Tok);
890 // Fake up a Declarator to use with ActOnTypeName.
891 DeclSpec DS(AttrFactory);
892 DS.SetRangeStart(Tok.getLocation());
893 DS.SetRangeEnd(Tok.getLastLoc());
895 const char *PrevSpec = 0;
897 DS.SetTypeSpecType(TST_typename, Tok.getAnnotationEndLoc(),
898 PrevSpec, DiagID, Type);
900 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
901 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
906 Res = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(),
913 case tok::kw_wchar_t:
914 case tok::kw_char16_t:
915 case tok::kw_char32_t:
920 case tok::kw___int64:
922 case tok::kw_unsigned:
927 case tok::kw_typename:
929 case tok::kw___vector: {
930 if (!getLang().CPlusPlus) {
931 Diag(Tok, diag::err_expected_expression);
935 if (SavedKind == tok::kw_typename) {
936 // postfix-expression: typename-specifier '(' expression-list[opt] ')'
937 // typename-specifier braced-init-list
938 if (TryAnnotateTypeOrScopeToken())
942 // postfix-expression: simple-type-specifier '(' expression-list[opt] ')'
943 // simple-type-specifier braced-init-list
945 DeclSpec DS(AttrFactory);
946 ParseCXXSimpleTypeSpecifier(DS);
947 if (Tok.isNot(tok::l_paren) &&
948 (!getLang().CPlusPlus0x || Tok.isNot(tok::l_brace)))
949 return ExprError(Diag(Tok, diag::err_expected_lparen_after_type)
950 << DS.getSourceRange());
952 Res = ParseCXXTypeConstructExpression(DS);
956 case tok::annot_cxxscope: { // [C++] id-expression: qualified-id
957 // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse.
958 // (We can end up in this situation after tentative parsing.)
959 if (TryAnnotateTypeOrScopeToken())
961 if (!Tok.is(tok::annot_cxxscope))
962 return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
963 NotCastExpr, isTypeCast);
965 Token Next = NextToken();
966 if (Next.is(tok::annot_template_id)) {
967 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Next);
968 if (TemplateId->Kind == TNK_Type_template) {
969 // We have a qualified template-id that we know refers to a
970 // type, translate it into a type and continue parsing as a
973 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
974 AnnotateTemplateIdTokenAsType();
975 return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
976 NotCastExpr, isTypeCast);
980 // Parse as an id-expression.
981 Res = ParseCXXIdExpression(isAddressOfOperand);
985 case tok::annot_template_id: { // [C++] template-id
986 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
987 if (TemplateId->Kind == TNK_Type_template) {
988 // We have a template-id that we know refers to a type,
989 // translate it into a type and continue parsing as a cast
991 AnnotateTemplateIdTokenAsType();
992 return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
993 NotCastExpr, isTypeCast);
996 // Fall through to treat the template-id as an id-expression.
999 case tok::kw_operator: // [C++] id-expression: operator/conversion-function-id
1000 Res = ParseCXXIdExpression(isAddressOfOperand);
1003 case tok::coloncolon: {
1004 // ::foo::bar -> global qualified name etc. If TryAnnotateTypeOrScopeToken
1005 // annotates the token, tail recurse.
1006 if (TryAnnotateTypeOrScopeToken())
1008 if (!Tok.is(tok::coloncolon))
1009 return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
1011 // ::new -> [C++] new-expression
1012 // ::delete -> [C++] delete-expression
1013 SourceLocation CCLoc = ConsumeToken();
1014 if (Tok.is(tok::kw_new))
1015 return ParseCXXNewExpression(true, CCLoc);
1016 if (Tok.is(tok::kw_delete))
1017 return ParseCXXDeleteExpression(true, CCLoc);
1019 // This is not a type name or scope specifier, it is an invalid expression.
1020 Diag(CCLoc, diag::err_expected_expression);
1024 case tok::kw_new: // [C++] new-expression
1025 return ParseCXXNewExpression(false, Tok.getLocation());
1027 case tok::kw_delete: // [C++] delete-expression
1028 return ParseCXXDeleteExpression(false, Tok.getLocation());
1030 case tok::kw_noexcept: { // [C++0x] 'noexcept' '(' expression ')'
1031 SourceLocation KeyLoc = ConsumeToken();
1032 BalancedDelimiterTracker T(*this, tok::l_paren);
1034 if (T.expectAndConsume(diag::err_expected_lparen_after, "noexcept"))
1036 // C++ [expr.unary.noexcept]p1:
1037 // The noexcept operator determines whether the evaluation of its operand,
1038 // which is an unevaluated operand, can throw an exception.
1039 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
1040 ExprResult Result = ParseExpression();
1044 if (!Result.isInvalid())
1045 Result = Actions.ActOnNoexceptExpr(KeyLoc, T.getOpenLocation(),
1046 Result.take(), T.getCloseLocation());
1047 return move(Result);
1050 case tok::kw___is_abstract: // [GNU] unary-type-trait
1051 case tok::kw___is_class:
1052 case tok::kw___is_empty:
1053 case tok::kw___is_enum:
1054 case tok::kw___is_literal:
1055 case tok::kw___is_arithmetic:
1056 case tok::kw___is_integral:
1057 case tok::kw___is_floating_point:
1058 case tok::kw___is_complete_type:
1059 case tok::kw___is_void:
1060 case tok::kw___is_array:
1061 case tok::kw___is_function:
1062 case tok::kw___is_reference:
1063 case tok::kw___is_lvalue_reference:
1064 case tok::kw___is_rvalue_reference:
1065 case tok::kw___is_fundamental:
1066 case tok::kw___is_object:
1067 case tok::kw___is_scalar:
1068 case tok::kw___is_compound:
1069 case tok::kw___is_pointer:
1070 case tok::kw___is_member_object_pointer:
1071 case tok::kw___is_member_function_pointer:
1072 case tok::kw___is_member_pointer:
1073 case tok::kw___is_const:
1074 case tok::kw___is_volatile:
1075 case tok::kw___is_standard_layout:
1076 case tok::kw___is_signed:
1077 case tok::kw___is_unsigned:
1078 case tok::kw___is_literal_type:
1079 case tok::kw___is_pod:
1080 case tok::kw___is_polymorphic:
1081 case tok::kw___is_trivial:
1082 case tok::kw___is_trivially_copyable:
1083 case tok::kw___is_union:
1084 case tok::kw___has_trivial_constructor:
1085 case tok::kw___has_trivial_copy:
1086 case tok::kw___has_trivial_assign:
1087 case tok::kw___has_trivial_destructor:
1088 case tok::kw___has_nothrow_assign:
1089 case tok::kw___has_nothrow_copy:
1090 case tok::kw___has_nothrow_constructor:
1091 case tok::kw___has_virtual_destructor:
1092 return ParseUnaryTypeTrait();
1094 case tok::kw___builtin_types_compatible_p:
1095 case tok::kw___is_base_of:
1096 case tok::kw___is_same:
1097 case tok::kw___is_convertible:
1098 case tok::kw___is_convertible_to:
1099 return ParseBinaryTypeTrait();
1101 case tok::kw___array_rank:
1102 case tok::kw___array_extent:
1103 return ParseArrayTypeTrait();
1105 case tok::kw___is_lvalue_expr:
1106 case tok::kw___is_rvalue_expr:
1107 return ParseExpressionTrait();
1110 SourceLocation AtLoc = ConsumeToken();
1111 return ParseObjCAtExpression(AtLoc);
1114 Res = ParseBlockLiteralExpression();
1116 case tok::code_completion: {
1117 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
1122 if (getLang().CPlusPlus0x) {
1123 if (getLang().ObjC1) {
1124 Res = TryParseLambdaExpression();
1125 if (Res.isInvalid())
1126 Res = ParseObjCMessageExpression();
1129 Res = ParseLambdaExpression();
1132 if (getLang().ObjC1) {
1133 Res = ParseObjCMessageExpression();
1142 // These can be followed by postfix-expr pieces.
1143 return ParsePostfixExpressionSuffix(Res);
1146 /// ParsePostfixExpressionSuffix - Once the leading part of a postfix-expression
1147 /// is parsed, this method parses any suffixes that apply.
1149 /// postfix-expression: [C99 6.5.2]
1150 /// primary-expression
1151 /// postfix-expression '[' expression ']'
1152 /// postfix-expression '[' braced-init-list ']'
1153 /// postfix-expression '(' argument-expression-list[opt] ')'
1154 /// postfix-expression '.' identifier
1155 /// postfix-expression '->' identifier
1156 /// postfix-expression '++'
1157 /// postfix-expression '--'
1158 /// '(' type-name ')' '{' initializer-list '}'
1159 /// '(' type-name ')' '{' initializer-list ',' '}'
1161 /// argument-expression-list: [C99 6.5.2]
1162 /// argument-expression ...[opt]
1163 /// argument-expression-list ',' assignment-expression ...[opt]
1166 Parser::ParsePostfixExpressionSuffix(ExprResult LHS) {
1167 // Now that the primary-expression piece of the postfix-expression has been
1168 // parsed, see if there are any postfix-expression pieces here.
1171 switch (Tok.getKind()) {
1172 case tok::code_completion:
1173 if (InMessageExpression)
1176 Actions.CodeCompletePostfixExpression(getCurScope(), LHS);
1180 case tok::identifier:
1181 // If we see identifier: after an expression, and we're not already in a
1182 // message send, then this is probably a message send with a missing
1183 // opening bracket '['.
1184 if (getLang().ObjC1 && !InMessageExpression &&
1185 (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) {
1186 LHS = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(),
1187 ParsedType(), LHS.get());
1191 // Fall through; this isn't a message send.
1193 default: // Not a postfix-expression suffix.
1195 case tok::l_square: { // postfix-expression: p-e '[' expression ']'
1196 // If we have a array postfix expression that starts on a new line and
1197 // Objective-C is enabled, it is highly likely that the user forgot a
1198 // semicolon after the base expression and that the array postfix-expr is
1199 // actually another message send. In this case, do some look-ahead to see
1200 // if the contents of the square brackets are obviously not a valid
1201 // expression and recover by pretending there is no suffix.
1202 if (getLang().ObjC1 && Tok.isAtStartOfLine() &&
1203 isSimpleObjCMessageExpression())
1206 BalancedDelimiterTracker T(*this, tok::l_square);
1208 Loc = T.getOpenLocation();
1210 if (getLang().CPlusPlus0x && Tok.is(tok::l_brace))
1211 Idx = ParseBraceInitializer();
1213 Idx = ParseExpression();
1215 SourceLocation RLoc = Tok.getLocation();
1217 if (!LHS.isInvalid() && !Idx.isInvalid() && Tok.is(tok::r_square)) {
1218 LHS = Actions.ActOnArraySubscriptExpr(getCurScope(), LHS.take(), Loc,
1228 case tok::l_paren: // p-e: p-e '(' argument-expression-list[opt] ')'
1229 case tok::lesslessless: { // p-e: p-e '<<<' argument-expression-list '>>>'
1230 // '(' argument-expression-list[opt] ')'
1231 tok::TokenKind OpKind = Tok.getKind();
1232 InMessageExpressionRAIIObject InMessage(*this, false);
1234 Expr *ExecConfig = 0;
1236 BalancedDelimiterTracker LLLT(*this, tok::lesslessless);
1237 BalancedDelimiterTracker PT(*this, tok::l_paren);
1239 if (OpKind == tok::lesslessless) {
1240 ExprVector ExecConfigExprs(Actions);
1241 CommaLocsTy ExecConfigCommaLocs;
1244 if (ParseExpressionList(ExecConfigExprs, ExecConfigCommaLocs)) {
1248 if (LHS.isInvalid()) {
1249 SkipUntil(tok::greatergreatergreater);
1250 } else if (LLLT.consumeClose()) {
1251 // There was an error closing the brackets
1255 if (!LHS.isInvalid()) {
1256 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen, ""))
1259 Loc = PrevTokLocation;
1262 if (!LHS.isInvalid()) {
1263 ExprResult ECResult = Actions.ActOnCUDAExecConfigExpr(getCurScope(),
1264 LLLT.getOpenLocation(),
1265 move_arg(ExecConfigExprs),
1266 LLLT.getCloseLocation());
1267 if (ECResult.isInvalid())
1270 ExecConfig = ECResult.get();
1274 Loc = PT.getOpenLocation();
1277 ExprVector ArgExprs(Actions);
1278 CommaLocsTy CommaLocs;
1280 if (Tok.is(tok::code_completion)) {
1281 Actions.CodeCompleteCall(getCurScope(), LHS.get(), 0, 0);
1286 if (OpKind == tok::l_paren || !LHS.isInvalid()) {
1287 if (Tok.isNot(tok::r_paren)) {
1288 if (ParseExpressionList(ArgExprs, CommaLocs, &Sema::CodeCompleteCall,
1296 if (LHS.isInvalid()) {
1297 SkipUntil(tok::r_paren);
1298 } else if (Tok.isNot(tok::r_paren)) {
1302 assert((ArgExprs.size() == 0 ||
1303 ArgExprs.size()-1 == CommaLocs.size())&&
1304 "Unexpected number of commas!");
1305 LHS = Actions.ActOnCallExpr(getCurScope(), LHS.take(), Loc,
1306 move_arg(ArgExprs), Tok.getLocation(),
1315 // postfix-expression: p-e '->' template[opt] id-expression
1316 // postfix-expression: p-e '.' template[opt] id-expression
1317 tok::TokenKind OpKind = Tok.getKind();
1318 SourceLocation OpLoc = ConsumeToken(); // Eat the "." or "->" token.
1321 ParsedType ObjectType;
1322 bool MayBePseudoDestructor = false;
1323 if (getLang().CPlusPlus && !LHS.isInvalid()) {
1324 LHS = Actions.ActOnStartCXXMemberReference(getCurScope(), LHS.take(),
1325 OpLoc, OpKind, ObjectType,
1326 MayBePseudoDestructor);
1327 if (LHS.isInvalid())
1330 ParseOptionalCXXScopeSpecifier(SS, ObjectType, false,
1331 &MayBePseudoDestructor);
1332 if (SS.isNotEmpty())
1333 ObjectType = ParsedType();
1336 if (Tok.is(tok::code_completion)) {
1337 // Code completion for a member access expression.
1338 Actions.CodeCompleteMemberReferenceExpr(getCurScope(), LHS.get(),
1339 OpLoc, OpKind == tok::arrow);
1345 if (MayBePseudoDestructor && !LHS.isInvalid()) {
1346 LHS = ParseCXXPseudoDestructor(LHS.take(), OpLoc, OpKind, SS,
1351 // Either the action has told is that this cannot be a
1352 // pseudo-destructor expression (based on the type of base
1353 // expression), or we didn't see a '~' in the right place. We
1354 // can still parse a destructor name here, but in that case it
1355 // names a real destructor.
1356 // Allow explicit constructor calls in Microsoft mode.
1357 // FIXME: Add support for explicit call of template constructor.
1359 if (ParseUnqualifiedId(SS,
1360 /*EnteringContext=*/false,
1361 /*AllowDestructorName=*/true,
1362 /*AllowConstructorName=*/ getLang().MicrosoftExt,
1367 if (!LHS.isInvalid())
1368 LHS = Actions.ActOnMemberAccessExpr(getCurScope(), LHS.take(), OpLoc,
1369 OpKind, SS, Name, ObjCImpDecl,
1370 Tok.is(tok::l_paren));
1373 case tok::plusplus: // postfix-expression: postfix-expression '++'
1374 case tok::minusminus: // postfix-expression: postfix-expression '--'
1375 if (!LHS.isInvalid()) {
1376 LHS = Actions.ActOnPostfixUnaryOp(getCurScope(), Tok.getLocation(),
1377 Tok.getKind(), LHS.take());
1385 /// ParseExprAfterUnaryExprOrTypeTrait - We parsed a typeof/sizeof/alignof/
1386 /// vec_step and we are at the start of an expression or a parenthesized
1387 /// type-id. OpTok is the operand token (typeof/sizeof/alignof). Returns the
1388 /// expression (isCastExpr == false) or the type (isCastExpr == true).
1390 /// unary-expression: [C99 6.5.3]
1391 /// 'sizeof' unary-expression
1392 /// 'sizeof' '(' type-name ')'
1393 /// [GNU] '__alignof' unary-expression
1394 /// [GNU] '__alignof' '(' type-name ')'
1395 /// [C++0x] 'alignof' '(' type-id ')'
1397 /// [GNU] typeof-specifier:
1398 /// typeof ( expressions )
1399 /// typeof ( type-name )
1400 /// [GNU/C++] typeof unary-expression
1402 /// [OpenCL 1.1 6.11.12] vec_step built-in function:
1403 /// vec_step ( expressions )
1404 /// vec_step ( type-name )
1407 Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok,
1410 SourceRange &CastRange) {
1412 assert((OpTok.is(tok::kw_typeof) || OpTok.is(tok::kw_sizeof) ||
1413 OpTok.is(tok::kw___alignof) || OpTok.is(tok::kw_alignof) ||
1414 OpTok.is(tok::kw_vec_step)) &&
1415 "Not a typeof/sizeof/alignof/vec_step expression!");
1419 // If the operand doesn't start with an '(', it must be an expression.
1420 if (Tok.isNot(tok::l_paren)) {
1422 if (OpTok.is(tok::kw_typeof) && !getLang().CPlusPlus) {
1423 Diag(Tok,diag::err_expected_lparen_after_id) << OpTok.getIdentifierInfo();
1427 // C++0x [expr.sizeof]p1:
1428 // [...] The operand is either an expression, which is an unevaluated
1429 // operand (Clause 5) [...]
1431 // The GNU typeof and alignof extensions also behave as unevaluated
1433 EnterExpressionEvaluationContext Unevaluated(Actions,
1435 Operand = ParseCastExpression(true/*isUnaryExpression*/);
1437 // If it starts with a '(', we know that it is either a parenthesized
1438 // type-name, or it is a unary-expression that starts with a compound
1439 // literal, or starts with a primary-expression that is a parenthesized
1441 ParenParseOption ExprType = CastExpr;
1442 SourceLocation LParenLoc = Tok.getLocation(), RParenLoc;
1444 // C++0x [expr.sizeof]p1:
1445 // [...] The operand is either an expression, which is an unevaluated
1446 // operand (Clause 5) [...]
1448 // The GNU typeof and alignof extensions also behave as unevaluated
1450 EnterExpressionEvaluationContext Unevaluated(Actions,
1452 Operand = ParseParenExpression(ExprType, true/*stopIfCastExpr*/,
1453 false, CastTy, RParenLoc);
1454 CastRange = SourceRange(LParenLoc, RParenLoc);
1456 // If ParseParenExpression parsed a '(typename)' sequence only, then this is
1458 if (ExprType == CastExpr) {
1463 if (getLang().CPlusPlus || OpTok.isNot(tok::kw_typeof)) {
1464 // GNU typeof in C requires the expression to be parenthesized. Not so for
1465 // sizeof/alignof or in C++. Therefore, the parenthesized expression is
1466 // the start of a unary-expression, but doesn't include any postfix
1467 // pieces. Parse these now if present.
1468 if (!Operand.isInvalid())
1469 Operand = ParsePostfixExpressionSuffix(Operand.get());
1473 // If we get here, the operand to the typeof/sizeof/alignof was an expresion.
1475 return move(Operand);
1479 /// ParseUnaryExprOrTypeTraitExpression - Parse a sizeof or alignof expression.
1480 /// unary-expression: [C99 6.5.3]
1481 /// 'sizeof' unary-expression
1482 /// 'sizeof' '(' type-name ')'
1483 /// [C++0x] 'sizeof' '...' '(' identifier ')'
1484 /// [GNU] '__alignof' unary-expression
1485 /// [GNU] '__alignof' '(' type-name ')'
1486 /// [C++0x] 'alignof' '(' type-id ')'
1487 ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() {
1488 assert((Tok.is(tok::kw_sizeof) || Tok.is(tok::kw___alignof)
1489 || Tok.is(tok::kw_alignof) || Tok.is(tok::kw_vec_step)) &&
1490 "Not a sizeof/alignof/vec_step expression!");
1494 // [C++0x] 'sizeof' '...' '(' identifier ')'
1495 if (Tok.is(tok::ellipsis) && OpTok.is(tok::kw_sizeof)) {
1496 SourceLocation EllipsisLoc = ConsumeToken();
1497 SourceLocation LParenLoc, RParenLoc;
1498 IdentifierInfo *Name = 0;
1499 SourceLocation NameLoc;
1500 if (Tok.is(tok::l_paren)) {
1501 BalancedDelimiterTracker T(*this, tok::l_paren);
1503 LParenLoc = T.getOpenLocation();
1504 if (Tok.is(tok::identifier)) {
1505 Name = Tok.getIdentifierInfo();
1506 NameLoc = ConsumeToken();
1508 RParenLoc = T.getCloseLocation();
1509 if (RParenLoc.isInvalid())
1510 RParenLoc = PP.getLocForEndOfToken(NameLoc);
1512 Diag(Tok, diag::err_expected_parameter_pack);
1513 SkipUntil(tok::r_paren);
1515 } else if (Tok.is(tok::identifier)) {
1516 Name = Tok.getIdentifierInfo();
1517 NameLoc = ConsumeToken();
1518 LParenLoc = PP.getLocForEndOfToken(EllipsisLoc);
1519 RParenLoc = PP.getLocForEndOfToken(NameLoc);
1520 Diag(LParenLoc, diag::err_paren_sizeof_parameter_pack)
1522 << FixItHint::CreateInsertion(LParenLoc, "(")
1523 << FixItHint::CreateInsertion(RParenLoc, ")");
1525 Diag(Tok, diag::err_sizeof_parameter_pack);
1531 return Actions.ActOnSizeofParameterPackExpr(getCurScope(),
1532 OpTok.getLocation(),
1539 SourceRange CastRange;
1540 ExprResult Operand = ParseExprAfterUnaryExprOrTypeTrait(OpTok,
1545 UnaryExprOrTypeTrait ExprKind = UETT_SizeOf;
1546 if (OpTok.is(tok::kw_alignof) || OpTok.is(tok::kw___alignof))
1547 ExprKind = UETT_AlignOf;
1548 else if (OpTok.is(tok::kw_vec_step))
1549 ExprKind = UETT_VecStep;
1552 return Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(),
1555 CastTy.getAsOpaquePtr(),
1558 // If we get here, the operand to the sizeof/alignof was an expresion.
1559 if (!Operand.isInvalid())
1560 Operand = Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(),
1565 return move(Operand);
1568 /// ParseBuiltinPrimaryExpression
1570 /// primary-expression: [C99 6.5.1]
1571 /// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
1572 /// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
1573 /// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
1575 /// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
1576 /// [OCL] '__builtin_astype' '(' type-name expr ')'
1578 /// [GNU] offsetof-member-designator:
1579 /// [GNU] identifier
1580 /// [GNU] offsetof-member-designator '.' identifier
1581 /// [GNU] offsetof-member-designator '[' expression ']'
1583 ExprResult Parser::ParseBuiltinPrimaryExpression() {
1585 const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo();
1587 tok::TokenKind T = Tok.getKind();
1588 SourceLocation StartLoc = ConsumeToken(); // Eat the builtin identifier.
1590 // All of these start with an open paren.
1591 if (Tok.isNot(tok::l_paren))
1592 return ExprError(Diag(Tok, diag::err_expected_lparen_after_id)
1595 BalancedDelimiterTracker PT(*this, tok::l_paren);
1601 default: llvm_unreachable("Not a builtin primary expression!");
1602 case tok::kw___builtin_va_arg: {
1603 ExprResult Expr(ParseAssignmentExpression());
1605 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
1608 TypeResult Ty = ParseTypeName();
1610 if (Tok.isNot(tok::r_paren)) {
1611 Diag(Tok, diag::err_expected_rparen);
1615 if (Expr.isInvalid() || Ty.isInvalid())
1618 Res = Actions.ActOnVAArg(StartLoc, Expr.take(), Ty.get(), ConsumeParen());
1621 case tok::kw___builtin_offsetof: {
1622 SourceLocation TypeLoc = Tok.getLocation();
1623 TypeResult Ty = ParseTypeName();
1624 if (Ty.isInvalid()) {
1625 SkipUntil(tok::r_paren);
1629 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
1632 // We must have at least one identifier here.
1633 if (Tok.isNot(tok::identifier)) {
1634 Diag(Tok, diag::err_expected_ident);
1635 SkipUntil(tok::r_paren);
1639 // Keep track of the various subcomponents we see.
1640 SmallVector<Sema::OffsetOfComponent, 4> Comps;
1642 Comps.push_back(Sema::OffsetOfComponent());
1643 Comps.back().isBrackets = false;
1644 Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
1645 Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken();
1647 // FIXME: This loop leaks the index expressions on error.
1649 if (Tok.is(tok::period)) {
1650 // offsetof-member-designator: offsetof-member-designator '.' identifier
1651 Comps.push_back(Sema::OffsetOfComponent());
1652 Comps.back().isBrackets = false;
1653 Comps.back().LocStart = ConsumeToken();
1655 if (Tok.isNot(tok::identifier)) {
1656 Diag(Tok, diag::err_expected_ident);
1657 SkipUntil(tok::r_paren);
1660 Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
1661 Comps.back().LocEnd = ConsumeToken();
1663 } else if (Tok.is(tok::l_square)) {
1664 // offsetof-member-designator: offsetof-member-design '[' expression ']'
1665 Comps.push_back(Sema::OffsetOfComponent());
1666 Comps.back().isBrackets = true;
1667 BalancedDelimiterTracker ST(*this, tok::l_square);
1669 Comps.back().LocStart = ST.getOpenLocation();
1670 Res = ParseExpression();
1671 if (Res.isInvalid()) {
1672 SkipUntil(tok::r_paren);
1675 Comps.back().U.E = Res.release();
1678 Comps.back().LocEnd = ST.getCloseLocation();
1680 if (Tok.isNot(tok::r_paren)) {
1683 } else if (Ty.isInvalid()) {
1687 Res = Actions.ActOnBuiltinOffsetOf(getCurScope(), StartLoc, TypeLoc,
1688 Ty.get(), &Comps[0], Comps.size(),
1689 PT.getCloseLocation());
1696 case tok::kw___builtin_choose_expr: {
1697 ExprResult Cond(ParseAssignmentExpression());
1698 if (Cond.isInvalid()) {
1699 SkipUntil(tok::r_paren);
1702 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
1705 ExprResult Expr1(ParseAssignmentExpression());
1706 if (Expr1.isInvalid()) {
1707 SkipUntil(tok::r_paren);
1710 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
1713 ExprResult Expr2(ParseAssignmentExpression());
1714 if (Expr2.isInvalid()) {
1715 SkipUntil(tok::r_paren);
1718 if (Tok.isNot(tok::r_paren)) {
1719 Diag(Tok, diag::err_expected_rparen);
1722 Res = Actions.ActOnChooseExpr(StartLoc, Cond.take(), Expr1.take(),
1723 Expr2.take(), ConsumeParen());
1726 case tok::kw___builtin_astype: {
1727 // The first argument is an expression to be converted, followed by a comma.
1728 ExprResult Expr(ParseAssignmentExpression());
1729 if (Expr.isInvalid()) {
1730 SkipUntil(tok::r_paren);
1734 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",
1738 // Second argument is the type to bitcast to.
1739 TypeResult DestTy = ParseTypeName();
1740 if (DestTy.isInvalid())
1743 // Attempt to consume the r-paren.
1744 if (Tok.isNot(tok::r_paren)) {
1745 Diag(Tok, diag::err_expected_rparen);
1746 SkipUntil(tok::r_paren);
1750 Res = Actions.ActOnAsTypeExpr(Expr.take(), DestTy.get(), StartLoc,
1756 if (Res.isInvalid())
1759 // These can be followed by postfix-expr pieces because they are
1760 // primary-expressions.
1761 return ParsePostfixExpressionSuffix(Res.take());
1764 /// ParseParenExpression - This parses the unit that starts with a '(' token,
1765 /// based on what is allowed by ExprType. The actual thing parsed is returned
1766 /// in ExprType. If stopIfCastExpr is true, it will only return the parsed type,
1767 /// not the parsed cast-expression.
1769 /// primary-expression: [C99 6.5.1]
1770 /// '(' expression ')'
1771 /// [GNU] '(' compound-statement ')' (if !ParenExprOnly)
1772 /// postfix-expression: [C99 6.5.2]
1773 /// '(' type-name ')' '{' initializer-list '}'
1774 /// '(' type-name ')' '{' initializer-list ',' '}'
1775 /// cast-expression: [C99 6.5.4]
1776 /// '(' type-name ')' cast-expression
1777 /// [ARC] bridged-cast-expression
1779 /// [ARC] bridged-cast-expression:
1780 /// (__bridge type-name) cast-expression
1781 /// (__bridge_transfer type-name) cast-expression
1782 /// (__bridge_retained type-name) cast-expression
1784 Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr,
1785 bool isTypeCast, ParsedType &CastTy,
1786 SourceLocation &RParenLoc) {
1787 assert(Tok.is(tok::l_paren) && "Not a paren expr!");
1788 GreaterThanIsOperatorScope G(GreaterThanIsOperator, true);
1789 BalancedDelimiterTracker T(*this, tok::l_paren);
1790 if (T.consumeOpen())
1792 SourceLocation OpenLoc = T.getOpenLocation();
1794 ExprResult Result(true);
1795 bool isAmbiguousTypeId;
1796 CastTy = ParsedType();
1798 if (Tok.is(tok::code_completion)) {
1799 Actions.CodeCompleteOrdinaryName(getCurScope(),
1800 ExprType >= CompoundLiteral? Sema::PCC_ParenthesizedExpression
1801 : Sema::PCC_Expression);
1806 // None of these cases should fall through with an invalid Result
1807 // unless they've already reported an error.
1809 if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) {
1810 Diag(Tok, diag::ext_gnu_statement_expr);
1811 ParsedAttributes attrs(AttrFactory);
1812 StmtResult Stmt(ParseCompoundStatement(attrs, true));
1813 ExprType = CompoundStmt;
1815 // If the substmt parsed correctly, build the AST node.
1816 if (!Stmt.isInvalid())
1817 Result = Actions.ActOnStmtExpr(OpenLoc, Stmt.take(), Tok.getLocation());
1818 } else if (ExprType >= CompoundLiteral &&
1819 (Tok.is(tok::kw___bridge) ||
1820 Tok.is(tok::kw___bridge_transfer) ||
1821 Tok.is(tok::kw___bridge_retained) ||
1822 Tok.is(tok::kw___bridge_retain))) {
1823 tok::TokenKind tokenKind = Tok.getKind();
1824 SourceLocation BridgeKeywordLoc = ConsumeToken();
1826 // Parse an Objective-C ARC ownership cast expression.
1827 ObjCBridgeCastKind Kind;
1828 if (tokenKind == tok::kw___bridge)
1830 else if (tokenKind == tok::kw___bridge_transfer)
1831 Kind = OBC_BridgeTransfer;
1832 else if (tokenKind == tok::kw___bridge_retained)
1833 Kind = OBC_BridgeRetained;
1835 // As a hopefully temporary workaround, allow __bridge_retain as
1836 // a synonym for __bridge_retained, but only in system headers.
1837 assert(tokenKind == tok::kw___bridge_retain);
1838 Kind = OBC_BridgeRetained;
1839 if (!PP.getSourceManager().isInSystemHeader(BridgeKeywordLoc))
1840 Diag(BridgeKeywordLoc, diag::err_arc_bridge_retain)
1841 << FixItHint::CreateReplacement(BridgeKeywordLoc,
1842 "__bridge_retained");
1845 TypeResult Ty = ParseTypeName();
1847 RParenLoc = T.getCloseLocation();
1848 ExprResult SubExpr = ParseCastExpression(/*isUnaryExpression=*/false);
1850 if (Ty.isInvalid() || SubExpr.isInvalid())
1853 return Actions.ActOnObjCBridgedCast(getCurScope(), OpenLoc, Kind,
1854 BridgeKeywordLoc, Ty.get(),
1855 RParenLoc, SubExpr.get());
1856 } else if (ExprType >= CompoundLiteral &&
1857 isTypeIdInParens(isAmbiguousTypeId)) {
1859 // Otherwise, this is a compound literal expression or cast expression.
1861 // In C++, if the type-id is ambiguous we disambiguate based on context.
1862 // If stopIfCastExpr is true the context is a typeof/sizeof/alignof
1863 // in which case we should treat it as type-id.
1864 // if stopIfCastExpr is false, we need to determine the context past the
1865 // parens, so we defer to ParseCXXAmbiguousParenExpression for that.
1866 if (isAmbiguousTypeId && !stopIfCastExpr) {
1867 ExprResult res = ParseCXXAmbiguousParenExpression(ExprType, CastTy, T);
1868 RParenLoc = T.getCloseLocation();
1872 // Parse the type declarator.
1873 DeclSpec DS(AttrFactory);
1874 ParseSpecifierQualifierList(DS);
1875 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1876 ParseDeclarator(DeclaratorInfo);
1878 // If our type is followed by an identifier and either ':' or ']', then
1879 // this is probably an Objective-C message send where the leading '[' is
1880 // missing. Recover as if that were the case.
1881 if (!DeclaratorInfo.isInvalidType() && Tok.is(tok::identifier) &&
1882 !InMessageExpression && getLang().ObjC1 &&
1883 (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) {
1886 InMessageExpressionRAIIObject InMessage(*this, false);
1887 Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
1889 Result = ParseObjCMessageExpressionBody(SourceLocation(),
1895 RParenLoc = T.getCloseLocation();
1896 if (Tok.is(tok::l_brace)) {
1897 ExprType = CompoundLiteral;
1900 InMessageExpressionRAIIObject InMessage(*this, false);
1901 Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
1903 return ParseCompoundLiteralExpression(Ty.get(), OpenLoc, RParenLoc);
1906 if (ExprType == CastExpr) {
1907 // We parsed '(' type-name ')' and the thing after it wasn't a '{'.
1909 if (DeclaratorInfo.isInvalidType())
1912 // Note that this doesn't parse the subsequent cast-expression, it just
1913 // returns the parsed type to the callee.
1914 if (stopIfCastExpr) {
1917 InMessageExpressionRAIIObject InMessage(*this, false);
1918 Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
1921 return ExprResult();
1924 // Reject the cast of super idiom in ObjC.
1925 if (Tok.is(tok::identifier) && getLang().ObjC1 &&
1926 Tok.getIdentifierInfo() == Ident_super &&
1927 getCurScope()->isInObjcMethodScope() &&
1928 GetLookAheadToken(1).isNot(tok::period)) {
1929 Diag(Tok.getLocation(), diag::err_illegal_super_cast)
1930 << SourceRange(OpenLoc, RParenLoc);
1934 // Parse the cast-expression that follows it next.
1935 // TODO: For cast expression with CastTy.
1936 Result = ParseCastExpression(/*isUnaryExpression=*/false,
1937 /*isAddressOfOperand=*/false,
1938 /*isTypeCast=*/true);
1939 if (!Result.isInvalid()) {
1940 Result = Actions.ActOnCastExpr(getCurScope(), OpenLoc,
1941 DeclaratorInfo, CastTy,
1942 RParenLoc, Result.take());
1944 return move(Result);
1947 Diag(Tok, diag::err_expected_lbrace_in_compound_literal);
1950 } else if (isTypeCast) {
1951 // Parse the expression-list.
1952 InMessageExpressionRAIIObject InMessage(*this, false);
1954 ExprVector ArgExprs(Actions);
1955 CommaLocsTy CommaLocs;
1957 if (!ParseExpressionList(ArgExprs, CommaLocs)) {
1958 ExprType = SimpleExpr;
1959 Result = Actions.ActOnParenOrParenListExpr(OpenLoc, Tok.getLocation(),
1960 move_arg(ArgExprs));
1963 InMessageExpressionRAIIObject InMessage(*this, false);
1965 Result = ParseExpression();
1966 ExprType = SimpleExpr;
1968 // Don't build a paren expression unless we actually match a ')'.
1969 if (!Result.isInvalid() && Tok.is(tok::r_paren))
1970 Result = Actions.ActOnParenExpr(OpenLoc, Tok.getLocation(), Result.take());
1974 if (Result.isInvalid()) {
1975 SkipUntil(tok::r_paren);
1980 RParenLoc = T.getCloseLocation();
1981 return move(Result);
1984 /// ParseCompoundLiteralExpression - We have parsed the parenthesized type-name
1985 /// and we are at the left brace.
1987 /// postfix-expression: [C99 6.5.2]
1988 /// '(' type-name ')' '{' initializer-list '}'
1989 /// '(' type-name ')' '{' initializer-list ',' '}'
1992 Parser::ParseCompoundLiteralExpression(ParsedType Ty,
1993 SourceLocation LParenLoc,
1994 SourceLocation RParenLoc) {
1995 assert(Tok.is(tok::l_brace) && "Not a compound literal!");
1996 if (!getLang().C99) // Compound literals don't exist in C90.
1997 Diag(LParenLoc, diag::ext_c99_compound_literal);
1998 ExprResult Result = ParseInitializer();
1999 if (!Result.isInvalid() && Ty)
2000 return Actions.ActOnCompoundLiteral(LParenLoc, Ty, RParenLoc, Result.take());
2001 return move(Result);
2004 /// ParseStringLiteralExpression - This handles the various token types that
2005 /// form string literals, and also handles string concatenation [C99 5.1.1.2,
2006 /// translation phase #6].
2008 /// primary-expression: [C99 6.5.1]
2010 ExprResult Parser::ParseStringLiteralExpression() {
2011 assert(isTokenStringLiteral() && "Not a string literal!");
2013 // String concat. Note that keywords like __func__ and __FUNCTION__ are not
2014 // considered to be strings for concatenation purposes.
2015 SmallVector<Token, 4> StringToks;
2018 StringToks.push_back(Tok);
2019 ConsumeStringToken();
2020 } while (isTokenStringLiteral());
2022 // Pass the set of string tokens, ready for concatenation, to the actions.
2023 return Actions.ActOnStringLiteral(&StringToks[0], StringToks.size());
2026 /// ParseGenericSelectionExpression - Parse a C1X generic-selection
2029 /// generic-selection:
2030 /// _Generic ( assignment-expression , generic-assoc-list )
2031 /// generic-assoc-list:
2032 /// generic-association
2033 /// generic-assoc-list , generic-association
2034 /// generic-association:
2035 /// type-name : assignment-expression
2036 /// default : assignment-expression
2037 ExprResult Parser::ParseGenericSelectionExpression() {
2038 assert(Tok.is(tok::kw__Generic) && "_Generic keyword expected");
2039 SourceLocation KeyLoc = ConsumeToken();
2042 Diag(KeyLoc, diag::ext_c1x_generic_selection);
2044 BalancedDelimiterTracker T(*this, tok::l_paren);
2045 if (T.expectAndConsume(diag::err_expected_lparen))
2048 ExprResult ControllingExpr;
2050 // C1X 6.5.1.1p3 "The controlling expression of a generic selection is
2052 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
2053 ControllingExpr = ParseAssignmentExpression();
2054 if (ControllingExpr.isInvalid()) {
2055 SkipUntil(tok::r_paren);
2060 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "")) {
2061 SkipUntil(tok::r_paren);
2065 SourceLocation DefaultLoc;
2066 TypeVector Types(Actions);
2067 ExprVector Exprs(Actions);
2070 if (Tok.is(tok::kw_default)) {
2071 // C1X 6.5.1.1p2 "A generic selection shall have no more than one default
2072 // generic association."
2073 if (!DefaultLoc.isInvalid()) {
2074 Diag(Tok, diag::err_duplicate_default_assoc);
2075 Diag(DefaultLoc, diag::note_previous_default_assoc);
2076 SkipUntil(tok::r_paren);
2079 DefaultLoc = ConsumeToken();
2082 ColonProtectionRAIIObject X(*this);
2083 TypeResult TR = ParseTypeName();
2084 if (TR.isInvalid()) {
2085 SkipUntil(tok::r_paren);
2090 Types.push_back(Ty);
2092 if (ExpectAndConsume(tok::colon, diag::err_expected_colon, "")) {
2093 SkipUntil(tok::r_paren);
2097 // FIXME: These expressions should be parsed in a potentially potentially
2098 // evaluated context.
2099 ExprResult ER(ParseAssignmentExpression());
2100 if (ER.isInvalid()) {
2101 SkipUntil(tok::r_paren);
2104 Exprs.push_back(ER.release());
2106 if (Tok.isNot(tok::comma))
2112 if (T.getCloseLocation().isInvalid())
2115 return Actions.ActOnGenericSelectionExpr(KeyLoc, DefaultLoc,
2116 T.getCloseLocation(),
2117 ControllingExpr.release(),
2118 move_arg(Types), move_arg(Exprs));
2121 /// ParseExpressionList - Used for C/C++ (argument-)expression-list.
2123 /// argument-expression-list:
2124 /// assignment-expression
2125 /// argument-expression-list , assignment-expression
2127 /// [C++] expression-list:
2128 /// [C++] assignment-expression
2129 /// [C++] expression-list , assignment-expression
2131 /// [C++0x] expression-list:
2132 /// [C++0x] initializer-list
2134 /// [C++0x] initializer-list
2135 /// [C++0x] initializer-clause ...[opt]
2136 /// [C++0x] initializer-list , initializer-clause ...[opt]
2138 /// [C++0x] initializer-clause:
2139 /// [C++0x] assignment-expression
2140 /// [C++0x] braced-init-list
2142 bool Parser::ParseExpressionList(SmallVectorImpl<Expr*> &Exprs,
2143 SmallVectorImpl<SourceLocation> &CommaLocs,
2144 void (Sema::*Completer)(Scope *S,
2150 if (Tok.is(tok::code_completion)) {
2152 (Actions.*Completer)(getCurScope(), Data, Exprs.data(), Exprs.size());
2154 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
2160 if (getLang().CPlusPlus0x && Tok.is(tok::l_brace))
2161 Expr = ParseBraceInitializer();
2163 Expr = ParseAssignmentExpression();
2165 if (Tok.is(tok::ellipsis))
2166 Expr = Actions.ActOnPackExpansion(Expr.get(), ConsumeToken());
2167 if (Expr.isInvalid())
2170 Exprs.push_back(Expr.release());
2172 if (Tok.isNot(tok::comma))
2174 // Move to the next argument, remember where the comma was.
2175 CommaLocs.push_back(ConsumeToken());
2179 /// ParseBlockId - Parse a block-id, which roughly looks like int (int x).
2181 /// [clang] block-id:
2182 /// [clang] specifier-qualifier-list block-declarator
2184 void Parser::ParseBlockId() {
2185 if (Tok.is(tok::code_completion)) {
2186 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type);
2187 return cutOffParsing();
2190 // Parse the specifier-qualifier-list piece.
2191 DeclSpec DS(AttrFactory);
2192 ParseSpecifierQualifierList(DS);
2194 // Parse the block-declarator.
2195 Declarator DeclaratorInfo(DS, Declarator::BlockLiteralContext);
2196 ParseDeclarator(DeclaratorInfo);
2198 // We do this for: ^ __attribute__((noreturn)) {, as DS has the attributes.
2199 DeclaratorInfo.takeAttributes(DS.getAttributes(), SourceLocation());
2201 MaybeParseGNUAttributes(DeclaratorInfo);
2203 // Inform sema that we are starting a block.
2204 Actions.ActOnBlockArguments(DeclaratorInfo, getCurScope());
2207 /// ParseBlockLiteralExpression - Parse a block literal, which roughly looks
2208 /// like ^(int x){ return x+1; }
2211 /// [clang] '^' block-args[opt] compound-statement
2212 /// [clang] '^' block-id compound-statement
2213 /// [clang] block-args:
2214 /// [clang] '(' parameter-list ')'
2216 ExprResult Parser::ParseBlockLiteralExpression() {
2217 assert(Tok.is(tok::caret) && "block literal starts with ^");
2218 SourceLocation CaretLoc = ConsumeToken();
2220 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), CaretLoc,
2221 "block literal parsing");
2223 // Enter a scope to hold everything within the block. This includes the
2224 // argument decls, decls within the compound expression, etc. This also
2225 // allows determining whether a variable reference inside the block is
2226 // within or outside of the block.
2227 ParseScope BlockScope(this, Scope::BlockScope | Scope::FnScope |
2228 Scope::BreakScope | Scope::ContinueScope |
2231 // Inform sema that we are starting a block.
2232 Actions.ActOnBlockStart(CaretLoc, getCurScope());
2234 // Parse the return type if present.
2235 DeclSpec DS(AttrFactory);
2236 Declarator ParamInfo(DS, Declarator::BlockLiteralContext);
2237 // FIXME: Since the return type isn't actually parsed, it can't be used to
2238 // fill ParamInfo with an initial valid range, so do it manually.
2239 ParamInfo.SetSourceRange(SourceRange(Tok.getLocation(), Tok.getLocation()));
2241 // If this block has arguments, parse them. There is no ambiguity here with
2242 // the expression case, because the expression case requires a parameter list.
2243 if (Tok.is(tok::l_paren)) {
2244 ParseParenDeclarator(ParamInfo);
2245 // Parse the pieces after the identifier as if we had "int(...)".
2246 // SetIdentifier sets the source range end, but in this case we're past
2248 SourceLocation Tmp = ParamInfo.getSourceRange().getEnd();
2249 ParamInfo.SetIdentifier(0, CaretLoc);
2250 ParamInfo.SetRangeEnd(Tmp);
2251 if (ParamInfo.isInvalidType()) {
2252 // If there was an error parsing the arguments, they may have
2253 // tried to use ^(x+y) which requires an argument list. Just
2254 // skip the whole block literal.
2255 Actions.ActOnBlockError(CaretLoc, getCurScope());
2259 MaybeParseGNUAttributes(ParamInfo);
2261 // Inform sema that we are starting a block.
2262 Actions.ActOnBlockArguments(ParamInfo, getCurScope());
2263 } else if (!Tok.is(tok::l_brace)) {
2266 // Otherwise, pretend we saw (void).
2267 ParsedAttributes attrs(AttrFactory);
2268 ParamInfo.AddTypeInfo(DeclaratorChunk::getFunction(true, false,
2271 true, SourceLocation(),
2280 MaybeParseGNUAttributes(ParamInfo);
2282 // Inform sema that we are starting a block.
2283 Actions.ActOnBlockArguments(ParamInfo, getCurScope());
2287 ExprResult Result(true);
2288 if (!Tok.is(tok::l_brace)) {
2289 // Saw something like: ^expr
2290 Diag(Tok, diag::err_expected_expression);
2291 Actions.ActOnBlockError(CaretLoc, getCurScope());
2295 StmtResult Stmt(ParseCompoundStatementBody());
2297 if (!Stmt.isInvalid())
2298 Result = Actions.ActOnBlockStmtExpr(CaretLoc, Stmt.take(), getCurScope());
2300 Actions.ActOnBlockError(CaretLoc, getCurScope());
2301 return move(Result);