ParseExpr.cpp revision c987a4107c73308c58832beb1dc9709e7a3285c0 
1//===--- ParseExpr.cpp - Expression Parsing -------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Expression parsing implementation.  Expressions in
11// C99 basically consist of a bunch of binary operators with unary operators and
12// other random stuff at the leaves.
13//
14// In the C99 grammar, these unary operators bind tightest and are represented
15// as the 'cast-expression' production.  Everything else is either a binary
16// operator (e.g. '/') or a ternary operator ("?:").  The unary leaves are
17// handled by ParseCastExpression, the higher level pieces are handled by
18// ParseBinaryExpression.
19//
20//===----------------------------------------------------------------------===//
21
22#include "clang/Parse/Parser.h"
23#include "clang/Parse/DeclSpec.h"
24#include "clang/Parse/Scope.h"
25#include "clang/Parse/Template.h"
26#include "clang/Basic/PrettyStackTrace.h"
27#include "RAIIObjectsForParser.h"
28#include "llvm/ADT/SmallVector.h"
29#include "llvm/ADT/SmallString.h"
30using namespace clang;
31
32/// PrecedenceLevels - These are precedences for the binary/ternary operators in
33/// the C99 grammar.  These have been named to relate with the C99 grammar
34/// productions.  Low precedences numbers bind more weakly than high numbers.
35namespace prec {
36  enum Level {
37    Unknown         = 0,    // Not binary operator.
38    Comma           = 1,    // ,
39    Assignment      = 2,    // =, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=
40    Conditional     = 3,    // ?
41    LogicalOr       = 4,    // ||
42    LogicalAnd      = 5,    // &&
43    InclusiveOr     = 6,    // |
44    ExclusiveOr     = 7,    // ^
45    And             = 8,    // &
46    Equality        = 9,    // ==, !=
47    Relational      = 10,   //  >=, <=, >, <
48    Shift           = 11,   // <<, >>
49    Additive        = 12,   // -, +
50    Multiplicative  = 13,   // *, /, %
51    PointerToMember = 14    // .*, ->*
52  };
53}
54
55
56/// getBinOpPrecedence - Return the precedence of the specified binary operator
57/// token.  This returns:
58///
59static prec::Level getBinOpPrecedence(tok::TokenKind Kind,
60                                      bool GreaterThanIsOperator,
61                                      bool CPlusPlus0x) {
62  switch (Kind) {
63  case tok::greater:
64    // C++ [temp.names]p3:
65    //   [...] When parsing a template-argument-list, the first
66    //   non-nested > is taken as the ending delimiter rather than a
67    //   greater-than operator. [...]
68    if (GreaterThanIsOperator)
69      return prec::Relational;
70    return prec::Unknown;
71
72  case tok::greatergreater:
73    // C++0x [temp.names]p3:
74    //
75    //   [...] Similarly, the first non-nested >> is treated as two
76    //   consecutive but distinct > tokens, the first of which is
77    //   taken as the end of the template-argument-list and completes
78    //   the template-id. [...]
79    if (GreaterThanIsOperator || !CPlusPlus0x)
80      return prec::Shift;
81    return prec::Unknown;
82
83  default:                        return prec::Unknown;
84  case tok::comma:                return prec::Comma;
85  case tok::equal:
86  case tok::starequal:
87  case tok::slashequal:
88  case tok::percentequal:
89  case tok::plusequal:
90  case tok::minusequal:
91  case tok::lesslessequal:
92  case tok::greatergreaterequal:
93  case tok::ampequal:
94  case tok::caretequal:
95  case tok::pipeequal:            return prec::Assignment;
96  case tok::question:             return prec::Conditional;
97  case tok::pipepipe:             return prec::LogicalOr;
98  case tok::ampamp:               return prec::LogicalAnd;
99  case tok::pipe:                 return prec::InclusiveOr;
100  case tok::caret:                return prec::ExclusiveOr;
101  case tok::amp:                  return prec::And;
102  case tok::exclaimequal:
103  case tok::equalequal:           return prec::Equality;
104  case tok::lessequal:
105  case tok::less:
106  case tok::greaterequal:         return prec::Relational;
107  case tok::lessless:             return prec::Shift;
108  case tok::plus:
109  case tok::minus:                return prec::Additive;
110  case tok::percent:
111  case tok::slash:
112  case tok::star:                 return prec::Multiplicative;
113  case tok::periodstar:
114  case tok::arrowstar:            return prec::PointerToMember;
115  }
116}
117
118
119/// ParseExpression - Simple precedence-based parser for binary/ternary
120/// operators.
121///
122/// Note: we diverge from the C99 grammar when parsing the assignment-expression
123/// production.  C99 specifies that the LHS of an assignment operator should be
124/// parsed as a unary-expression, but consistency dictates that it be a
125/// conditional-expession.  In practice, the important thing here is that the
126/// LHS of an assignment has to be an l-value, which productions between
127/// unary-expression and conditional-expression don't produce.  Because we want
128/// consistency, we parse the LHS as a conditional-expression, then check for
129/// l-value-ness in semantic analysis stages.
130///
131///       pm-expression: [C++ 5.5]
132///         cast-expression
133///         pm-expression '.*' cast-expression
134///         pm-expression '->*' cast-expression
135///
136///       multiplicative-expression: [C99 6.5.5]
137///     Note: in C++, apply pm-expression instead of cast-expression
138///         cast-expression
139///         multiplicative-expression '*' cast-expression
140///         multiplicative-expression '/' cast-expression
141///         multiplicative-expression '%' cast-expression
142///
143///       additive-expression: [C99 6.5.6]
144///         multiplicative-expression
145///         additive-expression '+' multiplicative-expression
146///         additive-expression '-' multiplicative-expression
147///
148///       shift-expression: [C99 6.5.7]
149///         additive-expression
150///         shift-expression '<<' additive-expression
151///         shift-expression '>>' additive-expression
152///
153///       relational-expression: [C99 6.5.8]
154///         shift-expression
155///         relational-expression '<' shift-expression
156///         relational-expression '>' shift-expression
157///         relational-expression '<=' shift-expression
158///         relational-expression '>=' shift-expression
159///
160///       equality-expression: [C99 6.5.9]
161///         relational-expression
162///         equality-expression '==' relational-expression
163///         equality-expression '!=' relational-expression
164///
165///       AND-expression: [C99 6.5.10]
166///         equality-expression
167///         AND-expression '&' equality-expression
168///
169///       exclusive-OR-expression: [C99 6.5.11]
170///         AND-expression
171///         exclusive-OR-expression '^' AND-expression
172///
173///       inclusive-OR-expression: [C99 6.5.12]
174///         exclusive-OR-expression
175///         inclusive-OR-expression '|' exclusive-OR-expression
176///
177///       logical-AND-expression: [C99 6.5.13]
178///         inclusive-OR-expression
179///         logical-AND-expression '&&' inclusive-OR-expression
180///
181///       logical-OR-expression: [C99 6.5.14]
182///         logical-AND-expression
183///         logical-OR-expression '||' logical-AND-expression
184///
185///       conditional-expression: [C99 6.5.15]
186///         logical-OR-expression
187///         logical-OR-expression '?' expression ':' conditional-expression
188/// [GNU]   logical-OR-expression '?' ':' conditional-expression
189/// [C++] the third operand is an assignment-expression
190///
191///       assignment-expression: [C99 6.5.16]
192///         conditional-expression
193///         unary-expression assignment-operator assignment-expression
194/// [C++]   throw-expression [C++ 15]
195///
196///       assignment-operator: one of
197///         = *= /= %= += -= <<= >>= &= ^= |=
198///
199///       expression: [C99 6.5.17]
200///         assignment-expression
201///         expression ',' assignment-expression
202///
203Parser::OwningExprResult Parser::ParseExpression() {
204  OwningExprResult LHS(ParseAssignmentExpression());
205  if (LHS.isInvalid()) return move(LHS);
206
207  return ParseRHSOfBinaryExpression(move(LHS), prec::Comma);
208}
209
210/// This routine is called when the '@' is seen and consumed.
211/// Current token is an Identifier and is not a 'try'. This
212/// routine is necessary to disambiguate @try-statement from,
213/// for example, @encode-expression.
214///
215Parser::OwningExprResult
216Parser::ParseExpressionWithLeadingAt(SourceLocation AtLoc) {
217  OwningExprResult LHS(ParseObjCAtExpression(AtLoc));
218  if (LHS.isInvalid()) return move(LHS);
219
220  return ParseRHSOfBinaryExpression(move(LHS), prec::Comma);
221}
222
223/// This routine is called when a leading '__extension__' is seen and
224/// consumed.  This is necessary because the token gets consumed in the
225/// process of disambiguating between an expression and a declaration.
226Parser::OwningExprResult
227Parser::ParseExpressionWithLeadingExtension(SourceLocation ExtLoc) {
228  OwningExprResult LHS(Actions, true);
229  {
230    // Silence extension warnings in the sub-expression
231    ExtensionRAIIObject O(Diags);
232
233    LHS = ParseCastExpression(false);
234    if (LHS.isInvalid()) return move(LHS);
235  }
236
237  LHS = Actions.ActOnUnaryOp(CurScope, ExtLoc, tok::kw___extension__,
238                             move(LHS));
239  if (LHS.isInvalid()) return move(LHS);
240
241  return ParseRHSOfBinaryExpression(move(LHS), prec::Comma);
242}
243
244/// ParseAssignmentExpression - Parse an expr that doesn't include commas.
245///
246Parser::OwningExprResult Parser::ParseAssignmentExpression() {
247  if (Tok.is(tok::code_completion)) {
248    Actions.CodeCompleteOrdinaryName(CurScope, Action::CCC_Expression);
249    ConsumeToken();
250  }
251
252  if (Tok.is(tok::kw_throw))
253    return ParseThrowExpression();
254
255  OwningExprResult LHS(ParseCastExpression(false));
256  if (LHS.isInvalid()) return move(LHS);
257
258  return ParseRHSOfBinaryExpression(move(LHS), prec::Assignment);
259}
260
261/// ParseAssignmentExprWithObjCMessageExprStart - Parse an assignment expression
262/// where part of an objc message send has already been parsed.  In this case
263/// LBracLoc indicates the location of the '[' of the message send, and either
264/// ReceiverName or ReceiverExpr is non-null indicating the receiver of the
265/// message.
266///
267/// Since this handles full assignment-expression's, it handles postfix
268/// expressions and other binary operators for these expressions as well.
269Parser::OwningExprResult
270Parser::ParseAssignmentExprWithObjCMessageExprStart(SourceLocation LBracLoc,
271                                                    SourceLocation NameLoc,
272                                                   IdentifierInfo *ReceiverName,
273                                                    ExprArg ReceiverExpr) {
274  OwningExprResult R(ParseObjCMessageExpressionBody(LBracLoc, NameLoc,
275                                                    ReceiverName,
276                                                    move(ReceiverExpr)));
277  if (R.isInvalid()) return move(R);
278  R = ParsePostfixExpressionSuffix(move(R));
279  if (R.isInvalid()) return move(R);
280  return ParseRHSOfBinaryExpression(move(R), prec::Assignment);
281}
282
283
284Parser::OwningExprResult Parser::ParseConstantExpression() {
285  // C++ [basic.def.odr]p2:
286  //   An expression is potentially evaluated unless it appears where an
287  //   integral constant expression is required (see 5.19) [...].
288  EnterExpressionEvaluationContext Unevaluated(Actions,
289                                               Action::Unevaluated);
290
291  OwningExprResult LHS(ParseCastExpression(false));
292  if (LHS.isInvalid()) return move(LHS);
293
294  return ParseRHSOfBinaryExpression(move(LHS), prec::Conditional);
295}
296
297/// ParseRHSOfBinaryExpression - Parse a binary expression that starts with
298/// LHS and has a precedence of at least MinPrec.
299Parser::OwningExprResult
300Parser::ParseRHSOfBinaryExpression(OwningExprResult LHS, unsigned MinPrec) {
301  unsigned NextTokPrec = getBinOpPrecedence(Tok.getKind(),
302                                            GreaterThanIsOperator,
303                                            getLang().CPlusPlus0x);
304  SourceLocation ColonLoc;
305
306  while (1) {
307    // If this token has a lower precedence than we are allowed to parse (e.g.
308    // because we are called recursively, or because the token is not a binop),
309    // then we are done!
310    if (NextTokPrec < MinPrec)
311      return move(LHS);
312
313    // Consume the operator, saving the operator token for error reporting.
314    Token OpToken = Tok;
315    ConsumeToken();
316
317    // Special case handling for the ternary operator.
318    OwningExprResult TernaryMiddle(Actions, true);
319    if (NextTokPrec == prec::Conditional) {
320      if (Tok.isNot(tok::colon)) {
321        // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
322        ColonProtectionRAIIObject X(*this);
323
324        // Handle this production specially:
325        //   logical-OR-expression '?' expression ':' conditional-expression
326        // In particular, the RHS of the '?' is 'expression', not
327        // 'logical-OR-expression' as we might expect.
328        TernaryMiddle = ParseExpression();
329        if (TernaryMiddle.isInvalid())
330          return move(TernaryMiddle);
331      } else {
332        // Special case handling of "X ? Y : Z" where Y is empty:
333        //   logical-OR-expression '?' ':' conditional-expression   [GNU]
334        TernaryMiddle = 0;
335        Diag(Tok, diag::ext_gnu_conditional_expr);
336      }
337
338      if (Tok.isNot(tok::colon)) {
339        Diag(Tok, diag::err_expected_colon);
340        Diag(OpToken, diag::note_matching) << "?";
341        return ExprError();
342      }
343
344      // Eat the colon.
345      ColonLoc = ConsumeToken();
346    }
347
348    // Parse another leaf here for the RHS of the operator.
349    // ParseCastExpression works here because all RHS expressions in C have it
350    // as a prefix, at least. However, in C++, an assignment-expression could
351    // be a throw-expression, which is not a valid cast-expression.
352    // Therefore we need some special-casing here.
353    // Also note that the third operand of the conditional operator is
354    // an assignment-expression in C++.
355    OwningExprResult RHS(Actions);
356    if (getLang().CPlusPlus && NextTokPrec <= prec::Conditional)
357      RHS = ParseAssignmentExpression();
358    else
359      RHS = ParseCastExpression(false);
360    if (RHS.isInvalid())
361      return move(RHS);
362
363    // Remember the precedence of this operator and get the precedence of the
364    // operator immediately to the right of the RHS.
365    unsigned ThisPrec = NextTokPrec;
366    NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator,
367                                     getLang().CPlusPlus0x);
368
369    // Assignment and conditional expressions are right-associative.
370    bool isRightAssoc = ThisPrec == prec::Conditional ||
371                        ThisPrec == prec::Assignment;
372
373    // Get the precedence of the operator to the right of the RHS.  If it binds
374    // more tightly with RHS than we do, evaluate it completely first.
375    if (ThisPrec < NextTokPrec ||
376        (ThisPrec == NextTokPrec && isRightAssoc)) {
377      // If this is left-associative, only parse things on the RHS that bind
378      // more tightly than the current operator.  If it is left-associative, it
379      // is okay, to bind exactly as tightly.  For example, compile A=B=C=D as
380      // A=(B=(C=D)), where each paren is a level of recursion here.
381      // The function takes ownership of the RHS.
382      RHS = ParseRHSOfBinaryExpression(move(RHS), ThisPrec + !isRightAssoc);
383      if (RHS.isInvalid())
384        return move(RHS);
385
386      NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator,
387                                       getLang().CPlusPlus0x);
388    }
389    assert(NextTokPrec <= ThisPrec && "Recursion didn't work!");
390
391    if (!LHS.isInvalid()) {
392      // Combine the LHS and RHS into the LHS (e.g. build AST).
393      if (TernaryMiddle.isInvalid()) {
394        // If we're using '>>' as an operator within a template
395        // argument list (in C++98), suggest the addition of
396        // parentheses so that the code remains well-formed in C++0x.
397        if (!GreaterThanIsOperator && OpToken.is(tok::greatergreater))
398          SuggestParentheses(OpToken.getLocation(),
399                             diag::warn_cxx0x_right_shift_in_template_arg,
400                         SourceRange(Actions.getExprRange(LHS.get()).getBegin(),
401                                     Actions.getExprRange(RHS.get()).getEnd()));
402
403        LHS = Actions.ActOnBinOp(CurScope, OpToken.getLocation(),
404                                 OpToken.getKind(), move(LHS), move(RHS));
405      } else
406        LHS = Actions.ActOnConditionalOp(OpToken.getLocation(), ColonLoc,
407                                         move(LHS), move(TernaryMiddle),
408                                         move(RHS));
409    }
410  }
411}
412
413/// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is
414/// true, parse a unary-expression. isAddressOfOperand exists because an
415/// id-expression that is the operand of address-of gets special treatment
416/// due to member pointers.
417///
418Parser::OwningExprResult Parser::ParseCastExpression(bool isUnaryExpression,
419                                                     bool isAddressOfOperand,
420                                                     TypeTy *TypeOfCast) {
421  bool NotCastExpr;
422  OwningExprResult Res = ParseCastExpression(isUnaryExpression,
423                                             isAddressOfOperand,
424                                             NotCastExpr,
425                                             TypeOfCast);
426  if (NotCastExpr)
427    Diag(Tok, diag::err_expected_expression);
428  return move(Res);
429}
430
431/// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is
432/// true, parse a unary-expression. isAddressOfOperand exists because an
433/// id-expression that is the operand of address-of gets special treatment
434/// due to member pointers. NotCastExpr is set to true if the token is not the
435/// start of a cast-expression, and no diagnostic is emitted in this case.
436///
437///       cast-expression: [C99 6.5.4]
438///         unary-expression
439///         '(' type-name ')' cast-expression
440///
441///       unary-expression:  [C99 6.5.3]
442///         postfix-expression
443///         '++' unary-expression
444///         '--' unary-expression
445///         unary-operator cast-expression
446///         'sizeof' unary-expression
447///         'sizeof' '(' type-name ')'
448/// [GNU]   '__alignof' unary-expression
449/// [GNU]   '__alignof' '(' type-name ')'
450/// [C++0x] 'alignof' '(' type-id ')'
451/// [GNU]   '&&' identifier
452/// [C++]   new-expression
453/// [C++]   delete-expression
454///
455///       unary-operator: one of
456///         '&'  '*'  '+'  '-'  '~'  '!'
457/// [GNU]   '__extension__'  '__real'  '__imag'
458///
459///       primary-expression: [C99 6.5.1]
460/// [C99]   identifier
461/// [C++]   id-expression
462///         constant
463///         string-literal
464/// [C++]   boolean-literal  [C++ 2.13.5]
465/// [C++0x] 'nullptr'        [C++0x 2.14.7]
466///         '(' expression ')'
467///         '__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 ')'
476/// [GNU]   '__null'
477/// [OBJC]  '[' objc-message-expr ']'
478/// [OBJC]  '@selector' '(' objc-selector-arg ')'
479/// [OBJC]  '@protocol' '(' identifier ')'
480/// [OBJC]  '@encode' '(' type-name ')'
481/// [OBJC]  objc-string-literal
482/// [C++]   simple-type-specifier '(' expression-list[opt] ')'      [C++ 5.2.3]
483/// [C++]   typename-specifier '(' expression-list[opt] ')'         [TODO]
484/// [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]
488/// [C++]   'typeid' '(' expression ')'                             [C++ 5.2p1]
489/// [C++]   'typeid' '(' type-id ')'                                [C++ 5.2p1]
490/// [C++]   'this'          [C++ 9.3.2]
491/// [G++]   unary-type-trait '(' type-id ')'
492/// [G++]   binary-type-trait '(' type-id ',' type-id ')'           [TODO]
493/// [clang] '^' block-literal
494///
495///       constant: [C99 6.4.4]
496///         integer-constant
497///         floating-constant
498///         enumeration-constant -> identifier
499///         character-constant
500///
501///       id-expression: [C++ 5.1]
502///                   unqualified-id
503///                   qualified-id           [TODO]
504///
505///       unqualified-id: [C++ 5.1]
506///                   identifier
507///                   operator-function-id
508///                   conversion-function-id [TODO]
509///                   '~' class-name         [TODO]
510///                   template-id            [TODO]
511///
512///       new-expression: [C++ 5.3.4]
513///                   '::'[opt] 'new' new-placement[opt] new-type-id
514///                                     new-initializer[opt]
515///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
516///                                     new-initializer[opt]
517///
518///       delete-expression: [C++ 5.3.5]
519///                   '::'[opt] 'delete' cast-expression
520///                   '::'[opt] 'delete' '[' ']' cast-expression
521///
522/// [GNU] unary-type-trait:
523///                   '__has_nothrow_assign'                  [TODO]
524///                   '__has_nothrow_copy'                    [TODO]
525///                   '__has_nothrow_constructor'             [TODO]
526///                   '__has_trivial_assign'                  [TODO]
527///                   '__has_trivial_copy'                    [TODO]
528///                   '__has_trivial_constructor'
529///                   '__has_trivial_destructor'
530///                   '__has_virtual_destructor'              [TODO]
531///                   '__is_abstract'                         [TODO]
532///                   '__is_class'
533///                   '__is_empty'                            [TODO]
534///                   '__is_enum'
535///                   '__is_pod'
536///                   '__is_polymorphic'
537///                   '__is_union'
538///
539/// [GNU] binary-type-trait:
540///                   '__is_base_of'                          [TODO]
541///
542Parser::OwningExprResult Parser::ParseCastExpression(bool isUnaryExpression,
543                                                     bool isAddressOfOperand,
544                                                     bool &NotCastExpr,
545                                                     TypeTy *TypeOfCast) {
546  OwningExprResult Res(Actions);
547  tok::TokenKind SavedKind = Tok.getKind();
548  NotCastExpr = false;
549
550  // This handles all of cast-expression, unary-expression, postfix-expression,
551  // and primary-expression.  We handle them together like this for efficiency
552  // and to simplify handling of an expression starting with a '(' token: which
553  // may be one of a parenthesized expression, cast-expression, compound literal
554  // expression, or statement expression.
555  //
556  // If the parsed tokens consist of a primary-expression, the cases below
557  // call ParsePostfixExpressionSuffix to handle the postfix expression
558  // suffixes.  Cases that cannot be followed by postfix exprs should
559  // return without invoking ParsePostfixExpressionSuffix.
560  switch (SavedKind) {
561  case tok::l_paren: {
562    // If this expression is limited to being a unary-expression, the parent can
563    // not start a cast expression.
564    ParenParseOption ParenExprType =
565      isUnaryExpression ? CompoundLiteral : CastExpr;
566    TypeTy *CastTy;
567    SourceLocation LParenLoc = Tok.getLocation();
568    SourceLocation RParenLoc;
569
570    {
571      // The inside of the parens don't need to be a colon protected scope.
572      ColonProtectionRAIIObject X(*this, false);
573
574      Res = ParseParenExpression(ParenExprType, false/*stopIfCastExr*/,
575                                 TypeOfCast, CastTy, RParenLoc);
576      if (Res.isInvalid()) return move(Res);
577    }
578
579    switch (ParenExprType) {
580    case SimpleExpr:   break;    // Nothing else to do.
581    case CompoundStmt: break;  // Nothing else to do.
582    case CompoundLiteral:
583      // We parsed '(' type-name ')' '{' ... '}'.  If any suffixes of
584      // postfix-expression exist, parse them now.
585      break;
586    case CastExpr:
587      // We have parsed the cast-expression and no postfix-expr pieces are
588      // following.
589      return move(Res);
590    }
591
592    // These can be followed by postfix-expr pieces.
593    return ParsePostfixExpressionSuffix(move(Res));
594  }
595
596    // primary-expression
597  case tok::numeric_constant:
598    // constant: integer-constant
599    // constant: floating-constant
600
601    Res = Actions.ActOnNumericConstant(Tok);
602    ConsumeToken();
603
604    // These can be followed by postfix-expr pieces.
605    return ParsePostfixExpressionSuffix(move(Res));
606
607  case tok::kw_true:
608  case tok::kw_false:
609    return ParseCXXBoolLiteral();
610
611  case tok::kw_nullptr:
612    return Actions.ActOnCXXNullPtrLiteral(ConsumeToken());
613
614  case tok::identifier: {      // primary-expression: identifier
615                               // unqualified-id: identifier
616                               // constant: enumeration-constant
617    // Turn a potentially qualified name into a annot_typename or
618    // annot_cxxscope if it would be valid.  This handles things like x::y, etc.
619    if (getLang().CPlusPlus) {
620      // Avoid the unnecessary parse-time lookup in the common case
621      // where the syntax forbids a type.
622      const Token &Next = NextToken();
623      if (Next.is(tok::coloncolon) ||
624          (!ColonIsSacred && Next.is(tok::colon)) ||
625          Next.is(tok::less) ||
626          Next.is(tok::l_paren)) {
627        // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse.
628        if (TryAnnotateTypeOrScopeToken())
629          return ExprError();
630        if (!Tok.is(tok::identifier))
631          return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
632      }
633    }
634
635    // Consume the identifier so that we can see if it is followed by a '(' or
636    // '.'.
637    IdentifierInfo &II = *Tok.getIdentifierInfo();
638    SourceLocation ILoc = ConsumeToken();
639
640    // Support 'Class.property' and 'super.property' notation.
641    if (getLang().ObjC1 && Tok.is(tok::period) &&
642        (Actions.getTypeName(II, ILoc, CurScope) ||
643         // Allow the base to be 'super' if in an objc-method.
644         (&II == Ident_super && CurScope->isInObjcMethodScope()))) {
645      SourceLocation DotLoc = ConsumeToken();
646
647      if (Tok.isNot(tok::identifier)) {
648        Diag(Tok, diag::err_expected_property_name);
649        return ExprError();
650      }
651      IdentifierInfo &PropertyName = *Tok.getIdentifierInfo();
652      SourceLocation PropertyLoc = ConsumeToken();
653
654      Res = Actions.ActOnClassPropertyRefExpr(II, PropertyName,
655                                              ILoc, PropertyLoc);
656      // These can be followed by postfix-expr pieces.
657      return ParsePostfixExpressionSuffix(move(Res));
658    }
659
660    // Function designators are allowed to be undeclared (C99 6.5.1p2), so we
661    // need to know whether or not this identifier is a function designator or
662    // not.
663    UnqualifiedId Name;
664    CXXScopeSpec ScopeSpec;
665    Name.setIdentifier(&II, ILoc);
666    Res = Actions.ActOnIdExpression(CurScope, ScopeSpec, Name,
667                                    Tok.is(tok::l_paren), false);
668    // These can be followed by postfix-expr pieces.
669    return ParsePostfixExpressionSuffix(move(Res));
670  }
671  case tok::char_constant:     // constant: character-constant
672    Res = Actions.ActOnCharacterConstant(Tok);
673    ConsumeToken();
674    // These can be followed by postfix-expr pieces.
675    return ParsePostfixExpressionSuffix(move(Res));
676  case tok::kw___func__:       // primary-expression: __func__ [C99 6.4.2.2]
677  case tok::kw___FUNCTION__:   // primary-expression: __FUNCTION__ [GNU]
678  case tok::kw___PRETTY_FUNCTION__:  // primary-expression: __P..Y_F..N__ [GNU]
679    Res = Actions.ActOnPredefinedExpr(Tok.getLocation(), SavedKind);
680    ConsumeToken();
681    // These can be followed by postfix-expr pieces.
682    return ParsePostfixExpressionSuffix(move(Res));
683  case tok::string_literal:    // primary-expression: string-literal
684  case tok::wide_string_literal:
685    Res = ParseStringLiteralExpression();
686    if (Res.isInvalid()) return move(Res);
687    // This can be followed by postfix-expr pieces (e.g. "foo"[1]).
688    return ParsePostfixExpressionSuffix(move(Res));
689  case tok::kw___builtin_va_arg:
690  case tok::kw___builtin_offsetof:
691  case tok::kw___builtin_choose_expr:
692  case tok::kw___builtin_types_compatible_p:
693    return ParseBuiltinPrimaryExpression();
694  case tok::kw___null:
695    return Actions.ActOnGNUNullExpr(ConsumeToken());
696    break;
697  case tok::plusplus:      // unary-expression: '++' unary-expression
698  case tok::minusminus: {  // unary-expression: '--' unary-expression
699    SourceLocation SavedLoc = ConsumeToken();
700    Res = ParseCastExpression(true);
701    if (!Res.isInvalid())
702      Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res));
703    return move(Res);
704  }
705  case tok::amp: {         // unary-expression: '&' cast-expression
706    // Special treatment because of member pointers
707    SourceLocation SavedLoc = ConsumeToken();
708    Res = ParseCastExpression(false, true);
709    if (!Res.isInvalid())
710      Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res));
711    return move(Res);
712  }
713
714  case tok::star:          // unary-expression: '*' cast-expression
715  case tok::plus:          // unary-expression: '+' cast-expression
716  case tok::minus:         // unary-expression: '-' cast-expression
717  case tok::tilde:         // unary-expression: '~' cast-expression
718  case tok::exclaim:       // unary-expression: '!' cast-expression
719  case tok::kw___real:     // unary-expression: '__real' cast-expression [GNU]
720  case tok::kw___imag: {   // unary-expression: '__imag' cast-expression [GNU]
721    SourceLocation SavedLoc = ConsumeToken();
722    Res = ParseCastExpression(false);
723    if (!Res.isInvalid())
724      Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res));
725    return move(Res);
726  }
727
728  case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU]
729    // __extension__ silences extension warnings in the subexpression.
730    ExtensionRAIIObject O(Diags);  // Use RAII to do this.
731    SourceLocation SavedLoc = ConsumeToken();
732    Res = ParseCastExpression(false);
733    if (!Res.isInvalid())
734      Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res));
735    return move(Res);
736  }
737  case tok::kw_sizeof:     // unary-expression: 'sizeof' unary-expression
738                           // unary-expression: 'sizeof' '(' type-name ')'
739  case tok::kw_alignof:
740  case tok::kw___alignof:  // unary-expression: '__alignof' unary-expression
741                           // unary-expression: '__alignof' '(' type-name ')'
742                           // unary-expression: 'alignof' '(' type-id ')'
743    return ParseSizeofAlignofExpression();
744  case tok::ampamp: {      // unary-expression: '&&' identifier
745    SourceLocation AmpAmpLoc = ConsumeToken();
746    if (Tok.isNot(tok::identifier))
747      return ExprError(Diag(Tok, diag::err_expected_ident));
748
749    Diag(AmpAmpLoc, diag::ext_gnu_address_of_label);
750    Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(),
751                                 Tok.getIdentifierInfo());
752    ConsumeToken();
753    return move(Res);
754  }
755  case tok::kw_const_cast:
756  case tok::kw_dynamic_cast:
757  case tok::kw_reinterpret_cast:
758  case tok::kw_static_cast:
759    Res = ParseCXXCasts();
760    // These can be followed by postfix-expr pieces.
761    return ParsePostfixExpressionSuffix(move(Res));
762  case tok::kw_typeid:
763    Res = ParseCXXTypeid();
764    // This can be followed by postfix-expr pieces.
765    return ParsePostfixExpressionSuffix(move(Res));
766  case tok::kw_this:
767    Res = ParseCXXThis();
768    // This can be followed by postfix-expr pieces.
769    return ParsePostfixExpressionSuffix(move(Res));
770
771  case tok::kw_char:
772  case tok::kw_wchar_t:
773  case tok::kw_char16_t:
774  case tok::kw_char32_t:
775  case tok::kw_bool:
776  case tok::kw_short:
777  case tok::kw_int:
778  case tok::kw_long:
779  case tok::kw_signed:
780  case tok::kw_unsigned:
781  case tok::kw_float:
782  case tok::kw_double:
783  case tok::kw_void:
784  case tok::kw_typename:
785  case tok::kw_typeof:
786  case tok::kw___vector:
787  case tok::annot_typename: {
788    if (!getLang().CPlusPlus) {
789      Diag(Tok, diag::err_expected_expression);
790      return ExprError();
791    }
792
793    if (SavedKind == tok::kw_typename) {
794      // postfix-expression: typename-specifier '(' expression-list[opt] ')'
795      if (TryAnnotateTypeOrScopeToken())
796        return ExprError();
797    }
798
799    // postfix-expression: simple-type-specifier '(' expression-list[opt] ')'
800    //
801    DeclSpec DS;
802    ParseCXXSimpleTypeSpecifier(DS);
803    if (Tok.isNot(tok::l_paren))
804      return ExprError(Diag(Tok, diag::err_expected_lparen_after_type)
805                         << DS.getSourceRange());
806
807    Res = ParseCXXTypeConstructExpression(DS);
808    // This can be followed by postfix-expr pieces.
809    return ParsePostfixExpressionSuffix(move(Res));
810  }
811
812  case tok::annot_cxxscope: { // [C++] id-expression: qualified-id
813    Token Next = NextToken();
814    if (Next.is(tok::annot_template_id)) {
815      TemplateIdAnnotation *TemplateId
816        = static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue());
817      if (TemplateId->Kind == TNK_Type_template) {
818        // We have a qualified template-id that we know refers to a
819        // type, translate it into a type and continue parsing as a
820        // cast expression.
821        CXXScopeSpec SS;
822        ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/0, false);
823        AnnotateTemplateIdTokenAsType(&SS);
824        return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
825                                   NotCastExpr, TypeOfCast);
826      }
827    }
828
829    // Parse as an id-expression.
830    Res = ParseCXXIdExpression(isAddressOfOperand);
831    return ParsePostfixExpressionSuffix(move(Res));
832  }
833
834  case tok::annot_template_id: { // [C++]          template-id
835    TemplateIdAnnotation *TemplateId
836      = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
837    if (TemplateId->Kind == TNK_Type_template) {
838      // We have a template-id that we know refers to a type,
839      // translate it into a type and continue parsing as a cast
840      // expression.
841      AnnotateTemplateIdTokenAsType();
842      return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
843                                 NotCastExpr, TypeOfCast);
844    }
845
846    // Fall through to treat the template-id as an id-expression.
847  }
848
849  case tok::kw_operator: // [C++] id-expression: operator/conversion-function-id
850    Res = ParseCXXIdExpression(isAddressOfOperand);
851    return ParsePostfixExpressionSuffix(move(Res));
852
853  case tok::coloncolon: {
854    // ::foo::bar -> global qualified name etc.   If TryAnnotateTypeOrScopeToken
855    // annotates the token, tail recurse.
856    if (TryAnnotateTypeOrScopeToken())
857      return ExprError();
858    if (!Tok.is(tok::coloncolon))
859      return ParseCastExpression(isUnaryExpression, isAddressOfOperand);
860
861    // ::new -> [C++] new-expression
862    // ::delete -> [C++] delete-expression
863    SourceLocation CCLoc = ConsumeToken();
864    if (Tok.is(tok::kw_new))
865      return ParseCXXNewExpression(true, CCLoc);
866    if (Tok.is(tok::kw_delete))
867      return ParseCXXDeleteExpression(true, CCLoc);
868
869    // This is not a type name or scope specifier, it is an invalid expression.
870    Diag(CCLoc, diag::err_expected_expression);
871    return ExprError();
872  }
873
874  case tok::kw_new: // [C++] new-expression
875    return ParseCXXNewExpression(false, Tok.getLocation());
876
877  case tok::kw_delete: // [C++] delete-expression
878    return ParseCXXDeleteExpression(false, Tok.getLocation());
879
880  case tok::kw___is_pod: // [GNU] unary-type-trait
881  case tok::kw___is_class:
882  case tok::kw___is_enum:
883  case tok::kw___is_union:
884  case tok::kw___is_empty:
885  case tok::kw___is_polymorphic:
886  case tok::kw___is_abstract:
887  case tok::kw___is_literal:
888  case tok::kw___has_trivial_constructor:
889  case tok::kw___has_trivial_copy:
890  case tok::kw___has_trivial_assign:
891  case tok::kw___has_trivial_destructor:
892    return ParseUnaryTypeTrait();
893
894  case tok::at: {
895    SourceLocation AtLoc = ConsumeToken();
896    return ParseObjCAtExpression(AtLoc);
897  }
898  case tok::caret:
899    return ParsePostfixExpressionSuffix(ParseBlockLiteralExpression());
900  case tok::code_completion:
901    Actions.CodeCompleteOrdinaryName(CurScope, Action::CCC_Expression);
902    ConsumeToken();
903    return ParseCastExpression(isUnaryExpression, isAddressOfOperand,
904                               NotCastExpr, TypeOfCast);
905  case tok::l_square:
906    // These can be followed by postfix-expr pieces.
907    if (getLang().ObjC1)
908      return ParsePostfixExpressionSuffix(ParseObjCMessageExpression());
909    // FALL THROUGH.
910  default:
911    NotCastExpr = true;
912    return ExprError();
913  }
914
915  // unreachable.
916  abort();
917}
918
919/// ParsePostfixExpressionSuffix - Once the leading part of a postfix-expression
920/// is parsed, this method parses any suffixes that apply.
921///
922///       postfix-expression: [C99 6.5.2]
923///         primary-expression
924///         postfix-expression '[' expression ']'
925///         postfix-expression '(' argument-expression-list[opt] ')'
926///         postfix-expression '.' identifier
927///         postfix-expression '->' identifier
928///         postfix-expression '++'
929///         postfix-expression '--'
930///         '(' type-name ')' '{' initializer-list '}'
931///         '(' type-name ')' '{' initializer-list ',' '}'
932///
933///       argument-expression-list: [C99 6.5.2]
934///         argument-expression
935///         argument-expression-list ',' assignment-expression
936///
937Parser::OwningExprResult
938Parser::ParsePostfixExpressionSuffix(OwningExprResult LHS) {
939  // Now that the primary-expression piece of the postfix-expression has been
940  // parsed, see if there are any postfix-expression pieces here.
941  SourceLocation Loc;
942  while (1) {
943    switch (Tok.getKind()) {
944    default:  // Not a postfix-expression suffix.
945      return move(LHS);
946    case tok::l_square: {  // postfix-expression: p-e '[' expression ']'
947      Loc = ConsumeBracket();
948      OwningExprResult Idx(ParseExpression());
949
950      SourceLocation RLoc = Tok.getLocation();
951
952      if (!LHS.isInvalid() && !Idx.isInvalid() && Tok.is(tok::r_square)) {
953        LHS = Actions.ActOnArraySubscriptExpr(CurScope, move(LHS), Loc,
954                                              move(Idx), RLoc);
955      } else
956        LHS = ExprError();
957
958      // Match the ']'.
959      MatchRHSPunctuation(tok::r_square, Loc);
960      break;
961    }
962
963    case tok::l_paren: {   // p-e: p-e '(' argument-expression-list[opt] ')'
964      ExprVector ArgExprs(Actions);
965      CommaLocsTy CommaLocs;
966
967      Loc = ConsumeParen();
968
969      if (Tok.is(tok::code_completion)) {
970        Actions.CodeCompleteCall(CurScope, LHS.get(), 0, 0);
971        ConsumeToken();
972      }
973
974      if (Tok.isNot(tok::r_paren)) {
975        if (ParseExpressionList(ArgExprs, CommaLocs, &Action::CodeCompleteCall,
976                                LHS.get())) {
977          SkipUntil(tok::r_paren);
978          return ExprError();
979        }
980      }
981
982      // Match the ')'.
983      if (Tok.isNot(tok::r_paren)) {
984        MatchRHSPunctuation(tok::r_paren, Loc);
985        return ExprError();
986      }
987
988      if (!LHS.isInvalid()) {
989        assert((ArgExprs.size() == 0 || ArgExprs.size()-1 == CommaLocs.size())&&
990               "Unexpected number of commas!");
991        LHS = Actions.ActOnCallExpr(CurScope, move(LHS), Loc,
992                                    move_arg(ArgExprs), CommaLocs.data(),
993                                    Tok.getLocation());
994      }
995
996      ConsumeParen();
997      break;
998    }
999    case tok::arrow:
1000    case tok::period: {
1001      // postfix-expression: p-e '->' template[opt] id-expression
1002      // postfix-expression: p-e '.' template[opt] id-expression
1003      tok::TokenKind OpKind = Tok.getKind();
1004      SourceLocation OpLoc = ConsumeToken();  // Eat the "." or "->" token.
1005
1006      CXXScopeSpec SS;
1007      Action::TypeTy *ObjectType = 0;
1008      bool MayBePseudoDestructor = false;
1009      if (getLang().CPlusPlus && !LHS.isInvalid()) {
1010        LHS = Actions.ActOnStartCXXMemberReference(CurScope, move(LHS),
1011                                                   OpLoc, OpKind, ObjectType,
1012                                                   MayBePseudoDestructor);
1013        if (LHS.isInvalid())
1014          break;
1015
1016        ParseOptionalCXXScopeSpecifier(SS, ObjectType, false,
1017                                       &MayBePseudoDestructor);
1018      }
1019
1020      if (Tok.is(tok::code_completion)) {
1021        // Code completion for a member access expression.
1022        Actions.CodeCompleteMemberReferenceExpr(CurScope, LHS.get(),
1023                                                OpLoc, OpKind == tok::arrow);
1024
1025        ConsumeToken();
1026      }
1027
1028      if (MayBePseudoDestructor) {
1029        LHS = ParseCXXPseudoDestructor(move(LHS), OpLoc, OpKind, SS,
1030                                       ObjectType);
1031        break;
1032      }
1033
1034      // Either the action has told is that this cannot be a
1035      // pseudo-destructor expression (based on the type of base
1036      // expression), or we didn't see a '~' in the right place. We
1037      // can still parse a destructor name here, but in that case it
1038      // names a real destructor.
1039      UnqualifiedId Name;
1040      if (ParseUnqualifiedId(SS,
1041                             /*EnteringContext=*/false,
1042                             /*AllowDestructorName=*/true,
1043                             /*AllowConstructorName=*/false,
1044                             ObjectType,
1045                             Name))
1046        return ExprError();
1047
1048      if (!LHS.isInvalid())
1049        LHS = Actions.ActOnMemberAccessExpr(CurScope, move(LHS), OpLoc,
1050                                            OpKind, SS, Name, ObjCImpDecl,
1051                                            Tok.is(tok::l_paren));
1052      break;
1053    }
1054    case tok::plusplus:    // postfix-expression: postfix-expression '++'
1055    case tok::minusminus:  // postfix-expression: postfix-expression '--'
1056      if (!LHS.isInvalid()) {
1057        LHS = Actions.ActOnPostfixUnaryOp(CurScope, Tok.getLocation(),
1058                                          Tok.getKind(), move(LHS));
1059      }
1060      ConsumeToken();
1061      break;
1062    }
1063  }
1064}
1065
1066/// ParseExprAfterTypeofSizeofAlignof - We parsed a typeof/sizeof/alignof and
1067/// we are at the start of an expression or a parenthesized type-id.
1068/// OpTok is the operand token (typeof/sizeof/alignof). Returns the expression
1069/// (isCastExpr == false) or the type (isCastExpr == true).
1070///
1071///       unary-expression:  [C99 6.5.3]
1072///         'sizeof' unary-expression
1073///         'sizeof' '(' type-name ')'
1074/// [GNU]   '__alignof' unary-expression
1075/// [GNU]   '__alignof' '(' type-name ')'
1076/// [C++0x] 'alignof' '(' type-id ')'
1077///
1078/// [GNU]   typeof-specifier:
1079///           typeof ( expressions )
1080///           typeof ( type-name )
1081/// [GNU/C++] typeof unary-expression
1082///
1083Parser::OwningExprResult
1084Parser::ParseExprAfterTypeofSizeofAlignof(const Token &OpTok,
1085                                          bool &isCastExpr,
1086                                          TypeTy *&CastTy,
1087                                          SourceRange &CastRange) {
1088
1089  assert((OpTok.is(tok::kw_typeof)    || OpTok.is(tok::kw_sizeof) ||
1090          OpTok.is(tok::kw___alignof) || OpTok.is(tok::kw_alignof)) &&
1091          "Not a typeof/sizeof/alignof expression!");
1092
1093  OwningExprResult Operand(Actions);
1094
1095  // If the operand doesn't start with an '(', it must be an expression.
1096  if (Tok.isNot(tok::l_paren)) {
1097    isCastExpr = false;
1098    if (OpTok.is(tok::kw_typeof) && !getLang().CPlusPlus) {
1099      Diag(Tok,diag::err_expected_lparen_after_id) << OpTok.getIdentifierInfo();
1100      return ExprError();
1101    }
1102
1103    // C++0x [expr.sizeof]p1:
1104    //   [...] The operand is either an expression, which is an unevaluated
1105    //   operand (Clause 5) [...]
1106    //
1107    // The GNU typeof and alignof extensions also behave as unevaluated
1108    // operands.
1109    EnterExpressionEvaluationContext Unevaluated(Actions,
1110                                                 Action::Unevaluated);
1111    Operand = ParseCastExpression(true/*isUnaryExpression*/);
1112  } else {
1113    // If it starts with a '(', we know that it is either a parenthesized
1114    // type-name, or it is a unary-expression that starts with a compound
1115    // literal, or starts with a primary-expression that is a parenthesized
1116    // expression.
1117    ParenParseOption ExprType = CastExpr;
1118    SourceLocation LParenLoc = Tok.getLocation(), RParenLoc;
1119
1120    // C++0x [expr.sizeof]p1:
1121    //   [...] The operand is either an expression, which is an unevaluated
1122    //   operand (Clause 5) [...]
1123    //
1124    // The GNU typeof and alignof extensions also behave as unevaluated
1125    // operands.
1126    EnterExpressionEvaluationContext Unevaluated(Actions,
1127                                                 Action::Unevaluated);
1128    Operand = ParseParenExpression(ExprType, true/*stopIfCastExpr*/,
1129                                   0/*TypeOfCast*/,
1130                                   CastTy, RParenLoc);
1131    CastRange = SourceRange(LParenLoc, RParenLoc);
1132
1133    // If ParseParenExpression parsed a '(typename)' sequence only, then this is
1134    // a type.
1135    if (ExprType == CastExpr) {
1136      isCastExpr = true;
1137      return ExprEmpty();
1138    }
1139
1140    // If this is a parenthesized expression, it is the start of a
1141    // unary-expression, but doesn't include any postfix pieces.  Parse these
1142    // now if present.
1143    Operand = ParsePostfixExpressionSuffix(move(Operand));
1144  }
1145
1146  // If we get here, the operand to the typeof/sizeof/alignof was an expresion.
1147  isCastExpr = false;
1148  return move(Operand);
1149}
1150
1151
1152/// ParseSizeofAlignofExpression - Parse a sizeof or alignof expression.
1153///       unary-expression:  [C99 6.5.3]
1154///         'sizeof' unary-expression
1155///         'sizeof' '(' type-name ')'
1156/// [GNU]   '__alignof' unary-expression
1157/// [GNU]   '__alignof' '(' type-name ')'
1158/// [C++0x] 'alignof' '(' type-id ')'
1159Parser::OwningExprResult Parser::ParseSizeofAlignofExpression() {
1160  assert((Tok.is(tok::kw_sizeof) || Tok.is(tok::kw___alignof)
1161          || Tok.is(tok::kw_alignof)) &&
1162         "Not a sizeof/alignof expression!");
1163  Token OpTok = Tok;
1164  ConsumeToken();
1165
1166  bool isCastExpr;
1167  TypeTy *CastTy;
1168  SourceRange CastRange;
1169  OwningExprResult Operand = ParseExprAfterTypeofSizeofAlignof(OpTok,
1170                                                               isCastExpr,
1171                                                               CastTy,
1172                                                               CastRange);
1173
1174  if (isCastExpr)
1175    return Actions.ActOnSizeOfAlignOfExpr(OpTok.getLocation(),
1176                                          OpTok.is(tok::kw_sizeof),
1177                                          /*isType=*/true, CastTy,
1178                                          CastRange);
1179
1180  // If we get here, the operand to the sizeof/alignof was an expresion.
1181  if (!Operand.isInvalid())
1182    Operand = Actions.ActOnSizeOfAlignOfExpr(OpTok.getLocation(),
1183                                             OpTok.is(tok::kw_sizeof),
1184                                             /*isType=*/false,
1185                                             Operand.release(), CastRange);
1186  return move(Operand);
1187}
1188
1189/// ParseBuiltinPrimaryExpression
1190///
1191///       primary-expression: [C99 6.5.1]
1192/// [GNU]   '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
1193/// [GNU]   '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
1194/// [GNU]   '__builtin_choose_expr' '(' assign-expr ',' assign-expr ','
1195///                                     assign-expr ')'
1196/// [GNU]   '__builtin_types_compatible_p' '(' type-name ',' type-name ')'
1197///
1198/// [GNU] offsetof-member-designator:
1199/// [GNU]   identifier
1200/// [GNU]   offsetof-member-designator '.' identifier
1201/// [GNU]   offsetof-member-designator '[' expression ']'
1202///
1203Parser::OwningExprResult Parser::ParseBuiltinPrimaryExpression() {
1204  OwningExprResult Res(Actions);
1205  const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo();
1206
1207  tok::TokenKind T = Tok.getKind();
1208  SourceLocation StartLoc = ConsumeToken();   // Eat the builtin identifier.
1209
1210  // All of these start with an open paren.
1211  if (Tok.isNot(tok::l_paren))
1212    return ExprError(Diag(Tok, diag::err_expected_lparen_after_id)
1213                       << BuiltinII);
1214
1215  SourceLocation LParenLoc = ConsumeParen();
1216  // TODO: Build AST.
1217
1218  switch (T) {
1219  default: assert(0 && "Not a builtin primary expression!");
1220  case tok::kw___builtin_va_arg: {
1221    OwningExprResult Expr(ParseAssignmentExpression());
1222    if (Expr.isInvalid()) {
1223      SkipUntil(tok::r_paren);
1224      return ExprError();
1225    }
1226
1227    if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
1228      return ExprError();
1229
1230    TypeResult Ty = ParseTypeName();
1231
1232    if (Tok.isNot(tok::r_paren)) {
1233      Diag(Tok, diag::err_expected_rparen);
1234      return ExprError();
1235    }
1236    if (Ty.isInvalid())
1237      Res = ExprError();
1238    else
1239      Res = Actions.ActOnVAArg(StartLoc, move(Expr), Ty.get(), ConsumeParen());
1240    break;
1241  }
1242  case tok::kw___builtin_offsetof: {
1243    SourceLocation TypeLoc = Tok.getLocation();
1244    TypeResult Ty = ParseTypeName();
1245    if (Ty.isInvalid()) {
1246      SkipUntil(tok::r_paren);
1247      return ExprError();
1248    }
1249
1250    if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
1251      return ExprError();
1252
1253    // We must have at least one identifier here.
1254    if (Tok.isNot(tok::identifier)) {
1255      Diag(Tok, diag::err_expected_ident);
1256      SkipUntil(tok::r_paren);
1257      return ExprError();
1258    }
1259
1260    // Keep track of the various subcomponents we see.
1261    llvm::SmallVector<Action::OffsetOfComponent, 4> Comps;
1262
1263    Comps.push_back(Action::OffsetOfComponent());
1264    Comps.back().isBrackets = false;
1265    Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
1266    Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken();
1267
1268    // FIXME: This loop leaks the index expressions on error.
1269    while (1) {
1270      if (Tok.is(tok::period)) {
1271        // offsetof-member-designator: offsetof-member-designator '.' identifier
1272        Comps.push_back(Action::OffsetOfComponent());
1273        Comps.back().isBrackets = false;
1274        Comps.back().LocStart = ConsumeToken();
1275
1276        if (Tok.isNot(tok::identifier)) {
1277          Diag(Tok, diag::err_expected_ident);
1278          SkipUntil(tok::r_paren);
1279          return ExprError();
1280        }
1281        Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
1282        Comps.back().LocEnd = ConsumeToken();
1283
1284      } else if (Tok.is(tok::l_square)) {
1285        // offsetof-member-designator: offsetof-member-design '[' expression ']'
1286        Comps.push_back(Action::OffsetOfComponent());
1287        Comps.back().isBrackets = true;
1288        Comps.back().LocStart = ConsumeBracket();
1289        Res = ParseExpression();
1290        if (Res.isInvalid()) {
1291          SkipUntil(tok::r_paren);
1292          return move(Res);
1293        }
1294        Comps.back().U.E = Res.release();
1295
1296        Comps.back().LocEnd =
1297          MatchRHSPunctuation(tok::r_square, Comps.back().LocStart);
1298      } else {
1299        if (Tok.isNot(tok::r_paren)) {
1300          MatchRHSPunctuation(tok::r_paren, LParenLoc);
1301          Res = ExprError();
1302        } else if (Ty.isInvalid()) {
1303          Res = ExprError();
1304        } else {
1305          Res = Actions.ActOnBuiltinOffsetOf(CurScope, StartLoc, TypeLoc,
1306                                             Ty.get(), &Comps[0],
1307                                             Comps.size(), ConsumeParen());
1308        }
1309        break;
1310      }
1311    }
1312    break;
1313  }
1314  case tok::kw___builtin_choose_expr: {
1315    OwningExprResult Cond(ParseAssignmentExpression());
1316    if (Cond.isInvalid()) {
1317      SkipUntil(tok::r_paren);
1318      return move(Cond);
1319    }
1320    if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
1321      return ExprError();
1322
1323    OwningExprResult Expr1(ParseAssignmentExpression());
1324    if (Expr1.isInvalid()) {
1325      SkipUntil(tok::r_paren);
1326      return move(Expr1);
1327    }
1328    if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
1329      return ExprError();
1330
1331    OwningExprResult Expr2(ParseAssignmentExpression());
1332    if (Expr2.isInvalid()) {
1333      SkipUntil(tok::r_paren);
1334      return move(Expr2);
1335    }
1336    if (Tok.isNot(tok::r_paren)) {
1337      Diag(Tok, diag::err_expected_rparen);
1338      return ExprError();
1339    }
1340    Res = Actions.ActOnChooseExpr(StartLoc, move(Cond), move(Expr1),
1341                                  move(Expr2), ConsumeParen());
1342    break;
1343  }
1344  case tok::kw___builtin_types_compatible_p:
1345    TypeResult Ty1 = ParseTypeName();
1346
1347    if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren))
1348      return ExprError();
1349
1350    TypeResult Ty2 = ParseTypeName();
1351
1352    if (Tok.isNot(tok::r_paren)) {
1353      Diag(Tok, diag::err_expected_rparen);
1354      return ExprError();
1355    }
1356
1357    if (Ty1.isInvalid() || Ty2.isInvalid())
1358      Res = ExprError();
1359    else
1360      Res = Actions.ActOnTypesCompatibleExpr(StartLoc, Ty1.get(), Ty2.get(),
1361                                             ConsumeParen());
1362    break;
1363  }
1364
1365  // These can be followed by postfix-expr pieces because they are
1366  // primary-expressions.
1367  return ParsePostfixExpressionSuffix(move(Res));
1368}
1369
1370/// ParseParenExpression - This parses the unit that starts with a '(' token,
1371/// based on what is allowed by ExprType.  The actual thing parsed is returned
1372/// in ExprType. If stopIfCastExpr is true, it will only return the parsed type,
1373/// not the parsed cast-expression.
1374///
1375///       primary-expression: [C99 6.5.1]
1376///         '(' expression ')'
1377/// [GNU]   '(' compound-statement ')'      (if !ParenExprOnly)
1378///       postfix-expression: [C99 6.5.2]
1379///         '(' type-name ')' '{' initializer-list '}'
1380///         '(' type-name ')' '{' initializer-list ',' '}'
1381///       cast-expression: [C99 6.5.4]
1382///         '(' type-name ')' cast-expression
1383///
1384Parser::OwningExprResult
1385Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr,
1386                             TypeTy *TypeOfCast, TypeTy *&CastTy,
1387                             SourceLocation &RParenLoc) {
1388  assert(Tok.is(tok::l_paren) && "Not a paren expr!");
1389  GreaterThanIsOperatorScope G(GreaterThanIsOperator, true);
1390  SourceLocation OpenLoc = ConsumeParen();
1391  OwningExprResult Result(Actions, true);
1392  bool isAmbiguousTypeId;
1393  CastTy = 0;
1394
1395  if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) {
1396    Diag(Tok, diag::ext_gnu_statement_expr);
1397    OwningStmtResult Stmt(ParseCompoundStatement(0, true));
1398    ExprType = CompoundStmt;
1399
1400    // If the substmt parsed correctly, build the AST node.
1401    if (!Stmt.isInvalid() && Tok.is(tok::r_paren))
1402      Result = Actions.ActOnStmtExpr(OpenLoc, move(Stmt), Tok.getLocation());
1403
1404  } else if (ExprType >= CompoundLiteral &&
1405             isTypeIdInParens(isAmbiguousTypeId)) {
1406
1407    // Otherwise, this is a compound literal expression or cast expression.
1408
1409    // In C++, if the type-id is ambiguous we disambiguate based on context.
1410    // If stopIfCastExpr is true the context is a typeof/sizeof/alignof
1411    // in which case we should treat it as type-id.
1412    // if stopIfCastExpr is false, we need to determine the context past the
1413    // parens, so we defer to ParseCXXAmbiguousParenExpression for that.
1414    if (isAmbiguousTypeId && !stopIfCastExpr)
1415      return ParseCXXAmbiguousParenExpression(ExprType, CastTy,
1416                                              OpenLoc, RParenLoc);
1417
1418    TypeResult Ty = ParseTypeName();
1419
1420    // Match the ')'.
1421    if (Tok.is(tok::r_paren))
1422      RParenLoc = ConsumeParen();
1423    else
1424      MatchRHSPunctuation(tok::r_paren, OpenLoc);
1425
1426    if (Tok.is(tok::l_brace)) {
1427      ExprType = CompoundLiteral;
1428      return ParseCompoundLiteralExpression(Ty.get(), OpenLoc, RParenLoc);
1429    }
1430
1431    if (ExprType == CastExpr) {
1432      // We parsed '(' type-name ')' and the thing after it wasn't a '{'.
1433
1434      if (Ty.isInvalid())
1435        return ExprError();
1436
1437      CastTy = Ty.get();
1438
1439      if (stopIfCastExpr) {
1440        // Note that this doesn't parse the subsequent cast-expression, it just
1441        // returns the parsed type to the callee.
1442        return OwningExprResult(Actions);
1443      }
1444
1445      // Reject the cast of super idiom in ObjC.
1446      if (Tok.is(tok::identifier) && getLang().ObjC1 &&
1447          Tok.getIdentifierInfo() == Ident_super) {
1448        Diag(Tok.getLocation(), diag::err_illegal_super_cast)
1449          << SourceRange(OpenLoc, RParenLoc);
1450        return ExprError();
1451      }
1452
1453      // Parse the cast-expression that follows it next.
1454      // TODO: For cast expression with CastTy.
1455      Result = ParseCastExpression(false, false, CastTy);
1456      if (!Result.isInvalid())
1457        Result = Actions.ActOnCastExpr(CurScope, OpenLoc, CastTy, RParenLoc,
1458                                       move(Result));
1459      return move(Result);
1460    }
1461
1462    Diag(Tok, diag::err_expected_lbrace_in_compound_literal);
1463    return ExprError();
1464  } else if (TypeOfCast) {
1465    // Parse the expression-list.
1466    ExprVector ArgExprs(Actions);
1467    CommaLocsTy CommaLocs;
1468
1469    if (!ParseExpressionList(ArgExprs, CommaLocs)) {
1470      ExprType = SimpleExpr;
1471      Result = Actions.ActOnParenOrParenListExpr(OpenLoc, Tok.getLocation(),
1472                                          move_arg(ArgExprs), TypeOfCast);
1473    }
1474  } else {
1475    Result = ParseExpression();
1476    ExprType = SimpleExpr;
1477    if (!Result.isInvalid() && Tok.is(tok::r_paren))
1478      Result = Actions.ActOnParenExpr(OpenLoc, Tok.getLocation(), move(Result));
1479  }
1480
1481  // Match the ')'.
1482  if (Result.isInvalid()) {
1483    SkipUntil(tok::r_paren);
1484    return ExprError();
1485  }
1486
1487  if (Tok.is(tok::r_paren))
1488    RParenLoc = ConsumeParen();
1489  else
1490    MatchRHSPunctuation(tok::r_paren, OpenLoc);
1491
1492  return move(Result);
1493}
1494
1495/// ParseCompoundLiteralExpression - We have parsed the parenthesized type-name
1496/// and we are at the left brace.
1497///
1498///       postfix-expression: [C99 6.5.2]
1499///         '(' type-name ')' '{' initializer-list '}'
1500///         '(' type-name ')' '{' initializer-list ',' '}'
1501///
1502Parser::OwningExprResult
1503Parser::ParseCompoundLiteralExpression(TypeTy *Ty,
1504                                       SourceLocation LParenLoc,
1505                                       SourceLocation RParenLoc) {
1506  assert(Tok.is(tok::l_brace) && "Not a compound literal!");
1507  if (!getLang().C99)   // Compound literals don't exist in C90.
1508    Diag(LParenLoc, diag::ext_c99_compound_literal);
1509  OwningExprResult Result = ParseInitializer();
1510  if (!Result.isInvalid() && Ty)
1511    return Actions.ActOnCompoundLiteral(LParenLoc, Ty, RParenLoc, move(Result));
1512  return move(Result);
1513}
1514
1515/// ParseStringLiteralExpression - This handles the various token types that
1516/// form string literals, and also handles string concatenation [C99 5.1.1.2,
1517/// translation phase #6].
1518///
1519///       primary-expression: [C99 6.5.1]
1520///         string-literal
1521Parser::OwningExprResult Parser::ParseStringLiteralExpression() {
1522  assert(isTokenStringLiteral() && "Not a string literal!");
1523
1524  // String concat.  Note that keywords like __func__ and __FUNCTION__ are not
1525  // considered to be strings for concatenation purposes.
1526  llvm::SmallVector<Token, 4> StringToks;
1527
1528  do {
1529    StringToks.push_back(Tok);
1530    ConsumeStringToken();
1531  } while (isTokenStringLiteral());
1532
1533  // Pass the set of string tokens, ready for concatenation, to the actions.
1534  return Actions.ActOnStringLiteral(&StringToks[0], StringToks.size());
1535}
1536
1537/// ParseExpressionList - Used for C/C++ (argument-)expression-list.
1538///
1539///       argument-expression-list:
1540///         assignment-expression
1541///         argument-expression-list , assignment-expression
1542///
1543/// [C++] expression-list:
1544/// [C++]   assignment-expression
1545/// [C++]   expression-list , assignment-expression
1546///
1547bool Parser::ParseExpressionList(ExprListTy &Exprs, CommaLocsTy &CommaLocs,
1548                                 void (Action::*Completer)(Scope *S,
1549                                                           void *Data,
1550                                                           ExprTy **Args,
1551                                                           unsigned NumArgs),
1552                                 void *Data) {
1553  while (1) {
1554    if (Tok.is(tok::code_completion)) {
1555      if (Completer)
1556        (Actions.*Completer)(CurScope, Data, Exprs.data(), Exprs.size());
1557      ConsumeToken();
1558    }
1559
1560    OwningExprResult Expr(ParseAssignmentExpression());
1561    if (Expr.isInvalid())
1562      return true;
1563
1564    Exprs.push_back(Expr.release());
1565
1566    if (Tok.isNot(tok::comma))
1567      return false;
1568    // Move to the next argument, remember where the comma was.
1569    CommaLocs.push_back(ConsumeToken());
1570  }
1571}
1572
1573/// ParseBlockId - Parse a block-id, which roughly looks like int (int x).
1574///
1575/// [clang] block-id:
1576/// [clang]   specifier-qualifier-list block-declarator
1577///
1578void Parser::ParseBlockId() {
1579  // Parse the specifier-qualifier-list piece.
1580  DeclSpec DS;
1581  ParseSpecifierQualifierList(DS);
1582
1583  // Parse the block-declarator.
1584  Declarator DeclaratorInfo(DS, Declarator::BlockLiteralContext);
1585  ParseDeclarator(DeclaratorInfo);
1586
1587  // We do this for: ^ __attribute__((noreturn)) {, as DS has the attributes.
1588  DeclaratorInfo.AddAttributes(DS.TakeAttributes(),
1589                               SourceLocation());
1590
1591  if (Tok.is(tok::kw___attribute)) {
1592    SourceLocation Loc;
1593    AttributeList *AttrList = ParseGNUAttributes(&Loc);
1594    DeclaratorInfo.AddAttributes(AttrList, Loc);
1595  }
1596
1597  // Inform sema that we are starting a block.
1598  Actions.ActOnBlockArguments(DeclaratorInfo, CurScope);
1599}
1600
1601/// ParseBlockLiteralExpression - Parse a block literal, which roughly looks
1602/// like ^(int x){ return x+1; }
1603///
1604///         block-literal:
1605/// [clang]   '^' block-args[opt] compound-statement
1606/// [clang]   '^' block-id compound-statement
1607/// [clang] block-args:
1608/// [clang]   '(' parameter-list ')'
1609///
1610Parser::OwningExprResult Parser::ParseBlockLiteralExpression() {
1611  assert(Tok.is(tok::caret) && "block literal starts with ^");
1612  SourceLocation CaretLoc = ConsumeToken();
1613
1614  PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), CaretLoc,
1615                                "block literal parsing");
1616
1617  // Enter a scope to hold everything within the block.  This includes the
1618  // argument decls, decls within the compound expression, etc.  This also
1619  // allows determining whether a variable reference inside the block is
1620  // within or outside of the block.
1621  ParseScope BlockScope(this, Scope::BlockScope | Scope::FnScope |
1622                              Scope::BreakScope | Scope::ContinueScope |
1623                              Scope::DeclScope);
1624
1625  // Inform sema that we are starting a block.
1626  Actions.ActOnBlockStart(CaretLoc, CurScope);
1627
1628  // Parse the return type if present.
1629  DeclSpec DS;
1630  Declarator ParamInfo(DS, Declarator::BlockLiteralContext);
1631  // FIXME: Since the return type isn't actually parsed, it can't be used to
1632  // fill ParamInfo with an initial valid range, so do it manually.
1633  ParamInfo.SetSourceRange(SourceRange(Tok.getLocation(), Tok.getLocation()));
1634
1635  // If this block has arguments, parse them.  There is no ambiguity here with
1636  // the expression case, because the expression case requires a parameter list.
1637  if (Tok.is(tok::l_paren)) {
1638    ParseParenDeclarator(ParamInfo);
1639    // Parse the pieces after the identifier as if we had "int(...)".
1640    // SetIdentifier sets the source range end, but in this case we're past
1641    // that location.
1642    SourceLocation Tmp = ParamInfo.getSourceRange().getEnd();
1643    ParamInfo.SetIdentifier(0, CaretLoc);
1644    ParamInfo.SetRangeEnd(Tmp);
1645    if (ParamInfo.isInvalidType()) {
1646      // If there was an error parsing the arguments, they may have
1647      // tried to use ^(x+y) which requires an argument list.  Just
1648      // skip the whole block literal.
1649      Actions.ActOnBlockError(CaretLoc, CurScope);
1650      return ExprError();
1651    }
1652
1653    if (Tok.is(tok::kw___attribute)) {
1654      SourceLocation Loc;
1655      AttributeList *AttrList = ParseGNUAttributes(&Loc);
1656      ParamInfo.AddAttributes(AttrList, Loc);
1657    }
1658
1659    // Inform sema that we are starting a block.
1660    Actions.ActOnBlockArguments(ParamInfo, CurScope);
1661  } else if (!Tok.is(tok::l_brace)) {
1662    ParseBlockId();
1663  } else {
1664    // Otherwise, pretend we saw (void).
1665    ParamInfo.AddTypeInfo(DeclaratorChunk::getFunction(true, false,
1666                                                       SourceLocation(),
1667                                                       0, 0, 0,
1668                                                       false, SourceLocation(),
1669                                                       false, 0, 0, 0,
1670                                                       CaretLoc, CaretLoc,
1671                                                       ParamInfo),
1672                          CaretLoc);
1673
1674    if (Tok.is(tok::kw___attribute)) {
1675      SourceLocation Loc;
1676      AttributeList *AttrList = ParseGNUAttributes(&Loc);
1677      ParamInfo.AddAttributes(AttrList, Loc);
1678    }
1679
1680    // Inform sema that we are starting a block.
1681    Actions.ActOnBlockArguments(ParamInfo, CurScope);
1682  }
1683
1684
1685  OwningExprResult Result(Actions, true);
1686  if (!Tok.is(tok::l_brace)) {
1687    // Saw something like: ^expr
1688    Diag(Tok, diag::err_expected_expression);
1689    Actions.ActOnBlockError(CaretLoc, CurScope);
1690    return ExprError();
1691  }
1692
1693  OwningStmtResult Stmt(ParseCompoundStatementBody());
1694  if (!Stmt.isInvalid())
1695    Result = Actions.ActOnBlockStmtExpr(CaretLoc, move(Stmt), CurScope);
1696  else
1697    Actions.ActOnBlockError(CaretLoc, CurScope);
1698  return move(Result);
1699}
1700