ParseExprCXX.cpp revision dec0984fce504a39a7f085774fb67cfd9957be58 
1//===--- ParseExprCXX.cpp - C++ 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 for C++.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Parse/ParseDiagnostic.h"
15#include "clang/Parse/Parser.h"
16#include "RAIIObjectsForParser.h"
17#include "clang/Sema/DeclSpec.h"
18#include "clang/Sema/ParsedTemplate.h"
19#include "llvm/Support/ErrorHandling.h"
20
21using namespace clang;
22
23/// \brief Parse global scope or nested-name-specifier if present.
24///
25/// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
26/// may be preceded by '::'). Note that this routine will not parse ::new or
27/// ::delete; it will just leave them in the token stream.
28///
29///       '::'[opt] nested-name-specifier
30///       '::'
31///
32///       nested-name-specifier:
33///         type-name '::'
34///         namespace-name '::'
35///         nested-name-specifier identifier '::'
36///         nested-name-specifier 'template'[opt] simple-template-id '::'
37///
38///
39/// \param SS the scope specifier that will be set to the parsed
40/// nested-name-specifier (or empty)
41///
42/// \param ObjectType if this nested-name-specifier is being parsed following
43/// the "." or "->" of a member access expression, this parameter provides the
44/// type of the object whose members are being accessed.
45///
46/// \param EnteringContext whether we will be entering into the context of
47/// the nested-name-specifier after parsing it.
48///
49/// \param MayBePseudoDestructor When non-NULL, points to a flag that
50/// indicates whether this nested-name-specifier may be part of a
51/// pseudo-destructor name. In this case, the flag will be set false
52/// if we don't actually end up parsing a destructor name. Moreorover,
53/// if we do end up determining that we are parsing a destructor name,
54/// the last component of the nested-name-specifier is not parsed as
55/// part of the scope specifier.
56
57/// member access expression, e.g., the \p T:: in \p p->T::m.
58///
59/// \returns true if there was an error parsing a scope specifier
60bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
61                                            ParsedType ObjectType,
62                                            bool EnteringContext,
63                                            bool *MayBePseudoDestructor) {
64  assert(getLang().CPlusPlus &&
65         "Call sites of this function should be guarded by checking for C++");
66
67  if (Tok.is(tok::annot_cxxscope)) {
68    SS.setScopeRep(static_cast<NestedNameSpecifier*>(Tok.getAnnotationValue()));
69    SS.setRange(Tok.getAnnotationRange());
70    ConsumeToken();
71    return false;
72  }
73
74  bool HasScopeSpecifier = false;
75
76  if (Tok.is(tok::coloncolon)) {
77    // ::new and ::delete aren't nested-name-specifiers.
78    tok::TokenKind NextKind = NextToken().getKind();
79    if (NextKind == tok::kw_new || NextKind == tok::kw_delete)
80      return false;
81
82    // '::' - Global scope qualifier.
83    SourceLocation CCLoc = ConsumeToken();
84    SS.setBeginLoc(CCLoc);
85    SS.setScopeRep(Actions.ActOnCXXGlobalScopeSpecifier(getCurScope(), CCLoc));
86    SS.setEndLoc(CCLoc);
87    HasScopeSpecifier = true;
88  }
89
90  bool CheckForDestructor = false;
91  if (MayBePseudoDestructor && *MayBePseudoDestructor) {
92    CheckForDestructor = true;
93    *MayBePseudoDestructor = false;
94  }
95
96  while (true) {
97    if (HasScopeSpecifier) {
98      // C++ [basic.lookup.classref]p5:
99      //   If the qualified-id has the form
100      //
101      //       ::class-name-or-namespace-name::...
102      //
103      //   the class-name-or-namespace-name is looked up in global scope as a
104      //   class-name or namespace-name.
105      //
106      // To implement this, we clear out the object type as soon as we've
107      // seen a leading '::' or part of a nested-name-specifier.
108      ObjectType = ParsedType();
109
110      if (Tok.is(tok::code_completion)) {
111        // Code completion for a nested-name-specifier, where the code
112        // code completion token follows the '::'.
113        Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext);
114        ConsumeCodeCompletionToken();
115      }
116    }
117
118    // nested-name-specifier:
119    //   nested-name-specifier 'template'[opt] simple-template-id '::'
120
121    // Parse the optional 'template' keyword, then make sure we have
122    // 'identifier <' after it.
123    if (Tok.is(tok::kw_template)) {
124      // If we don't have a scope specifier or an object type, this isn't a
125      // nested-name-specifier, since they aren't allowed to start with
126      // 'template'.
127      if (!HasScopeSpecifier && !ObjectType)
128        break;
129
130      TentativeParsingAction TPA(*this);
131      SourceLocation TemplateKWLoc = ConsumeToken();
132
133      UnqualifiedId TemplateName;
134      if (Tok.is(tok::identifier)) {
135        // Consume the identifier.
136        TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
137        ConsumeToken();
138      } else if (Tok.is(tok::kw_operator)) {
139        if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,
140                                       TemplateName)) {
141          TPA.Commit();
142          break;
143        }
144
145        if (TemplateName.getKind() != UnqualifiedId::IK_OperatorFunctionId &&
146            TemplateName.getKind() != UnqualifiedId::IK_LiteralOperatorId) {
147          Diag(TemplateName.getSourceRange().getBegin(),
148               diag::err_id_after_template_in_nested_name_spec)
149            << TemplateName.getSourceRange();
150          TPA.Commit();
151          break;
152        }
153      } else {
154        TPA.Revert();
155        break;
156      }
157
158      // If the next token is not '<', we have a qualified-id that refers
159      // to a template name, such as T::template apply, but is not a
160      // template-id.
161      if (Tok.isNot(tok::less)) {
162        TPA.Revert();
163        break;
164      }
165
166      // Commit to parsing the template-id.
167      TPA.Commit();
168      TemplateTy Template;
169      if (TemplateNameKind TNK = Actions.ActOnDependentTemplateName(getCurScope(),
170                                                                TemplateKWLoc,
171                                                                    SS,
172                                                                  TemplateName,
173                                                                    ObjectType,
174                                                                EnteringContext,
175                                                                    Template)) {
176        if (AnnotateTemplateIdToken(Template, TNK, &SS, TemplateName,
177                                    TemplateKWLoc, false))
178          return true;
179      } else
180        return true;
181
182      continue;
183    }
184
185    if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
186      // We have
187      //
188      //   simple-template-id '::'
189      //
190      // So we need to check whether the simple-template-id is of the
191      // right kind (it should name a type or be dependent), and then
192      // convert it into a type within the nested-name-specifier.
193      TemplateIdAnnotation *TemplateId
194        = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
195      if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
196        *MayBePseudoDestructor = true;
197        return false;
198      }
199
200      if (TemplateId->Kind == TNK_Type_template ||
201          TemplateId->Kind == TNK_Dependent_template_name) {
202        AnnotateTemplateIdTokenAsType(&SS);
203
204        assert(Tok.is(tok::annot_typename) &&
205               "AnnotateTemplateIdTokenAsType isn't working");
206        Token TypeToken = Tok;
207        ConsumeToken();
208        assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
209        SourceLocation CCLoc = ConsumeToken();
210
211        if (!HasScopeSpecifier) {
212          SS.setBeginLoc(TypeToken.getLocation());
213          HasScopeSpecifier = true;
214        }
215
216        if (ParsedType T = getTypeAnnotation(TypeToken)) {
217          CXXScopeTy *Scope =
218            Actions.ActOnCXXNestedNameSpecifier(getCurScope(), SS, T,
219                                                TypeToken.getAnnotationRange(),
220                                                CCLoc);
221          SS.setScopeRep(Scope);
222        } else
223          SS.setScopeRep(0);
224        SS.setEndLoc(CCLoc);
225        continue;
226      }
227
228      assert(false && "FIXME: Only type template names supported here");
229    }
230
231
232    // The rest of the nested-name-specifier possibilities start with
233    // tok::identifier.
234    if (Tok.isNot(tok::identifier))
235      break;
236
237    IdentifierInfo &II = *Tok.getIdentifierInfo();
238
239    // nested-name-specifier:
240    //   type-name '::'
241    //   namespace-name '::'
242    //   nested-name-specifier identifier '::'
243    Token Next = NextToken();
244
245    // If we get foo:bar, this is almost certainly a typo for foo::bar.  Recover
246    // and emit a fixit hint for it.
247    if (Next.is(tok::colon) && !ColonIsSacred) {
248      if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, II, ObjectType,
249                                            EnteringContext) &&
250          // If the token after the colon isn't an identifier, it's still an
251          // error, but they probably meant something else strange so don't
252          // recover like this.
253          PP.LookAhead(1).is(tok::identifier)) {
254        Diag(Next, diag::err_unexected_colon_in_nested_name_spec)
255          << FixItHint::CreateReplacement(Next.getLocation(), "::");
256
257        // Recover as if the user wrote '::'.
258        Next.setKind(tok::coloncolon);
259      }
260    }
261
262    if (Next.is(tok::coloncolon)) {
263      if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde) &&
264          !Actions.isNonTypeNestedNameSpecifier(getCurScope(), SS, Tok.getLocation(),
265                                                II, ObjectType)) {
266        *MayBePseudoDestructor = true;
267        return false;
268      }
269
270      // We have an identifier followed by a '::'. Lookup this name
271      // as the name in a nested-name-specifier.
272      SourceLocation IdLoc = ConsumeToken();
273      assert((Tok.is(tok::coloncolon) || Tok.is(tok::colon)) &&
274             "NextToken() not working properly!");
275      SourceLocation CCLoc = ConsumeToken();
276
277      if (!HasScopeSpecifier) {
278        SS.setBeginLoc(IdLoc);
279        HasScopeSpecifier = true;
280      }
281
282      if (!SS.isInvalid())
283        SS.setScopeRep(
284            Actions.ActOnCXXNestedNameSpecifier(getCurScope(), SS, IdLoc, CCLoc, II,
285                                                ObjectType, EnteringContext));
286      SS.setEndLoc(CCLoc);
287      continue;
288    }
289
290    // nested-name-specifier:
291    //   type-name '<'
292    if (Next.is(tok::less)) {
293      TemplateTy Template;
294      UnqualifiedId TemplateName;
295      TemplateName.setIdentifier(&II, Tok.getLocation());
296      bool MemberOfUnknownSpecialization;
297      if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
298                                              /*hasTemplateKeyword=*/false,
299                                                        TemplateName,
300                                                        ObjectType,
301                                                        EnteringContext,
302                                                        Template,
303                                              MemberOfUnknownSpecialization)) {
304        // We have found a template name, so annotate this this token
305        // with a template-id annotation. We do not permit the
306        // template-id to be translated into a type annotation,
307        // because some clients (e.g., the parsing of class template
308        // specializations) still want to see the original template-id
309        // token.
310        ConsumeToken();
311        if (AnnotateTemplateIdToken(Template, TNK, &SS, TemplateName,
312                                    SourceLocation(), false))
313          return true;
314        continue;
315      }
316
317      if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) &&
318          IsTemplateArgumentList(1)) {
319        // We have something like t::getAs<T>, where getAs is a
320        // member of an unknown specialization. However, this will only
321        // parse correctly as a template, so suggest the keyword 'template'
322        // before 'getAs' and treat this as a dependent template name.
323        Diag(Tok.getLocation(), diag::err_missing_dependent_template_keyword)
324          << II.getName()
325          << FixItHint::CreateInsertion(Tok.getLocation(), "template ");
326
327        if (TemplateNameKind TNK
328              = Actions.ActOnDependentTemplateName(getCurScope(),
329                                                   Tok.getLocation(), SS,
330                                                   TemplateName, ObjectType,
331                                                   EnteringContext, Template)) {
332          // Consume the identifier.
333          ConsumeToken();
334          if (AnnotateTemplateIdToken(Template, TNK, &SS, TemplateName,
335                                      SourceLocation(), false))
336            return true;
337        }
338        else
339          return true;
340
341        continue;
342      }
343    }
344
345    // We don't have any tokens that form the beginning of a
346    // nested-name-specifier, so we're done.
347    break;
348  }
349
350  // Even if we didn't see any pieces of a nested-name-specifier, we
351  // still check whether there is a tilde in this position, which
352  // indicates a potential pseudo-destructor.
353  if (CheckForDestructor && Tok.is(tok::tilde))
354    *MayBePseudoDestructor = true;
355
356  return false;
357}
358
359/// ParseCXXIdExpression - Handle id-expression.
360///
361///       id-expression:
362///         unqualified-id
363///         qualified-id
364///
365///       qualified-id:
366///         '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
367///         '::' identifier
368///         '::' operator-function-id
369///         '::' template-id
370///
371/// NOTE: The standard specifies that, for qualified-id, the parser does not
372/// expect:
373///
374///   '::' conversion-function-id
375///   '::' '~' class-name
376///
377/// This may cause a slight inconsistency on diagnostics:
378///
379/// class C {};
380/// namespace A {}
381/// void f() {
382///   :: A :: ~ C(); // Some Sema error about using destructor with a
383///                  // namespace.
384///   :: ~ C(); // Some Parser error like 'unexpected ~'.
385/// }
386///
387/// We simplify the parser a bit and make it work like:
388///
389///       qualified-id:
390///         '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
391///         '::' unqualified-id
392///
393/// That way Sema can handle and report similar errors for namespaces and the
394/// global scope.
395///
396/// The isAddressOfOperand parameter indicates that this id-expression is a
397/// direct operand of the address-of operator. This is, besides member contexts,
398/// the only place where a qualified-id naming a non-static class member may
399/// appear.
400///
401ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
402  // qualified-id:
403  //   '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
404  //   '::' unqualified-id
405  //
406  CXXScopeSpec SS;
407  ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false);
408
409  UnqualifiedId Name;
410  if (ParseUnqualifiedId(SS,
411                         /*EnteringContext=*/false,
412                         /*AllowDestructorName=*/false,
413                         /*AllowConstructorName=*/false,
414                         /*ObjectType=*/ ParsedType(),
415                         Name))
416    return ExprError();
417
418  // This is only the direct operand of an & operator if it is not
419  // followed by a postfix-expression suffix.
420  if (isAddressOfOperand && isPostfixExpressionSuffixStart())
421    isAddressOfOperand = false;
422
423  return Actions.ActOnIdExpression(getCurScope(), SS, Name, Tok.is(tok::l_paren),
424                                   isAddressOfOperand);
425
426}
427
428/// ParseCXXCasts - This handles the various ways to cast expressions to another
429/// type.
430///
431///       postfix-expression: [C++ 5.2p1]
432///         'dynamic_cast' '<' type-name '>' '(' expression ')'
433///         'static_cast' '<' type-name '>' '(' expression ')'
434///         'reinterpret_cast' '<' type-name '>' '(' expression ')'
435///         'const_cast' '<' type-name '>' '(' expression ')'
436///
437ExprResult Parser::ParseCXXCasts() {
438  tok::TokenKind Kind = Tok.getKind();
439  const char *CastName = 0;     // For error messages
440
441  switch (Kind) {
442  default: assert(0 && "Unknown C++ cast!"); abort();
443  case tok::kw_const_cast:       CastName = "const_cast";       break;
444  case tok::kw_dynamic_cast:     CastName = "dynamic_cast";     break;
445  case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
446  case tok::kw_static_cast:      CastName = "static_cast";      break;
447  }
448
449  SourceLocation OpLoc = ConsumeToken();
450  SourceLocation LAngleBracketLoc = Tok.getLocation();
451
452  if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
453    return ExprError();
454
455  TypeResult CastTy = ParseTypeName();
456  SourceLocation RAngleBracketLoc = Tok.getLocation();
457
458  if (ExpectAndConsume(tok::greater, diag::err_expected_greater))
459    return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << "<");
460
461  SourceLocation LParenLoc = Tok.getLocation(), RParenLoc;
462
463  if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, CastName))
464    return ExprError();
465
466  ExprResult Result = ParseExpression();
467
468  // Match the ')'.
469  RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
470
471  if (!Result.isInvalid() && !CastTy.isInvalid())
472    Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
473                                       LAngleBracketLoc, CastTy.get(),
474                                       RAngleBracketLoc,
475                                       LParenLoc, Result.take(), RParenLoc);
476
477  return move(Result);
478}
479
480/// ParseCXXTypeid - This handles the C++ typeid expression.
481///
482///       postfix-expression: [C++ 5.2p1]
483///         'typeid' '(' expression ')'
484///         'typeid' '(' type-id ')'
485///
486ExprResult Parser::ParseCXXTypeid() {
487  assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
488
489  SourceLocation OpLoc = ConsumeToken();
490  SourceLocation LParenLoc = Tok.getLocation();
491  SourceLocation RParenLoc;
492
493  // typeid expressions are always parenthesized.
494  if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
495      "typeid"))
496    return ExprError();
497
498  ExprResult Result;
499
500  if (isTypeIdInParens()) {
501    TypeResult Ty = ParseTypeName();
502
503    // Match the ')'.
504    RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
505
506    if (Ty.isInvalid() || RParenLoc.isInvalid())
507      return ExprError();
508
509    Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
510                                    Ty.get().getAsOpaquePtr(), RParenLoc);
511  } else {
512    // C++0x [expr.typeid]p3:
513    //   When typeid is applied to an expression other than an lvalue of a
514    //   polymorphic class type [...] The expression is an unevaluated
515    //   operand (Clause 5).
516    //
517    // Note that we can't tell whether the expression is an lvalue of a
518    // polymorphic class type until after we've parsed the expression, so
519    // we the expression is potentially potentially evaluated.
520    EnterExpressionEvaluationContext Unevaluated(Actions,
521                                       Sema::PotentiallyPotentiallyEvaluated);
522    Result = ParseExpression();
523
524    // Match the ')'.
525    if (Result.isInvalid())
526      SkipUntil(tok::r_paren);
527    else {
528      RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
529      if (RParenLoc.isInvalid())
530        return ExprError();
531
532      Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
533                                      Result.release(), RParenLoc);
534    }
535  }
536
537  return move(Result);
538}
539
540/// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
541///
542///         '__uuidof' '(' expression ')'
543///         '__uuidof' '(' type-id ')'
544///
545ExprResult Parser::ParseCXXUuidof() {
546  assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!");
547
548  SourceLocation OpLoc = ConsumeToken();
549  SourceLocation LParenLoc = Tok.getLocation();
550  SourceLocation RParenLoc;
551
552  // __uuidof expressions are always parenthesized.
553  if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
554      "__uuidof"))
555    return ExprError();
556
557  ExprResult Result;
558
559  if (isTypeIdInParens()) {
560    TypeResult Ty = ParseTypeName();
561
562    // Match the ')'.
563    RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
564
565    if (Ty.isInvalid())
566      return ExprError();
567
568    Result = Actions.ActOnCXXUuidof(OpLoc, LParenLoc, /*isType=*/true,
569                                    Ty.get().getAsOpaquePtr(), RParenLoc);
570  } else {
571    EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
572    Result = ParseExpression();
573
574    // Match the ')'.
575    if (Result.isInvalid())
576      SkipUntil(tok::r_paren);
577    else {
578      RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
579
580      Result = Actions.ActOnCXXUuidof(OpLoc, LParenLoc, /*isType=*/false,
581                                      Result.release(), RParenLoc);
582    }
583  }
584
585  return move(Result);
586}
587
588/// \brief Parse a C++ pseudo-destructor expression after the base,
589/// . or -> operator, and nested-name-specifier have already been
590/// parsed.
591///
592///       postfix-expression: [C++ 5.2]
593///         postfix-expression . pseudo-destructor-name
594///         postfix-expression -> pseudo-destructor-name
595///
596///       pseudo-destructor-name:
597///         ::[opt] nested-name-specifier[opt] type-name :: ~type-name
598///         ::[opt] nested-name-specifier template simple-template-id ::
599///                 ~type-name
600///         ::[opt] nested-name-specifier[opt] ~type-name
601///
602ExprResult
603Parser::ParseCXXPseudoDestructor(ExprArg Base, SourceLocation OpLoc,
604                                 tok::TokenKind OpKind,
605                                 CXXScopeSpec &SS,
606                                 ParsedType ObjectType) {
607  // We're parsing either a pseudo-destructor-name or a dependent
608  // member access that has the same form as a
609  // pseudo-destructor-name. We parse both in the same way and let
610  // the action model sort them out.
611  //
612  // Note that the ::[opt] nested-name-specifier[opt] has already
613  // been parsed, and if there was a simple-template-id, it has
614  // been coalesced into a template-id annotation token.
615  UnqualifiedId FirstTypeName;
616  SourceLocation CCLoc;
617  if (Tok.is(tok::identifier)) {
618    FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
619    ConsumeToken();
620    assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
621    CCLoc = ConsumeToken();
622  } else if (Tok.is(tok::annot_template_id)) {
623    FirstTypeName.setTemplateId(
624                              (TemplateIdAnnotation *)Tok.getAnnotationValue());
625    ConsumeToken();
626    assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
627    CCLoc = ConsumeToken();
628  } else {
629    FirstTypeName.setIdentifier(0, SourceLocation());
630  }
631
632  // Parse the tilde.
633  assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail");
634  SourceLocation TildeLoc = ConsumeToken();
635  if (!Tok.is(tok::identifier)) {
636    Diag(Tok, diag::err_destructor_tilde_identifier);
637    return ExprError();
638  }
639
640  // Parse the second type.
641  UnqualifiedId SecondTypeName;
642  IdentifierInfo *Name = Tok.getIdentifierInfo();
643  SourceLocation NameLoc = ConsumeToken();
644  SecondTypeName.setIdentifier(Name, NameLoc);
645
646  // If there is a '<', the second type name is a template-id. Parse
647  // it as such.
648  if (Tok.is(tok::less) &&
649      ParseUnqualifiedIdTemplateId(SS, Name, NameLoc, false, ObjectType,
650                                   SecondTypeName, /*AssumeTemplateName=*/true,
651                                   /*TemplateKWLoc*/SourceLocation()))
652    return ExprError();
653
654  return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base,
655                                           OpLoc, OpKind,
656                                           SS, FirstTypeName, CCLoc,
657                                           TildeLoc, SecondTypeName,
658                                           Tok.is(tok::l_paren));
659}
660
661/// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
662///
663///       boolean-literal: [C++ 2.13.5]
664///         'true'
665///         'false'
666ExprResult Parser::ParseCXXBoolLiteral() {
667  tok::TokenKind Kind = Tok.getKind();
668  return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
669}
670
671/// ParseThrowExpression - This handles the C++ throw expression.
672///
673///       throw-expression: [C++ 15]
674///         'throw' assignment-expression[opt]
675ExprResult Parser::ParseThrowExpression() {
676  assert(Tok.is(tok::kw_throw) && "Not throw!");
677  SourceLocation ThrowLoc = ConsumeToken();           // Eat the throw token.
678
679  // If the current token isn't the start of an assignment-expression,
680  // then the expression is not present.  This handles things like:
681  //   "C ? throw : (void)42", which is crazy but legal.
682  switch (Tok.getKind()) {  // FIXME: move this predicate somewhere common.
683  case tok::semi:
684  case tok::r_paren:
685  case tok::r_square:
686  case tok::r_brace:
687  case tok::colon:
688  case tok::comma:
689    return Actions.ActOnCXXThrow(ThrowLoc, 0);
690
691  default:
692    ExprResult Expr(ParseAssignmentExpression());
693    if (Expr.isInvalid()) return move(Expr);
694    return Actions.ActOnCXXThrow(ThrowLoc, Expr.take());
695  }
696}
697
698/// ParseCXXThis - This handles the C++ 'this' pointer.
699///
700/// C++ 9.3.2: In the body of a non-static member function, the keyword this is
701/// a non-lvalue expression whose value is the address of the object for which
702/// the function is called.
703ExprResult Parser::ParseCXXThis() {
704  assert(Tok.is(tok::kw_this) && "Not 'this'!");
705  SourceLocation ThisLoc = ConsumeToken();
706  return Actions.ActOnCXXThis(ThisLoc);
707}
708
709/// ParseCXXTypeConstructExpression - Parse construction of a specified type.
710/// Can be interpreted either as function-style casting ("int(x)")
711/// or class type construction ("ClassType(x,y,z)")
712/// or creation of a value-initialized type ("int()").
713///
714///       postfix-expression: [C++ 5.2p1]
715///         simple-type-specifier '(' expression-list[opt] ')'      [C++ 5.2.3]
716///         typename-specifier '(' expression-list[opt] ')'         [TODO]
717///
718ExprResult
719Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
720  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
721  ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
722
723  assert(Tok.is(tok::l_paren) && "Expected '('!");
724  GreaterThanIsOperatorScope G(GreaterThanIsOperator, true);
725
726  SourceLocation LParenLoc = ConsumeParen();
727
728  ExprVector Exprs(Actions);
729  CommaLocsTy CommaLocs;
730
731  if (Tok.isNot(tok::r_paren)) {
732    if (ParseExpressionList(Exprs, CommaLocs)) {
733      SkipUntil(tok::r_paren);
734      return ExprError();
735    }
736  }
737
738  // Match the ')'.
739  SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
740
741  // TypeRep could be null, if it references an invalid typedef.
742  if (!TypeRep)
743    return ExprError();
744
745  assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
746         "Unexpected number of commas!");
747  return Actions.ActOnCXXTypeConstructExpr(TypeRep, LParenLoc, move_arg(Exprs),
748                                           RParenLoc);
749}
750
751/// ParseCXXCondition - if/switch/while condition expression.
752///
753///       condition:
754///         expression
755///         type-specifier-seq declarator '=' assignment-expression
756/// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
757///             '=' assignment-expression
758///
759/// \param ExprResult if the condition was parsed as an expression, the
760/// parsed expression.
761///
762/// \param DeclResult if the condition was parsed as a declaration, the
763/// parsed declaration.
764///
765/// \param Loc The location of the start of the statement that requires this
766/// condition, e.g., the "for" in a for loop.
767///
768/// \param ConvertToBoolean Whether the condition expression should be
769/// converted to a boolean value.
770///
771/// \returns true if there was a parsing, false otherwise.
772bool Parser::ParseCXXCondition(ExprResult &ExprOut,
773                               Decl *&DeclOut,
774                               SourceLocation Loc,
775                               bool ConvertToBoolean) {
776  if (Tok.is(tok::code_completion)) {
777    Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
778    ConsumeCodeCompletionToken();
779  }
780
781  if (!isCXXConditionDeclaration()) {
782    // Parse the expression.
783    ExprOut = ParseExpression(); // expression
784    DeclOut = 0;
785    if (ExprOut.isInvalid())
786      return true;
787
788    // If required, convert to a boolean value.
789    if (ConvertToBoolean)
790      ExprOut
791        = Actions.ActOnBooleanCondition(getCurScope(), Loc, ExprOut.get());
792    return ExprOut.isInvalid();
793  }
794
795  // type-specifier-seq
796  DeclSpec DS;
797  ParseSpecifierQualifierList(DS);
798
799  // declarator
800  Declarator DeclaratorInfo(DS, Declarator::ConditionContext);
801  ParseDeclarator(DeclaratorInfo);
802
803  // simple-asm-expr[opt]
804  if (Tok.is(tok::kw_asm)) {
805    SourceLocation Loc;
806    ExprResult AsmLabel(ParseSimpleAsm(&Loc));
807    if (AsmLabel.isInvalid()) {
808      SkipUntil(tok::semi);
809      return true;
810    }
811    DeclaratorInfo.setAsmLabel(AsmLabel.release());
812    DeclaratorInfo.SetRangeEnd(Loc);
813  }
814
815  // If attributes are present, parse them.
816  MaybeParseGNUAttributes(DeclaratorInfo);
817
818  // Type-check the declaration itself.
819  DeclResult Dcl = Actions.ActOnCXXConditionDeclaration(getCurScope(),
820                                                        DeclaratorInfo);
821  DeclOut = Dcl.get();
822  ExprOut = ExprError();
823
824  // '=' assignment-expression
825  if (isTokenEqualOrMistypedEqualEqual(
826                               diag::err_invalid_equalequal_after_declarator)) {
827    ConsumeToken();
828    ExprResult AssignExpr(ParseAssignmentExpression());
829    if (!AssignExpr.isInvalid())
830      Actions.AddInitializerToDecl(DeclOut, AssignExpr.take());
831  } else {
832    // FIXME: C++0x allows a braced-init-list
833    Diag(Tok, diag::err_expected_equal_after_declarator);
834  }
835
836  // FIXME: Build a reference to this declaration? Convert it to bool?
837  // (This is currently handled by Sema).
838
839  return false;
840}
841
842/// \brief Determine whether the current token starts a C++
843/// simple-type-specifier.
844bool Parser::isCXXSimpleTypeSpecifier() const {
845  switch (Tok.getKind()) {
846  case tok::annot_typename:
847  case tok::kw_short:
848  case tok::kw_long:
849  case tok::kw_signed:
850  case tok::kw_unsigned:
851  case tok::kw_void:
852  case tok::kw_char:
853  case tok::kw_int:
854  case tok::kw_float:
855  case tok::kw_double:
856  case tok::kw_wchar_t:
857  case tok::kw_char16_t:
858  case tok::kw_char32_t:
859  case tok::kw_bool:
860    // FIXME: C++0x decltype support.
861  // GNU typeof support.
862  case tok::kw_typeof:
863    return true;
864
865  default:
866    break;
867  }
868
869  return false;
870}
871
872/// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
873/// This should only be called when the current token is known to be part of
874/// simple-type-specifier.
875///
876///       simple-type-specifier:
877///         '::'[opt] nested-name-specifier[opt] type-name
878///         '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
879///         char
880///         wchar_t
881///         bool
882///         short
883///         int
884///         long
885///         signed
886///         unsigned
887///         float
888///         double
889///         void
890/// [GNU]   typeof-specifier
891/// [C++0x] auto               [TODO]
892///
893///       type-name:
894///         class-name
895///         enum-name
896///         typedef-name
897///
898void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
899  DS.SetRangeStart(Tok.getLocation());
900  const char *PrevSpec;
901  unsigned DiagID;
902  SourceLocation Loc = Tok.getLocation();
903
904  switch (Tok.getKind()) {
905  case tok::identifier:   // foo::bar
906  case tok::coloncolon:   // ::foo::bar
907    assert(0 && "Annotation token should already be formed!");
908  default:
909    assert(0 && "Not a simple-type-specifier token!");
910    abort();
911
912  // type-name
913  case tok::annot_typename: {
914    DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
915                       getTypeAnnotation(Tok));
916
917    DS.SetRangeEnd(Tok.getAnnotationEndLoc());
918    ConsumeToken();
919
920    // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
921    // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
922    // Objective-C interface.  If we don't have Objective-C or a '<', this is
923    // just a normal reference to a typedef name.
924    if (Tok.is(tok::less) && getLang().ObjC1)
925      ParseObjCProtocolQualifiers(DS);
926
927    DS.Finish(Diags, PP);
928    return;
929  }
930
931  // builtin types
932  case tok::kw_short:
933    DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID);
934    break;
935  case tok::kw_long:
936    DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID);
937    break;
938  case tok::kw_signed:
939    DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
940    break;
941  case tok::kw_unsigned:
942    DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID);
943    break;
944  case tok::kw_void:
945    DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID);
946    break;
947  case tok::kw_char:
948    DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID);
949    break;
950  case tok::kw_int:
951    DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID);
952    break;
953  case tok::kw_float:
954    DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID);
955    break;
956  case tok::kw_double:
957    DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID);
958    break;
959  case tok::kw_wchar_t:
960    DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID);
961    break;
962  case tok::kw_char16_t:
963    DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID);
964    break;
965  case tok::kw_char32_t:
966    DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID);
967    break;
968  case tok::kw_bool:
969    DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID);
970    break;
971
972    // FIXME: C++0x decltype support.
973  // GNU typeof support.
974  case tok::kw_typeof:
975    ParseTypeofSpecifier(DS);
976    DS.Finish(Diags, PP);
977    return;
978  }
979  if (Tok.is(tok::annot_typename))
980    DS.SetRangeEnd(Tok.getAnnotationEndLoc());
981  else
982    DS.SetRangeEnd(Tok.getLocation());
983  ConsumeToken();
984  DS.Finish(Diags, PP);
985}
986
987/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
988/// [dcl.name]), which is a non-empty sequence of type-specifiers,
989/// e.g., "const short int". Note that the DeclSpec is *not* finished
990/// by parsing the type-specifier-seq, because these sequences are
991/// typically followed by some form of declarator. Returns true and
992/// emits diagnostics if this is not a type-specifier-seq, false
993/// otherwise.
994///
995///   type-specifier-seq: [C++ 8.1]
996///     type-specifier type-specifier-seq[opt]
997///
998bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
999  DS.SetRangeStart(Tok.getLocation());
1000  const char *PrevSpec = 0;
1001  unsigned DiagID;
1002  bool isInvalid = 0;
1003
1004  // Parse one or more of the type specifiers.
1005  if (!ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID,
1006      ParsedTemplateInfo(), /*SuppressDeclarations*/true)) {
1007    Diag(Tok, diag::err_expected_type);
1008    return true;
1009  }
1010
1011  while (ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID,
1012         ParsedTemplateInfo(), /*SuppressDeclarations*/true))
1013  {}
1014
1015  DS.Finish(Diags, PP);
1016  return false;
1017}
1018
1019/// \brief Finish parsing a C++ unqualified-id that is a template-id of
1020/// some form.
1021///
1022/// This routine is invoked when a '<' is encountered after an identifier or
1023/// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
1024/// whether the unqualified-id is actually a template-id. This routine will
1025/// then parse the template arguments and form the appropriate template-id to
1026/// return to the caller.
1027///
1028/// \param SS the nested-name-specifier that precedes this template-id, if
1029/// we're actually parsing a qualified-id.
1030///
1031/// \param Name for constructor and destructor names, this is the actual
1032/// identifier that may be a template-name.
1033///
1034/// \param NameLoc the location of the class-name in a constructor or
1035/// destructor.
1036///
1037/// \param EnteringContext whether we're entering the scope of the
1038/// nested-name-specifier.
1039///
1040/// \param ObjectType if this unqualified-id occurs within a member access
1041/// expression, the type of the base object whose member is being accessed.
1042///
1043/// \param Id as input, describes the template-name or operator-function-id
1044/// that precedes the '<'. If template arguments were parsed successfully,
1045/// will be updated with the template-id.
1046///
1047/// \param AssumeTemplateId When true, this routine will assume that the name
1048/// refers to a template without performing name lookup to verify.
1049///
1050/// \returns true if a parse error occurred, false otherwise.
1051bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
1052                                          IdentifierInfo *Name,
1053                                          SourceLocation NameLoc,
1054                                          bool EnteringContext,
1055                                          ParsedType ObjectType,
1056                                          UnqualifiedId &Id,
1057                                          bool AssumeTemplateId,
1058                                          SourceLocation TemplateKWLoc) {
1059  assert((AssumeTemplateId || Tok.is(tok::less)) &&
1060         "Expected '<' to finish parsing a template-id");
1061
1062  TemplateTy Template;
1063  TemplateNameKind TNK = TNK_Non_template;
1064  switch (Id.getKind()) {
1065  case UnqualifiedId::IK_Identifier:
1066  case UnqualifiedId::IK_OperatorFunctionId:
1067  case UnqualifiedId::IK_LiteralOperatorId:
1068    if (AssumeTemplateId) {
1069      TNK = Actions.ActOnDependentTemplateName(getCurScope(), TemplateKWLoc, SS,
1070                                               Id, ObjectType, EnteringContext,
1071                                               Template);
1072      if (TNK == TNK_Non_template)
1073        return true;
1074    } else {
1075      bool MemberOfUnknownSpecialization;
1076      TNK = Actions.isTemplateName(getCurScope(), SS,
1077                                   TemplateKWLoc.isValid(), Id,
1078                                   ObjectType, EnteringContext, Template,
1079                                   MemberOfUnknownSpecialization);
1080
1081      if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
1082          ObjectType && IsTemplateArgumentList()) {
1083        // We have something like t->getAs<T>(), where getAs is a
1084        // member of an unknown specialization. However, this will only
1085        // parse correctly as a template, so suggest the keyword 'template'
1086        // before 'getAs' and treat this as a dependent template name.
1087        std::string Name;
1088        if (Id.getKind() == UnqualifiedId::IK_Identifier)
1089          Name = Id.Identifier->getName();
1090        else {
1091          Name = "operator ";
1092          if (Id.getKind() == UnqualifiedId::IK_OperatorFunctionId)
1093            Name += getOperatorSpelling(Id.OperatorFunctionId.Operator);
1094          else
1095            Name += Id.Identifier->getName();
1096        }
1097        Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
1098          << Name
1099          << FixItHint::CreateInsertion(Id.StartLocation, "template ");
1100        TNK = Actions.ActOnDependentTemplateName(getCurScope(), TemplateKWLoc,
1101                                                 SS, Id, ObjectType,
1102                                                 EnteringContext, Template);
1103        if (TNK == TNK_Non_template)
1104          return true;
1105      }
1106    }
1107    break;
1108
1109  case UnqualifiedId::IK_ConstructorName: {
1110    UnqualifiedId TemplateName;
1111    bool MemberOfUnknownSpecialization;
1112    TemplateName.setIdentifier(Name, NameLoc);
1113    TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
1114                                 TemplateName, ObjectType,
1115                                 EnteringContext, Template,
1116                                 MemberOfUnknownSpecialization);
1117    break;
1118  }
1119
1120  case UnqualifiedId::IK_DestructorName: {
1121    UnqualifiedId TemplateName;
1122    bool MemberOfUnknownSpecialization;
1123    TemplateName.setIdentifier(Name, NameLoc);
1124    if (ObjectType) {
1125      TNK = Actions.ActOnDependentTemplateName(getCurScope(), TemplateKWLoc, SS,
1126                                               TemplateName, ObjectType,
1127                                               EnteringContext, Template);
1128      if (TNK == TNK_Non_template)
1129        return true;
1130    } else {
1131      TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
1132                                   TemplateName, ObjectType,
1133                                   EnteringContext, Template,
1134                                   MemberOfUnknownSpecialization);
1135
1136      if (TNK == TNK_Non_template && !Id.DestructorName.get()) {
1137        Diag(NameLoc, diag::err_destructor_template_id)
1138          << Name << SS.getRange();
1139        return true;
1140      }
1141    }
1142    break;
1143  }
1144
1145  default:
1146    return false;
1147  }
1148
1149  if (TNK == TNK_Non_template)
1150    return false;
1151
1152  // Parse the enclosed template argument list.
1153  SourceLocation LAngleLoc, RAngleLoc;
1154  TemplateArgList TemplateArgs;
1155  if (Tok.is(tok::less) &&
1156      ParseTemplateIdAfterTemplateName(Template, Id.StartLocation,
1157                                       &SS, true, LAngleLoc,
1158                                       TemplateArgs,
1159                                       RAngleLoc))
1160    return true;
1161
1162  if (Id.getKind() == UnqualifiedId::IK_Identifier ||
1163      Id.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
1164      Id.getKind() == UnqualifiedId::IK_LiteralOperatorId) {
1165    // Form a parsed representation of the template-id to be stored in the
1166    // UnqualifiedId.
1167    TemplateIdAnnotation *TemplateId
1168      = TemplateIdAnnotation::Allocate(TemplateArgs.size());
1169
1170    if (Id.getKind() == UnqualifiedId::IK_Identifier) {
1171      TemplateId->Name = Id.Identifier;
1172      TemplateId->Operator = OO_None;
1173      TemplateId->TemplateNameLoc = Id.StartLocation;
1174    } else {
1175      TemplateId->Name = 0;
1176      TemplateId->Operator = Id.OperatorFunctionId.Operator;
1177      TemplateId->TemplateNameLoc = Id.StartLocation;
1178    }
1179
1180    TemplateId->Template = Template;
1181    TemplateId->Kind = TNK;
1182    TemplateId->LAngleLoc = LAngleLoc;
1183    TemplateId->RAngleLoc = RAngleLoc;
1184    ParsedTemplateArgument *Args = TemplateId->getTemplateArgs();
1185    for (unsigned Arg = 0, ArgEnd = TemplateArgs.size();
1186         Arg != ArgEnd; ++Arg)
1187      Args[Arg] = TemplateArgs[Arg];
1188
1189    Id.setTemplateId(TemplateId);
1190    return false;
1191  }
1192
1193  // Bundle the template arguments together.
1194  ASTTemplateArgsPtr TemplateArgsPtr(Actions, TemplateArgs.data(),
1195                                     TemplateArgs.size());
1196
1197  // Constructor and destructor names.
1198  TypeResult Type
1199    = Actions.ActOnTemplateIdType(Template, NameLoc,
1200                                  LAngleLoc, TemplateArgsPtr,
1201                                  RAngleLoc);
1202  if (Type.isInvalid())
1203    return true;
1204
1205  if (Id.getKind() == UnqualifiedId::IK_ConstructorName)
1206    Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
1207  else
1208    Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
1209
1210  return false;
1211}
1212
1213/// \brief Parse an operator-function-id or conversion-function-id as part
1214/// of a C++ unqualified-id.
1215///
1216/// This routine is responsible only for parsing the operator-function-id or
1217/// conversion-function-id; it does not handle template arguments in any way.
1218///
1219/// \code
1220///       operator-function-id: [C++ 13.5]
1221///         'operator' operator
1222///
1223///       operator: one of
1224///            new   delete  new[]   delete[]
1225///            +     -    *  /    %  ^    &   |   ~
1226///            !     =    <  >    += -=   *=  /=  %=
1227///            ^=    &=   |= <<   >> >>= <<=  ==  !=
1228///            <=    >=   && ||   ++ --   ,   ->* ->
1229///            ()    []
1230///
1231///       conversion-function-id: [C++ 12.3.2]
1232///         operator conversion-type-id
1233///
1234///       conversion-type-id:
1235///         type-specifier-seq conversion-declarator[opt]
1236///
1237///       conversion-declarator:
1238///         ptr-operator conversion-declarator[opt]
1239/// \endcode
1240///
1241/// \param The nested-name-specifier that preceded this unqualified-id. If
1242/// non-empty, then we are parsing the unqualified-id of a qualified-id.
1243///
1244/// \param EnteringContext whether we are entering the scope of the
1245/// nested-name-specifier.
1246///
1247/// \param ObjectType if this unqualified-id occurs within a member access
1248/// expression, the type of the base object whose member is being accessed.
1249///
1250/// \param Result on a successful parse, contains the parsed unqualified-id.
1251///
1252/// \returns true if parsing fails, false otherwise.
1253bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
1254                                        ParsedType ObjectType,
1255                                        UnqualifiedId &Result) {
1256  assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
1257
1258  // Consume the 'operator' keyword.
1259  SourceLocation KeywordLoc = ConsumeToken();
1260
1261  // Determine what kind of operator name we have.
1262  unsigned SymbolIdx = 0;
1263  SourceLocation SymbolLocations[3];
1264  OverloadedOperatorKind Op = OO_None;
1265  switch (Tok.getKind()) {
1266    case tok::kw_new:
1267    case tok::kw_delete: {
1268      bool isNew = Tok.getKind() == tok::kw_new;
1269      // Consume the 'new' or 'delete'.
1270      SymbolLocations[SymbolIdx++] = ConsumeToken();
1271      if (Tok.is(tok::l_square)) {
1272        // Consume the '['.
1273        SourceLocation LBracketLoc = ConsumeBracket();
1274        // Consume the ']'.
1275        SourceLocation RBracketLoc = MatchRHSPunctuation(tok::r_square,
1276                                                         LBracketLoc);
1277        if (RBracketLoc.isInvalid())
1278          return true;
1279
1280        SymbolLocations[SymbolIdx++] = LBracketLoc;
1281        SymbolLocations[SymbolIdx++] = RBracketLoc;
1282        Op = isNew? OO_Array_New : OO_Array_Delete;
1283      } else {
1284        Op = isNew? OO_New : OO_Delete;
1285      }
1286      break;
1287    }
1288
1289#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
1290    case tok::Token:                                                     \
1291      SymbolLocations[SymbolIdx++] = ConsumeToken();                     \
1292      Op = OO_##Name;                                                    \
1293      break;
1294#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
1295#include "clang/Basic/OperatorKinds.def"
1296
1297    case tok::l_paren: {
1298      // Consume the '('.
1299      SourceLocation LParenLoc = ConsumeParen();
1300      // Consume the ')'.
1301      SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren,
1302                                                     LParenLoc);
1303      if (RParenLoc.isInvalid())
1304        return true;
1305
1306      SymbolLocations[SymbolIdx++] = LParenLoc;
1307      SymbolLocations[SymbolIdx++] = RParenLoc;
1308      Op = OO_Call;
1309      break;
1310    }
1311
1312    case tok::l_square: {
1313      // Consume the '['.
1314      SourceLocation LBracketLoc = ConsumeBracket();
1315      // Consume the ']'.
1316      SourceLocation RBracketLoc = MatchRHSPunctuation(tok::r_square,
1317                                                       LBracketLoc);
1318      if (RBracketLoc.isInvalid())
1319        return true;
1320
1321      SymbolLocations[SymbolIdx++] = LBracketLoc;
1322      SymbolLocations[SymbolIdx++] = RBracketLoc;
1323      Op = OO_Subscript;
1324      break;
1325    }
1326
1327    case tok::code_completion: {
1328      // Code completion for the operator name.
1329      Actions.CodeCompleteOperatorName(getCurScope());
1330
1331      // Consume the operator token.
1332      ConsumeCodeCompletionToken();
1333
1334      // Don't try to parse any further.
1335      return true;
1336    }
1337
1338    default:
1339      break;
1340  }
1341
1342  if (Op != OO_None) {
1343    // We have parsed an operator-function-id.
1344    Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
1345    return false;
1346  }
1347
1348  // Parse a literal-operator-id.
1349  //
1350  //   literal-operator-id: [C++0x 13.5.8]
1351  //     operator "" identifier
1352
1353  if (getLang().CPlusPlus0x && Tok.is(tok::string_literal)) {
1354    if (Tok.getLength() != 2)
1355      Diag(Tok.getLocation(), diag::err_operator_string_not_empty);
1356    ConsumeStringToken();
1357
1358    if (Tok.isNot(tok::identifier)) {
1359      Diag(Tok.getLocation(), diag::err_expected_ident);
1360      return true;
1361    }
1362
1363    IdentifierInfo *II = Tok.getIdentifierInfo();
1364    Result.setLiteralOperatorId(II, KeywordLoc, ConsumeToken());
1365    return false;
1366  }
1367
1368  // Parse a conversion-function-id.
1369  //
1370  //   conversion-function-id: [C++ 12.3.2]
1371  //     operator conversion-type-id
1372  //
1373  //   conversion-type-id:
1374  //     type-specifier-seq conversion-declarator[opt]
1375  //
1376  //   conversion-declarator:
1377  //     ptr-operator conversion-declarator[opt]
1378
1379  // Parse the type-specifier-seq.
1380  DeclSpec DS;
1381  if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
1382    return true;
1383
1384  // Parse the conversion-declarator, which is merely a sequence of
1385  // ptr-operators.
1386  Declarator D(DS, Declarator::TypeNameContext);
1387  ParseDeclaratorInternal(D, /*DirectDeclParser=*/0);
1388
1389  // Finish up the type.
1390  TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
1391  if (Ty.isInvalid())
1392    return true;
1393
1394  // Note that this is a conversion-function-id.
1395  Result.setConversionFunctionId(KeywordLoc, Ty.get(),
1396                                 D.getSourceRange().getEnd());
1397  return false;
1398}
1399
1400/// \brief Parse a C++ unqualified-id (or a C identifier), which describes the
1401/// name of an entity.
1402///
1403/// \code
1404///       unqualified-id: [C++ expr.prim.general]
1405///         identifier
1406///         operator-function-id
1407///         conversion-function-id
1408/// [C++0x] literal-operator-id [TODO]
1409///         ~ class-name
1410///         template-id
1411///
1412/// \endcode
1413///
1414/// \param The nested-name-specifier that preceded this unqualified-id. If
1415/// non-empty, then we are parsing the unqualified-id of a qualified-id.
1416///
1417/// \param EnteringContext whether we are entering the scope of the
1418/// nested-name-specifier.
1419///
1420/// \param AllowDestructorName whether we allow parsing of a destructor name.
1421///
1422/// \param AllowConstructorName whether we allow parsing a constructor name.
1423///
1424/// \param ObjectType if this unqualified-id occurs within a member access
1425/// expression, the type of the base object whose member is being accessed.
1426///
1427/// \param Result on a successful parse, contains the parsed unqualified-id.
1428///
1429/// \returns true if parsing fails, false otherwise.
1430bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
1431                                bool AllowDestructorName,
1432                                bool AllowConstructorName,
1433                                ParsedType ObjectType,
1434                                UnqualifiedId &Result) {
1435
1436  // Handle 'A::template B'. This is for template-ids which have not
1437  // already been annotated by ParseOptionalCXXScopeSpecifier().
1438  bool TemplateSpecified = false;
1439  SourceLocation TemplateKWLoc;
1440  if (getLang().CPlusPlus && Tok.is(tok::kw_template) &&
1441      (ObjectType || SS.isSet())) {
1442    TemplateSpecified = true;
1443    TemplateKWLoc = ConsumeToken();
1444  }
1445
1446  // unqualified-id:
1447  //   identifier
1448  //   template-id (when it hasn't already been annotated)
1449  if (Tok.is(tok::identifier)) {
1450    // Consume the identifier.
1451    IdentifierInfo *Id = Tok.getIdentifierInfo();
1452    SourceLocation IdLoc = ConsumeToken();
1453
1454    if (!getLang().CPlusPlus) {
1455      // If we're not in C++, only identifiers matter. Record the
1456      // identifier and return.
1457      Result.setIdentifier(Id, IdLoc);
1458      return false;
1459    }
1460
1461    if (AllowConstructorName &&
1462        Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
1463      // We have parsed a constructor name.
1464      Result.setConstructorName(Actions.getTypeName(*Id, IdLoc, getCurScope(),
1465                                                    &SS, false),
1466                                IdLoc, IdLoc);
1467    } else {
1468      // We have parsed an identifier.
1469      Result.setIdentifier(Id, IdLoc);
1470    }
1471
1472    // If the next token is a '<', we may have a template.
1473    if (TemplateSpecified || Tok.is(tok::less))
1474      return ParseUnqualifiedIdTemplateId(SS, Id, IdLoc, EnteringContext,
1475                                          ObjectType, Result,
1476                                          TemplateSpecified, TemplateKWLoc);
1477
1478    return false;
1479  }
1480
1481  // unqualified-id:
1482  //   template-id (already parsed and annotated)
1483  if (Tok.is(tok::annot_template_id)) {
1484    TemplateIdAnnotation *TemplateId
1485      = static_cast<TemplateIdAnnotation*>(Tok.getAnnotationValue());
1486
1487    // If the template-name names the current class, then this is a constructor
1488    if (AllowConstructorName && TemplateId->Name &&
1489        Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
1490      if (SS.isSet()) {
1491        // C++ [class.qual]p2 specifies that a qualified template-name
1492        // is taken as the constructor name where a constructor can be
1493        // declared. Thus, the template arguments are extraneous, so
1494        // complain about them and remove them entirely.
1495        Diag(TemplateId->TemplateNameLoc,
1496             diag::err_out_of_line_constructor_template_id)
1497          << TemplateId->Name
1498          << FixItHint::CreateRemoval(
1499                    SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
1500        Result.setConstructorName(Actions.getTypeName(*TemplateId->Name,
1501                                                  TemplateId->TemplateNameLoc,
1502                                                      getCurScope(),
1503                                                      &SS, false),
1504                                  TemplateId->TemplateNameLoc,
1505                                  TemplateId->RAngleLoc);
1506        TemplateId->Destroy();
1507        ConsumeToken();
1508        return false;
1509      }
1510
1511      Result.setConstructorTemplateId(TemplateId);
1512      ConsumeToken();
1513      return false;
1514    }
1515
1516    // We have already parsed a template-id; consume the annotation token as
1517    // our unqualified-id.
1518    Result.setTemplateId(TemplateId);
1519    ConsumeToken();
1520    return false;
1521  }
1522
1523  // unqualified-id:
1524  //   operator-function-id
1525  //   conversion-function-id
1526  if (Tok.is(tok::kw_operator)) {
1527    if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
1528      return true;
1529
1530    // If we have an operator-function-id or a literal-operator-id and the next
1531    // token is a '<', we may have a
1532    //
1533    //   template-id:
1534    //     operator-function-id < template-argument-list[opt] >
1535    if ((Result.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
1536         Result.getKind() == UnqualifiedId::IK_LiteralOperatorId) &&
1537        (TemplateSpecified || Tok.is(tok::less)))
1538      return ParseUnqualifiedIdTemplateId(SS, 0, SourceLocation(),
1539                                          EnteringContext, ObjectType,
1540                                          Result,
1541                                          TemplateSpecified, TemplateKWLoc);
1542
1543    return false;
1544  }
1545
1546  if (getLang().CPlusPlus &&
1547      (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
1548    // C++ [expr.unary.op]p10:
1549    //   There is an ambiguity in the unary-expression ~X(), where X is a
1550    //   class-name. The ambiguity is resolved in favor of treating ~ as a
1551    //    unary complement rather than treating ~X as referring to a destructor.
1552
1553    // Parse the '~'.
1554    SourceLocation TildeLoc = ConsumeToken();
1555
1556    // Parse the class-name.
1557    if (Tok.isNot(tok::identifier)) {
1558      Diag(Tok, diag::err_destructor_tilde_identifier);
1559      return true;
1560    }
1561
1562    // Parse the class-name (or template-name in a simple-template-id).
1563    IdentifierInfo *ClassName = Tok.getIdentifierInfo();
1564    SourceLocation ClassNameLoc = ConsumeToken();
1565
1566    if (TemplateSpecified || Tok.is(tok::less)) {
1567      Result.setDestructorName(TildeLoc, ParsedType(), ClassNameLoc);
1568      return ParseUnqualifiedIdTemplateId(SS, ClassName, ClassNameLoc,
1569                                          EnteringContext, ObjectType, Result,
1570                                          TemplateSpecified, TemplateKWLoc);
1571    }
1572
1573    // Note that this is a destructor name.
1574    ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
1575                                              ClassNameLoc, getCurScope(),
1576                                              SS, ObjectType,
1577                                              EnteringContext);
1578    if (!Ty)
1579      return true;
1580
1581    Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
1582    return false;
1583  }
1584
1585  Diag(Tok, diag::err_expected_unqualified_id)
1586    << getLang().CPlusPlus;
1587  return true;
1588}
1589
1590/// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
1591/// memory in a typesafe manner and call constructors.
1592///
1593/// This method is called to parse the new expression after the optional :: has
1594/// been already parsed.  If the :: was present, "UseGlobal" is true and "Start"
1595/// is its location.  Otherwise, "Start" is the location of the 'new' token.
1596///
1597///        new-expression:
1598///                   '::'[opt] 'new' new-placement[opt] new-type-id
1599///                                     new-initializer[opt]
1600///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
1601///                                     new-initializer[opt]
1602///
1603///        new-placement:
1604///                   '(' expression-list ')'
1605///
1606///        new-type-id:
1607///                   type-specifier-seq new-declarator[opt]
1608///
1609///        new-declarator:
1610///                   ptr-operator new-declarator[opt]
1611///                   direct-new-declarator
1612///
1613///        new-initializer:
1614///                   '(' expression-list[opt] ')'
1615/// [C++0x]           braced-init-list                                   [TODO]
1616///
1617ExprResult
1618Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
1619  assert(Tok.is(tok::kw_new) && "expected 'new' token");
1620  ConsumeToken();   // Consume 'new'
1621
1622  // A '(' now can be a new-placement or the '(' wrapping the type-id in the
1623  // second form of new-expression. It can't be a new-type-id.
1624
1625  ExprVector PlacementArgs(Actions);
1626  SourceLocation PlacementLParen, PlacementRParen;
1627
1628  SourceRange TypeIdParens;
1629  DeclSpec DS;
1630  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1631  if (Tok.is(tok::l_paren)) {
1632    // If it turns out to be a placement, we change the type location.
1633    PlacementLParen = ConsumeParen();
1634    if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
1635      SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
1636      return ExprError();
1637    }
1638
1639    PlacementRParen = MatchRHSPunctuation(tok::r_paren, PlacementLParen);
1640    if (PlacementRParen.isInvalid()) {
1641      SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
1642      return ExprError();
1643    }
1644
1645    if (PlacementArgs.empty()) {
1646      // Reset the placement locations. There was no placement.
1647      TypeIdParens = SourceRange(PlacementLParen, PlacementRParen);
1648      PlacementLParen = PlacementRParen = SourceLocation();
1649    } else {
1650      // We still need the type.
1651      if (Tok.is(tok::l_paren)) {
1652        TypeIdParens.setBegin(ConsumeParen());
1653        ParseSpecifierQualifierList(DS);
1654        DeclaratorInfo.SetSourceRange(DS.getSourceRange());
1655        ParseDeclarator(DeclaratorInfo);
1656        TypeIdParens.setEnd(MatchRHSPunctuation(tok::r_paren,
1657                                                TypeIdParens.getBegin()));
1658      } else {
1659        if (ParseCXXTypeSpecifierSeq(DS))
1660          DeclaratorInfo.setInvalidType(true);
1661        else {
1662          DeclaratorInfo.SetSourceRange(DS.getSourceRange());
1663          ParseDeclaratorInternal(DeclaratorInfo,
1664                                  &Parser::ParseDirectNewDeclarator);
1665        }
1666      }
1667    }
1668  } else {
1669    // A new-type-id is a simplified type-id, where essentially the
1670    // direct-declarator is replaced by a direct-new-declarator.
1671    if (ParseCXXTypeSpecifierSeq(DS))
1672      DeclaratorInfo.setInvalidType(true);
1673    else {
1674      DeclaratorInfo.SetSourceRange(DS.getSourceRange());
1675      ParseDeclaratorInternal(DeclaratorInfo,
1676                              &Parser::ParseDirectNewDeclarator);
1677    }
1678  }
1679  if (DeclaratorInfo.isInvalidType()) {
1680    SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
1681    return ExprError();
1682  }
1683
1684  ExprVector ConstructorArgs(Actions);
1685  SourceLocation ConstructorLParen, ConstructorRParen;
1686
1687  if (Tok.is(tok::l_paren)) {
1688    ConstructorLParen = ConsumeParen();
1689    if (Tok.isNot(tok::r_paren)) {
1690      CommaLocsTy CommaLocs;
1691      if (ParseExpressionList(ConstructorArgs, CommaLocs)) {
1692        SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
1693        return ExprError();
1694      }
1695    }
1696    ConstructorRParen = MatchRHSPunctuation(tok::r_paren, ConstructorLParen);
1697    if (ConstructorRParen.isInvalid()) {
1698      SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
1699      return ExprError();
1700    }
1701  }
1702
1703  return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
1704                             move_arg(PlacementArgs), PlacementRParen,
1705                             TypeIdParens, DeclaratorInfo, ConstructorLParen,
1706                             move_arg(ConstructorArgs), ConstructorRParen);
1707}
1708
1709/// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
1710/// passed to ParseDeclaratorInternal.
1711///
1712///        direct-new-declarator:
1713///                   '[' expression ']'
1714///                   direct-new-declarator '[' constant-expression ']'
1715///
1716void Parser::ParseDirectNewDeclarator(Declarator &D) {
1717  // Parse the array dimensions.
1718  bool first = true;
1719  while (Tok.is(tok::l_square)) {
1720    SourceLocation LLoc = ConsumeBracket();
1721    ExprResult Size(first ? ParseExpression()
1722                                : ParseConstantExpression());
1723    if (Size.isInvalid()) {
1724      // Recover
1725      SkipUntil(tok::r_square);
1726      return;
1727    }
1728    first = false;
1729
1730    SourceLocation RLoc = MatchRHSPunctuation(tok::r_square, LLoc);
1731    D.AddTypeInfo(DeclaratorChunk::getArray(0, ParsedAttributes(),
1732                                            /*static=*/false, /*star=*/false,
1733                                            Size.release(), LLoc, RLoc),
1734                  RLoc);
1735
1736    if (RLoc.isInvalid())
1737      return;
1738  }
1739}
1740
1741/// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
1742/// This ambiguity appears in the syntax of the C++ new operator.
1743///
1744///        new-expression:
1745///                   '::'[opt] 'new' new-placement[opt] '(' type-id ')'
1746///                                     new-initializer[opt]
1747///
1748///        new-placement:
1749///                   '(' expression-list ')'
1750///
1751bool Parser::ParseExpressionListOrTypeId(
1752                                   llvm::SmallVectorImpl<Expr*> &PlacementArgs,
1753                                         Declarator &D) {
1754  // The '(' was already consumed.
1755  if (isTypeIdInParens()) {
1756    ParseSpecifierQualifierList(D.getMutableDeclSpec());
1757    D.SetSourceRange(D.getDeclSpec().getSourceRange());
1758    ParseDeclarator(D);
1759    return D.isInvalidType();
1760  }
1761
1762  // It's not a type, it has to be an expression list.
1763  // Discard the comma locations - ActOnCXXNew has enough parameters.
1764  CommaLocsTy CommaLocs;
1765  return ParseExpressionList(PlacementArgs, CommaLocs);
1766}
1767
1768/// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
1769/// to free memory allocated by new.
1770///
1771/// This method is called to parse the 'delete' expression after the optional
1772/// '::' has been already parsed.  If the '::' was present, "UseGlobal" is true
1773/// and "Start" is its location.  Otherwise, "Start" is the location of the
1774/// 'delete' token.
1775///
1776///        delete-expression:
1777///                   '::'[opt] 'delete' cast-expression
1778///                   '::'[opt] 'delete' '[' ']' cast-expression
1779ExprResult
1780Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
1781  assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
1782  ConsumeToken(); // Consume 'delete'
1783
1784  // Array delete?
1785  bool ArrayDelete = false;
1786  if (Tok.is(tok::l_square)) {
1787    ArrayDelete = true;
1788    SourceLocation LHS = ConsumeBracket();
1789    SourceLocation RHS = MatchRHSPunctuation(tok::r_square, LHS);
1790    if (RHS.isInvalid())
1791      return ExprError();
1792  }
1793
1794  ExprResult Operand(ParseCastExpression(false));
1795  if (Operand.isInvalid())
1796    return move(Operand);
1797
1798  return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.take());
1799}
1800
1801static UnaryTypeTrait UnaryTypeTraitFromTokKind(tok::TokenKind kind) {
1802  switch(kind) {
1803  default: llvm_unreachable("Not a known unary type trait");
1804  case tok::kw___has_nothrow_assign:      return UTT_HasNothrowAssign;
1805  case tok::kw___has_nothrow_copy:        return UTT_HasNothrowCopy;
1806  case tok::kw___has_nothrow_constructor: return UTT_HasNothrowConstructor;
1807  case tok::kw___has_trivial_assign:      return UTT_HasTrivialAssign;
1808  case tok::kw___has_trivial_copy:        return UTT_HasTrivialCopy;
1809  case tok::kw___has_trivial_constructor: return UTT_HasTrivialConstructor;
1810  case tok::kw___has_trivial_destructor:  return UTT_HasTrivialDestructor;
1811  case tok::kw___has_virtual_destructor:  return UTT_HasVirtualDestructor;
1812  case tok::kw___is_abstract:             return UTT_IsAbstract;
1813  case tok::kw___is_class:                return UTT_IsClass;
1814  case tok::kw___is_empty:                return UTT_IsEmpty;
1815  case tok::kw___is_enum:                 return UTT_IsEnum;
1816  case tok::kw___is_pod:                  return UTT_IsPOD;
1817  case tok::kw___is_polymorphic:          return UTT_IsPolymorphic;
1818  case tok::kw___is_union:                return UTT_IsUnion;
1819  case tok::kw___is_literal:              return UTT_IsLiteral;
1820  }
1821}
1822
1823static BinaryTypeTrait BinaryTypeTraitFromTokKind(tok::TokenKind kind) {
1824  switch(kind) {
1825  default: llvm_unreachable("Not a known binary type trait");
1826  case tok::kw___is_base_of:                 return BTT_IsBaseOf;
1827  case tok::kw___builtin_types_compatible_p: return BTT_TypeCompatible;
1828  }
1829}
1830
1831/// ParseUnaryTypeTrait - Parse the built-in unary type-trait
1832/// pseudo-functions that allow implementation of the TR1/C++0x type traits
1833/// templates.
1834///
1835///       primary-expression:
1836/// [GNU]             unary-type-trait '(' type-id ')'
1837///
1838ExprResult Parser::ParseUnaryTypeTrait() {
1839  UnaryTypeTrait UTT = UnaryTypeTraitFromTokKind(Tok.getKind());
1840  SourceLocation Loc = ConsumeToken();
1841
1842  SourceLocation LParen = Tok.getLocation();
1843  if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen))
1844    return ExprError();
1845
1846  // FIXME: Error reporting absolutely sucks! If the this fails to parse a type
1847  // there will be cryptic errors about mismatched parentheses and missing
1848  // specifiers.
1849  TypeResult Ty = ParseTypeName();
1850
1851  SourceLocation RParen = MatchRHSPunctuation(tok::r_paren, LParen);
1852
1853  if (Ty.isInvalid())
1854    return ExprError();
1855
1856  return Actions.ActOnUnaryTypeTrait(UTT, Loc, Ty.get(), RParen);
1857}
1858
1859/// ParseBinaryTypeTrait - Parse the built-in binary type-trait
1860/// pseudo-functions that allow implementation of the TR1/C++0x type traits
1861/// templates.
1862///
1863///       primary-expression:
1864/// [GNU]             binary-type-trait '(' type-id ',' type-id ')'
1865///
1866ExprResult Parser::ParseBinaryTypeTrait() {
1867  BinaryTypeTrait BTT = BinaryTypeTraitFromTokKind(Tok.getKind());
1868  SourceLocation Loc = ConsumeToken();
1869
1870  SourceLocation LParen = Tok.getLocation();
1871  if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen))
1872    return ExprError();
1873
1874  TypeResult LhsTy = ParseTypeName();
1875  if (LhsTy.isInvalid()) {
1876    SkipUntil(tok::r_paren);
1877    return ExprError();
1878  }
1879
1880  if (ExpectAndConsume(tok::comma, diag::err_expected_comma)) {
1881    SkipUntil(tok::r_paren);
1882    return ExprError();
1883  }
1884
1885  TypeResult RhsTy = ParseTypeName();
1886  if (RhsTy.isInvalid()) {
1887    SkipUntil(tok::r_paren);
1888    return ExprError();
1889  }
1890
1891  SourceLocation RParen = MatchRHSPunctuation(tok::r_paren, LParen);
1892
1893  return Actions.ActOnBinaryTypeTrait(BTT, Loc, LhsTy.get(), RhsTy.get(), RParen);
1894}
1895
1896/// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
1897/// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
1898/// based on the context past the parens.
1899ExprResult
1900Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
1901                                         ParsedType &CastTy,
1902                                         SourceLocation LParenLoc,
1903                                         SourceLocation &RParenLoc) {
1904  assert(getLang().CPlusPlus && "Should only be called for C++!");
1905  assert(ExprType == CastExpr && "Compound literals are not ambiguous!");
1906  assert(isTypeIdInParens() && "Not a type-id!");
1907
1908  ExprResult Result(true);
1909  CastTy = ParsedType();
1910
1911  // We need to disambiguate a very ugly part of the C++ syntax:
1912  //
1913  // (T())x;  - type-id
1914  // (T())*x; - type-id
1915  // (T())/x; - expression
1916  // (T());   - expression
1917  //
1918  // The bad news is that we cannot use the specialized tentative parser, since
1919  // it can only verify that the thing inside the parens can be parsed as
1920  // type-id, it is not useful for determining the context past the parens.
1921  //
1922  // The good news is that the parser can disambiguate this part without
1923  // making any unnecessary Action calls.
1924  //
1925  // It uses a scheme similar to parsing inline methods. The parenthesized
1926  // tokens are cached, the context that follows is determined (possibly by
1927  // parsing a cast-expression), and then we re-introduce the cached tokens
1928  // into the token stream and parse them appropriately.
1929
1930  ParenParseOption ParseAs;
1931  CachedTokens Toks;
1932
1933  // Store the tokens of the parentheses. We will parse them after we determine
1934  // the context that follows them.
1935  if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
1936    // We didn't find the ')' we expected.
1937    MatchRHSPunctuation(tok::r_paren, LParenLoc);
1938    return ExprError();
1939  }
1940
1941  if (Tok.is(tok::l_brace)) {
1942    ParseAs = CompoundLiteral;
1943  } else {
1944    bool NotCastExpr;
1945    // FIXME: Special-case ++ and --: "(S())++;" is not a cast-expression
1946    if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
1947      NotCastExpr = true;
1948    } else {
1949      // Try parsing the cast-expression that may follow.
1950      // If it is not a cast-expression, NotCastExpr will be true and no token
1951      // will be consumed.
1952      Result = ParseCastExpression(false/*isUnaryExpression*/,
1953                                   false/*isAddressofOperand*/,
1954                                   NotCastExpr,
1955                                   ParsedType()/*TypeOfCast*/);
1956    }
1957
1958    // If we parsed a cast-expression, it's really a type-id, otherwise it's
1959    // an expression.
1960    ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
1961  }
1962
1963  // The current token should go after the cached tokens.
1964  Toks.push_back(Tok);
1965  // Re-enter the stored parenthesized tokens into the token stream, so we may
1966  // parse them now.
1967  PP.EnterTokenStream(Toks.data(), Toks.size(),
1968                      true/*DisableMacroExpansion*/, false/*OwnsTokens*/);
1969  // Drop the current token and bring the first cached one. It's the same token
1970  // as when we entered this function.
1971  ConsumeAnyToken();
1972
1973  if (ParseAs >= CompoundLiteral) {
1974    TypeResult Ty = ParseTypeName();
1975
1976    // Match the ')'.
1977    if (Tok.is(tok::r_paren))
1978      RParenLoc = ConsumeParen();
1979    else
1980      MatchRHSPunctuation(tok::r_paren, LParenLoc);
1981
1982    if (ParseAs == CompoundLiteral) {
1983      ExprType = CompoundLiteral;
1984      return ParseCompoundLiteralExpression(Ty.get(), LParenLoc, RParenLoc);
1985    }
1986
1987    // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
1988    assert(ParseAs == CastExpr);
1989
1990    if (Ty.isInvalid())
1991      return ExprError();
1992
1993    CastTy = Ty.get();
1994
1995    // Result is what ParseCastExpression returned earlier.
1996    if (!Result.isInvalid())
1997      Result = Actions.ActOnCastExpr(getCurScope(), LParenLoc, CastTy, RParenLoc,
1998                                     Result.take());
1999    return move(Result);
2000  }
2001
2002  // Not a compound literal, and not followed by a cast-expression.
2003  assert(ParseAs == SimpleExpr);
2004
2005  ExprType = SimpleExpr;
2006  Result = ParseExpression();
2007  if (!Result.isInvalid() && Tok.is(tok::r_paren))
2008    Result = Actions.ActOnParenExpr(LParenLoc, Tok.getLocation(), Result.take());
2009
2010  // Match the ')'.
2011  if (Result.isInvalid()) {
2012    SkipUntil(tok::r_paren);
2013    return ExprError();
2014  }
2015
2016  if (Tok.is(tok::r_paren))
2017    RParenLoc = ConsumeParen();
2018  else
2019    MatchRHSPunctuation(tok::r_paren, LParenLoc);
2020
2021  return move(Result);
2022}
2023