#include "clang/Sema/Scope.h"

#include "clang/Sema/ParsedTemplate.h"

#include "clang/Sema/PrettyDeclStackTrace.h"

#include "RAIIObjectsForParser.h"

using namespace clang;

}

// If we're still good, complain about inline namespaces in non-C++0x now.

// Enter a scope for the namespace.

ParseScope NamespaceScope(this, Scope::DeclScope);

CXXScopeSpec SS;

// Parse (optional) nested-name-specifier.

if (SS.isInvalid() || Tok.isNot(tok::identifier)) {

Diag(Tok, diag::err_expected_namespace_name);

///

Decl *Parser::ParseLinkage(ParsingDeclSpec &DS, unsigned Context) {

assert(Tok.is(tok::string_literal) && "Not a string literal!");

bool Invalid = false;

StringRef Lang = PP.getSpelling(Tok, LangBuffer, &Invalid);

if (Invalid)

return 0;

SourceLocation Loc = ConsumeStringToken();

ParseScope LinkageScope(this, Scope::DeclScope);

CXXScopeSpec SS;

// Parse (optional) nested-name-specifier.

IdentifierInfo *NamespcName = 0;

SourceLocation IdentLoc = SourceLocation();

IsTypeName = false;

// Parse nested-name-specifier.

// Check nested-name specifier.

if (SS.isInvalid()) {

// Parse the unqualified-id. We allow parsing of both constructor and

// destructor names and allow the action module to diagnose any semantic

// errors.

UnqualifiedId Name;

if (ParseUnqualifiedId(SS,

/*EnteringContext=*/false,

/*AllowDestructorName=*/true,

/*AllowConstructorName=*/true,

ParsedType(),

Name)) {

SkipUntil(tok::semi);

return 0;

// Where can GNU attributes appear?

ConsumeToken();

// Type alias templates cannot be specialized.

int SpecKind = -1;

IsTypeName, TypenameLoc);

}

///

/// [C++0x] static_assert-declaration:

/// static_assert ( constant-expression , string-literal ) ;

///

/// _Static_assert ( constant-expression , string-literal ) ;

///

Decl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd){

assert((Tok.is(tok::kw_static_assert) || Tok.is(tok::kw__Static_assert)) &&

"Not a static_assert declaration");

SourceLocation StaticAssertLoc = ConsumeToken();

if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", tok::semi))

return 0;

Diag(Tok, diag::err_expected_string_literal);

SkipUntil(tok::semi);

return 0;

}

ExprResult AssertMessage(ParseStringLiteralExpression());

return 0;

T.consumeClose();

///

/// 'decltype' ( expression )

///

const char *PrevSpec = 0;

unsigned DiagID;

// Check for duplicate type specifiers (e.g. "int decltype(a)").

if (DS.SetTypeSpecType(DeclSpec::TST_decltype, StartLoc, PrevSpec,

Diag(StartLoc, DiagID) << PrevSpec;

}

void Parser::ParseUnderlyingTypeSpecifier(DeclSpec &DS) {

Diag(StartLoc, DiagID) << PrevSpec;

}

/// class-name: [C++ 9.1]

/// identifier

/// simple-template-id

///

// Check whether we have a template-id that names a type.

if (Tok.is(tok::annot_template_id)) {

TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);

TemplateName.setIdentifier(Id, IdLoc);

// Parse the full template-id, then turn it into a type.

return true;

if (TNK == TNK_Dependent_template_name)

AnnotateTemplateIdTokenAsType();

// We have an identifier; check whether it is actually a type.

ParsedType Type = Actions.getTypeName(*Id, IdLoc, getCurScope(), &SS, true,

false, ParsedType(),

/*NonTrivialTypeSourceInfo=*/true);

if (!Type) {

Diag(IdLoc, diag::err_expected_class_name);

/// ParseClassSpecifier - Parse a C++ class-specifier [C++ class] or

/// elaborated-type-specifier [C++ dcl.type.elab]; we can't tell which

/// until we reach the start of a definition or see a token that

///

/// class-specifier: [C++ class]

/// class-head '{' member-specification[opt] '}'

void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,

SourceLocation StartLoc, DeclSpec &DS,

const ParsedTemplateInfo &TemplateInfo,

DeclSpec::TST TagType;

if (TagTokKind == tok::kw_struct)

TagType = DeclSpec::TST_struct;

// As an extension we do not perform access checking on the names used to

// specify explicit specializations either. This is important to allow

// specializing traits classes for private types.

ParsedAttributes attrs(AttrFactory);

// If attributes exist after tag, parse them.

// Parse the (optional) nested-name-specifier.

CXXScopeSpec &SS = DS.getTypeSpecScope();

// "FOO : BAR" is not a potential typo for "FOO::BAR".

ColonProtectionRAIIObject X(*this);

DS.SetTypeSpecError();

if (SS.isSet())

if (Tok.isNot(tok::identifier) && Tok.isNot(tok::annot_template_id))

Name = Tok.getIdentifierInfo();

NameLoc = ConsumeToken();

// The name was supposed to refer to a template, but didn't.

// Eat the template argument list and try to continue parsing this as

// a class (or template thereof).

DS.SetTypeSpecError();

SkipUntil(tok::semi, false, true);

return;

}

}

// As soon as we're finished parsing the class's template-id, turn access

// checking back on.

// or

Sema::TagUseKind TUK;

TUK = Sema::TUK_Reference;

if (DS.isFriendSpecified()) {

// C++ [class.friend]p2:

// A class shall not be defined in a friend declaration.

<< SourceRange(DS.getFriendSpecLoc());

// Skip everything up to the semicolon, so that this looks like a proper

// Okay, this is a class definition.

TUK = Sema::TUK_Definition;

}

TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration;

else

TUK = Sema::TUK_Reference;

} else if (TUK == Sema::TUK_Reference ||

(TUK == Sema::TUK_Friend &&

TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate)) {

TemplateId->SS,

TemplateId->Template,

TemplateId->TemplateNameLoc,

TemplateId->LAngleLoc,

TemplateArgsPtr,

} else {

// This is an explicit specialization or a class template

// partial specialization.

TagOrTempResult = Actions.ActOnTag(getCurScope(), TagType, TUK, StartLoc,

SS, Name, NameLoc, attrs.getList(), AS,

DS.getModulePrivateSpecLoc(),

// If ActOnTag said the type was dependent, try again with the

// less common call.

// If there is a body, parse it and inform the actions module.

if (TUK == Sema::TUK_Definition) {

assert(Tok.is(tok::l_brace) ||

isCXX0XFinalKeyword());

ParseCXXMemberSpecification(StartLoc, TagType, TagOrTempResult.get());

else

ParseStructUnionBody(StartLoc, TagType, TagOrTempResult.get());

case tok::r_brace: // struct bar { struct foo {...} }

// Missing ';' at end of struct is accepted as an extension in C mode.

ExpectedSemi = false;

break;

}

/// base-specifier: [C++ class.derived]

/// ::[opt] nested-name-specifier[opt] class-name

/// 'virtual' access-specifier[opt] ::[opt] nested-name-specifier[opt]

/// access-specifier 'virtual'[opt] ::[opt] nested-name-specifier[opt]

Parser::BaseResult Parser::ParseBaseSpecifier(Decl *ClassDecl) {

bool IsVirtual = false;

SourceLocation StartLoc = Tok.getLocation();

IsVirtual = true;

}

// Parse the class-name.

SourceLocation EndLocation;

if (BaseType.isInvalid())

return true;

}

}

