blob: 89422b97fc1fcc008a2b54ae28d27ab5cfdf7b96 [file] [log] [blame]
Chris Lattner7ad0fbe2006-11-05 07:46:30 +00001//===--- ParseExpr.cpp - Expression Parsing -------------------------------===//
Chris Lattnerc951dae2006-08-10 04:23:57 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerc951dae2006-08-10 04:23:57 +00007//
8//===----------------------------------------------------------------------===//
9//
Chris Lattnercde626a2006-08-12 08:13:25 +000010// This file implements the Expression parsing implementation. Expressions in
11// C99 basically consist of a bunch of binary operators with unary operators and
12// other random stuff at the leaves.
13//
14// In the C99 grammar, these unary operators bind tightest and are represented
15// as the 'cast-expression' production. Everything else is either a binary
Chris Lattnerb7f1fc92006-08-12 16:45:01 +000016// operator (e.g. '/') or a ternary operator ("?:"). The unary leaves are
Chris Lattnercde626a2006-08-12 08:13:25 +000017// handled by ParseCastExpression, the higher level pieces are handled by
18// ParseBinaryExpression.
Chris Lattnerc951dae2006-08-10 04:23:57 +000019//
20//===----------------------------------------------------------------------===//
21
22#include "clang/Parse/Parser.h"
John McCall8b0666c2010-08-20 18:27:03 +000023#include "clang/Sema/DeclSpec.h"
24#include "clang/Sema/Scope.h"
25#include "clang/Sema/ParsedTemplate.h"
Chris Lattnerf6801202009-03-05 07:32:12 +000026#include "clang/Basic/PrettyStackTrace.h"
Chris Lattner8a9a97a2009-12-10 00:21:05 +000027#include "RAIIObjectsForParser.h"
Chris Lattner6d28d9b2006-08-24 03:51:22 +000028#include "llvm/ADT/SmallVector.h"
Chris Lattner834618d2006-11-03 07:48:41 +000029#include "llvm/ADT/SmallString.h"
Chris Lattnerc951dae2006-08-10 04:23:57 +000030using namespace clang;
31
Chris Lattnercde626a2006-08-12 08:13:25 +000032/// getBinOpPrecedence - Return the precedence of the specified binary operator
Chris Lattner8d72f2a2010-07-19 05:07:24 +000033/// token.
Mike Stump11289f42009-09-09 15:08:12 +000034static prec::Level getBinOpPrecedence(tok::TokenKind Kind,
Douglas Gregorcbb45d02009-02-25 23:02:36 +000035 bool GreaterThanIsOperator,
36 bool CPlusPlus0x) {
Chris Lattnercde626a2006-08-12 08:13:25 +000037 switch (Kind) {
Douglas Gregor8bf42052009-02-09 18:46:07 +000038 case tok::greater:
Douglas Gregorcbb45d02009-02-25 23:02:36 +000039 // 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. [...]
Douglas Gregor8bf42052009-02-09 18:46:07 +000043 if (GreaterThanIsOperator)
44 return prec::Relational;
45 return prec::Unknown;
Mike Stump11289f42009-09-09 15:08:12 +000046
Douglas Gregorcbb45d02009-02-25 23:02:36 +000047 case tok::greatergreater:
48 // C++0x [temp.names]p3:
49 //
50 // [...] Similarly, the first non-nested >> is treated as two
51 // consecutive but distinct > tokens, the first of which is
52 // taken as the end of the template-argument-list and completes
53 // the template-id. [...]
54 if (GreaterThanIsOperator || !CPlusPlus0x)
55 return prec::Shift;
56 return prec::Unknown;
57
Chris Lattnercde626a2006-08-12 08:13:25 +000058 default: return prec::Unknown;
59 case tok::comma: return prec::Comma;
60 case tok::equal:
61 case tok::starequal:
62 case tok::slashequal:
63 case tok::percentequal:
64 case tok::plusequal:
65 case tok::minusequal:
66 case tok::lesslessequal:
67 case tok::greatergreaterequal:
68 case tok::ampequal:
69 case tok::caretequal:
70 case tok::pipeequal: return prec::Assignment;
71 case tok::question: return prec::Conditional;
72 case tok::pipepipe: return prec::LogicalOr;
73 case tok::ampamp: return prec::LogicalAnd;
74 case tok::pipe: return prec::InclusiveOr;
75 case tok::caret: return prec::ExclusiveOr;
76 case tok::amp: return prec::And;
Chris Lattnercde626a2006-08-12 08:13:25 +000077 case tok::exclaimequal:
78 case tok::equalequal: return prec::Equality;
79 case tok::lessequal:
80 case tok::less:
Douglas Gregor8bf42052009-02-09 18:46:07 +000081 case tok::greaterequal: return prec::Relational;
Douglas Gregorcbb45d02009-02-25 23:02:36 +000082 case tok::lessless: return prec::Shift;
Chris Lattnercde626a2006-08-12 08:13:25 +000083 case tok::plus:
84 case tok::minus: return prec::Additive;
85 case tok::percent:
86 case tok::slash:
87 case tok::star: return prec::Multiplicative;
Sebastian Redl112a97662009-02-07 00:15:38 +000088 case tok::periodstar:
89 case tok::arrowstar: return prec::PointerToMember;
Chris Lattnercde626a2006-08-12 08:13:25 +000090 }
91}
92
93
Chris Lattnerce7e21d2006-08-12 17:22:40 +000094/// ParseExpression - Simple precedence-based parser for binary/ternary
Chris Lattnercde626a2006-08-12 08:13:25 +000095/// operators.
96///
Chris Lattnerb7f1fc92006-08-12 16:45:01 +000097/// Note: we diverge from the C99 grammar when parsing the assignment-expression
98/// production. C99 specifies that the LHS of an assignment operator should be
99/// parsed as a unary-expression, but consistency dictates that it be a
100/// conditional-expession. In practice, the important thing here is that the
101/// LHS of an assignment has to be an l-value, which productions between
102/// unary-expression and conditional-expression don't produce. Because we want
103/// consistency, we parse the LHS as a conditional-expression, then check for
104/// l-value-ness in semantic analysis stages.
105///
Sebastian Redl112a97662009-02-07 00:15:38 +0000106/// pm-expression: [C++ 5.5]
107/// cast-expression
108/// pm-expression '.*' cast-expression
109/// pm-expression '->*' cast-expression
110///
Chris Lattnercde626a2006-08-12 08:13:25 +0000111/// multiplicative-expression: [C99 6.5.5]
Sebastian Redl112a97662009-02-07 00:15:38 +0000112/// Note: in C++, apply pm-expression instead of cast-expression
Chris Lattnercde626a2006-08-12 08:13:25 +0000113/// cast-expression
114/// multiplicative-expression '*' cast-expression
115/// multiplicative-expression '/' cast-expression
116/// multiplicative-expression '%' cast-expression
117///
118/// additive-expression: [C99 6.5.6]
119/// multiplicative-expression
120/// additive-expression '+' multiplicative-expression
121/// additive-expression '-' multiplicative-expression
122///
123/// shift-expression: [C99 6.5.7]
124/// additive-expression
125/// shift-expression '<<' additive-expression
126/// shift-expression '>>' additive-expression
127///
128/// relational-expression: [C99 6.5.8]
129/// shift-expression
130/// relational-expression '<' shift-expression
131/// relational-expression '>' shift-expression
132/// relational-expression '<=' shift-expression
133/// relational-expression '>=' shift-expression
134///
135/// equality-expression: [C99 6.5.9]
136/// relational-expression
137/// equality-expression '==' relational-expression
138/// equality-expression '!=' relational-expression
139///
140/// AND-expression: [C99 6.5.10]
141/// equality-expression
142/// AND-expression '&' equality-expression
143///
144/// exclusive-OR-expression: [C99 6.5.11]
145/// AND-expression
146/// exclusive-OR-expression '^' AND-expression
147///
148/// inclusive-OR-expression: [C99 6.5.12]
149/// exclusive-OR-expression
150/// inclusive-OR-expression '|' exclusive-OR-expression
151///
152/// logical-AND-expression: [C99 6.5.13]
153/// inclusive-OR-expression
154/// logical-AND-expression '&&' inclusive-OR-expression
155///
156/// logical-OR-expression: [C99 6.5.14]
157/// logical-AND-expression
158/// logical-OR-expression '||' logical-AND-expression
159///
160/// conditional-expression: [C99 6.5.15]
161/// logical-OR-expression
162/// logical-OR-expression '?' expression ':' conditional-expression
163/// [GNU] logical-OR-expression '?' ':' conditional-expression
Sebastian Redl1a99f442009-04-16 17:51:27 +0000164/// [C++] the third operand is an assignment-expression
Chris Lattnercde626a2006-08-12 08:13:25 +0000165///
166/// assignment-expression: [C99 6.5.16]
167/// conditional-expression
168/// unary-expression assignment-operator assignment-expression
Chris Lattnerb7e656b2008-02-26 00:51:44 +0000169/// [C++] throw-expression [C++ 15]
Chris Lattnercde626a2006-08-12 08:13:25 +0000170///
171/// assignment-operator: one of
172/// = *= /= %= += -= <<= >>= &= ^= |=
173///
174/// expression: [C99 6.5.17]
Douglas Gregor968f23a2011-01-03 19:31:53 +0000175/// assignment-expression ...[opt]
176/// expression ',' assignment-expression ...[opt]
Douglas Gregorda6c89d2011-04-27 06:18:01 +0000177ExprResult Parser::ParseExpression() {
178 ExprResult LHS(ParseAssignmentExpression());
Sebastian Redl90893182008-12-11 22:33:27 +0000179 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma);
Chris Lattnercde626a2006-08-12 08:13:25 +0000180}
181
Mike Stump11289f42009-09-09 15:08:12 +0000182/// This routine is called when the '@' is seen and consumed.
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +0000183/// Current token is an Identifier and is not a 'try'. This
Chris Lattner644e1b72007-10-03 22:03:06 +0000184/// routine is necessary to disambiguate @try-statement from,
185/// for example, @encode-expression.
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +0000186///
John McCalldadc5752010-08-24 06:29:42 +0000187ExprResult
Sebastian Redl90893182008-12-11 22:33:27 +0000188Parser::ParseExpressionWithLeadingAt(SourceLocation AtLoc) {
John McCalldadc5752010-08-24 06:29:42 +0000189 ExprResult LHS(ParseObjCAtExpression(AtLoc));
Sebastian Redl90893182008-12-11 22:33:27 +0000190 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma);
Fariborz Jahanian62fd2b42007-09-19 19:14:32 +0000191}
192
Eli Friedmaneb3a9b02009-01-27 08:43:38 +0000193/// 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.
John McCalldadc5752010-08-24 06:29:42 +0000196ExprResult
Eli Friedmaneb3a9b02009-01-27 08:43:38 +0000197Parser::ParseExpressionWithLeadingExtension(SourceLocation ExtLoc) {
John McCalldadc5752010-08-24 06:29:42 +0000198 ExprResult LHS(true);
Eli Friedman15af3ee2009-05-16 23:40:44 +0000199 {
200 // Silence extension warnings in the sub-expression
201 ExtensionRAIIObject O(Diags);
202
203 LHS = ParseCastExpression(false);
Eli Friedman15af3ee2009-05-16 23:40:44 +0000204 }
Eli Friedmaneb3a9b02009-01-27 08:43:38 +0000205
Douglas Gregor29d907d2010-09-17 22:25:06 +0000206 if (!LHS.isInvalid())
207 LHS = Actions.ActOnUnaryOp(getCurScope(), ExtLoc, tok::kw___extension__,
208 LHS.take());
Eli Friedmaneb3a9b02009-01-27 08:43:38 +0000209
Douglas Gregor29d907d2010-09-17 22:25:06 +0000210 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma);
Eli Friedmaneb3a9b02009-01-27 08:43:38 +0000211}
212
Chris Lattner0c6c0342006-08-12 18:12:45 +0000213/// ParseAssignmentExpression - Parse an expr that doesn't include commas.
Douglas Gregorda6c89d2011-04-27 06:18:01 +0000214ExprResult Parser::ParseAssignmentExpression() {
Douglas Gregor504a6ae2010-01-10 23:08:15 +0000215 if (Tok.is(tok::code_completion)) {
Douglas Gregorda6c89d2011-04-27 06:18:01 +0000216 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
Douglas Gregor6da3db42010-05-25 05:58:43 +0000217 ConsumeCodeCompletionToken();
Douglas Gregor504a6ae2010-01-10 23:08:15 +0000218 }
219
Douglas Gregorda6c89d2011-04-27 06:18:01 +0000220 if (Tok.is(tok::kw_throw))
Sebastian Redld65cea82008-12-11 22:51:44 +0000221 return ParseThrowExpression();
Chris Lattnerb7e656b2008-02-26 00:51:44 +0000222
Douglas Gregorda6c89d2011-04-27 06:18:01 +0000223 ExprResult LHS = ParseCastExpression(false, false, ParsedType());
Douglas Gregor29d907d2010-09-17 22:25:06 +0000224 return ParseRHSOfBinaryExpression(move(LHS), prec::Assignment);
Chris Lattnerce7e21d2006-08-12 17:22:40 +0000225}
226
Chris Lattnerfd2fe822008-06-02 21:31:07 +0000227/// ParseAssignmentExprWithObjCMessageExprStart - Parse an assignment expression
228/// where part of an objc message send has already been parsed. In this case
229/// LBracLoc indicates the location of the '[' of the message send, and either
230/// ReceiverName or ReceiverExpr is non-null indicating the receiver of the
231/// message.
232///
233/// Since this handles full assignment-expression's, it handles postfix
234/// expressions and other binary operators for these expressions as well.
John McCalldadc5752010-08-24 06:29:42 +0000235ExprResult
Chris Lattnerfd2fe822008-06-02 21:31:07 +0000236Parser::ParseAssignmentExprWithObjCMessageExprStart(SourceLocation LBracLoc,
Douglas Gregor0c78ad92010-04-21 19:57:20 +0000237 SourceLocation SuperLoc,
John McCallba7bf592010-08-24 05:47:05 +0000238 ParsedType ReceiverType,
John McCallb268a282010-08-23 23:25:46 +0000239 Expr *ReceiverExpr) {
John McCalldadc5752010-08-24 06:29:42 +0000240 ExprResult R
John McCallb268a282010-08-23 23:25:46 +0000241 = ParseObjCMessageExpressionBody(LBracLoc, SuperLoc,
242 ReceiverType, ReceiverExpr);
Douglas Gregoreda7e542010-09-18 01:28:11 +0000243 R = ParsePostfixExpressionSuffix(R);
Douglas Gregor29d907d2010-09-17 22:25:06 +0000244 return ParseRHSOfBinaryExpression(R, prec::Assignment);
Chris Lattnerfd2fe822008-06-02 21:31:07 +0000245}
246
247
John McCalldadc5752010-08-24 06:29:42 +0000248ExprResult Parser::ParseConstantExpression() {
Douglas Gregorc9c02ed2009-06-19 23:52:42 +0000249 // C++ [basic.def.odr]p2:
Mike Stump11289f42009-09-09 15:08:12 +0000250 // An expression is potentially evaluated unless it appears where an
Douglas Gregorc9c02ed2009-06-19 23:52:42 +0000251 // integral constant expression is required (see 5.19) [...].
Douglas Gregor0b6a6242009-06-22 20:57:11 +0000252 EnterExpressionEvaluationContext Unevaluated(Actions,
John McCallfaf5fb42010-08-26 23:41:50 +0000253 Sema::Unevaluated);
Mike Stump11289f42009-09-09 15:08:12 +0000254
John McCalldadc5752010-08-24 06:29:42 +0000255 ExprResult LHS(ParseCastExpression(false));
Douglas Gregor29d907d2010-09-17 22:25:06 +0000256 return ParseRHSOfBinaryExpression(LHS, prec::Conditional);
Chris Lattner3b561a32006-08-13 00:12:11 +0000257}
258
Chris Lattnercde626a2006-08-12 08:13:25 +0000259/// ParseRHSOfBinaryExpression - Parse a binary expression that starts with
260/// LHS and has a precedence of at least MinPrec.
John McCalldadc5752010-08-24 06:29:42 +0000261ExprResult
262Parser::ParseRHSOfBinaryExpression(ExprResult LHS, prec::Level MinPrec) {
Douglas Gregor8d4de672010-04-21 22:36:40 +0000263 prec::Level NextTokPrec = getBinOpPrecedence(Tok.getKind(),
264 GreaterThanIsOperator,
265 getLang().CPlusPlus0x);
Chris Lattner9b6d4cb2006-08-23 05:17:46 +0000266 SourceLocation ColonLoc;
267
Chris Lattnercde626a2006-08-12 08:13:25 +0000268 while (1) {
269 // If this token has a lower precedence than we are allowed to parse (e.g.
270 // because we are called recursively, or because the token is not a binop),
271 // then we are done!
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000272 if (NextTokPrec < MinPrec)
Sebastian Redl90893182008-12-11 22:33:27 +0000273 return move(LHS);
Chris Lattnercde626a2006-08-12 08:13:25 +0000274
275 // Consume the operator, saving the operator token for error reporting.
Chris Lattner146762e2007-07-20 16:59:19 +0000276 Token OpToken = Tok;
Chris Lattnercde626a2006-08-12 08:13:25 +0000277 ConsumeToken();
Sebastian Redl112a97662009-02-07 00:15:38 +0000278
Chris Lattner96c3deb2006-08-12 17:13:08 +0000279 // Special case handling for the ternary operator.
John McCalldadc5752010-08-24 06:29:42 +0000280 ExprResult TernaryMiddle(true);
Chris Lattner96c3deb2006-08-12 17:13:08 +0000281 if (NextTokPrec == prec::Conditional) {
Chris Lattnerfeb00b62007-10-09 17:41:39 +0000282 if (Tok.isNot(tok::colon)) {
Chris Lattner244b96b2009-12-10 02:02:58 +0000283 // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
284 ColonProtectionRAIIObject X(*this);
285
Chris Lattner96c3deb2006-08-12 17:13:08 +0000286 // Handle this production specially:
287 // logical-OR-expression '?' expression ':' conditional-expression
288 // In particular, the RHS of the '?' is 'expression', not
289 // 'logical-OR-expression' as we might expect.
290 TernaryMiddle = ParseExpression();
Douglas Gregorec06c122010-09-17 22:41:34 +0000291 if (TernaryMiddle.isInvalid()) {
292 LHS = ExprError();
293 TernaryMiddle = 0;
294 }
Chris Lattner96c3deb2006-08-12 17:13:08 +0000295 } else {
296 // Special case handling of "X ? Y : Z" where Y is empty:
297 // logical-OR-expression '?' ':' conditional-expression [GNU]
Sebastian Redlc13f2682008-12-09 20:22:58 +0000298 TernaryMiddle = 0;
Chris Lattner96c3deb2006-08-12 17:13:08 +0000299 Diag(Tok, diag::ext_gnu_conditional_expr);
300 }
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000301
Chris Lattner0151b7e2010-04-20 21:33:39 +0000302 if (Tok.is(tok::colon)) {
303 // Eat the colon.
304 ColonLoc = ConsumeToken();
305 } else {
Chris Lattnerfb585152010-05-24 22:31:37 +0000306 // Otherwise, we're missing a ':'. Assume that this was a typo that the
307 // user forgot. If we're not in a macro instantion, we can suggest a
308 // fixit hint. If there were two spaces before the current token,
309 // suggest inserting the colon in between them, otherwise insert ": ".
310 SourceLocation FILoc = Tok.getLocation();
311 const char *FIText = ": ";
312 if (FILoc.isFileID()) {
313 const SourceManager &SM = PP.getSourceManager();
314 bool IsInvalid = false;
315 const char *SourcePtr =
316 SM.getCharacterData(FILoc.getFileLocWithOffset(-1), &IsInvalid);
317 if (!IsInvalid && *SourcePtr == ' ') {
318 SourcePtr =
319 SM.getCharacterData(FILoc.getFileLocWithOffset(-2), &IsInvalid);
320 if (!IsInvalid && *SourcePtr == ' ') {
321 FILoc = FILoc.getFileLocWithOffset(-1);
322 FIText = ":";
323 }
324 }
325 }
326
Ted Kremeneke6013652010-04-12 22:10:35 +0000327 Diag(Tok, diag::err_expected_colon)
Chris Lattnerfb585152010-05-24 22:31:37 +0000328 << FixItHint::CreateInsertion(FILoc, FIText);
Chris Lattner03c40412008-11-23 23:17:07 +0000329 Diag(OpToken, diag::note_matching) << "?";
Chris Lattner0151b7e2010-04-20 21:33:39 +0000330 ColonLoc = Tok.getLocation();
Chris Lattner96c3deb2006-08-12 17:13:08 +0000331 }
Chris Lattnercde626a2006-08-12 08:13:25 +0000332 }
Fariborz Jahanian9a14b842009-10-23 21:01:39 +0000333
Douglas Gregor7aa6b222010-05-30 01:49:25 +0000334 // Code completion for the right-hand side of an assignment expression
335 // goes through a special hook that takes the left-hand side into account.
336 if (Tok.is(tok::code_completion) && NextTokPrec == prec::Assignment) {
Douglas Gregor0be31a22010-07-02 17:43:08 +0000337 Actions.CodeCompleteAssignmentRHS(getCurScope(), LHS.get());
Douglas Gregor7aa6b222010-05-30 01:49:25 +0000338 ConsumeCodeCompletionToken();
339 return ExprError();
340 }
341
Chris Lattner96c3deb2006-08-12 17:13:08 +0000342 // Parse another leaf here for the RHS of the operator.
Sebastian Redl1a99f442009-04-16 17:51:27 +0000343 // ParseCastExpression works here because all RHS expressions in C have it
344 // as a prefix, at least. However, in C++, an assignment-expression could
345 // be a throw-expression, which is not a valid cast-expression.
346 // Therefore we need some special-casing here.
347 // Also note that the third operand of the conditional operator is
348 // an assignment-expression in C++.
John McCalldadc5752010-08-24 06:29:42 +0000349 ExprResult RHS;
Sebastian Redl1a99f442009-04-16 17:51:27 +0000350 if (getLang().CPlusPlus && NextTokPrec <= prec::Conditional)
351 RHS = ParseAssignmentExpression();
352 else
353 RHS = ParseCastExpression(false);
Chris Lattnercde626a2006-08-12 08:13:25 +0000354
Douglas Gregor29d907d2010-09-17 22:25:06 +0000355 if (RHS.isInvalid())
356 LHS = ExprError();
357
Chris Lattnercde626a2006-08-12 08:13:25 +0000358 // Remember the precedence of this operator and get the precedence of the
359 // operator immediately to the right of the RHS.
Douglas Gregor8d4de672010-04-21 22:36:40 +0000360 prec::Level ThisPrec = NextTokPrec;
Douglas Gregorcbb45d02009-02-25 23:02:36 +0000361 NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator,
362 getLang().CPlusPlus0x);
Chris Lattner89d53752006-08-12 17:18:19 +0000363
364 // Assignment and conditional expressions are right-associative.
Chris Lattnerdcb7cc52007-12-18 06:06:23 +0000365 bool isRightAssoc = ThisPrec == prec::Conditional ||
366 ThisPrec == prec::Assignment;
Chris Lattnercde626a2006-08-12 08:13:25 +0000367
368 // Get the precedence of the operator to the right of the RHS. If it binds
369 // more tightly with RHS than we do, evaluate it completely first.
Chris Lattnercde626a2006-08-12 08:13:25 +0000370 if (ThisPrec < NextTokPrec ||
371 (ThisPrec == NextTokPrec && isRightAssoc)) {
Chris Lattner89d53752006-08-12 17:18:19 +0000372 // If this is left-associative, only parse things on the RHS that bind
373 // more tightly than the current operator. If it is left-associative, it
374 // is okay, to bind exactly as tightly. For example, compile A=B=C=D as
375 // A=(B=(C=D)), where each paren is a level of recursion here.
Sebastian Redl511ed552008-11-25 22:21:31 +0000376 // The function takes ownership of the RHS.
Douglas Gregor29d907d2010-09-17 22:25:06 +0000377 RHS = ParseRHSOfBinaryExpression(RHS,
Douglas Gregor8d4de672010-04-21 22:36:40 +0000378 static_cast<prec::Level>(ThisPrec + !isRightAssoc));
Douglas Gregor29d907d2010-09-17 22:25:06 +0000379
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000380 if (RHS.isInvalid())
Douglas Gregor29d907d2010-09-17 22:25:06 +0000381 LHS = ExprError();
Chris Lattnercde626a2006-08-12 08:13:25 +0000382
Douglas Gregorcbb45d02009-02-25 23:02:36 +0000383 NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator,
384 getLang().CPlusPlus0x);
Chris Lattnercde626a2006-08-12 08:13:25 +0000385 }
386 assert(NextTokPrec <= ThisPrec && "Recursion didn't work!");
Sebastian Redl511ed552008-11-25 22:21:31 +0000387
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000388 if (!LHS.isInvalid()) {
Chris Lattner319079c2007-08-31 05:01:50 +0000389 // Combine the LHS and RHS into the LHS (e.g. build AST).
Douglas Gregor87f95b02009-02-26 21:00:50 +0000390 if (TernaryMiddle.isInvalid()) {
391 // If we're using '>>' as an operator within a template
392 // argument list (in C++98), suggest the addition of
393 // parentheses so that the code remains well-formed in C++0x.
394 if (!GreaterThanIsOperator && OpToken.is(tok::greatergreater))
395 SuggestParentheses(OpToken.getLocation(),
396 diag::warn_cxx0x_right_shift_in_template_arg,
397 SourceRange(Actions.getExprRange(LHS.get()).getBegin(),
398 Actions.getExprRange(RHS.get()).getEnd()));
399
Douglas Gregor0be31a22010-07-02 17:43:08 +0000400 LHS = Actions.ActOnBinOp(getCurScope(), OpToken.getLocation(),
John McCallb268a282010-08-23 23:25:46 +0000401 OpToken.getKind(), LHS.take(), RHS.take());
Douglas Gregor87f95b02009-02-26 21:00:50 +0000402 } else
Steve Naroff83895f72007-09-16 03:34:24 +0000403 LHS = Actions.ActOnConditionalOp(OpToken.getLocation(), ColonLoc,
John McCallb268a282010-08-23 23:25:46 +0000404 LHS.take(), TernaryMiddle.take(),
405 RHS.take());
Chris Lattner319079c2007-08-31 05:01:50 +0000406 }
Chris Lattnercde626a2006-08-12 08:13:25 +0000407 }
408}
409
Chris Lattnereaf06592006-08-11 02:02:23 +0000410/// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is
Sebastian Redl3d3f75a2009-02-03 20:19:35 +0000411/// true, parse a unary-expression. isAddressOfOperand exists because an
412/// id-expression that is the operand of address-of gets special treatment
413/// due to member pointers.
Chris Lattnereaf06592006-08-11 02:02:23 +0000414///
John McCalldadc5752010-08-24 06:29:42 +0000415ExprResult Parser::ParseCastExpression(bool isUnaryExpression,
Douglas Gregor0e7dde52011-04-24 05:37:28 +0000416 bool isAddressOfOperand,
417 ParsedType TypeOfCast) {
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +0000418 bool NotCastExpr;
John McCalldadc5752010-08-24 06:29:42 +0000419 ExprResult Res = ParseCastExpression(isUnaryExpression,
Douglas Gregor29d907d2010-09-17 22:25:06 +0000420 isAddressOfOperand,
421 NotCastExpr,
422 TypeOfCast);
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +0000423 if (NotCastExpr)
424 Diag(Tok, diag::err_expected_expression);
425 return move(Res);
426}
427
428/// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is
429/// true, parse a unary-expression. isAddressOfOperand exists because an
430/// id-expression that is the operand of address-of gets special treatment
431/// due to member pointers. NotCastExpr is set to true if the token is not the
432/// start of a cast-expression, and no diagnostic is emitted in this case.
433///
Chris Lattner4564bc12006-08-10 23:14:52 +0000434/// cast-expression: [C99 6.5.4]
435/// unary-expression
436/// '(' type-name ')' cast-expression
Chris Lattner81b576e2006-08-11 02:13:20 +0000437///
Chris Lattnerc2dd85a2006-08-10 22:57:16 +0000438/// unary-expression: [C99 6.5.3]
439/// postfix-expression
440/// '++' unary-expression
441/// '--' unary-expression
442/// unary-operator cast-expression
443/// 'sizeof' unary-expression
444/// 'sizeof' '(' type-name ')'
Douglas Gregor820ba7b2011-01-04 17:33:58 +0000445/// [C++0x] 'sizeof' '...' '(' identifier ')'
Chris Lattnerc2dd85a2006-08-10 22:57:16 +0000446/// [GNU] '__alignof' unary-expression
447/// [GNU] '__alignof' '(' type-name ')'
Douglas Gregord7fc8722008-11-06 15:17:27 +0000448/// [C++0x] 'alignof' '(' type-id ')'
Chris Lattnerc2dd85a2006-08-10 22:57:16 +0000449/// [GNU] '&&' identifier
Sebastian Redlbd150f42008-11-21 19:14:01 +0000450/// [C++] new-expression
451/// [C++] delete-expression
Sebastian Redl22e3a932010-09-10 20:55:37 +0000452/// [C++0x] 'noexcept' '(' expression ')'
Chris Lattner81b576e2006-08-11 02:13:20 +0000453///
Chris Lattnerc2dd85a2006-08-10 22:57:16 +0000454/// unary-operator: one of
455/// '&' '*' '+' '-' '~' '!'
456/// [GNU] '__extension__' '__real' '__imag'
457///
Chris Lattner52a99e52006-08-10 20:56:00 +0000458/// primary-expression: [C99 6.5.1]
Douglas Gregor11d0c4c2008-11-06 22:13:31 +0000459/// [C99] identifier
Sebastian Redlc4704762008-11-11 11:37:55 +0000460/// [C++] id-expression
Chris Lattnerc5e0d4a2006-08-10 19:06:03 +0000461/// constant
462/// string-literal
Bill Wendling4073ed52007-02-13 01:51:42 +0000463/// [C++] boolean-literal [C++ 2.13.5]
Sebastian Redl576fd422009-05-10 18:38:11 +0000464/// [C++0x] 'nullptr' [C++0x 2.14.7]
Chris Lattnerc5e0d4a2006-08-10 19:06:03 +0000465/// '(' expression ')'
Peter Collingbourne91147592011-04-15 00:35:48 +0000466/// [C1X] generic-selection
Chris Lattner52a99e52006-08-10 20:56:00 +0000467/// '__func__' [C99 6.4.2.2]
468/// [GNU] '__FUNCTION__'
469/// [GNU] '__PRETTY_FUNCTION__'
470/// [GNU] '(' compound-statement ')'
471/// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
472/// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
473/// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
474/// assign-expr ')'
475/// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
Douglas Gregor3be4b122008-11-29 04:51:27 +0000476/// [GNU] '__null'
Mike Stump11289f42009-09-09 15:08:12 +0000477/// [OBJC] '[' objc-message-expr ']'
Chris Lattnerb241a1b2008-01-25 18:58:06 +0000478/// [OBJC] '@selector' '(' objc-selector-arg ')'
Mike Stump11289f42009-09-09 15:08:12 +0000479/// [OBJC] '@protocol' '(' identifier ')'
480/// [OBJC] '@encode' '(' type-name ')'
Fariborz Jahanian7db004d2007-09-05 19:52:07 +0000481/// [OBJC] objc-string-literal
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000482/// [C++] simple-type-specifier '(' expression-list[opt] ')' [C++ 5.2.3]
Douglas Gregor0c78ad92010-04-21 19:57:20 +0000483/// [C++] typename-specifier '(' expression-list[opt] ')' [C++ 5.2.3]
Bill Wendlinga6930032007-06-29 18:21:34 +0000484/// [C++] 'const_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
485/// [C++] 'dynamic_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
486/// [C++] 'reinterpret_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
487/// [C++] 'static_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1]
Sebastian Redlc4704762008-11-11 11:37:55 +0000488/// [C++] 'typeid' '(' expression ')' [C++ 5.2p1]
489/// [C++] 'typeid' '(' type-id ')' [C++ 5.2p1]
Argyrios Kyrtzidis16c04102008-07-16 07:23:27 +0000490/// [C++] 'this' [C++ 9.3.2]
Sebastian Redlbaad4e72009-01-05 20:52:13 +0000491/// [G++] unary-type-trait '(' type-id ')'
492/// [G++] binary-type-trait '(' type-id ',' type-id ')' [TODO]
John Wiegley6242b6a2011-04-28 00:16:57 +0000493/// [EMBT] array-type-trait '(' type-id ',' integer ')'
Steve Naroff0ac012832008-08-28 19:20:44 +0000494/// [clang] '^' block-literal
Chris Lattner52a99e52006-08-10 20:56:00 +0000495///
496/// constant: [C99 6.4.4]
497/// integer-constant
498/// floating-constant
499/// enumeration-constant -> identifier
500/// character-constant
Chris Lattner52a99e52006-08-10 20:56:00 +0000501///
Douglas Gregor11d0c4c2008-11-06 22:13:31 +0000502/// id-expression: [C++ 5.1]
503/// unqualified-id
Douglas Gregor0c78ad92010-04-21 19:57:20 +0000504/// qualified-id
Douglas Gregor11d0c4c2008-11-06 22:13:31 +0000505///
506/// unqualified-id: [C++ 5.1]
507/// identifier
508/// operator-function-id
Douglas Gregor0c78ad92010-04-21 19:57:20 +0000509/// conversion-function-id
510/// '~' class-name
511/// template-id
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000512///
Sebastian Redlbd150f42008-11-21 19:14:01 +0000513/// new-expression: [C++ 5.3.4]
514/// '::'[opt] 'new' new-placement[opt] new-type-id
515/// new-initializer[opt]
516/// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
517/// new-initializer[opt]
518///
519/// delete-expression: [C++ 5.3.5]
520/// '::'[opt] 'delete' cast-expression
521/// '::'[opt] 'delete' '[' ']' cast-expression
522///
John Wiegley65497cc2011-04-27 23:09:49 +0000523/// [GNU/Embarcadero] unary-type-trait:
524/// '__is_arithmetic'
525/// '__is_floating_point'
526/// '__is_integral'
527/// '__is_lvalue_expr'
528/// '__is_rvalue_expr'
529/// '__is_complete_type'
530/// '__is_void'
531/// '__is_array'
532/// '__is_function'
533/// '__is_reference'
534/// '__is_lvalue_reference'
535/// '__is_rvalue_reference'
536/// '__is_fundamental'
537/// '__is_object'
538/// '__is_scalar'
539/// '__is_compound'
540/// '__is_pointer'
541/// '__is_member_object_pointer'
542/// '__is_member_function_pointer'
543/// '__is_member_pointer'
544/// '__is_const'
545/// '__is_volatile'
546/// '__is_trivial'
547/// '__is_standard_layout'
548/// '__is_signed'
549/// '__is_unsigned'
550///
Sebastian Redlbaad4e72009-01-05 20:52:13 +0000551/// [GNU] unary-type-trait:
Sebastian Redl7dcb1552010-08-31 04:59:00 +0000552/// '__has_nothrow_assign'
553/// '__has_nothrow_copy'
554/// '__has_nothrow_constructor'
Sebastian Redlbaad4e72009-01-05 20:52:13 +0000555/// '__has_trivial_assign' [TODO]
556/// '__has_trivial_copy' [TODO]
Anders Carlssonfe63dc52009-04-16 00:08:20 +0000557/// '__has_trivial_constructor'
Anders Carlsson6dc35752009-04-17 02:34:54 +0000558/// '__has_trivial_destructor'
Sebastian Redlb469afb2010-09-02 23:19:42 +0000559/// '__has_virtual_destructor'
Sebastian Redlbaad4e72009-01-05 20:52:13 +0000560/// '__is_abstract' [TODO]
561/// '__is_class'
562/// '__is_empty' [TODO]
563/// '__is_enum'
564/// '__is_pod'
565/// '__is_polymorphic'
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +0000566/// '__is_trivial'
Sebastian Redlbaad4e72009-01-05 20:52:13 +0000567/// '__is_union'
568///
Alexis Huntd9a5cc12011-05-13 00:31:07 +0000569/// [Clang] unary-type-trait:
570/// '__trivially_copyable'
571///
Douglas Gregor8006e762011-01-27 20:28:01 +0000572/// binary-type-trait:
573/// [GNU] '__is_base_of'
574/// [MS] '__is_convertible_to'
John Wiegley65497cc2011-04-27 23:09:49 +0000575/// '__is_convertible'
576/// '__is_same'
Sebastian Redlbaad4e72009-01-05 20:52:13 +0000577///
John Wiegley6242b6a2011-04-28 00:16:57 +0000578/// [Embarcadero] array-type-trait:
579/// '__array_rank'
580/// '__array_extent'
581///
John Wiegleyf9f65842011-04-25 06:54:41 +0000582/// [Embarcadero] expression-trait:
583/// '__is_lvalue_expr'
584/// '__is_rvalue_expr'
585///
John McCalldadc5752010-08-24 06:29:42 +0000586ExprResult Parser::ParseCastExpression(bool isUnaryExpression,
Sebastian Redl22e3a932010-09-10 20:55:37 +0000587 bool isAddressOfOperand,
588 bool &NotCastExpr,
589 ParsedType TypeOfCast) {
John McCalldadc5752010-08-24 06:29:42 +0000590 ExprResult Res;
Chris Lattner0ba3dc42006-10-25 03:38:23 +0000591 tok::TokenKind SavedKind = Tok.getKind();
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +0000592 NotCastExpr = false;
Mike Stump11289f42009-09-09 15:08:12 +0000593
Chris Lattner81b576e2006-08-11 02:13:20 +0000594 // This handles all of cast-expression, unary-expression, postfix-expression,
595 // and primary-expression. We handle them together like this for efficiency
596 // and to simplify handling of an expression starting with a '(' token: which
597 // may be one of a parenthesized expression, cast-expression, compound literal
598 // expression, or statement expression.
599 //
600 // If the parsed tokens consist of a primary-expression, the cases below
John McCallb268a282010-08-23 23:25:46 +0000601 // break out of the switch; at the end we call ParsePostfixExpressionSuffix
602 // to handle the postfix expression suffixes. Cases that cannot be followed
603 // by postfix exprs should return without invoking
604 // ParsePostfixExpressionSuffix.
Chris Lattnerae319692006-10-25 03:49:28 +0000605 switch (SavedKind) {
Chris Lattnere550a4e2006-08-24 06:37:51 +0000606 case tok::l_paren: {
Chris Lattner81b576e2006-08-11 02:13:20 +0000607 // If this expression is limited to being a unary-expression, the parent can
608 // not start a cast expression.
609 ParenParseOption ParenExprType =
Douglas Gregora49ccfe2010-08-06 14:50:36 +0000610 (isUnaryExpression && !getLang().CPlusPlus)? CompoundLiteral : CastExpr;
John McCallba7bf592010-08-24 05:47:05 +0000611 ParsedType CastTy;
Chris Lattnere550a4e2006-08-24 06:37:51 +0000612 SourceLocation RParenLoc;
Chris Lattner3c674cf2009-12-10 02:08:07 +0000613
614 {
Douglas Gregore9bba4f2010-09-15 14:51:05 +0000615 // The inside of the parens don't need to be a colon protected scope, and
616 // isn't immediately a message send.
Chris Lattner3c674cf2009-12-10 02:08:07 +0000617 ColonProtectionRAIIObject X(*this, false);
Douglas Gregore9bba4f2010-09-15 14:51:05 +0000618
Chris Lattner3c674cf2009-12-10 02:08:07 +0000619 Res = ParseParenExpression(ParenExprType, false/*stopIfCastExr*/,
620 TypeOfCast, CastTy, RParenLoc);
Chris Lattner3c674cf2009-12-10 02:08:07 +0000621 }
Mike Stump11289f42009-09-09 15:08:12 +0000622
Chris Lattner81b576e2006-08-11 02:13:20 +0000623 switch (ParenExprType) {
624 case SimpleExpr: break; // Nothing else to do.
625 case CompoundStmt: break; // Nothing else to do.
626 case CompoundLiteral:
627 // We parsed '(' type-name ')' '{' ... '}'. If any suffixes of
628 // postfix-expression exist, parse them now.
629 break;
630 case CastExpr:
Argyrios Kyrtzidis9a9c0f42009-05-22 10:23:40 +0000631 // We have parsed the cast-expression and no postfix-expr pieces are
632 // following.
Sebastian Redl59b5e512008-12-11 21:36:32 +0000633 return move(Res);
Chris Lattner81b576e2006-08-11 02:13:20 +0000634 }
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000635
John McCallb268a282010-08-23 23:25:46 +0000636 break;
Chris Lattnere550a4e2006-08-24 06:37:51 +0000637 }
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000638
Chris Lattner52a99e52006-08-10 20:56:00 +0000639 // primary-expression
Chris Lattner9b6d4cb2006-08-23 05:17:46 +0000640 case tok::numeric_constant:
641 // constant: integer-constant
642 // constant: floating-constant
Sebastian Redl59b5e512008-12-11 21:36:32 +0000643
Steve Naroff83895f72007-09-16 03:34:24 +0000644 Res = Actions.ActOnNumericConstant(Tok);
Chris Lattner9b6d4cb2006-08-23 05:17:46 +0000645 ConsumeToken();
John McCallb268a282010-08-23 23:25:46 +0000646 break;
Chris Lattner9b6d4cb2006-08-23 05:17:46 +0000647
Bill Wendling4073ed52007-02-13 01:51:42 +0000648 case tok::kw_true:
649 case tok::kw_false:
Sebastian Redld65cea82008-12-11 22:51:44 +0000650 return ParseCXXBoolLiteral();
Bill Wendling4073ed52007-02-13 01:51:42 +0000651
Sebastian Redl576fd422009-05-10 18:38:11 +0000652 case tok::kw_nullptr:
653 return Actions.ActOnCXXNullPtrLiteral(ConsumeToken());
654
Douglas Gregorda6c89d2011-04-27 06:18:01 +0000655 case tok::annot_primary_expr:
656 assert(Res.get() == 0 && "Stray primary-expression annotation?");
657 Res = getExprAnnotation(Tok);
658 ConsumeToken();
659 break;
660
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000661 case tok::identifier: { // primary-expression: identifier
662 // unqualified-id: identifier
663 // constant: enumeration-constant
Chris Lattnera8a3f732009-01-06 05:06:21 +0000664 // Turn a potentially qualified name into a annot_typename or
Chris Lattner122db262009-01-04 22:52:14 +0000665 // annot_cxxscope if it would be valid. This handles things like x::y, etc.
Chris Lattner9a8968b2009-01-04 23:23:14 +0000666 if (getLang().CPlusPlus) {
John McCall64fe2332010-01-07 19:29:58 +0000667 // Avoid the unnecessary parse-time lookup in the common case
668 // where the syntax forbids a type.
669 const Token &Next = NextToken();
670 if (Next.is(tok::coloncolon) ||
671 (!ColonIsSacred && Next.is(tok::colon)) ||
672 Next.is(tok::less) ||
673 Next.is(tok::l_paren)) {
674 // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse.
675 if (TryAnnotateTypeOrScopeToken())
John McCall1f476a12010-02-26 08:45:28 +0000676 return ExprError();
677 if (!Tok.is(tok::identifier))
John McCall64fe2332010-01-07 19:29:58 +0000678 return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
679 }
Chris Lattner9a8968b2009-01-04 23:23:14 +0000680 }
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000681
Chris Lattner55662902009-10-25 17:04:48 +0000682 // Consume the identifier so that we can see if it is followed by a '(' or
683 // '.'.
684 IdentifierInfo &II = *Tok.getIdentifierInfo();
685 SourceLocation ILoc = ConsumeToken();
686
Chris Lattnera36ec422010-04-11 08:28:14 +0000687 // Support 'Class.property' and 'super.property' notation.
Chris Lattner55662902009-10-25 17:04:48 +0000688 if (getLang().ObjC1 && Tok.is(tok::period) &&
Douglas Gregor0be31a22010-07-02 17:43:08 +0000689 (Actions.getTypeName(II, ILoc, getCurScope()) ||
Chris Lattnercd963182010-04-12 06:20:33 +0000690 // Allow the base to be 'super' if in an objc-method.
Douglas Gregor0be31a22010-07-02 17:43:08 +0000691 (&II == Ident_super && getCurScope()->isInObjcMethodScope()))) {
Jeffrey Yasskin8dfa5f12011-01-18 02:00:16 +0000692 ConsumeToken();
Chris Lattner55662902009-10-25 17:04:48 +0000693
Steve Naroff9527bbf2009-03-09 21:12:44 +0000694 if (Tok.isNot(tok::identifier)) {
Chris Lattner55662902009-10-25 17:04:48 +0000695 Diag(Tok, diag::err_expected_property_name);
Steve Naroff9527bbf2009-03-09 21:12:44 +0000696 return ExprError();
697 }
698 IdentifierInfo &PropertyName = *Tok.getIdentifierInfo();
699 SourceLocation PropertyLoc = ConsumeToken();
Chris Lattner55662902009-10-25 17:04:48 +0000700
701 Res = Actions.ActOnClassPropertyRefExpr(II, PropertyName,
702 ILoc, PropertyLoc);
John McCallb268a282010-08-23 23:25:46 +0000703 break;
Steve Naroff9527bbf2009-03-09 21:12:44 +0000704 }
John McCall8d08b9b2010-08-27 09:08:28 +0000705
Douglas Gregor7617c7d2010-09-15 15:09:43 +0000706 // In an Objective-C method, if we have "super" followed by an identifier,
Douglas Gregored0b69d2010-09-15 16:23:04 +0000707 // the token sequence is ill-formed. However, if there's a ':' or ']' after
Douglas Gregor7617c7d2010-09-15 15:09:43 +0000708 // that identifier, this is probably a message send with a missing open
Douglas Gregored0b69d2010-09-15 16:23:04 +0000709 // bracket. Treat it as such.
710 if (getLang().ObjC1 && &II == Ident_super && !InMessageExpression &&
Douglas Gregor7617c7d2010-09-15 15:09:43 +0000711 getCurScope()->isInObjcMethodScope() &&
Douglas Gregored0b69d2010-09-15 16:23:04 +0000712 ((Tok.is(tok::identifier) &&
713 (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) ||
714 Tok.is(tok::code_completion))) {
Douglas Gregor7617c7d2010-09-15 15:09:43 +0000715 Res = ParseObjCMessageExpressionBody(SourceLocation(), ILoc, ParsedType(),
716 0);
717 break;
718 }
719
Douglas Gregord39ae3e2011-02-15 19:17:31 +0000720 // If we have an Objective-C class name followed by an identifier
721 // and either ':' or ']', this is an Objective-C class message
722 // send that's missing the opening '['. Recovery
723 // appropriately. Also take this path if we're performing code
724 // completion after an Objective-C class name.
725 if (getLang().ObjC1 &&
726 ((Tok.is(tok::identifier) && !InMessageExpression) ||
727 Tok.is(tok::code_completion))) {
Douglas Gregorabf4a3e2010-09-16 01:51:54 +0000728 const Token& Next = NextToken();
Douglas Gregord39ae3e2011-02-15 19:17:31 +0000729 if (Tok.is(tok::code_completion) ||
730 Next.is(tok::colon) || Next.is(tok::r_square))
Gabor Greif433c9e12010-09-17 10:21:45 +0000731 if (ParsedType Typ = Actions.getTypeName(II, ILoc, getCurScope()))
732 if (Typ.get()->isObjCObjectOrInterfaceType()) {
Douglas Gregorabf4a3e2010-09-16 01:51:54 +0000733 // Fake up a Declarator to use with ActOnTypeName.
John McCall084e83d2011-03-24 11:26:52 +0000734 DeclSpec DS(AttrFactory);
Douglas Gregorabf4a3e2010-09-16 01:51:54 +0000735 DS.SetRangeStart(ILoc);
736 DS.SetRangeEnd(ILoc);
737 const char *PrevSpec = 0;
738 unsigned DiagID;
Gabor Greif433c9e12010-09-17 10:21:45 +0000739 DS.SetTypeSpecType(TST_typename, ILoc, PrevSpec, DiagID, Typ);
Douglas Gregorabf4a3e2010-09-16 01:51:54 +0000740
741 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
742 TypeResult Ty = Actions.ActOnTypeName(getCurScope(),
743 DeclaratorInfo);
744 if (Ty.isInvalid())
745 break;
746
747 Res = ParseObjCMessageExpressionBody(SourceLocation(),
748 SourceLocation(),
749 Ty.get(), 0);
750 break;
751 }
752 }
753
John McCall8d08b9b2010-08-27 09:08:28 +0000754 // Make sure to pass down the right value for isAddressOfOperand.
755 if (isAddressOfOperand && isPostfixExpressionSuffixStart())
756 isAddressOfOperand = false;
Chris Lattner55662902009-10-25 17:04:48 +0000757
Chris Lattnerac18be92006-11-20 06:49:47 +0000758 // Function designators are allowed to be undeclared (C99 6.5.1p2), so we
759 // need to know whether or not this identifier is a function designator or
760 // not.
Douglas Gregora121b752009-11-03 16:56:39 +0000761 UnqualifiedId Name;
762 CXXScopeSpec ScopeSpec;
763 Name.setIdentifier(&II, ILoc);
Douglas Gregor0be31a22010-07-02 17:43:08 +0000764 Res = Actions.ActOnIdExpression(getCurScope(), ScopeSpec, Name,
John McCall8d08b9b2010-08-27 09:08:28 +0000765 Tok.is(tok::l_paren), isAddressOfOperand);
John McCallb268a282010-08-23 23:25:46 +0000766 break;
Chris Lattnerac18be92006-11-20 06:49:47 +0000767 }
Chris Lattner52a99e52006-08-10 20:56:00 +0000768 case tok::char_constant: // constant: character-constant
Steve Naroff83895f72007-09-16 03:34:24 +0000769 Res = Actions.ActOnCharacterConstant(Tok);
Steve Naroffae4143e2007-04-26 20:39:23 +0000770 ConsumeToken();
John McCallb268a282010-08-23 23:25:46 +0000771 break;
Chris Lattner52a99e52006-08-10 20:56:00 +0000772 case tok::kw___func__: // primary-expression: __func__ [C99 6.4.2.2]
773 case tok::kw___FUNCTION__: // primary-expression: __FUNCTION__ [GNU]
774 case tok::kw___PRETTY_FUNCTION__: // primary-expression: __P..Y_F..N__ [GNU]
Chris Lattner6307f192008-08-10 01:53:14 +0000775 Res = Actions.ActOnPredefinedExpr(Tok.getLocation(), SavedKind);
Chris Lattner52a99e52006-08-10 20:56:00 +0000776 ConsumeToken();
John McCallb268a282010-08-23 23:25:46 +0000777 break;
Chris Lattner52a99e52006-08-10 20:56:00 +0000778 case tok::string_literal: // primary-expression: string-literal
Chris Lattnerd3e98952006-10-06 05:22:26 +0000779 case tok::wide_string_literal:
Chris Lattner89c50c62006-08-11 06:41:18 +0000780 Res = ParseStringLiteralExpression();
John McCallb268a282010-08-23 23:25:46 +0000781 break;
Peter Collingbourne91147592011-04-15 00:35:48 +0000782 case tok::kw__Generic: // primary-expression: generic-selection [C1X 6.5.1]
783 Res = ParseGenericSelectionExpression();
784 break;
Chris Lattnerf8339772006-08-10 22:01:51 +0000785 case tok::kw___builtin_va_arg:
786 case tok::kw___builtin_offsetof:
787 case tok::kw___builtin_choose_expr:
Tanya Lattner55808c12011-06-04 00:47:47 +0000788 case tok::kw___builtin_astype: // primary-expression: [OCL] as_type()
Sebastian Redl90893182008-12-11 22:33:27 +0000789 return ParseBuiltinPrimaryExpression();
Douglas Gregor3be4b122008-11-29 04:51:27 +0000790 case tok::kw___null:
Sebastian Redl6d4256c2009-03-15 17:47:39 +0000791 return Actions.ActOnGNUNullExpr(ConsumeToken());
Douglas Gregor3be4b122008-11-29 04:51:27 +0000792 break;
Douglas Gregora49ccfe2010-08-06 14:50:36 +0000793 case tok::plusplus: // unary-expression: '++' unary-expression [C99]
794 case tok::minusminus: { // unary-expression: '--' unary-expression [C99]
795 // C++ [expr.unary] has:
796 // unary-expression:
797 // ++ cast-expression
798 // -- cast-expression
Chris Lattner0ba3dc42006-10-25 03:38:23 +0000799 SourceLocation SavedLoc = ConsumeToken();
Douglas Gregora49ccfe2010-08-06 14:50:36 +0000800 Res = ParseCastExpression(!getLang().CPlusPlus);
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000801 if (!Res.isInvalid())
John McCallb268a282010-08-23 23:25:46 +0000802 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
Sebastian Redl59b5e512008-12-11 21:36:32 +0000803 return move(Res);
Chris Lattner0ba3dc42006-10-25 03:38:23 +0000804 }
Sebastian Redl3d3f75a2009-02-03 20:19:35 +0000805 case tok::amp: { // unary-expression: '&' cast-expression
806 // Special treatment because of member pointers
807 SourceLocation SavedLoc = ConsumeToken();
808 Res = ParseCastExpression(false, true);
809 if (!Res.isInvalid())
John McCallb268a282010-08-23 23:25:46 +0000810 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
Sebastian Redl3d3f75a2009-02-03 20:19:35 +0000811 return move(Res);
812 }
813
Chris Lattner81b576e2006-08-11 02:13:20 +0000814 case tok::star: // unary-expression: '*' cast-expression
815 case tok::plus: // unary-expression: '+' cast-expression
816 case tok::minus: // unary-expression: '-' cast-expression
817 case tok::tilde: // unary-expression: '~' cast-expression
818 case tok::exclaim: // unary-expression: '!' cast-expression
819 case tok::kw___real: // unary-expression: '__real' cast-expression [GNU]
Chris Lattnerc43926f2008-02-02 20:20:10 +0000820 case tok::kw___imag: { // unary-expression: '__imag' cast-expression [GNU]
Chris Lattner0ba3dc42006-10-25 03:38:23 +0000821 SourceLocation SavedLoc = ConsumeToken();
Chris Lattner1b926492006-08-23 06:42:10 +0000822 Res = ParseCastExpression(false);
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000823 if (!Res.isInvalid())
John McCallb268a282010-08-23 23:25:46 +0000824 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
Sebastian Redl59b5e512008-12-11 21:36:32 +0000825 return move(Res);
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000826 }
827
Chris Lattnerc43926f2008-02-02 20:20:10 +0000828 case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU]
829 // __extension__ silences extension warnings in the subexpression.
Chris Lattnerf02ef3e2008-10-20 06:45:43 +0000830 ExtensionRAIIObject O(Diags); // Use RAII to do this.
Chris Lattnerc43926f2008-02-02 20:20:10 +0000831 SourceLocation SavedLoc = ConsumeToken();
832 Res = ParseCastExpression(false);
Sebastian Redl17f2c7d2008-12-09 13:15:23 +0000833 if (!Res.isInvalid())
John McCallb268a282010-08-23 23:25:46 +0000834 Res = Actions.ActOnUnaryOp(getCurScope(), SavedLoc, SavedKind, Res.get());
Sebastian Redl59b5e512008-12-11 21:36:32 +0000835 return move(Res);
Chris Lattner0ba3dc42006-10-25 03:38:23 +0000836 }
Chris Lattner81b576e2006-08-11 02:13:20 +0000837 case tok::kw_sizeof: // unary-expression: 'sizeof' unary-expression
838 // unary-expression: 'sizeof' '(' type-name ')'
Douglas Gregord7fc8722008-11-06 15:17:27 +0000839 case tok::kw_alignof:
Chris Lattner81b576e2006-08-11 02:13:20 +0000840 case tok::kw___alignof: // unary-expression: '__alignof' unary-expression
841 // unary-expression: '__alignof' '(' type-name ')'
Douglas Gregord7fc8722008-11-06 15:17:27 +0000842 // unary-expression: 'alignof' '(' type-id ')'
Peter Collingbournee190dee2011-03-11 19:24:49 +0000843 case tok::kw_vec_step: // unary-expression: OpenCL 'vec_step' expression
844 return ParseUnaryExprOrTypeTraitExpression();
Chris Lattner0ba3dc42006-10-25 03:38:23 +0000845 case tok::ampamp: { // unary-expression: '&&' identifier
Chris Lattnereefa10e2007-05-28 06:56:27 +0000846 SourceLocation AmpAmpLoc = ConsumeToken();
Sebastian Redl59b5e512008-12-11 21:36:32 +0000847 if (Tok.isNot(tok::identifier))
848 return ExprError(Diag(Tok, diag::err_expected_ident));
Sebastian Redld9f7b1c2008-12-10 00:02:53 +0000849
Chris Lattner9ba479b2011-02-18 21:16:39 +0000850 if (getCurScope()->getFnParent() == 0)
851 return ExprError(Diag(Tok, diag::err_address_of_label_outside_fn));
852
Chris Lattnereefa10e2007-05-28 06:56:27 +0000853 Diag(AmpAmpLoc, diag::ext_gnu_address_of_label);
Chris Lattnerebb5c6c2011-02-18 01:27:55 +0000854 LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
855 Tok.getLocation());
856 Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(), LD);
Chris Lattner14a1b642006-10-15 22:33:58 +0000857 ConsumeToken();
Sebastian Redl59b5e512008-12-11 21:36:32 +0000858 return move(Res);
Chris Lattner0ba3dc42006-10-25 03:38:23 +0000859 }
Chris Lattner29375652006-12-04 18:06:35 +0000860 case tok::kw_const_cast:
861 case tok::kw_dynamic_cast:
862 case tok::kw_reinterpret_cast:
863 case tok::kw_static_cast:
Argyrios Kyrtzidis16d63a72008-08-16 19:45:32 +0000864 Res = ParseCXXCasts();
John McCallb268a282010-08-23 23:25:46 +0000865 break;
Sebastian Redlc4704762008-11-11 11:37:55 +0000866 case tok::kw_typeid:
867 Res = ParseCXXTypeid();
John McCallb268a282010-08-23 23:25:46 +0000868 break;
Francois Pichet9f4f2072010-09-08 12:20:18 +0000869 case tok::kw___uuidof:
870 Res = ParseCXXUuidof();
871 break;
Argyrios Kyrtzidis7bbb20e2008-06-24 22:12:16 +0000872 case tok::kw_this:
Argyrios Kyrtzidis37779ad2008-08-16 19:34:46 +0000873 Res = ParseCXXThis();
John McCallb268a282010-08-23 23:25:46 +0000874 break;
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000875
Douglas Gregorabf4a3e2010-09-16 01:51:54 +0000876 case tok::annot_typename:
877 if (isStartOfObjCClassMessageMissingOpenBracket()) {
878 ParsedType Type = getTypeAnnotation(Tok);
879
880 // Fake up a Declarator to use with ActOnTypeName.
John McCall084e83d2011-03-24 11:26:52 +0000881 DeclSpec DS(AttrFactory);
Douglas Gregorabf4a3e2010-09-16 01:51:54 +0000882 DS.SetRangeStart(Tok.getLocation());
883 DS.SetRangeEnd(Tok.getLastLoc());
884
885 const char *PrevSpec = 0;
886 unsigned DiagID;
Nico Weber77430342010-11-22 10:30:56 +0000887 DS.SetTypeSpecType(TST_typename, Tok.getAnnotationEndLoc(),
888 PrevSpec, DiagID, Type);
Douglas Gregorabf4a3e2010-09-16 01:51:54 +0000889
890 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
891 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
892 if (Ty.isInvalid())
893 break;
894
895 ConsumeToken();
896 Res = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(),
897 Ty.get(), 0);
898 break;
899 }
900 // Fall through
901
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000902 case tok::kw_char:
903 case tok::kw_wchar_t:
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +0000904 case tok::kw_char16_t:
905 case tok::kw_char32_t:
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000906 case tok::kw_bool:
907 case tok::kw_short:
908 case tok::kw_int:
909 case tok::kw_long:
Francois Pichet84133e42011-04-28 01:59:37 +0000910 case tok::kw___int64:
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000911 case tok::kw_signed:
912 case tok::kw_unsigned:
913 case tok::kw_float:
914 case tok::kw_double:
915 case tok::kw_void:
Douglas Gregor333489b2009-03-27 23:10:48 +0000916 case tok::kw_typename:
Chris Lattner8a38aa82009-01-04 22:28:21 +0000917 case tok::kw_typeof:
Douglas Gregorabf4a3e2010-09-16 01:51:54 +0000918 case tok::kw___vector: {
Chris Lattner8a38aa82009-01-04 22:28:21 +0000919 if (!getLang().CPlusPlus) {
920 Diag(Tok, diag::err_expected_expression);
921 return ExprError();
922 }
Eli Friedman6d692cc2009-06-11 00:33:41 +0000923
924 if (SavedKind == tok::kw_typename) {
925 // postfix-expression: typename-specifier '(' expression-list[opt] ')'
John McCall1f476a12010-02-26 08:45:28 +0000926 if (TryAnnotateTypeOrScopeToken())
Eli Friedman6d692cc2009-06-11 00:33:41 +0000927 return ExprError();
928 }
929
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000930 // postfix-expression: simple-type-specifier '(' expression-list[opt] ')'
931 //
John McCall084e83d2011-03-24 11:26:52 +0000932 DeclSpec DS(AttrFactory);
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000933 ParseCXXSimpleTypeSpecifier(DS);
934 if (Tok.isNot(tok::l_paren))
Sebastian Redl59b5e512008-12-11 21:36:32 +0000935 return ExprError(Diag(Tok, diag::err_expected_lparen_after_type)
936 << DS.getSourceRange());
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000937
938 Res = ParseCXXTypeConstructExpression(DS);
John McCallb268a282010-08-23 23:25:46 +0000939 break;
Argyrios Kyrtzidis857fcc22008-08-22 15:38:55 +0000940 }
941
Douglas Gregor7df89f52010-02-05 19:11:37 +0000942 case tok::annot_cxxscope: { // [C++] id-expression: qualified-id
Douglas Gregor2c4a7502010-04-23 02:08:13 +0000943 // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse.
944 // (We can end up in this situation after tentative parsing.)
945 if (TryAnnotateTypeOrScopeToken())
946 return ExprError();
947 if (!Tok.is(tok::annot_cxxscope))
948 return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
949 NotCastExpr, TypeOfCast);
950
Douglas Gregor7df89f52010-02-05 19:11:37 +0000951 Token Next = NextToken();
952 if (Next.is(tok::annot_template_id)) {
953 TemplateIdAnnotation *TemplateId
954 = static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue());
955 if (TemplateId->Kind == TNK_Type_template) {
956 // We have a qualified template-id that we know refers to a
957 // type, translate it into a type and continue parsing as a
958 // cast expression.
959 CXXScopeSpec SS;
John McCallba7bf592010-08-24 05:47:05 +0000960 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
Douglas Gregore7c20652011-03-02 00:47:37 +0000961 AnnotateTemplateIdTokenAsType();
Douglas Gregor7df89f52010-02-05 19:11:37 +0000962 return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
963 NotCastExpr, TypeOfCast);
964 }
965 }
966
967 // Parse as an id-expression.
968 Res = ParseCXXIdExpression(isAddressOfOperand);
John McCallb268a282010-08-23 23:25:46 +0000969 break;
Douglas Gregor7df89f52010-02-05 19:11:37 +0000970 }
971
972 case tok::annot_template_id: { // [C++] template-id
973 TemplateIdAnnotation *TemplateId
974 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
975 if (TemplateId->Kind == TNK_Type_template) {
976 // We have a template-id that we know refers to a type,
977 // translate it into a type and continue parsing as a cast
978 // expression.
979 AnnotateTemplateIdTokenAsType();
980 return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
981 NotCastExpr, TypeOfCast);
982 }
983
984 // Fall through to treat the template-id as an id-expression.
985 }
986
Argyrios Kyrtzidis32a03792008-11-08 16:45:02 +0000987 case tok::kw_operator: // [C++] id-expression: operator/conversion-function-id
Sebastian Redl3d3f75a2009-02-03 20:19:35 +0000988 Res = ParseCXXIdExpression(isAddressOfOperand);
John McCallb268a282010-08-23 23:25:46 +0000989 break;
Douglas Gregor11d0c4c2008-11-06 22:13:31 +0000990
Chris Lattner122db262009-01-04 22:52:14 +0000991 case tok::coloncolon: {
Chris Lattner8a7d10d2009-01-05 03:55:46 +0000992 // ::foo::bar -> global qualified name etc. If TryAnnotateTypeOrScopeToken
993 // annotates the token, tail recurse.
994 if (TryAnnotateTypeOrScopeToken())
John McCall1f476a12010-02-26 08:45:28 +0000995 return ExprError();
996 if (!Tok.is(tok::coloncolon))
Sebastian Redl3d3f75a2009-02-03 20:19:35 +0000997 return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
998
Chris Lattner122db262009-01-04 22:52:14 +0000999 // ::new -> [C++] new-expression
1000 // ::delete -> [C++] delete-expression
Chris Lattner8a7d10d2009-01-05 03:55:46 +00001001 SourceLocation CCLoc = ConsumeToken();
Chris Lattner109faf22009-01-04 21:25:24 +00001002 if (Tok.is(tok::kw_new))
Chris Lattner8a7d10d2009-01-05 03:55:46 +00001003 return ParseCXXNewExpression(true, CCLoc);
Chris Lattner122db262009-01-04 22:52:14 +00001004 if (Tok.is(tok::kw_delete))
Chris Lattner8a7d10d2009-01-05 03:55:46 +00001005 return ParseCXXDeleteExpression(true, CCLoc);
Mike Stump11289f42009-09-09 15:08:12 +00001006
Chris Lattner9a8968b2009-01-04 23:23:14 +00001007 // This is not a type name or scope specifier, it is an invalid expression.
Chris Lattner8a7d10d2009-01-05 03:55:46 +00001008 Diag(CCLoc, diag::err_expected_expression);
Chris Lattner9a8968b2009-01-04 23:23:14 +00001009 return ExprError();
Chris Lattner109faf22009-01-04 21:25:24 +00001010 }
Sebastian Redldb36b9b2008-12-02 16:35:44 +00001011
Sebastian Redlbd150f42008-11-21 19:14:01 +00001012 case tok::kw_new: // [C++] new-expression
Chris Lattner109faf22009-01-04 21:25:24 +00001013 return ParseCXXNewExpression(false, Tok.getLocation());
Sebastian Redlbd150f42008-11-21 19:14:01 +00001014
1015 case tok::kw_delete: // [C++] delete-expression
Chris Lattner109faf22009-01-04 21:25:24 +00001016 return ParseCXXDeleteExpression(false, Tok.getLocation());
Sebastian Redlbd150f42008-11-21 19:14:01 +00001017
Sebastian Redl22e3a932010-09-10 20:55:37 +00001018 case tok::kw_noexcept: { // [C++0x] 'noexcept' '(' expression ')'
1019 SourceLocation KeyLoc = ConsumeToken();
1020 SourceLocation LParen = Tok.getLocation();
1021 if (ExpectAndConsume(tok::l_paren,
1022 diag::err_expected_lparen_after, "noexcept"))
1023 return ExprError();
Sebastian Redle56be2f72010-09-10 21:57:27 +00001024 // C++ [expr.unary.noexcept]p1:
1025 // The noexcept operator determines whether the evaluation of its operand,
1026 // which is an unevaluated operand, can throw an exception.
1027 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
Sebastian Redl22e3a932010-09-10 20:55:37 +00001028 ExprResult Result = ParseExpression();
1029 SourceLocation RParen = MatchRHSPunctuation(tok::r_paren, LParen);
1030 if (!Result.isInvalid())
1031 Result = Actions.ActOnNoexceptExpr(KeyLoc, LParen, Result.take(), RParen);
1032 return move(Result);
1033 }
1034
Chandler Carruth79803482011-04-23 10:47:20 +00001035 case tok::kw___is_abstract: // [GNU] unary-type-trait
Sebastian Redlbaad4e72009-01-05 20:52:13 +00001036 case tok::kw___is_class:
Eli Friedmanc96d4962009-08-15 21:55:26 +00001037 case tok::kw___is_empty:
Chandler Carruth79803482011-04-23 10:47:20 +00001038 case tok::kw___is_enum:
Sebastian Redl79eba1c2009-12-03 00:13:20 +00001039 case tok::kw___is_literal:
John Wiegley65497cc2011-04-27 23:09:49 +00001040 case tok::kw___is_arithmetic:
1041 case tok::kw___is_integral:
1042 case tok::kw___is_floating_point:
1043 case tok::kw___is_complete_type:
1044 case tok::kw___is_void:
1045 case tok::kw___is_array:
1046 case tok::kw___is_function:
1047 case tok::kw___is_reference:
1048 case tok::kw___is_lvalue_reference:
1049 case tok::kw___is_rvalue_reference:
1050 case tok::kw___is_fundamental:
1051 case tok::kw___is_object:
1052 case tok::kw___is_scalar:
1053 case tok::kw___is_compound:
1054 case tok::kw___is_pointer:
1055 case tok::kw___is_member_object_pointer:
1056 case tok::kw___is_member_function_pointer:
1057 case tok::kw___is_member_pointer:
1058 case tok::kw___is_const:
1059 case tok::kw___is_volatile:
1060 case tok::kw___is_standard_layout:
1061 case tok::kw___is_signed:
1062 case tok::kw___is_unsigned:
Chandler Carruth65fa1fd2011-04-24 02:49:28 +00001063 case tok::kw___is_literal_type:
Chandler Carruth79803482011-04-23 10:47:20 +00001064 case tok::kw___is_pod:
1065 case tok::kw___is_polymorphic:
Chandler Carrutha3e1f9a2011-04-23 10:47:28 +00001066 case tok::kw___is_trivial:
Alexis Huntd9a5cc12011-05-13 00:31:07 +00001067 case tok::kw___is_trivially_copyable:
Chandler Carruth79803482011-04-23 10:47:20 +00001068 case tok::kw___is_union:
Anders Carlssonfe63dc52009-04-16 00:08:20 +00001069 case tok::kw___has_trivial_constructor:
Douglas Gregor79f83ed2009-07-23 23:49:00 +00001070 case tok::kw___has_trivial_copy:
1071 case tok::kw___has_trivial_assign:
Anders Carlsson6dc35752009-04-17 02:34:54 +00001072 case tok::kw___has_trivial_destructor:
Sebastian Redl7dcb1552010-08-31 04:59:00 +00001073 case tok::kw___has_nothrow_assign:
1074 case tok::kw___has_nothrow_copy:
1075 case tok::kw___has_nothrow_constructor:
Sebastian Redlb469afb2010-09-02 23:19:42 +00001076 case tok::kw___has_virtual_destructor:
Sebastian Redlbaad4e72009-01-05 20:52:13 +00001077 return ParseUnaryTypeTrait();
1078
Francois Pichet34b21132010-12-08 22:35:30 +00001079 case tok::kw___builtin_types_compatible_p:
Francois Pichet9dfa3ce2010-12-07 00:08:36 +00001080 case tok::kw___is_base_of:
John Wiegley65497cc2011-04-27 23:09:49 +00001081 case tok::kw___is_same:
1082 case tok::kw___is_convertible:
Douglas Gregor8006e762011-01-27 20:28:01 +00001083 case tok::kw___is_convertible_to:
Francois Pichet9dfa3ce2010-12-07 00:08:36 +00001084 return ParseBinaryTypeTrait();
1085
John Wiegley6242b6a2011-04-28 00:16:57 +00001086 case tok::kw___array_rank:
1087 case tok::kw___array_extent:
1088 return ParseArrayTypeTrait();
1089
John Wiegleyf9f65842011-04-25 06:54:41 +00001090 case tok::kw___is_lvalue_expr:
1091 case tok::kw___is_rvalue_expr:
1092 return ParseExpressionTrait();
1093
Chris Lattner644e1b72007-10-03 22:03:06 +00001094 case tok::at: {
1095 SourceLocation AtLoc = ConsumeToken();
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00001096 return ParseObjCAtExpression(AtLoc);
Chris Lattner644e1b72007-10-03 22:03:06 +00001097 }
Steve Naroff0ac012832008-08-28 19:20:44 +00001098 case tok::caret:
Chris Lattner9eac9312009-03-27 04:18:06 +00001099 return ParsePostfixExpressionSuffix(ParseBlockLiteralExpression());
Douglas Gregorbe9ea80a2010-04-06 15:09:27 +00001100 case tok::code_completion:
John McCallfaf5fb42010-08-26 23:41:50 +00001101 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
Douglas Gregor6da3db42010-05-25 05:58:43 +00001102 ConsumeCodeCompletionToken();
Douglas Gregorbe9ea80a2010-04-06 15:09:27 +00001103 return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
1104 NotCastExpr, TypeOfCast);
Chris Lattner6bf1db12008-12-12 19:20:14 +00001105 case tok::l_square:
1106 // These can be followed by postfix-expr pieces.
1107 if (getLang().ObjC1)
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00001108 return ParsePostfixExpressionSuffix(ParseObjCMessageExpression());
Douglas Gregorbe9ea80a2010-04-06 15:09:27 +00001109 // FALL THROUGH.
Chris Lattner52a99e52006-08-10 20:56:00 +00001110 default:
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00001111 NotCastExpr = true;
Sebastian Redl59b5e512008-12-11 21:36:32 +00001112 return ExprError();
Chris Lattnerf8339772006-08-10 22:01:51 +00001113 }
Sebastian Redl59b5e512008-12-11 21:36:32 +00001114
John McCallb268a282010-08-23 23:25:46 +00001115 // These can be followed by postfix-expr pieces.
Douglas Gregoreda7e542010-09-18 01:28:11 +00001116 return ParsePostfixExpressionSuffix(Res);
Chris Lattner20c6a452006-08-12 17:40:43 +00001117}
1118
1119/// ParsePostfixExpressionSuffix - Once the leading part of a postfix-expression
1120/// is parsed, this method parses any suffixes that apply.
1121///
1122/// postfix-expression: [C99 6.5.2]
1123/// primary-expression
1124/// postfix-expression '[' expression ']'
1125/// postfix-expression '(' argument-expression-list[opt] ')'
1126/// postfix-expression '.' identifier
1127/// postfix-expression '->' identifier
1128/// postfix-expression '++'
1129/// postfix-expression '--'
1130/// '(' type-name ')' '{' initializer-list '}'
1131/// '(' type-name ')' '{' initializer-list ',' '}'
1132///
1133/// argument-expression-list: [C99 6.5.2]
Douglas Gregor968f23a2011-01-03 19:31:53 +00001134/// argument-expression ...[opt]
1135/// argument-expression-list ',' assignment-expression ...[opt]
Chris Lattner20c6a452006-08-12 17:40:43 +00001136///
John McCalldadc5752010-08-24 06:29:42 +00001137ExprResult
1138Parser::ParsePostfixExpressionSuffix(ExprResult LHS) {
Chris Lattnerf8339772006-08-10 22:01:51 +00001139 // Now that the primary-expression piece of the postfix-expression has been
1140 // parsed, see if there are any postfix-expression pieces here.
1141 SourceLocation Loc;
1142 while (1) {
1143 switch (Tok.getKind()) {
Douglas Gregored0b69d2010-09-15 16:23:04 +00001144 case tok::code_completion:
1145 if (InMessageExpression)
1146 return move(LHS);
1147
Douglas Gregoreda7e542010-09-18 01:28:11 +00001148 Actions.CodeCompletePostfixExpression(getCurScope(), LHS);
Douglas Gregored0b69d2010-09-15 16:23:04 +00001149 ConsumeCodeCompletionToken();
1150 LHS = ExprError();
1151 break;
1152
Douglas Gregore9bba4f2010-09-15 14:51:05 +00001153 case tok::identifier:
1154 // If we see identifier: after an expression, and we're not already in a
1155 // message send, then this is probably a message send with a missing
1156 // opening bracket '['.
1157 if (getLang().ObjC1 && !InMessageExpression &&
Douglas Gregord6d98002010-09-15 14:54:45 +00001158 (NextToken().is(tok::colon) || NextToken().is(tok::r_square))) {
Douglas Gregore9bba4f2010-09-15 14:51:05 +00001159 LHS = ParseObjCMessageExpressionBody(SourceLocation(), SourceLocation(),
1160 ParsedType(), LHS.get());
1161 break;
1162 }
1163
1164 // Fall through; this isn't a message send.
1165
Chris Lattner20c6a452006-08-12 17:40:43 +00001166 default: // Not a postfix-expression suffix.
Sebastian Redl59b5e512008-12-11 21:36:32 +00001167 return move(LHS);
Chris Lattner6d28d9b2006-08-24 03:51:22 +00001168 case tok::l_square: { // postfix-expression: p-e '[' expression ']'
Chris Lattner47054fb2010-05-31 18:18:22 +00001169 // If we have a array postfix expression that starts on a new line and
1170 // Objective-C is enabled, it is highly likely that the user forgot a
1171 // semicolon after the base expression and that the array postfix-expr is
1172 // actually another message send. In this case, do some look-ahead to see
1173 // if the contents of the square brackets are obviously not a valid
1174 // expression and recover by pretending there is no suffix.
1175 if (getLang().ObjC1 && Tok.isAtStartOfLine() &&
1176 isSimpleObjCMessageExpression())
Douglas Gregor990ccac2010-05-31 14:40:22 +00001177 return move(LHS);
1178
Chris Lattner04132372006-10-16 06:12:55 +00001179 Loc = ConsumeBracket();
John McCalldadc5752010-08-24 06:29:42 +00001180 ExprResult Idx(ParseExpression());
Sebastian Redl511ed552008-11-25 22:21:31 +00001181
Chris Lattner6d28d9b2006-08-24 03:51:22 +00001182 SourceLocation RLoc = Tok.getLocation();
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001183
1184 if (!LHS.isInvalid() && !Idx.isInvalid() && Tok.is(tok::r_square)) {
John McCallb268a282010-08-23 23:25:46 +00001185 LHS = Actions.ActOnArraySubscriptExpr(getCurScope(), LHS.take(), Loc,
1186 Idx.take(), RLoc);
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001187 } else
Sebastian Redl59b5e512008-12-11 21:36:32 +00001188 LHS = ExprError();
Chris Lattner6d28d9b2006-08-24 03:51:22 +00001189
Chris Lattner89c50c62006-08-11 06:41:18 +00001190 // Match the ']'.
Chris Lattner04f80192006-08-15 04:55:54 +00001191 MatchRHSPunctuation(tok::r_square, Loc);
Chris Lattner89c50c62006-08-11 06:41:18 +00001192 break;
Chris Lattner6d28d9b2006-08-24 03:51:22 +00001193 }
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001194
Peter Collingbourne5eec5f02011-02-09 21:12:02 +00001195 case tok::l_paren: // p-e: p-e '(' argument-expression-list[opt] ')'
1196 case tok::lesslessless: { // p-e: p-e '<<<' argument-expression-list '>>>'
1197 // '(' argument-expression-list[opt] ')'
1198 tok::TokenKind OpKind = Tok.getKind();
Douglas Gregore9bba4f2010-09-15 14:51:05 +00001199 InMessageExpressionRAIIObject InMessage(*this, false);
1200
Peter Collingbourne5eec5f02011-02-09 21:12:02 +00001201 Expr *ExecConfig = 0;
1202
1203 if (OpKind == tok::lesslessless) {
1204 ExprVector ExecConfigExprs(Actions);
1205 CommaLocsTy ExecConfigCommaLocs;
1206 SourceLocation LLLLoc, GGGLoc;
1207
1208 LLLLoc = ConsumeToken();
1209
1210 if (ParseExpressionList(ExecConfigExprs, ExecConfigCommaLocs)) {
1211 LHS = ExprError();
1212 }
1213
1214 if (LHS.isInvalid()) {
1215 SkipUntil(tok::greatergreatergreater);
1216 } else if (Tok.isNot(tok::greatergreatergreater)) {
1217 MatchRHSPunctuation(tok::greatergreatergreater, LLLLoc);
1218 LHS = ExprError();
1219 } else {
1220 GGGLoc = ConsumeToken();
1221 }
1222
1223 if (!LHS.isInvalid()) {
1224 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen, ""))
1225 LHS = ExprError();
1226 else
1227 Loc = PrevTokLocation;
1228 }
1229
1230 if (!LHS.isInvalid()) {
1231 ExprResult ECResult = Actions.ActOnCUDAExecConfigExpr(getCurScope(),
1232 LLLLoc, move_arg(ExecConfigExprs), GGGLoc);
1233 if (ECResult.isInvalid())
1234 LHS = ExprError();
1235 else
1236 ExecConfig = ECResult.get();
1237 }
1238 } else {
1239 Loc = ConsumeParen();
1240 }
1241
Sebastian Redl511ed552008-11-25 22:21:31 +00001242 ExprVector ArgExprs(Actions);
Argyrios Kyrtzidis69af9ee2008-08-16 20:03:01 +00001243 CommaLocsTy CommaLocs;
Douglas Gregoreda7e542010-09-18 01:28:11 +00001244
Douglas Gregorcabea402009-09-22 15:41:20 +00001245 if (Tok.is(tok::code_completion)) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001246 Actions.CodeCompleteCall(getCurScope(), LHS.get(), 0, 0);
Douglas Gregor6da3db42010-05-25 05:58:43 +00001247 ConsumeCodeCompletionToken();
Douglas Gregorcabea402009-09-22 15:41:20 +00001248 }
Peter Collingbourne5eec5f02011-02-09 21:12:02 +00001249
1250 if (OpKind == tok::l_paren || !LHS.isInvalid()) {
1251 if (Tok.isNot(tok::r_paren)) {
1252 if (ParseExpressionList(ArgExprs, CommaLocs, &Sema::CodeCompleteCall,
1253 LHS.get())) {
1254 SkipUntil(tok::r_paren);
1255 LHS = ExprError();
1256 }
Chris Lattner0c6c0342006-08-12 18:12:45 +00001257 }
Chris Lattner89c50c62006-08-11 06:41:18 +00001258 }
Sebastian Redl59b5e512008-12-11 21:36:32 +00001259
Chris Lattner89c50c62006-08-11 06:41:18 +00001260 // Match the ')'.
Douglas Gregoreda7e542010-09-18 01:28:11 +00001261 if (LHS.isInvalid()) {
1262 SkipUntil(tok::r_paren);
1263 } else if (Tok.isNot(tok::r_paren)) {
Chris Lattner0d6c0612009-04-13 00:10:38 +00001264 MatchRHSPunctuation(tok::r_paren, Loc);
Douglas Gregoreda7e542010-09-18 01:28:11 +00001265 LHS = ExprError();
1266 } else {
1267 assert((ArgExprs.size() == 0 ||
1268 ArgExprs.size()-1 == CommaLocs.size())&&
Chris Lattnere165d942006-08-24 04:40:38 +00001269 "Unexpected number of commas!");
John McCallb268a282010-08-23 23:25:46 +00001270 LHS = Actions.ActOnCallExpr(getCurScope(), LHS.take(), Loc,
Peter Collingbourne5eec5f02011-02-09 21:12:02 +00001271 move_arg(ArgExprs), Tok.getLocation(),
1272 ExecConfig);
Douglas Gregoreda7e542010-09-18 01:28:11 +00001273 ConsumeParen();
Chris Lattnere165d942006-08-24 04:40:38 +00001274 }
Mike Stump11289f42009-09-09 15:08:12 +00001275
Chris Lattner89c50c62006-08-11 06:41:18 +00001276 break;
Chris Lattner6d28d9b2006-08-24 03:51:22 +00001277 }
Douglas Gregor308047d2009-09-09 00:23:06 +00001278 case tok::arrow:
1279 case tok::period: {
1280 // postfix-expression: p-e '->' template[opt] id-expression
1281 // postfix-expression: p-e '.' template[opt] id-expression
Chris Lattner6d28d9b2006-08-24 03:51:22 +00001282 tok::TokenKind OpKind = Tok.getKind();
Chris Lattneraf635312006-10-16 06:06:51 +00001283 SourceLocation OpLoc = ConsumeToken(); // Eat the "." or "->" token.
Sebastian Redl59b5e512008-12-11 21:36:32 +00001284
Douglas Gregord8061562009-08-06 03:17:00 +00001285 CXXScopeSpec SS;
John McCallba7bf592010-08-24 05:47:05 +00001286 ParsedType ObjectType;
Douglas Gregore610ada2010-02-24 18:44:31 +00001287 bool MayBePseudoDestructor = false;
Douglas Gregord8061562009-08-06 03:17:00 +00001288 if (getLang().CPlusPlus && !LHS.isInvalid()) {
John McCallb268a282010-08-23 23:25:46 +00001289 LHS = Actions.ActOnStartCXXMemberReference(getCurScope(), LHS.take(),
Douglas Gregore610ada2010-02-24 18:44:31 +00001290 OpLoc, OpKind, ObjectType,
1291 MayBePseudoDestructor);
Douglas Gregord8061562009-08-06 03:17:00 +00001292 if (LHS.isInvalid())
1293 break;
Douglas Gregore610ada2010-02-24 18:44:31 +00001294
Douglas Gregorcd3f49f2010-02-25 04:46:04 +00001295 ParseOptionalCXXScopeSpecifier(SS, ObjectType, false,
Douglas Gregore610ada2010-02-24 18:44:31 +00001296 &MayBePseudoDestructor);
Douglas Gregor205a3612010-05-27 15:25:59 +00001297 if (SS.isNotEmpty())
John McCallba7bf592010-08-24 05:47:05 +00001298 ObjectType = ParsedType();
Douglas Gregord8061562009-08-06 03:17:00 +00001299 }
1300
Douglas Gregor2436e712009-09-17 21:32:03 +00001301 if (Tok.is(tok::code_completion)) {
1302 // Code completion for a member access expression.
Douglas Gregor0be31a22010-07-02 17:43:08 +00001303 Actions.CodeCompleteMemberReferenceExpr(getCurScope(), LHS.get(),
Douglas Gregor2436e712009-09-17 21:32:03 +00001304 OpLoc, OpKind == tok::arrow);
1305
Douglas Gregor6da3db42010-05-25 05:58:43 +00001306 ConsumeCodeCompletionToken();
Douglas Gregor2436e712009-09-17 21:32:03 +00001307 }
1308
John McCallb268a282010-08-23 23:25:46 +00001309 if (MayBePseudoDestructor && !LHS.isInvalid()) {
1310 LHS = ParseCXXPseudoDestructor(LHS.take(), OpLoc, OpKind, SS,
Douglas Gregore610ada2010-02-24 18:44:31 +00001311 ObjectType);
1312 break;
1313 }
1314
1315 // Either the action has told is that this cannot be a
1316 // pseudo-destructor expression (based on the type of base
1317 // expression), or we didn't see a '~' in the right place. We
1318 // can still parse a destructor name here, but in that case it
1319 // names a real destructor.
Francois Pichet64225792011-01-18 05:04:39 +00001320 // Allow explicit constructor calls in Microsoft mode.
1321 // FIXME: Add support for explicit call of template constructor.
Douglas Gregor30d60cb2009-11-03 19:44:04 +00001322 UnqualifiedId Name;
1323 if (ParseUnqualifiedId(SS,
1324 /*EnteringContext=*/false,
1325 /*AllowDestructorName=*/true,
Francois Pichet64225792011-01-18 05:04:39 +00001326 /*AllowConstructorName=*/ getLang().Microsoft,
Douglas Gregor30d60cb2009-11-03 19:44:04 +00001327 ObjectType,
1328 Name))
Douglas Gregoreda7e542010-09-18 01:28:11 +00001329 LHS = ExprError();
Douglas Gregor30d60cb2009-11-03 19:44:04 +00001330
1331 if (!LHS.isInvalid())
John McCallb268a282010-08-23 23:25:46 +00001332 LHS = Actions.ActOnMemberAccessExpr(getCurScope(), LHS.take(), OpLoc,
Douglas Gregore610ada2010-02-24 18:44:31 +00001333 OpKind, SS, Name, ObjCImpDecl,
Douglas Gregor30d60cb2009-11-03 19:44:04 +00001334 Tok.is(tok::l_paren));
Chris Lattner89c50c62006-08-11 06:41:18 +00001335 break;
Chris Lattner6d28d9b2006-08-24 03:51:22 +00001336 }
Chris Lattner89c50c62006-08-11 06:41:18 +00001337 case tok::plusplus: // postfix-expression: postfix-expression '++'
1338 case tok::minusminus: // postfix-expression: postfix-expression '--'
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001339 if (!LHS.isInvalid()) {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001340 LHS = Actions.ActOnPostfixUnaryOp(getCurScope(), Tok.getLocation(),
John McCallb268a282010-08-23 23:25:46 +00001341 Tok.getKind(), LHS.take());
Sebastian Redl511ed552008-11-25 22:21:31 +00001342 }
Chris Lattner89c50c62006-08-11 06:41:18 +00001343 ConsumeToken();
1344 break;
Chris Lattnerf8339772006-08-10 22:01:51 +00001345 }
1346 }
Chris Lattner52a99e52006-08-10 20:56:00 +00001347}
1348
Peter Collingbournee190dee2011-03-11 19:24:49 +00001349/// ParseExprAfterUnaryExprOrTypeTrait - We parsed a typeof/sizeof/alignof/
1350/// vec_step and we are at the start of an expression or a parenthesized
1351/// type-id. OpTok is the operand token (typeof/sizeof/alignof). Returns the
1352/// expression (isCastExpr == false) or the type (isCastExpr == true).
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00001353///
1354/// unary-expression: [C99 6.5.3]
1355/// 'sizeof' unary-expression
1356/// 'sizeof' '(' type-name ')'
1357/// [GNU] '__alignof' unary-expression
1358/// [GNU] '__alignof' '(' type-name ')'
1359/// [C++0x] 'alignof' '(' type-id ')'
1360///
1361/// [GNU] typeof-specifier:
1362/// typeof ( expressions )
1363/// typeof ( type-name )
1364/// [GNU/C++] typeof unary-expression
1365///
Peter Collingbournee190dee2011-03-11 19:24:49 +00001366/// [OpenCL 1.1 6.11.12] vec_step built-in function:
1367/// vec_step ( expressions )
1368/// vec_step ( type-name )
1369///
John McCalldadc5752010-08-24 06:29:42 +00001370ExprResult
Peter Collingbournee190dee2011-03-11 19:24:49 +00001371Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok,
1372 bool &isCastExpr,
1373 ParsedType &CastTy,
1374 SourceRange &CastRange) {
Mike Stump11289f42009-09-09 15:08:12 +00001375
1376 assert((OpTok.is(tok::kw_typeof) || OpTok.is(tok::kw_sizeof) ||
Peter Collingbournee190dee2011-03-11 19:24:49 +00001377 OpTok.is(tok::kw___alignof) || OpTok.is(tok::kw_alignof) ||
1378 OpTok.is(tok::kw_vec_step)) &&
1379 "Not a typeof/sizeof/alignof/vec_step expression!");
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00001380
John McCalldadc5752010-08-24 06:29:42 +00001381 ExprResult Operand;
Mike Stump11289f42009-09-09 15:08:12 +00001382
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00001383 // If the operand doesn't start with an '(', it must be an expression.
1384 if (Tok.isNot(tok::l_paren)) {
1385 isCastExpr = false;
1386 if (OpTok.is(tok::kw_typeof) && !getLang().CPlusPlus) {
1387 Diag(Tok,diag::err_expected_lparen_after_id) << OpTok.getIdentifierInfo();
1388 return ExprError();
1389 }
Mike Stump11289f42009-09-09 15:08:12 +00001390
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00001391 // C++0x [expr.sizeof]p1:
Mike Stump11289f42009-09-09 15:08:12 +00001392 // [...] The operand is either an expression, which is an unevaluated
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00001393 // operand (Clause 5) [...]
1394 //
1395 // The GNU typeof and alignof extensions also behave as unevaluated
1396 // operands.
Douglas Gregor0b6a6242009-06-22 20:57:11 +00001397 EnterExpressionEvaluationContext Unevaluated(Actions,
John McCallfaf5fb42010-08-26 23:41:50 +00001398 Sema::Unevaluated);
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00001399 Operand = ParseCastExpression(true/*isUnaryExpression*/);
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00001400 } else {
1401 // If it starts with a '(', we know that it is either a parenthesized
1402 // type-name, or it is a unary-expression that starts with a compound
1403 // literal, or starts with a primary-expression that is a parenthesized
1404 // expression.
1405 ParenParseOption ExprType = CastExpr;
1406 SourceLocation LParenLoc = Tok.getLocation(), RParenLoc;
Mike Stump11289f42009-09-09 15:08:12 +00001407
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00001408 // C++0x [expr.sizeof]p1:
Mike Stump11289f42009-09-09 15:08:12 +00001409 // [...] The operand is either an expression, which is an unevaluated
Douglas Gregorc9c02ed2009-06-19 23:52:42 +00001410 // operand (Clause 5) [...]
1411 //
1412 // The GNU typeof and alignof extensions also behave as unevaluated
1413 // operands.
Douglas Gregor0b6a6242009-06-22 20:57:11 +00001414 EnterExpressionEvaluationContext Unevaluated(Actions,
John McCallfaf5fb42010-08-26 23:41:50 +00001415 Sema::Unevaluated);
Fariborz Jahanian906d8712009-11-25 01:26:41 +00001416 Operand = ParseParenExpression(ExprType, true/*stopIfCastExpr*/,
John McCallba7bf592010-08-24 05:47:05 +00001417 ParsedType(), CastTy, RParenLoc);
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00001418 CastRange = SourceRange(LParenLoc, RParenLoc);
1419
1420 // If ParseParenExpression parsed a '(typename)' sequence only, then this is
1421 // a type.
1422 if (ExprType == CastExpr) {
1423 isCastExpr = true;
1424 return ExprEmpty();
1425 }
1426
Douglas Gregor5dc05532010-07-28 18:22:12 +00001427 if (getLang().CPlusPlus || OpTok.isNot(tok::kw_typeof)) {
1428 // GNU typeof in C requires the expression to be parenthesized. Not so for
1429 // sizeof/alignof or in C++. Therefore, the parenthesized expression is
1430 // the start of a unary-expression, but doesn't include any postfix
1431 // pieces. Parse these now if present.
John McCall3669c802010-08-24 23:41:43 +00001432 if (!Operand.isInvalid())
1433 Operand = ParsePostfixExpressionSuffix(Operand.get());
Douglas Gregor5dc05532010-07-28 18:22:12 +00001434 }
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00001435 }
1436
1437 // If we get here, the operand to the typeof/sizeof/alignof was an expresion.
1438 isCastExpr = false;
1439 return move(Operand);
1440}
1441
Chris Lattner20c6a452006-08-12 17:40:43 +00001442
Peter Collingbournee190dee2011-03-11 19:24:49 +00001443/// ParseUnaryExprOrTypeTraitExpression - Parse a sizeof or alignof expression.
Chris Lattner81b576e2006-08-11 02:13:20 +00001444/// unary-expression: [C99 6.5.3]
1445/// 'sizeof' unary-expression
1446/// 'sizeof' '(' type-name ')'
Douglas Gregor820ba7b2011-01-04 17:33:58 +00001447/// [C++0x] 'sizeof' '...' '(' identifier ')'
Chris Lattner81b576e2006-08-11 02:13:20 +00001448/// [GNU] '__alignof' unary-expression
1449/// [GNU] '__alignof' '(' type-name ')'
Douglas Gregord7fc8722008-11-06 15:17:27 +00001450/// [C++0x] 'alignof' '(' type-id ')'
Peter Collingbournee190dee2011-03-11 19:24:49 +00001451ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() {
Douglas Gregord7fc8722008-11-06 15:17:27 +00001452 assert((Tok.is(tok::kw_sizeof) || Tok.is(tok::kw___alignof)
Peter Collingbournee190dee2011-03-11 19:24:49 +00001453 || Tok.is(tok::kw_alignof) || Tok.is(tok::kw_vec_step)) &&
1454 "Not a sizeof/alignof/vec_step expression!");
Chris Lattner146762e2007-07-20 16:59:19 +00001455 Token OpTok = Tok;
Chris Lattner81b576e2006-08-11 02:13:20 +00001456 ConsumeToken();
Mike Stump11289f42009-09-09 15:08:12 +00001457
Douglas Gregor820ba7b2011-01-04 17:33:58 +00001458 // [C++0x] 'sizeof' '...' '(' identifier ')'
1459 if (Tok.is(tok::ellipsis) && OpTok.is(tok::kw_sizeof)) {
1460 SourceLocation EllipsisLoc = ConsumeToken();
1461 SourceLocation LParenLoc, RParenLoc;
1462 IdentifierInfo *Name = 0;
1463 SourceLocation NameLoc;
1464 if (Tok.is(tok::l_paren)) {
1465 LParenLoc = ConsumeParen();
1466 if (Tok.is(tok::identifier)) {
1467 Name = Tok.getIdentifierInfo();
1468 NameLoc = ConsumeToken();
1469 RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
1470 if (RParenLoc.isInvalid())
1471 RParenLoc = PP.getLocForEndOfToken(NameLoc);
1472 } else {
1473 Diag(Tok, diag::err_expected_parameter_pack);
1474 SkipUntil(tok::r_paren);
1475 }
1476 } else if (Tok.is(tok::identifier)) {
1477 Name = Tok.getIdentifierInfo();
1478 NameLoc = ConsumeToken();
1479 LParenLoc = PP.getLocForEndOfToken(EllipsisLoc);
1480 RParenLoc = PP.getLocForEndOfToken(NameLoc);
1481 Diag(LParenLoc, diag::err_paren_sizeof_parameter_pack)
1482 << Name
1483 << FixItHint::CreateInsertion(LParenLoc, "(")
1484 << FixItHint::CreateInsertion(RParenLoc, ")");
1485 } else {
1486 Diag(Tok, diag::err_sizeof_parameter_pack);
1487 }
1488
1489 if (!Name)
1490 return ExprError();
1491
1492 return Actions.ActOnSizeofParameterPackExpr(getCurScope(),
1493 OpTok.getLocation(),
1494 *Name, NameLoc,
1495 RParenLoc);
1496 }
1497
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00001498 bool isCastExpr;
John McCallba7bf592010-08-24 05:47:05 +00001499 ParsedType CastTy;
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00001500 SourceRange CastRange;
Peter Collingbournee190dee2011-03-11 19:24:49 +00001501 ExprResult Operand = ParseExprAfterUnaryExprOrTypeTrait(OpTok,
1502 isCastExpr,
1503 CastTy,
1504 CastRange);
1505
1506 UnaryExprOrTypeTrait ExprKind = UETT_SizeOf;
1507 if (OpTok.is(tok::kw_alignof) || OpTok.is(tok::kw___alignof))
1508 ExprKind = UETT_AlignOf;
1509 else if (OpTok.is(tok::kw_vec_step))
1510 ExprKind = UETT_VecStep;
Sebastian Redl90893182008-12-11 22:33:27 +00001511
Argyrios Kyrtzidis7bd98442009-05-22 10:22:50 +00001512 if (isCastExpr)
Peter Collingbournee190dee2011-03-11 19:24:49 +00001513 return Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(),
1514 ExprKind,
1515 /*isType=*/true,
1516 CastTy.getAsOpaquePtr(),
1517 CastRange);
Sebastian Redl90893182008-12-11 22:33:27 +00001518
Chris Lattner26115ac2006-08-24 06:10:04 +00001519 // If we get here, the operand to the sizeof/alignof was an expresion.
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001520 if (!Operand.isInvalid())
Peter Collingbournee190dee2011-03-11 19:24:49 +00001521 Operand = Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(),
1522 ExprKind,
1523 /*isType=*/false,
1524 Operand.release(),
1525 CastRange);
Sebastian Redl90893182008-12-11 22:33:27 +00001526 return move(Operand);
Chris Lattner81b576e2006-08-11 02:13:20 +00001527}
1528
Chris Lattner11124352006-08-12 19:16:08 +00001529/// ParseBuiltinPrimaryExpression
1530///
1531/// primary-expression: [C99 6.5.1]
1532/// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
1533/// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
1534/// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
1535/// assign-expr ')'
1536/// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
Tanya Lattner55808c12011-06-04 00:47:47 +00001537/// [OCL] '__builtin_astype' '(' type-name expr ')'
Mike Stump11289f42009-09-09 15:08:12 +00001538///
Chris Lattner11124352006-08-12 19:16:08 +00001539/// [GNU] offsetof-member-designator:
1540/// [GNU] identifier
1541/// [GNU] offsetof-member-designator '.' identifier
1542/// [GNU] offsetof-member-designator '[' expression ']'
1543///
John McCalldadc5752010-08-24 06:29:42 +00001544ExprResult Parser::ParseBuiltinPrimaryExpression() {
1545 ExprResult Res;
Chris Lattner11124352006-08-12 19:16:08 +00001546 const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo();
1547
1548 tok::TokenKind T = Tok.getKind();
Chris Lattneraf635312006-10-16 06:06:51 +00001549 SourceLocation StartLoc = ConsumeToken(); // Eat the builtin identifier.
Chris Lattner11124352006-08-12 19:16:08 +00001550
1551 // All of these start with an open paren.
Sebastian Redl90893182008-12-11 22:33:27 +00001552 if (Tok.isNot(tok::l_paren))
1553 return ExprError(Diag(Tok, diag::err_expected_lparen_after_id)
1554 << BuiltinII);
1555
Chris Lattner04132372006-10-16 06:12:55 +00001556 SourceLocation LParenLoc = ConsumeParen();
Chris Lattner6d28d9b2006-08-24 03:51:22 +00001557 // TODO: Build AST.
1558
Chris Lattner11124352006-08-12 19:16:08 +00001559 switch (T) {
1560 default: assert(0 && "Not a builtin primary expression!");
Anders Carlsson7e13ab82007-10-15 20:28:48 +00001561 case tok::kw___builtin_va_arg: {
John McCalldadc5752010-08-24 06:29:42 +00001562 ExprResult Expr(ParseAssignmentExpression());
Chris Lattner0be454e2006-08-12 19:30:51 +00001563
Chris Lattner6d7e6342006-08-15 03:41:14 +00001564 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
Douglas Gregoreda7e542010-09-18 01:28:11 +00001565 Expr = ExprError();
Chris Lattner0be454e2006-08-12 19:30:51 +00001566
Douglas Gregor220cac52009-02-18 17:45:20 +00001567 TypeResult Ty = ParseTypeName();
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001568
Anders Carlsson7e13ab82007-10-15 20:28:48 +00001569 if (Tok.isNot(tok::r_paren)) {
1570 Diag(Tok, diag::err_expected_rparen);
Douglas Gregoreda7e542010-09-18 01:28:11 +00001571 Expr = ExprError();
Anders Carlsson7e13ab82007-10-15 20:28:48 +00001572 }
Douglas Gregoreda7e542010-09-18 01:28:11 +00001573
1574 if (Expr.isInvalid() || Ty.isInvalid())
Douglas Gregor220cac52009-02-18 17:45:20 +00001575 Res = ExprError();
1576 else
John McCallb268a282010-08-23 23:25:46 +00001577 Res = Actions.ActOnVAArg(StartLoc, Expr.take(), Ty.get(), ConsumeParen());
Chris Lattner11124352006-08-12 19:16:08 +00001578 break;
Anders Carlsson7e13ab82007-10-15 20:28:48 +00001579 }
Chris Lattner687d6092007-08-30 15:51:11 +00001580 case tok::kw___builtin_offsetof: {
Chris Lattnere4ee2df2007-08-30 17:08:45 +00001581 SourceLocation TypeLoc = Tok.getLocation();
Douglas Gregor220cac52009-02-18 17:45:20 +00001582 TypeResult Ty = ParseTypeName();
Chris Lattnerf37e09e2009-03-24 17:21:43 +00001583 if (Ty.isInvalid()) {
1584 SkipUntil(tok::r_paren);
1585 return ExprError();
1586 }
Mike Stump11289f42009-09-09 15:08:12 +00001587
Chris Lattner6d7e6342006-08-15 03:41:14 +00001588 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
Sebastian Redl90893182008-12-11 22:33:27 +00001589 return ExprError();
1590
Chris Lattner11124352006-08-12 19:16:08 +00001591 // We must have at least one identifier here.
Chris Lattnerfeb00b62007-10-09 17:41:39 +00001592 if (Tok.isNot(tok::identifier)) {
Chris Lattner687d6092007-08-30 15:51:11 +00001593 Diag(Tok, diag::err_expected_ident);
1594 SkipUntil(tok::r_paren);
Sebastian Redl90893182008-12-11 22:33:27 +00001595 return ExprError();
Chris Lattner687d6092007-08-30 15:51:11 +00001596 }
Sebastian Redl90893182008-12-11 22:33:27 +00001597
Chris Lattner687d6092007-08-30 15:51:11 +00001598 // Keep track of the various subcomponents we see.
John McCallfaf5fb42010-08-26 23:41:50 +00001599 llvm::SmallVector<Sema::OffsetOfComponent, 4> Comps;
Sebastian Redl90893182008-12-11 22:33:27 +00001600
John McCallfaf5fb42010-08-26 23:41:50 +00001601 Comps.push_back(Sema::OffsetOfComponent());
Chris Lattner687d6092007-08-30 15:51:11 +00001602 Comps.back().isBrackets = false;
1603 Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
1604 Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken();
Chris Lattnerdbb2a462006-08-12 19:26:13 +00001605
Sebastian Redl511ed552008-11-25 22:21:31 +00001606 // FIXME: This loop leaks the index expressions on error.
Chris Lattner11124352006-08-12 19:16:08 +00001607 while (1) {
Chris Lattnerfeb00b62007-10-09 17:41:39 +00001608 if (Tok.is(tok::period)) {
Chris Lattner11124352006-08-12 19:16:08 +00001609 // offsetof-member-designator: offsetof-member-designator '.' identifier
John McCallfaf5fb42010-08-26 23:41:50 +00001610 Comps.push_back(Sema::OffsetOfComponent());
Chris Lattner687d6092007-08-30 15:51:11 +00001611 Comps.back().isBrackets = false;
1612 Comps.back().LocStart = ConsumeToken();
Sebastian Redl90893182008-12-11 22:33:27 +00001613
Chris Lattnerfeb00b62007-10-09 17:41:39 +00001614 if (Tok.isNot(tok::identifier)) {
Chris Lattner687d6092007-08-30 15:51:11 +00001615 Diag(Tok, diag::err_expected_ident);
1616 SkipUntil(tok::r_paren);
Sebastian Redl90893182008-12-11 22:33:27 +00001617 return ExprError();
Chris Lattner687d6092007-08-30 15:51:11 +00001618 }
1619 Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
1620 Comps.back().LocEnd = ConsumeToken();
Sebastian Redl90893182008-12-11 22:33:27 +00001621
Chris Lattnerfeb00b62007-10-09 17:41:39 +00001622 } else if (Tok.is(tok::l_square)) {
Chris Lattner11124352006-08-12 19:16:08 +00001623 // offsetof-member-designator: offsetof-member-design '[' expression ']'
John McCallfaf5fb42010-08-26 23:41:50 +00001624 Comps.push_back(Sema::OffsetOfComponent());
Chris Lattner687d6092007-08-30 15:51:11 +00001625 Comps.back().isBrackets = true;
1626 Comps.back().LocStart = ConsumeBracket();
Chris Lattner11124352006-08-12 19:16:08 +00001627 Res = ParseExpression();
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001628 if (Res.isInvalid()) {
Chris Lattner11124352006-08-12 19:16:08 +00001629 SkipUntil(tok::r_paren);
Sebastian Redl90893182008-12-11 22:33:27 +00001630 return move(Res);
Chris Lattner11124352006-08-12 19:16:08 +00001631 }
Sebastian Redld9f7b1c2008-12-10 00:02:53 +00001632 Comps.back().U.E = Res.release();
Chris Lattner11124352006-08-12 19:16:08 +00001633
Chris Lattner687d6092007-08-30 15:51:11 +00001634 Comps.back().LocEnd =
1635 MatchRHSPunctuation(tok::r_square, Comps.back().LocStart);
Eli Friedman5e774b12009-06-27 20:38:33 +00001636 } else {
1637 if (Tok.isNot(tok::r_paren)) {
1638 MatchRHSPunctuation(tok::r_paren, LParenLoc);
Douglas Gregor220cac52009-02-18 17:45:20 +00001639 Res = ExprError();
Eli Friedman5e774b12009-06-27 20:38:33 +00001640 } else if (Ty.isInvalid()) {
1641 Res = ExprError();
1642 } else {
Douglas Gregor0be31a22010-07-02 17:43:08 +00001643 Res = Actions.ActOnBuiltinOffsetOf(getCurScope(), StartLoc, TypeLoc,
Mike Stump11289f42009-09-09 15:08:12 +00001644 Ty.get(), &Comps[0],
Douglas Gregor220cac52009-02-18 17:45:20 +00001645 Comps.size(), ConsumeParen());
Eli Friedman5e774b12009-06-27 20:38:33 +00001646 }
Chris Lattner5ad4f462007-08-30 15:52:49 +00001647 break;
Chris Lattner11124352006-08-12 19:16:08 +00001648 }
1649 }
1650 break;
Chris Lattner687d6092007-08-30 15:51:11 +00001651 }
Steve Naroff9efdabc2007-08-03 21:21:27 +00001652 case tok::kw___builtin_choose_expr: {
John McCalldadc5752010-08-24 06:29:42 +00001653 ExprResult Cond(ParseAssignmentExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001654 if (Cond.isInvalid()) {
Steve Naroff9efdabc2007-08-03 21:21:27 +00001655 SkipUntil(tok::r_paren);
Sebastian Redl90893182008-12-11 22:33:27 +00001656 return move(Cond);
Steve Naroff9efdabc2007-08-03 21:21:27 +00001657 }
Chris Lattner6d7e6342006-08-15 03:41:14 +00001658 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
Sebastian Redl90893182008-12-11 22:33:27 +00001659 return ExprError();
1660
John McCalldadc5752010-08-24 06:29:42 +00001661 ExprResult Expr1(ParseAssignmentExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001662 if (Expr1.isInvalid()) {
Steve Naroff9efdabc2007-08-03 21:21:27 +00001663 SkipUntil(tok::r_paren);
Sebastian Redl90893182008-12-11 22:33:27 +00001664 return move(Expr1);
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001665 }
Chris Lattner6d7e6342006-08-15 03:41:14 +00001666 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
Sebastian Redl90893182008-12-11 22:33:27 +00001667 return ExprError();
1668
John McCalldadc5752010-08-24 06:29:42 +00001669 ExprResult Expr2(ParseAssignmentExpression());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001670 if (Expr2.isInvalid()) {
Steve Naroff9efdabc2007-08-03 21:21:27 +00001671 SkipUntil(tok::r_paren);
Sebastian Redl90893182008-12-11 22:33:27 +00001672 return move(Expr2);
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001673 }
Chris Lattnerfeb00b62007-10-09 17:41:39 +00001674 if (Tok.isNot(tok::r_paren)) {
Steve Naroff9efdabc2007-08-03 21:21:27 +00001675 Diag(Tok, diag::err_expected_rparen);
Sebastian Redl90893182008-12-11 22:33:27 +00001676 return ExprError();
Steve Naroff9efdabc2007-08-03 21:21:27 +00001677 }
John McCallb268a282010-08-23 23:25:46 +00001678 Res = Actions.ActOnChooseExpr(StartLoc, Cond.take(), Expr1.take(),
1679 Expr2.take(), ConsumeParen());
Chris Lattner5ad4f462007-08-30 15:52:49 +00001680 break;
Steve Naroff9efdabc2007-08-03 21:21:27 +00001681 }
Tanya Lattner55808c12011-06-04 00:47:47 +00001682 case tok::kw___builtin_astype: {
1683 // The first argument is an expression to be converted, followed by a comma.
1684 ExprResult Expr(ParseAssignmentExpression());
1685 if (Expr.isInvalid()) {
1686 SkipUntil(tok::r_paren);
1687 return ExprError();
1688 }
1689
1690 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",
1691 tok::r_paren))
1692 return ExprError();
1693
1694 // Second argument is the type to bitcast to.
1695 TypeResult DestTy = ParseTypeName();
1696 if (DestTy.isInvalid())
1697 return ExprError();
1698
1699 // Attempt to consume the r-paren.
1700 if (Tok.isNot(tok::r_paren)) {
1701 Diag(Tok, diag::err_expected_rparen);
1702 SkipUntil(tok::r_paren);
1703 return ExprError();
1704 }
1705
1706 Res = Actions.ActOnAsTypeExpr(Expr.take(), DestTy.get(), StartLoc,
1707 ConsumeParen());
1708 break;
Sebastian Redl59b5e512008-12-11 21:36:32 +00001709 }
Tanya Lattner55808c12011-06-04 00:47:47 +00001710}
Sebastian Redl59b5e512008-12-11 21:36:32 +00001711
John McCallb268a282010-08-23 23:25:46 +00001712 if (Res.isInvalid())
1713 return ExprError();
1714
Chris Lattner11124352006-08-12 19:16:08 +00001715 // These can be followed by postfix-expr pieces because they are
1716 // primary-expressions.
John McCallb268a282010-08-23 23:25:46 +00001717 return ParsePostfixExpressionSuffix(Res.take());
Chris Lattner11124352006-08-12 19:16:08 +00001718}
1719
Chris Lattner4add4e62006-08-11 01:33:00 +00001720/// ParseParenExpression - This parses the unit that starts with a '(' token,
1721/// based on what is allowed by ExprType. The actual thing parsed is returned
Argyrios Kyrtzidis9a9c0f42009-05-22 10:23:40 +00001722/// in ExprType. If stopIfCastExpr is true, it will only return the parsed type,
1723/// not the parsed cast-expression.
Chris Lattner4add4e62006-08-11 01:33:00 +00001724///
1725/// primary-expression: [C99 6.5.1]
Chris Lattnerc951dae2006-08-10 04:23:57 +00001726/// '(' expression ')'
Chris Lattnerf8339772006-08-10 22:01:51 +00001727/// [GNU] '(' compound-statement ')' (if !ParenExprOnly)
1728/// postfix-expression: [C99 6.5.2]
1729/// '(' type-name ')' '{' initializer-list '}'
1730/// '(' type-name ')' '{' initializer-list ',' '}'
Chris Lattner4add4e62006-08-11 01:33:00 +00001731/// cast-expression: [C99 6.5.4]
1732/// '(' type-name ')' cast-expression
Chris Lattnerf8339772006-08-10 22:01:51 +00001733///
John McCalldadc5752010-08-24 06:29:42 +00001734ExprResult
Argyrios Kyrtzidis9a9c0f42009-05-22 10:23:40 +00001735Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr,
John McCallba7bf592010-08-24 05:47:05 +00001736 ParsedType TypeOfCast, ParsedType &CastTy,
Nate Begeman5ec4b312009-08-10 23:49:36 +00001737 SourceLocation &RParenLoc) {
Chris Lattnerfeb00b62007-10-09 17:41:39 +00001738 assert(Tok.is(tok::l_paren) && "Not a paren expr!");
Douglas Gregor0db4ccd2009-02-09 21:04:56 +00001739 GreaterThanIsOperatorScope G(GreaterThanIsOperator, true);
Chris Lattner04132372006-10-16 06:12:55 +00001740 SourceLocation OpenLoc = ConsumeParen();
John McCalldadc5752010-08-24 06:29:42 +00001741 ExprResult Result(true);
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00001742 bool isAmbiguousTypeId;
John McCallba7bf592010-08-24 05:47:05 +00001743 CastTy = ParsedType();
Sebastian Redl90893182008-12-11 22:33:27 +00001744
Douglas Gregor5e35d592010-09-14 23:59:36 +00001745 if (Tok.is(tok::code_completion)) {
1746 Actions.CodeCompleteOrdinaryName(getCurScope(),
1747 ExprType >= CompoundLiteral? Sema::PCC_ParenthesizedExpression
1748 : Sema::PCC_Expression);
1749 ConsumeCodeCompletionToken();
1750 return ExprError();
1751 }
John McCallc5e6b972011-04-06 02:35:25 +00001752
1753 // None of these cases should fall through with an invalid Result
1754 // unless they've already reported an error.
Douglas Gregor5e35d592010-09-14 23:59:36 +00001755
Chris Lattnerfeb00b62007-10-09 17:41:39 +00001756 if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) {
Chris Lattnerf8339772006-08-10 22:01:51 +00001757 Diag(Tok, diag::ext_gnu_statement_expr);
John McCall084e83d2011-03-24 11:26:52 +00001758 ParsedAttributes attrs(AttrFactory);
John McCall53fa7142010-12-24 02:08:15 +00001759 StmtResult Stmt(ParseCompoundStatement(attrs, true));
Chris Lattner4add4e62006-08-11 01:33:00 +00001760 ExprType = CompoundStmt;
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001761
Chris Lattner366727f2007-07-24 16:58:17 +00001762 // If the substmt parsed correctly, build the AST node.
John McCallc5e6b972011-04-06 02:35:25 +00001763 if (!Stmt.isInvalid())
John McCallb268a282010-08-23 23:25:46 +00001764 Result = Actions.ActOnStmtExpr(OpenLoc, Stmt.take(), Tok.getLocation());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001765
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00001766 } else if (ExprType >= CompoundLiteral &&
1767 isTypeIdInParens(isAmbiguousTypeId)) {
Mike Stump11289f42009-09-09 15:08:12 +00001768
Chris Lattner6c3f05d2006-08-12 16:54:25 +00001769 // Otherwise, this is a compound literal expression or cast expression.
Mike Stump11289f42009-09-09 15:08:12 +00001770
Argyrios Kyrtzidis12179bc2009-05-22 10:24:42 +00001771 // In C++, if the type-id is ambiguous we disambiguate based on context.
1772 // If stopIfCastExpr is true the context is a typeof/sizeof/alignof
1773 // in which case we should treat it as type-id.
1774 // if stopIfCastExpr is false, we need to determine the context past the
1775 // parens, so we defer to ParseCXXAmbiguousParenExpression for that.
1776 if (isAmbiguousTypeId && !stopIfCastExpr)
1777 return ParseCXXAmbiguousParenExpression(ExprType, CastTy,
1778 OpenLoc, RParenLoc);
Mike Stump11289f42009-09-09 15:08:12 +00001779
Douglas Gregore9bba4f2010-09-15 14:51:05 +00001780 TypeResult Ty;
1781
1782 {
1783 InMessageExpressionRAIIObject InMessage(*this, false);
1784 Ty = ParseTypeName();
1785 }
1786
Douglas Gregor3e972002010-09-15 23:19:31 +00001787 // If our type is followed by an identifier and either ':' or ']', then
1788 // this is probably an Objective-C message send where the leading '[' is
1789 // missing. Recover as if that were the case.
1790 if (!Ty.isInvalid() && Tok.is(tok::identifier) && !InMessageExpression &&
1791 getLang().ObjC1 && !Ty.get().get().isNull() &&
1792 (NextToken().is(tok::colon) || NextToken().is(tok::r_square)) &&
1793 Ty.get().get()->isObjCObjectOrInterfaceType()) {
1794 Result = ParseObjCMessageExpressionBody(SourceLocation(),
1795 SourceLocation(),
1796 Ty.get(), 0);
1797 } else {
1798 // Match the ')'.
1799 if (Tok.is(tok::r_paren))
1800 RParenLoc = ConsumeParen();
1801 else
1802 MatchRHSPunctuation(tok::r_paren, OpenLoc);
Sebastian Redl90893182008-12-11 22:33:27 +00001803
Douglas Gregor3e972002010-09-15 23:19:31 +00001804 if (Tok.is(tok::l_brace)) {
1805 ExprType = CompoundLiteral;
1806 return ParseCompoundLiteralExpression(Ty.get(), OpenLoc, RParenLoc);
Chris Lattnera36ec422010-04-11 08:28:14 +00001807 }
Argyrios Kyrtzidis9a9c0f42009-05-22 10:23:40 +00001808
Douglas Gregor3e972002010-09-15 23:19:31 +00001809 if (ExprType == CastExpr) {
1810 // We parsed '(' type-name ')' and the thing after it wasn't a '{'.
Sebastian Redlb5d49352009-01-19 22:31:54 +00001811
Douglas Gregor3e972002010-09-15 23:19:31 +00001812 if (Ty.isInvalid())
1813 return ExprError();
1814
1815 CastTy = Ty.get();
1816
1817 // Note that this doesn't parse the subsequent cast-expression, it just
1818 // returns the parsed type to the callee.
1819 if (stopIfCastExpr)
1820 return ExprResult();
1821
1822 // Reject the cast of super idiom in ObjC.
1823 if (Tok.is(tok::identifier) && getLang().ObjC1 &&
1824 Tok.getIdentifierInfo() == Ident_super &&
1825 getCurScope()->isInObjcMethodScope() &&
1826 GetLookAheadToken(1).isNot(tok::period)) {
1827 Diag(Tok.getLocation(), diag::err_illegal_super_cast)
1828 << SourceRange(OpenLoc, RParenLoc);
1829 return ExprError();
1830 }
1831
1832 // Parse the cast-expression that follows it next.
1833 // TODO: For cast expression with CastTy.
1834 Result = ParseCastExpression(false, false, CastTy);
1835 if (!Result.isInvalid())
1836 Result = Actions.ActOnCastExpr(getCurScope(), OpenLoc, CastTy,
1837 RParenLoc, Result.take());
1838 return move(Result);
1839 }
1840
1841 Diag(Tok, diag::err_expected_lbrace_in_compound_literal);
1842 return ExprError();
1843 }
Fariborz Jahanian906d8712009-11-25 01:26:41 +00001844 } else if (TypeOfCast) {
Nate Begeman5ec4b312009-08-10 23:49:36 +00001845 // Parse the expression-list.
Douglas Gregore9bba4f2010-09-15 14:51:05 +00001846 InMessageExpressionRAIIObject InMessage(*this, false);
1847
Nate Begeman5ec4b312009-08-10 23:49:36 +00001848 ExprVector ArgExprs(Actions);
1849 CommaLocsTy CommaLocs;
1850
1851 if (!ParseExpressionList(ArgExprs, CommaLocs)) {
1852 ExprType = SimpleExpr;
Fariborz Jahanian906d8712009-11-25 01:26:41 +00001853 Result = Actions.ActOnParenOrParenListExpr(OpenLoc, Tok.getLocation(),
1854 move_arg(ArgExprs), TypeOfCast);
Nate Begeman5ec4b312009-08-10 23:49:36 +00001855 }
Chris Lattner4add4e62006-08-11 01:33:00 +00001856 } else {
Douglas Gregore9bba4f2010-09-15 14:51:05 +00001857 InMessageExpressionRAIIObject InMessage(*this, false);
1858
Chris Lattner89c50c62006-08-11 06:41:18 +00001859 Result = ParseExpression();
Chris Lattner4add4e62006-08-11 01:33:00 +00001860 ExprType = SimpleExpr;
John McCallc5e6b972011-04-06 02:35:25 +00001861
1862 // Don't build a paren expression unless we actually match a ')'.
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00001863 if (!Result.isInvalid() && Tok.is(tok::r_paren))
John McCallb268a282010-08-23 23:25:46 +00001864 Result = Actions.ActOnParenExpr(OpenLoc, Tok.getLocation(), Result.take());
Chris Lattnerf8339772006-08-10 22:01:51 +00001865 }
Sebastian Redl90893182008-12-11 22:33:27 +00001866
Chris Lattner4564bc12006-08-10 23:14:52 +00001867 // Match the ')'.
Chris Lattnerd8980502008-12-12 06:00:12 +00001868 if (Result.isInvalid()) {
Chris Lattner89c50c62006-08-11 06:41:18 +00001869 SkipUntil(tok::r_paren);
Chris Lattnerd8980502008-12-12 06:00:12 +00001870 return ExprError();
Chris Lattnere550a4e2006-08-24 06:37:51 +00001871 }
Mike Stump11289f42009-09-09 15:08:12 +00001872
Chris Lattnerd8980502008-12-12 06:00:12 +00001873 if (Tok.is(tok::r_paren))
1874 RParenLoc = ConsumeParen();
1875 else
1876 MatchRHSPunctuation(tok::r_paren, OpenLoc);
Sebastian Redl90893182008-12-11 22:33:27 +00001877
1878 return move(Result);
Chris Lattnerc951dae2006-08-10 04:23:57 +00001879}
Chris Lattnerd3e98952006-10-06 05:22:26 +00001880
Argyrios Kyrtzidis5da1f082009-05-22 10:24:05 +00001881/// ParseCompoundLiteralExpression - We have parsed the parenthesized type-name
1882/// and we are at the left brace.
1883///
1884/// postfix-expression: [C99 6.5.2]
1885/// '(' type-name ')' '{' initializer-list '}'
1886/// '(' type-name ')' '{' initializer-list ',' '}'
1887///
John McCalldadc5752010-08-24 06:29:42 +00001888ExprResult
John McCallba7bf592010-08-24 05:47:05 +00001889Parser::ParseCompoundLiteralExpression(ParsedType Ty,
Argyrios Kyrtzidis5da1f082009-05-22 10:24:05 +00001890 SourceLocation LParenLoc,
1891 SourceLocation RParenLoc) {
1892 assert(Tok.is(tok::l_brace) && "Not a compound literal!");
1893 if (!getLang().C99) // Compound literals don't exist in C90.
1894 Diag(LParenLoc, diag::ext_c99_compound_literal);
John McCalldadc5752010-08-24 06:29:42 +00001895 ExprResult Result = ParseInitializer();
Argyrios Kyrtzidis5da1f082009-05-22 10:24:05 +00001896 if (!Result.isInvalid() && Ty)
John McCallb268a282010-08-23 23:25:46 +00001897 return Actions.ActOnCompoundLiteral(LParenLoc, Ty, RParenLoc, Result.take());
Argyrios Kyrtzidis5da1f082009-05-22 10:24:05 +00001898 return move(Result);
1899}
1900
Chris Lattnerd3e98952006-10-06 05:22:26 +00001901/// ParseStringLiteralExpression - This handles the various token types that
1902/// form string literals, and also handles string concatenation [C99 5.1.1.2,
1903/// translation phase #6].
1904///
1905/// primary-expression: [C99 6.5.1]
1906/// string-literal
John McCalldadc5752010-08-24 06:29:42 +00001907ExprResult Parser::ParseStringLiteralExpression() {
Chris Lattnerd3e98952006-10-06 05:22:26 +00001908 assert(isTokenStringLiteral() && "Not a string literal!");
Sebastian Redld65cea82008-12-11 22:51:44 +00001909
Chris Lattnerd3e98952006-10-06 05:22:26 +00001910 // String concat. Note that keywords like __func__ and __FUNCTION__ are not
1911 // considered to be strings for concatenation purposes.
Chris Lattner146762e2007-07-20 16:59:19 +00001912 llvm::SmallVector<Token, 4> StringToks;
Sebastian Redld65cea82008-12-11 22:51:44 +00001913
Chris Lattnerd3e98952006-10-06 05:22:26 +00001914 do {
Chris Lattnerd3e98952006-10-06 05:22:26 +00001915 StringToks.push_back(Tok);
1916 ConsumeStringToken();
1917 } while (isTokenStringLiteral());
Chris Lattner08f27912006-11-09 06:34:47 +00001918
1919 // Pass the set of string tokens, ready for concatenation, to the actions.
Alexis Hunt3b791862010-08-30 17:47:05 +00001920 return Actions.ActOnStringLiteral(&StringToks[0], StringToks.size());
Chris Lattnerd3e98952006-10-06 05:22:26 +00001921}
Argyrios Kyrtzidis69af9ee2008-08-16 20:03:01 +00001922
Peter Collingbourne91147592011-04-15 00:35:48 +00001923/// ParseGenericSelectionExpression - Parse a C1X generic-selection
1924/// [C1X 6.5.1.1].
1925///
1926/// generic-selection:
1927/// _Generic ( assignment-expression , generic-assoc-list )
1928/// generic-assoc-list:
1929/// generic-association
1930/// generic-assoc-list , generic-association
1931/// generic-association:
1932/// type-name : assignment-expression
1933/// default : assignment-expression
1934ExprResult Parser::ParseGenericSelectionExpression() {
1935 assert(Tok.is(tok::kw__Generic) && "_Generic keyword expected");
1936 SourceLocation KeyLoc = ConsumeToken();
1937
1938 if (!getLang().C1X)
1939 Diag(KeyLoc, diag::ext_c1x_generic_selection);
1940
1941 SourceLocation LParenLoc = Tok.getLocation();
1942 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen, ""))
1943 return ExprError();
1944
1945 ExprResult ControllingExpr;
1946 {
1947 // C1X 6.5.1.1p3 "The controlling expression of a generic selection is
1948 // not evaluated."
1949 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
1950 ControllingExpr = ParseAssignmentExpression();
1951 if (ControllingExpr.isInvalid()) {
1952 SkipUntil(tok::r_paren);
1953 return ExprError();
1954 }
1955 }
1956
1957 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "")) {
1958 SkipUntil(tok::r_paren);
1959 return ExprError();
1960 }
1961
1962 SourceLocation DefaultLoc;
1963 TypeVector Types(Actions);
1964 ExprVector Exprs(Actions);
1965 while (1) {
1966 ParsedType Ty;
1967 if (Tok.is(tok::kw_default)) {
1968 // C1X 6.5.1.1p2 "A generic selection shall have no more than one default
1969 // generic association."
1970 if (!DefaultLoc.isInvalid()) {
1971 Diag(Tok, diag::err_duplicate_default_assoc);
1972 Diag(DefaultLoc, diag::note_previous_default_assoc);
1973 SkipUntil(tok::r_paren);
1974 return ExprError();
1975 }
1976 DefaultLoc = ConsumeToken();
1977 Ty = ParsedType();
1978 } else {
1979 ColonProtectionRAIIObject X(*this);
1980 TypeResult TR = ParseTypeName();
1981 if (TR.isInvalid()) {
1982 SkipUntil(tok::r_paren);
1983 return ExprError();
1984 }
1985 Ty = TR.release();
1986 }
1987 Types.push_back(Ty);
1988
1989 if (ExpectAndConsume(tok::colon, diag::err_expected_colon, "")) {
1990 SkipUntil(tok::r_paren);
1991 return ExprError();
1992 }
1993
1994 // FIXME: These expressions should be parsed in a potentially potentially
1995 // evaluated context.
1996 ExprResult ER(ParseAssignmentExpression());
1997 if (ER.isInvalid()) {
1998 SkipUntil(tok::r_paren);
1999 return ExprError();
2000 }
2001 Exprs.push_back(ER.release());
2002
2003 if (Tok.isNot(tok::comma))
2004 break;
2005 ConsumeToken();
2006 }
2007
2008 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
2009 if (RParenLoc.isInvalid())
2010 return ExprError();
2011
2012 return Actions.ActOnGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
2013 ControllingExpr.release(),
2014 move_arg(Types), move_arg(Exprs));
2015}
2016
Argyrios Kyrtzidis69af9ee2008-08-16 20:03:01 +00002017/// ParseExpressionList - Used for C/C++ (argument-)expression-list.
2018///
2019/// argument-expression-list:
2020/// assignment-expression
2021/// argument-expression-list , assignment-expression
2022///
2023/// [C++] expression-list:
Douglas Gregor968f23a2011-01-03 19:31:53 +00002024/// [C++] assignment-expression ...[opt]
2025/// [C++] expression-list , assignment-expression ...[opt]
Argyrios Kyrtzidis69af9ee2008-08-16 20:03:01 +00002026///
John McCall37ad5512010-08-23 06:44:23 +00002027bool Parser::ParseExpressionList(llvm::SmallVectorImpl<Expr*> &Exprs,
2028 llvm::SmallVectorImpl<SourceLocation> &CommaLocs,
John McCallfaf5fb42010-08-26 23:41:50 +00002029 void (Sema::*Completer)(Scope *S,
John McCall37ad5512010-08-23 06:44:23 +00002030 Expr *Data,
2031 Expr **Args,
Douglas Gregorcabea402009-09-22 15:41:20 +00002032 unsigned NumArgs),
John McCall37ad5512010-08-23 06:44:23 +00002033 Expr *Data) {
Argyrios Kyrtzidis69af9ee2008-08-16 20:03:01 +00002034 while (1) {
Douglas Gregorcabea402009-09-22 15:41:20 +00002035 if (Tok.is(tok::code_completion)) {
2036 if (Completer)
Douglas Gregor0be31a22010-07-02 17:43:08 +00002037 (Actions.*Completer)(getCurScope(), Data, Exprs.data(), Exprs.size());
Douglas Gregor9c1f1bf2011-02-17 03:09:23 +00002038 else
2039 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
Douglas Gregor6da3db42010-05-25 05:58:43 +00002040 ConsumeCodeCompletionToken();
Douglas Gregorcabea402009-09-22 15:41:20 +00002041 }
2042
John McCalldadc5752010-08-24 06:29:42 +00002043 ExprResult Expr(ParseAssignmentExpression());
Douglas Gregor968f23a2011-01-03 19:31:53 +00002044 if (Tok.is(tok::ellipsis))
2045 Expr = Actions.ActOnPackExpansion(Expr.get(), ConsumeToken());
Sebastian Redl17f2c7d2008-12-09 13:15:23 +00002046 if (Expr.isInvalid())
Argyrios Kyrtzidis69af9ee2008-08-16 20:03:01 +00002047 return true;
Argyrios Kyrtzidis22fc2662008-08-18 22:49:40 +00002048
Sebastian Redld9f7b1c2008-12-10 00:02:53 +00002049 Exprs.push_back(Expr.release());
Argyrios Kyrtzidis69af9ee2008-08-16 20:03:01 +00002050
2051 if (Tok.isNot(tok::comma))
2052 return false;
2053 // Move to the next argument, remember where the comma was.
2054 CommaLocs.push_back(ConsumeToken());
2055 }
2056}
Steve Naroff0ac012832008-08-28 19:20:44 +00002057
Mike Stump82f071f2009-02-04 22:31:32 +00002058/// ParseBlockId - Parse a block-id, which roughly looks like int (int x).
2059///
2060/// [clang] block-id:
2061/// [clang] specifier-qualifier-list block-declarator
2062///
2063void Parser::ParseBlockId() {
Douglas Gregor643c3302010-10-18 21:34:55 +00002064 if (Tok.is(tok::code_completion)) {
2065 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Type);
2066 ConsumeCodeCompletionToken();
2067 }
2068
Mike Stump82f071f2009-02-04 22:31:32 +00002069 // Parse the specifier-qualifier-list piece.
John McCall084e83d2011-03-24 11:26:52 +00002070 DeclSpec DS(AttrFactory);
Mike Stump82f071f2009-02-04 22:31:32 +00002071 ParseSpecifierQualifierList(DS);
2072
2073 // Parse the block-declarator.
2074 Declarator DeclaratorInfo(DS, Declarator::BlockLiteralContext);
2075 ParseDeclarator(DeclaratorInfo);
Mike Stump88788fe2009-04-29 19:03:13 +00002076
Mike Stump56ed2ea2009-04-29 21:40:37 +00002077 // We do this for: ^ __attribute__((noreturn)) {, as DS has the attributes.
John McCall084e83d2011-03-24 11:26:52 +00002078 DeclaratorInfo.takeAttributes(DS.getAttributes(), SourceLocation());
Mike Stump56ed2ea2009-04-29 21:40:37 +00002079
John McCall53fa7142010-12-24 02:08:15 +00002080 MaybeParseGNUAttributes(DeclaratorInfo);
Mike Stump88788fe2009-04-29 19:03:13 +00002081
Mike Stump82f071f2009-02-04 22:31:32 +00002082 // Inform sema that we are starting a block.
Douglas Gregor0be31a22010-07-02 17:43:08 +00002083 Actions.ActOnBlockArguments(DeclaratorInfo, getCurScope());
Mike Stump82f071f2009-02-04 22:31:32 +00002084}
2085
Steve Naroff0ac012832008-08-28 19:20:44 +00002086/// ParseBlockLiteralExpression - Parse a block literal, which roughly looks
Steve Naroff7a147c62008-09-16 23:11:46 +00002087/// like ^(int x){ return x+1; }
Steve Naroff0ac012832008-08-28 19:20:44 +00002088///
2089/// block-literal:
2090/// [clang] '^' block-args[opt] compound-statement
Mike Stump82f071f2009-02-04 22:31:32 +00002091/// [clang] '^' block-id compound-statement
Steve Naroff0ac012832008-08-28 19:20:44 +00002092/// [clang] block-args:
2093/// [clang] '(' parameter-list ')'
2094///
John McCalldadc5752010-08-24 06:29:42 +00002095ExprResult Parser::ParseBlockLiteralExpression() {
Steve Naroff0ac012832008-08-28 19:20:44 +00002096 assert(Tok.is(tok::caret) && "block literal starts with ^");
2097 SourceLocation CaretLoc = ConsumeToken();
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002098
Chris Lattnerf6801202009-03-05 07:32:12 +00002099 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), CaretLoc,
2100 "block literal parsing");
2101
Mike Stump11289f42009-09-09 15:08:12 +00002102 // Enter a scope to hold everything within the block. This includes the
Steve Naroff0ac012832008-08-28 19:20:44 +00002103 // argument decls, decls within the compound expression, etc. This also
2104 // allows determining whether a variable reference inside the block is
2105 // within or outside of the block.
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002106 ParseScope BlockScope(this, Scope::BlockScope | Scope::FnScope |
2107 Scope::BreakScope | Scope::ContinueScope |
2108 Scope::DeclScope);
Steve Naroff1d95e5a2008-10-10 01:28:17 +00002109
2110 // Inform sema that we are starting a block.
Douglas Gregor0be31a22010-07-02 17:43:08 +00002111 Actions.ActOnBlockStart(CaretLoc, getCurScope());
Mike Stump11289f42009-09-09 15:08:12 +00002112
Steve Naroff0ac012832008-08-28 19:20:44 +00002113 // Parse the return type if present.
John McCall084e83d2011-03-24 11:26:52 +00002114 DeclSpec DS(AttrFactory);
Mike Stump82f071f2009-02-04 22:31:32 +00002115 Declarator ParamInfo(DS, Declarator::BlockLiteralContext);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002116 // FIXME: Since the return type isn't actually parsed, it can't be used to
2117 // fill ParamInfo with an initial valid range, so do it manually.
2118 ParamInfo.SetSourceRange(SourceRange(Tok.getLocation(), Tok.getLocation()));
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002119
Steve Naroff0ac012832008-08-28 19:20:44 +00002120 // If this block has arguments, parse them. There is no ambiguity here with
2121 // the expression case, because the expression case requires a parameter list.
2122 if (Tok.is(tok::l_paren)) {
2123 ParseParenDeclarator(ParamInfo);
2124 // Parse the pieces after the identifier as if we had "int(...)".
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002125 // SetIdentifier sets the source range end, but in this case we're past
2126 // that location.
2127 SourceLocation Tmp = ParamInfo.getSourceRange().getEnd();
Steve Naroff0ac012832008-08-28 19:20:44 +00002128 ParamInfo.SetIdentifier(0, CaretLoc);
Sebastian Redlf6591ca2009-02-09 18:23:29 +00002129 ParamInfo.SetRangeEnd(Tmp);
Chris Lattnerf6d1c9c2009-04-25 08:06:05 +00002130 if (ParamInfo.isInvalidType()) {
Mike Stump82f071f2009-02-04 22:31:32 +00002131 // If there was an error parsing the arguments, they may have
2132 // tried to use ^(x+y) which requires an argument list. Just
2133 // skip the whole block literal.
Douglas Gregor0be31a22010-07-02 17:43:08 +00002134 Actions.ActOnBlockError(CaretLoc, getCurScope());
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002135 return ExprError();
Steve Naroff0ac012832008-08-28 19:20:44 +00002136 }
Mike Stump88788fe2009-04-29 19:03:13 +00002137
John McCall53fa7142010-12-24 02:08:15 +00002138 MaybeParseGNUAttributes(ParamInfo);
Mike Stump88788fe2009-04-29 19:03:13 +00002139
Mike Stump82f071f2009-02-04 22:31:32 +00002140 // Inform sema that we are starting a block.
Douglas Gregor0be31a22010-07-02 17:43:08 +00002141 Actions.ActOnBlockArguments(ParamInfo, getCurScope());
Mike Stumpd73e4412009-04-14 18:24:37 +00002142 } else if (!Tok.is(tok::l_brace)) {
Mike Stump82f071f2009-02-04 22:31:32 +00002143 ParseBlockId();
Steve Naroff0ac012832008-08-28 19:20:44 +00002144 } else {
2145 // Otherwise, pretend we saw (void).
John McCall084e83d2011-03-24 11:26:52 +00002146 ParsedAttributes attrs(AttrFactory);
2147 ParamInfo.AddTypeInfo(DeclaratorChunk::getFunction(true, false,
Douglas Gregor94349fd2009-02-18 07:07:28 +00002148 SourceLocation(),
Sebastian Redl2b9cacb2009-04-29 17:30:04 +00002149 0, 0, 0,
Douglas Gregor54992352011-01-26 03:43:54 +00002150 true, SourceLocation(),
Sebastian Redl802a4532011-03-05 22:42:13 +00002151 EST_None,
2152 SourceLocation(),
2153 0, 0, 0, 0,
Argyrios Kyrtzidis20cf1912009-08-19 23:14:54 +00002154 CaretLoc, CaretLoc,
2155 ParamInfo),
John McCall084e83d2011-03-24 11:26:52 +00002156 attrs, CaretLoc);
Mike Stump88788fe2009-04-29 19:03:13 +00002157
John McCall53fa7142010-12-24 02:08:15 +00002158 MaybeParseGNUAttributes(ParamInfo);
Mike Stump88788fe2009-04-29 19:03:13 +00002159
Mike Stump82f071f2009-02-04 22:31:32 +00002160 // Inform sema that we are starting a block.
Douglas Gregor0be31a22010-07-02 17:43:08 +00002161 Actions.ActOnBlockArguments(ParamInfo, getCurScope());
Steve Naroff0ac012832008-08-28 19:20:44 +00002162 }
2163
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002164
John McCalldadc5752010-08-24 06:29:42 +00002165 ExprResult Result(true);
Chris Lattner9eac9312009-03-27 04:18:06 +00002166 if (!Tok.is(tok::l_brace)) {
Fariborz Jahanianf2a31202009-01-14 19:39:53 +00002167 // Saw something like: ^expr
2168 Diag(Tok, diag::err_expected_expression);
Douglas Gregor0be31a22010-07-02 17:43:08 +00002169 Actions.ActOnBlockError(CaretLoc, getCurScope());
Fariborz Jahanianf2a31202009-01-14 19:39:53 +00002170 return ExprError();
2171 }
Mike Stump11289f42009-09-09 15:08:12 +00002172
John McCalldadc5752010-08-24 06:29:42 +00002173 StmtResult Stmt(ParseCompoundStatementBody());
Douglas Gregora0ff0c32011-03-16 17:05:57 +00002174 BlockScope.Exit();
Chris Lattner9eac9312009-03-27 04:18:06 +00002175 if (!Stmt.isInvalid())
John McCallb268a282010-08-23 23:25:46 +00002176 Result = Actions.ActOnBlockStmtExpr(CaretLoc, Stmt.take(), getCurScope());
Chris Lattner9eac9312009-03-27 04:18:06 +00002177 else
Douglas Gregor0be31a22010-07-02 17:43:08 +00002178 Actions.ActOnBlockError(CaretLoc, getCurScope());
Sebastian Redlcb6e2c62008-12-13 15:32:12 +00002179 return move(Result);
Steve Naroff0ac012832008-08-28 19:20:44 +00002180}