1 //===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Expression parsing implementation for C++.
12 //===----------------------------------------------------------------------===//
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"
21 using namespace clang
;
23 /// \brief Parse global scope or nested-name-specifier if present.
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.
29 /// '::'[opt] nested-name-specifier
32 /// nested-name-specifier:
34 /// namespace-name '::'
35 /// nested-name-specifier identifier '::'
36 /// nested-name-specifier 'template'[opt] simple-template-id '::'
39 /// \param SS the scope specifier that will be set to the parsed
40 /// nested-name-specifier (or empty)
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.
46 /// \param EnteringContext whether we will be entering into the context of
47 /// the nested-name-specifier after parsing it.
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.
57 /// member access expression, e.g., the \p T:: in \p p->T::m.
59 /// \returns true if there was an error parsing a scope specifier
60 bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec
&SS
,
61 ParsedType ObjectType
,
63 bool *MayBePseudoDestructor
) {
64 assert(getLang().CPlusPlus
&&
65 "Call sites of this function should be guarded by checking for C++");
67 if (Tok
.is(tok::annot_cxxscope
)) {
68 SS
.setScopeRep(static_cast<NestedNameSpecifier
*>(Tok
.getAnnotationValue()));
69 SS
.setRange(Tok
.getAnnotationRange());
74 bool HasScopeSpecifier
= false;
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
)
82 // '::' - Global scope qualifier.
83 SourceLocation CCLoc
= ConsumeToken();
84 SS
.setBeginLoc(CCLoc
);
85 SS
.setScopeRep(Actions
.ActOnCXXGlobalScopeSpecifier(getCurScope(), CCLoc
));
87 HasScopeSpecifier
= true;
90 bool CheckForDestructor
= false;
91 if (MayBePseudoDestructor
&& *MayBePseudoDestructor
) {
92 CheckForDestructor
= true;
93 *MayBePseudoDestructor
= false;
97 if (HasScopeSpecifier
) {
98 // C++ [basic.lookup.classref]p5:
99 // If the qualified-id has the form
101 // ::class-name-or-namespace-name::...
103 // the class-name-or-namespace-name is looked up in global scope as a
104 // class-name or namespace-name.
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();
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();
118 // nested-name-specifier:
119 // nested-name-specifier 'template'[opt] simple-template-id '::'
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
127 if (!HasScopeSpecifier
&& !ObjectType
)
130 TentativeParsingAction
TPA(*this);
131 SourceLocation TemplateKWLoc
= ConsumeToken();
133 UnqualifiedId TemplateName
;
134 if (Tok
.is(tok::identifier
)) {
135 // Consume the identifier.
136 TemplateName
.setIdentifier(Tok
.getIdentifierInfo(), Tok
.getLocation());
138 } else if (Tok
.is(tok::kw_operator
)) {
139 if (ParseUnqualifiedIdOperator(SS
, EnteringContext
, ObjectType
,
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();
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
161 if (Tok
.isNot(tok::less
)) {
166 // Commit to parsing the template-id.
169 if (TemplateNameKind TNK
= Actions
.ActOnDependentTemplateName(getCurScope(),
176 if (AnnotateTemplateIdToken(Template
, TNK
, &SS
, TemplateName
,
177 TemplateKWLoc
, false))
185 if (Tok
.is(tok::annot_template_id
) && NextToken().is(tok::coloncolon
)) {
188 // simple-template-id '::'
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;
200 if (TemplateId
->Kind
== TNK_Type_template
||
201 TemplateId
->Kind
== TNK_Dependent_template_name
) {
202 AnnotateTemplateIdTokenAsType(&SS
);
204 assert(Tok
.is(tok::annot_typename
) &&
205 "AnnotateTemplateIdTokenAsType isn't working");
206 Token TypeToken
= Tok
;
208 assert(Tok
.is(tok::coloncolon
) && "NextToken() not working properly!");
209 SourceLocation CCLoc
= ConsumeToken();
211 if (!HasScopeSpecifier
) {
212 SS
.setBeginLoc(TypeToken
.getLocation());
213 HasScopeSpecifier
= true;
216 if (ParsedType T
= getTypeAnnotation(TypeToken
)) {
218 Actions
.ActOnCXXNestedNameSpecifier(getCurScope(), SS
, T
,
219 TypeToken
.getAnnotationRange(),
221 SS
.setScopeRep(Scope
);
228 assert(false && "FIXME: Only type template names supported here");
232 // The rest of the nested-name-specifier possibilities start with
234 if (Tok
.isNot(tok::identifier
))
237 IdentifierInfo
&II
= *Tok
.getIdentifierInfo();
239 // nested-name-specifier:
241 // namespace-name '::'
242 // nested-name-specifier identifier '::'
243 Token Next
= NextToken();
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
,
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(), "::");
257 // Recover as if the user wrote '::'.
258 Next
.setKind(tok::coloncolon
);
262 if (Next
.is(tok::coloncolon
)) {
263 if (CheckForDestructor
&& GetLookAheadToken(2).is(tok::tilde
) &&
264 !Actions
.isNonTypeNestedNameSpecifier(getCurScope(), SS
, Tok
.getLocation(),
266 *MayBePseudoDestructor
= true;
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();
277 if (!HasScopeSpecifier
) {
278 SS
.setBeginLoc(IdLoc
);
279 HasScopeSpecifier
= true;
284 Actions
.ActOnCXXNestedNameSpecifier(getCurScope(), SS
, IdLoc
, CCLoc
, II
,
285 ObjectType
, EnteringContext
));
290 // nested-name-specifier:
292 if (Next
.is(tok::less
)) {
294 UnqualifiedId TemplateName
;
295 TemplateName
.setIdentifier(&II
, Tok
.getLocation());
296 bool MemberOfUnknownSpecialization
;
297 if (TemplateNameKind TNK
= Actions
.isTemplateName(getCurScope(), SS
,
298 /*hasTemplateKeyword=*/false,
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
311 if (AnnotateTemplateIdToken(Template
, TNK
, &SS
, TemplateName
,
312 SourceLocation(), false))
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
)
325 << FixItHint::CreateInsertion(Tok
.getLocation(), "template ");
327 if (TemplateNameKind TNK
328 = Actions
.ActOnDependentTemplateName(getCurScope(),
329 Tok
.getLocation(), SS
,
330 TemplateName
, ObjectType
,
331 EnteringContext
, Template
)) {
332 // Consume the identifier.
334 if (AnnotateTemplateIdToken(Template
, TNK
, &SS
, TemplateName
,
335 SourceLocation(), false))
345 // We don't have any tokens that form the beginning of a
346 // nested-name-specifier, so we're done.
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;
359 /// ParseCXXIdExpression - Handle id-expression.
366 /// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
368 /// '::' operator-function-id
371 /// NOTE: The standard specifies that, for qualified-id, the parser does not
374 /// '::' conversion-function-id
375 /// '::' '~' class-name
377 /// This may cause a slight inconsistency on diagnostics:
382 /// :: A :: ~ C(); // Some Sema error about using destructor with a
384 /// :: ~ C(); // Some Parser error like 'unexpected ~'.
387 /// We simplify the parser a bit and make it work like:
390 /// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
391 /// '::' unqualified-id
393 /// That way Sema can handle and report similar errors for namespaces and the
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
401 ExprResult
Parser::ParseCXXIdExpression(bool isAddressOfOperand
) {
403 // '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
404 // '::' unqualified-id
407 ParseOptionalCXXScopeSpecifier(SS
, ParsedType(), false);
410 if (ParseUnqualifiedId(SS
,
411 /*EnteringContext=*/false,
412 /*AllowDestructorName=*/false,
413 /*AllowConstructorName=*/false,
414 /*ObjectType=*/ ParsedType(),
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;
423 return Actions
.ActOnIdExpression(getCurScope(), SS
, Name
, Tok
.is(tok::l_paren
),
428 /// ParseCXXCasts - This handles the various ways to cast expressions to another
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 ')'
437 ExprResult
Parser::ParseCXXCasts() {
438 tok::TokenKind Kind
= Tok
.getKind();
439 const char *CastName
= 0; // For error messages
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;
449 SourceLocation OpLoc
= ConsumeToken();
450 SourceLocation LAngleBracketLoc
= Tok
.getLocation();
452 if (ExpectAndConsume(tok::less
, diag::err_expected_less_after
, CastName
))
455 TypeResult CastTy
= ParseTypeName();
456 SourceLocation RAngleBracketLoc
= Tok
.getLocation();
458 if (ExpectAndConsume(tok::greater
, diag::err_expected_greater
))
459 return ExprError(Diag(LAngleBracketLoc
, diag::note_matching
) << "<");
461 SourceLocation LParenLoc
= Tok
.getLocation(), RParenLoc
;
463 if (ExpectAndConsume(tok::l_paren
, diag::err_expected_lparen_after
, CastName
))
466 ExprResult Result
= ParseExpression();
469 RParenLoc
= MatchRHSPunctuation(tok::r_paren
, LParenLoc
);
471 if (!Result
.isInvalid() && !CastTy
.isInvalid())
472 Result
= Actions
.ActOnCXXNamedCast(OpLoc
, Kind
,
473 LAngleBracketLoc
, CastTy
.get(),
475 LParenLoc
, Result
.take(), RParenLoc
);
480 /// ParseCXXTypeid - This handles the C++ typeid expression.
482 /// postfix-expression: [C++ 5.2p1]
483 /// 'typeid' '(' expression ')'
484 /// 'typeid' '(' type-id ')'
486 ExprResult
Parser::ParseCXXTypeid() {
487 assert(Tok
.is(tok::kw_typeid
) && "Not 'typeid'!");
489 SourceLocation OpLoc
= ConsumeToken();
490 SourceLocation LParenLoc
= Tok
.getLocation();
491 SourceLocation RParenLoc
;
493 // typeid expressions are always parenthesized.
494 if (ExpectAndConsume(tok::l_paren
, diag::err_expected_lparen_after
,
500 if (isTypeIdInParens()) {
501 TypeResult Ty
= ParseTypeName();
504 RParenLoc
= MatchRHSPunctuation(tok::r_paren
, LParenLoc
);
506 if (Ty
.isInvalid() || RParenLoc
.isInvalid())
509 Result
= Actions
.ActOnCXXTypeid(OpLoc
, LParenLoc
, /*isType=*/true,
510 Ty
.get().getAsOpaquePtr(), RParenLoc
);
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).
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();
525 if (Result
.isInvalid())
526 SkipUntil(tok::r_paren
);
528 RParenLoc
= MatchRHSPunctuation(tok::r_paren
, LParenLoc
);
529 if (RParenLoc
.isInvalid())
532 Result
= Actions
.ActOnCXXTypeid(OpLoc
, LParenLoc
, /*isType=*/false,
533 Result
.release(), RParenLoc
);
540 /// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
542 /// '__uuidof' '(' expression ')'
543 /// '__uuidof' '(' type-id ')'
545 ExprResult
Parser::ParseCXXUuidof() {
546 assert(Tok
.is(tok::kw___uuidof
) && "Not '__uuidof'!");
548 SourceLocation OpLoc
= ConsumeToken();
549 SourceLocation LParenLoc
= Tok
.getLocation();
550 SourceLocation RParenLoc
;
552 // __uuidof expressions are always parenthesized.
553 if (ExpectAndConsume(tok::l_paren
, diag::err_expected_lparen_after
,
559 if (isTypeIdInParens()) {
560 TypeResult Ty
= ParseTypeName();
563 RParenLoc
= MatchRHSPunctuation(tok::r_paren
, LParenLoc
);
568 Result
= Actions
.ActOnCXXUuidof(OpLoc
, LParenLoc
, /*isType=*/true,
569 Ty
.get().getAsOpaquePtr(), RParenLoc
);
571 EnterExpressionEvaluationContext
Unevaluated(Actions
, Sema::Unevaluated
);
572 Result
= ParseExpression();
575 if (Result
.isInvalid())
576 SkipUntil(tok::r_paren
);
578 RParenLoc
= MatchRHSPunctuation(tok::r_paren
, LParenLoc
);
580 Result
= Actions
.ActOnCXXUuidof(OpLoc
, LParenLoc
, /*isType=*/false,
581 Result
.release(), RParenLoc
);
588 /// \brief Parse a C++ pseudo-destructor expression after the base,
589 /// . or -> operator, and nested-name-specifier have already been
592 /// postfix-expression: [C++ 5.2]
593 /// postfix-expression . pseudo-destructor-name
594 /// postfix-expression -> pseudo-destructor-name
596 /// pseudo-destructor-name:
597 /// ::[opt] nested-name-specifier[opt] type-name :: ~type-name
598 /// ::[opt] nested-name-specifier template simple-template-id ::
600 /// ::[opt] nested-name-specifier[opt] ~type-name
603 Parser::ParseCXXPseudoDestructor(ExprArg Base
, SourceLocation OpLoc
,
604 tok::TokenKind OpKind
,
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.
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());
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());
626 assert(Tok
.is(tok::coloncolon
) &&"ParseOptionalCXXScopeSpecifier fail");
627 CCLoc
= ConsumeToken();
629 FirstTypeName
.setIdentifier(0, SourceLocation());
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
);
640 // Parse the second type.
641 UnqualifiedId SecondTypeName
;
642 IdentifierInfo
*Name
= Tok
.getIdentifierInfo();
643 SourceLocation NameLoc
= ConsumeToken();
644 SecondTypeName
.setIdentifier(Name
, NameLoc
);
646 // If there is a '<', the second type name is a template-id. Parse
648 if (Tok
.is(tok::less
) &&
649 ParseUnqualifiedIdTemplateId(SS
, Name
, NameLoc
, false, ObjectType
,
650 SecondTypeName
, /*AssumeTemplateName=*/true,
651 /*TemplateKWLoc*/SourceLocation()))
654 return Actions
.ActOnPseudoDestructorExpr(getCurScope(), Base
,
656 SS
, FirstTypeName
, CCLoc
,
657 TildeLoc
, SecondTypeName
,
658 Tok
.is(tok::l_paren
));
661 /// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
663 /// boolean-literal: [C++ 2.13.5]
666 ExprResult
Parser::ParseCXXBoolLiteral() {
667 tok::TokenKind Kind
= Tok
.getKind();
668 return Actions
.ActOnCXXBoolLiteral(ConsumeToken(), Kind
);
671 /// ParseThrowExpression - This handles the C++ throw expression.
673 /// throw-expression: [C++ 15]
674 /// 'throw' assignment-expression[opt]
675 ExprResult
Parser::ParseThrowExpression() {
676 assert(Tok
.is(tok::kw_throw
) && "Not throw!");
677 SourceLocation ThrowLoc
= ConsumeToken(); // Eat the throw token.
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.
689 return Actions
.ActOnCXXThrow(ThrowLoc
, 0);
692 ExprResult
Expr(ParseAssignmentExpression());
693 if (Expr
.isInvalid()) return move(Expr
);
694 return Actions
.ActOnCXXThrow(ThrowLoc
, Expr
.take());
698 /// ParseCXXThis - This handles the C++ 'this' pointer.
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.
703 ExprResult
Parser::ParseCXXThis() {
704 assert(Tok
.is(tok::kw_this
) && "Not 'this'!");
705 SourceLocation ThisLoc
= ConsumeToken();
706 return Actions
.ActOnCXXThis(ThisLoc
);
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()").
714 /// postfix-expression: [C++ 5.2p1]
715 /// simple-type-specifier '(' expression-list[opt] ')' [C++ 5.2.3]
716 /// typename-specifier '(' expression-list[opt] ')' [TODO]
719 Parser::ParseCXXTypeConstructExpression(const DeclSpec
&DS
) {
720 Declarator
DeclaratorInfo(DS
, Declarator::TypeNameContext
);
721 ParsedType TypeRep
= Actions
.ActOnTypeName(getCurScope(), DeclaratorInfo
).get();
723 assert(Tok
.is(tok::l_paren
) && "Expected '('!");
724 GreaterThanIsOperatorScope
G(GreaterThanIsOperator
, true);
726 SourceLocation LParenLoc
= ConsumeParen();
728 ExprVector
Exprs(Actions
);
729 CommaLocsTy CommaLocs
;
731 if (Tok
.isNot(tok::r_paren
)) {
732 if (ParseExpressionList(Exprs
, CommaLocs
)) {
733 SkipUntil(tok::r_paren
);
739 SourceLocation RParenLoc
= MatchRHSPunctuation(tok::r_paren
, LParenLoc
);
741 // TypeRep could be null, if it references an invalid typedef.
745 assert((Exprs
.size() == 0 || Exprs
.size()-1 == CommaLocs
.size())&&
746 "Unexpected number of commas!");
747 return Actions
.ActOnCXXTypeConstructExpr(TypeRep
, LParenLoc
, move_arg(Exprs
),
751 /// ParseCXXCondition - if/switch/while condition expression.
755 /// type-specifier-seq declarator '=' assignment-expression
756 /// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
757 /// '=' assignment-expression
759 /// \param ExprResult if the condition was parsed as an expression, the
760 /// parsed expression.
762 /// \param DeclResult if the condition was parsed as a declaration, the
763 /// parsed declaration.
765 /// \param Loc The location of the start of the statement that requires this
766 /// condition, e.g., the "for" in a for loop.
768 /// \param ConvertToBoolean Whether the condition expression should be
769 /// converted to a boolean value.
771 /// \returns true if there was a parsing, false otherwise.
772 bool Parser::ParseCXXCondition(ExprResult
&ExprOut
,
775 bool ConvertToBoolean
) {
776 if (Tok
.is(tok::code_completion
)) {
777 Actions
.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition
);
778 ConsumeCodeCompletionToken();
781 if (!isCXXConditionDeclaration()) {
782 // Parse the expression.
783 ExprOut
= ParseExpression(); // expression
785 if (ExprOut
.isInvalid())
788 // If required, convert to a boolean value.
789 if (ConvertToBoolean
)
791 = Actions
.ActOnBooleanCondition(getCurScope(), Loc
, ExprOut
.get());
792 return ExprOut
.isInvalid();
795 // type-specifier-seq
797 ParseSpecifierQualifierList(DS
);
800 Declarator
DeclaratorInfo(DS
, Declarator::ConditionContext
);
801 ParseDeclarator(DeclaratorInfo
);
803 // simple-asm-expr[opt]
804 if (Tok
.is(tok::kw_asm
)) {
806 ExprResult
AsmLabel(ParseSimpleAsm(&Loc
));
807 if (AsmLabel
.isInvalid()) {
808 SkipUntil(tok::semi
);
811 DeclaratorInfo
.setAsmLabel(AsmLabel
.release());
812 DeclaratorInfo
.SetRangeEnd(Loc
);
815 // If attributes are present, parse them.
816 MaybeParseGNUAttributes(DeclaratorInfo
);
818 // Type-check the declaration itself.
819 DeclResult Dcl
= Actions
.ActOnCXXConditionDeclaration(getCurScope(),
822 ExprOut
= ExprError();
824 // '=' assignment-expression
825 if (isTokenEqualOrMistypedEqualEqual(
826 diag::err_invalid_equalequal_after_declarator
)) {
828 ExprResult
AssignExpr(ParseAssignmentExpression());
829 if (!AssignExpr
.isInvalid())
830 Actions
.AddInitializerToDecl(DeclOut
, AssignExpr
.take());
832 // FIXME: C++0x allows a braced-init-list
833 Diag(Tok
, diag::err_expected_equal_after_declarator
);
836 // FIXME: Build a reference to this declaration? Convert it to bool?
837 // (This is currently handled by Sema).
842 /// \brief Determine whether the current token starts a C++
843 /// simple-type-specifier.
844 bool Parser::isCXXSimpleTypeSpecifier() const {
845 switch (Tok
.getKind()) {
846 case tok::annot_typename
:
850 case tok::kw_unsigned
:
856 case tok::kw_wchar_t
:
857 case tok::kw_char16_t
:
858 case tok::kw_char32_t
:
860 // FIXME: C++0x decltype support.
861 // GNU typeof support.
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.
876 /// simple-type-specifier:
877 /// '::'[opt] nested-name-specifier[opt] type-name
878 /// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
890 /// [GNU] typeof-specifier
891 /// [C++0x] auto [TODO]
898 void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec
&DS
) {
899 DS
.SetRangeStart(Tok
.getLocation());
900 const char *PrevSpec
;
902 SourceLocation Loc
= Tok
.getLocation();
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!");
909 assert(0 && "Not a simple-type-specifier token!");
913 case tok::annot_typename
: {
914 if (getTypeAnnotation(Tok
))
915 DS
.SetTypeSpecType(DeclSpec::TST_typename
, Loc
, PrevSpec
, DiagID
,
916 getTypeAnnotation(Tok
));
918 DS
.SetTypeSpecError();
920 DS
.SetRangeEnd(Tok
.getAnnotationEndLoc());
923 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
924 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
925 // Objective-C interface. If we don't have Objective-C or a '<', this is
926 // just a normal reference to a typedef name.
927 if (Tok
.is(tok::less
) && getLang().ObjC1
)
928 ParseObjCProtocolQualifiers(DS
);
930 DS
.Finish(Diags
, PP
);
936 DS
.SetTypeSpecWidth(DeclSpec::TSW_short
, Loc
, PrevSpec
, DiagID
);
939 DS
.SetTypeSpecWidth(DeclSpec::TSW_long
, Loc
, PrevSpec
, DiagID
);
942 DS
.SetTypeSpecSign(DeclSpec::TSS_signed
, Loc
, PrevSpec
, DiagID
);
944 case tok::kw_unsigned
:
945 DS
.SetTypeSpecSign(DeclSpec::TSS_unsigned
, Loc
, PrevSpec
, DiagID
);
948 DS
.SetTypeSpecType(DeclSpec::TST_void
, Loc
, PrevSpec
, DiagID
);
951 DS
.SetTypeSpecType(DeclSpec::TST_char
, Loc
, PrevSpec
, DiagID
);
954 DS
.SetTypeSpecType(DeclSpec::TST_int
, Loc
, PrevSpec
, DiagID
);
957 DS
.SetTypeSpecType(DeclSpec::TST_float
, Loc
, PrevSpec
, DiagID
);
960 DS
.SetTypeSpecType(DeclSpec::TST_double
, Loc
, PrevSpec
, DiagID
);
962 case tok::kw_wchar_t
:
963 DS
.SetTypeSpecType(DeclSpec::TST_wchar
, Loc
, PrevSpec
, DiagID
);
965 case tok::kw_char16_t
:
966 DS
.SetTypeSpecType(DeclSpec::TST_char16
, Loc
, PrevSpec
, DiagID
);
968 case tok::kw_char32_t
:
969 DS
.SetTypeSpecType(DeclSpec::TST_char32
, Loc
, PrevSpec
, DiagID
);
972 DS
.SetTypeSpecType(DeclSpec::TST_bool
, Loc
, PrevSpec
, DiagID
);
975 // FIXME: C++0x decltype support.
976 // GNU typeof support.
978 ParseTypeofSpecifier(DS
);
979 DS
.Finish(Diags
, PP
);
982 if (Tok
.is(tok::annot_typename
))
983 DS
.SetRangeEnd(Tok
.getAnnotationEndLoc());
985 DS
.SetRangeEnd(Tok
.getLocation());
987 DS
.Finish(Diags
, PP
);
990 /// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
991 /// [dcl.name]), which is a non-empty sequence of type-specifiers,
992 /// e.g., "const short int". Note that the DeclSpec is *not* finished
993 /// by parsing the type-specifier-seq, because these sequences are
994 /// typically followed by some form of declarator. Returns true and
995 /// emits diagnostics if this is not a type-specifier-seq, false
998 /// type-specifier-seq: [C++ 8.1]
999 /// type-specifier type-specifier-seq[opt]
1001 bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec
&DS
) {
1002 DS
.SetRangeStart(Tok
.getLocation());
1003 const char *PrevSpec
= 0;
1007 // Parse one or more of the type specifiers.
1008 if (!ParseOptionalTypeSpecifier(DS
, isInvalid
, PrevSpec
, DiagID
,
1009 ParsedTemplateInfo(), /*SuppressDeclarations*/true)) {
1010 Diag(Tok
, diag::err_expected_type
);
1014 while (ParseOptionalTypeSpecifier(DS
, isInvalid
, PrevSpec
, DiagID
,
1015 ParsedTemplateInfo(), /*SuppressDeclarations*/true))
1018 DS
.Finish(Diags
, PP
);
1022 /// \brief Finish parsing a C++ unqualified-id that is a template-id of
1025 /// This routine is invoked when a '<' is encountered after an identifier or
1026 /// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
1027 /// whether the unqualified-id is actually a template-id. This routine will
1028 /// then parse the template arguments and form the appropriate template-id to
1029 /// return to the caller.
1031 /// \param SS the nested-name-specifier that precedes this template-id, if
1032 /// we're actually parsing a qualified-id.
1034 /// \param Name for constructor and destructor names, this is the actual
1035 /// identifier that may be a template-name.
1037 /// \param NameLoc the location of the class-name in a constructor or
1040 /// \param EnteringContext whether we're entering the scope of the
1041 /// nested-name-specifier.
1043 /// \param ObjectType if this unqualified-id occurs within a member access
1044 /// expression, the type of the base object whose member is being accessed.
1046 /// \param Id as input, describes the template-name or operator-function-id
1047 /// that precedes the '<'. If template arguments were parsed successfully,
1048 /// will be updated with the template-id.
1050 /// \param AssumeTemplateId When true, this routine will assume that the name
1051 /// refers to a template without performing name lookup to verify.
1053 /// \returns true if a parse error occurred, false otherwise.
1054 bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec
&SS
,
1055 IdentifierInfo
*Name
,
1056 SourceLocation NameLoc
,
1057 bool EnteringContext
,
1058 ParsedType ObjectType
,
1060 bool AssumeTemplateId
,
1061 SourceLocation TemplateKWLoc
) {
1062 assert((AssumeTemplateId
|| Tok
.is(tok::less
)) &&
1063 "Expected '<' to finish parsing a template-id");
1065 TemplateTy Template
;
1066 TemplateNameKind TNK
= TNK_Non_template
;
1067 switch (Id
.getKind()) {
1068 case UnqualifiedId::IK_Identifier
:
1069 case UnqualifiedId::IK_OperatorFunctionId
:
1070 case UnqualifiedId::IK_LiteralOperatorId
:
1071 if (AssumeTemplateId
) {
1072 TNK
= Actions
.ActOnDependentTemplateName(getCurScope(), TemplateKWLoc
, SS
,
1073 Id
, ObjectType
, EnteringContext
,
1075 if (TNK
== TNK_Non_template
)
1078 bool MemberOfUnknownSpecialization
;
1079 TNK
= Actions
.isTemplateName(getCurScope(), SS
,
1080 TemplateKWLoc
.isValid(), Id
,
1081 ObjectType
, EnteringContext
, Template
,
1082 MemberOfUnknownSpecialization
);
1084 if (TNK
== TNK_Non_template
&& MemberOfUnknownSpecialization
&&
1085 ObjectType
&& IsTemplateArgumentList()) {
1086 // We have something like t->getAs<T>(), where getAs is a
1087 // member of an unknown specialization. However, this will only
1088 // parse correctly as a template, so suggest the keyword 'template'
1089 // before 'getAs' and treat this as a dependent template name.
1091 if (Id
.getKind() == UnqualifiedId::IK_Identifier
)
1092 Name
= Id
.Identifier
->getName();
1095 if (Id
.getKind() == UnqualifiedId::IK_OperatorFunctionId
)
1096 Name
+= getOperatorSpelling(Id
.OperatorFunctionId
.Operator
);
1098 Name
+= Id
.Identifier
->getName();
1100 Diag(Id
.StartLocation
, diag::err_missing_dependent_template_keyword
)
1102 << FixItHint::CreateInsertion(Id
.StartLocation
, "template ");
1103 TNK
= Actions
.ActOnDependentTemplateName(getCurScope(), TemplateKWLoc
,
1105 EnteringContext
, Template
);
1106 if (TNK
== TNK_Non_template
)
1112 case UnqualifiedId::IK_ConstructorName
: {
1113 UnqualifiedId TemplateName
;
1114 bool MemberOfUnknownSpecialization
;
1115 TemplateName
.setIdentifier(Name
, NameLoc
);
1116 TNK
= Actions
.isTemplateName(getCurScope(), SS
, TemplateKWLoc
.isValid(),
1117 TemplateName
, ObjectType
,
1118 EnteringContext
, Template
,
1119 MemberOfUnknownSpecialization
);
1123 case UnqualifiedId::IK_DestructorName
: {
1124 UnqualifiedId TemplateName
;
1125 bool MemberOfUnknownSpecialization
;
1126 TemplateName
.setIdentifier(Name
, NameLoc
);
1128 TNK
= Actions
.ActOnDependentTemplateName(getCurScope(), TemplateKWLoc
, SS
,
1129 TemplateName
, ObjectType
,
1130 EnteringContext
, Template
);
1131 if (TNK
== TNK_Non_template
)
1134 TNK
= Actions
.isTemplateName(getCurScope(), SS
, TemplateKWLoc
.isValid(),
1135 TemplateName
, ObjectType
,
1136 EnteringContext
, Template
,
1137 MemberOfUnknownSpecialization
);
1139 if (TNK
== TNK_Non_template
&& !Id
.DestructorName
.get()) {
1140 Diag(NameLoc
, diag::err_destructor_template_id
)
1141 << Name
<< SS
.getRange();
1152 if (TNK
== TNK_Non_template
)
1155 // Parse the enclosed template argument list.
1156 SourceLocation LAngleLoc
, RAngleLoc
;
1157 TemplateArgList TemplateArgs
;
1158 if (Tok
.is(tok::less
) &&
1159 ParseTemplateIdAfterTemplateName(Template
, Id
.StartLocation
,
1160 &SS
, true, LAngleLoc
,
1165 if (Id
.getKind() == UnqualifiedId::IK_Identifier
||
1166 Id
.getKind() == UnqualifiedId::IK_OperatorFunctionId
||
1167 Id
.getKind() == UnqualifiedId::IK_LiteralOperatorId
) {
1168 // Form a parsed representation of the template-id to be stored in the
1170 TemplateIdAnnotation
*TemplateId
1171 = TemplateIdAnnotation::Allocate(TemplateArgs
.size());
1173 if (Id
.getKind() == UnqualifiedId::IK_Identifier
) {
1174 TemplateId
->Name
= Id
.Identifier
;
1175 TemplateId
->Operator
= OO_None
;
1176 TemplateId
->TemplateNameLoc
= Id
.StartLocation
;
1178 TemplateId
->Name
= 0;
1179 TemplateId
->Operator
= Id
.OperatorFunctionId
.Operator
;
1180 TemplateId
->TemplateNameLoc
= Id
.StartLocation
;
1183 TemplateId
->Template
= Template
;
1184 TemplateId
->Kind
= TNK
;
1185 TemplateId
->LAngleLoc
= LAngleLoc
;
1186 TemplateId
->RAngleLoc
= RAngleLoc
;
1187 ParsedTemplateArgument
*Args
= TemplateId
->getTemplateArgs();
1188 for (unsigned Arg
= 0, ArgEnd
= TemplateArgs
.size();
1189 Arg
!= ArgEnd
; ++Arg
)
1190 Args
[Arg
] = TemplateArgs
[Arg
];
1192 Id
.setTemplateId(TemplateId
);
1196 // Bundle the template arguments together.
1197 ASTTemplateArgsPtr
TemplateArgsPtr(Actions
, TemplateArgs
.data(),
1198 TemplateArgs
.size());
1200 // Constructor and destructor names.
1202 = Actions
.ActOnTemplateIdType(Template
, NameLoc
,
1203 LAngleLoc
, TemplateArgsPtr
,
1205 if (Type
.isInvalid())
1208 if (Id
.getKind() == UnqualifiedId::IK_ConstructorName
)
1209 Id
.setConstructorName(Type
.get(), NameLoc
, RAngleLoc
);
1211 Id
.setDestructorName(Id
.StartLocation
, Type
.get(), RAngleLoc
);
1216 /// \brief Parse an operator-function-id or conversion-function-id as part
1217 /// of a C++ unqualified-id.
1219 /// This routine is responsible only for parsing the operator-function-id or
1220 /// conversion-function-id; it does not handle template arguments in any way.
1223 /// operator-function-id: [C++ 13.5]
1224 /// 'operator' operator
1226 /// operator: one of
1227 /// new delete new[] delete[]
1228 /// + - * / % ^ & | ~
1229 /// ! = < > += -= *= /= %=
1230 /// ^= &= |= << >> >>= <<= == !=
1231 /// <= >= && || ++ -- , ->* ->
1234 /// conversion-function-id: [C++ 12.3.2]
1235 /// operator conversion-type-id
1237 /// conversion-type-id:
1238 /// type-specifier-seq conversion-declarator[opt]
1240 /// conversion-declarator:
1241 /// ptr-operator conversion-declarator[opt]
1244 /// \param The nested-name-specifier that preceded this unqualified-id. If
1245 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
1247 /// \param EnteringContext whether we are entering the scope of the
1248 /// nested-name-specifier.
1250 /// \param ObjectType if this unqualified-id occurs within a member access
1251 /// expression, the type of the base object whose member is being accessed.
1253 /// \param Result on a successful parse, contains the parsed unqualified-id.
1255 /// \returns true if parsing fails, false otherwise.
1256 bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec
&SS
, bool EnteringContext
,
1257 ParsedType ObjectType
,
1258 UnqualifiedId
&Result
) {
1259 assert(Tok
.is(tok::kw_operator
) && "Expected 'operator' keyword");
1261 // Consume the 'operator' keyword.
1262 SourceLocation KeywordLoc
= ConsumeToken();
1264 // Determine what kind of operator name we have.
1265 unsigned SymbolIdx
= 0;
1266 SourceLocation SymbolLocations
[3];
1267 OverloadedOperatorKind Op
= OO_None
;
1268 switch (Tok
.getKind()) {
1270 case tok::kw_delete
: {
1271 bool isNew
= Tok
.getKind() == tok::kw_new
;
1272 // Consume the 'new' or 'delete'.
1273 SymbolLocations
[SymbolIdx
++] = ConsumeToken();
1274 if (Tok
.is(tok::l_square
)) {
1276 SourceLocation LBracketLoc
= ConsumeBracket();
1278 SourceLocation RBracketLoc
= MatchRHSPunctuation(tok::r_square
,
1280 if (RBracketLoc
.isInvalid())
1283 SymbolLocations
[SymbolIdx
++] = LBracketLoc
;
1284 SymbolLocations
[SymbolIdx
++] = RBracketLoc
;
1285 Op
= isNew
? OO_Array_New
: OO_Array_Delete
;
1287 Op
= isNew
? OO_New
: OO_Delete
;
1292 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
1294 SymbolLocations[SymbolIdx++] = ConsumeToken(); \
1297 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
1298 #include "clang/Basic/OperatorKinds.def"
1300 case tok::l_paren
: {
1302 SourceLocation LParenLoc
= ConsumeParen();
1304 SourceLocation RParenLoc
= MatchRHSPunctuation(tok::r_paren
,
1306 if (RParenLoc
.isInvalid())
1309 SymbolLocations
[SymbolIdx
++] = LParenLoc
;
1310 SymbolLocations
[SymbolIdx
++] = RParenLoc
;
1315 case tok::l_square
: {
1317 SourceLocation LBracketLoc
= ConsumeBracket();
1319 SourceLocation RBracketLoc
= MatchRHSPunctuation(tok::r_square
,
1321 if (RBracketLoc
.isInvalid())
1324 SymbolLocations
[SymbolIdx
++] = LBracketLoc
;
1325 SymbolLocations
[SymbolIdx
++] = RBracketLoc
;
1330 case tok::code_completion
: {
1331 // Code completion for the operator name.
1332 Actions
.CodeCompleteOperatorName(getCurScope());
1334 // Consume the operator token.
1335 ConsumeCodeCompletionToken();
1337 // Don't try to parse any further.
1345 if (Op
!= OO_None
) {
1346 // We have parsed an operator-function-id.
1347 Result
.setOperatorFunctionId(KeywordLoc
, Op
, SymbolLocations
);
1351 // Parse a literal-operator-id.
1353 // literal-operator-id: [C++0x 13.5.8]
1354 // operator "" identifier
1356 if (getLang().CPlusPlus0x
&& Tok
.is(tok::string_literal
)) {
1357 if (Tok
.getLength() != 2)
1358 Diag(Tok
.getLocation(), diag::err_operator_string_not_empty
);
1359 ConsumeStringToken();
1361 if (Tok
.isNot(tok::identifier
)) {
1362 Diag(Tok
.getLocation(), diag::err_expected_ident
);
1366 IdentifierInfo
*II
= Tok
.getIdentifierInfo();
1367 Result
.setLiteralOperatorId(II
, KeywordLoc
, ConsumeToken());
1371 // Parse a conversion-function-id.
1373 // conversion-function-id: [C++ 12.3.2]
1374 // operator conversion-type-id
1376 // conversion-type-id:
1377 // type-specifier-seq conversion-declarator[opt]
1379 // conversion-declarator:
1380 // ptr-operator conversion-declarator[opt]
1382 // Parse the type-specifier-seq.
1384 if (ParseCXXTypeSpecifierSeq(DS
)) // FIXME: ObjectType?
1387 // Parse the conversion-declarator, which is merely a sequence of
1389 Declarator
D(DS
, Declarator::TypeNameContext
);
1390 ParseDeclaratorInternal(D
, /*DirectDeclParser=*/0);
1392 // Finish up the type.
1393 TypeResult Ty
= Actions
.ActOnTypeName(getCurScope(), D
);
1397 // Note that this is a conversion-function-id.
1398 Result
.setConversionFunctionId(KeywordLoc
, Ty
.get(),
1399 D
.getSourceRange().getEnd());
1403 /// \brief Parse a C++ unqualified-id (or a C identifier), which describes the
1404 /// name of an entity.
1407 /// unqualified-id: [C++ expr.prim.general]
1409 /// operator-function-id
1410 /// conversion-function-id
1411 /// [C++0x] literal-operator-id [TODO]
1417 /// \param The nested-name-specifier that preceded this unqualified-id. If
1418 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
1420 /// \param EnteringContext whether we are entering the scope of the
1421 /// nested-name-specifier.
1423 /// \param AllowDestructorName whether we allow parsing of a destructor name.
1425 /// \param AllowConstructorName whether we allow parsing a constructor name.
1427 /// \param ObjectType if this unqualified-id occurs within a member access
1428 /// expression, the type of the base object whose member is being accessed.
1430 /// \param Result on a successful parse, contains the parsed unqualified-id.
1432 /// \returns true if parsing fails, false otherwise.
1433 bool Parser::ParseUnqualifiedId(CXXScopeSpec
&SS
, bool EnteringContext
,
1434 bool AllowDestructorName
,
1435 bool AllowConstructorName
,
1436 ParsedType ObjectType
,
1437 UnqualifiedId
&Result
) {
1439 // Handle 'A::template B'. This is for template-ids which have not
1440 // already been annotated by ParseOptionalCXXScopeSpecifier().
1441 bool TemplateSpecified
= false;
1442 SourceLocation TemplateKWLoc
;
1443 if (getLang().CPlusPlus
&& Tok
.is(tok::kw_template
) &&
1444 (ObjectType
|| SS
.isSet())) {
1445 TemplateSpecified
= true;
1446 TemplateKWLoc
= ConsumeToken();
1451 // template-id (when it hasn't already been annotated)
1452 if (Tok
.is(tok::identifier
)) {
1453 // Consume the identifier.
1454 IdentifierInfo
*Id
= Tok
.getIdentifierInfo();
1455 SourceLocation IdLoc
= ConsumeToken();
1457 if (!getLang().CPlusPlus
) {
1458 // If we're not in C++, only identifiers matter. Record the
1459 // identifier and return.
1460 Result
.setIdentifier(Id
, IdLoc
);
1464 if (AllowConstructorName
&&
1465 Actions
.isCurrentClassName(*Id
, getCurScope(), &SS
)) {
1466 // We have parsed a constructor name.
1467 Result
.setConstructorName(Actions
.getTypeName(*Id
, IdLoc
, getCurScope(),
1471 // We have parsed an identifier.
1472 Result
.setIdentifier(Id
, IdLoc
);
1475 // If the next token is a '<', we may have a template.
1476 if (TemplateSpecified
|| Tok
.is(tok::less
))
1477 return ParseUnqualifiedIdTemplateId(SS
, Id
, IdLoc
, EnteringContext
,
1479 TemplateSpecified
, TemplateKWLoc
);
1485 // template-id (already parsed and annotated)
1486 if (Tok
.is(tok::annot_template_id
)) {
1487 TemplateIdAnnotation
*TemplateId
1488 = static_cast<TemplateIdAnnotation
*>(Tok
.getAnnotationValue());
1490 // If the template-name names the current class, then this is a constructor
1491 if (AllowConstructorName
&& TemplateId
->Name
&&
1492 Actions
.isCurrentClassName(*TemplateId
->Name
, getCurScope(), &SS
)) {
1494 // C++ [class.qual]p2 specifies that a qualified template-name
1495 // is taken as the constructor name where a constructor can be
1496 // declared. Thus, the template arguments are extraneous, so
1497 // complain about them and remove them entirely.
1498 Diag(TemplateId
->TemplateNameLoc
,
1499 diag::err_out_of_line_constructor_template_id
)
1501 << FixItHint::CreateRemoval(
1502 SourceRange(TemplateId
->LAngleLoc
, TemplateId
->RAngleLoc
));
1503 Result
.setConstructorName(Actions
.getTypeName(*TemplateId
->Name
,
1504 TemplateId
->TemplateNameLoc
,
1507 TemplateId
->TemplateNameLoc
,
1508 TemplateId
->RAngleLoc
);
1509 TemplateId
->Destroy();
1514 Result
.setConstructorTemplateId(TemplateId
);
1519 // We have already parsed a template-id; consume the annotation token as
1520 // our unqualified-id.
1521 Result
.setTemplateId(TemplateId
);
1527 // operator-function-id
1528 // conversion-function-id
1529 if (Tok
.is(tok::kw_operator
)) {
1530 if (ParseUnqualifiedIdOperator(SS
, EnteringContext
, ObjectType
, Result
))
1533 // If we have an operator-function-id or a literal-operator-id and the next
1534 // token is a '<', we may have a
1537 // operator-function-id < template-argument-list[opt] >
1538 if ((Result
.getKind() == UnqualifiedId::IK_OperatorFunctionId
||
1539 Result
.getKind() == UnqualifiedId::IK_LiteralOperatorId
) &&
1540 (TemplateSpecified
|| Tok
.is(tok::less
)))
1541 return ParseUnqualifiedIdTemplateId(SS
, 0, SourceLocation(),
1542 EnteringContext
, ObjectType
,
1544 TemplateSpecified
, TemplateKWLoc
);
1549 if (getLang().CPlusPlus
&&
1550 (AllowDestructorName
|| SS
.isSet()) && Tok
.is(tok::tilde
)) {
1551 // C++ [expr.unary.op]p10:
1552 // There is an ambiguity in the unary-expression ~X(), where X is a
1553 // class-name. The ambiguity is resolved in favor of treating ~ as a
1554 // unary complement rather than treating ~X as referring to a destructor.
1557 SourceLocation TildeLoc
= ConsumeToken();
1559 // Parse the class-name.
1560 if (Tok
.isNot(tok::identifier
)) {
1561 Diag(Tok
, diag::err_destructor_tilde_identifier
);
1565 // Parse the class-name (or template-name in a simple-template-id).
1566 IdentifierInfo
*ClassName
= Tok
.getIdentifierInfo();
1567 SourceLocation ClassNameLoc
= ConsumeToken();
1569 if (TemplateSpecified
|| Tok
.is(tok::less
)) {
1570 Result
.setDestructorName(TildeLoc
, ParsedType(), ClassNameLoc
);
1571 return ParseUnqualifiedIdTemplateId(SS
, ClassName
, ClassNameLoc
,
1572 EnteringContext
, ObjectType
, Result
,
1573 TemplateSpecified
, TemplateKWLoc
);
1576 // Note that this is a destructor name.
1577 ParsedType Ty
= Actions
.getDestructorName(TildeLoc
, *ClassName
,
1578 ClassNameLoc
, getCurScope(),
1584 Result
.setDestructorName(TildeLoc
, Ty
, ClassNameLoc
);
1588 Diag(Tok
, diag::err_expected_unqualified_id
)
1589 << getLang().CPlusPlus
;
1593 /// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
1594 /// memory in a typesafe manner and call constructors.
1596 /// This method is called to parse the new expression after the optional :: has
1597 /// been already parsed. If the :: was present, "UseGlobal" is true and "Start"
1598 /// is its location. Otherwise, "Start" is the location of the 'new' token.
1601 /// '::'[opt] 'new' new-placement[opt] new-type-id
1602 /// new-initializer[opt]
1603 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
1604 /// new-initializer[opt]
1607 /// '(' expression-list ')'
1610 /// type-specifier-seq new-declarator[opt]
1613 /// ptr-operator new-declarator[opt]
1614 /// direct-new-declarator
1616 /// new-initializer:
1617 /// '(' expression-list[opt] ')'
1618 /// [C++0x] braced-init-list [TODO]
1621 Parser::ParseCXXNewExpression(bool UseGlobal
, SourceLocation Start
) {
1622 assert(Tok
.is(tok::kw_new
) && "expected 'new' token");
1623 ConsumeToken(); // Consume 'new'
1625 // A '(' now can be a new-placement or the '(' wrapping the type-id in the
1626 // second form of new-expression. It can't be a new-type-id.
1628 ExprVector
PlacementArgs(Actions
);
1629 SourceLocation PlacementLParen
, PlacementRParen
;
1631 SourceRange TypeIdParens
;
1633 Declarator
DeclaratorInfo(DS
, Declarator::TypeNameContext
);
1634 if (Tok
.is(tok::l_paren
)) {
1635 // If it turns out to be a placement, we change the type location.
1636 PlacementLParen
= ConsumeParen();
1637 if (ParseExpressionListOrTypeId(PlacementArgs
, DeclaratorInfo
)) {
1638 SkipUntil(tok::semi
, /*StopAtSemi=*/true, /*DontConsume=*/true);
1642 PlacementRParen
= MatchRHSPunctuation(tok::r_paren
, PlacementLParen
);
1643 if (PlacementRParen
.isInvalid()) {
1644 SkipUntil(tok::semi
, /*StopAtSemi=*/true, /*DontConsume=*/true);
1648 if (PlacementArgs
.empty()) {
1649 // Reset the placement locations. There was no placement.
1650 TypeIdParens
= SourceRange(PlacementLParen
, PlacementRParen
);
1651 PlacementLParen
= PlacementRParen
= SourceLocation();
1653 // We still need the type.
1654 if (Tok
.is(tok::l_paren
)) {
1655 TypeIdParens
.setBegin(ConsumeParen());
1656 ParseSpecifierQualifierList(DS
);
1657 DeclaratorInfo
.SetSourceRange(DS
.getSourceRange());
1658 ParseDeclarator(DeclaratorInfo
);
1659 TypeIdParens
.setEnd(MatchRHSPunctuation(tok::r_paren
,
1660 TypeIdParens
.getBegin()));
1662 if (ParseCXXTypeSpecifierSeq(DS
))
1663 DeclaratorInfo
.setInvalidType(true);
1665 DeclaratorInfo
.SetSourceRange(DS
.getSourceRange());
1666 ParseDeclaratorInternal(DeclaratorInfo
,
1667 &Parser::ParseDirectNewDeclarator
);
1672 // A new-type-id is a simplified type-id, where essentially the
1673 // direct-declarator is replaced by a direct-new-declarator.
1674 if (ParseCXXTypeSpecifierSeq(DS
))
1675 DeclaratorInfo
.setInvalidType(true);
1677 DeclaratorInfo
.SetSourceRange(DS
.getSourceRange());
1678 ParseDeclaratorInternal(DeclaratorInfo
,
1679 &Parser::ParseDirectNewDeclarator
);
1682 if (DeclaratorInfo
.isInvalidType()) {
1683 SkipUntil(tok::semi
, /*StopAtSemi=*/true, /*DontConsume=*/true);
1687 ExprVector
ConstructorArgs(Actions
);
1688 SourceLocation ConstructorLParen
, ConstructorRParen
;
1690 if (Tok
.is(tok::l_paren
)) {
1691 ConstructorLParen
= ConsumeParen();
1692 if (Tok
.isNot(tok::r_paren
)) {
1693 CommaLocsTy CommaLocs
;
1694 if (ParseExpressionList(ConstructorArgs
, CommaLocs
)) {
1695 SkipUntil(tok::semi
, /*StopAtSemi=*/true, /*DontConsume=*/true);
1699 ConstructorRParen
= MatchRHSPunctuation(tok::r_paren
, ConstructorLParen
);
1700 if (ConstructorRParen
.isInvalid()) {
1701 SkipUntil(tok::semi
, /*StopAtSemi=*/true, /*DontConsume=*/true);
1706 return Actions
.ActOnCXXNew(Start
, UseGlobal
, PlacementLParen
,
1707 move_arg(PlacementArgs
), PlacementRParen
,
1708 TypeIdParens
, DeclaratorInfo
, ConstructorLParen
,
1709 move_arg(ConstructorArgs
), ConstructorRParen
);
1712 /// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
1713 /// passed to ParseDeclaratorInternal.
1715 /// direct-new-declarator:
1716 /// '[' expression ']'
1717 /// direct-new-declarator '[' constant-expression ']'
1719 void Parser::ParseDirectNewDeclarator(Declarator
&D
) {
1720 // Parse the array dimensions.
1722 while (Tok
.is(tok::l_square
)) {
1723 SourceLocation LLoc
= ConsumeBracket();
1724 ExprResult
Size(first
? ParseExpression()
1725 : ParseConstantExpression());
1726 if (Size
.isInvalid()) {
1728 SkipUntil(tok::r_square
);
1733 SourceLocation RLoc
= MatchRHSPunctuation(tok::r_square
, LLoc
);
1734 D
.AddTypeInfo(DeclaratorChunk::getArray(0, ParsedAttributes(),
1735 /*static=*/false, /*star=*/false,
1736 Size
.release(), LLoc
, RLoc
),
1739 if (RLoc
.isInvalid())
1744 /// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
1745 /// This ambiguity appears in the syntax of the C++ new operator.
1748 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
1749 /// new-initializer[opt]
1752 /// '(' expression-list ')'
1754 bool Parser::ParseExpressionListOrTypeId(
1755 llvm::SmallVectorImpl
<Expr
*> &PlacementArgs
,
1757 // The '(' was already consumed.
1758 if (isTypeIdInParens()) {
1759 ParseSpecifierQualifierList(D
.getMutableDeclSpec());
1760 D
.SetSourceRange(D
.getDeclSpec().getSourceRange());
1762 return D
.isInvalidType();
1765 // It's not a type, it has to be an expression list.
1766 // Discard the comma locations - ActOnCXXNew has enough parameters.
1767 CommaLocsTy CommaLocs
;
1768 return ParseExpressionList(PlacementArgs
, CommaLocs
);
1771 /// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
1772 /// to free memory allocated by new.
1774 /// This method is called to parse the 'delete' expression after the optional
1775 /// '::' has been already parsed. If the '::' was present, "UseGlobal" is true
1776 /// and "Start" is its location. Otherwise, "Start" is the location of the
1779 /// delete-expression:
1780 /// '::'[opt] 'delete' cast-expression
1781 /// '::'[opt] 'delete' '[' ']' cast-expression
1783 Parser::ParseCXXDeleteExpression(bool UseGlobal
, SourceLocation Start
) {
1784 assert(Tok
.is(tok::kw_delete
) && "Expected 'delete' keyword");
1785 ConsumeToken(); // Consume 'delete'
1788 bool ArrayDelete
= false;
1789 if (Tok
.is(tok::l_square
)) {
1791 SourceLocation LHS
= ConsumeBracket();
1792 SourceLocation RHS
= MatchRHSPunctuation(tok::r_square
, LHS
);
1793 if (RHS
.isInvalid())
1797 ExprResult
Operand(ParseCastExpression(false));
1798 if (Operand
.isInvalid())
1799 return move(Operand
);
1801 return Actions
.ActOnCXXDelete(Start
, UseGlobal
, ArrayDelete
, Operand
.take());
1804 static UnaryTypeTrait
UnaryTypeTraitFromTokKind(tok::TokenKind kind
) {
1806 default: llvm_unreachable("Not a known unary type trait");
1807 case tok::kw___has_nothrow_assign
: return UTT_HasNothrowAssign
;
1808 case tok::kw___has_nothrow_copy
: return UTT_HasNothrowCopy
;
1809 case tok::kw___has_nothrow_constructor
: return UTT_HasNothrowConstructor
;
1810 case tok::kw___has_trivial_assign
: return UTT_HasTrivialAssign
;
1811 case tok::kw___has_trivial_copy
: return UTT_HasTrivialCopy
;
1812 case tok::kw___has_trivial_constructor
: return UTT_HasTrivialConstructor
;
1813 case tok::kw___has_trivial_destructor
: return UTT_HasTrivialDestructor
;
1814 case tok::kw___has_virtual_destructor
: return UTT_HasVirtualDestructor
;
1815 case tok::kw___is_abstract
: return UTT_IsAbstract
;
1816 case tok::kw___is_class
: return UTT_IsClass
;
1817 case tok::kw___is_empty
: return UTT_IsEmpty
;
1818 case tok::kw___is_enum
: return UTT_IsEnum
;
1819 case tok::kw___is_pod
: return UTT_IsPOD
;
1820 case tok::kw___is_polymorphic
: return UTT_IsPolymorphic
;
1821 case tok::kw___is_union
: return UTT_IsUnion
;
1822 case tok::kw___is_literal
: return UTT_IsLiteral
;
1826 static BinaryTypeTrait
BinaryTypeTraitFromTokKind(tok::TokenKind kind
) {
1828 default: llvm_unreachable("Not a known binary type trait");
1829 case tok::kw___is_base_of
: return BTT_IsBaseOf
;
1830 case tok::kw___builtin_types_compatible_p
: return BTT_TypeCompatible
;
1834 /// ParseUnaryTypeTrait - Parse the built-in unary type-trait
1835 /// pseudo-functions that allow implementation of the TR1/C++0x type traits
1838 /// primary-expression:
1839 /// [GNU] unary-type-trait '(' type-id ')'
1841 ExprResult
Parser::ParseUnaryTypeTrait() {
1842 UnaryTypeTrait UTT
= UnaryTypeTraitFromTokKind(Tok
.getKind());
1843 SourceLocation Loc
= ConsumeToken();
1845 SourceLocation LParen
= Tok
.getLocation();
1846 if (ExpectAndConsume(tok::l_paren
, diag::err_expected_lparen
))
1849 // FIXME: Error reporting absolutely sucks! If the this fails to parse a type
1850 // there will be cryptic errors about mismatched parentheses and missing
1852 TypeResult Ty
= ParseTypeName();
1854 SourceLocation RParen
= MatchRHSPunctuation(tok::r_paren
, LParen
);
1859 return Actions
.ActOnUnaryTypeTrait(UTT
, Loc
, Ty
.get(), RParen
);
1862 /// ParseBinaryTypeTrait - Parse the built-in binary type-trait
1863 /// pseudo-functions that allow implementation of the TR1/C++0x type traits
1866 /// primary-expression:
1867 /// [GNU] binary-type-trait '(' type-id ',' type-id ')'
1869 ExprResult
Parser::ParseBinaryTypeTrait() {
1870 BinaryTypeTrait BTT
= BinaryTypeTraitFromTokKind(Tok
.getKind());
1871 SourceLocation Loc
= ConsumeToken();
1873 SourceLocation LParen
= Tok
.getLocation();
1874 if (ExpectAndConsume(tok::l_paren
, diag::err_expected_lparen
))
1877 TypeResult LhsTy
= ParseTypeName();
1878 if (LhsTy
.isInvalid()) {
1879 SkipUntil(tok::r_paren
);
1883 if (ExpectAndConsume(tok::comma
, diag::err_expected_comma
)) {
1884 SkipUntil(tok::r_paren
);
1888 TypeResult RhsTy
= ParseTypeName();
1889 if (RhsTy
.isInvalid()) {
1890 SkipUntil(tok::r_paren
);
1894 SourceLocation RParen
= MatchRHSPunctuation(tok::r_paren
, LParen
);
1896 return Actions
.ActOnBinaryTypeTrait(BTT
, Loc
, LhsTy
.get(), RhsTy
.get(), RParen
);
1899 /// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
1900 /// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
1901 /// based on the context past the parens.
1903 Parser::ParseCXXAmbiguousParenExpression(ParenParseOption
&ExprType
,
1905 SourceLocation LParenLoc
,
1906 SourceLocation
&RParenLoc
) {
1907 assert(getLang().CPlusPlus
&& "Should only be called for C++!");
1908 assert(ExprType
== CastExpr
&& "Compound literals are not ambiguous!");
1909 assert(isTypeIdInParens() && "Not a type-id!");
1911 ExprResult
Result(true);
1912 CastTy
= ParsedType();
1914 // We need to disambiguate a very ugly part of the C++ syntax:
1916 // (T())x; - type-id
1917 // (T())*x; - type-id
1918 // (T())/x; - expression
1919 // (T()); - expression
1921 // The bad news is that we cannot use the specialized tentative parser, since
1922 // it can only verify that the thing inside the parens can be parsed as
1923 // type-id, it is not useful for determining the context past the parens.
1925 // The good news is that the parser can disambiguate this part without
1926 // making any unnecessary Action calls.
1928 // It uses a scheme similar to parsing inline methods. The parenthesized
1929 // tokens are cached, the context that follows is determined (possibly by
1930 // parsing a cast-expression), and then we re-introduce the cached tokens
1931 // into the token stream and parse them appropriately.
1933 ParenParseOption ParseAs
;
1936 // Store the tokens of the parentheses. We will parse them after we determine
1937 // the context that follows them.
1938 if (!ConsumeAndStoreUntil(tok::r_paren
, Toks
)) {
1939 // We didn't find the ')' we expected.
1940 MatchRHSPunctuation(tok::r_paren
, LParenLoc
);
1944 if (Tok
.is(tok::l_brace
)) {
1945 ParseAs
= CompoundLiteral
;
1948 // FIXME: Special-case ++ and --: "(S())++;" is not a cast-expression
1949 if (Tok
.is(tok::l_paren
) && NextToken().is(tok::r_paren
)) {
1952 // Try parsing the cast-expression that may follow.
1953 // If it is not a cast-expression, NotCastExpr will be true and no token
1954 // will be consumed.
1955 Result
= ParseCastExpression(false/*isUnaryExpression*/,
1956 false/*isAddressofOperand*/,
1958 ParsedType()/*TypeOfCast*/);
1961 // If we parsed a cast-expression, it's really a type-id, otherwise it's
1963 ParseAs
= NotCastExpr
? SimpleExpr
: CastExpr
;
1966 // The current token should go after the cached tokens.
1967 Toks
.push_back(Tok
);
1968 // Re-enter the stored parenthesized tokens into the token stream, so we may
1970 PP
.EnterTokenStream(Toks
.data(), Toks
.size(),
1971 true/*DisableMacroExpansion*/, false/*OwnsTokens*/);
1972 // Drop the current token and bring the first cached one. It's the same token
1973 // as when we entered this function.
1976 if (ParseAs
>= CompoundLiteral
) {
1977 TypeResult Ty
= ParseTypeName();
1980 if (Tok
.is(tok::r_paren
))
1981 RParenLoc
= ConsumeParen();
1983 MatchRHSPunctuation(tok::r_paren
, LParenLoc
);
1985 if (ParseAs
== CompoundLiteral
) {
1986 ExprType
= CompoundLiteral
;
1987 return ParseCompoundLiteralExpression(Ty
.get(), LParenLoc
, RParenLoc
);
1990 // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
1991 assert(ParseAs
== CastExpr
);
1998 // Result is what ParseCastExpression returned earlier.
1999 if (!Result
.isInvalid())
2000 Result
= Actions
.ActOnCastExpr(getCurScope(), LParenLoc
, CastTy
, RParenLoc
,
2002 return move(Result
);
2005 // Not a compound literal, and not followed by a cast-expression.
2006 assert(ParseAs
== SimpleExpr
);
2008 ExprType
= SimpleExpr
;
2009 Result
= ParseExpression();
2010 if (!Result
.isInvalid() && Tok
.is(tok::r_paren
))
2011 Result
= Actions
.ActOnParenExpr(LParenLoc
, Tok
.getLocation(), Result
.take());
2014 if (Result
.isInvalid()) {
2015 SkipUntil(tok::r_paren
);
2019 if (Tok
.is(tok::r_paren
))
2020 RParenLoc
= ConsumeParen();
2022 MatchRHSPunctuation(tok::r_paren
, LParenLoc
);
2024 return move(Result
);