/// virt-specifier.

///

/// virt-specifier:

/// override

/// final

return VirtSpecifiers::VS_None;

if (Tok.is(tok::identifier)) {

<< PrevSpec

<< FixItHint::CreateRemoval(Tok.getLocation());

ConsumeToken();

}

}

/// isCXX0XFinalKeyword - Determine whether the next token is a C++0x

/// contextual 'final' keyword.

bool Parser::isCXX0XFinalKeyword() const {

return false;

if (!Tok.is(tok::identifier))

const ParsedTemplateInfo &TemplateInfo,

ParsingDeclRAIIObject *TemplateDiags) {

if (Tok.is(tok::at)) {

Diag(Tok, diag::err_at_defs_cxx);

else

Diag(Tok, diag::err_at_in_class);

if (isAccessDecl) {

// Collect the scope specifier token we annotated earlier.

CXXScopeSpec SS;

// Try to parse an unqualified-id.

UnqualifiedId Name;

SkipUntil(tok::semi);

return;

}

return;

}

// decl-specifier-seq:

// Parse the common declaration-specifiers piece.

ParsingDeclSpec DS(*this, TemplateDiags);

DS.takeAttributesFrom(attrs);

MultiTemplateParamsArg TemplateParams(Actions,

TemplateInfo.TemplateParams? TemplateInfo.TemplateParams->data() : 0,

// Hold late-parsed attributes so we can attach a Decl to them later.

LateParsedAttrList LateParsedAttrs;

if (Tok.isNot(tok::colon)) {

// Don't parse FOO:BAR as if it were a typo for FOO::BAR.

ColonProtectionRAIIObject X(*this);

// MSVC permits pure specifier on inline functions declared at class scope.

// Hence check for =0 before checking for function definition.

DeclaratorInfo.isFunctionDeclarator() &&

NextToken().is(tok::numeric_constant)) {

Init = ParseInitializer();

if (Init.isInvalid())

SkipUntil(tok::comma, true, true);

}

// function-definition:

//

// In C++11, a non-function declarator followed by an open brace is a

// braced-init-list for an in-class member initialization, not an

// erroneous function definition.

} else if (DeclaratorInfo.isFunctionDeclarator()) {

if (Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) {

} else if (Tok.is(tok::equal)) {

const Token &KW = NextToken();

}

}

if (!DeclaratorInfo.isFunctionDeclarator()) {

ConsumeBrace();

// Consume the optional ';'

if (Tok.is(tok::semi))

}

if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {

// This recovery skips the entire function body. It would be nice

// to simply call ParseCXXInlineMethodDef() below, however Sema

// assumes the declarator represents a function, not a typedef.

ConsumeBrace();

// Consume the optional ';'

if (Tok.is(tok::semi))

Decl *FunDecl =

ParseCXXInlineMethodDef(AS, AccessAttrs, DeclaratorInfo, TemplateInfo,

for (unsigned i = 0, ni = LateParsedAttrs.size(); i < ni; ++i) {

}

LateParsedAttrs.clear();

SmallVector<Decl *, 8> DeclsInGroup;

ExprResult BitfieldSize;

while (1) {

// member-declarator:

// goes before or after the GNU attributes and __asm__.

ParseOptionalCXX0XVirtSpecifierSeq(VS);

bool HasDeferredInitializer = false;

if (BitfieldSize.get()) {

Diag(Tok, diag::err_bitfield_member_init);

SkipUntil(tok::comma, true, true);

}

// Set the Decl for any late parsed attributes

for (unsigned i = 0, ni = LateParsedAttrs.size(); i < ni; ++i) {

}

LateParsedAttrs.clear();

// Handle the initializer.

if (HasDeferredInitializer) {

// The initializer was deferred; parse it and cache the tokens.

if (DeclaratorInfo.isArrayOfUnknownBound()) {

// C++0x [dcl.array]p3: An array bound may also be omitted when the

// declarator is followed by an initializer.

//

// A brace-or-equal-initializer for a member-declarator is not an

Diag(Tok, diag::err_incomplete_array_member_init);

SkipUntil(tok::comma, true, true);

} else

ParseCXXNonStaticMemberInitializer(ThisDecl);

} else if (HasInitializer) {

// Normal initializer.

if (Init.isInvalid())

SkipUntil(tok::comma, true, true);

else if (ThisDecl)

} else if (ThisDecl && DS.getStorageClassSpec() == DeclSpec::SCS_static) {

// No initializer.

Actions.ActOnUninitializedDecl(ThisDecl,

break;

// Consume the comma.

// Parse the next declarator.

DeclaratorInfo.clear();

VS.clear();

BitfieldSize = true;

// Attributes are only allowed on the second declarator.

MaybeParseGNUAttributes(DeclaratorInfo);

ParseDeclarator(DeclaratorInfo);

}

// Skip to end of block or statement.

SkipUntil(tok::r_brace, true, true);

// If we stopped at a ';', eat it.

///

/// pure-specifier:

/// '= 0'

/// brace-or-equal-initializer:

/// '=' initializer-expression

/// initializer-clause:

/// assignment-expression

/// defaulted/deleted function-definition:

/// '=' 'default'

/// '=' 'delete'

///

/// Prior to C++0x, the assignment-expression in an initializer-clause must

/// be a constant-expression.

SourceLocation &EqualLoc) {

assert((Tok.is(tok::equal) || Tok.is(tok::l_brace))

&& "Data member initializer not starting with '=' or '{'");

if (Tok.is(tok::equal)) {

EqualLoc = ConsumeToken();

if (Tok.is(tok::kw_delete)) {

return ExprResult();

}

}

/// ParseCXXMemberSpecification - Parse the class definition.

SourceLocation FinalLoc;

// Parse the optional 'final' keyword.

}

if (Tok.is(tok::colon)) {

while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {

// Each iteration of this loop reads one member-declaration.

Tok.is(tok::kw___if_not_exists))) {

ParseMicrosoftIfExistsClassDeclaration((DeclSpec::TST)TagType, CurAS);

continue;

continue;

}

AccessSpecifier AS = getAccessSpecifierIfPresent();

if (AS != AS_none) {

// Current token is a C++ access specifier.

SourceLocation EndLoc;

if (Tok.is(tok::colon)) {

EndLoc = Tok.getLocation();

ConsumeToken();

} else if (Tok.is(tok::semi)) {

EndLoc = Tok.getLocation();

Diag(EndLoc, diag::err_expected_colon)

<< FixItHint::CreateInsertion(EndLoc, ":");

}

continue;

}

Parser::MemInitResult Parser::ParseMemInitializer(Decl *ConstructorDecl) {

// parse '::'[opt] nested-name-specifier[opt]

CXXScopeSpec SS;

ParsedType TemplateTypeTy;

if (Tok.is(tok::annot_template_id)) {

TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);

TemplateTypeTy = getTypeAnnotation(Tok);

}

}

Diag(Tok, diag::err_expected_member_or_base_name);

return true;

}

// Parse the '('.

ExprResult InitList = ParseBraceInitializer();

if (InitList.isInvalid())

return true;

EllipsisLoc = ConsumeToken();

return Actions.ActOnMemInitializer(ConstructorDecl, getCurScope(), SS, II,

} else if(Tok.is(tok::l_paren)) {

BalancedDelimiterTracker T(*this, tok::l_paren);

T.consumeOpen();

EllipsisLoc = ConsumeToken();

return Actions.ActOnMemInitializer(ConstructorDecl, getCurScope(), SS, II,

T.getOpenLocation(), ArgExprs.take(),

ArgExprs.size(), T.getCloseLocation(),

EllipsisLoc);

}

: diag::err_expected_lparen);

return true;

}

