blob: 3bddd3de13d06a49389aca61a76fa6ef3eb0b061 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- ParseDecl.cpp - Declaration Parsing ------------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Declaration portions of the Parser interfaces.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Parse/Parser.h"
Chris Lattner500d3292009-01-29 05:15:15 +000015#include "clang/Parse/ParseDiagnostic.h"
Peter Collingbourne207f4d82011-03-18 22:38:29 +000016#include "clang/Basic/OpenCL.h"
John McCall19510852010-08-20 18:27:03 +000017#include "clang/Sema/Scope.h"
18#include "clang/Sema/ParsedTemplate.h"
John McCallf312b1e2010-08-26 23:41:50 +000019#include "clang/Sema/PrettyDeclStackTrace.h"
Chris Lattnerd167ca02009-12-10 00:21:05 +000020#include "RAIIObjectsForParser.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000021#include "llvm/ADT/SmallSet.h"
Caitlin Sadowskib51e0312011-08-09 17:59:31 +000022#include "llvm/ADT/StringSwitch.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000023using namespace clang;
24
25//===----------------------------------------------------------------------===//
26// C99 6.7: Declarations.
27//===----------------------------------------------------------------------===//
28
29/// ParseTypeName
30/// type-name: [C99 6.7.6]
31/// specifier-qualifier-list abstract-declarator[opt]
Sebastian Redl4c5d3202008-11-21 19:14:01 +000032///
33/// Called type-id in C++.
Douglas Gregor683a81f2011-01-31 16:09:46 +000034TypeResult Parser::ParseTypeName(SourceRange *Range,
John McCallf85e1932011-06-15 23:02:42 +000035 Declarator::TheContext Context,
Richard Smithc89edf52011-07-01 19:46:12 +000036 AccessSpecifier AS,
37 Decl **OwnedType) {
Reid Spencer5f016e22007-07-11 17:01:13 +000038 // Parse the common declaration-specifiers piece.
John McCall0b7e6782011-03-24 11:26:52 +000039 DeclSpec DS(AttrFactory);
Richard Smithc89edf52011-07-01 19:46:12 +000040 ParseSpecifierQualifierList(DS, AS);
41 if (OwnedType)
42 *OwnedType = DS.isTypeSpecOwned() ? DS.getRepAsDecl() : 0;
Sebastian Redlef65f062009-05-29 18:02:33 +000043
Reid Spencer5f016e22007-07-11 17:01:13 +000044 // Parse the abstract-declarator, if present.
Douglas Gregor683a81f2011-01-31 16:09:46 +000045 Declarator DeclaratorInfo(DS, Context);
Reid Spencer5f016e22007-07-11 17:01:13 +000046 ParseDeclarator(DeclaratorInfo);
Sebastian Redlef65f062009-05-29 18:02:33 +000047 if (Range)
48 *Range = DeclaratorInfo.getSourceRange();
49
Chris Lattnereaaebc72009-04-25 08:06:05 +000050 if (DeclaratorInfo.isInvalidType())
Douglas Gregor809070a2009-02-18 17:45:20 +000051 return true;
52
Douglas Gregor23c94db2010-07-02 17:43:08 +000053 return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
Reid Spencer5f016e22007-07-11 17:01:13 +000054}
55
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +000056
57/// isAttributeLateParsed - Return true if the attribute has arguments that
58/// require late parsing.
59static bool isAttributeLateParsed(const IdentifierInfo &II) {
60 return llvm::StringSwitch<bool>(II.getName())
61#include "clang/Parse/AttrLateParsed.inc"
62 .Default(false);
63}
64
65
Sean Huntbbd37c62009-11-21 08:43:09 +000066/// ParseGNUAttributes - Parse a non-empty attributes list.
Reid Spencer5f016e22007-07-11 17:01:13 +000067///
68/// [GNU] attributes:
69/// attribute
70/// attributes attribute
71///
72/// [GNU] attribute:
73/// '__attribute__' '(' '(' attribute-list ')' ')'
74///
75/// [GNU] attribute-list:
76/// attrib
77/// attribute_list ',' attrib
78///
79/// [GNU] attrib:
80/// empty
81/// attrib-name
82/// attrib-name '(' identifier ')'
83/// attrib-name '(' identifier ',' nonempty-expr-list ')'
84/// attrib-name '(' argument-expression-list [C99 6.5.2] ')'
85///
86/// [GNU] attrib-name:
87/// identifier
88/// typespec
89/// typequal
90/// storageclass
Mike Stump1eb44332009-09-09 15:08:12 +000091///
Reid Spencer5f016e22007-07-11 17:01:13 +000092/// FIXME: The GCC grammar/code for this construct implies we need two
Mike Stump1eb44332009-09-09 15:08:12 +000093/// token lookahead. Comment from gcc: "If they start with an identifier
94/// which is followed by a comma or close parenthesis, then the arguments
Reid Spencer5f016e22007-07-11 17:01:13 +000095/// start with that identifier; otherwise they are an expression list."
96///
Richard Smithfe0a0fb2011-10-17 21:20:17 +000097/// GCC does not require the ',' between attribs in an attribute-list.
98///
Reid Spencer5f016e22007-07-11 17:01:13 +000099/// At the moment, I am not doing 2 token lookahead. I am also unaware of
100/// any attributes that don't work (based on my limited testing). Most
101/// attributes are very simple in practice. Until we find a bug, I don't see
102/// a pressing need to implement the 2 token lookahead.
103
John McCall7f040a92010-12-24 02:08:15 +0000104void Parser::ParseGNUAttributes(ParsedAttributes &attrs,
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000105 SourceLocation *endLoc,
106 LateParsedAttrList *LateAttrs) {
Sean Huntbbd37c62009-11-21 08:43:09 +0000107 assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!");
Mike Stump1eb44332009-09-09 15:08:12 +0000108
Chris Lattner04d66662007-10-09 17:33:22 +0000109 while (Tok.is(tok::kw___attribute)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000110 ConsumeToken();
111 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
112 "attribute")) {
113 SkipUntil(tok::r_paren, true); // skip until ) or ;
John McCall7f040a92010-12-24 02:08:15 +0000114 return;
Reid Spencer5f016e22007-07-11 17:01:13 +0000115 }
116 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
117 SkipUntil(tok::r_paren, true); // skip until ) or ;
John McCall7f040a92010-12-24 02:08:15 +0000118 return;
Reid Spencer5f016e22007-07-11 17:01:13 +0000119 }
120 // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") ))
Chris Lattner04d66662007-10-09 17:33:22 +0000121 while (Tok.is(tok::identifier) || isDeclarationSpecifier() ||
122 Tok.is(tok::comma)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000123 if (Tok.is(tok::comma)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000124 // allows for empty/non-empty attributes. ((__vector_size__(16),,,,))
125 ConsumeToken();
126 continue;
127 }
128 // we have an identifier or declaration specifier (const, int, etc.)
129 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
130 SourceLocation AttrNameLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +0000131
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000132 if (Tok.is(tok::l_paren)) {
133 // handle "parameterized" attributes
134 if (LateAttrs && !ClassStack.empty() &&
135 isAttributeLateParsed(*AttrName)) {
136 // Delayed parsing is only available for attributes that occur
137 // in certain locations within a class scope.
138 LateParsedAttribute *LA =
139 new LateParsedAttribute(this, *AttrName, AttrNameLoc);
140 LateAttrs->push_back(LA);
141 getCurrentClass().LateParsedDeclarations.push_back(LA);
Mike Stump1eb44332009-09-09 15:08:12 +0000142
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000143 // consume everything up to and including the matching right parens
144 ConsumeAndStoreUntil(tok::r_paren, LA->Toks, true, false);
Mike Stump1eb44332009-09-09 15:08:12 +0000145
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000146 Token Eof;
147 Eof.startToken();
148 Eof.setLocation(Tok.getLocation());
149 LA->Toks.push_back(Eof);
150 } else {
151 ParseGNUAttributeArgs(AttrName, AttrNameLoc, attrs, endLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +0000152 }
153 } else {
John McCall0b7e6782011-03-24 11:26:52 +0000154 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc,
155 0, SourceLocation(), 0, 0);
Reid Spencer5f016e22007-07-11 17:01:13 +0000156 }
157 }
158 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
Reid Spencer5f016e22007-07-11 17:01:13 +0000159 SkipUntil(tok::r_paren, false);
Sean Huntbbd37c62009-11-21 08:43:09 +0000160 SourceLocation Loc = Tok.getLocation();
Sebastian Redlab197ba2009-02-09 18:23:29 +0000161 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) {
162 SkipUntil(tok::r_paren, false);
163 }
John McCall7f040a92010-12-24 02:08:15 +0000164 if (endLoc)
165 *endLoc = Loc;
Reid Spencer5f016e22007-07-11 17:01:13 +0000166 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000167}
168
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000169
170/// Parse the arguments to a parameterized GNU attribute
171void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName,
172 SourceLocation AttrNameLoc,
173 ParsedAttributes &Attrs,
174 SourceLocation *EndLoc) {
175
176 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
177
178 // Availability attributes have their own grammar.
179 if (AttrName->isStr("availability")) {
180 ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc);
181 return;
182 }
183 // Thread safety attributes fit into the FIXME case above, so we
184 // just parse the arguments as a list of expressions
185 if (IsThreadSafetyAttribute(AttrName->getName())) {
186 ParseThreadSafetyAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc);
187 return;
188 }
189
190 ConsumeParen(); // ignore the left paren loc for now
191
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000192 IdentifierInfo *ParmName = 0;
193 SourceLocation ParmLoc;
194 bool BuiltinType = false;
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000195
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000196 switch (Tok.getKind()) {
197 case tok::kw_char:
198 case tok::kw_wchar_t:
199 case tok::kw_char16_t:
200 case tok::kw_char32_t:
201 case tok::kw_bool:
202 case tok::kw_short:
203 case tok::kw_int:
204 case tok::kw_long:
205 case tok::kw___int64:
206 case tok::kw_signed:
207 case tok::kw_unsigned:
208 case tok::kw_float:
209 case tok::kw_double:
210 case tok::kw_void:
211 case tok::kw_typeof:
212 // __attribute__(( vec_type_hint(char) ))
213 // FIXME: Don't just discard the builtin type token.
214 ConsumeToken();
215 BuiltinType = true;
216 break;
217
218 case tok::identifier:
219 ParmName = Tok.getIdentifierInfo();
220 ParmLoc = ConsumeToken();
221 break;
222
223 default:
224 break;
225 }
226
227 ExprVector ArgExprs(Actions);
228
229 if (!BuiltinType &&
230 (ParmLoc.isValid() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren))) {
231 // Eat the comma.
232 if (ParmLoc.isValid())
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000233 ConsumeToken();
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000234
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000235 // Parse the non-empty comma-separated list of expressions.
236 while (1) {
237 ExprResult ArgExpr(ParseAssignmentExpression());
238 if (ArgExpr.isInvalid()) {
239 SkipUntil(tok::r_paren);
240 return;
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000241 }
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000242 ArgExprs.push_back(ArgExpr.release());
243 if (Tok.isNot(tok::comma))
244 break;
245 ConsumeToken(); // Eat the comma, move to the next argument
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000246 }
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000247 }
Fariborz Jahanian7a81e412011-10-18 17:11:10 +0000248 else if (Tok.is(tok::less) && AttrName->isStr("iboutletcollection")) {
249 if (!ExpectAndConsume(tok::less, diag::err_expected_less_after, "<",
250 tok::greater)) {
Fariborz Jahanianb2243432011-10-18 23:13:50 +0000251 while (Tok.is(tok::identifier)) {
252 ConsumeToken();
253 if (Tok.is(tok::greater))
254 break;
255 if (Tok.is(tok::comma)) {
256 ConsumeToken();
257 continue;
258 }
259 }
260 if (Tok.isNot(tok::greater))
261 Diag(Tok, diag::err_iboutletcollection_with_protocol);
Fariborz Jahanian7a81e412011-10-18 17:11:10 +0000262 SkipUntil(tok::r_paren, false, true); // skip until ')'
263 }
264 }
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000265
266 SourceLocation RParen = Tok.getLocation();
267 if (!ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) {
268 AttributeList *attr =
Argyrios Kyrtzidisffcc3102011-09-13 16:05:53 +0000269 Attrs.addNew(AttrName, SourceRange(AttrNameLoc, RParen), 0, AttrNameLoc,
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000270 ParmName, ParmLoc, ArgExprs.take(), ArgExprs.size());
271 if (BuiltinType && attr->getKind() == AttributeList::AT_IBOutletCollection)
272 Diag(Tok, diag::err_iboutletcollection_builtintype);
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000273 }
274}
275
276
Eli Friedmana23b4852009-06-08 07:21:15 +0000277/// ParseMicrosoftDeclSpec - Parse an __declspec construct
278///
279/// [MS] decl-specifier:
280/// __declspec ( extended-decl-modifier-seq )
281///
282/// [MS] extended-decl-modifier-seq:
283/// extended-decl-modifier[opt]
284/// extended-decl-modifier extended-decl-modifier-seq
285
John McCall7f040a92010-12-24 02:08:15 +0000286void Parser::ParseMicrosoftDeclSpec(ParsedAttributes &attrs) {
Steve Narofff59e17e2008-12-24 20:59:21 +0000287 assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
Eli Friedmana23b4852009-06-08 07:21:15 +0000288
Steve Narofff59e17e2008-12-24 20:59:21 +0000289 ConsumeToken();
Eli Friedmana23b4852009-06-08 07:21:15 +0000290 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
291 "declspec")) {
292 SkipUntil(tok::r_paren, true); // skip until ) or ;
John McCall7f040a92010-12-24 02:08:15 +0000293 return;
Eli Friedmana23b4852009-06-08 07:21:15 +0000294 }
Francois Pichet373197b2011-05-07 19:04:49 +0000295
Eli Friedman290eeb02009-06-08 23:27:34 +0000296 while (Tok.getIdentifierInfo()) {
Eli Friedmana23b4852009-06-08 07:21:15 +0000297 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
298 SourceLocation AttrNameLoc = ConsumeToken();
Francois Pichet373197b2011-05-07 19:04:49 +0000299
300 // FIXME: Remove this when we have proper __declspec(property()) support.
301 // Just skip everything inside property().
302 if (AttrName->getName() == "property") {
303 ConsumeParen();
304 SkipUntil(tok::r_paren);
305 }
Eli Friedmana23b4852009-06-08 07:21:15 +0000306 if (Tok.is(tok::l_paren)) {
307 ConsumeParen();
308 // FIXME: This doesn't parse __declspec(property(get=get_func_name))
309 // correctly.
John McCall60d7b3a2010-08-24 06:29:42 +0000310 ExprResult ArgExpr(ParseAssignmentExpression());
Eli Friedmana23b4852009-06-08 07:21:15 +0000311 if (!ArgExpr.isInvalid()) {
John McCallca0408f2010-08-23 06:44:23 +0000312 Expr *ExprList = ArgExpr.take();
John McCall0b7e6782011-03-24 11:26:52 +0000313 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
314 SourceLocation(), &ExprList, 1, true);
Eli Friedmana23b4852009-06-08 07:21:15 +0000315 }
316 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
317 SkipUntil(tok::r_paren, false);
318 } else {
John McCall0b7e6782011-03-24 11:26:52 +0000319 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc,
320 0, SourceLocation(), 0, 0, true);
Eli Friedmana23b4852009-06-08 07:21:15 +0000321 }
322 }
323 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
324 SkipUntil(tok::r_paren, false);
John McCall7f040a92010-12-24 02:08:15 +0000325 return;
Eli Friedman290eeb02009-06-08 23:27:34 +0000326}
327
John McCall7f040a92010-12-24 02:08:15 +0000328void Parser::ParseMicrosoftTypeAttributes(ParsedAttributes &attrs) {
Eli Friedman290eeb02009-06-08 23:27:34 +0000329 // Treat these like attributes
330 // FIXME: Allow Sema to distinguish between these and real attributes!
331 while (Tok.is(tok::kw___fastcall) || Tok.is(tok::kw___stdcall) ||
Douglas Gregorf813a2c2010-05-18 16:57:00 +0000332 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___cdecl) ||
Francois Pichet3bd9aa42011-08-18 09:59:55 +0000333 Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64) ||
Francois Pichet58fd97a2011-08-25 00:36:46 +0000334 Tok.is(tok::kw___ptr32) ||
Francois Pichet3bd9aa42011-08-18 09:59:55 +0000335 Tok.is(tok::kw___unaligned)) {
Eli Friedman290eeb02009-06-08 23:27:34 +0000336 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
337 SourceLocation AttrNameLoc = ConsumeToken();
Francois Pichet58fd97a2011-08-25 00:36:46 +0000338 if (Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64) ||
339 Tok.is(tok::kw___ptr32))
Eli Friedman290eeb02009-06-08 23:27:34 +0000340 // FIXME: Support these properly!
341 continue;
John McCall0b7e6782011-03-24 11:26:52 +0000342 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
343 SourceLocation(), 0, 0, true);
Eli Friedman290eeb02009-06-08 23:27:34 +0000344 }
Steve Narofff59e17e2008-12-24 20:59:21 +0000345}
346
John McCall7f040a92010-12-24 02:08:15 +0000347void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) {
Dawn Perchik52fc3142010-09-03 01:29:35 +0000348 // Treat these like attributes
349 while (Tok.is(tok::kw___pascal)) {
350 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
351 SourceLocation AttrNameLoc = ConsumeToken();
John McCall0b7e6782011-03-24 11:26:52 +0000352 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
353 SourceLocation(), 0, 0, true);
Dawn Perchik52fc3142010-09-03 01:29:35 +0000354 }
John McCall7f040a92010-12-24 02:08:15 +0000355}
356
Peter Collingbournef315fa82011-02-14 01:42:53 +0000357void Parser::ParseOpenCLAttributes(ParsedAttributes &attrs) {
358 // Treat these like attributes
359 while (Tok.is(tok::kw___kernel)) {
360 SourceLocation AttrNameLoc = ConsumeToken();
John McCall0b7e6782011-03-24 11:26:52 +0000361 attrs.addNew(PP.getIdentifierInfo("opencl_kernel_function"),
362 AttrNameLoc, 0, AttrNameLoc, 0,
363 SourceLocation(), 0, 0, false);
Peter Collingbournef315fa82011-02-14 01:42:53 +0000364 }
365}
366
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000367void Parser::ParseOpenCLQualifiers(DeclSpec &DS) {
368 SourceLocation Loc = Tok.getLocation();
369 switch(Tok.getKind()) {
370 // OpenCL qualifiers:
371 case tok::kw___private:
372 case tok::kw_private:
John McCall0b7e6782011-03-24 11:26:52 +0000373 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000374 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000375 PP.getIdentifierInfo("address_space"), Loc, 0);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000376 break;
377
378 case tok::kw___global:
John McCall0b7e6782011-03-24 11:26:52 +0000379 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000380 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000381 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_global);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000382 break;
383
384 case tok::kw___local:
John McCall0b7e6782011-03-24 11:26:52 +0000385 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000386 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000387 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_local);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000388 break;
389
390 case tok::kw___constant:
John McCall0b7e6782011-03-24 11:26:52 +0000391 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000392 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000393 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_constant);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000394 break;
395
396 case tok::kw___read_only:
John McCall0b7e6782011-03-24 11:26:52 +0000397 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000398 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000399 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_only);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000400 break;
401
402 case tok::kw___write_only:
John McCall0b7e6782011-03-24 11:26:52 +0000403 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000404 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000405 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_write_only);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000406 break;
407
408 case tok::kw___read_write:
John McCall0b7e6782011-03-24 11:26:52 +0000409 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000410 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000411 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_write);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000412 break;
413 default: break;
414 }
415}
416
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000417/// \brief Parse a version number.
418///
419/// version:
420/// simple-integer
421/// simple-integer ',' simple-integer
422/// simple-integer ',' simple-integer ',' simple-integer
423VersionTuple Parser::ParseVersionTuple(SourceRange &Range) {
424 Range = Tok.getLocation();
425
426 if (!Tok.is(tok::numeric_constant)) {
427 Diag(Tok, diag::err_expected_version);
428 SkipUntil(tok::comma, tok::r_paren, true, true, true);
429 return VersionTuple();
430 }
431
432 // Parse the major (and possibly minor and subminor) versions, which
433 // are stored in the numeric constant. We utilize a quirk of the
434 // lexer, which is that it handles something like 1.2.3 as a single
435 // numeric constant, rather than two separate tokens.
436 llvm::SmallString<512> Buffer;
437 Buffer.resize(Tok.getLength()+1);
438 const char *ThisTokBegin = &Buffer[0];
439
440 // Get the spelling of the token, which eliminates trigraphs, etc.
441 bool Invalid = false;
442 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid);
443 if (Invalid)
444 return VersionTuple();
445
446 // Parse the major version.
447 unsigned AfterMajor = 0;
448 unsigned Major = 0;
449 while (AfterMajor < ActualLength && isdigit(ThisTokBegin[AfterMajor])) {
450 Major = Major * 10 + ThisTokBegin[AfterMajor] - '0';
451 ++AfterMajor;
452 }
453
454 if (AfterMajor == 0) {
455 Diag(Tok, diag::err_expected_version);
456 SkipUntil(tok::comma, tok::r_paren, true, true, true);
457 return VersionTuple();
458 }
459
460 if (AfterMajor == ActualLength) {
461 ConsumeToken();
462
463 // We only had a single version component.
464 if (Major == 0) {
465 Diag(Tok, diag::err_zero_version);
466 return VersionTuple();
467 }
468
469 return VersionTuple(Major);
470 }
471
472 if (ThisTokBegin[AfterMajor] != '.' || (AfterMajor + 1 == ActualLength)) {
473 Diag(Tok, diag::err_expected_version);
474 SkipUntil(tok::comma, tok::r_paren, true, true, true);
475 return VersionTuple();
476 }
477
478 // Parse the minor version.
479 unsigned AfterMinor = AfterMajor + 1;
480 unsigned Minor = 0;
481 while (AfterMinor < ActualLength && isdigit(ThisTokBegin[AfterMinor])) {
482 Minor = Minor * 10 + ThisTokBegin[AfterMinor] - '0';
483 ++AfterMinor;
484 }
485
486 if (AfterMinor == ActualLength) {
487 ConsumeToken();
488
489 // We had major.minor.
490 if (Major == 0 && Minor == 0) {
491 Diag(Tok, diag::err_zero_version);
492 return VersionTuple();
493 }
494
495 return VersionTuple(Major, Minor);
496 }
497
498 // If what follows is not a '.', we have a problem.
499 if (ThisTokBegin[AfterMinor] != '.') {
500 Diag(Tok, diag::err_expected_version);
501 SkipUntil(tok::comma, tok::r_paren, true, true, true);
502 return VersionTuple();
503 }
504
505 // Parse the subminor version.
506 unsigned AfterSubminor = AfterMinor + 1;
507 unsigned Subminor = 0;
508 while (AfterSubminor < ActualLength && isdigit(ThisTokBegin[AfterSubminor])) {
509 Subminor = Subminor * 10 + ThisTokBegin[AfterSubminor] - '0';
510 ++AfterSubminor;
511 }
512
513 if (AfterSubminor != ActualLength) {
514 Diag(Tok, diag::err_expected_version);
515 SkipUntil(tok::comma, tok::r_paren, true, true, true);
516 return VersionTuple();
517 }
518 ConsumeToken();
519 return VersionTuple(Major, Minor, Subminor);
520}
521
522/// \brief Parse the contents of the "availability" attribute.
523///
524/// availability-attribute:
525/// 'availability' '(' platform ',' version-arg-list ')'
526///
527/// platform:
528/// identifier
529///
530/// version-arg-list:
531/// version-arg
532/// version-arg ',' version-arg-list
533///
534/// version-arg:
535/// 'introduced' '=' version
536/// 'deprecated' '=' version
537/// 'removed' = version
Douglas Gregorb53e4172011-03-26 03:35:55 +0000538/// 'unavailable'
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000539void Parser::ParseAvailabilityAttribute(IdentifierInfo &Availability,
540 SourceLocation AvailabilityLoc,
541 ParsedAttributes &attrs,
542 SourceLocation *endLoc) {
543 SourceLocation PlatformLoc;
544 IdentifierInfo *Platform = 0;
545
546 enum { Introduced, Deprecated, Obsoleted, Unknown };
547 AvailabilityChange Changes[Unknown];
548
549 // Opening '('.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000550 BalancedDelimiterTracker T(*this, tok::l_paren);
551 if (T.consumeOpen()) {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000552 Diag(Tok, diag::err_expected_lparen);
553 return;
554 }
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000555
556 // Parse the platform name,
557 if (Tok.isNot(tok::identifier)) {
558 Diag(Tok, diag::err_availability_expected_platform);
559 SkipUntil(tok::r_paren);
560 return;
561 }
562 Platform = Tok.getIdentifierInfo();
563 PlatformLoc = ConsumeToken();
564
565 // Parse the ',' following the platform name.
566 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", tok::r_paren))
567 return;
568
569 // If we haven't grabbed the pointers for the identifiers
570 // "introduced", "deprecated", and "obsoleted", do so now.
571 if (!Ident_introduced) {
572 Ident_introduced = PP.getIdentifierInfo("introduced");
573 Ident_deprecated = PP.getIdentifierInfo("deprecated");
574 Ident_obsoleted = PP.getIdentifierInfo("obsoleted");
Douglas Gregorb53e4172011-03-26 03:35:55 +0000575 Ident_unavailable = PP.getIdentifierInfo("unavailable");
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000576 }
577
578 // Parse the set of introductions/deprecations/removals.
Douglas Gregorb53e4172011-03-26 03:35:55 +0000579 SourceLocation UnavailableLoc;
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000580 do {
581 if (Tok.isNot(tok::identifier)) {
582 Diag(Tok, diag::err_availability_expected_change);
583 SkipUntil(tok::r_paren);
584 return;
585 }
586 IdentifierInfo *Keyword = Tok.getIdentifierInfo();
587 SourceLocation KeywordLoc = ConsumeToken();
588
Douglas Gregorb53e4172011-03-26 03:35:55 +0000589 if (Keyword == Ident_unavailable) {
590 if (UnavailableLoc.isValid()) {
591 Diag(KeywordLoc, diag::err_availability_redundant)
592 << Keyword << SourceRange(UnavailableLoc);
593 }
594 UnavailableLoc = KeywordLoc;
595
596 if (Tok.isNot(tok::comma))
597 break;
598
599 ConsumeToken();
600 continue;
601 }
602
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000603 if (Tok.isNot(tok::equal)) {
604 Diag(Tok, diag::err_expected_equal_after)
605 << Keyword;
606 SkipUntil(tok::r_paren);
607 return;
608 }
609 ConsumeToken();
610
611 SourceRange VersionRange;
612 VersionTuple Version = ParseVersionTuple(VersionRange);
613
614 if (Version.empty()) {
615 SkipUntil(tok::r_paren);
616 return;
617 }
618
619 unsigned Index;
620 if (Keyword == Ident_introduced)
621 Index = Introduced;
622 else if (Keyword == Ident_deprecated)
623 Index = Deprecated;
624 else if (Keyword == Ident_obsoleted)
625 Index = Obsoleted;
626 else
627 Index = Unknown;
628
629 if (Index < Unknown) {
630 if (!Changes[Index].KeywordLoc.isInvalid()) {
631 Diag(KeywordLoc, diag::err_availability_redundant)
632 << Keyword
633 << SourceRange(Changes[Index].KeywordLoc,
634 Changes[Index].VersionRange.getEnd());
635 }
636
637 Changes[Index].KeywordLoc = KeywordLoc;
638 Changes[Index].Version = Version;
639 Changes[Index].VersionRange = VersionRange;
640 } else {
641 Diag(KeywordLoc, diag::err_availability_unknown_change)
642 << Keyword << VersionRange;
643 }
644
645 if (Tok.isNot(tok::comma))
646 break;
647
648 ConsumeToken();
649 } while (true);
650
651 // Closing ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000652 if (T.consumeClose())
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000653 return;
654
655 if (endLoc)
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000656 *endLoc = T.getCloseLocation();
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000657
Douglas Gregorb53e4172011-03-26 03:35:55 +0000658 // The 'unavailable' availability cannot be combined with any other
659 // availability changes. Make sure that hasn't happened.
660 if (UnavailableLoc.isValid()) {
661 bool Complained = false;
662 for (unsigned Index = Introduced; Index != Unknown; ++Index) {
663 if (Changes[Index].KeywordLoc.isValid()) {
664 if (!Complained) {
665 Diag(UnavailableLoc, diag::warn_availability_and_unavailable)
666 << SourceRange(Changes[Index].KeywordLoc,
667 Changes[Index].VersionRange.getEnd());
668 Complained = true;
669 }
670
671 // Clear out the availability.
672 Changes[Index] = AvailabilityChange();
673 }
674 }
675 }
676
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000677 // Record this attribute
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000678 attrs.addNew(&Availability,
679 SourceRange(AvailabilityLoc, T.getCloseLocation()),
John McCall0b7e6782011-03-24 11:26:52 +0000680 0, SourceLocation(),
681 Platform, PlatformLoc,
682 Changes[Introduced],
683 Changes[Deprecated],
Douglas Gregorb53e4172011-03-26 03:35:55 +0000684 Changes[Obsoleted],
685 UnavailableLoc, false, false);
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000686}
687
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000688
689// Late Parsed Attributes:
690// See other examples of late parsing in lib/Parse/ParseCXXInlineMethods
691
692void Parser::LateParsedDeclaration::ParseLexedAttributes() {}
693
694void Parser::LateParsedClass::ParseLexedAttributes() {
695 Self->ParseLexedAttributes(*Class);
696}
697
698void Parser::LateParsedAttribute::ParseLexedAttributes() {
699 Self->ParseLexedAttribute(*this);
700}
701
702/// Wrapper class which calls ParseLexedAttribute, after setting up the
703/// scope appropriately.
704void Parser::ParseLexedAttributes(ParsingClass &Class) {
705 // Deal with templates
706 // FIXME: Test cases to make sure this does the right thing for templates.
707 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
708 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
709 HasTemplateScope);
710 if (HasTemplateScope)
711 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
712
713 // Set or update the scope flags to include Scope::ThisScope.
714 bool AlreadyHasClassScope = Class.TopLevelClass;
715 unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope|Scope::ThisScope;
716 ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope);
717 ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope);
718
719 for (unsigned i = 0, ni = Class.LateParsedDeclarations.size(); i < ni; ++i) {
720 Class.LateParsedDeclarations[i]->ParseLexedAttributes();
721 }
722}
723
724/// \brief Finish parsing an attribute for which parsing was delayed.
725/// This will be called at the end of parsing a class declaration
726/// for each LateParsedAttribute. We consume the saved tokens and
727/// create an attribute with the arguments filled in. We add this
728/// to the Attribute list for the decl.
729void Parser::ParseLexedAttribute(LateParsedAttribute &LA) {
730 // Save the current token position.
731 SourceLocation OrigLoc = Tok.getLocation();
732
733 // Append the current token at the end of the new token stream so that it
734 // doesn't get lost.
735 LA.Toks.push_back(Tok);
736 PP.EnterTokenStream(LA.Toks.data(), LA.Toks.size(), true, false);
737 // Consume the previously pushed token.
738 ConsumeAnyToken();
739
740 ParsedAttributes Attrs(AttrFactory);
741 SourceLocation endLoc;
742
Caitlin Sadowskied9d84a2011-09-08 17:42:31 +0000743 // If the Decl is templatized, add template parameters to scope.
744 bool HasTemplateScope = LA.D && LA.D->isTemplateDecl();
745 ParseScope TempScope(this, Scope::TemplateParamScope, HasTemplateScope);
746 if (HasTemplateScope)
747 Actions.ActOnReenterTemplateScope(Actions.CurScope, LA.D);
748
749 // If the Decl is on a function, add function parameters to the scope.
750 bool HasFunctionScope = LA.D && LA.D->isFunctionOrFunctionTemplate();
751 ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope, HasFunctionScope);
752 if (HasFunctionScope)
753 Actions.ActOnReenterFunctionContext(Actions.CurScope, LA.D);
754
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000755 ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc);
756
Caitlin Sadowskied9d84a2011-09-08 17:42:31 +0000757 if (HasFunctionScope) {
758 Actions.ActOnExitFunctionContext();
759 FnScope.Exit(); // Pop scope, and remove Decls from IdResolver
760 }
761 if (HasTemplateScope) {
762 TempScope.Exit();
763 }
764
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000765 // Late parsed attributes must be attached to Decls by hand. If the
766 // LA.D is not set, then this was not done properly.
767 assert(LA.D && "No decl attached to late parsed attribute");
768 Actions.ActOnFinishDelayedAttribute(getCurScope(), LA.D, Attrs);
769
770 if (Tok.getLocation() != OrigLoc) {
771 // Due to a parsing error, we either went over the cached tokens or
772 // there are still cached tokens left, so we skip the leftover tokens.
773 // Since this is an uncommon situation that should be avoided, use the
774 // expensive isBeforeInTranslationUnit call.
775 if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(),
776 OrigLoc))
777 while (Tok.getLocation() != OrigLoc && Tok.isNot(tok::eof))
778 ConsumeAnyToken();
779 }
780}
781
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000782/// \brief Wrapper around a case statement checking if AttrName is
783/// one of the thread safety attributes
784bool Parser::IsThreadSafetyAttribute(llvm::StringRef AttrName){
785 return llvm::StringSwitch<bool>(AttrName)
786 .Case("guarded_by", true)
787 .Case("guarded_var", true)
788 .Case("pt_guarded_by", true)
789 .Case("pt_guarded_var", true)
790 .Case("lockable", true)
791 .Case("scoped_lockable", true)
792 .Case("no_thread_safety_analysis", true)
793 .Case("acquired_after", true)
794 .Case("acquired_before", true)
795 .Case("exclusive_lock_function", true)
796 .Case("shared_lock_function", true)
797 .Case("exclusive_trylock_function", true)
798 .Case("shared_trylock_function", true)
799 .Case("unlock_function", true)
800 .Case("lock_returned", true)
801 .Case("locks_excluded", true)
802 .Case("exclusive_locks_required", true)
803 .Case("shared_locks_required", true)
804 .Default(false);
805}
806
807/// \brief Parse the contents of thread safety attributes. These
808/// should always be parsed as an expression list.
809///
810/// We need to special case the parsing due to the fact that if the first token
811/// of the first argument is an identifier, the main parse loop will store
812/// that token as a "parameter" and the rest of
813/// the arguments will be added to a list of "arguments". However,
814/// subsequent tokens in the first argument are lost. We instead parse each
815/// argument as an expression and add all arguments to the list of "arguments".
816/// In future, we will take advantage of this special case to also
817/// deal with some argument scoping issues here (for example, referring to a
818/// function parameter in the attribute on that function).
819void Parser::ParseThreadSafetyAttribute(IdentifierInfo &AttrName,
820 SourceLocation AttrNameLoc,
821 ParsedAttributes &Attrs,
822 SourceLocation *EndLoc) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000823 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000824
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000825 BalancedDelimiterTracker T(*this, tok::l_paren);
826 T.consumeOpen();
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000827
828 ExprVector ArgExprs(Actions);
829 bool ArgExprsOk = true;
830
831 // now parse the list of expressions
832 while (1) {
833 ExprResult ArgExpr(ParseAssignmentExpression());
834 if (ArgExpr.isInvalid()) {
835 ArgExprsOk = false;
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000836 T.consumeClose();
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000837 break;
838 } else {
839 ArgExprs.push_back(ArgExpr.release());
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000840 }
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000841 if (Tok.isNot(tok::comma))
842 break;
843 ConsumeToken(); // Eat the comma, move to the next argument
844 }
845 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000846 if (ArgExprsOk && !T.consumeClose()) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000847 Attrs.addNew(&AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(),
848 ArgExprs.take(), ArgExprs.size());
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000849 }
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000850 if (EndLoc)
851 *EndLoc = T.getCloseLocation();
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000852}
853
John McCall7f040a92010-12-24 02:08:15 +0000854void Parser::DiagnoseProhibitedAttributes(ParsedAttributesWithRange &attrs) {
855 Diag(attrs.Range.getBegin(), diag::err_attributes_not_allowed)
856 << attrs.Range;
Dawn Perchik52fc3142010-09-03 01:29:35 +0000857}
858
Reid Spencer5f016e22007-07-11 17:01:13 +0000859/// ParseDeclaration - Parse a full 'declaration', which consists of
860/// declaration-specifiers, some number of declarators, and a semicolon.
Chris Lattner97144fc2009-04-02 04:16:50 +0000861/// 'Context' should be a Declarator::TheContext value. This returns the
862/// location of the semicolon in DeclEnd.
Chris Lattner8f08cb72007-08-25 06:57:03 +0000863///
864/// declaration: [C99 6.7]
865/// block-declaration ->
866/// simple-declaration
867/// others [FIXME]
Douglas Gregoradcac882008-12-01 23:54:00 +0000868/// [C++] template-declaration
Chris Lattner8f08cb72007-08-25 06:57:03 +0000869/// [C++] namespace-definition
Douglas Gregorf780abc2008-12-30 03:27:21 +0000870/// [C++] using-directive
Douglas Gregord7f37bf2009-06-22 23:06:13 +0000871/// [C++] using-declaration
Peter Collingbournec6eb44b2011-04-15 00:35:57 +0000872/// [C++0x/C1X] static_assert-declaration
Chris Lattner8f08cb72007-08-25 06:57:03 +0000873/// others... [FIXME]
874///
Fariborz Jahanianc5be7b02010-09-28 20:42:35 +0000875Parser::DeclGroupPtrTy Parser::ParseDeclaration(StmtVector &Stmts,
876 unsigned Context,
Sean Huntbbd37c62009-11-21 08:43:09 +0000877 SourceLocation &DeclEnd,
John McCall7f040a92010-12-24 02:08:15 +0000878 ParsedAttributesWithRange &attrs) {
Argyrios Kyrtzidis36d36802010-06-17 10:52:18 +0000879 ParenBraceBracketBalancer BalancerRAIIObj(*this);
Fariborz Jahaniane8cff362011-08-30 17:10:52 +0000880 // Must temporarily exit the objective-c container scope for
881 // parsing c none objective-c decls.
882 ObjCDeclContextSwitch ObjCDC(*this);
Argyrios Kyrtzidis36d36802010-06-17 10:52:18 +0000883
John McCalld226f652010-08-21 09:40:31 +0000884 Decl *SingleDecl = 0;
Richard Smithc89edf52011-07-01 19:46:12 +0000885 Decl *OwnedType = 0;
Chris Lattner8f08cb72007-08-25 06:57:03 +0000886 switch (Tok.getKind()) {
Douglas Gregoradcac882008-12-01 23:54:00 +0000887 case tok::kw_template:
Douglas Gregor1426e532009-05-12 21:31:51 +0000888 case tok::kw_export:
John McCall7f040a92010-12-24 02:08:15 +0000889 ProhibitAttributes(attrs);
Douglas Gregor4d9a16f2009-05-12 23:25:50 +0000890 SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +0000891 break;
Sebastian Redld078e642010-08-27 23:12:46 +0000892 case tok::kw_inline:
Sebastian Redl88e64ca2010-08-31 00:36:45 +0000893 // Could be the start of an inline namespace. Allowed as an ext in C++03.
894 if (getLang().CPlusPlus && NextToken().is(tok::kw_namespace)) {
John McCall7f040a92010-12-24 02:08:15 +0000895 ProhibitAttributes(attrs);
Sebastian Redld078e642010-08-27 23:12:46 +0000896 SourceLocation InlineLoc = ConsumeToken();
897 SingleDecl = ParseNamespace(Context, DeclEnd, InlineLoc);
898 break;
899 }
John McCall7f040a92010-12-24 02:08:15 +0000900 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs,
Fariborz Jahanianc5be7b02010-09-28 20:42:35 +0000901 true);
Chris Lattner8f08cb72007-08-25 06:57:03 +0000902 case tok::kw_namespace:
John McCall7f040a92010-12-24 02:08:15 +0000903 ProhibitAttributes(attrs);
Chris Lattner97144fc2009-04-02 04:16:50 +0000904 SingleDecl = ParseNamespace(Context, DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +0000905 break;
Douglas Gregorf780abc2008-12-30 03:27:21 +0000906 case tok::kw_using:
John McCall78b81052010-11-10 02:40:36 +0000907 SingleDecl = ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(),
Richard Smithc89edf52011-07-01 19:46:12 +0000908 DeclEnd, attrs, &OwnedType);
Chris Lattner682bf922009-03-29 16:50:03 +0000909 break;
Anders Carlsson511d7ab2009-03-11 16:27:10 +0000910 case tok::kw_static_assert:
Peter Collingbournec6eb44b2011-04-15 00:35:57 +0000911 case tok::kw__Static_assert:
John McCall7f040a92010-12-24 02:08:15 +0000912 ProhibitAttributes(attrs);
Chris Lattner97144fc2009-04-02 04:16:50 +0000913 SingleDecl = ParseStaticAssertDeclaration(DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +0000914 break;
Chris Lattner8f08cb72007-08-25 06:57:03 +0000915 default:
John McCall7f040a92010-12-24 02:08:15 +0000916 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs, true);
Chris Lattner8f08cb72007-08-25 06:57:03 +0000917 }
Sean Huntbbd37c62009-11-21 08:43:09 +0000918
Chris Lattner682bf922009-03-29 16:50:03 +0000919 // This routine returns a DeclGroup, if the thing we parsed only contains a
Richard Smithc89edf52011-07-01 19:46:12 +0000920 // single decl, convert it now. Alias declarations can also declare a type;
921 // include that too if it is present.
922 return Actions.ConvertDeclToDeclGroup(SingleDecl, OwnedType);
Chris Lattner8f08cb72007-08-25 06:57:03 +0000923}
924
925/// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
926/// declaration-specifiers init-declarator-list[opt] ';'
927///[C90/C++]init-declarator-list ';' [TODO]
928/// [OMP] threadprivate-directive [TODO]
Chris Lattnercd147752009-03-29 17:27:48 +0000929///
Richard Smithad762fc2011-04-14 22:09:26 +0000930/// for-range-declaration: [C++0x 6.5p1: stmt.ranged]
931/// attribute-specifier-seq[opt] type-specifier-seq declarator
932///
Chris Lattnercd147752009-03-29 17:27:48 +0000933/// If RequireSemi is false, this does not check for a ';' at the end of the
Chris Lattner5c5db552010-04-05 18:18:31 +0000934/// declaration. If it is true, it checks for and eats it.
Richard Smithad762fc2011-04-14 22:09:26 +0000935///
936/// If FRI is non-null, we might be parsing a for-range-declaration instead
937/// of a simple-declaration. If we find that we are, we also parse the
938/// for-range-initializer, and place it here.
Fariborz Jahanianc5be7b02010-09-28 20:42:35 +0000939Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration(StmtVector &Stmts,
940 unsigned Context,
Sean Huntbbd37c62009-11-21 08:43:09 +0000941 SourceLocation &DeclEnd,
John McCall7f040a92010-12-24 02:08:15 +0000942 ParsedAttributes &attrs,
Richard Smithad762fc2011-04-14 22:09:26 +0000943 bool RequireSemi,
944 ForRangeInit *FRI) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000945 // Parse the common declaration-specifiers piece.
John McCall54abf7d2009-11-04 02:18:39 +0000946 ParsingDeclSpec DS(*this);
John McCall7f040a92010-12-24 02:08:15 +0000947 DS.takeAttributesFrom(attrs);
Douglas Gregor312eadb2011-04-24 05:37:28 +0000948
Douglas Gregor0efc2c12010-01-13 17:31:36 +0000949 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none,
Richard Smith34b41d92011-02-20 03:19:35 +0000950 getDeclSpecContextFromDeclaratorContext(Context));
Fariborz Jahanianc5be7b02010-09-28 20:42:35 +0000951 StmtResult R = Actions.ActOnVlaStmt(DS);
952 if (R.isUsable())
953 Stmts.push_back(R.release());
Douglas Gregor312eadb2011-04-24 05:37:28 +0000954
Reid Spencer5f016e22007-07-11 17:01:13 +0000955 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
956 // declaration-specifiers init-declarator-list[opt] ';'
Chris Lattner04d66662007-10-09 17:33:22 +0000957 if (Tok.is(tok::semi)) {
Chris Lattner5c5db552010-04-05 18:18:31 +0000958 if (RequireSemi) ConsumeToken();
John McCalld226f652010-08-21 09:40:31 +0000959 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
Douglas Gregor312eadb2011-04-24 05:37:28 +0000960 DS);
John McCall54abf7d2009-11-04 02:18:39 +0000961 DS.complete(TheDecl);
Chris Lattner682bf922009-03-29 16:50:03 +0000962 return Actions.ConvertDeclToDeclGroup(TheDecl);
Reid Spencer5f016e22007-07-11 17:01:13 +0000963 }
Douglas Gregor312eadb2011-04-24 05:37:28 +0000964
965 return ParseDeclGroup(DS, Context, /*FunctionDefs=*/ false, &DeclEnd, FRI);
John McCalld8ac0572009-11-03 19:26:08 +0000966}
Mike Stump1eb44332009-09-09 15:08:12 +0000967
Richard Smith0706df42011-10-19 21:33:05 +0000968/// Returns true if this might be the start of a declarator, or a common typo
969/// for a declarator.
970bool Parser::MightBeDeclarator(unsigned Context) {
971 switch (Tok.getKind()) {
972 case tok::annot_cxxscope:
973 case tok::annot_template_id:
974 case tok::caret:
975 case tok::code_completion:
976 case tok::coloncolon:
977 case tok::ellipsis:
978 case tok::kw___attribute:
979 case tok::kw_operator:
980 case tok::l_paren:
981 case tok::star:
982 return true;
983
984 case tok::amp:
985 case tok::ampamp:
986 case tok::colon: // Might be a typo for '::'.
987 return getLang().CPlusPlus;
988
989 case tok::identifier:
990 switch (NextToken().getKind()) {
991 case tok::code_completion:
992 case tok::coloncolon:
993 case tok::comma:
994 case tok::equal:
995 case tok::equalequal: // Might be a typo for '='.
996 case tok::kw_alignas:
997 case tok::kw_asm:
998 case tok::kw___attribute:
999 case tok::l_brace:
1000 case tok::l_paren:
1001 case tok::l_square:
1002 case tok::less:
1003 case tok::r_brace:
1004 case tok::r_paren:
1005 case tok::r_square:
1006 case tok::semi:
1007 return true;
1008
1009 case tok::colon:
1010 // At namespace scope, 'identifier:' is probably a typo for 'identifier::'
1011 // and in block scope it's probably a label.
1012 return getLang().CPlusPlus && Context == Declarator::FileContext;
1013
1014 default:
1015 return false;
1016 }
1017
1018 default:
1019 return false;
1020 }
1021}
1022
John McCalld8ac0572009-11-03 19:26:08 +00001023/// ParseDeclGroup - Having concluded that this is either a function
1024/// definition or a group of object declarations, actually parse the
1025/// result.
John McCall54abf7d2009-11-04 02:18:39 +00001026Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS,
1027 unsigned Context,
John McCalld8ac0572009-11-03 19:26:08 +00001028 bool AllowFunctionDefinitions,
Richard Smithad762fc2011-04-14 22:09:26 +00001029 SourceLocation *DeclEnd,
1030 ForRangeInit *FRI) {
John McCalld8ac0572009-11-03 19:26:08 +00001031 // Parse the first declarator.
John McCall54abf7d2009-11-04 02:18:39 +00001032 ParsingDeclarator D(*this, DS, static_cast<Declarator::TheContext>(Context));
John McCalld8ac0572009-11-03 19:26:08 +00001033 ParseDeclarator(D);
Chris Lattnercd147752009-03-29 17:27:48 +00001034
John McCalld8ac0572009-11-03 19:26:08 +00001035 // Bail out if the first declarator didn't seem well-formed.
1036 if (!D.hasName() && !D.mayOmitIdentifier()) {
1037 // Skip until ; or }.
1038 SkipUntil(tok::r_brace, true, true);
1039 if (Tok.is(tok::semi))
1040 ConsumeToken();
1041 return DeclGroupPtrTy();
Chris Lattner23c4b182009-03-29 17:18:04 +00001042 }
Mike Stump1eb44332009-09-09 15:08:12 +00001043
Chris Lattnerc82daef2010-07-11 22:24:20 +00001044 // Check to see if we have a function *definition* which must have a body.
1045 if (AllowFunctionDefinitions && D.isFunctionDeclarator() &&
1046 // Look at the next token to make sure that this isn't a function
1047 // declaration. We have to check this because __attribute__ might be the
1048 // start of a function definition in GCC-extended K&R C.
1049 !isDeclarationAfterDeclarator()) {
1050
Chris Lattner004659a2010-07-11 22:42:07 +00001051 if (isStartOfFunctionDefinition(D)) {
John McCalld8ac0572009-11-03 19:26:08 +00001052 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
1053 Diag(Tok, diag::err_function_declared_typedef);
1054
1055 // Recover by treating the 'typedef' as spurious.
1056 DS.ClearStorageClassSpecs();
1057 }
1058
John McCalld226f652010-08-21 09:40:31 +00001059 Decl *TheDecl = ParseFunctionDefinition(D);
John McCalld8ac0572009-11-03 19:26:08 +00001060 return Actions.ConvertDeclToDeclGroup(TheDecl);
Chris Lattner004659a2010-07-11 22:42:07 +00001061 }
1062
1063 if (isDeclarationSpecifier()) {
1064 // If there is an invalid declaration specifier right after the function
1065 // prototype, then we must be in a missing semicolon case where this isn't
1066 // actually a body. Just fall through into the code that handles it as a
1067 // prototype, and let the top-level code handle the erroneous declspec
1068 // where it would otherwise expect a comma or semicolon.
John McCalld8ac0572009-11-03 19:26:08 +00001069 } else {
1070 Diag(Tok, diag::err_expected_fn_body);
1071 SkipUntil(tok::semi);
1072 return DeclGroupPtrTy();
1073 }
1074 }
1075
Richard Smithad762fc2011-04-14 22:09:26 +00001076 if (ParseAttributesAfterDeclarator(D))
1077 return DeclGroupPtrTy();
1078
1079 // C++0x [stmt.iter]p1: Check if we have a for-range-declarator. If so, we
1080 // must parse and analyze the for-range-initializer before the declaration is
1081 // analyzed.
1082 if (FRI && Tok.is(tok::colon)) {
1083 FRI->ColonLoc = ConsumeToken();
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001084 if (Tok.is(tok::l_brace))
1085 FRI->RangeExpr = ParseBraceInitializer();
1086 else
1087 FRI->RangeExpr = ParseExpression();
Richard Smithad762fc2011-04-14 22:09:26 +00001088 Decl *ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
1089 Actions.ActOnCXXForRangeDecl(ThisDecl);
1090 Actions.FinalizeDeclaration(ThisDecl);
1091 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, &ThisDecl, 1);
1092 }
1093
Chris Lattner5f9e2722011-07-23 10:55:15 +00001094 SmallVector<Decl *, 8> DeclsInGroup;
Richard Smithad762fc2011-04-14 22:09:26 +00001095 Decl *FirstDecl = ParseDeclarationAfterDeclaratorAndAttributes(D);
John McCall54abf7d2009-11-04 02:18:39 +00001096 D.complete(FirstDecl);
John McCalld226f652010-08-21 09:40:31 +00001097 if (FirstDecl)
John McCalld8ac0572009-11-03 19:26:08 +00001098 DeclsInGroup.push_back(FirstDecl);
1099
Richard Smith0706df42011-10-19 21:33:05 +00001100 bool ExpectSemi = Context != Declarator::ForContext;
1101
John McCalld8ac0572009-11-03 19:26:08 +00001102 // If we don't have a comma, it is either the end of the list (a ';') or an
1103 // error, bail out.
1104 while (Tok.is(tok::comma)) {
Richard Smith0706df42011-10-19 21:33:05 +00001105 SourceLocation CommaLoc = ConsumeToken();
1106
1107 if (Tok.isAtStartOfLine() && ExpectSemi && !MightBeDeclarator(Context)) {
1108 // This comma was followed by a line-break and something which can't be
1109 // the start of a declarator. The comma was probably a typo for a
1110 // semicolon.
1111 Diag(CommaLoc, diag::err_expected_semi_declaration)
1112 << FixItHint::CreateReplacement(CommaLoc, ";");
1113 ExpectSemi = false;
1114 break;
1115 }
John McCalld8ac0572009-11-03 19:26:08 +00001116
1117 // Parse the next declarator.
1118 D.clear();
1119
1120 // Accept attributes in an init-declarator. In the first declarator in a
1121 // declaration, these would be part of the declspec. In subsequent
1122 // declarators, they become part of the declarator itself, so that they
1123 // don't apply to declarators after *this* one. Examples:
1124 // short __attribute__((common)) var; -> declspec
1125 // short var __attribute__((common)); -> declarator
1126 // short x, __attribute__((common)) var; -> declarator
John McCall7f040a92010-12-24 02:08:15 +00001127 MaybeParseGNUAttributes(D);
John McCalld8ac0572009-11-03 19:26:08 +00001128
1129 ParseDeclarator(D);
1130
John McCalld226f652010-08-21 09:40:31 +00001131 Decl *ThisDecl = ParseDeclarationAfterDeclarator(D);
John McCall54abf7d2009-11-04 02:18:39 +00001132 D.complete(ThisDecl);
John McCalld226f652010-08-21 09:40:31 +00001133 if (ThisDecl)
John McCalld8ac0572009-11-03 19:26:08 +00001134 DeclsInGroup.push_back(ThisDecl);
1135 }
1136
1137 if (DeclEnd)
1138 *DeclEnd = Tok.getLocation();
1139
Richard Smith0706df42011-10-19 21:33:05 +00001140 if (ExpectSemi &&
John McCalld8ac0572009-11-03 19:26:08 +00001141 ExpectAndConsume(tok::semi,
1142 Context == Declarator::FileContext
1143 ? diag::err_invalid_token_after_toplevel_declarator
1144 : diag::err_expected_semi_declaration)) {
Chris Lattner004659a2010-07-11 22:42:07 +00001145 // Okay, there was no semicolon and one was expected. If we see a
1146 // declaration specifier, just assume it was missing and continue parsing.
1147 // Otherwise things are very confused and we skip to recover.
1148 if (!isDeclarationSpecifier()) {
1149 SkipUntil(tok::r_brace, true, true);
1150 if (Tok.is(tok::semi))
1151 ConsumeToken();
1152 }
John McCalld8ac0572009-11-03 19:26:08 +00001153 }
1154
Douglas Gregor23c94db2010-07-02 17:43:08 +00001155 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS,
John McCalld8ac0572009-11-03 19:26:08 +00001156 DeclsInGroup.data(),
1157 DeclsInGroup.size());
Reid Spencer5f016e22007-07-11 17:01:13 +00001158}
1159
Richard Smithad762fc2011-04-14 22:09:26 +00001160/// Parse an optional simple-asm-expr and attributes, and attach them to a
1161/// declarator. Returns true on an error.
1162bool Parser::ParseAttributesAfterDeclarator(Declarator &D) {
1163 // If a simple-asm-expr is present, parse it.
1164 if (Tok.is(tok::kw_asm)) {
1165 SourceLocation Loc;
1166 ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1167 if (AsmLabel.isInvalid()) {
1168 SkipUntil(tok::semi, true, true);
1169 return true;
1170 }
1171
1172 D.setAsmLabel(AsmLabel.release());
1173 D.SetRangeEnd(Loc);
1174 }
1175
1176 MaybeParseGNUAttributes(D);
1177 return false;
1178}
1179
Douglas Gregor1426e532009-05-12 21:31:51 +00001180/// \brief Parse 'declaration' after parsing 'declaration-specifiers
1181/// declarator'. This method parses the remainder of the declaration
1182/// (including any attributes or initializer, among other things) and
1183/// finalizes the declaration.
Reid Spencer5f016e22007-07-11 17:01:13 +00001184///
Reid Spencer5f016e22007-07-11 17:01:13 +00001185/// init-declarator: [C99 6.7]
1186/// declarator
1187/// declarator '=' initializer
1188/// [GNU] declarator simple-asm-expr[opt] attributes[opt]
1189/// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001190/// [C++] declarator initializer[opt]
1191///
1192/// [C++] initializer:
1193/// [C++] '=' initializer-clause
1194/// [C++] '(' expression-list ')'
Sebastian Redl50de12f2009-03-24 22:27:57 +00001195/// [C++0x] '=' 'default' [TODO]
1196/// [C++0x] '=' 'delete'
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001197/// [C++0x] braced-init-list
Sebastian Redl50de12f2009-03-24 22:27:57 +00001198///
1199/// According to the standard grammar, =default and =delete are function
1200/// definitions, but that definitely doesn't fit with the parser here.
Reid Spencer5f016e22007-07-11 17:01:13 +00001201///
John McCalld226f652010-08-21 09:40:31 +00001202Decl *Parser::ParseDeclarationAfterDeclarator(Declarator &D,
Douglas Gregore542c862009-06-23 23:11:28 +00001203 const ParsedTemplateInfo &TemplateInfo) {
Richard Smithad762fc2011-04-14 22:09:26 +00001204 if (ParseAttributesAfterDeclarator(D))
1205 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001206
Richard Smithad762fc2011-04-14 22:09:26 +00001207 return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo);
1208}
Mike Stump1eb44332009-09-09 15:08:12 +00001209
Richard Smithad762fc2011-04-14 22:09:26 +00001210Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(Declarator &D,
1211 const ParsedTemplateInfo &TemplateInfo) {
Douglas Gregor1426e532009-05-12 21:31:51 +00001212 // Inform the current actions module that we just parsed this declarator.
John McCalld226f652010-08-21 09:40:31 +00001213 Decl *ThisDecl = 0;
Douglas Gregord5a423b2009-09-25 18:43:00 +00001214 switch (TemplateInfo.Kind) {
1215 case ParsedTemplateInfo::NonTemplate:
Douglas Gregor23c94db2010-07-02 17:43:08 +00001216 ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
Douglas Gregord5a423b2009-09-25 18:43:00 +00001217 break;
1218
1219 case ParsedTemplateInfo::Template:
1220 case ParsedTemplateInfo::ExplicitSpecialization:
Douglas Gregor23c94db2010-07-02 17:43:08 +00001221 ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
John McCallf312b1e2010-08-26 23:41:50 +00001222 MultiTemplateParamsArg(Actions,
Douglas Gregore542c862009-06-23 23:11:28 +00001223 TemplateInfo.TemplateParams->data(),
1224 TemplateInfo.TemplateParams->size()),
Douglas Gregord5a423b2009-09-25 18:43:00 +00001225 D);
1226 break;
1227
1228 case ParsedTemplateInfo::ExplicitInstantiation: {
John McCalld226f652010-08-21 09:40:31 +00001229 DeclResult ThisRes
Douglas Gregor23c94db2010-07-02 17:43:08 +00001230 = Actions.ActOnExplicitInstantiation(getCurScope(),
Douglas Gregord5a423b2009-09-25 18:43:00 +00001231 TemplateInfo.ExternLoc,
1232 TemplateInfo.TemplateLoc,
1233 D);
1234 if (ThisRes.isInvalid()) {
1235 SkipUntil(tok::semi, true, true);
John McCalld226f652010-08-21 09:40:31 +00001236 return 0;
Douglas Gregord5a423b2009-09-25 18:43:00 +00001237 }
1238
1239 ThisDecl = ThisRes.get();
1240 break;
1241 }
1242 }
Mike Stump1eb44332009-09-09 15:08:12 +00001243
Richard Smith34b41d92011-02-20 03:19:35 +00001244 bool TypeContainsAuto =
1245 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto;
1246
Douglas Gregor1426e532009-05-12 21:31:51 +00001247 // Parse declarator '=' initializer.
Argyrios Kyrtzidisa6eb5f82010-10-08 02:39:23 +00001248 if (isTokenEqualOrMistypedEqualEqual(
1249 diag::err_invalid_equalequal_after_declarator)) {
Douglas Gregor1426e532009-05-12 21:31:51 +00001250 ConsumeToken();
Anders Carlsson37bf9d22010-09-24 21:25:25 +00001251 if (Tok.is(tok::kw_delete)) {
Sean Hunte4246a62011-05-12 06:15:49 +00001252 if (D.isFunctionDeclarator())
1253 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
1254 << 1 /* delete */;
1255 else
1256 Diag(ConsumeToken(), diag::err_deleted_non_function);
Sean Huntfe2695e2011-05-06 01:42:00 +00001257 } else if (Tok.is(tok::kw_default)) {
Sean Hunte4246a62011-05-12 06:15:49 +00001258 if (D.isFunctionDeclarator())
1259 Diag(Tok, diag::err_default_delete_in_multiple_declaration)
1260 << 1 /* delete */;
1261 else
1262 Diag(ConsumeToken(), diag::err_default_special_members);
Douglas Gregor1426e532009-05-12 21:31:51 +00001263 } else {
John McCall731ad842009-12-19 09:28:58 +00001264 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
1265 EnterScope(0);
Douglas Gregor23c94db2010-07-02 17:43:08 +00001266 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
John McCall731ad842009-12-19 09:28:58 +00001267 }
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00001268
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00001269 if (Tok.is(tok::code_completion)) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001270 Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00001271 cutOffParsing();
1272 return 0;
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00001273 }
1274
John McCall60d7b3a2010-08-24 06:29:42 +00001275 ExprResult Init(ParseInitializer());
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00001276
John McCall731ad842009-12-19 09:28:58 +00001277 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001278 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
John McCall731ad842009-12-19 09:28:58 +00001279 ExitScope();
1280 }
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00001281
Douglas Gregor1426e532009-05-12 21:31:51 +00001282 if (Init.isInvalid()) {
Douglas Gregor00225542010-03-01 18:27:54 +00001283 SkipUntil(tok::comma, true, true);
1284 Actions.ActOnInitializerError(ThisDecl);
1285 } else
Richard Smith34b41d92011-02-20 03:19:35 +00001286 Actions.AddInitializerToDecl(ThisDecl, Init.take(),
1287 /*DirectInit=*/false, TypeContainsAuto);
Douglas Gregor1426e532009-05-12 21:31:51 +00001288 }
1289 } else if (Tok.is(tok::l_paren)) {
1290 // Parse C++ direct initializer: '(' expression-list ')'
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001291 BalancedDelimiterTracker T(*this, tok::l_paren);
1292 T.consumeOpen();
1293
Douglas Gregor1426e532009-05-12 21:31:51 +00001294 ExprVector Exprs(Actions);
1295 CommaLocsTy CommaLocs;
1296
Douglas Gregorb4debae2009-12-22 17:47:17 +00001297 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
1298 EnterScope(0);
Douglas Gregor23c94db2010-07-02 17:43:08 +00001299 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001300 }
1301
Douglas Gregor1426e532009-05-12 21:31:51 +00001302 if (ParseExpressionList(Exprs, CommaLocs)) {
1303 SkipUntil(tok::r_paren);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001304
1305 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001306 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001307 ExitScope();
1308 }
Douglas Gregor1426e532009-05-12 21:31:51 +00001309 } else {
1310 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001311 T.consumeClose();
Douglas Gregor1426e532009-05-12 21:31:51 +00001312
1313 assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() &&
1314 "Unexpected number of commas!");
Douglas Gregorb4debae2009-12-22 17:47:17 +00001315
1316 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001317 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001318 ExitScope();
1319 }
1320
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001321 Actions.AddCXXDirectInitializerToDecl(ThisDecl, T.getOpenLocation(),
Douglas Gregor1426e532009-05-12 21:31:51 +00001322 move_arg(Exprs),
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001323 T.getCloseLocation(),
Richard Smith34b41d92011-02-20 03:19:35 +00001324 TypeContainsAuto);
Douglas Gregor1426e532009-05-12 21:31:51 +00001325 }
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001326 } else if (getLang().CPlusPlus0x && Tok.is(tok::l_brace)) {
1327 // Parse C++0x braced-init-list.
Richard Smith7fe62082011-10-15 05:09:34 +00001328 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
1329
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001330 if (D.getCXXScopeSpec().isSet()) {
1331 EnterScope(0);
1332 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
1333 }
1334
1335 ExprResult Init(ParseBraceInitializer());
1336
1337 if (D.getCXXScopeSpec().isSet()) {
1338 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
1339 ExitScope();
1340 }
1341
1342 if (Init.isInvalid()) {
1343 Actions.ActOnInitializerError(ThisDecl);
1344 } else
1345 Actions.AddInitializerToDecl(ThisDecl, Init.take(),
1346 /*DirectInit=*/true, TypeContainsAuto);
1347
Douglas Gregor1426e532009-05-12 21:31:51 +00001348 } else {
Richard Smith34b41d92011-02-20 03:19:35 +00001349 Actions.ActOnUninitializedDecl(ThisDecl, TypeContainsAuto);
Douglas Gregor1426e532009-05-12 21:31:51 +00001350 }
1351
Richard Smith483b9f32011-02-21 20:05:19 +00001352 Actions.FinalizeDeclaration(ThisDecl);
1353
Douglas Gregor1426e532009-05-12 21:31:51 +00001354 return ThisDecl;
1355}
1356
Reid Spencer5f016e22007-07-11 17:01:13 +00001357/// ParseSpecifierQualifierList
1358/// specifier-qualifier-list:
1359/// type-specifier specifier-qualifier-list[opt]
1360/// type-qualifier specifier-qualifier-list[opt]
1361/// [GNU] attributes specifier-qualifier-list[opt]
1362///
Richard Smithc89edf52011-07-01 19:46:12 +00001363void Parser::ParseSpecifierQualifierList(DeclSpec &DS, AccessSpecifier AS) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001364 /// specifier-qualifier-list is a subset of declaration-specifiers. Just
1365 /// parse declaration-specifiers and complain about extra stuff.
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001366 /// TODO: diagnose attribute-specifiers and alignment-specifiers.
Richard Smithc89edf52011-07-01 19:46:12 +00001367 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS);
Mike Stump1eb44332009-09-09 15:08:12 +00001368
Reid Spencer5f016e22007-07-11 17:01:13 +00001369 // Validate declspec for type-name.
1370 unsigned Specs = DS.getParsedSpecifiers();
Chris Lattnerb6645dd2009-04-14 21:16:09 +00001371 if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers() &&
John McCall7f040a92010-12-24 02:08:15 +00001372 !DS.hasAttributes())
Reid Spencer5f016e22007-07-11 17:01:13 +00001373 Diag(Tok, diag::err_typename_requires_specqual);
Mike Stump1eb44332009-09-09 15:08:12 +00001374
Reid Spencer5f016e22007-07-11 17:01:13 +00001375 // Issue diagnostic and remove storage class if present.
1376 if (Specs & DeclSpec::PQ_StorageClassSpecifier) {
1377 if (DS.getStorageClassSpecLoc().isValid())
1378 Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass);
1379 else
1380 Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass);
1381 DS.ClearStorageClassSpecs();
1382 }
Mike Stump1eb44332009-09-09 15:08:12 +00001383
Reid Spencer5f016e22007-07-11 17:01:13 +00001384 // Issue diagnostic and remove function specfier if present.
1385 if (Specs & DeclSpec::PQ_FunctionSpecifier) {
Douglas Gregorb48fe382008-10-31 09:07:45 +00001386 if (DS.isInlineSpecified())
1387 Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
1388 if (DS.isVirtualSpecified())
1389 Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
1390 if (DS.isExplicitSpecified())
1391 Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
Reid Spencer5f016e22007-07-11 17:01:13 +00001392 DS.ClearFunctionSpecs();
1393 }
1394}
1395
Chris Lattnerc199ab32009-04-12 20:42:31 +00001396/// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
1397/// specified token is valid after the identifier in a declarator which
1398/// immediately follows the declspec. For example, these things are valid:
1399///
1400/// int x [ 4]; // direct-declarator
1401/// int x ( int y); // direct-declarator
1402/// int(int x ) // direct-declarator
1403/// int x ; // simple-declaration
1404/// int x = 17; // init-declarator-list
1405/// int x , y; // init-declarator-list
1406/// int x __asm__ ("foo"); // init-declarator-list
Chris Lattnerb6645dd2009-04-14 21:16:09 +00001407/// int x : 4; // struct-declarator
Chris Lattnerc83c27a2009-04-12 22:29:43 +00001408/// int x { 5}; // C++'0x unified initializers
Chris Lattnerc199ab32009-04-12 20:42:31 +00001409///
1410/// This is not, because 'x' does not immediately follow the declspec (though
1411/// ')' happens to be valid anyway).
1412/// int (x)
1413///
1414static bool isValidAfterIdentifierInDeclarator(const Token &T) {
1415 return T.is(tok::l_square) || T.is(tok::l_paren) || T.is(tok::r_paren) ||
1416 T.is(tok::semi) || T.is(tok::comma) || T.is(tok::equal) ||
Chris Lattnerb6645dd2009-04-14 21:16:09 +00001417 T.is(tok::kw_asm) || T.is(tok::l_brace) || T.is(tok::colon);
Chris Lattnerc199ab32009-04-12 20:42:31 +00001418}
1419
Chris Lattnere40c2952009-04-14 21:34:55 +00001420
1421/// ParseImplicitInt - This method is called when we have an non-typename
1422/// identifier in a declspec (which normally terminates the decl spec) when
1423/// the declspec has no type specifier. In this case, the declspec is either
1424/// malformed or is "implicit int" (in K&R and C89).
1425///
1426/// This method handles diagnosing this prettily and returns false if the
1427/// declspec is done being processed. If it recovers and thinks there may be
1428/// other pieces of declspec after it, it returns true.
1429///
Chris Lattnerf4382f52009-04-14 22:17:06 +00001430bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001431 const ParsedTemplateInfo &TemplateInfo,
Chris Lattnere40c2952009-04-14 21:34:55 +00001432 AccessSpecifier AS) {
Chris Lattnerf4382f52009-04-14 22:17:06 +00001433 assert(Tok.is(tok::identifier) && "should have identifier");
Mike Stump1eb44332009-09-09 15:08:12 +00001434
Chris Lattnere40c2952009-04-14 21:34:55 +00001435 SourceLocation Loc = Tok.getLocation();
1436 // If we see an identifier that is not a type name, we normally would
1437 // parse it as the identifer being declared. However, when a typename
1438 // is typo'd or the definition is not included, this will incorrectly
1439 // parse the typename as the identifier name and fall over misparsing
1440 // later parts of the diagnostic.
1441 //
1442 // As such, we try to do some look-ahead in cases where this would
1443 // otherwise be an "implicit-int" case to see if this is invalid. For
1444 // example: "static foo_t x = 4;" In this case, if we parsed foo_t as
1445 // an identifier with implicit int, we'd get a parse error because the
1446 // next token is obviously invalid for a type. Parse these as a case
1447 // with an invalid type specifier.
1448 assert(!DS.hasTypeSpecifier() && "Type specifier checked above");
Mike Stump1eb44332009-09-09 15:08:12 +00001449
Chris Lattnere40c2952009-04-14 21:34:55 +00001450 // Since we know that this either implicit int (which is rare) or an
1451 // error, we'd do lookahead to try to do better recovery.
1452 if (isValidAfterIdentifierInDeclarator(NextToken())) {
1453 // If this token is valid for implicit int, e.g. "static x = 4", then
1454 // we just avoid eating the identifier, so it will be parsed as the
1455 // identifier in the declarator.
1456 return false;
1457 }
Mike Stump1eb44332009-09-09 15:08:12 +00001458
Chris Lattnere40c2952009-04-14 21:34:55 +00001459 // Otherwise, if we don't consume this token, we are going to emit an
1460 // error anyway. Try to recover from various common problems. Check
1461 // to see if this was a reference to a tag name without a tag specified.
1462 // This is a common problem in C (saying 'foo' instead of 'struct foo').
Chris Lattnerf4382f52009-04-14 22:17:06 +00001463 //
1464 // C++ doesn't need this, and isTagName doesn't take SS.
1465 if (SS == 0) {
Argyrios Kyrtzidisb8a9d3b2011-04-21 17:29:47 +00001466 const char *TagName = 0, *FixitTagName = 0;
Chris Lattnerf4382f52009-04-14 22:17:06 +00001467 tok::TokenKind TagKind = tok::unknown;
Mike Stump1eb44332009-09-09 15:08:12 +00001468
Douglas Gregor23c94db2010-07-02 17:43:08 +00001469 switch (Actions.isTagName(*Tok.getIdentifierInfo(), getCurScope())) {
Chris Lattnere40c2952009-04-14 21:34:55 +00001470 default: break;
Argyrios Kyrtzidisb8a9d3b2011-04-21 17:29:47 +00001471 case DeclSpec::TST_enum:
1472 TagName="enum" ; FixitTagName = "enum " ; TagKind=tok::kw_enum ;break;
1473 case DeclSpec::TST_union:
1474 TagName="union" ; FixitTagName = "union " ;TagKind=tok::kw_union ;break;
1475 case DeclSpec::TST_struct:
1476 TagName="struct"; FixitTagName = "struct ";TagKind=tok::kw_struct;break;
1477 case DeclSpec::TST_class:
1478 TagName="class" ; FixitTagName = "class " ;TagKind=tok::kw_class ;break;
Chris Lattnere40c2952009-04-14 21:34:55 +00001479 }
Mike Stump1eb44332009-09-09 15:08:12 +00001480
Chris Lattnerf4382f52009-04-14 22:17:06 +00001481 if (TagName) {
1482 Diag(Loc, diag::err_use_of_tag_name_without_tag)
John McCall23e907a2010-02-14 01:03:10 +00001483 << Tok.getIdentifierInfo() << TagName << getLang().CPlusPlus
Argyrios Kyrtzidisb8a9d3b2011-04-21 17:29:47 +00001484 << FixItHint::CreateInsertion(Tok.getLocation(),FixitTagName);
Mike Stump1eb44332009-09-09 15:08:12 +00001485
Chris Lattnerf4382f52009-04-14 22:17:06 +00001486 // Parse this as a tag as if the missing tag were present.
1487 if (TagKind == tok::kw_enum)
Douglas Gregor9b9edd62010-03-02 17:53:14 +00001488 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS);
Chris Lattnerf4382f52009-04-14 22:17:06 +00001489 else
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001490 ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS);
Chris Lattnerf4382f52009-04-14 22:17:06 +00001491 return true;
1492 }
Chris Lattnere40c2952009-04-14 21:34:55 +00001493 }
Mike Stump1eb44332009-09-09 15:08:12 +00001494
Douglas Gregora786fdb2009-10-13 23:27:22 +00001495 // This is almost certainly an invalid type name. Let the action emit a
1496 // diagnostic and attempt to recover.
John McCallb3d87482010-08-24 05:47:05 +00001497 ParsedType T;
Douglas Gregora786fdb2009-10-13 23:27:22 +00001498 if (Actions.DiagnoseUnknownTypeName(*Tok.getIdentifierInfo(), Loc,
Douglas Gregor23c94db2010-07-02 17:43:08 +00001499 getCurScope(), SS, T)) {
Douglas Gregora786fdb2009-10-13 23:27:22 +00001500 // The action emitted a diagnostic, so we don't have to.
1501 if (T) {
1502 // The action has suggested that the type T could be used. Set that as
1503 // the type in the declaration specifiers, consume the would-be type
1504 // name token, and we're done.
1505 const char *PrevSpec;
1506 unsigned DiagID;
John McCallb3d87482010-08-24 05:47:05 +00001507 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T);
Douglas Gregora786fdb2009-10-13 23:27:22 +00001508 DS.SetRangeEnd(Tok.getLocation());
1509 ConsumeToken();
1510
1511 // There may be other declaration specifiers after this.
1512 return true;
1513 }
1514
1515 // Fall through; the action had no suggestion for us.
1516 } else {
1517 // The action did not emit a diagnostic, so emit one now.
1518 SourceRange R;
1519 if (SS) R = SS->getRange();
1520 Diag(Loc, diag::err_unknown_typename) << Tok.getIdentifierInfo() << R;
1521 }
Mike Stump1eb44332009-09-09 15:08:12 +00001522
Douglas Gregora786fdb2009-10-13 23:27:22 +00001523 // Mark this as an error.
Chris Lattnere40c2952009-04-14 21:34:55 +00001524 const char *PrevSpec;
John McCallfec54012009-08-03 20:12:06 +00001525 unsigned DiagID;
1526 DS.SetTypeSpecType(DeclSpec::TST_error, Loc, PrevSpec, DiagID);
Chris Lattnere40c2952009-04-14 21:34:55 +00001527 DS.SetRangeEnd(Tok.getLocation());
1528 ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00001529
Chris Lattnere40c2952009-04-14 21:34:55 +00001530 // TODO: Could inject an invalid typedef decl in an enclosing scope to
1531 // avoid rippling error messages on subsequent uses of the same type,
1532 // could be useful if #include was forgotten.
1533 return false;
1534}
1535
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001536/// \brief Determine the declaration specifier context from the declarator
1537/// context.
1538///
1539/// \param Context the declarator context, which is one of the
1540/// Declarator::TheContext enumerator values.
1541Parser::DeclSpecContext
1542Parser::getDeclSpecContextFromDeclaratorContext(unsigned Context) {
1543 if (Context == Declarator::MemberContext)
1544 return DSC_class;
1545 if (Context == Declarator::FileContext)
1546 return DSC_top_level;
1547 return DSC_normal;
1548}
1549
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001550/// ParseAlignArgument - Parse the argument to an alignment-specifier.
1551///
1552/// FIXME: Simply returns an alignof() expression if the argument is a
1553/// type. Ideally, the type should be propagated directly into Sema.
1554///
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001555/// [C1X] type-id
1556/// [C1X] constant-expression
1557/// [C++0x] type-id ...[opt]
1558/// [C++0x] assignment-expression ...[opt]
1559ExprResult Parser::ParseAlignArgument(SourceLocation Start,
1560 SourceLocation &EllipsisLoc) {
1561 ExprResult ER;
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001562 if (isTypeIdInParens()) {
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001563 SourceLocation TypeLoc = Tok.getLocation();
1564 ParsedType Ty = ParseTypeName().get();
1565 SourceRange TypeRange(Start, Tok.getLocation());
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001566 ER = Actions.ActOnUnaryExprOrTypeTraitExpr(TypeLoc, UETT_AlignOf, true,
1567 Ty.getAsOpaquePtr(), TypeRange);
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001568 } else
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001569 ER = ParseConstantExpression();
1570
Peter Collingbournefe9b2a82011-10-24 17:56:00 +00001571 if (getLang().CPlusPlus0x && Tok.is(tok::ellipsis))
1572 EllipsisLoc = ConsumeToken();
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001573
1574 return ER;
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001575}
1576
1577/// ParseAlignmentSpecifier - Parse an alignment-specifier, and add the
1578/// attribute to Attrs.
1579///
1580/// alignment-specifier:
1581/// [C1X] '_Alignas' '(' type-id ')'
1582/// [C1X] '_Alignas' '(' constant-expression ')'
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001583/// [C++0x] 'alignas' '(' type-id ...[opt] ')'
1584/// [C++0x] 'alignas' '(' assignment-expression ...[opt] ')'
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001585void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs,
1586 SourceLocation *endLoc) {
1587 assert((Tok.is(tok::kw_alignas) || Tok.is(tok::kw__Alignas)) &&
1588 "Not an alignment-specifier!");
1589
1590 SourceLocation KWLoc = Tok.getLocation();
1591 ConsumeToken();
1592
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001593 BalancedDelimiterTracker T(*this, tok::l_paren);
1594 if (T.expectAndConsume(diag::err_expected_lparen))
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001595 return;
1596
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001597 SourceLocation EllipsisLoc;
1598 ExprResult ArgExpr = ParseAlignArgument(T.getOpenLocation(), EllipsisLoc);
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001599 if (ArgExpr.isInvalid()) {
1600 SkipUntil(tok::r_paren);
1601 return;
1602 }
1603
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001604 T.consumeClose();
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001605 if (endLoc)
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001606 *endLoc = T.getCloseLocation();
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001607
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001608 // FIXME: Handle pack-expansions here.
1609 if (EllipsisLoc.isValid()) {
1610 Diag(EllipsisLoc, diag::err_alignas_pack_exp_unsupported);
1611 return;
1612 }
1613
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001614 ExprVector ArgExprs(Actions);
1615 ArgExprs.push_back(ArgExpr.release());
1616 Attrs.addNew(PP.getIdentifierInfo("aligned"), KWLoc, 0, KWLoc,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001617 0, T.getOpenLocation(), ArgExprs.take(), 1, false, true);
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001618}
1619
Reid Spencer5f016e22007-07-11 17:01:13 +00001620/// ParseDeclarationSpecifiers
1621/// declaration-specifiers: [C99 6.7]
1622/// storage-class-specifier declaration-specifiers[opt]
1623/// type-specifier declaration-specifiers[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00001624/// [C99] function-specifier declaration-specifiers[opt]
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001625/// [C1X] alignment-specifier declaration-specifiers[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00001626/// [GNU] attributes declaration-specifiers[opt]
Douglas Gregor8d267c52011-09-09 02:06:17 +00001627/// [Clang] '__module_private__' declaration-specifiers[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00001628///
1629/// storage-class-specifier: [C99 6.7.1]
1630/// 'typedef'
1631/// 'extern'
1632/// 'static'
1633/// 'auto'
1634/// 'register'
Sebastian Redl669d5d72008-11-14 23:42:31 +00001635/// [C++] 'mutable'
Reid Spencer5f016e22007-07-11 17:01:13 +00001636/// [GNU] '__thread'
Reid Spencer5f016e22007-07-11 17:01:13 +00001637/// function-specifier: [C99 6.7.4]
1638/// [C99] 'inline'
Douglas Gregorb48fe382008-10-31 09:07:45 +00001639/// [C++] 'virtual'
1640/// [C++] 'explicit'
Peter Collingbournef315fa82011-02-14 01:42:53 +00001641/// [OpenCL] '__kernel'
Anders Carlssonf47f7a12009-05-06 04:46:28 +00001642/// 'friend': [C++ dcl.friend]
Sebastian Redl2ac67232009-11-05 15:47:02 +00001643/// 'constexpr': [C++0x dcl.constexpr]
Anders Carlssonf47f7a12009-05-06 04:46:28 +00001644
Reid Spencer5f016e22007-07-11 17:01:13 +00001645///
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00001646void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001647 const ParsedTemplateInfo &TemplateInfo,
John McCall67d1a672009-08-06 02:15:43 +00001648 AccessSpecifier AS,
Douglas Gregor312eadb2011-04-24 05:37:28 +00001649 DeclSpecContext DSContext) {
1650 if (DS.getSourceRange().isInvalid()) {
1651 DS.SetRangeStart(Tok.getLocation());
1652 DS.SetRangeEnd(Tok.getLocation());
1653 }
1654
Douglas Gregorefaa93a2011-11-07 17:33:42 +00001655 bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level);
Reid Spencer5f016e22007-07-11 17:01:13 +00001656 while (1) {
John McCallfec54012009-08-03 20:12:06 +00001657 bool isInvalid = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00001658 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00001659 unsigned DiagID = 0;
1660
Reid Spencer5f016e22007-07-11 17:01:13 +00001661 SourceLocation Loc = Tok.getLocation();
Douglas Gregor12e083c2008-11-07 15:42:26 +00001662
Reid Spencer5f016e22007-07-11 17:01:13 +00001663 switch (Tok.getKind()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001664 default:
Chris Lattnerbce61352008-07-26 00:20:22 +00001665 DoneWithDeclSpec:
Peter Collingbournef1907682011-09-29 18:03:57 +00001666 // [C++0x] decl-specifier-seq: decl-specifier attribute-specifier-seq[opt]
1667 MaybeParseCXX0XAttributes(DS.getAttributes());
1668
Reid Spencer5f016e22007-07-11 17:01:13 +00001669 // If this is not a declaration specifier token, we're done reading decl
1670 // specifiers. First verify that DeclSpec's are consistent.
Douglas Gregor9b3064b2009-04-01 22:41:11 +00001671 DS.Finish(Diags, PP);
Reid Spencer5f016e22007-07-11 17:01:13 +00001672 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001673
Douglas Gregor2ccccb32010-08-23 18:23:48 +00001674 case tok::code_completion: {
John McCallf312b1e2010-08-26 23:41:50 +00001675 Sema::ParserCompletionContext CCC = Sema::PCC_Namespace;
Douglas Gregor2ccccb32010-08-23 18:23:48 +00001676 if (DS.hasTypeSpecifier()) {
1677 bool AllowNonIdentifiers
1678 = (getCurScope()->getFlags() & (Scope::ControlScope |
1679 Scope::BlockScope |
1680 Scope::TemplateParamScope |
1681 Scope::FunctionPrototypeScope |
1682 Scope::AtCatchScope)) == 0;
1683 bool AllowNestedNameSpecifiers
1684 = DSContext == DSC_top_level ||
1685 (DSContext == DSC_class && DS.isFriendSpecified());
1686
Douglas Gregorc7b6d882010-09-16 15:14:18 +00001687 Actions.CodeCompleteDeclSpec(getCurScope(), DS,
1688 AllowNonIdentifiers,
1689 AllowNestedNameSpecifiers);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00001690 return cutOffParsing();
Douglas Gregor2ccccb32010-08-23 18:23:48 +00001691 }
1692
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00001693 if (getCurScope()->getFnParent() || getCurScope()->getBlockParent())
1694 CCC = Sema::PCC_LocalDeclarationSpecifiers;
1695 else if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate)
John McCallf312b1e2010-08-26 23:41:50 +00001696 CCC = DSContext == DSC_class? Sema::PCC_MemberTemplate
1697 : Sema::PCC_Template;
Douglas Gregor2ccccb32010-08-23 18:23:48 +00001698 else if (DSContext == DSC_class)
John McCallf312b1e2010-08-26 23:41:50 +00001699 CCC = Sema::PCC_Class;
Douglas Gregor2ccccb32010-08-23 18:23:48 +00001700 else if (ObjCImpDecl)
John McCallf312b1e2010-08-26 23:41:50 +00001701 CCC = Sema::PCC_ObjCImplementation;
Douglas Gregor2ccccb32010-08-23 18:23:48 +00001702
1703 Actions.CodeCompleteOrdinaryName(getCurScope(), CCC);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00001704 return cutOffParsing();
Douglas Gregor2ccccb32010-08-23 18:23:48 +00001705 }
1706
Chris Lattner5e02c472009-01-05 00:07:25 +00001707 case tok::coloncolon: // ::foo::bar
John McCall9ba61662010-02-26 08:45:28 +00001708 // C++ scope specifier. Annotate and loop, or bail out on error.
1709 if (TryAnnotateCXXScopeToken(true)) {
1710 if (!DS.hasTypeSpecifier())
1711 DS.SetTypeSpecError();
1712 goto DoneWithDeclSpec;
1713 }
John McCall2e0a7152010-03-01 18:20:46 +00001714 if (Tok.is(tok::coloncolon)) // ::new or ::delete
1715 goto DoneWithDeclSpec;
John McCall9ba61662010-02-26 08:45:28 +00001716 continue;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001717
1718 case tok::annot_cxxscope: {
1719 if (DS.hasTypeSpecifier())
1720 goto DoneWithDeclSpec;
1721
John McCallaa87d332009-12-12 11:40:51 +00001722 CXXScopeSpec SS;
Douglas Gregorc34348a2011-02-24 17:54:50 +00001723 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
1724 Tok.getAnnotationRange(),
1725 SS);
John McCallaa87d332009-12-12 11:40:51 +00001726
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001727 // We are looking for a qualified typename.
Douglas Gregor9135c722009-03-25 15:40:00 +00001728 Token Next = NextToken();
Mike Stump1eb44332009-09-09 15:08:12 +00001729 if (Next.is(tok::annot_template_id) &&
Douglas Gregor9135c722009-03-25 15:40:00 +00001730 static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue())
Douglas Gregorc45c2322009-03-31 00:43:58 +00001731 ->Kind == TNK_Type_template) {
Douglas Gregor9135c722009-03-25 15:40:00 +00001732 // We have a qualified template-id, e.g., N::A<int>
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001733
1734 // C++ [class.qual]p2:
1735 // In a lookup in which the constructor is an acceptable lookup
1736 // result and the nested-name-specifier nominates a class C:
1737 //
1738 // - if the name specified after the
1739 // nested-name-specifier, when looked up in C, is the
1740 // injected-class-name of C (Clause 9), or
1741 //
1742 // - if the name specified after the nested-name-specifier
1743 // is the same as the identifier or the
1744 // simple-template-id's template-name in the last
1745 // component of the nested-name-specifier,
1746 //
1747 // the name is instead considered to name the constructor of
1748 // class C.
1749 //
1750 // Thus, if the template-name is actually the constructor
1751 // name, then the code is ill-formed; this interpretation is
1752 // reinforced by the NAD status of core issue 635.
Argyrios Kyrtzidis25a76762011-06-22 06:09:49 +00001753 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Next);
John McCallba9d8532010-04-13 06:39:49 +00001754 if ((DSContext == DSC_top_level ||
1755 (DSContext == DSC_class && DS.isFriendSpecified())) &&
1756 TemplateId->Name &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00001757 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001758 if (isConstructorDeclarator()) {
1759 // The user meant this to be an out-of-line constructor
1760 // definition, but template arguments are not allowed
1761 // there. Just allow this as a constructor; we'll
1762 // complain about it later.
1763 goto DoneWithDeclSpec;
1764 }
1765
1766 // The user meant this to name a type, but it actually names
1767 // a constructor with some extraneous template
1768 // arguments. Complain, then parse it as a type as the user
1769 // intended.
1770 Diag(TemplateId->TemplateNameLoc,
1771 diag::err_out_of_line_template_id_names_constructor)
1772 << TemplateId->Name;
1773 }
1774
John McCallaa87d332009-12-12 11:40:51 +00001775 DS.getTypeSpecScope() = SS;
1776 ConsumeToken(); // The C++ scope.
Mike Stump1eb44332009-09-09 15:08:12 +00001777 assert(Tok.is(tok::annot_template_id) &&
Douglas Gregor9135c722009-03-25 15:40:00 +00001778 "ParseOptionalCXXScopeSpecifier not working");
Douglas Gregor059101f2011-03-02 00:47:37 +00001779 AnnotateTemplateIdTokenAsType();
Douglas Gregor9135c722009-03-25 15:40:00 +00001780 continue;
1781 }
1782
Douglas Gregor9d7b3532009-09-28 07:26:33 +00001783 if (Next.is(tok::annot_typename)) {
John McCallaa87d332009-12-12 11:40:51 +00001784 DS.getTypeSpecScope() = SS;
1785 ConsumeToken(); // The C++ scope.
John McCallb3d87482010-08-24 05:47:05 +00001786 if (Tok.getAnnotationValue()) {
1787 ParsedType T = getTypeAnnotation(Tok);
Nico Weber253e80b2010-11-22 10:30:56 +00001788 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename,
1789 Tok.getAnnotationEndLoc(),
John McCallb3d87482010-08-24 05:47:05 +00001790 PrevSpec, DiagID, T);
1791 }
Douglas Gregor9d7b3532009-09-28 07:26:33 +00001792 else
1793 DS.SetTypeSpecError();
1794 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1795 ConsumeToken(); // The typename
1796 }
1797
Douglas Gregor9135c722009-03-25 15:40:00 +00001798 if (Next.isNot(tok::identifier))
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001799 goto DoneWithDeclSpec;
1800
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001801 // If we're in a context where the identifier could be a class name,
1802 // check whether this is a constructor declaration.
John McCallba9d8532010-04-13 06:39:49 +00001803 if ((DSContext == DSC_top_level ||
1804 (DSContext == DSC_class && DS.isFriendSpecified())) &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00001805 Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(),
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001806 &SS)) {
1807 if (isConstructorDeclarator())
1808 goto DoneWithDeclSpec;
1809
1810 // As noted in C++ [class.qual]p2 (cited above), when the name
1811 // of the class is qualified in a context where it could name
1812 // a constructor, its a constructor name. However, we've
1813 // looked at the declarator, and the user probably meant this
1814 // to be a type. Complain that it isn't supposed to be treated
1815 // as a type, then proceed to parse it as a type.
1816 Diag(Next.getLocation(), diag::err_out_of_line_type_names_constructor)
1817 << Next.getIdentifierInfo();
1818 }
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001819
John McCallb3d87482010-08-24 05:47:05 +00001820 ParsedType TypeRep = Actions.getTypeName(*Next.getIdentifierInfo(),
1821 Next.getLocation(),
Douglas Gregor9e876872011-03-01 18:12:44 +00001822 getCurScope(), &SS,
1823 false, false, ParsedType(),
1824 /*NonTrivialSourceInfo=*/true);
Douglas Gregor55f6b142009-02-09 18:46:07 +00001825
Chris Lattnerf4382f52009-04-14 22:17:06 +00001826 // If the referenced identifier is not a type, then this declspec is
1827 // erroneous: We already checked about that it has no type specifier, and
1828 // C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the
Mike Stump1eb44332009-09-09 15:08:12 +00001829 // typename.
Chris Lattnerf4382f52009-04-14 22:17:06 +00001830 if (TypeRep == 0) {
1831 ConsumeToken(); // Eat the scope spec so the identifier is current.
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001832 if (ParseImplicitInt(DS, &SS, TemplateInfo, AS)) continue;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001833 goto DoneWithDeclSpec;
Chris Lattnerf4382f52009-04-14 22:17:06 +00001834 }
Mike Stump1eb44332009-09-09 15:08:12 +00001835
John McCallaa87d332009-12-12 11:40:51 +00001836 DS.getTypeSpecScope() = SS;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001837 ConsumeToken(); // The C++ scope.
1838
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00001839 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00001840 DiagID, TypeRep);
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001841 if (isInvalid)
1842 break;
Mike Stump1eb44332009-09-09 15:08:12 +00001843
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001844 DS.SetRangeEnd(Tok.getLocation());
1845 ConsumeToken(); // The typename.
1846
1847 continue;
1848 }
Mike Stump1eb44332009-09-09 15:08:12 +00001849
Chris Lattner80d0c892009-01-21 19:48:37 +00001850 case tok::annot_typename: {
John McCallb3d87482010-08-24 05:47:05 +00001851 if (Tok.getAnnotationValue()) {
1852 ParsedType T = getTypeAnnotation(Tok);
Nico Weberc43271e2010-11-22 12:50:03 +00001853 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCallb3d87482010-08-24 05:47:05 +00001854 DiagID, T);
1855 } else
Douglas Gregor31a19b62009-04-01 21:51:26 +00001856 DS.SetTypeSpecError();
Chris Lattner5c5db552010-04-05 18:18:31 +00001857
1858 if (isInvalid)
1859 break;
1860
Chris Lattner80d0c892009-01-21 19:48:37 +00001861 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1862 ConsumeToken(); // The typename
Mike Stump1eb44332009-09-09 15:08:12 +00001863
Chris Lattner80d0c892009-01-21 19:48:37 +00001864 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
1865 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00001866 // Objective-C interface.
1867 if (Tok.is(tok::less) && getLang().ObjC1)
1868 ParseObjCProtocolQualifiers(DS);
1869
Chris Lattner80d0c892009-01-21 19:48:37 +00001870 continue;
1871 }
Mike Stump1eb44332009-09-09 15:08:12 +00001872
Douglas Gregorbfad9152011-04-28 15:48:45 +00001873 case tok::kw___is_signed:
1874 // GNU libstdc++ 4.4 uses __is_signed as an identifier, but Clang
1875 // typically treats it as a trait. If we see __is_signed as it appears
1876 // in libstdc++, e.g.,
1877 //
1878 // static const bool __is_signed;
1879 //
1880 // then treat __is_signed as an identifier rather than as a keyword.
1881 if (DS.getTypeSpecType() == TST_bool &&
1882 DS.getTypeQualifiers() == DeclSpec::TQ_const &&
1883 DS.getStorageClassSpec() == DeclSpec::SCS_static) {
1884 Tok.getIdentifierInfo()->RevertTokenIDToIdentifier();
1885 Tok.setKind(tok::identifier);
1886 }
1887
1888 // We're done with the declaration-specifiers.
1889 goto DoneWithDeclSpec;
1890
Chris Lattner3bd934a2008-07-26 01:18:38 +00001891 // typedef-name
1892 case tok::identifier: {
Chris Lattner5e02c472009-01-05 00:07:25 +00001893 // In C++, check to see if this is a scope specifier like foo::bar::, if
1894 // so handle it as such. This is important for ctor parsing.
John McCall9ba61662010-02-26 08:45:28 +00001895 if (getLang().CPlusPlus) {
1896 if (TryAnnotateCXXScopeToken(true)) {
1897 if (!DS.hasTypeSpecifier())
1898 DS.SetTypeSpecError();
1899 goto DoneWithDeclSpec;
1900 }
1901 if (!Tok.is(tok::identifier))
1902 continue;
1903 }
Mike Stump1eb44332009-09-09 15:08:12 +00001904
Chris Lattner3bd934a2008-07-26 01:18:38 +00001905 // This identifier can only be a typedef name if we haven't already seen
1906 // a type-specifier. Without this check we misparse:
1907 // typedef int X; struct Y { short X; }; as 'short int'.
1908 if (DS.hasTypeSpecifier())
1909 goto DoneWithDeclSpec;
Mike Stump1eb44332009-09-09 15:08:12 +00001910
John Thompson82287d12010-02-05 00:12:22 +00001911 // Check for need to substitute AltiVec keyword tokens.
1912 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
1913 break;
1914
Chris Lattner3bd934a2008-07-26 01:18:38 +00001915 // It has to be available as a typedef too!
John McCallb3d87482010-08-24 05:47:05 +00001916 ParsedType TypeRep =
1917 Actions.getTypeName(*Tok.getIdentifierInfo(),
1918 Tok.getLocation(), getCurScope());
Douglas Gregor55f6b142009-02-09 18:46:07 +00001919
Chris Lattnerc199ab32009-04-12 20:42:31 +00001920 // If this is not a typedef name, don't parse it as part of the declspec,
1921 // it must be an implicit int or an error.
John McCallb3d87482010-08-24 05:47:05 +00001922 if (!TypeRep) {
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001923 if (ParseImplicitInt(DS, 0, TemplateInfo, AS)) continue;
Chris Lattner3bd934a2008-07-26 01:18:38 +00001924 goto DoneWithDeclSpec;
Chris Lattnerc199ab32009-04-12 20:42:31 +00001925 }
Douglas Gregor55f6b142009-02-09 18:46:07 +00001926
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001927 // If we're in a context where the identifier could be a class name,
1928 // check whether this is a constructor declaration.
1929 if (getLang().CPlusPlus && DSContext == DSC_class &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00001930 Actions.isCurrentClassName(*Tok.getIdentifierInfo(), getCurScope()) &&
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001931 isConstructorDeclarator())
Douglas Gregorb48fe382008-10-31 09:07:45 +00001932 goto DoneWithDeclSpec;
1933
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00001934 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00001935 DiagID, TypeRep);
Chris Lattner3bd934a2008-07-26 01:18:38 +00001936 if (isInvalid)
1937 break;
Mike Stump1eb44332009-09-09 15:08:12 +00001938
Chris Lattner3bd934a2008-07-26 01:18:38 +00001939 DS.SetRangeEnd(Tok.getLocation());
1940 ConsumeToken(); // The identifier
1941
1942 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
1943 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00001944 // Objective-C interface.
1945 if (Tok.is(tok::less) && getLang().ObjC1)
1946 ParseObjCProtocolQualifiers(DS);
1947
Steve Naroff4f9b9f12008-09-22 10:28:57 +00001948 // Need to support trailing type qualifiers (e.g. "id<p> const").
1949 // If a type specifier follows, it will be diagnosed elsewhere.
1950 continue;
Chris Lattner3bd934a2008-07-26 01:18:38 +00001951 }
Douglas Gregor39a8de12009-02-25 19:37:18 +00001952
1953 // type-name
1954 case tok::annot_template_id: {
Argyrios Kyrtzidis25a76762011-06-22 06:09:49 +00001955 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
Douglas Gregorc45c2322009-03-31 00:43:58 +00001956 if (TemplateId->Kind != TNK_Type_template) {
Douglas Gregor39a8de12009-02-25 19:37:18 +00001957 // This template-id does not refer to a type name, so we're
1958 // done with the type-specifiers.
1959 goto DoneWithDeclSpec;
1960 }
1961
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001962 // If we're in a context where the template-id could be a
1963 // constructor name or specialization, check whether this is a
1964 // constructor declaration.
1965 if (getLang().CPlusPlus && DSContext == DSC_class &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00001966 Actions.isCurrentClassName(*TemplateId->Name, getCurScope()) &&
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001967 isConstructorDeclarator())
1968 goto DoneWithDeclSpec;
1969
Douglas Gregor39a8de12009-02-25 19:37:18 +00001970 // Turn the template-id annotation token into a type annotation
1971 // token, then try again to parse it as a type-specifier.
Douglas Gregor31a19b62009-04-01 21:51:26 +00001972 AnnotateTemplateIdTokenAsType();
Douglas Gregor39a8de12009-02-25 19:37:18 +00001973 continue;
1974 }
1975
Reid Spencer5f016e22007-07-11 17:01:13 +00001976 // GNU attributes support.
1977 case tok::kw___attribute:
John McCall7f040a92010-12-24 02:08:15 +00001978 ParseGNUAttributes(DS.getAttributes());
Reid Spencer5f016e22007-07-11 17:01:13 +00001979 continue;
Steve Narofff59e17e2008-12-24 20:59:21 +00001980
1981 // Microsoft declspec support.
1982 case tok::kw___declspec:
John McCall7f040a92010-12-24 02:08:15 +00001983 ParseMicrosoftDeclSpec(DS.getAttributes());
Steve Narofff59e17e2008-12-24 20:59:21 +00001984 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001985
Steve Naroff239f0732008-12-25 14:16:32 +00001986 // Microsoft single token adornments.
Steve Naroff86bc6cf2008-12-25 14:41:26 +00001987 case tok::kw___forceinline:
Eli Friedman290eeb02009-06-08 23:27:34 +00001988 // FIXME: Add handling here!
1989 break;
1990
1991 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00001992 case tok::kw___ptr32:
Steve Naroff86bc6cf2008-12-25 14:41:26 +00001993 case tok::kw___w64:
Steve Naroff239f0732008-12-25 14:16:32 +00001994 case tok::kw___cdecl:
1995 case tok::kw___stdcall:
1996 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00001997 case tok::kw___thiscall:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00001998 case tok::kw___unaligned:
John McCall7f040a92010-12-24 02:08:15 +00001999 ParseMicrosoftTypeAttributes(DS.getAttributes());
Eli Friedman290eeb02009-06-08 23:27:34 +00002000 continue;
2001
Dawn Perchik52fc3142010-09-03 01:29:35 +00002002 // Borland single token adornments.
2003 case tok::kw___pascal:
John McCall7f040a92010-12-24 02:08:15 +00002004 ParseBorlandTypeAttributes(DS.getAttributes());
Dawn Perchik52fc3142010-09-03 01:29:35 +00002005 continue;
2006
Peter Collingbournef315fa82011-02-14 01:42:53 +00002007 // OpenCL single token adornments.
2008 case tok::kw___kernel:
2009 ParseOpenCLAttributes(DS.getAttributes());
2010 continue;
2011
Reid Spencer5f016e22007-07-11 17:01:13 +00002012 // storage-class-specifier
2013 case tok::kw_typedef:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002014 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc,
2015 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002016 break;
2017 case tok::kw_extern:
2018 if (DS.isThreadSpecified())
Chris Lattner1ab3b962008-11-18 07:48:38 +00002019 Diag(Tok, diag::ext_thread_before) << "extern";
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002020 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_extern, Loc,
2021 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002022 break;
Steve Naroff8d54bf22007-12-18 00:16:02 +00002023 case tok::kw___private_extern__:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002024 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_private_extern,
2025 Loc, PrevSpec, DiagID);
Steve Naroff8d54bf22007-12-18 00:16:02 +00002026 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00002027 case tok::kw_static:
2028 if (DS.isThreadSpecified())
Chris Lattner1ab3b962008-11-18 07:48:38 +00002029 Diag(Tok, diag::ext_thread_before) << "static";
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002030 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_static, Loc,
2031 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002032 break;
2033 case tok::kw_auto:
Douglas Gregor18d8b792011-03-14 21:43:30 +00002034 if (getLang().CPlusPlus0x) {
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002035 if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) {
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002036 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
2037 PrevSpec, DiagID);
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002038 if (!isInvalid)
Richard Smith8f4fb192011-09-04 19:54:14 +00002039 Diag(Tok, diag::ext_auto_storage_class)
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002040 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
Richard Smith8f4fb192011-09-04 19:54:14 +00002041 } else
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002042 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec,
2043 DiagID);
Richard Smith8f4fb192011-09-04 19:54:14 +00002044 } else
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002045 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
2046 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002047 break;
2048 case tok::kw_register:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002049 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_register, Loc,
2050 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002051 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +00002052 case tok::kw_mutable:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002053 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_mutable, Loc,
2054 PrevSpec, DiagID);
Sebastian Redl669d5d72008-11-14 23:42:31 +00002055 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00002056 case tok::kw___thread:
John McCallfec54012009-08-03 20:12:06 +00002057 isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002058 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002059
Reid Spencer5f016e22007-07-11 17:01:13 +00002060 // function-specifier
2061 case tok::kw_inline:
John McCallfec54012009-08-03 20:12:06 +00002062 isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002063 break;
Douglas Gregorb48fe382008-10-31 09:07:45 +00002064 case tok::kw_virtual:
John McCallfec54012009-08-03 20:12:06 +00002065 isInvalid = DS.SetFunctionSpecVirtual(Loc, PrevSpec, DiagID);
Douglas Gregorb48fe382008-10-31 09:07:45 +00002066 break;
Douglas Gregorb48fe382008-10-31 09:07:45 +00002067 case tok::kw_explicit:
John McCallfec54012009-08-03 20:12:06 +00002068 isInvalid = DS.SetFunctionSpecExplicit(Loc, PrevSpec, DiagID);
Douglas Gregorb48fe382008-10-31 09:07:45 +00002069 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002070
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002071 // alignment-specifier
2072 case tok::kw__Alignas:
2073 if (!getLang().C1X)
2074 Diag(Tok, diag::ext_c1x_alignas);
2075 ParseAlignmentSpecifier(DS.getAttributes());
2076 continue;
2077
Anders Carlssonf47f7a12009-05-06 04:46:28 +00002078 // friend
2079 case tok::kw_friend:
John McCall67d1a672009-08-06 02:15:43 +00002080 if (DSContext == DSC_class)
2081 isInvalid = DS.SetFriendSpec(Loc, PrevSpec, DiagID);
2082 else {
2083 PrevSpec = ""; // not actually used by the diagnostic
2084 DiagID = diag::err_friend_invalid_in_context;
2085 isInvalid = true;
2086 }
Anders Carlssonf47f7a12009-05-06 04:46:28 +00002087 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002088
Douglas Gregor8d267c52011-09-09 02:06:17 +00002089 // Modules
2090 case tok::kw___module_private__:
2091 isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID);
2092 break;
2093
Sebastian Redl2ac67232009-11-05 15:47:02 +00002094 // constexpr
2095 case tok::kw_constexpr:
2096 isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID);
2097 break;
2098
Chris Lattner80d0c892009-01-21 19:48:37 +00002099 // type-specifier
2100 case tok::kw_short:
John McCallfec54012009-08-03 20:12:06 +00002101 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec,
2102 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002103 break;
2104 case tok::kw_long:
2105 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
John McCallfec54012009-08-03 20:12:06 +00002106 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
2107 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002108 else
John McCallfec54012009-08-03 20:12:06 +00002109 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2110 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002111 break;
Francois Pichet338d7f72011-04-28 01:59:37 +00002112 case tok::kw___int64:
2113 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2114 DiagID);
2115 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002116 case tok::kw_signed:
John McCallfec54012009-08-03 20:12:06 +00002117 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec,
2118 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002119 break;
2120 case tok::kw_unsigned:
John McCallfec54012009-08-03 20:12:06 +00002121 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec,
2122 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002123 break;
2124 case tok::kw__Complex:
John McCallfec54012009-08-03 20:12:06 +00002125 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec,
2126 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002127 break;
2128 case tok::kw__Imaginary:
John McCallfec54012009-08-03 20:12:06 +00002129 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec,
2130 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002131 break;
2132 case tok::kw_void:
John McCallfec54012009-08-03 20:12:06 +00002133 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec,
2134 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002135 break;
2136 case tok::kw_char:
John McCallfec54012009-08-03 20:12:06 +00002137 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec,
2138 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002139 break;
2140 case tok::kw_int:
John McCallfec54012009-08-03 20:12:06 +00002141 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec,
2142 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002143 break;
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00002144 case tok::kw_half:
2145 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec,
2146 DiagID);
2147 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002148 case tok::kw_float:
John McCallfec54012009-08-03 20:12:06 +00002149 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
2150 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002151 break;
2152 case tok::kw_double:
John McCallfec54012009-08-03 20:12:06 +00002153 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
2154 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002155 break;
2156 case tok::kw_wchar_t:
John McCallfec54012009-08-03 20:12:06 +00002157 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
2158 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002159 break;
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002160 case tok::kw_char16_t:
John McCallfec54012009-08-03 20:12:06 +00002161 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec,
2162 DiagID);
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002163 break;
2164 case tok::kw_char32_t:
John McCallfec54012009-08-03 20:12:06 +00002165 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec,
2166 DiagID);
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002167 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002168 case tok::kw_bool:
2169 case tok::kw__Bool:
Argyrios Kyrtzidis4383e182010-11-16 18:18:13 +00002170 if (Tok.is(tok::kw_bool) &&
2171 DS.getTypeSpecType() != DeclSpec::TST_unspecified &&
2172 DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
2173 PrevSpec = ""; // Not used by the diagnostic.
2174 DiagID = diag::err_bool_redeclaration;
Fariborz Jahaniane106a0b2011-04-19 21:42:37 +00002175 // For better error recovery.
2176 Tok.setKind(tok::identifier);
Argyrios Kyrtzidis4383e182010-11-16 18:18:13 +00002177 isInvalid = true;
2178 } else {
2179 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec,
2180 DiagID);
2181 }
Chris Lattner80d0c892009-01-21 19:48:37 +00002182 break;
2183 case tok::kw__Decimal32:
John McCallfec54012009-08-03 20:12:06 +00002184 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
2185 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002186 break;
2187 case tok::kw__Decimal64:
John McCallfec54012009-08-03 20:12:06 +00002188 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
2189 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002190 break;
2191 case tok::kw__Decimal128:
John McCallfec54012009-08-03 20:12:06 +00002192 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
2193 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002194 break;
John Thompson82287d12010-02-05 00:12:22 +00002195 case tok::kw___vector:
2196 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
2197 break;
2198 case tok::kw___pixel:
2199 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
2200 break;
John McCalla5fc4722011-04-09 22:50:59 +00002201 case tok::kw___unknown_anytype:
2202 isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc,
2203 PrevSpec, DiagID);
2204 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002205
2206 // class-specifier:
2207 case tok::kw_class:
2208 case tok::kw_struct:
Chris Lattner4c97d762009-04-12 21:49:30 +00002209 case tok::kw_union: {
2210 tok::TokenKind Kind = Tok.getKind();
2211 ConsumeToken();
Douglas Gregorefaa93a2011-11-07 17:33:42 +00002212 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS, EnteringContext);
Chris Lattner80d0c892009-01-21 19:48:37 +00002213 continue;
Chris Lattner4c97d762009-04-12 21:49:30 +00002214 }
Chris Lattner80d0c892009-01-21 19:48:37 +00002215
2216 // enum-specifier:
2217 case tok::kw_enum:
Chris Lattner4c97d762009-04-12 21:49:30 +00002218 ConsumeToken();
Douglas Gregor9b9edd62010-03-02 17:53:14 +00002219 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS);
Chris Lattner80d0c892009-01-21 19:48:37 +00002220 continue;
2221
2222 // cv-qualifier:
2223 case tok::kw_const:
John McCallfec54012009-08-03 20:12:06 +00002224 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID,
2225 getLang());
Chris Lattner80d0c892009-01-21 19:48:37 +00002226 break;
2227 case tok::kw_volatile:
John McCallfec54012009-08-03 20:12:06 +00002228 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
2229 getLang());
Chris Lattner80d0c892009-01-21 19:48:37 +00002230 break;
2231 case tok::kw_restrict:
John McCallfec54012009-08-03 20:12:06 +00002232 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
2233 getLang());
Chris Lattner80d0c892009-01-21 19:48:37 +00002234 break;
2235
Douglas Gregord57959a2009-03-27 23:10:48 +00002236 // C++ typename-specifier:
2237 case tok::kw_typename:
John McCall9ba61662010-02-26 08:45:28 +00002238 if (TryAnnotateTypeOrScopeToken()) {
2239 DS.SetTypeSpecError();
2240 goto DoneWithDeclSpec;
2241 }
2242 if (!Tok.is(tok::kw_typename))
Douglas Gregord57959a2009-03-27 23:10:48 +00002243 continue;
2244 break;
2245
Chris Lattner80d0c892009-01-21 19:48:37 +00002246 // GNU typeof support.
2247 case tok::kw_typeof:
2248 ParseTypeofSpecifier(DS);
2249 continue;
2250
Anders Carlsson6fd634f2009-06-24 17:47:40 +00002251 case tok::kw_decltype:
2252 ParseDecltypeSpecifier(DS);
2253 continue;
2254
Sean Huntdb5d44b2011-05-19 05:37:45 +00002255 case tok::kw___underlying_type:
2256 ParseUnderlyingTypeSpecifier(DS);
Eli Friedmanb001de72011-10-06 23:00:33 +00002257 continue;
2258
2259 case tok::kw__Atomic:
2260 ParseAtomicSpecifier(DS);
2261 continue;
Sean Huntdb5d44b2011-05-19 05:37:45 +00002262
Peter Collingbourne207f4d82011-03-18 22:38:29 +00002263 // OpenCL qualifiers:
2264 case tok::kw_private:
2265 if (!getLang().OpenCL)
2266 goto DoneWithDeclSpec;
2267 case tok::kw___private:
2268 case tok::kw___global:
2269 case tok::kw___local:
2270 case tok::kw___constant:
2271 case tok::kw___read_only:
2272 case tok::kw___write_only:
2273 case tok::kw___read_write:
2274 ParseOpenCLQualifiers(DS);
2275 break;
2276
Steve Naroffd3ded1f2008-06-05 00:02:44 +00002277 case tok::less:
Chris Lattner3bd934a2008-07-26 01:18:38 +00002278 // GCC ObjC supports types like "<SomeProtocol>" as a synonym for
Chris Lattnerbce61352008-07-26 00:20:22 +00002279 // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous,
2280 // but we support it.
Chris Lattner3bd934a2008-07-26 01:18:38 +00002281 if (DS.hasTypeSpecifier() || !getLang().ObjC1)
Chris Lattnerbce61352008-07-26 00:20:22 +00002282 goto DoneWithDeclSpec;
Mike Stump1eb44332009-09-09 15:08:12 +00002283
Douglas Gregor46f936e2010-11-19 17:10:50 +00002284 if (!ParseObjCProtocolQualifiers(DS))
2285 Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id)
2286 << FixItHint::CreateInsertion(Loc, "id")
2287 << SourceRange(Loc, DS.getSourceRange().getEnd());
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00002288
2289 // Need to support trailing type qualifiers (e.g. "id<p> const").
2290 // If a type specifier follows, it will be diagnosed elsewhere.
2291 continue;
Reid Spencer5f016e22007-07-11 17:01:13 +00002292 }
John McCallfec54012009-08-03 20:12:06 +00002293 // If the specifier wasn't legal, issue a diagnostic.
Reid Spencer5f016e22007-07-11 17:01:13 +00002294 if (isInvalid) {
2295 assert(PrevSpec && "Method did not return previous specifier!");
John McCallfec54012009-08-03 20:12:06 +00002296 assert(DiagID);
Douglas Gregorae2fb142010-08-23 14:34:43 +00002297
2298 if (DiagID == diag::ext_duplicate_declspec)
2299 Diag(Tok, DiagID)
2300 << PrevSpec << FixItHint::CreateRemoval(Tok.getLocation());
2301 else
2302 Diag(Tok, DiagID) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00002303 }
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002304
Chris Lattner81c018d2008-03-13 06:29:04 +00002305 DS.SetRangeEnd(Tok.getLocation());
Fariborz Jahaniane106a0b2011-04-19 21:42:37 +00002306 if (DiagID != diag::err_bool_redeclaration)
2307 ConsumeToken();
Reid Spencer5f016e22007-07-11 17:01:13 +00002308 }
2309}
Douglas Gregoradcac882008-12-01 23:54:00 +00002310
Chris Lattner7a0ab5f2009-01-06 06:59:53 +00002311/// ParseOptionalTypeSpecifier - Try to parse a single type-specifier. We
Douglas Gregor12e083c2008-11-07 15:42:26 +00002312/// primarily follow the C++ grammar with additions for C99 and GNU,
2313/// which together subsume the C grammar. Note that the C++
2314/// type-specifier also includes the C type-qualifier (for const,
2315/// volatile, and C99 restrict). Returns true if a type-specifier was
2316/// found (and parsed), false otherwise.
2317///
2318/// type-specifier: [C++ 7.1.5]
2319/// simple-type-specifier
2320/// class-specifier
2321/// enum-specifier
2322/// elaborated-type-specifier [TODO]
2323/// cv-qualifier
2324///
2325/// cv-qualifier: [C++ 7.1.5.1]
2326/// 'const'
2327/// 'volatile'
2328/// [C99] 'restrict'
2329///
2330/// simple-type-specifier: [ C++ 7.1.5.2]
2331/// '::'[opt] nested-name-specifier[opt] type-name [TODO]
2332/// '::'[opt] nested-name-specifier 'template' template-id [TODO]
2333/// 'char'
2334/// 'wchar_t'
2335/// 'bool'
2336/// 'short'
2337/// 'int'
2338/// 'long'
2339/// 'signed'
2340/// 'unsigned'
2341/// 'float'
2342/// 'double'
2343/// 'void'
2344/// [C99] '_Bool'
2345/// [C99] '_Complex'
2346/// [C99] '_Imaginary' // Removed in TC2?
2347/// [GNU] '_Decimal32'
2348/// [GNU] '_Decimal64'
2349/// [GNU] '_Decimal128'
2350/// [GNU] typeof-specifier
2351/// [OBJC] class-name objc-protocol-refs[opt] [TODO]
2352/// [OBJC] typedef-name objc-protocol-refs[opt] [TODO]
Anders Carlsson6fd634f2009-06-24 17:47:40 +00002353/// [C++0x] 'decltype' ( expression )
John Thompson82287d12010-02-05 00:12:22 +00002354/// [AltiVec] '__vector'
John McCallfec54012009-08-03 20:12:06 +00002355bool Parser::ParseOptionalTypeSpecifier(DeclSpec &DS, bool& isInvalid,
Chris Lattner7a0ab5f2009-01-06 06:59:53 +00002356 const char *&PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00002357 unsigned &DiagID,
Sebastian Redld9bafa72010-02-03 21:21:43 +00002358 const ParsedTemplateInfo &TemplateInfo,
2359 bool SuppressDeclarations) {
Douglas Gregor12e083c2008-11-07 15:42:26 +00002360 SourceLocation Loc = Tok.getLocation();
2361
2362 switch (Tok.getKind()) {
Chris Lattner166a8fc2009-01-04 23:41:41 +00002363 case tok::identifier: // foo::bar
Douglas Gregorc0b39642010-04-15 23:40:53 +00002364 // If we already have a type specifier, this identifier is not a type.
2365 if (DS.getTypeSpecType() != DeclSpec::TST_unspecified ||
2366 DS.getTypeSpecWidth() != DeclSpec::TSW_unspecified ||
2367 DS.getTypeSpecSign() != DeclSpec::TSS_unspecified)
2368 return false;
John Thompson82287d12010-02-05 00:12:22 +00002369 // Check for need to substitute AltiVec keyword tokens.
2370 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
2371 break;
2372 // Fall through.
Douglas Gregord57959a2009-03-27 23:10:48 +00002373 case tok::kw_typename: // typename foo::bar
Chris Lattner166a8fc2009-01-04 23:41:41 +00002374 // Annotate typenames and C++ scope specifiers. If we get one, just
2375 // recurse to handle whatever we get.
Kaelyn Uhrainfac94672011-10-11 01:02:41 +00002376 if (TryAnnotateTypeOrScopeToken(/*EnteringContext=*/false,
2377 /*NeedType=*/true))
John McCall9ba61662010-02-26 08:45:28 +00002378 return true;
2379 if (Tok.is(tok::identifier))
2380 return false;
2381 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID,
2382 TemplateInfo, SuppressDeclarations);
Chris Lattner166a8fc2009-01-04 23:41:41 +00002383 case tok::coloncolon: // ::foo::bar
2384 if (NextToken().is(tok::kw_new) || // ::new
2385 NextToken().is(tok::kw_delete)) // ::delete
2386 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00002387
Chris Lattner166a8fc2009-01-04 23:41:41 +00002388 // Annotate typenames and C++ scope specifiers. If we get one, just
2389 // recurse to handle whatever we get.
Kaelyn Uhrainfac94672011-10-11 01:02:41 +00002390 if (TryAnnotateTypeOrScopeToken(/*EnteringContext=*/false,
2391 /*NeedType=*/true))
John McCall9ba61662010-02-26 08:45:28 +00002392 return true;
2393 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID,
2394 TemplateInfo, SuppressDeclarations);
Mike Stump1eb44332009-09-09 15:08:12 +00002395
Douglas Gregor12e083c2008-11-07 15:42:26 +00002396 // simple-type-specifier:
Chris Lattnerb31757b2009-01-06 05:06:21 +00002397 case tok::annot_typename: {
John McCallb3d87482010-08-24 05:47:05 +00002398 if (ParsedType T = getTypeAnnotation(Tok)) {
Nico Weber253e80b2010-11-22 10:30:56 +00002399 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename,
2400 Tok.getAnnotationEndLoc(), PrevSpec,
John McCallb3d87482010-08-24 05:47:05 +00002401 DiagID, T);
2402 } else
Douglas Gregor31a19b62009-04-01 21:51:26 +00002403 DS.SetTypeSpecError();
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002404 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
2405 ConsumeToken(); // The typename
Mike Stump1eb44332009-09-09 15:08:12 +00002406
Douglas Gregor12e083c2008-11-07 15:42:26 +00002407 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
2408 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
2409 // Objective-C interface. If we don't have Objective-C or a '<', this is
2410 // just a normal reference to a typedef name.
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00002411 if (Tok.is(tok::less) && getLang().ObjC1)
2412 ParseObjCProtocolQualifiers(DS);
2413
Douglas Gregor12e083c2008-11-07 15:42:26 +00002414 return true;
2415 }
2416
2417 case tok::kw_short:
John McCallfec54012009-08-03 20:12:06 +00002418 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002419 break;
2420 case tok::kw_long:
2421 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
John McCallfec54012009-08-03 20:12:06 +00002422 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
2423 DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002424 else
John McCallfec54012009-08-03 20:12:06 +00002425 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2426 DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002427 break;
Francois Pichet338d7f72011-04-28 01:59:37 +00002428 case tok::kw___int64:
2429 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2430 DiagID);
2431 break;
Douglas Gregor12e083c2008-11-07 15:42:26 +00002432 case tok::kw_signed:
John McCallfec54012009-08-03 20:12:06 +00002433 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002434 break;
2435 case tok::kw_unsigned:
John McCallfec54012009-08-03 20:12:06 +00002436 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec,
2437 DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002438 break;
2439 case tok::kw__Complex:
John McCallfec54012009-08-03 20:12:06 +00002440 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec,
2441 DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002442 break;
2443 case tok::kw__Imaginary:
John McCallfec54012009-08-03 20:12:06 +00002444 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec,
2445 DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002446 break;
2447 case tok::kw_void:
John McCallfec54012009-08-03 20:12:06 +00002448 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002449 break;
2450 case tok::kw_char:
John McCallfec54012009-08-03 20:12:06 +00002451 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002452 break;
2453 case tok::kw_int:
John McCallfec54012009-08-03 20:12:06 +00002454 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002455 break;
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00002456 case tok::kw_half:
2457 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID);
2458 break;
Douglas Gregor12e083c2008-11-07 15:42:26 +00002459 case tok::kw_float:
John McCallfec54012009-08-03 20:12:06 +00002460 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002461 break;
2462 case tok::kw_double:
John McCallfec54012009-08-03 20:12:06 +00002463 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002464 break;
2465 case tok::kw_wchar_t:
John McCallfec54012009-08-03 20:12:06 +00002466 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002467 break;
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002468 case tok::kw_char16_t:
John McCallfec54012009-08-03 20:12:06 +00002469 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID);
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002470 break;
2471 case tok::kw_char32_t:
John McCallfec54012009-08-03 20:12:06 +00002472 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID);
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002473 break;
Douglas Gregor12e083c2008-11-07 15:42:26 +00002474 case tok::kw_bool:
2475 case tok::kw__Bool:
John McCallfec54012009-08-03 20:12:06 +00002476 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002477 break;
2478 case tok::kw__Decimal32:
John McCallfec54012009-08-03 20:12:06 +00002479 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
2480 DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002481 break;
2482 case tok::kw__Decimal64:
John McCallfec54012009-08-03 20:12:06 +00002483 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
2484 DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002485 break;
2486 case tok::kw__Decimal128:
John McCallfec54012009-08-03 20:12:06 +00002487 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
2488 DiagID);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002489 break;
John Thompson82287d12010-02-05 00:12:22 +00002490 case tok::kw___vector:
2491 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
2492 break;
2493 case tok::kw___pixel:
2494 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
2495 break;
2496
Douglas Gregor12e083c2008-11-07 15:42:26 +00002497 // class-specifier:
2498 case tok::kw_class:
2499 case tok::kw_struct:
Chris Lattner4c97d762009-04-12 21:49:30 +00002500 case tok::kw_union: {
2501 tok::TokenKind Kind = Tok.getKind();
2502 ConsumeToken();
Sebastian Redld9bafa72010-02-03 21:21:43 +00002503 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS_none,
Douglas Gregorefaa93a2011-11-07 17:33:42 +00002504 /*EnteringContext=*/false,
Sebastian Redld9bafa72010-02-03 21:21:43 +00002505 SuppressDeclarations);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002506 return true;
Chris Lattner4c97d762009-04-12 21:49:30 +00002507 }
Douglas Gregor12e083c2008-11-07 15:42:26 +00002508
2509 // enum-specifier:
2510 case tok::kw_enum:
Chris Lattner4c97d762009-04-12 21:49:30 +00002511 ConsumeToken();
Douglas Gregor9b9edd62010-03-02 17:53:14 +00002512 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS_none);
Douglas Gregor12e083c2008-11-07 15:42:26 +00002513 return true;
2514
2515 // cv-qualifier:
2516 case tok::kw_const:
2517 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00002518 DiagID, getLang());
Douglas Gregor12e083c2008-11-07 15:42:26 +00002519 break;
2520 case tok::kw_volatile:
2521 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00002522 DiagID, getLang());
Douglas Gregor12e083c2008-11-07 15:42:26 +00002523 break;
2524 case tok::kw_restrict:
2525 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00002526 DiagID, getLang());
Douglas Gregor12e083c2008-11-07 15:42:26 +00002527 break;
2528
2529 // GNU typeof support.
2530 case tok::kw_typeof:
2531 ParseTypeofSpecifier(DS);
2532 return true;
2533
Anders Carlsson6fd634f2009-06-24 17:47:40 +00002534 // C++0x decltype support.
2535 case tok::kw_decltype:
2536 ParseDecltypeSpecifier(DS);
2537 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00002538
Sean Huntdb5d44b2011-05-19 05:37:45 +00002539 // C++0x type traits support.
2540 case tok::kw___underlying_type:
2541 ParseUnderlyingTypeSpecifier(DS);
2542 return true;
2543
Eli Friedmanb001de72011-10-06 23:00:33 +00002544 case tok::kw__Atomic:
2545 ParseAtomicSpecifier(DS);
2546 return true;
2547
Peter Collingbourne207f4d82011-03-18 22:38:29 +00002548 // OpenCL qualifiers:
2549 case tok::kw_private:
2550 if (!getLang().OpenCL)
2551 return false;
2552 case tok::kw___private:
2553 case tok::kw___global:
2554 case tok::kw___local:
2555 case tok::kw___constant:
2556 case tok::kw___read_only:
2557 case tok::kw___write_only:
2558 case tok::kw___read_write:
2559 ParseOpenCLQualifiers(DS);
2560 break;
2561
Anders Carlsson0b7f7892009-06-26 23:44:14 +00002562 // C++0x auto support.
2563 case tok::kw_auto:
Richard Smith87e96eb2011-09-04 20:24:20 +00002564 // This is only called in situations where a storage-class specifier is
2565 // illegal, so we can assume an auto type specifier was intended even in
2566 // C++98. In C++98 mode, DeclSpec::Finish will produce an appropriate
2567 // extension diagnostic.
2568 if (!getLang().CPlusPlus)
Anders Carlsson0b7f7892009-06-26 23:44:14 +00002569 return false;
2570
John McCallfec54012009-08-03 20:12:06 +00002571 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec, DiagID);
Anders Carlsson0b7f7892009-06-26 23:44:14 +00002572 break;
Dawn Perchik52fc3142010-09-03 01:29:35 +00002573
Eli Friedman290eeb02009-06-08 23:27:34 +00002574 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00002575 case tok::kw___ptr32:
Eli Friedman290eeb02009-06-08 23:27:34 +00002576 case tok::kw___w64:
Steve Naroff239f0732008-12-25 14:16:32 +00002577 case tok::kw___cdecl:
2578 case tok::kw___stdcall:
2579 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00002580 case tok::kw___thiscall:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00002581 case tok::kw___unaligned:
John McCall7f040a92010-12-24 02:08:15 +00002582 ParseMicrosoftTypeAttributes(DS.getAttributes());
Chris Lattner837acd02009-01-21 19:19:26 +00002583 return true;
Steve Naroff239f0732008-12-25 14:16:32 +00002584
Dawn Perchik52fc3142010-09-03 01:29:35 +00002585 case tok::kw___pascal:
John McCall7f040a92010-12-24 02:08:15 +00002586 ParseBorlandTypeAttributes(DS.getAttributes());
Dawn Perchik52fc3142010-09-03 01:29:35 +00002587 return true;
2588
Douglas Gregor12e083c2008-11-07 15:42:26 +00002589 default:
2590 // Not a type-specifier; do nothing.
2591 return false;
2592 }
2593
2594 // If the specifier combination wasn't legal, issue a diagnostic.
2595 if (isInvalid) {
2596 assert(PrevSpec && "Method did not return previous specifier!");
Chris Lattner1ab3b962008-11-18 07:48:38 +00002597 // Pick between error or extwarn.
Chris Lattner1ab3b962008-11-18 07:48:38 +00002598 Diag(Tok, DiagID) << PrevSpec;
Douglas Gregor12e083c2008-11-07 15:42:26 +00002599 }
2600 DS.SetRangeEnd(Tok.getLocation());
2601 ConsumeToken(); // whatever we parsed above.
2602 return true;
2603}
Reid Spencer5f016e22007-07-11 17:01:13 +00002604
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002605/// ParseStructDeclaration - Parse a struct declaration without the terminating
2606/// semicolon.
2607///
Reid Spencer5f016e22007-07-11 17:01:13 +00002608/// struct-declaration:
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002609/// specifier-qualifier-list struct-declarator-list
Reid Spencer5f016e22007-07-11 17:01:13 +00002610/// [GNU] __extension__ struct-declaration
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002611/// [GNU] specifier-qualifier-list
Reid Spencer5f016e22007-07-11 17:01:13 +00002612/// struct-declarator-list:
2613/// struct-declarator
2614/// struct-declarator-list ',' struct-declarator
2615/// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator
2616/// struct-declarator:
2617/// declarator
2618/// [GNU] declarator attributes[opt]
2619/// declarator[opt] ':' constant-expression
2620/// [GNU] declarator[opt] ':' constant-expression attributes[opt]
2621///
Chris Lattnere1359422008-04-10 06:46:29 +00002622void Parser::
John McCallbdd563e2009-11-03 02:38:08 +00002623ParseStructDeclaration(DeclSpec &DS, FieldCallback &Fields) {
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00002624
Chris Lattnerc46d1a12008-10-20 06:45:43 +00002625 if (Tok.is(tok::kw___extension__)) {
2626 // __extension__ silences extension warnings in the subexpression.
2627 ExtensionRAIIObject O(Diags); // Use RAII to do this.
Steve Naroff28a7ca82007-08-20 22:28:22 +00002628 ConsumeToken();
Chris Lattnerc46d1a12008-10-20 06:45:43 +00002629 return ParseStructDeclaration(DS, Fields);
2630 }
Mike Stump1eb44332009-09-09 15:08:12 +00002631
Steve Naroff28a7ca82007-08-20 22:28:22 +00002632 // Parse the common specifier-qualifiers-list piece.
Steve Naroff28a7ca82007-08-20 22:28:22 +00002633 ParseSpecifierQualifierList(DS);
Mike Stump1eb44332009-09-09 15:08:12 +00002634
Douglas Gregor4920f1f2009-01-12 22:49:06 +00002635 // If there are no declarators, this is a free-standing declaration
2636 // specifier. Let the actions module cope with it.
Chris Lattner04d66662007-10-09 17:33:22 +00002637 if (Tok.is(tok::semi)) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00002638 Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, DS);
Steve Naroff28a7ca82007-08-20 22:28:22 +00002639 return;
2640 }
2641
2642 // Read struct-declarators until we find the semicolon.
John McCallbdd563e2009-11-03 02:38:08 +00002643 bool FirstDeclarator = true;
Steve Naroff28a7ca82007-08-20 22:28:22 +00002644 while (1) {
John McCall54abf7d2009-11-04 02:18:39 +00002645 ParsingDeclRAIIObject PD(*this);
John McCallbdd563e2009-11-03 02:38:08 +00002646 FieldDeclarator DeclaratorInfo(DS);
2647
2648 // Attributes are only allowed here on successive declarators.
John McCall7f040a92010-12-24 02:08:15 +00002649 if (!FirstDeclarator)
2650 MaybeParseGNUAttributes(DeclaratorInfo.D);
Mike Stump1eb44332009-09-09 15:08:12 +00002651
Steve Naroff28a7ca82007-08-20 22:28:22 +00002652 /// struct-declarator: declarator
2653 /// struct-declarator: declarator[opt] ':' constant-expression
Chris Lattnera1efc8c2009-12-10 01:59:24 +00002654 if (Tok.isNot(tok::colon)) {
2655 // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
2656 ColonProtectionRAIIObject X(*this);
Chris Lattnere1359422008-04-10 06:46:29 +00002657 ParseDeclarator(DeclaratorInfo.D);
Chris Lattnera1efc8c2009-12-10 01:59:24 +00002658 }
Mike Stump1eb44332009-09-09 15:08:12 +00002659
Chris Lattner04d66662007-10-09 17:33:22 +00002660 if (Tok.is(tok::colon)) {
Steve Naroff28a7ca82007-08-20 22:28:22 +00002661 ConsumeToken();
John McCall60d7b3a2010-08-24 06:29:42 +00002662 ExprResult Res(ParseConstantExpression());
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00002663 if (Res.isInvalid())
Steve Naroff28a7ca82007-08-20 22:28:22 +00002664 SkipUntil(tok::semi, true, true);
Chris Lattner60b1e3e2008-04-10 06:15:14 +00002665 else
Sebastian Redleffa8d12008-12-10 00:02:53 +00002666 DeclaratorInfo.BitfieldSize = Res.release();
Steve Naroff28a7ca82007-08-20 22:28:22 +00002667 }
Sebastian Redlab197ba2009-02-09 18:23:29 +00002668
Steve Naroff28a7ca82007-08-20 22:28:22 +00002669 // If attributes exist after the declarator, parse them.
John McCall7f040a92010-12-24 02:08:15 +00002670 MaybeParseGNUAttributes(DeclaratorInfo.D);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002671
John McCallbdd563e2009-11-03 02:38:08 +00002672 // We're done with this declarator; invoke the callback.
John McCalld226f652010-08-21 09:40:31 +00002673 Decl *D = Fields.invoke(DeclaratorInfo);
John McCall54abf7d2009-11-04 02:18:39 +00002674 PD.complete(D);
John McCallbdd563e2009-11-03 02:38:08 +00002675
Steve Naroff28a7ca82007-08-20 22:28:22 +00002676 // If we don't have a comma, it is either the end of the list (a ';')
2677 // or an error, bail out.
Chris Lattner04d66662007-10-09 17:33:22 +00002678 if (Tok.isNot(tok::comma))
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002679 return;
Sebastian Redlab197ba2009-02-09 18:23:29 +00002680
Steve Naroff28a7ca82007-08-20 22:28:22 +00002681 // Consume the comma.
2682 ConsumeToken();
Sebastian Redlab197ba2009-02-09 18:23:29 +00002683
John McCallbdd563e2009-11-03 02:38:08 +00002684 FirstDeclarator = false;
Steve Naroff28a7ca82007-08-20 22:28:22 +00002685 }
Steve Naroff28a7ca82007-08-20 22:28:22 +00002686}
2687
2688/// ParseStructUnionBody
2689/// struct-contents:
2690/// struct-declaration-list
2691/// [EXT] empty
2692/// [GNU] "struct-declaration-list" without terminatoring ';'
2693/// struct-declaration-list:
2694/// struct-declaration
2695/// struct-declaration-list struct-declaration
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002696/// [OBC] '@' 'defs' '(' class-name ')'
Steve Naroff28a7ca82007-08-20 22:28:22 +00002697///
Reid Spencer5f016e22007-07-11 17:01:13 +00002698void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
John McCalld226f652010-08-21 09:40:31 +00002699 unsigned TagType, Decl *TagDecl) {
John McCallf312b1e2010-08-26 23:41:50 +00002700 PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc,
2701 "parsing struct/union body");
Mike Stump1eb44332009-09-09 15:08:12 +00002702
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002703 BalancedDelimiterTracker T(*this, tok::l_brace);
2704 if (T.consumeOpen())
2705 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002706
Douglas Gregor3218c4b2009-01-09 22:42:13 +00002707 ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
Douglas Gregor23c94db2010-07-02 17:43:08 +00002708 Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
Douglas Gregor72de6672009-01-08 20:45:30 +00002709
Reid Spencer5f016e22007-07-11 17:01:13 +00002710 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in
2711 // C++.
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002712 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus)
Douglas Gregor03332962010-07-29 14:29:34 +00002713 Diag(Tok, diag::ext_empty_struct_union)
2714 << (TagType == TST_union);
Reid Spencer5f016e22007-07-11 17:01:13 +00002715
Chris Lattner5f9e2722011-07-23 10:55:15 +00002716 SmallVector<Decl *, 32> FieldDecls;
Chris Lattnere1359422008-04-10 06:46:29 +00002717
Reid Spencer5f016e22007-07-11 17:01:13 +00002718 // While we still have something to read, read the declarations in the struct.
Chris Lattner04d66662007-10-09 17:33:22 +00002719 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002720 // Each iteration of this loop reads one struct-declaration.
Mike Stump1eb44332009-09-09 15:08:12 +00002721
Reid Spencer5f016e22007-07-11 17:01:13 +00002722 // Check for extraneous top-level semicolon.
Chris Lattner04d66662007-10-09 17:33:22 +00002723 if (Tok.is(tok::semi)) {
Douglas Gregor9b3064b2009-04-01 22:41:11 +00002724 Diag(Tok, diag::ext_extra_struct_semi)
Douglas Gregorf13ca062010-06-16 23:08:59 +00002725 << DeclSpec::getSpecifierName((DeclSpec::TST)TagType)
Douglas Gregor849b2432010-03-31 17:46:05 +00002726 << FixItHint::CreateRemoval(Tok.getLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00002727 ConsumeToken();
2728 continue;
2729 }
Chris Lattnere1359422008-04-10 06:46:29 +00002730
2731 // Parse all the comma separated declarators.
John McCall0b7e6782011-03-24 11:26:52 +00002732 DeclSpec DS(AttrFactory);
Mike Stump1eb44332009-09-09 15:08:12 +00002733
John McCallbdd563e2009-11-03 02:38:08 +00002734 if (!Tok.is(tok::at)) {
2735 struct CFieldCallback : FieldCallback {
2736 Parser &P;
John McCalld226f652010-08-21 09:40:31 +00002737 Decl *TagDecl;
Chris Lattner5f9e2722011-07-23 10:55:15 +00002738 SmallVectorImpl<Decl *> &FieldDecls;
John McCallbdd563e2009-11-03 02:38:08 +00002739
John McCalld226f652010-08-21 09:40:31 +00002740 CFieldCallback(Parser &P, Decl *TagDecl,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002741 SmallVectorImpl<Decl *> &FieldDecls) :
John McCallbdd563e2009-11-03 02:38:08 +00002742 P(P), TagDecl(TagDecl), FieldDecls(FieldDecls) {}
2743
John McCalld226f652010-08-21 09:40:31 +00002744 virtual Decl *invoke(FieldDeclarator &FD) {
John McCallbdd563e2009-11-03 02:38:08 +00002745 // Install the declarator into the current TagDecl.
John McCalld226f652010-08-21 09:40:31 +00002746 Decl *Field = P.Actions.ActOnField(P.getCurScope(), TagDecl,
John McCall4ba39712009-11-03 21:13:47 +00002747 FD.D.getDeclSpec().getSourceRange().getBegin(),
2748 FD.D, FD.BitfieldSize);
John McCallbdd563e2009-11-03 02:38:08 +00002749 FieldDecls.push_back(Field);
2750 return Field;
Douglas Gregor91a28862009-08-26 14:27:30 +00002751 }
John McCallbdd563e2009-11-03 02:38:08 +00002752 } Callback(*this, TagDecl, FieldDecls);
2753
2754 ParseStructDeclaration(DS, Callback);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002755 } else { // Handle @defs
2756 ConsumeToken();
2757 if (!Tok.isObjCAtKeyword(tok::objc_defs)) {
2758 Diag(Tok, diag::err_unexpected_at);
Chris Lattner3e156ad2010-02-02 00:37:27 +00002759 SkipUntil(tok::semi, true);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002760 continue;
2761 }
2762 ConsumeToken();
2763 ExpectAndConsume(tok::l_paren, diag::err_expected_lparen);
2764 if (!Tok.is(tok::identifier)) {
2765 Diag(Tok, diag::err_expected_ident);
Chris Lattner3e156ad2010-02-02 00:37:27 +00002766 SkipUntil(tok::semi, true);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002767 continue;
2768 }
Chris Lattner5f9e2722011-07-23 10:55:15 +00002769 SmallVector<Decl *, 16> Fields;
Douglas Gregor23c94db2010-07-02 17:43:08 +00002770 Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(),
Douglas Gregor44b43212008-12-11 16:49:14 +00002771 Tok.getIdentifierInfo(), Fields);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002772 FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end());
2773 ConsumeToken();
2774 ExpectAndConsume(tok::r_paren, diag::err_expected_rparen);
Mike Stump1eb44332009-09-09 15:08:12 +00002775 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002776
Chris Lattner04d66662007-10-09 17:33:22 +00002777 if (Tok.is(tok::semi)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002778 ConsumeToken();
Chris Lattner04d66662007-10-09 17:33:22 +00002779 } else if (Tok.is(tok::r_brace)) {
Chris Lattner3e156ad2010-02-02 00:37:27 +00002780 ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list);
Reid Spencer5f016e22007-07-11 17:01:13 +00002781 break;
2782 } else {
Chris Lattner3e156ad2010-02-02 00:37:27 +00002783 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
2784 // Skip to end of block or statement to avoid ext-warning on extra ';'.
Reid Spencer5f016e22007-07-11 17:01:13 +00002785 SkipUntil(tok::r_brace, true, true);
Chris Lattner3e156ad2010-02-02 00:37:27 +00002786 // If we stopped at a ';', eat it.
2787 if (Tok.is(tok::semi)) ConsumeToken();
Reid Spencer5f016e22007-07-11 17:01:13 +00002788 }
2789 }
Mike Stump1eb44332009-09-09 15:08:12 +00002790
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002791 T.consumeClose();
Mike Stump1eb44332009-09-09 15:08:12 +00002792
John McCall0b7e6782011-03-24 11:26:52 +00002793 ParsedAttributes attrs(AttrFactory);
Reid Spencer5f016e22007-07-11 17:01:13 +00002794 // If attributes exist after struct contents, parse them.
John McCall7f040a92010-12-24 02:08:15 +00002795 MaybeParseGNUAttributes(attrs);
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00002796
Douglas Gregor23c94db2010-07-02 17:43:08 +00002797 Actions.ActOnFields(getCurScope(),
David Blaikie77b6de02011-09-22 02:58:26 +00002798 RecordLoc, TagDecl, FieldDecls,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002799 T.getOpenLocation(), T.getCloseLocation(),
John McCall7f040a92010-12-24 02:08:15 +00002800 attrs.getList());
Douglas Gregor72de6672009-01-08 20:45:30 +00002801 StructScope.Exit();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002802 Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl,
2803 T.getCloseLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00002804}
2805
Reid Spencer5f016e22007-07-11 17:01:13 +00002806/// ParseEnumSpecifier
2807/// enum-specifier: [C99 6.7.2.2]
2808/// 'enum' identifier[opt] '{' enumerator-list '}'
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002809///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
Reid Spencer5f016e22007-07-11 17:01:13 +00002810/// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
2811/// '}' attributes[opt]
2812/// 'enum' identifier
2813/// [GNU] 'enum' attributes[opt] identifier
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002814///
Douglas Gregor1274ccd2010-10-08 23:50:27 +00002815/// [C++0x] enum-head '{' enumerator-list[opt] '}'
2816/// [C++0x] enum-head '{' enumerator-list ',' '}'
2817///
2818/// enum-head: [C++0x]
2819/// enum-key attributes[opt] identifier[opt] enum-base[opt]
2820/// enum-key attributes[opt] nested-name-specifier identifier enum-base[opt]
2821///
2822/// enum-key: [C++0x]
2823/// 'enum'
2824/// 'enum' 'class'
2825/// 'enum' 'struct'
2826///
2827/// enum-base: [C++0x]
2828/// ':' type-specifier-seq
2829///
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002830/// [C++] elaborated-type-specifier:
2831/// [C++] 'enum' '::'[opt] nested-name-specifier[opt] identifier
2832///
Chris Lattner4c97d762009-04-12 21:49:30 +00002833void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
Douglas Gregor9b9edd62010-03-02 17:53:14 +00002834 const ParsedTemplateInfo &TemplateInfo,
Chris Lattner4c97d762009-04-12 21:49:30 +00002835 AccessSpecifier AS) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002836 // Parse the tag portion of this.
Douglas Gregor374929f2009-09-18 15:37:17 +00002837 if (Tok.is(tok::code_completion)) {
2838 // Code completion for an enum name.
Douglas Gregor23c94db2010-07-02 17:43:08 +00002839 Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00002840 return cutOffParsing();
Douglas Gregor374929f2009-09-18 15:37:17 +00002841 }
John McCall57c13002011-07-06 05:58:41 +00002842
2843 bool IsScopedEnum = false;
2844 bool IsScopedUsingClassTag = false;
2845
2846 if (getLang().CPlusPlus0x &&
2847 (Tok.is(tok::kw_class) || Tok.is(tok::kw_struct))) {
Richard Smith7fe62082011-10-15 05:09:34 +00002848 Diag(Tok, diag::warn_cxx98_compat_scoped_enum);
John McCall57c13002011-07-06 05:58:41 +00002849 IsScopedEnum = true;
2850 IsScopedUsingClassTag = Tok.is(tok::kw_class);
2851 ConsumeToken();
2852 }
Douglas Gregor374929f2009-09-18 15:37:17 +00002853
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00002854 // If attributes exist after tag, parse them.
John McCall0b7e6782011-03-24 11:26:52 +00002855 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00002856 MaybeParseGNUAttributes(attrs);
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002857
Douglas Gregor5471bc82011-09-08 17:18:35 +00002858 bool AllowFixedUnderlyingType
Francois Pichet62ec1f22011-09-17 17:15:52 +00002859 = getLang().CPlusPlus0x || getLang().MicrosoftExt || getLang().ObjC2;
John McCall57c13002011-07-06 05:58:41 +00002860
Abramo Bagnarae4da7a02010-05-19 21:37:53 +00002861 CXXScopeSpec &SS = DS.getTypeSpecScope();
John McCall9ba61662010-02-26 08:45:28 +00002862 if (getLang().CPlusPlus) {
John McCall57c13002011-07-06 05:58:41 +00002863 // "enum foo : bar;" is not a potential typo for "enum foo::bar;"
2864 // if a fixed underlying type is allowed.
2865 ColonProtectionRAIIObject X(*this, AllowFixedUnderlyingType);
2866
Douglas Gregorefaa93a2011-11-07 17:33:42 +00002867 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
2868 /*EnteringContext=*/false))
John McCall9ba61662010-02-26 08:45:28 +00002869 return;
2870
2871 if (SS.isSet() && Tok.isNot(tok::identifier)) {
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002872 Diag(Tok, diag::err_expected_ident);
2873 if (Tok.isNot(tok::l_brace)) {
2874 // Has no name and is not a definition.
2875 // Skip the rest of this declarator, up until the comma or semicolon.
2876 SkipUntil(tok::comma, true);
2877 return;
2878 }
2879 }
2880 }
Mike Stump1eb44332009-09-09 15:08:12 +00002881
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00002882 // Must have either 'enum name' or 'enum {...}'.
Douglas Gregorb9075602011-02-22 02:55:24 +00002883 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) &&
2884 (AllowFixedUnderlyingType && Tok.isNot(tok::colon))) {
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00002885 Diag(Tok, diag::err_expected_ident_lbrace);
Mike Stump1eb44332009-09-09 15:08:12 +00002886
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00002887 // Skip the rest of this declarator, up until the comma or semicolon.
2888 SkipUntil(tok::comma, true);
Reid Spencer5f016e22007-07-11 17:01:13 +00002889 return;
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00002890 }
Mike Stump1eb44332009-09-09 15:08:12 +00002891
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00002892 // If an identifier is present, consume and remember it.
2893 IdentifierInfo *Name = 0;
2894 SourceLocation NameLoc;
2895 if (Tok.is(tok::identifier)) {
2896 Name = Tok.getIdentifierInfo();
2897 NameLoc = ConsumeToken();
2898 }
Mike Stump1eb44332009-09-09 15:08:12 +00002899
Douglas Gregor1274ccd2010-10-08 23:50:27 +00002900 if (!Name && IsScopedEnum) {
2901 // C++0x 7.2p2: The optional identifier shall not be omitted in the
2902 // declaration of a scoped enumeration.
2903 Diag(Tok, diag::err_scoped_enum_missing_identifier);
2904 IsScopedEnum = false;
Abramo Bagnaraa88cefd2010-12-03 18:54:17 +00002905 IsScopedUsingClassTag = false;
Douglas Gregor1274ccd2010-10-08 23:50:27 +00002906 }
2907
2908 TypeResult BaseType;
2909
Douglas Gregora61b3e72010-12-01 17:42:47 +00002910 // Parse the fixed underlying type.
Douglas Gregorb9075602011-02-22 02:55:24 +00002911 if (AllowFixedUnderlyingType && Tok.is(tok::colon)) {
Douglas Gregora61b3e72010-12-01 17:42:47 +00002912 bool PossibleBitfield = false;
2913 if (getCurScope()->getFlags() & Scope::ClassScope) {
2914 // If we're in class scope, this can either be an enum declaration with
2915 // an underlying type, or a declaration of a bitfield member. We try to
2916 // use a simple disambiguation scheme first to catch the common cases
2917 // (integer literal, sizeof); if it's still ambiguous, we then consider
2918 // anything that's a simple-type-specifier followed by '(' as an
2919 // expression. This suffices because function types are not valid
2920 // underlying types anyway.
2921 TPResult TPR = isExpressionOrTypeSpecifierSimple(NextToken().getKind());
2922 // If the next token starts an expression, we know we're parsing a
2923 // bit-field. This is the common case.
2924 if (TPR == TPResult::True())
2925 PossibleBitfield = true;
2926 // If the next token starts a type-specifier-seq, it may be either a
2927 // a fixed underlying type or the start of a function-style cast in C++;
2928 // lookahead one more token to see if it's obvious that we have a
2929 // fixed underlying type.
2930 else if (TPR == TPResult::False() &&
2931 GetLookAheadToken(2).getKind() == tok::semi) {
2932 // Consume the ':'.
2933 ConsumeToken();
2934 } else {
2935 // We have the start of a type-specifier-seq, so we have to perform
2936 // tentative parsing to determine whether we have an expression or a
2937 // type.
2938 TentativeParsingAction TPA(*this);
2939
2940 // Consume the ':'.
2941 ConsumeToken();
2942
Douglas Gregor86f208c2011-02-22 20:32:04 +00002943 if ((getLang().CPlusPlus &&
2944 isCXXDeclarationSpecifier() != TPResult::True()) ||
2945 (!getLang().CPlusPlus && !isDeclarationSpecifier(true))) {
Douglas Gregora61b3e72010-12-01 17:42:47 +00002946 // We'll parse this as a bitfield later.
2947 PossibleBitfield = true;
2948 TPA.Revert();
2949 } else {
2950 // We have a type-specifier-seq.
2951 TPA.Commit();
2952 }
2953 }
2954 } else {
2955 // Consume the ':'.
2956 ConsumeToken();
2957 }
2958
2959 if (!PossibleBitfield) {
2960 SourceRange Range;
2961 BaseType = ParseTypeName(&Range);
Douglas Gregor86f208c2011-02-22 20:32:04 +00002962
Douglas Gregor5471bc82011-09-08 17:18:35 +00002963 if (!getLang().CPlusPlus0x && !getLang().ObjC2)
Douglas Gregor86f208c2011-02-22 20:32:04 +00002964 Diag(StartLoc, diag::ext_ms_enum_fixed_underlying_type)
2965 << Range;
Richard Smith7fe62082011-10-15 05:09:34 +00002966 if (getLang().CPlusPlus0x)
2967 Diag(StartLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type);
Douglas Gregora61b3e72010-12-01 17:42:47 +00002968 }
Douglas Gregor1274ccd2010-10-08 23:50:27 +00002969 }
2970
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00002971 // There are three options here. If we have 'enum foo;', then this is a
2972 // forward declaration. If we have 'enum foo {...' then this is a
2973 // definition. Otherwise we have something like 'enum foo xyz', a reference.
2974 //
2975 // This is needed to handle stuff like this right (C99 6.7.2.3p11):
2976 // enum foo {..}; void bar() { enum foo; } <- new foo in bar.
2977 // enum foo {..}; void bar() { enum foo x; } <- use of old foo.
2978 //
John McCallf312b1e2010-08-26 23:41:50 +00002979 Sema::TagUseKind TUK;
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00002980 if (Tok.is(tok::l_brace))
John McCallf312b1e2010-08-26 23:41:50 +00002981 TUK = Sema::TUK_Definition;
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00002982 else if (Tok.is(tok::semi))
John McCallf312b1e2010-08-26 23:41:50 +00002983 TUK = Sema::TUK_Declaration;
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00002984 else
John McCallf312b1e2010-08-26 23:41:50 +00002985 TUK = Sema::TUK_Reference;
Douglas Gregor8fc6d232010-05-03 17:48:54 +00002986
2987 // enums cannot be templates, although they can be referenced from a
2988 // template.
2989 if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
John McCallf312b1e2010-08-26 23:41:50 +00002990 TUK != Sema::TUK_Reference) {
Douglas Gregor8fc6d232010-05-03 17:48:54 +00002991 Diag(Tok, diag::err_enum_template);
2992
2993 // Skip the rest of this declarator, up until the comma or semicolon.
2994 SkipUntil(tok::comma, true);
2995 return;
2996 }
2997
Douglas Gregorb9075602011-02-22 02:55:24 +00002998 if (!Name && TUK != Sema::TUK_Definition) {
2999 Diag(Tok, diag::err_enumerator_unnamed_no_def);
3000
3001 // Skip the rest of this declarator, up until the comma or semicolon.
3002 SkipUntil(tok::comma, true);
3003 return;
3004 }
3005
Douglas Gregor402abb52009-05-28 23:31:59 +00003006 bool Owned = false;
John McCallc4e70192009-09-11 04:59:25 +00003007 bool IsDependent = false;
Douglas Gregor48c89f42010-04-24 16:38:41 +00003008 const char *PrevSpec = 0;
3009 unsigned DiagID;
John McCalld226f652010-08-21 09:40:31 +00003010 Decl *TagDecl = Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK,
John McCall7f040a92010-12-24 02:08:15 +00003011 StartLoc, SS, Name, NameLoc, attrs.getList(),
Douglas Gregore7612302011-09-09 19:05:14 +00003012 AS, DS.getModulePrivateSpecLoc(),
John McCallf312b1e2010-08-26 23:41:50 +00003013 MultiTemplateParamsArg(Actions),
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003014 Owned, IsDependent, IsScopedEnum,
Abramo Bagnaraa88cefd2010-12-03 18:54:17 +00003015 IsScopedUsingClassTag, BaseType);
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003016
Douglas Gregor48c89f42010-04-24 16:38:41 +00003017 if (IsDependent) {
3018 // This enum has a dependent nested-name-specifier. Handle it as a
3019 // dependent tag.
3020 if (!Name) {
3021 DS.SetTypeSpecError();
3022 Diag(Tok, diag::err_expected_type_name_after_typename);
3023 return;
3024 }
3025
Douglas Gregor23c94db2010-07-02 17:43:08 +00003026 TypeResult Type = Actions.ActOnDependentTag(getCurScope(), DeclSpec::TST_enum,
Douglas Gregor48c89f42010-04-24 16:38:41 +00003027 TUK, SS, Name, StartLoc,
3028 NameLoc);
3029 if (Type.isInvalid()) {
3030 DS.SetTypeSpecError();
3031 return;
3032 }
3033
Abramo Bagnara0daaf322011-03-16 20:16:18 +00003034 if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
3035 NameLoc.isValid() ? NameLoc : StartLoc,
3036 PrevSpec, DiagID, Type.get()))
Douglas Gregor48c89f42010-04-24 16:38:41 +00003037 Diag(StartLoc, DiagID) << PrevSpec;
3038
3039 return;
3040 }
Mike Stump1eb44332009-09-09 15:08:12 +00003041
John McCalld226f652010-08-21 09:40:31 +00003042 if (!TagDecl) {
Douglas Gregor48c89f42010-04-24 16:38:41 +00003043 // The action failed to produce an enumeration tag. If this is a
3044 // definition, consume the entire definition.
3045 if (Tok.is(tok::l_brace)) {
3046 ConsumeBrace();
3047 SkipUntil(tok::r_brace);
3048 }
3049
3050 DS.SetTypeSpecError();
3051 return;
3052 }
3053
Chris Lattner04d66662007-10-09 17:33:22 +00003054 if (Tok.is(tok::l_brace))
Reid Spencer5f016e22007-07-11 17:01:13 +00003055 ParseEnumBody(StartLoc, TagDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00003056
Abramo Bagnara0daaf322011-03-16 20:16:18 +00003057 if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
3058 NameLoc.isValid() ? NameLoc : StartLoc,
3059 PrevSpec, DiagID, TagDecl, Owned))
John McCallfec54012009-08-03 20:12:06 +00003060 Diag(StartLoc, DiagID) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00003061}
3062
3063/// ParseEnumBody - Parse a {} enclosed enumerator-list.
3064/// enumerator-list:
3065/// enumerator
3066/// enumerator-list ',' enumerator
3067/// enumerator:
3068/// enumeration-constant
3069/// enumeration-constant '=' constant-expression
3070/// enumeration-constant:
3071/// identifier
3072///
John McCalld226f652010-08-21 09:40:31 +00003073void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {
Douglas Gregor074149e2009-01-05 19:45:36 +00003074 // Enter the scope of the enum body and start the definition.
3075 ParseScope EnumScope(this, Scope::DeclScope);
Douglas Gregor23c94db2010-07-02 17:43:08 +00003076 Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl);
Douglas Gregor074149e2009-01-05 19:45:36 +00003077
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003078 BalancedDelimiterTracker T(*this, tok::l_brace);
3079 T.consumeOpen();
Mike Stump1eb44332009-09-09 15:08:12 +00003080
Chris Lattner7946dd32007-08-27 17:24:30 +00003081 // C does not allow an empty enumerator-list, C++ does [dcl.enum].
Chris Lattner04d66662007-10-09 17:33:22 +00003082 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus)
Fariborz Jahanian05115522010-05-28 22:23:22 +00003083 Diag(Tok, diag::error_empty_enum);
Mike Stump1eb44332009-09-09 15:08:12 +00003084
Chris Lattner5f9e2722011-07-23 10:55:15 +00003085 SmallVector<Decl *, 32> EnumConstantDecls;
Reid Spencer5f016e22007-07-11 17:01:13 +00003086
John McCalld226f652010-08-21 09:40:31 +00003087 Decl *LastEnumConstDecl = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00003088
Reid Spencer5f016e22007-07-11 17:01:13 +00003089 // Parse the enumerator-list.
Chris Lattner04d66662007-10-09 17:33:22 +00003090 while (Tok.is(tok::identifier)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003091 IdentifierInfo *Ident = Tok.getIdentifierInfo();
3092 SourceLocation IdentLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00003093
John McCall5b629aa2010-10-22 23:36:17 +00003094 // If attributes exist after the enumerator, parse them.
John McCall0b7e6782011-03-24 11:26:52 +00003095 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00003096 MaybeParseGNUAttributes(attrs);
John McCall5b629aa2010-10-22 23:36:17 +00003097
Reid Spencer5f016e22007-07-11 17:01:13 +00003098 SourceLocation EqualLoc;
John McCall60d7b3a2010-08-24 06:29:42 +00003099 ExprResult AssignedVal;
Chris Lattner04d66662007-10-09 17:33:22 +00003100 if (Tok.is(tok::equal)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003101 EqualLoc = ConsumeToken();
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00003102 AssignedVal = ParseConstantExpression();
3103 if (AssignedVal.isInvalid())
Reid Spencer5f016e22007-07-11 17:01:13 +00003104 SkipUntil(tok::comma, tok::r_brace, true, true);
Reid Spencer5f016e22007-07-11 17:01:13 +00003105 }
Mike Stump1eb44332009-09-09 15:08:12 +00003106
Reid Spencer5f016e22007-07-11 17:01:13 +00003107 // Install the enumerator constant into EnumDecl.
John McCalld226f652010-08-21 09:40:31 +00003108 Decl *EnumConstDecl = Actions.ActOnEnumConstant(getCurScope(), EnumDecl,
3109 LastEnumConstDecl,
3110 IdentLoc, Ident,
John McCall7f040a92010-12-24 02:08:15 +00003111 attrs.getList(), EqualLoc,
John McCalld226f652010-08-21 09:40:31 +00003112 AssignedVal.release());
Reid Spencer5f016e22007-07-11 17:01:13 +00003113 EnumConstantDecls.push_back(EnumConstDecl);
3114 LastEnumConstDecl = EnumConstDecl;
Mike Stump1eb44332009-09-09 15:08:12 +00003115
Douglas Gregor751f6922010-09-07 14:51:08 +00003116 if (Tok.is(tok::identifier)) {
3117 // We're missing a comma between enumerators.
3118 SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation);
3119 Diag(Loc, diag::err_enumerator_list_missing_comma)
3120 << FixItHint::CreateInsertion(Loc, ", ");
3121 continue;
3122 }
3123
Chris Lattner04d66662007-10-09 17:33:22 +00003124 if (Tok.isNot(tok::comma))
Reid Spencer5f016e22007-07-11 17:01:13 +00003125 break;
3126 SourceLocation CommaLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00003127
Richard Smith7fe62082011-10-15 05:09:34 +00003128 if (Tok.isNot(tok::identifier)) {
3129 if (!getLang().C99 && !getLang().CPlusPlus0x)
3130 Diag(CommaLoc, diag::ext_enumerator_list_comma)
3131 << getLang().CPlusPlus
3132 << FixItHint::CreateRemoval(CommaLoc);
3133 else if (getLang().CPlusPlus0x)
3134 Diag(CommaLoc, diag::warn_cxx98_compat_enumerator_list_comma)
3135 << FixItHint::CreateRemoval(CommaLoc);
3136 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003137 }
Mike Stump1eb44332009-09-09 15:08:12 +00003138
Reid Spencer5f016e22007-07-11 17:01:13 +00003139 // Eat the }.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003140 T.consumeClose();
Reid Spencer5f016e22007-07-11 17:01:13 +00003141
Reid Spencer5f016e22007-07-11 17:01:13 +00003142 // If attributes exist after the identifier list, parse them.
John McCall0b7e6782011-03-24 11:26:52 +00003143 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00003144 MaybeParseGNUAttributes(attrs);
Douglas Gregor72de6672009-01-08 20:45:30 +00003145
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003146 Actions.ActOnEnumBody(StartLoc, T.getOpenLocation(), T.getCloseLocation(),
3147 EnumDecl, EnumConstantDecls.data(),
3148 EnumConstantDecls.size(), getCurScope(),
3149 attrs.getList());
Mike Stump1eb44332009-09-09 15:08:12 +00003150
Douglas Gregor72de6672009-01-08 20:45:30 +00003151 EnumScope.Exit();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003152 Actions.ActOnTagFinishDefinition(getCurScope(), EnumDecl,
3153 T.getCloseLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00003154}
3155
3156/// isTypeSpecifierQualifier - Return true if the current token could be the
Steve Naroff5f8aa692008-02-11 23:15:56 +00003157/// start of a type-qualifier-list.
3158bool Parser::isTypeQualifier() const {
3159 switch (Tok.getKind()) {
3160 default: return false;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003161
3162 // type-qualifier only in OpenCL
3163 case tok::kw_private:
3164 return getLang().OpenCL;
3165
Steve Naroff5f8aa692008-02-11 23:15:56 +00003166 // type-qualifier
3167 case tok::kw_const:
3168 case tok::kw_volatile:
3169 case tok::kw_restrict:
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003170 case tok::kw___private:
3171 case tok::kw___local:
3172 case tok::kw___global:
3173 case tok::kw___constant:
3174 case tok::kw___read_only:
3175 case tok::kw___read_write:
3176 case tok::kw___write_only:
Steve Naroff5f8aa692008-02-11 23:15:56 +00003177 return true;
3178 }
3179}
3180
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003181/// isKnownToBeTypeSpecifier - Return true if we know that the specified token
3182/// is definitely a type-specifier. Return false if it isn't part of a type
3183/// specifier or if we're not sure.
3184bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const {
3185 switch (Tok.getKind()) {
3186 default: return false;
3187 // type-specifiers
3188 case tok::kw_short:
3189 case tok::kw_long:
Francois Pichet338d7f72011-04-28 01:59:37 +00003190 case tok::kw___int64:
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003191 case tok::kw_signed:
3192 case tok::kw_unsigned:
3193 case tok::kw__Complex:
3194 case tok::kw__Imaginary:
3195 case tok::kw_void:
3196 case tok::kw_char:
3197 case tok::kw_wchar_t:
3198 case tok::kw_char16_t:
3199 case tok::kw_char32_t:
3200 case tok::kw_int:
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00003201 case tok::kw_half:
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003202 case tok::kw_float:
3203 case tok::kw_double:
3204 case tok::kw_bool:
3205 case tok::kw__Bool:
3206 case tok::kw__Decimal32:
3207 case tok::kw__Decimal64:
3208 case tok::kw__Decimal128:
3209 case tok::kw___vector:
3210
3211 // struct-or-union-specifier (C99) or class-specifier (C++)
3212 case tok::kw_class:
3213 case tok::kw_struct:
3214 case tok::kw_union:
3215 // enum-specifier
3216 case tok::kw_enum:
3217
3218 // typedef-name
3219 case tok::annot_typename:
3220 return true;
3221 }
3222}
3223
Steve Naroff5f8aa692008-02-11 23:15:56 +00003224/// isTypeSpecifierQualifier - Return true if the current token could be the
Reid Spencer5f016e22007-07-11 17:01:13 +00003225/// start of a specifier-qualifier-list.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003226bool Parser::isTypeSpecifierQualifier() {
Reid Spencer5f016e22007-07-11 17:01:13 +00003227 switch (Tok.getKind()) {
3228 default: return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003229
Chris Lattner166a8fc2009-01-04 23:41:41 +00003230 case tok::identifier: // foo::bar
John Thompson82287d12010-02-05 00:12:22 +00003231 if (TryAltiVecVectorToken())
3232 return true;
3233 // Fall through.
Douglas Gregord57959a2009-03-27 23:10:48 +00003234 case tok::kw_typename: // typename T::type
Chris Lattner166a8fc2009-01-04 23:41:41 +00003235 // Annotate typenames and C++ scope specifiers. If we get one, just
3236 // recurse to handle whatever we get.
3237 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003238 return true;
3239 if (Tok.is(tok::identifier))
3240 return false;
3241 return isTypeSpecifierQualifier();
Douglas Gregord57959a2009-03-27 23:10:48 +00003242
Chris Lattner166a8fc2009-01-04 23:41:41 +00003243 case tok::coloncolon: // ::foo::bar
3244 if (NextToken().is(tok::kw_new) || // ::new
3245 NextToken().is(tok::kw_delete)) // ::delete
3246 return false;
3247
Chris Lattner166a8fc2009-01-04 23:41:41 +00003248 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003249 return true;
3250 return isTypeSpecifierQualifier();
Mike Stump1eb44332009-09-09 15:08:12 +00003251
Reid Spencer5f016e22007-07-11 17:01:13 +00003252 // GNU attributes support.
3253 case tok::kw___attribute:
Steve Naroffd1861fd2007-07-31 12:34:36 +00003254 // GNU typeof support.
3255 case tok::kw_typeof:
Mike Stump1eb44332009-09-09 15:08:12 +00003256
Reid Spencer5f016e22007-07-11 17:01:13 +00003257 // type-specifiers
3258 case tok::kw_short:
3259 case tok::kw_long:
Francois Pichet338d7f72011-04-28 01:59:37 +00003260 case tok::kw___int64:
Reid Spencer5f016e22007-07-11 17:01:13 +00003261 case tok::kw_signed:
3262 case tok::kw_unsigned:
3263 case tok::kw__Complex:
3264 case tok::kw__Imaginary:
3265 case tok::kw_void:
3266 case tok::kw_char:
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +00003267 case tok::kw_wchar_t:
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00003268 case tok::kw_char16_t:
3269 case tok::kw_char32_t:
Reid Spencer5f016e22007-07-11 17:01:13 +00003270 case tok::kw_int:
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00003271 case tok::kw_half:
Reid Spencer5f016e22007-07-11 17:01:13 +00003272 case tok::kw_float:
3273 case tok::kw_double:
Chris Lattner9298d962007-11-15 05:25:19 +00003274 case tok::kw_bool:
Reid Spencer5f016e22007-07-11 17:01:13 +00003275 case tok::kw__Bool:
3276 case tok::kw__Decimal32:
3277 case tok::kw__Decimal64:
3278 case tok::kw__Decimal128:
John Thompson82287d12010-02-05 00:12:22 +00003279 case tok::kw___vector:
Mike Stump1eb44332009-09-09 15:08:12 +00003280
Chris Lattner99dc9142008-04-13 18:59:07 +00003281 // struct-or-union-specifier (C99) or class-specifier (C++)
3282 case tok::kw_class:
Reid Spencer5f016e22007-07-11 17:01:13 +00003283 case tok::kw_struct:
3284 case tok::kw_union:
3285 // enum-specifier
3286 case tok::kw_enum:
Mike Stump1eb44332009-09-09 15:08:12 +00003287
Reid Spencer5f016e22007-07-11 17:01:13 +00003288 // type-qualifier
3289 case tok::kw_const:
3290 case tok::kw_volatile:
3291 case tok::kw_restrict:
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003292
3293 // typedef-name
Chris Lattnerb31757b2009-01-06 05:06:21 +00003294 case tok::annot_typename:
Reid Spencer5f016e22007-07-11 17:01:13 +00003295 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00003296
Chris Lattner7c186be2008-10-20 00:25:30 +00003297 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
3298 case tok::less:
3299 return getLang().ObjC1;
Mike Stump1eb44332009-09-09 15:08:12 +00003300
Steve Naroff239f0732008-12-25 14:16:32 +00003301 case tok::kw___cdecl:
3302 case tok::kw___stdcall:
3303 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00003304 case tok::kw___thiscall:
Eli Friedman290eeb02009-06-08 23:27:34 +00003305 case tok::kw___w64:
3306 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00003307 case tok::kw___ptr32:
Dawn Perchik52fc3142010-09-03 01:29:35 +00003308 case tok::kw___pascal:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00003309 case tok::kw___unaligned:
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003310
3311 case tok::kw___private:
3312 case tok::kw___local:
3313 case tok::kw___global:
3314 case tok::kw___constant:
3315 case tok::kw___read_only:
3316 case tok::kw___read_write:
3317 case tok::kw___write_only:
3318
Eli Friedman290eeb02009-06-08 23:27:34 +00003319 return true;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003320
3321 case tok::kw_private:
3322 return getLang().OpenCL;
Eli Friedmanb001de72011-10-06 23:00:33 +00003323
3324 // C1x _Atomic()
3325 case tok::kw__Atomic:
3326 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00003327 }
3328}
3329
3330/// isDeclarationSpecifier() - Return true if the current token is part of a
3331/// declaration specifier.
Douglas Gregor9497a732010-09-16 01:51:54 +00003332///
3333/// \param DisambiguatingWithExpression True to indicate that the purpose of
3334/// this check is to disambiguate between an expression and a declaration.
3335bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003336 switch (Tok.getKind()) {
3337 default: return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003338
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003339 case tok::kw_private:
3340 return getLang().OpenCL;
3341
Chris Lattner166a8fc2009-01-04 23:41:41 +00003342 case tok::identifier: // foo::bar
Steve Naroff61f72cb2009-03-09 21:12:44 +00003343 // Unfortunate hack to support "Class.factoryMethod" notation.
3344 if (getLang().ObjC1 && NextToken().is(tok::period))
3345 return false;
John Thompson82287d12010-02-05 00:12:22 +00003346 if (TryAltiVecVectorToken())
3347 return true;
3348 // Fall through.
Douglas Gregord57959a2009-03-27 23:10:48 +00003349 case tok::kw_typename: // typename T::type
Chris Lattner166a8fc2009-01-04 23:41:41 +00003350 // Annotate typenames and C++ scope specifiers. If we get one, just
3351 // recurse to handle whatever we get.
3352 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003353 return true;
3354 if (Tok.is(tok::identifier))
3355 return false;
Douglas Gregor9497a732010-09-16 01:51:54 +00003356
3357 // If we're in Objective-C and we have an Objective-C class type followed
3358 // by an identifier and then either ':' or ']', in a place where an
3359 // expression is permitted, then this is probably a class message send
3360 // missing the initial '['. In this case, we won't consider this to be
3361 // the start of a declaration.
3362 if (DisambiguatingWithExpression &&
3363 isStartOfObjCClassMessageMissingOpenBracket())
3364 return false;
3365
John McCall9ba61662010-02-26 08:45:28 +00003366 return isDeclarationSpecifier();
3367
Chris Lattner166a8fc2009-01-04 23:41:41 +00003368 case tok::coloncolon: // ::foo::bar
3369 if (NextToken().is(tok::kw_new) || // ::new
3370 NextToken().is(tok::kw_delete)) // ::delete
3371 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003372
Chris Lattner166a8fc2009-01-04 23:41:41 +00003373 // Annotate typenames and C++ scope specifiers. If we get one, just
3374 // recurse to handle whatever we get.
3375 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003376 return true;
3377 return isDeclarationSpecifier();
Mike Stump1eb44332009-09-09 15:08:12 +00003378
Reid Spencer5f016e22007-07-11 17:01:13 +00003379 // storage-class-specifier
3380 case tok::kw_typedef:
3381 case tok::kw_extern:
Steve Naroff8d54bf22007-12-18 00:16:02 +00003382 case tok::kw___private_extern__:
Reid Spencer5f016e22007-07-11 17:01:13 +00003383 case tok::kw_static:
3384 case tok::kw_auto:
3385 case tok::kw_register:
3386 case tok::kw___thread:
Mike Stump1eb44332009-09-09 15:08:12 +00003387
Douglas Gregor8d267c52011-09-09 02:06:17 +00003388 // Modules
3389 case tok::kw___module_private__:
3390
Reid Spencer5f016e22007-07-11 17:01:13 +00003391 // type-specifiers
3392 case tok::kw_short:
3393 case tok::kw_long:
Francois Pichet338d7f72011-04-28 01:59:37 +00003394 case tok::kw___int64:
Reid Spencer5f016e22007-07-11 17:01:13 +00003395 case tok::kw_signed:
3396 case tok::kw_unsigned:
3397 case tok::kw__Complex:
3398 case tok::kw__Imaginary:
3399 case tok::kw_void:
3400 case tok::kw_char:
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +00003401 case tok::kw_wchar_t:
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00003402 case tok::kw_char16_t:
3403 case tok::kw_char32_t:
3404
Reid Spencer5f016e22007-07-11 17:01:13 +00003405 case tok::kw_int:
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00003406 case tok::kw_half:
Reid Spencer5f016e22007-07-11 17:01:13 +00003407 case tok::kw_float:
3408 case tok::kw_double:
Chris Lattner9298d962007-11-15 05:25:19 +00003409 case tok::kw_bool:
Reid Spencer5f016e22007-07-11 17:01:13 +00003410 case tok::kw__Bool:
3411 case tok::kw__Decimal32:
3412 case tok::kw__Decimal64:
3413 case tok::kw__Decimal128:
John Thompson82287d12010-02-05 00:12:22 +00003414 case tok::kw___vector:
Mike Stump1eb44332009-09-09 15:08:12 +00003415
Chris Lattner99dc9142008-04-13 18:59:07 +00003416 // struct-or-union-specifier (C99) or class-specifier (C++)
3417 case tok::kw_class:
Reid Spencer5f016e22007-07-11 17:01:13 +00003418 case tok::kw_struct:
3419 case tok::kw_union:
3420 // enum-specifier
3421 case tok::kw_enum:
Mike Stump1eb44332009-09-09 15:08:12 +00003422
Reid Spencer5f016e22007-07-11 17:01:13 +00003423 // type-qualifier
3424 case tok::kw_const:
3425 case tok::kw_volatile:
3426 case tok::kw_restrict:
Steve Naroffd1861fd2007-07-31 12:34:36 +00003427
Reid Spencer5f016e22007-07-11 17:01:13 +00003428 // function-specifier
3429 case tok::kw_inline:
Douglas Gregorb48fe382008-10-31 09:07:45 +00003430 case tok::kw_virtual:
3431 case tok::kw_explicit:
Chris Lattnerd6c7c182007-08-09 16:40:21 +00003432
Peter Collingbournec6eb44b2011-04-15 00:35:57 +00003433 // static_assert-declaration
3434 case tok::kw__Static_assert:
3435
Chris Lattner1ef08762007-08-09 17:01:07 +00003436 // GNU typeof support.
3437 case tok::kw_typeof:
Mike Stump1eb44332009-09-09 15:08:12 +00003438
Chris Lattner1ef08762007-08-09 17:01:07 +00003439 // GNU attributes.
Chris Lattnerd6c7c182007-08-09 16:40:21 +00003440 case tok::kw___attribute:
Reid Spencer5f016e22007-07-11 17:01:13 +00003441 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00003442
Francois Pichete3d49b42011-06-19 08:02:06 +00003443 // C++0x decltype.
3444 case tok::kw_decltype:
3445 return true;
3446
Eli Friedmanb001de72011-10-06 23:00:33 +00003447 // C1x _Atomic()
3448 case tok::kw__Atomic:
3449 return true;
3450
Chris Lattnerf3948c42008-07-26 03:38:44 +00003451 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
3452 case tok::less:
3453 return getLang().ObjC1;
Mike Stump1eb44332009-09-09 15:08:12 +00003454
Douglas Gregord9d75e52011-04-27 05:41:15 +00003455 // typedef-name
3456 case tok::annot_typename:
3457 return !DisambiguatingWithExpression ||
3458 !isStartOfObjCClassMessageMissingOpenBracket();
3459
Steve Naroff47f52092009-01-06 19:34:12 +00003460 case tok::kw___declspec:
Steve Naroff239f0732008-12-25 14:16:32 +00003461 case tok::kw___cdecl:
3462 case tok::kw___stdcall:
3463 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00003464 case tok::kw___thiscall:
Eli Friedman290eeb02009-06-08 23:27:34 +00003465 case tok::kw___w64:
3466 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00003467 case tok::kw___ptr32:
Eli Friedman290eeb02009-06-08 23:27:34 +00003468 case tok::kw___forceinline:
Dawn Perchik52fc3142010-09-03 01:29:35 +00003469 case tok::kw___pascal:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00003470 case tok::kw___unaligned:
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003471
3472 case tok::kw___private:
3473 case tok::kw___local:
3474 case tok::kw___global:
3475 case tok::kw___constant:
3476 case tok::kw___read_only:
3477 case tok::kw___read_write:
3478 case tok::kw___write_only:
3479
Eli Friedman290eeb02009-06-08 23:27:34 +00003480 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00003481 }
3482}
3483
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003484bool Parser::isConstructorDeclarator() {
3485 TentativeParsingAction TPA(*this);
3486
3487 // Parse the C++ scope specifier.
3488 CXXScopeSpec SS;
Douglas Gregorefaa93a2011-11-07 17:33:42 +00003489 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
3490 /*EnteringContext=*/true)) {
John McCall9ba61662010-02-26 08:45:28 +00003491 TPA.Revert();
3492 return false;
3493 }
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003494
3495 // Parse the constructor name.
3496 if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id)) {
3497 // We already know that we have a constructor name; just consume
3498 // the token.
3499 ConsumeToken();
3500 } else {
3501 TPA.Revert();
3502 return false;
3503 }
3504
3505 // Current class name must be followed by a left parentheses.
3506 if (Tok.isNot(tok::l_paren)) {
3507 TPA.Revert();
3508 return false;
3509 }
3510 ConsumeParen();
3511
3512 // A right parentheses or ellipsis signals that we have a constructor.
3513 if (Tok.is(tok::r_paren) || Tok.is(tok::ellipsis)) {
3514 TPA.Revert();
3515 return true;
3516 }
3517
3518 // If we need to, enter the specified scope.
3519 DeclaratorScopeObj DeclScopeObj(*this, SS);
Douglas Gregor23c94db2010-07-02 17:43:08 +00003520 if (SS.isSet() && Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003521 DeclScopeObj.EnterDeclaratorScope();
3522
Francois Pichetdfaa5fb2011-01-31 04:54:32 +00003523 // Optionally skip Microsoft attributes.
John McCall0b7e6782011-03-24 11:26:52 +00003524 ParsedAttributes Attrs(AttrFactory);
Francois Pichetdfaa5fb2011-01-31 04:54:32 +00003525 MaybeParseMicrosoftAttributes(Attrs);
3526
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003527 // Check whether the next token(s) are part of a declaration
3528 // specifier, in which case we have the start of a parameter and,
3529 // therefore, we know that this is a constructor.
3530 bool IsConstructor = isDeclarationSpecifier();
3531 TPA.Revert();
3532 return IsConstructor;
3533}
Reid Spencer5f016e22007-07-11 17:01:13 +00003534
3535/// ParseTypeQualifierListOpt
Dawn Perchik52fc3142010-09-03 01:29:35 +00003536/// type-qualifier-list: [C99 6.7.5]
3537/// type-qualifier
3538/// [vendor] attributes
3539/// [ only if VendorAttributesAllowed=true ]
3540/// type-qualifier-list type-qualifier
3541/// [vendor] type-qualifier-list attributes
3542/// [ only if VendorAttributesAllowed=true ]
3543/// [C++0x] attribute-specifier[opt] is allowed before cv-qualifier-seq
3544/// [ only if CXX0XAttributesAllowed=true ]
3545/// Note: vendor can be GNU, MS, etc.
Reid Spencer5f016e22007-07-11 17:01:13 +00003546///
Dawn Perchik52fc3142010-09-03 01:29:35 +00003547void Parser::ParseTypeQualifierListOpt(DeclSpec &DS,
3548 bool VendorAttributesAllowed,
Sean Huntbbd37c62009-11-21 08:43:09 +00003549 bool CXX0XAttributesAllowed) {
3550 if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier()) {
3551 SourceLocation Loc = Tok.getLocation();
John McCall0b7e6782011-03-24 11:26:52 +00003552 ParsedAttributesWithRange attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00003553 ParseCXX0XAttributes(attrs);
Sean Huntbbd37c62009-11-21 08:43:09 +00003554 if (CXX0XAttributesAllowed)
John McCall7f040a92010-12-24 02:08:15 +00003555 DS.takeAttributesFrom(attrs);
Sean Huntbbd37c62009-11-21 08:43:09 +00003556 else
3557 Diag(Loc, diag::err_attributes_not_allowed);
3558 }
Abramo Bagnara796aa442011-03-12 11:17:06 +00003559
3560 SourceLocation EndLoc;
3561
Reid Spencer5f016e22007-07-11 17:01:13 +00003562 while (1) {
John McCallfec54012009-08-03 20:12:06 +00003563 bool isInvalid = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00003564 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00003565 unsigned DiagID = 0;
Reid Spencer5f016e22007-07-11 17:01:13 +00003566 SourceLocation Loc = Tok.getLocation();
3567
3568 switch (Tok.getKind()) {
Douglas Gregor1a480c42010-08-27 17:35:51 +00003569 case tok::code_completion:
3570 Actions.CodeCompleteTypeQualifiers(DS);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00003571 return cutOffParsing();
Douglas Gregor1a480c42010-08-27 17:35:51 +00003572
Reid Spencer5f016e22007-07-11 17:01:13 +00003573 case tok::kw_const:
John McCallfec54012009-08-03 20:12:06 +00003574 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, DiagID,
3575 getLang());
Reid Spencer5f016e22007-07-11 17:01:13 +00003576 break;
3577 case tok::kw_volatile:
John McCallfec54012009-08-03 20:12:06 +00003578 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
3579 getLang());
Reid Spencer5f016e22007-07-11 17:01:13 +00003580 break;
3581 case tok::kw_restrict:
John McCallfec54012009-08-03 20:12:06 +00003582 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
3583 getLang());
Reid Spencer5f016e22007-07-11 17:01:13 +00003584 break;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003585
3586 // OpenCL qualifiers:
3587 case tok::kw_private:
3588 if (!getLang().OpenCL)
3589 goto DoneWithTypeQuals;
3590 case tok::kw___private:
3591 case tok::kw___global:
3592 case tok::kw___local:
3593 case tok::kw___constant:
3594 case tok::kw___read_only:
3595 case tok::kw___write_only:
3596 case tok::kw___read_write:
3597 ParseOpenCLQualifiers(DS);
3598 break;
3599
Eli Friedman290eeb02009-06-08 23:27:34 +00003600 case tok::kw___w64:
Steve Naroff86bc6cf2008-12-25 14:41:26 +00003601 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00003602 case tok::kw___ptr32:
Steve Naroff239f0732008-12-25 14:16:32 +00003603 case tok::kw___cdecl:
3604 case tok::kw___stdcall:
3605 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00003606 case tok::kw___thiscall:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00003607 case tok::kw___unaligned:
Dawn Perchik52fc3142010-09-03 01:29:35 +00003608 if (VendorAttributesAllowed) {
John McCall7f040a92010-12-24 02:08:15 +00003609 ParseMicrosoftTypeAttributes(DS.getAttributes());
Eli Friedman290eeb02009-06-08 23:27:34 +00003610 continue;
3611 }
3612 goto DoneWithTypeQuals;
Dawn Perchik52fc3142010-09-03 01:29:35 +00003613 case tok::kw___pascal:
3614 if (VendorAttributesAllowed) {
John McCall7f040a92010-12-24 02:08:15 +00003615 ParseBorlandTypeAttributes(DS.getAttributes());
Dawn Perchik52fc3142010-09-03 01:29:35 +00003616 continue;
3617 }
3618 goto DoneWithTypeQuals;
Reid Spencer5f016e22007-07-11 17:01:13 +00003619 case tok::kw___attribute:
Dawn Perchik52fc3142010-09-03 01:29:35 +00003620 if (VendorAttributesAllowed) {
John McCall7f040a92010-12-24 02:08:15 +00003621 ParseGNUAttributes(DS.getAttributes());
Chris Lattner5a69d1c2008-12-18 07:02:59 +00003622 continue; // do *not* consume the next token!
3623 }
3624 // otherwise, FALL THROUGH!
3625 default:
Steve Naroff239f0732008-12-25 14:16:32 +00003626 DoneWithTypeQuals:
Chris Lattner5a69d1c2008-12-18 07:02:59 +00003627 // If this is not a type-qualifier token, we're done reading type
3628 // qualifiers. First verify that DeclSpec's are consistent.
Douglas Gregor9b3064b2009-04-01 22:41:11 +00003629 DS.Finish(Diags, PP);
Abramo Bagnara796aa442011-03-12 11:17:06 +00003630 if (EndLoc.isValid())
3631 DS.SetRangeEnd(EndLoc);
Chris Lattner5a69d1c2008-12-18 07:02:59 +00003632 return;
Reid Spencer5f016e22007-07-11 17:01:13 +00003633 }
Chris Lattnera1fcbad2008-12-18 06:50:14 +00003634
Reid Spencer5f016e22007-07-11 17:01:13 +00003635 // If the specifier combination wasn't legal, issue a diagnostic.
3636 if (isInvalid) {
3637 assert(PrevSpec && "Method did not return previous specifier!");
Chris Lattner1ab3b962008-11-18 07:48:38 +00003638 Diag(Tok, DiagID) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00003639 }
Abramo Bagnara796aa442011-03-12 11:17:06 +00003640 EndLoc = ConsumeToken();
Reid Spencer5f016e22007-07-11 17:01:13 +00003641 }
3642}
3643
3644
3645/// ParseDeclarator - Parse and verify a newly-initialized declarator.
3646///
3647void Parser::ParseDeclarator(Declarator &D) {
3648 /// This implements the 'declarator' production in the C grammar, then checks
3649 /// for well-formedness and issues diagnostics.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003650 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
Reid Spencer5f016e22007-07-11 17:01:13 +00003651}
3652
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003653/// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator
3654/// is parsed by the function passed to it. Pass null, and the direct-declarator
3655/// isn't parsed at all, making this function effectively parse the C++
Douglas Gregor2f1bc522008-11-07 20:08:42 +00003656/// ptr-operator production.
3657///
Richard Smith0706df42011-10-19 21:33:05 +00003658/// If the grammar of this construct is extended, matching changes must also be
3659/// made to TryParseDeclarator and MightBeDeclarator.
3660///
Sebastian Redlf30208a2009-01-24 21:16:55 +00003661/// declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
3662/// [C] pointer[opt] direct-declarator
3663/// [C++] direct-declarator
3664/// [C++] ptr-operator declarator
Reid Spencer5f016e22007-07-11 17:01:13 +00003665///
3666/// pointer: [C99 6.7.5]
3667/// '*' type-qualifier-list[opt]
3668/// '*' type-qualifier-list[opt] pointer
3669///
Douglas Gregor2f1bc522008-11-07 20:08:42 +00003670/// ptr-operator:
3671/// '*' cv-qualifier-seq[opt]
3672/// '&'
Sebastian Redl05532f22009-03-15 22:02:01 +00003673/// [C++0x] '&&'
Douglas Gregor2f1bc522008-11-07 20:08:42 +00003674/// [GNU] '&' restrict[opt] attributes[opt]
Sebastian Redl05532f22009-03-15 22:02:01 +00003675/// [GNU?] '&&' restrict[opt] attributes[opt]
Sebastian Redlf30208a2009-01-24 21:16:55 +00003676/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003677void Parser::ParseDeclaratorInternal(Declarator &D,
3678 DirectDeclParseFunction DirectDeclParser) {
Douglas Gregor91a28862009-08-26 14:27:30 +00003679 if (Diags.hasAllExtensionsSilenced())
3680 D.setExtension();
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003681
Sebastian Redlf30208a2009-01-24 21:16:55 +00003682 // C++ member pointers start with a '::' or a nested-name.
3683 // Member pointers get special handling, since there's no place for the
3684 // scope spec in the generic path below.
Chris Lattnerf919bfe2009-03-24 17:04:48 +00003685 if (getLang().CPlusPlus &&
3686 (Tok.is(tok::coloncolon) || Tok.is(tok::identifier) ||
3687 Tok.is(tok::annot_cxxscope))) {
Douglas Gregorefaa93a2011-11-07 17:33:42 +00003688 bool EnteringContext = D.getContext() == Declarator::FileContext ||
3689 D.getContext() == Declarator::MemberContext;
Sebastian Redlf30208a2009-01-24 21:16:55 +00003690 CXXScopeSpec SS;
Douglas Gregorefaa93a2011-11-07 17:33:42 +00003691 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext);
John McCall9ba61662010-02-26 08:45:28 +00003692
Jeffrey Yasskinedc28772010-04-07 23:29:58 +00003693 if (SS.isNotEmpty()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003694 if (Tok.isNot(tok::star)) {
Sebastian Redlf30208a2009-01-24 21:16:55 +00003695 // The scope spec really belongs to the direct-declarator.
3696 D.getCXXScopeSpec() = SS;
3697 if (DirectDeclParser)
3698 (this->*DirectDeclParser)(D);
3699 return;
3700 }
3701
3702 SourceLocation Loc = ConsumeToken();
Sebastian Redlab197ba2009-02-09 18:23:29 +00003703 D.SetRangeEnd(Loc);
John McCall0b7e6782011-03-24 11:26:52 +00003704 DeclSpec DS(AttrFactory);
Sebastian Redlf30208a2009-01-24 21:16:55 +00003705 ParseTypeQualifierListOpt(DS);
Sebastian Redlab197ba2009-02-09 18:23:29 +00003706 D.ExtendWithDeclSpec(DS);
Sebastian Redlf30208a2009-01-24 21:16:55 +00003707
3708 // Recurse to parse whatever is left.
3709 ParseDeclaratorInternal(D, DirectDeclParser);
3710
3711 // Sema will have to catch (syntactically invalid) pointers into global
3712 // scope. It has to catch pointers into namespace scope anyway.
3713 D.AddTypeInfo(DeclaratorChunk::getMemberPointer(SS,DS.getTypeQualifiers(),
John McCall0b7e6782011-03-24 11:26:52 +00003714 Loc),
3715 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00003716 /* Don't replace range end. */SourceLocation());
Sebastian Redlf30208a2009-01-24 21:16:55 +00003717 return;
3718 }
3719 }
3720
3721 tok::TokenKind Kind = Tok.getKind();
Steve Naroff5618bd42008-08-27 16:04:49 +00003722 // Not a pointer, C++ reference, or block.
Chris Lattner9af55002009-03-27 04:18:06 +00003723 if (Kind != tok::star && Kind != tok::caret &&
Chris Lattnerf919bfe2009-03-24 17:04:48 +00003724 (Kind != tok::amp || !getLang().CPlusPlus) &&
Sebastian Redl743de1f2009-03-23 00:00:23 +00003725 // We parse rvalue refs in C++03, because otherwise the errors are scary.
Chris Lattner9af55002009-03-27 04:18:06 +00003726 (Kind != tok::ampamp || !getLang().CPlusPlus)) {
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003727 if (DirectDeclParser)
3728 (this->*DirectDeclParser)(D);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00003729 return;
3730 }
Sebastian Redlf30208a2009-01-24 21:16:55 +00003731
Sebastian Redl05532f22009-03-15 22:02:01 +00003732 // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference,
3733 // '&&' -> rvalue reference
Sebastian Redl743de1f2009-03-23 00:00:23 +00003734 SourceLocation Loc = ConsumeToken(); // Eat the *, ^, & or &&.
Sebastian Redlab197ba2009-02-09 18:23:29 +00003735 D.SetRangeEnd(Loc);
Reid Spencer5f016e22007-07-11 17:01:13 +00003736
Chris Lattner9af55002009-03-27 04:18:06 +00003737 if (Kind == tok::star || Kind == tok::caret) {
Chris Lattner76549142008-02-21 01:32:26 +00003738 // Is a pointer.
John McCall0b7e6782011-03-24 11:26:52 +00003739 DeclSpec DS(AttrFactory);
Sebastian Redlf30208a2009-01-24 21:16:55 +00003740
Reid Spencer5f016e22007-07-11 17:01:13 +00003741 ParseTypeQualifierListOpt(DS);
Sebastian Redlab197ba2009-02-09 18:23:29 +00003742 D.ExtendWithDeclSpec(DS);
Sebastian Redlf30208a2009-01-24 21:16:55 +00003743
Reid Spencer5f016e22007-07-11 17:01:13 +00003744 // Recursively parse the declarator.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003745 ParseDeclaratorInternal(D, DirectDeclParser);
Steve Naroff5618bd42008-08-27 16:04:49 +00003746 if (Kind == tok::star)
3747 // Remember that we parsed a pointer type, and remember the type-quals.
3748 D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc,
Chandler Carruthd067c072011-02-23 18:51:59 +00003749 DS.getConstSpecLoc(),
3750 DS.getVolatileSpecLoc(),
John McCall0b7e6782011-03-24 11:26:52 +00003751 DS.getRestrictSpecLoc()),
3752 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00003753 SourceLocation());
Steve Naroff5618bd42008-08-27 16:04:49 +00003754 else
3755 // Remember that we parsed a Block type, and remember the type-quals.
Mike Stump1eb44332009-09-09 15:08:12 +00003756 D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(),
John McCall0b7e6782011-03-24 11:26:52 +00003757 Loc),
3758 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00003759 SourceLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00003760 } else {
3761 // Is a reference
John McCall0b7e6782011-03-24 11:26:52 +00003762 DeclSpec DS(AttrFactory);
Reid Spencer5f016e22007-07-11 17:01:13 +00003763
Sebastian Redl743de1f2009-03-23 00:00:23 +00003764 // Complain about rvalue references in C++03, but then go on and build
3765 // the declarator.
Richard Smith7fe62082011-10-15 05:09:34 +00003766 if (Kind == tok::ampamp)
3767 Diag(Loc, getLang().CPlusPlus0x ?
3768 diag::warn_cxx98_compat_rvalue_reference :
3769 diag::ext_rvalue_reference);
Sebastian Redl743de1f2009-03-23 00:00:23 +00003770
Reid Spencer5f016e22007-07-11 17:01:13 +00003771 // C++ 8.3.2p1: cv-qualified references are ill-formed except when the
3772 // cv-qualifiers are introduced through the use of a typedef or of a
3773 // template type argument, in which case the cv-qualifiers are ignored.
3774 //
3775 // [GNU] Retricted references are allowed.
3776 // [GNU] Attributes on references are allowed.
Sean Huntbbd37c62009-11-21 08:43:09 +00003777 // [C++0x] Attributes on references are not allowed.
3778 ParseTypeQualifierListOpt(DS, true, false);
Sebastian Redlab197ba2009-02-09 18:23:29 +00003779 D.ExtendWithDeclSpec(DS);
Reid Spencer5f016e22007-07-11 17:01:13 +00003780
3781 if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
3782 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
3783 Diag(DS.getConstSpecLoc(),
Chris Lattner1ab3b962008-11-18 07:48:38 +00003784 diag::err_invalid_reference_qualifier_application) << "const";
Reid Spencer5f016e22007-07-11 17:01:13 +00003785 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
3786 Diag(DS.getVolatileSpecLoc(),
Chris Lattner1ab3b962008-11-18 07:48:38 +00003787 diag::err_invalid_reference_qualifier_application) << "volatile";
Reid Spencer5f016e22007-07-11 17:01:13 +00003788 }
3789
3790 // Recursively parse the declarator.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003791 ParseDeclaratorInternal(D, DirectDeclParser);
Reid Spencer5f016e22007-07-11 17:01:13 +00003792
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00003793 if (D.getNumTypeObjects() > 0) {
3794 // C++ [dcl.ref]p4: There shall be no references to references.
3795 DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1);
3796 if (InnerChunk.Kind == DeclaratorChunk::Reference) {
Chris Lattnerda83bac2008-11-19 07:37:42 +00003797 if (const IdentifierInfo *II = D.getIdentifier())
3798 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
3799 << II;
3800 else
3801 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
3802 << "type name";
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00003803
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003804 // Once we've complained about the reference-to-reference, we
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00003805 // can go ahead and build the (technically ill-formed)
3806 // declarator: reference collapsing will take care of it.
3807 }
3808 }
3809
Reid Spencer5f016e22007-07-11 17:01:13 +00003810 // Remember that we parsed a reference type. It doesn't have type-quals.
Chris Lattner76549142008-02-21 01:32:26 +00003811 D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc,
Sebastian Redl05532f22009-03-15 22:02:01 +00003812 Kind == tok::amp),
John McCall0b7e6782011-03-24 11:26:52 +00003813 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00003814 SourceLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00003815 }
3816}
3817
3818/// ParseDirectDeclarator
3819/// direct-declarator: [C99 6.7.5]
Douglas Gregor42a552f2008-11-05 20:51:48 +00003820/// [C99] identifier
Reid Spencer5f016e22007-07-11 17:01:13 +00003821/// '(' declarator ')'
3822/// [GNU] '(' attributes declarator ')'
3823/// [C90] direct-declarator '[' constant-expression[opt] ']'
3824/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
3825/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
3826/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
3827/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
3828/// direct-declarator '(' parameter-type-list ')'
3829/// direct-declarator '(' identifier-list[opt] ')'
3830/// [GNU] direct-declarator '(' parameter-forward-declarations
3831/// parameter-type-list[opt] ')'
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00003832/// [C++] direct-declarator '(' parameter-declaration-clause ')'
3833/// cv-qualifier-seq[opt] exception-specification[opt]
Douglas Gregorb48fe382008-10-31 09:07:45 +00003834/// [C++] declarator-id
Douglas Gregor42a552f2008-11-05 20:51:48 +00003835///
3836/// declarator-id: [C++ 8]
Douglas Gregora8bc8c92010-12-23 22:44:42 +00003837/// '...'[opt] id-expression
Douglas Gregor42a552f2008-11-05 20:51:48 +00003838/// '::'[opt] nested-name-specifier[opt] type-name
3839///
3840/// id-expression: [C++ 5.1]
3841/// unqualified-id
Douglas Gregordb422df2009-09-25 21:45:23 +00003842/// qualified-id
Douglas Gregor42a552f2008-11-05 20:51:48 +00003843///
3844/// unqualified-id: [C++ 5.1]
Mike Stump1eb44332009-09-09 15:08:12 +00003845/// identifier
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003846/// operator-function-id
Douglas Gregordb422df2009-09-25 21:45:23 +00003847/// conversion-function-id
Mike Stump1eb44332009-09-09 15:08:12 +00003848/// '~' class-name
Douglas Gregor39a8de12009-02-25 19:37:18 +00003849/// template-id
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +00003850///
Reid Spencer5f016e22007-07-11 17:01:13 +00003851void Parser::ParseDirectDeclarator(Declarator &D) {
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00003852 DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec());
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003853
Douglas Gregor3f9a0562009-11-03 01:35:08 +00003854 if (getLang().CPlusPlus && D.mayHaveIdentifier()) {
3855 // ParseDeclaratorInternal might already have parsed the scope.
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00003856 if (D.getCXXScopeSpec().isEmpty()) {
Douglas Gregorefaa93a2011-11-07 17:33:42 +00003857 bool EnteringContext = D.getContext() == Declarator::FileContext ||
3858 D.getContext() == Declarator::MemberContext;
3859 ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec(), ParsedType(),
3860 EnteringContext);
John McCall9ba61662010-02-26 08:45:28 +00003861 }
3862
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00003863 if (D.getCXXScopeSpec().isValid()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00003864 if (Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec()))
John McCalle7e278b2009-12-11 20:04:54 +00003865 // Change the declaration context for name lookup, until this function
3866 // is exited (and the declarator has been parsed).
3867 DeclScopeObj.EnterDeclaratorScope();
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00003868 }
3869
Douglas Gregora8bc8c92010-12-23 22:44:42 +00003870 // C++0x [dcl.fct]p14:
3871 // There is a syntactic ambiguity when an ellipsis occurs at the end
3872 // of a parameter-declaration-clause without a preceding comma. In
3873 // this case, the ellipsis is parsed as part of the
3874 // abstract-declarator if the type of the parameter names a template
3875 // parameter pack that has not been expanded; otherwise, it is parsed
3876 // as part of the parameter-declaration-clause.
3877 if (Tok.is(tok::ellipsis) &&
3878 !((D.getContext() == Declarator::PrototypeContext ||
3879 D.getContext() == Declarator::BlockLiteralContext) &&
Douglas Gregora8bc8c92010-12-23 22:44:42 +00003880 NextToken().is(tok::r_paren) &&
3881 !Actions.containsUnexpandedParameterPacks(D)))
3882 D.setEllipsisLoc(ConsumeToken());
3883
Douglas Gregor3f9a0562009-11-03 01:35:08 +00003884 if (Tok.is(tok::identifier) || Tok.is(tok::kw_operator) ||
3885 Tok.is(tok::annot_template_id) || Tok.is(tok::tilde)) {
3886 // We found something that indicates the start of an unqualified-id.
3887 // Parse that unqualified-id.
John McCallba9d8532010-04-13 06:39:49 +00003888 bool AllowConstructorName;
3889 if (D.getDeclSpec().hasTypeSpecifier())
3890 AllowConstructorName = false;
3891 else if (D.getCXXScopeSpec().isSet())
3892 AllowConstructorName =
3893 (D.getContext() == Declarator::FileContext ||
3894 (D.getContext() == Declarator::MemberContext &&
3895 D.getDeclSpec().isFriendSpecified()));
3896 else
3897 AllowConstructorName = (D.getContext() == Declarator::MemberContext);
3898
Douglas Gregor3f9a0562009-11-03 01:35:08 +00003899 if (ParseUnqualifiedId(D.getCXXScopeSpec(),
3900 /*EnteringContext=*/true,
3901 /*AllowDestructorName=*/true,
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003902 AllowConstructorName,
John McCallb3d87482010-08-24 05:47:05 +00003903 ParsedType(),
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00003904 D.getName()) ||
3905 // Once we're past the identifier, if the scope was bad, mark the
3906 // whole declarator bad.
3907 D.getCXXScopeSpec().isInvalid()) {
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00003908 D.SetIdentifier(0, Tok.getLocation());
3909 D.setInvalidType(true);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00003910 } else {
3911 // Parsed the unqualified-id; update range information and move along.
3912 if (D.getSourceRange().getBegin().isInvalid())
3913 D.SetRangeBegin(D.getName().getSourceRange().getBegin());
3914 D.SetRangeEnd(D.getName().getSourceRange().getEnd());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00003915 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00003916 goto PastIdentifier;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00003917 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00003918 } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00003919 assert(!getLang().CPlusPlus &&
3920 "There's a C++-specific check for tok::identifier above");
3921 assert(Tok.getIdentifierInfo() && "Not an identifier?");
3922 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
3923 ConsumeToken();
Douglas Gregor3f9a0562009-11-03 01:35:08 +00003924 goto PastIdentifier;
3925 }
3926
3927 if (Tok.is(tok::l_paren)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003928 // direct-declarator: '(' declarator ')'
3929 // direct-declarator: '(' attributes declarator ')'
3930 // Example: 'char (*X)' or 'int (*XX)(void)'
3931 ParseParenDeclarator(D);
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003932
3933 // If the declarator was parenthesized, we entered the declarator
3934 // scope when parsing the parenthesized declarator, then exited
3935 // the scope already. Re-enter the scope, if we need to.
3936 if (D.getCXXScopeSpec().isSet()) {
Fariborz Jahanian46877cd2010-08-17 23:50:37 +00003937 // If there was an error parsing parenthesized declarator, declarator
3938 // scope may have been enterred before. Don't do it again.
3939 if (!D.isInvalidType() &&
3940 Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec()))
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003941 // Change the declaration context for name lookup, until this function
3942 // is exited (and the declarator has been parsed).
Fariborz Jahanian46877cd2010-08-17 23:50:37 +00003943 DeclScopeObj.EnterDeclaratorScope();
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003944 }
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00003945 } else if (D.mayOmitIdentifier()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003946 // This could be something simple like "int" (in which case the declarator
3947 // portion is empty), if an abstract-declarator is allowed.
3948 D.SetIdentifier(0, Tok.getLocation());
3949 } else {
Douglas Gregore950d4b2009-03-06 23:28:18 +00003950 if (D.getContext() == Declarator::MemberContext)
3951 Diag(Tok, diag::err_expected_member_name_or_semi)
3952 << D.getDeclSpec().getSourceRange();
3953 else if (getLang().CPlusPlus)
Douglas Gregor2d1c2142009-11-03 19:44:04 +00003954 Diag(Tok, diag::err_expected_unqualified_id) << getLang().CPlusPlus;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003955 else
Chris Lattner1ab3b962008-11-18 07:48:38 +00003956 Diag(Tok, diag::err_expected_ident_lparen);
Reid Spencer5f016e22007-07-11 17:01:13 +00003957 D.SetIdentifier(0, Tok.getLocation());
Chris Lattner1f6f54b2008-11-11 06:13:16 +00003958 D.setInvalidType(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00003959 }
Mike Stump1eb44332009-09-09 15:08:12 +00003960
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00003961 PastIdentifier:
Reid Spencer5f016e22007-07-11 17:01:13 +00003962 assert(D.isPastIdentifier() &&
3963 "Haven't past the location of the identifier yet?");
Mike Stump1eb44332009-09-09 15:08:12 +00003964
Sean Huntbbd37c62009-11-21 08:43:09 +00003965 // Don't parse attributes unless we have an identifier.
John McCall7f040a92010-12-24 02:08:15 +00003966 if (D.getIdentifier())
3967 MaybeParseCXX0XAttributes(D);
Sean Huntbbd37c62009-11-21 08:43:09 +00003968
Reid Spencer5f016e22007-07-11 17:01:13 +00003969 while (1) {
Chris Lattner04d66662007-10-09 17:33:22 +00003970 if (Tok.is(tok::l_paren)) {
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00003971 // The paren may be part of a C++ direct initializer, eg. "int x(1);".
3972 // In such a case, check if we actually have a function declarator; if it
3973 // is not, the declarator has been fully parsed.
Chris Lattner7399ee02008-10-20 02:05:46 +00003974 if (getLang().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) {
3975 // When not in file scope, warn for ambiguous function declarators, just
3976 // in case the author intended it as a variable definition.
3977 bool warnIfAmbiguous = D.getContext() != Declarator::FileContext;
3978 if (!isCXXFunctionDeclarator(warnIfAmbiguous))
3979 break;
3980 }
John McCall0b7e6782011-03-24 11:26:52 +00003981 ParsedAttributes attrs(AttrFactory);
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003982 BalancedDelimiterTracker T(*this, tok::l_paren);
3983 T.consumeOpen();
3984 ParseFunctionDeclarator(D, attrs, T);
Chris Lattner04d66662007-10-09 17:33:22 +00003985 } else if (Tok.is(tok::l_square)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003986 ParseBracketDeclarator(D);
3987 } else {
3988 break;
3989 }
3990 }
3991}
3992
Chris Lattneref4715c2008-04-06 05:45:57 +00003993/// ParseParenDeclarator - We parsed the declarator D up to a paren. This is
3994/// only called before the identifier, so these are most likely just grouping
Mike Stump1eb44332009-09-09 15:08:12 +00003995/// parens for precedence. If we find that these are actually function
Chris Lattneref4715c2008-04-06 05:45:57 +00003996/// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator.
3997///
3998/// direct-declarator:
3999/// '(' declarator ')'
4000/// [GNU] '(' attributes declarator ')'
Chris Lattner7399ee02008-10-20 02:05:46 +00004001/// direct-declarator '(' parameter-type-list ')'
4002/// direct-declarator '(' identifier-list[opt] ')'
4003/// [GNU] direct-declarator '(' parameter-forward-declarations
4004/// parameter-type-list[opt] ')'
Chris Lattneref4715c2008-04-06 05:45:57 +00004005///
4006void Parser::ParseParenDeclarator(Declarator &D) {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004007 BalancedDelimiterTracker T(*this, tok::l_paren);
4008 T.consumeOpen();
4009
Chris Lattneref4715c2008-04-06 05:45:57 +00004010 assert(!D.isPastIdentifier() && "Should be called before passing identifier");
Mike Stump1eb44332009-09-09 15:08:12 +00004011
Chris Lattner7399ee02008-10-20 02:05:46 +00004012 // Eat any attributes before we look at whether this is a grouping or function
4013 // declarator paren. If this is a grouping paren, the attribute applies to
4014 // the type being built up, for example:
4015 // int (__attribute__(()) *x)(long y)
4016 // If this ends up not being a grouping paren, the attribute applies to the
4017 // first argument, for example:
4018 // int (__attribute__(()) int x)
4019 // In either case, we need to eat any attributes to be able to determine what
4020 // sort of paren this is.
4021 //
John McCall0b7e6782011-03-24 11:26:52 +00004022 ParsedAttributes attrs(AttrFactory);
Chris Lattner7399ee02008-10-20 02:05:46 +00004023 bool RequiresArg = false;
4024 if (Tok.is(tok::kw___attribute)) {
John McCall7f040a92010-12-24 02:08:15 +00004025 ParseGNUAttributes(attrs);
Mike Stump1eb44332009-09-09 15:08:12 +00004026
Chris Lattner7399ee02008-10-20 02:05:46 +00004027 // We require that the argument list (if this is a non-grouping paren) be
4028 // present even if the attribute list was empty.
4029 RequiresArg = true;
4030 }
Steve Naroff239f0732008-12-25 14:16:32 +00004031 // Eat any Microsoft extensions.
Eli Friedman290eeb02009-06-08 23:27:34 +00004032 if (Tok.is(tok::kw___cdecl) || Tok.is(tok::kw___stdcall) ||
Douglas Gregorf813a2c2010-05-18 16:57:00 +00004033 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___fastcall) ||
Francois Pichet3bd9aa42011-08-18 09:59:55 +00004034 Tok.is(tok::kw___w64) || Tok.is(tok::kw___ptr64) ||
Francois Pichet58fd97a2011-08-25 00:36:46 +00004035 Tok.is(tok::kw___ptr32) || Tok.is(tok::kw___unaligned)) {
John McCall7f040a92010-12-24 02:08:15 +00004036 ParseMicrosoftTypeAttributes(attrs);
Eli Friedman290eeb02009-06-08 23:27:34 +00004037 }
Dawn Perchik52fc3142010-09-03 01:29:35 +00004038 // Eat any Borland extensions.
Ted Kremenek8113ecf2010-11-10 05:59:39 +00004039 if (Tok.is(tok::kw___pascal))
John McCall7f040a92010-12-24 02:08:15 +00004040 ParseBorlandTypeAttributes(attrs);
Mike Stump1eb44332009-09-09 15:08:12 +00004041
Chris Lattneref4715c2008-04-06 05:45:57 +00004042 // If we haven't past the identifier yet (or where the identifier would be
4043 // stored, if this is an abstract declarator), then this is probably just
4044 // grouping parens. However, if this could be an abstract-declarator, then
4045 // this could also be the start of function arguments (consider 'void()').
4046 bool isGrouping;
Mike Stump1eb44332009-09-09 15:08:12 +00004047
Chris Lattneref4715c2008-04-06 05:45:57 +00004048 if (!D.mayOmitIdentifier()) {
4049 // If this can't be an abstract-declarator, this *must* be a grouping
4050 // paren, because we haven't seen the identifier yet.
4051 isGrouping = true;
4052 } else if (Tok.is(tok::r_paren) || // 'int()' is a function.
Argyrios Kyrtzidise25d2702008-10-06 00:07:55 +00004053 (getLang().CPlusPlus && Tok.is(tok::ellipsis)) || // C++ int(...)
Chris Lattneref4715c2008-04-06 05:45:57 +00004054 isDeclarationSpecifier()) { // 'int(int)' is a function.
4055 // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is
4056 // considered to be a type, not a K&R identifier-list.
4057 isGrouping = false;
4058 } else {
4059 // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'.
4060 isGrouping = true;
4061 }
Mike Stump1eb44332009-09-09 15:08:12 +00004062
Chris Lattneref4715c2008-04-06 05:45:57 +00004063 // If this is a grouping paren, handle:
4064 // direct-declarator: '(' declarator ')'
4065 // direct-declarator: '(' attributes declarator ')'
4066 if (isGrouping) {
Argyrios Kyrtzidis3f2a8a02008-10-07 10:21:57 +00004067 bool hadGroupingParens = D.hasGroupingParens();
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004068 D.setGroupingParens(true);
4069
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004070 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
Chris Lattneref4715c2008-04-06 05:45:57 +00004071 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004072 T.consumeClose();
4073 D.AddTypeInfo(DeclaratorChunk::getParen(T.getOpenLocation(),
4074 T.getCloseLocation()),
4075 attrs, T.getCloseLocation());
Argyrios Kyrtzidis3f2a8a02008-10-07 10:21:57 +00004076
4077 D.setGroupingParens(hadGroupingParens);
Chris Lattneref4715c2008-04-06 05:45:57 +00004078 return;
4079 }
Mike Stump1eb44332009-09-09 15:08:12 +00004080
Chris Lattneref4715c2008-04-06 05:45:57 +00004081 // Okay, if this wasn't a grouping paren, it must be the start of a function
4082 // argument list. Recognize that this declarator will never have an
Chris Lattner7399ee02008-10-20 02:05:46 +00004083 // identifier (and remember where it would have been), then call into
4084 // ParseFunctionDeclarator to handle of argument list.
Chris Lattneref4715c2008-04-06 05:45:57 +00004085 D.SetIdentifier(0, Tok.getLocation());
4086
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004087 ParseFunctionDeclarator(D, attrs, T, RequiresArg);
Chris Lattneref4715c2008-04-06 05:45:57 +00004088}
4089
4090/// ParseFunctionDeclarator - We are after the identifier and have parsed the
4091/// declarator D up to a paren, which indicates that we are parsing function
4092/// arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00004093///
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004094/// If attrs is non-null, then the caller parsed those arguments immediately
Chris Lattner7399ee02008-10-20 02:05:46 +00004095/// after the open paren - they should be considered to be the first argument of
4096/// a parameter. If RequiresArg is true, then the first argument of the
4097/// function is required to be present and required to not be an identifier
4098/// list.
4099///
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004100/// For C++, after the parameter-list, it also parses cv-qualifier-seq[opt],
4101/// (C++0x) ref-qualifier[opt], exception-specification[opt], and
4102/// (C++0x) trailing-return-type[opt].
4103///
4104/// [C++0x] exception-specification:
4105/// dynamic-exception-specification
4106/// noexcept-specification
4107///
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004108void Parser::ParseFunctionDeclarator(Declarator &D,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004109 ParsedAttributes &attrs,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004110 BalancedDelimiterTracker &Tracker,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004111 bool RequiresArg) {
4112 // lparen is already consumed!
4113 assert(D.isPastIdentifier() && "Should not call before identifier!");
4114
4115 // This should be true when the function has typed arguments.
4116 // Otherwise, it is treated as a K&R-style function.
4117 bool HasProto = false;
4118 // Build up an array of information about the parsed arguments.
Chris Lattner5f9e2722011-07-23 10:55:15 +00004119 SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004120 // Remember where we see an ellipsis, if any.
4121 SourceLocation EllipsisLoc;
4122
4123 DeclSpec DS(AttrFactory);
4124 bool RefQualifierIsLValueRef = true;
4125 SourceLocation RefQualifierLoc;
Douglas Gregor43f51032011-10-19 06:04:55 +00004126 SourceLocation ConstQualifierLoc;
4127 SourceLocation VolatileQualifierLoc;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004128 ExceptionSpecificationType ESpecType = EST_None;
4129 SourceRange ESpecRange;
Chris Lattner5f9e2722011-07-23 10:55:15 +00004130 SmallVector<ParsedType, 2> DynamicExceptions;
4131 SmallVector<SourceRange, 2> DynamicExceptionRanges;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004132 ExprResult NoexceptExpr;
4133 ParsedType TrailingReturnType;
4134
4135 SourceLocation EndLoc;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004136 if (isFunctionDeclaratorIdentifierList()) {
4137 if (RequiresArg)
4138 Diag(Tok, diag::err_argument_required_after_attribute);
4139
4140 ParseFunctionDeclaratorIdentifierList(D, ParamInfo);
4141
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004142 Tracker.consumeClose();
4143 EndLoc = Tracker.getCloseLocation();
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004144 } else {
4145 // Enter function-declaration scope, limiting any declarators to the
4146 // function prototype scope, including parameter declarators.
4147 ParseScope PrototypeScope(this,
4148 Scope::FunctionPrototypeScope|Scope::DeclScope);
4149
4150 if (Tok.isNot(tok::r_paren))
4151 ParseParameterDeclarationClause(D, attrs, ParamInfo, EllipsisLoc);
4152 else if (RequiresArg)
4153 Diag(Tok, diag::err_argument_required_after_attribute);
4154
4155 HasProto = ParamInfo.size() || getLang().CPlusPlus;
4156
4157 // If we have the closing ')', eat it.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004158 Tracker.consumeClose();
4159 EndLoc = Tracker.getCloseLocation();
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004160
4161 if (getLang().CPlusPlus) {
4162 MaybeParseCXX0XAttributes(attrs);
4163
4164 // Parse cv-qualifier-seq[opt].
4165 ParseTypeQualifierListOpt(DS, false /*no attributes*/);
Douglas Gregor43f51032011-10-19 06:04:55 +00004166 if (!DS.getSourceRange().getEnd().isInvalid()) {
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004167 EndLoc = DS.getSourceRange().getEnd();
Douglas Gregor43f51032011-10-19 06:04:55 +00004168 ConstQualifierLoc = DS.getConstSpecLoc();
4169 VolatileQualifierLoc = DS.getVolatileSpecLoc();
4170 }
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004171
4172 // Parse ref-qualifier[opt].
4173 if (Tok.is(tok::amp) || Tok.is(tok::ampamp)) {
Richard Smith7fe62082011-10-15 05:09:34 +00004174 Diag(Tok, getLang().CPlusPlus0x ?
4175 diag::warn_cxx98_compat_ref_qualifier :
4176 diag::ext_ref_qualifier);
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004177
4178 RefQualifierIsLValueRef = Tok.is(tok::amp);
4179 RefQualifierLoc = ConsumeToken();
4180 EndLoc = RefQualifierLoc;
4181 }
4182
4183 // Parse exception-specification[opt].
4184 ESpecType = MaybeParseExceptionSpecification(ESpecRange,
4185 DynamicExceptions,
4186 DynamicExceptionRanges,
4187 NoexceptExpr);
4188 if (ESpecType != EST_None)
4189 EndLoc = ESpecRange.getEnd();
4190
4191 // Parse trailing-return-type[opt].
4192 if (getLang().CPlusPlus0x && Tok.is(tok::arrow)) {
Richard Smith7fe62082011-10-15 05:09:34 +00004193 Diag(Tok, diag::warn_cxx98_compat_trailing_return_type);
Douglas Gregorae7902c2011-08-04 15:30:47 +00004194 SourceRange Range;
4195 TrailingReturnType = ParseTrailingReturnType(Range).get();
4196 if (Range.getEnd().isValid())
4197 EndLoc = Range.getEnd();
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004198 }
4199 }
4200
4201 // Leave prototype scope.
4202 PrototypeScope.Exit();
4203 }
4204
4205 // Remember that we parsed a function type, and remember the attributes.
4206 D.AddTypeInfo(DeclaratorChunk::getFunction(HasProto,
4207 /*isVariadic=*/EllipsisLoc.isValid(),
4208 EllipsisLoc,
4209 ParamInfo.data(), ParamInfo.size(),
4210 DS.getTypeQualifiers(),
4211 RefQualifierIsLValueRef,
Douglas Gregor43f51032011-10-19 06:04:55 +00004212 RefQualifierLoc, ConstQualifierLoc,
4213 VolatileQualifierLoc,
Douglas Gregor90ebed02011-07-13 21:47:47 +00004214 /*MutableLoc=*/SourceLocation(),
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004215 ESpecType, ESpecRange.getBegin(),
4216 DynamicExceptions.data(),
4217 DynamicExceptionRanges.data(),
4218 DynamicExceptions.size(),
4219 NoexceptExpr.isUsable() ?
4220 NoexceptExpr.get() : 0,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004221 Tracker.getOpenLocation(),
4222 EndLoc, D,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004223 TrailingReturnType),
4224 attrs, EndLoc);
4225}
4226
4227/// isFunctionDeclaratorIdentifierList - This parameter list may have an
4228/// identifier list form for a K&R-style function: void foo(a,b,c)
4229///
4230/// Note that identifier-lists are only allowed for normal declarators, not for
4231/// abstract-declarators.
4232bool Parser::isFunctionDeclaratorIdentifierList() {
4233 return !getLang().CPlusPlus
4234 && Tok.is(tok::identifier)
4235 && !TryAltiVecVectorToken()
4236 // K&R identifier lists can't have typedefs as identifiers, per C99
4237 // 6.7.5.3p11.
4238 && (TryAnnotateTypeOrScopeToken() || !Tok.is(tok::annot_typename))
4239 // Identifier lists follow a really simple grammar: the identifiers can
4240 // be followed *only* by a ", identifier" or ")". However, K&R
4241 // identifier lists are really rare in the brave new modern world, and
4242 // it is very common for someone to typo a type in a non-K&R style
4243 // list. If we are presented with something like: "void foo(intptr x,
4244 // float y)", we don't want to start parsing the function declarator as
4245 // though it is a K&R style declarator just because intptr is an
4246 // invalid type.
4247 //
4248 // To handle this, we check to see if the token after the first
4249 // identifier is a "," or ")". Only then do we parse it as an
4250 // identifier list.
4251 && (NextToken().is(tok::comma) || NextToken().is(tok::r_paren));
4252}
4253
4254/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator
4255/// we found a K&R-style identifier list instead of a typed parameter list.
4256///
4257/// After returning, ParamInfo will hold the parsed parameters.
4258///
4259/// identifier-list: [C99 6.7.5]
4260/// identifier
4261/// identifier-list ',' identifier
4262///
4263void Parser::ParseFunctionDeclaratorIdentifierList(
4264 Declarator &D,
Chris Lattner5f9e2722011-07-23 10:55:15 +00004265 SmallVector<DeclaratorChunk::ParamInfo, 16> &ParamInfo) {
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004266 // If there was no identifier specified for the declarator, either we are in
4267 // an abstract-declarator, or we are in a parameter declarator which was found
4268 // to be abstract. In abstract-declarators, identifier lists are not valid:
4269 // diagnose this.
4270 if (!D.getIdentifier())
4271 Diag(Tok, diag::ext_ident_list_in_param);
4272
4273 // Maintain an efficient lookup of params we have seen so far.
4274 llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
4275
4276 while (1) {
4277 // If this isn't an identifier, report the error and skip until ')'.
4278 if (Tok.isNot(tok::identifier)) {
4279 Diag(Tok, diag::err_expected_ident);
4280 SkipUntil(tok::r_paren, /*StopAtSemi=*/true, /*DontConsume=*/true);
4281 // Forget we parsed anything.
4282 ParamInfo.clear();
4283 return;
4284 }
4285
4286 IdentifierInfo *ParmII = Tok.getIdentifierInfo();
4287
4288 // Reject 'typedef int y; int test(x, y)', but continue parsing.
4289 if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope()))
4290 Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;
4291
4292 // Verify that the argument identifier has not already been mentioned.
4293 if (!ParamsSoFar.insert(ParmII)) {
4294 Diag(Tok, diag::err_param_redefinition) << ParmII;
4295 } else {
4296 // Remember this identifier in ParamInfo.
4297 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
4298 Tok.getLocation(),
4299 0));
4300 }
4301
4302 // Eat the identifier.
4303 ConsumeToken();
4304
4305 // The list continues if we see a comma.
4306 if (Tok.isNot(tok::comma))
4307 break;
4308 ConsumeToken();
4309 }
4310}
4311
4312/// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list
4313/// after the opening parenthesis. This function will not parse a K&R-style
4314/// identifier list.
4315///
4316/// D is the declarator being parsed. If attrs is non-null, then the caller
4317/// parsed those arguments immediately after the open paren - they should be
4318/// considered to be the first argument of a parameter.
4319///
4320/// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will
4321/// be the location of the ellipsis, if any was parsed.
4322///
Reid Spencer5f016e22007-07-11 17:01:13 +00004323/// parameter-type-list: [C99 6.7.5]
4324/// parameter-list
4325/// parameter-list ',' '...'
Douglas Gregored5d6512009-09-22 21:41:40 +00004326/// [C++] parameter-list '...'
Reid Spencer5f016e22007-07-11 17:01:13 +00004327///
4328/// parameter-list: [C99 6.7.5]
4329/// parameter-declaration
4330/// parameter-list ',' parameter-declaration
4331///
4332/// parameter-declaration: [C99 6.7.5]
4333/// declaration-specifiers declarator
Chris Lattner04421082008-04-08 04:40:51 +00004334/// [C++] declaration-specifiers declarator '=' assignment-expression
Reid Spencer5f016e22007-07-11 17:01:13 +00004335/// [GNU] declaration-specifiers declarator attributes
Sebastian Redl50de12f2009-03-24 22:27:57 +00004336/// declaration-specifiers abstract-declarator[opt]
4337/// [C++] declaration-specifiers abstract-declarator[opt]
Chris Lattner8123a952008-04-10 02:22:51 +00004338/// '=' assignment-expression
Reid Spencer5f016e22007-07-11 17:01:13 +00004339/// [GNU] declaration-specifiers abstract-declarator[opt] attributes
4340///
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004341void Parser::ParseParameterDeclarationClause(
4342 Declarator &D,
4343 ParsedAttributes &attrs,
Chris Lattner5f9e2722011-07-23 10:55:15 +00004344 SmallVector<DeclaratorChunk::ParamInfo, 16> &ParamInfo,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004345 SourceLocation &EllipsisLoc) {
Mike Stump1eb44332009-09-09 15:08:12 +00004346
Chris Lattnerf97409f2008-04-06 06:57:35 +00004347 while (1) {
4348 if (Tok.is(tok::ellipsis)) {
Douglas Gregor965acbb2009-02-18 07:07:28 +00004349 EllipsisLoc = ConsumeToken(); // Consume the ellipsis.
Chris Lattnerf97409f2008-04-06 06:57:35 +00004350 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00004351 }
Mike Stump1eb44332009-09-09 15:08:12 +00004352
Chris Lattnerf97409f2008-04-06 06:57:35 +00004353 // Parse the declaration-specifiers.
John McCall54abf7d2009-11-04 02:18:39 +00004354 // Just use the ParsingDeclaration "scope" of the declarator.
John McCall0b7e6782011-03-24 11:26:52 +00004355 DeclSpec DS(AttrFactory);
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004356
John McCall7f040a92010-12-24 02:08:15 +00004357 // Skip any Microsoft attributes before a param.
Francois Pichet62ec1f22011-09-17 17:15:52 +00004358 if (getLang().MicrosoftExt && Tok.is(tok::l_square))
John McCall7f040a92010-12-24 02:08:15 +00004359 ParseMicrosoftAttributes(DS.getAttributes());
4360
4361 SourceLocation DSStart = Tok.getLocation();
Chris Lattner7399ee02008-10-20 02:05:46 +00004362
4363 // If the caller parsed attributes for the first argument, add them now.
John McCall7f040a92010-12-24 02:08:15 +00004364 // Take them so that we only apply the attributes to the first parameter.
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004365 // FIXME: If we saw an ellipsis first, this code is not reached. Are the
4366 // attributes lost? Should they even be allowed?
4367 // FIXME: If we can leave the attributes in the token stream somehow, we can
4368 // get rid of a parameter (attrs) and this statement. It might be too much
4369 // hassle.
John McCall7f040a92010-12-24 02:08:15 +00004370 DS.takeAttributesFrom(attrs);
4371
Chris Lattnere64c5492009-02-27 18:38:20 +00004372 ParseDeclarationSpecifiers(DS);
Mike Stump1eb44332009-09-09 15:08:12 +00004373
Chris Lattnerf97409f2008-04-06 06:57:35 +00004374 // Parse the declarator. This is "PrototypeContext", because we must
4375 // accept either 'declarator' or 'abstract-declarator' here.
4376 Declarator ParmDecl(DS, Declarator::PrototypeContext);
4377 ParseDeclarator(ParmDecl);
4378
4379 // Parse GNU attributes, if present.
John McCall7f040a92010-12-24 02:08:15 +00004380 MaybeParseGNUAttributes(ParmDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00004381
Chris Lattnerf97409f2008-04-06 06:57:35 +00004382 // Remember this parsed parameter in ParamInfo.
4383 IdentifierInfo *ParmII = ParmDecl.getIdentifier();
Mike Stump1eb44332009-09-09 15:08:12 +00004384
Douglas Gregor72b505b2008-12-16 21:30:33 +00004385 // DefArgToks is used when the parsing of default arguments needs
4386 // to be delayed.
4387 CachedTokens *DefArgToks = 0;
4388
Chris Lattnerf97409f2008-04-06 06:57:35 +00004389 // If no parameter was specified, verify that *something* was specified,
4390 // otherwise we have a missing type and identifier.
Chris Lattnere64c5492009-02-27 18:38:20 +00004391 if (DS.isEmpty() && ParmDecl.getIdentifier() == 0 &&
4392 ParmDecl.getNumTypeObjects() == 0) {
Chris Lattnerf97409f2008-04-06 06:57:35 +00004393 // Completely missing, emit error.
4394 Diag(DSStart, diag::err_missing_param);
4395 } else {
4396 // Otherwise, we have something. Add it and let semantic analysis try
4397 // to grok it and add the result to the ParamInfo we are building.
Mike Stump1eb44332009-09-09 15:08:12 +00004398
Chris Lattnerf97409f2008-04-06 06:57:35 +00004399 // Inform the actions module about the parameter declarator, so it gets
4400 // added to the current scope.
John McCalld226f652010-08-21 09:40:31 +00004401 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
Chris Lattner04421082008-04-08 04:40:51 +00004402
4403 // Parse the default argument, if any. We parse the default
4404 // arguments in all dialects; the semantic analysis in
4405 // ActOnParamDefaultArgument will reject the default argument in
4406 // C.
4407 if (Tok.is(tok::equal)) {
Douglas Gregor61366e92008-12-24 00:01:03 +00004408 SourceLocation EqualLoc = Tok.getLocation();
4409
Chris Lattner04421082008-04-08 04:40:51 +00004410 // Parse the default argument
Douglas Gregor72b505b2008-12-16 21:30:33 +00004411 if (D.getContext() == Declarator::MemberContext) {
4412 // If we're inside a class definition, cache the tokens
4413 // corresponding to the default argument. We'll actually parse
4414 // them when we see the end of the class definition.
4415 // FIXME: Templates will require something similar.
4416 // FIXME: Can we use a smart pointer for Toks?
4417 DefArgToks = new CachedTokens;
4418
Mike Stump1eb44332009-09-09 15:08:12 +00004419 if (!ConsumeAndStoreUntil(tok::comma, tok::r_paren, *DefArgToks,
Argyrios Kyrtzidis14b91622010-04-23 21:20:12 +00004420 /*StopAtSemi=*/true,
4421 /*ConsumeFinalToken=*/false)) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00004422 delete DefArgToks;
4423 DefArgToks = 0;
Douglas Gregor61366e92008-12-24 00:01:03 +00004424 Actions.ActOnParamDefaultArgumentError(Param);
Argyrios Kyrtzidis2b602ad2010-08-06 09:47:24 +00004425 } else {
4426 // Mark the end of the default argument so that we know when to
4427 // stop when we parse it later on.
4428 Token DefArgEnd;
4429 DefArgEnd.startToken();
4430 DefArgEnd.setKind(tok::cxx_defaultarg_end);
4431 DefArgEnd.setLocation(Tok.getLocation());
4432 DefArgToks->push_back(DefArgEnd);
Mike Stump1eb44332009-09-09 15:08:12 +00004433 Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc,
Anders Carlsson5e300d12009-06-12 16:51:40 +00004434 (*DefArgToks)[1].getLocation());
Argyrios Kyrtzidis2b602ad2010-08-06 09:47:24 +00004435 }
Chris Lattner04421082008-04-08 04:40:51 +00004436 } else {
Douglas Gregor72b505b2008-12-16 21:30:33 +00004437 // Consume the '='.
Douglas Gregor61366e92008-12-24 00:01:03 +00004438 ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00004439
Douglas Gregorbe0f7bd2010-09-11 20:24:53 +00004440 // The argument isn't actually potentially evaluated unless it is
4441 // used.
4442 EnterExpressionEvaluationContext Eval(Actions,
4443 Sema::PotentiallyEvaluatedIfUsed);
4444
John McCall60d7b3a2010-08-24 06:29:42 +00004445 ExprResult DefArgResult(ParseAssignmentExpression());
Douglas Gregor72b505b2008-12-16 21:30:33 +00004446 if (DefArgResult.isInvalid()) {
4447 Actions.ActOnParamDefaultArgumentError(Param);
4448 SkipUntil(tok::comma, tok::r_paren, true, true);
4449 } else {
4450 // Inform the actions module about the default argument
4451 Actions.ActOnParamDefaultArgument(Param, EqualLoc,
John McCall9ae2f072010-08-23 23:25:46 +00004452 DefArgResult.take());
Douglas Gregor72b505b2008-12-16 21:30:33 +00004453 }
Chris Lattner04421082008-04-08 04:40:51 +00004454 }
4455 }
Mike Stump1eb44332009-09-09 15:08:12 +00004456
4457 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
4458 ParmDecl.getIdentifierLoc(), Param,
Douglas Gregor72b505b2008-12-16 21:30:33 +00004459 DefArgToks));
Chris Lattnerf97409f2008-04-06 06:57:35 +00004460 }
4461
4462 // If the next token is a comma, consume it and keep reading arguments.
Douglas Gregored5d6512009-09-22 21:41:40 +00004463 if (Tok.isNot(tok::comma)) {
4464 if (Tok.is(tok::ellipsis)) {
Douglas Gregored5d6512009-09-22 21:41:40 +00004465 EllipsisLoc = ConsumeToken(); // Consume the ellipsis.
4466
4467 if (!getLang().CPlusPlus) {
4468 // We have ellipsis without a preceding ',', which is ill-formed
4469 // in C. Complain and provide the fix.
4470 Diag(EllipsisLoc, diag::err_missing_comma_before_ellipsis)
Douglas Gregor849b2432010-03-31 17:46:05 +00004471 << FixItHint::CreateInsertion(EllipsisLoc, ", ");
Douglas Gregored5d6512009-09-22 21:41:40 +00004472 }
4473 }
4474
4475 break;
4476 }
Mike Stump1eb44332009-09-09 15:08:12 +00004477
Chris Lattnerf97409f2008-04-06 06:57:35 +00004478 // Consume the comma.
4479 ConsumeToken();
Reid Spencer5f016e22007-07-11 17:01:13 +00004480 }
Mike Stump1eb44332009-09-09 15:08:12 +00004481
Chris Lattner66d28652008-04-06 06:34:08 +00004482}
Chris Lattneref4715c2008-04-06 05:45:57 +00004483
Reid Spencer5f016e22007-07-11 17:01:13 +00004484/// [C90] direct-declarator '[' constant-expression[opt] ']'
4485/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
4486/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
4487/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
4488/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
4489void Parser::ParseBracketDeclarator(Declarator &D) {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004490 BalancedDelimiterTracker T(*this, tok::l_square);
4491 T.consumeOpen();
Mike Stump1eb44332009-09-09 15:08:12 +00004492
Chris Lattner378c7e42008-12-18 07:27:21 +00004493 // C array syntax has many features, but by-far the most common is [] and [4].
4494 // This code does a fast path to handle some of the most obvious cases.
4495 if (Tok.getKind() == tok::r_square) {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004496 T.consumeClose();
John McCall0b7e6782011-03-24 11:26:52 +00004497 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00004498 MaybeParseCXX0XAttributes(attrs);
Sean Huntbbd37c62009-11-21 08:43:09 +00004499
Chris Lattner378c7e42008-12-18 07:27:21 +00004500 // Remember that we parsed the empty array type.
John McCall60d7b3a2010-08-24 06:29:42 +00004501 ExprResult NumElements;
John McCall0b7e6782011-03-24 11:26:52 +00004502 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, 0,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004503 T.getOpenLocation(),
4504 T.getCloseLocation()),
4505 attrs, T.getCloseLocation());
Chris Lattner378c7e42008-12-18 07:27:21 +00004506 return;
4507 } else if (Tok.getKind() == tok::numeric_constant &&
4508 GetLookAheadToken(1).is(tok::r_square)) {
4509 // [4] is very common. Parse the numeric constant expression.
John McCall60d7b3a2010-08-24 06:29:42 +00004510 ExprResult ExprRes(Actions.ActOnNumericConstant(Tok));
Chris Lattner378c7e42008-12-18 07:27:21 +00004511 ConsumeToken();
4512
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004513 T.consumeClose();
John McCall0b7e6782011-03-24 11:26:52 +00004514 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00004515 MaybeParseCXX0XAttributes(attrs);
Mike Stump1eb44332009-09-09 15:08:12 +00004516
Chris Lattner378c7e42008-12-18 07:27:21 +00004517 // Remember that we parsed a array type, and remember its features.
John McCall0b7e6782011-03-24 11:26:52 +00004518 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, 0,
John McCall7f040a92010-12-24 02:08:15 +00004519 ExprRes.release(),
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004520 T.getOpenLocation(),
4521 T.getCloseLocation()),
4522 attrs, T.getCloseLocation());
Chris Lattner378c7e42008-12-18 07:27:21 +00004523 return;
4524 }
Mike Stump1eb44332009-09-09 15:08:12 +00004525
Reid Spencer5f016e22007-07-11 17:01:13 +00004526 // If valid, this location is the position where we read the 'static' keyword.
4527 SourceLocation StaticLoc;
Chris Lattner04d66662007-10-09 17:33:22 +00004528 if (Tok.is(tok::kw_static))
Reid Spencer5f016e22007-07-11 17:01:13 +00004529 StaticLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00004530
Reid Spencer5f016e22007-07-11 17:01:13 +00004531 // If there is a type-qualifier-list, read it now.
Chris Lattnera1fcbad2008-12-18 06:50:14 +00004532 // Type qualifiers in an array subscript are a C99 feature.
John McCall0b7e6782011-03-24 11:26:52 +00004533 DeclSpec DS(AttrFactory);
Chris Lattner5a69d1c2008-12-18 07:02:59 +00004534 ParseTypeQualifierListOpt(DS, false /*no attributes*/);
Mike Stump1eb44332009-09-09 15:08:12 +00004535
Reid Spencer5f016e22007-07-11 17:01:13 +00004536 // If we haven't already read 'static', check to see if there is one after the
4537 // type-qualifier-list.
Chris Lattner04d66662007-10-09 17:33:22 +00004538 if (!StaticLoc.isValid() && Tok.is(tok::kw_static))
Reid Spencer5f016e22007-07-11 17:01:13 +00004539 StaticLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00004540
Reid Spencer5f016e22007-07-11 17:01:13 +00004541 // Handle "direct-declarator [ type-qual-list[opt] * ]".
4542 bool isStar = false;
John McCall60d7b3a2010-08-24 06:29:42 +00004543 ExprResult NumElements;
Mike Stump1eb44332009-09-09 15:08:12 +00004544
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00004545 // Handle the case where we have '[*]' as the array size. However, a leading
4546 // star could be the start of an expression, for example 'X[*p + 4]'. Verify
4547 // the the token after the star is a ']'. Since stars in arrays are
4548 // infrequent, use of lookahead is not costly here.
4549 if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
Chris Lattnera711dd02008-04-06 05:27:21 +00004550 ConsumeToken(); // Eat the '*'.
Reid Spencer5f016e22007-07-11 17:01:13 +00004551
Chris Lattnera1fcbad2008-12-18 06:50:14 +00004552 if (StaticLoc.isValid()) {
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00004553 Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);
Chris Lattnera1fcbad2008-12-18 06:50:14 +00004554 StaticLoc = SourceLocation(); // Drop the static.
4555 }
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00004556 isStar = true;
Chris Lattner04d66662007-10-09 17:33:22 +00004557 } else if (Tok.isNot(tok::r_square)) {
Chris Lattner378c7e42008-12-18 07:27:21 +00004558 // Note, in C89, this production uses the constant-expr production instead
4559 // of assignment-expr. The only difference is that assignment-expr allows
4560 // things like '=' and '*='. Sema rejects these in C89 mode because they
4561 // are not i-c-e's, so we don't need to distinguish between the two here.
Mike Stump1eb44332009-09-09 15:08:12 +00004562
Douglas Gregore0762c92009-06-19 23:52:42 +00004563 // Parse the constant-expression or assignment-expression now (depending
4564 // on dialect).
4565 if (getLang().CPlusPlus)
4566 NumElements = ParseConstantExpression();
4567 else
4568 NumElements = ParseAssignmentExpression();
Reid Spencer5f016e22007-07-11 17:01:13 +00004569 }
Mike Stump1eb44332009-09-09 15:08:12 +00004570
Reid Spencer5f016e22007-07-11 17:01:13 +00004571 // If there was an error parsing the assignment-expression, recover.
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00004572 if (NumElements.isInvalid()) {
Chris Lattner5cb10d32009-04-24 22:30:50 +00004573 D.setInvalidType(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00004574 // If the expression was invalid, skip it.
4575 SkipUntil(tok::r_square);
4576 return;
4577 }
Sebastian Redlab197ba2009-02-09 18:23:29 +00004578
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004579 T.consumeClose();
Sebastian Redlab197ba2009-02-09 18:23:29 +00004580
John McCall0b7e6782011-03-24 11:26:52 +00004581 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00004582 MaybeParseCXX0XAttributes(attrs);
Sean Huntbbd37c62009-11-21 08:43:09 +00004583
Chris Lattner378c7e42008-12-18 07:27:21 +00004584 // Remember that we parsed a array type, and remember its features.
John McCall0b7e6782011-03-24 11:26:52 +00004585 D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(),
Reid Spencer5f016e22007-07-11 17:01:13 +00004586 StaticLoc.isValid(), isStar,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00004587 NumElements.release(),
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004588 T.getOpenLocation(),
4589 T.getCloseLocation()),
4590 attrs, T.getCloseLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00004591}
4592
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00004593/// [GNU] typeof-specifier:
4594/// typeof ( expressions )
4595/// typeof ( type-name )
4596/// [GNU/C++] typeof unary-expression
Steve Naroffd1861fd2007-07-31 12:34:36 +00004597///
4598void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
Chris Lattner04d66662007-10-09 17:33:22 +00004599 assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier");
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004600 Token OpTok = Tok;
Steve Naroffd1861fd2007-07-31 12:34:36 +00004601 SourceLocation StartLoc = ConsumeToken();
4602
John McCallcfb708c2010-01-13 20:03:27 +00004603 const bool hasParens = Tok.is(tok::l_paren);
4604
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004605 bool isCastExpr;
John McCallb3d87482010-08-24 05:47:05 +00004606 ParsedType CastTy;
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004607 SourceRange CastRange;
Peter Collingbournef4e3cfb2011-03-11 19:24:49 +00004608 ExprResult Operand = ParseExprAfterUnaryExprOrTypeTrait(OpTok, isCastExpr,
4609 CastTy, CastRange);
John McCallcfb708c2010-01-13 20:03:27 +00004610 if (hasParens)
4611 DS.setTypeofParensRange(CastRange);
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004612
4613 if (CastRange.getEnd().isInvalid())
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00004614 // FIXME: Not accurate, the range gets one token more than it should.
4615 DS.SetRangeEnd(Tok.getLocation());
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004616 else
4617 DS.SetRangeEnd(CastRange.getEnd());
Mike Stump1eb44332009-09-09 15:08:12 +00004618
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004619 if (isCastExpr) {
4620 if (!CastTy) {
4621 DS.SetTypeSpecError();
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00004622 return;
Douglas Gregor809070a2009-02-18 17:45:20 +00004623 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00004624
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004625 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00004626 unsigned DiagID;
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004627 // Check for duplicate type specifiers (e.g. "int typeof(int)").
4628 if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00004629 DiagID, CastTy))
4630 Diag(StartLoc, DiagID) << PrevSpec;
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004631 return;
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00004632 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00004633
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00004634 // If we get here, the operand to the typeof was an expresion.
4635 if (Operand.isInvalid()) {
4636 DS.SetTypeSpecError();
Steve Naroff9dfa7b42007-08-02 02:53:48 +00004637 return;
Steve Naroffd1861fd2007-07-31 12:34:36 +00004638 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00004639
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00004640 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00004641 unsigned DiagID;
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00004642 // Check for duplicate type specifiers (e.g. "int typeof(int)").
4643 if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
John McCallb3d87482010-08-24 05:47:05 +00004644 DiagID, Operand.get()))
John McCallfec54012009-08-03 20:12:06 +00004645 Diag(StartLoc, DiagID) << PrevSpec;
Steve Naroffd1861fd2007-07-31 12:34:36 +00004646}
Chris Lattner1b492422010-02-28 18:33:55 +00004647
Eli Friedmanb001de72011-10-06 23:00:33 +00004648/// [C1X] atomic-specifier:
4649/// _Atomic ( type-name )
4650///
4651void Parser::ParseAtomicSpecifier(DeclSpec &DS) {
4652 assert(Tok.is(tok::kw__Atomic) && "Not an atomic specifier");
4653
4654 SourceLocation StartLoc = ConsumeToken();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004655 BalancedDelimiterTracker T(*this, tok::l_paren);
4656 if (T.expectAndConsume(diag::err_expected_lparen_after, "_Atomic")) {
Eli Friedmanb001de72011-10-06 23:00:33 +00004657 SkipUntil(tok::r_paren);
4658 return;
4659 }
4660
4661 TypeResult Result = ParseTypeName();
4662 if (Result.isInvalid()) {
4663 SkipUntil(tok::r_paren);
4664 return;
4665 }
4666
4667 // Match the ')'
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004668 T.consumeClose();
Eli Friedmanb001de72011-10-06 23:00:33 +00004669
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004670 if (T.getCloseLocation().isInvalid())
Eli Friedmanb001de72011-10-06 23:00:33 +00004671 return;
4672
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004673 DS.setTypeofParensRange(T.getRange());
4674 DS.SetRangeEnd(T.getCloseLocation());
Eli Friedmanb001de72011-10-06 23:00:33 +00004675
4676 const char *PrevSpec = 0;
4677 unsigned DiagID;
4678 if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec,
4679 DiagID, Result.release()))
4680 Diag(StartLoc, DiagID) << PrevSpec;
4681}
4682
Chris Lattner1b492422010-02-28 18:33:55 +00004683
4684/// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be called
4685/// from TryAltiVecVectorToken.
4686bool Parser::TryAltiVecVectorTokenOutOfLine() {
4687 Token Next = NextToken();
4688 switch (Next.getKind()) {
4689 default: return false;
4690 case tok::kw_short:
4691 case tok::kw_long:
4692 case tok::kw_signed:
4693 case tok::kw_unsigned:
4694 case tok::kw_void:
4695 case tok::kw_char:
4696 case tok::kw_int:
4697 case tok::kw_float:
4698 case tok::kw_double:
4699 case tok::kw_bool:
4700 case tok::kw___pixel:
4701 Tok.setKind(tok::kw___vector);
4702 return true;
4703 case tok::identifier:
4704 if (Next.getIdentifierInfo() == Ident_pixel) {
4705 Tok.setKind(tok::kw___vector);
4706 return true;
4707 }
4708 return false;
4709 }
4710}
4711
4712bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
4713 const char *&PrevSpec, unsigned &DiagID,
4714 bool &isInvalid) {
4715 if (Tok.getIdentifierInfo() == Ident_vector) {
4716 Token Next = NextToken();
4717 switch (Next.getKind()) {
4718 case tok::kw_short:
4719 case tok::kw_long:
4720 case tok::kw_signed:
4721 case tok::kw_unsigned:
4722 case tok::kw_void:
4723 case tok::kw_char:
4724 case tok::kw_int:
4725 case tok::kw_float:
4726 case tok::kw_double:
4727 case tok::kw_bool:
4728 case tok::kw___pixel:
4729 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
4730 return true;
4731 case tok::identifier:
4732 if (Next.getIdentifierInfo() == Ident_pixel) {
4733 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
4734 return true;
4735 }
4736 break;
4737 default:
4738 break;
4739 }
Douglas Gregora8f031f2010-06-16 15:28:57 +00004740 } else if ((Tok.getIdentifierInfo() == Ident_pixel) &&
Chris Lattner1b492422010-02-28 18:33:55 +00004741 DS.isTypeAltiVecVector()) {
4742 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
4743 return true;
4744 }
4745 return false;
4746}