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