if (Tok.isNot(tok::kw_noexcept))

return Result;

// If we already had a dynamic specification, parse the noexcept for,

// recovery, but emit a diagnostic and don't store the results.

SourceRange NoexceptRange;

// can throw anything".

if (Tok.is(tok::ellipsis)) {

SourceLocation EllipsisLoc = ConsumeToken();

Diag(EllipsisLoc, diag::ext_ellipsis_exception_spec);

T.consumeClose();

SpecificationRange.setEnd(T.getCloseLocation());

ConsumeToken();

}

/// \brief We have just started parsing the definition of a new class,

Victim->TemplateScope = getCurScope()->getParent()->isTemplateParamScope();

}

/// only parses standard attributes.

///

/// '[' '[' attribute-list ']' ']'

/// alignment-specifier

///

/// attribute[opt]

/// attribute-list ',' attribute[opt]

///

/// attribute-token attribute-argument-clause[opt]

///

/// identifier

/// attribute-scoped-token

///

/// attribute-namespace '::' identifier

///

/// identifier

///

/// '(' balanced-token-seq ')'

///

/// balanced-token

/// balanced-token-seq balanced-token

///

/// '(' balanced-token-seq ')'

/// '[' balanced-token-seq ']'

/// '{' balanced-token-seq '}'

/// any token but '(', ')', '[', ']', '{', or '}'

SourceLocation *endLoc) {

if (Tok.is(tok::kw_alignas)) {

Diag(Tok.getLocation(), diag::warn_cxx98_compat_alignas);

}

assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square)

Diag(Tok.getLocation(), diag::warn_cxx98_compat_attribute);

ConsumeBracket();

ConsumeBracket();

// attribute not present

if (Tok.is(tok::comma)) {

ConsumeToken();

continue;

}

// scoped attribute

if (Tok.is(tok::coloncolon)) {

ConsumeToken();

Diag(Tok.getLocation(), diag::err_expected_ident);

SkipUntil(tok::r_square, tok::comma, true, true);

continue;

}

}

bool AttrParsed = false;

// No scoped names are supported; ideally we could put all non-standard

// attributes into namespaces.

if (!ScopeName) {

// No arguments

case AttributeList::AT_carries_dependency:

case AttributeList::AT_noreturn: {

if (Tok.is(tok::l_paren)) {

<< AttrName->getName();

break;

}

// SkipUntil maintains the balancedness of tokens.

SkipUntil(tok::r_paren, false);

}

}

if (ExpectAndConsume(tok::r_square, diag::err_expected_rsquare))

SkipUntil(tok::r_square, false);

}

///

/// attribute-specifier-seq:

/// attribute-specifier-seq[opt] attribute-specifier

SourceLocation *endLoc) {

SourceLocation StartLoc = Tok.getLocation(), Loc;

if (!endLoc)

endLoc = &Loc;

do {

attrs.Range = SourceRange(StartLoc, *endLoc);

}

assert(Tok.is(tok::l_square) && "Not a Microsoft attribute list");

while (Tok.is(tok::l_square)) {

ConsumeBracket();

SkipUntil(tok::r_square, true, true);

if (endLoc) *endLoc = Tok.getLocation();

void Parser::ParseMicrosoftIfExistsClassDeclaration(DeclSpec::TST TagType,

AccessSpecifier& CurAS) {

if (ParseMicrosoftIfExistsCondition(Result))

return;

Diag(Tok, diag::err_expected_lbrace);

return;

}

return;

}

// __if_exists, __if_not_exists can nest.

if ((Tok.is(tok::kw___if_exists) || Tok.is(tok::kw___if_not_exists))) {

ParseMicrosoftIfExistsClassDeclaration((DeclSpec::TST)TagType, CurAS);

// Parse all the comma separated declarators.

ParseCXXClassMemberDeclaration(CurAS, 0);

}

}