blob: 96c57581e85958f06f4a53265bfac218efb99b68 [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"
Kaelyn Uhrainaec2ac62012-04-26 23:36:17 +000017#include "clang/Sema/Lookup.h"
John McCall19510852010-08-20 18:27:03 +000018#include "clang/Sema/Scope.h"
19#include "clang/Sema/ParsedTemplate.h"
John McCallf312b1e2010-08-26 23:41:50 +000020#include "clang/Sema/PrettyDeclStackTrace.h"
Chris Lattnerd167ca02009-12-10 00:21:05 +000021#include "RAIIObjectsForParser.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000022#include "llvm/ADT/SmallSet.h"
Benjamin Kramer8fe83e12012-02-04 13:45:25 +000023#include "llvm/ADT/SmallString.h"
Caitlin Sadowskib51e0312011-08-09 17:59:31 +000024#include "llvm/ADT/StringSwitch.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000025using namespace clang;
26
27//===----------------------------------------------------------------------===//
28// C99 6.7: Declarations.
29//===----------------------------------------------------------------------===//
30
31/// ParseTypeName
32/// type-name: [C99 6.7.6]
33/// specifier-qualifier-list abstract-declarator[opt]
Sebastian Redl4c5d3202008-11-21 19:14:01 +000034///
35/// Called type-id in C++.
Douglas Gregor683a81f2011-01-31 16:09:46 +000036TypeResult Parser::ParseTypeName(SourceRange *Range,
John McCallf85e1932011-06-15 23:02:42 +000037 Declarator::TheContext Context,
Richard Smithc89edf52011-07-01 19:46:12 +000038 AccessSpecifier AS,
39 Decl **OwnedType) {
Richard Smith6d96d3a2012-03-15 01:02:11 +000040 DeclSpecContext DSC = getDeclSpecContextFromDeclaratorContext(Context);
Richard Smitha971d242012-05-09 20:55:26 +000041 if (DSC == DSC_normal)
42 DSC = DSC_type_specifier;
Richard Smith7796eb52012-03-12 08:56:40 +000043
Reid Spencer5f016e22007-07-11 17:01:13 +000044 // Parse the common declaration-specifiers piece.
John McCall0b7e6782011-03-24 11:26:52 +000045 DeclSpec DS(AttrFactory);
Richard Smith7796eb52012-03-12 08:56:40 +000046 ParseSpecifierQualifierList(DS, AS, DSC);
Richard Smithc89edf52011-07-01 19:46:12 +000047 if (OwnedType)
48 *OwnedType = DS.isTypeSpecOwned() ? DS.getRepAsDecl() : 0;
Sebastian Redlef65f062009-05-29 18:02:33 +000049
Reid Spencer5f016e22007-07-11 17:01:13 +000050 // Parse the abstract-declarator, if present.
Douglas Gregor683a81f2011-01-31 16:09:46 +000051 Declarator DeclaratorInfo(DS, Context);
Reid Spencer5f016e22007-07-11 17:01:13 +000052 ParseDeclarator(DeclaratorInfo);
Sebastian Redlef65f062009-05-29 18:02:33 +000053 if (Range)
54 *Range = DeclaratorInfo.getSourceRange();
55
Chris Lattnereaaebc72009-04-25 08:06:05 +000056 if (DeclaratorInfo.isInvalidType())
Douglas Gregor809070a2009-02-18 17:45:20 +000057 return true;
58
Douglas Gregor23c94db2010-07-02 17:43:08 +000059 return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
Reid Spencer5f016e22007-07-11 17:01:13 +000060}
61
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +000062
63/// isAttributeLateParsed - Return true if the attribute has arguments that
64/// require late parsing.
65static bool isAttributeLateParsed(const IdentifierInfo &II) {
66 return llvm::StringSwitch<bool>(II.getName())
67#include "clang/Parse/AttrLateParsed.inc"
68 .Default(false);
69}
70
71
Sean Huntbbd37c62009-11-21 08:43:09 +000072/// ParseGNUAttributes - Parse a non-empty attributes list.
Reid Spencer5f016e22007-07-11 17:01:13 +000073///
74/// [GNU] attributes:
75/// attribute
76/// attributes attribute
77///
78/// [GNU] attribute:
79/// '__attribute__' '(' '(' attribute-list ')' ')'
80///
81/// [GNU] attribute-list:
82/// attrib
83/// attribute_list ',' attrib
84///
85/// [GNU] attrib:
86/// empty
87/// attrib-name
88/// attrib-name '(' identifier ')'
89/// attrib-name '(' identifier ',' nonempty-expr-list ')'
90/// attrib-name '(' argument-expression-list [C99 6.5.2] ')'
91///
92/// [GNU] attrib-name:
93/// identifier
94/// typespec
95/// typequal
96/// storageclass
Mike Stump1eb44332009-09-09 15:08:12 +000097///
Reid Spencer5f016e22007-07-11 17:01:13 +000098/// FIXME: The GCC grammar/code for this construct implies we need two
Mike Stump1eb44332009-09-09 15:08:12 +000099/// token lookahead. Comment from gcc: "If they start with an identifier
100/// which is followed by a comma or close parenthesis, then the arguments
Reid Spencer5f016e22007-07-11 17:01:13 +0000101/// start with that identifier; otherwise they are an expression list."
102///
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000103/// GCC does not require the ',' between attribs in an attribute-list.
104///
Reid Spencer5f016e22007-07-11 17:01:13 +0000105/// At the moment, I am not doing 2 token lookahead. I am also unaware of
106/// any attributes that don't work (based on my limited testing). Most
107/// attributes are very simple in practice. Until we find a bug, I don't see
108/// a pressing need to implement the 2 token lookahead.
109
John McCall7f040a92010-12-24 02:08:15 +0000110void Parser::ParseGNUAttributes(ParsedAttributes &attrs,
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000111 SourceLocation *endLoc,
112 LateParsedAttrList *LateAttrs) {
Sean Huntbbd37c62009-11-21 08:43:09 +0000113 assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!");
Mike Stump1eb44332009-09-09 15:08:12 +0000114
Chris Lattner04d66662007-10-09 17:33:22 +0000115 while (Tok.is(tok::kw___attribute)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000116 ConsumeToken();
117 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
118 "attribute")) {
119 SkipUntil(tok::r_paren, true); // skip until ) or ;
John McCall7f040a92010-12-24 02:08:15 +0000120 return;
Reid Spencer5f016e22007-07-11 17:01:13 +0000121 }
122 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
123 SkipUntil(tok::r_paren, true); // skip until ) or ;
John McCall7f040a92010-12-24 02:08:15 +0000124 return;
Reid Spencer5f016e22007-07-11 17:01:13 +0000125 }
126 // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") ))
Chris Lattner04d66662007-10-09 17:33:22 +0000127 while (Tok.is(tok::identifier) || isDeclarationSpecifier() ||
128 Tok.is(tok::comma)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000129 if (Tok.is(tok::comma)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000130 // allows for empty/non-empty attributes. ((__vector_size__(16),,,,))
131 ConsumeToken();
132 continue;
133 }
134 // we have an identifier or declaration specifier (const, int, etc.)
135 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
136 SourceLocation AttrNameLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +0000137
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000138 if (Tok.is(tok::l_paren)) {
139 // handle "parameterized" attributes
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000140 if (LateAttrs && isAttributeLateParsed(*AttrName)) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000141 LateParsedAttribute *LA =
142 new LateParsedAttribute(this, *AttrName, AttrNameLoc);
143 LateAttrs->push_back(LA);
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000144
145 // Attributes in a class are parsed at the end of the class, along
146 // with other late-parsed declarations.
147 if (!ClassStack.empty())
148 getCurrentClass().LateParsedDeclarations.push_back(LA);
Mike Stump1eb44332009-09-09 15:08:12 +0000149
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000150 // consume everything up to and including the matching right parens
151 ConsumeAndStoreUntil(tok::r_paren, LA->Toks, true, false);
Mike Stump1eb44332009-09-09 15:08:12 +0000152
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000153 Token Eof;
154 Eof.startToken();
155 Eof.setLocation(Tok.getLocation());
156 LA->Toks.push_back(Eof);
157 } else {
158 ParseGNUAttributeArgs(AttrName, AttrNameLoc, attrs, endLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +0000159 }
160 } else {
John McCall0b7e6782011-03-24 11:26:52 +0000161 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc,
Sean Hunt93f95f22012-06-18 16:13:52 +0000162 0, SourceLocation(), 0, 0, AttributeList::AS_GNU);
Reid Spencer5f016e22007-07-11 17:01:13 +0000163 }
164 }
165 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
Reid Spencer5f016e22007-07-11 17:01:13 +0000166 SkipUntil(tok::r_paren, false);
Sean Huntbbd37c62009-11-21 08:43:09 +0000167 SourceLocation Loc = Tok.getLocation();
Sebastian Redlab197ba2009-02-09 18:23:29 +0000168 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) {
169 SkipUntil(tok::r_paren, false);
170 }
John McCall7f040a92010-12-24 02:08:15 +0000171 if (endLoc)
172 *endLoc = Loc;
Reid Spencer5f016e22007-07-11 17:01:13 +0000173 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000174}
175
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000176
177/// Parse the arguments to a parameterized GNU attribute
178void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName,
179 SourceLocation AttrNameLoc,
180 ParsedAttributes &Attrs,
181 SourceLocation *EndLoc) {
182
183 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
184
185 // Availability attributes have their own grammar.
186 if (AttrName->isStr("availability")) {
187 ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc);
188 return;
189 }
190 // Thread safety attributes fit into the FIXME case above, so we
191 // just parse the arguments as a list of expressions
192 if (IsThreadSafetyAttribute(AttrName->getName())) {
193 ParseThreadSafetyAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc);
194 return;
195 }
196
197 ConsumeParen(); // ignore the left paren loc for now
198
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000199 IdentifierInfo *ParmName = 0;
200 SourceLocation ParmLoc;
201 bool BuiltinType = false;
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000202
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000203 switch (Tok.getKind()) {
204 case tok::kw_char:
205 case tok::kw_wchar_t:
206 case tok::kw_char16_t:
207 case tok::kw_char32_t:
208 case tok::kw_bool:
209 case tok::kw_short:
210 case tok::kw_int:
211 case tok::kw_long:
212 case tok::kw___int64:
Richard Smith5a5a9712012-04-04 06:24:32 +0000213 case tok::kw___int128:
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000214 case tok::kw_signed:
215 case tok::kw_unsigned:
216 case tok::kw_float:
217 case tok::kw_double:
218 case tok::kw_void:
219 case tok::kw_typeof:
220 // __attribute__(( vec_type_hint(char) ))
221 // FIXME: Don't just discard the builtin type token.
222 ConsumeToken();
223 BuiltinType = true;
224 break;
225
226 case tok::identifier:
227 ParmName = Tok.getIdentifierInfo();
228 ParmLoc = ConsumeToken();
229 break;
230
231 default:
232 break;
233 }
234
235 ExprVector ArgExprs(Actions);
236
237 if (!BuiltinType &&
238 (ParmLoc.isValid() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren))) {
239 // Eat the comma.
240 if (ParmLoc.isValid())
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000241 ConsumeToken();
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000242
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000243 // Parse the non-empty comma-separated list of expressions.
244 while (1) {
245 ExprResult ArgExpr(ParseAssignmentExpression());
246 if (ArgExpr.isInvalid()) {
247 SkipUntil(tok::r_paren);
248 return;
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000249 }
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000250 ArgExprs.push_back(ArgExpr.release());
251 if (Tok.isNot(tok::comma))
252 break;
253 ConsumeToken(); // Eat the comma, move to the next argument
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000254 }
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000255 }
Fariborz Jahanian7a81e412011-10-18 17:11:10 +0000256 else if (Tok.is(tok::less) && AttrName->isStr("iboutletcollection")) {
257 if (!ExpectAndConsume(tok::less, diag::err_expected_less_after, "<",
258 tok::greater)) {
Fariborz Jahanianb2243432011-10-18 23:13:50 +0000259 while (Tok.is(tok::identifier)) {
260 ConsumeToken();
261 if (Tok.is(tok::greater))
262 break;
263 if (Tok.is(tok::comma)) {
264 ConsumeToken();
265 continue;
266 }
267 }
268 if (Tok.isNot(tok::greater))
269 Diag(Tok, diag::err_iboutletcollection_with_protocol);
Fariborz Jahanian7a81e412011-10-18 17:11:10 +0000270 SkipUntil(tok::r_paren, false, true); // skip until ')'
271 }
272 }
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000273
274 SourceLocation RParen = Tok.getLocation();
275 if (!ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) {
276 AttributeList *attr =
Argyrios Kyrtzidisffcc3102011-09-13 16:05:53 +0000277 Attrs.addNew(AttrName, SourceRange(AttrNameLoc, RParen), 0, AttrNameLoc,
Sean Hunt93f95f22012-06-18 16:13:52 +0000278 ParmName, ParmLoc, ArgExprs.take(), ArgExprs.size(),
279 AttributeList::AS_GNU);
Sean Hunt8e083e72012-06-19 23:57:03 +0000280 if (BuiltinType && attr->getKind() == AttributeList::AT_IBOutletCollection)
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000281 Diag(Tok, diag::err_iboutletcollection_builtintype);
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000282 }
283}
284
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000285/// \brief Parses a single argument for a declspec, including the
286/// surrounding parens.
287void Parser::ParseMicrosoftDeclSpecWithSingleArg(IdentifierInfo *AttrName,
288 SourceLocation AttrNameLoc,
289 ParsedAttributes &Attrs)
290{
291 BalancedDelimiterTracker T(*this, tok::l_paren);
292 if (T.expectAndConsume(diag::err_expected_lparen_after,
293 AttrName->getNameStart(), tok::r_paren))
294 return;
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000295
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000296 ExprResult ArgExpr(ParseConstantExpression());
297 if (ArgExpr.isInvalid()) {
298 T.skipToEnd();
299 return;
300 }
301 Expr *ExprList = ArgExpr.take();
302 Attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(),
303 &ExprList, 1, AttributeList::AS_Declspec);
304
305 T.consumeClose();
306}
307
308/// \brief Determines whether a declspec is a "simple" one requiring no
309/// arguments.
310bool Parser::IsSimpleMicrosoftDeclSpec(IdentifierInfo *Ident) {
311 return llvm::StringSwitch<bool>(Ident->getName())
312 .Case("dllimport", true)
313 .Case("dllexport", true)
314 .Case("noreturn", true)
315 .Case("nothrow", true)
316 .Case("noinline", true)
317 .Case("naked", true)
318 .Case("appdomain", true)
319 .Case("process", true)
320 .Case("jitintrinsic", true)
321 .Case("noalias", true)
322 .Case("restrict", true)
323 .Case("novtable", true)
324 .Case("selectany", true)
325 .Case("thread", true)
326 .Default(false);
327}
328
329/// \brief Attempts to parse a declspec which is not simple (one that takes
330/// parameters). Will return false if we properly handled the declspec, or
331/// true if it is an unknown declspec.
332void Parser::ParseComplexMicrosoftDeclSpec(IdentifierInfo *Ident,
333 SourceLocation Loc,
334 ParsedAttributes &Attrs) {
335 // Try to handle the easy case first -- these declspecs all take a single
336 // parameter as their argument.
337 if (llvm::StringSwitch<bool>(Ident->getName())
338 .Case("uuid", true)
339 .Case("align", true)
340 .Case("allocate", true)
341 .Default(false)) {
342 ParseMicrosoftDeclSpecWithSingleArg(Ident, Loc, Attrs);
343 } else if (Ident->getName() == "deprecated") {
344 // The deprecated declspec has an optional single argument, so we will
345 // check for a l-paren to decide whether we should parse an argument or
346 // not.
347 if (Tok.getKind() == tok::l_paren)
348 ParseMicrosoftDeclSpecWithSingleArg(Ident, Loc, Attrs);
349 else
350 Attrs.addNew(Ident, Loc, 0, Loc, 0, SourceLocation(), 0, 0,
351 AttributeList::AS_Declspec);
352 } else if (Ident->getName() == "property") {
353 // The property declspec is more complex in that it can take one or two
354 // assignment expressions as a parameter, but the lhs of the assignment
355 // must be named get or put.
356 //
357 // For right now, we will just skip to the closing right paren of the
358 // property expression.
359 //
360 // FIXME: we should deal with __declspec(property) at some point because it
361 // is used in the platform SDK headers for the Parallel Patterns Library
362 // and ATL.
363 BalancedDelimiterTracker T(*this, tok::l_paren);
364 if (T.expectAndConsume(diag::err_expected_lparen_after,
365 Ident->getNameStart(), tok::r_paren))
366 return;
367 T.skipToEnd();
368 } else {
369 // We don't recognize this as a valid declspec, but instead of creating the
370 // attribute and allowing sema to warn about it, we will warn here instead.
371 // This is because some attributes have multiple spellings, but we need to
372 // disallow that for declspecs (such as align vs aligned). If we made the
373 // attribute, we'd have to split the valid declspec spelling logic into
374 // both locations.
375 Diag(Loc, diag::warn_ms_declspec_unknown) << Ident;
376
377 // If there's an open paren, we should eat the open and close parens under
378 // the assumption that this unknown declspec has parameters.
379 BalancedDelimiterTracker T(*this, tok::l_paren);
380 if (!T.consumeOpen())
381 T.skipToEnd();
382 }
383}
384
Eli Friedmana23b4852009-06-08 07:21:15 +0000385/// [MS] decl-specifier:
386/// __declspec ( extended-decl-modifier-seq )
387///
388/// [MS] extended-decl-modifier-seq:
389/// extended-decl-modifier[opt]
390/// extended-decl-modifier extended-decl-modifier-seq
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000391void Parser::ParseMicrosoftDeclSpec(ParsedAttributes &Attrs) {
Steve Narofff59e17e2008-12-24 20:59:21 +0000392 assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
Eli Friedmana23b4852009-06-08 07:21:15 +0000393
Steve Narofff59e17e2008-12-24 20:59:21 +0000394 ConsumeToken();
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000395 BalancedDelimiterTracker T(*this, tok::l_paren);
396 if (T.expectAndConsume(diag::err_expected_lparen_after, "__declspec",
397 tok::r_paren))
John McCall7f040a92010-12-24 02:08:15 +0000398 return;
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000399
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000400 // An empty declspec is perfectly legal and should not warn. Additionally,
401 // you can specify multiple attributes per declspec.
402 while (Tok.getKind() != tok::r_paren) {
403 // We expect either a well-known identifier or a generic string. Anything
404 // else is a malformed declspec.
405 bool IsString = Tok.getKind() == tok::string_literal ? true : false;
406 if (!IsString && Tok.getKind() != tok::identifier &&
407 Tok.getKind() != tok::kw_restrict) {
408 Diag(Tok, diag::err_ms_declspec_type);
409 T.skipToEnd();
410 return;
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000411 }
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000412
413 IdentifierInfo *AttrName;
414 SourceLocation AttrNameLoc;
415 if (IsString) {
416 SmallString<8> StrBuffer;
417 bool Invalid = false;
418 StringRef Str = PP.getSpelling(Tok, StrBuffer, &Invalid);
419 if (Invalid) {
420 T.skipToEnd();
421 return;
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000422 }
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000423 AttrName = PP.getIdentifierInfo(Str);
424 AttrNameLoc = ConsumeStringToken();
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000425 } else {
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000426 AttrName = Tok.getIdentifierInfo();
427 AttrNameLoc = ConsumeToken();
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000428 }
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000429
430 if (IsString || IsSimpleMicrosoftDeclSpec(AttrName))
431 // If we have a generic string, we will allow it because there is no
432 // documented list of allowable string declspecs, but we know they exist
433 // (for instance, SAL declspecs in older versions of MSVC).
434 //
435 // Alternatively, if the identifier is a simple one, then it requires no
436 // arguments and can be turned into an attribute directly.
437 Attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(),
438 0, 0, AttributeList::AS_Declspec);
439 else
440 ParseComplexMicrosoftDeclSpec(AttrName, AttrNameLoc, Attrs);
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000441 }
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000442 T.consumeClose();
Eli Friedman290eeb02009-06-08 23:27:34 +0000443}
444
John McCall7f040a92010-12-24 02:08:15 +0000445void Parser::ParseMicrosoftTypeAttributes(ParsedAttributes &attrs) {
Eli Friedman290eeb02009-06-08 23:27:34 +0000446 // Treat these like attributes
Eli Friedman290eeb02009-06-08 23:27:34 +0000447 while (Tok.is(tok::kw___fastcall) || Tok.is(tok::kw___stdcall) ||
Douglas Gregorf813a2c2010-05-18 16:57:00 +0000448 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___cdecl) ||
Francois Pichet3bd9aa42011-08-18 09:59:55 +0000449 Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64) ||
Francois Pichet58fd97a2011-08-25 00:36:46 +0000450 Tok.is(tok::kw___ptr32) ||
Francois Pichet3bd9aa42011-08-18 09:59:55 +0000451 Tok.is(tok::kw___unaligned)) {
Eli Friedman290eeb02009-06-08 23:27:34 +0000452 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
453 SourceLocation AttrNameLoc = ConsumeToken();
John McCall0b7e6782011-03-24 11:26:52 +0000454 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000455 SourceLocation(), 0, 0, AttributeList::AS_MSTypespec);
Eli Friedman290eeb02009-06-08 23:27:34 +0000456 }
Steve Narofff59e17e2008-12-24 20:59:21 +0000457}
458
John McCall7f040a92010-12-24 02:08:15 +0000459void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) {
Dawn Perchik52fc3142010-09-03 01:29:35 +0000460 // Treat these like attributes
461 while (Tok.is(tok::kw___pascal)) {
462 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
463 SourceLocation AttrNameLoc = ConsumeToken();
John McCall0b7e6782011-03-24 11:26:52 +0000464 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000465 SourceLocation(), 0, 0, AttributeList::AS_MSTypespec);
Dawn Perchik52fc3142010-09-03 01:29:35 +0000466 }
John McCall7f040a92010-12-24 02:08:15 +0000467}
468
Peter Collingbournef315fa82011-02-14 01:42:53 +0000469void Parser::ParseOpenCLAttributes(ParsedAttributes &attrs) {
470 // Treat these like attributes
471 while (Tok.is(tok::kw___kernel)) {
472 SourceLocation AttrNameLoc = ConsumeToken();
John McCall0b7e6782011-03-24 11:26:52 +0000473 attrs.addNew(PP.getIdentifierInfo("opencl_kernel_function"),
474 AttrNameLoc, 0, AttrNameLoc, 0,
Sean Hunt93f95f22012-06-18 16:13:52 +0000475 SourceLocation(), 0, 0, AttributeList::AS_GNU);
Peter Collingbournef315fa82011-02-14 01:42:53 +0000476 }
477}
478
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000479void Parser::ParseOpenCLQualifiers(DeclSpec &DS) {
480 SourceLocation Loc = Tok.getLocation();
481 switch(Tok.getKind()) {
482 // OpenCL qualifiers:
483 case tok::kw___private:
484 case tok::kw_private:
John McCall0b7e6782011-03-24 11:26:52 +0000485 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000486 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000487 PP.getIdentifierInfo("address_space"), Loc, 0);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000488 break;
489
490 case tok::kw___global:
John McCall0b7e6782011-03-24 11:26:52 +0000491 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000492 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000493 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_global);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000494 break;
495
496 case tok::kw___local:
John McCall0b7e6782011-03-24 11:26:52 +0000497 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000498 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000499 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_local);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000500 break;
501
502 case tok::kw___constant:
John McCall0b7e6782011-03-24 11:26:52 +0000503 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000504 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000505 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_constant);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000506 break;
507
508 case tok::kw___read_only:
John McCall0b7e6782011-03-24 11:26:52 +0000509 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000510 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000511 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_only);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000512 break;
513
514 case tok::kw___write_only:
John McCall0b7e6782011-03-24 11:26:52 +0000515 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000516 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000517 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_write_only);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000518 break;
519
520 case tok::kw___read_write:
John McCall0b7e6782011-03-24 11:26:52 +0000521 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000522 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000523 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_write);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000524 break;
525 default: break;
526 }
527}
528
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000529/// \brief Parse a version number.
530///
531/// version:
532/// simple-integer
533/// simple-integer ',' simple-integer
534/// simple-integer ',' simple-integer ',' simple-integer
535VersionTuple Parser::ParseVersionTuple(SourceRange &Range) {
536 Range = Tok.getLocation();
537
538 if (!Tok.is(tok::numeric_constant)) {
539 Diag(Tok, diag::err_expected_version);
540 SkipUntil(tok::comma, tok::r_paren, true, true, true);
541 return VersionTuple();
542 }
543
544 // Parse the major (and possibly minor and subminor) versions, which
545 // are stored in the numeric constant. We utilize a quirk of the
546 // lexer, which is that it handles something like 1.2.3 as a single
547 // numeric constant, rather than two separate tokens.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000548 SmallString<512> Buffer;
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000549 Buffer.resize(Tok.getLength()+1);
550 const char *ThisTokBegin = &Buffer[0];
551
552 // Get the spelling of the token, which eliminates trigraphs, etc.
553 bool Invalid = false;
554 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid);
555 if (Invalid)
556 return VersionTuple();
557
558 // Parse the major version.
559 unsigned AfterMajor = 0;
560 unsigned Major = 0;
561 while (AfterMajor < ActualLength && isdigit(ThisTokBegin[AfterMajor])) {
562 Major = Major * 10 + ThisTokBegin[AfterMajor] - '0';
563 ++AfterMajor;
564 }
565
566 if (AfterMajor == 0) {
567 Diag(Tok, diag::err_expected_version);
568 SkipUntil(tok::comma, tok::r_paren, true, true, true);
569 return VersionTuple();
570 }
571
572 if (AfterMajor == ActualLength) {
573 ConsumeToken();
574
575 // We only had a single version component.
576 if (Major == 0) {
577 Diag(Tok, diag::err_zero_version);
578 return VersionTuple();
579 }
580
581 return VersionTuple(Major);
582 }
583
584 if (ThisTokBegin[AfterMajor] != '.' || (AfterMajor + 1 == ActualLength)) {
585 Diag(Tok, diag::err_expected_version);
586 SkipUntil(tok::comma, tok::r_paren, true, true, true);
587 return VersionTuple();
588 }
589
590 // Parse the minor version.
591 unsigned AfterMinor = AfterMajor + 1;
592 unsigned Minor = 0;
593 while (AfterMinor < ActualLength && isdigit(ThisTokBegin[AfterMinor])) {
594 Minor = Minor * 10 + ThisTokBegin[AfterMinor] - '0';
595 ++AfterMinor;
596 }
597
598 if (AfterMinor == ActualLength) {
599 ConsumeToken();
600
601 // We had major.minor.
602 if (Major == 0 && Minor == 0) {
603 Diag(Tok, diag::err_zero_version);
604 return VersionTuple();
605 }
606
607 return VersionTuple(Major, Minor);
608 }
609
610 // If what follows is not a '.', we have a problem.
611 if (ThisTokBegin[AfterMinor] != '.') {
612 Diag(Tok, diag::err_expected_version);
613 SkipUntil(tok::comma, tok::r_paren, true, true, true);
614 return VersionTuple();
615 }
616
617 // Parse the subminor version.
618 unsigned AfterSubminor = AfterMinor + 1;
619 unsigned Subminor = 0;
620 while (AfterSubminor < ActualLength && isdigit(ThisTokBegin[AfterSubminor])) {
621 Subminor = Subminor * 10 + ThisTokBegin[AfterSubminor] - '0';
622 ++AfterSubminor;
623 }
624
625 if (AfterSubminor != ActualLength) {
626 Diag(Tok, diag::err_expected_version);
627 SkipUntil(tok::comma, tok::r_paren, true, true, true);
628 return VersionTuple();
629 }
630 ConsumeToken();
631 return VersionTuple(Major, Minor, Subminor);
632}
633
634/// \brief Parse the contents of the "availability" attribute.
635///
636/// availability-attribute:
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000637/// 'availability' '(' platform ',' version-arg-list, opt-message')'
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000638///
639/// platform:
640/// identifier
641///
642/// version-arg-list:
643/// version-arg
644/// version-arg ',' version-arg-list
645///
646/// version-arg:
647/// 'introduced' '=' version
648/// 'deprecated' '=' version
Douglas Gregor93a70672012-03-11 04:53:21 +0000649/// 'obsoleted' = version
Douglas Gregorb53e4172011-03-26 03:35:55 +0000650/// 'unavailable'
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000651/// opt-message:
652/// 'message' '=' <string>
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000653void Parser::ParseAvailabilityAttribute(IdentifierInfo &Availability,
654 SourceLocation AvailabilityLoc,
655 ParsedAttributes &attrs,
656 SourceLocation *endLoc) {
657 SourceLocation PlatformLoc;
658 IdentifierInfo *Platform = 0;
659
660 enum { Introduced, Deprecated, Obsoleted, Unknown };
661 AvailabilityChange Changes[Unknown];
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000662 ExprResult MessageExpr;
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000663
664 // Opening '('.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000665 BalancedDelimiterTracker T(*this, tok::l_paren);
666 if (T.consumeOpen()) {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000667 Diag(Tok, diag::err_expected_lparen);
668 return;
669 }
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000670
671 // Parse the platform name,
672 if (Tok.isNot(tok::identifier)) {
673 Diag(Tok, diag::err_availability_expected_platform);
674 SkipUntil(tok::r_paren);
675 return;
676 }
677 Platform = Tok.getIdentifierInfo();
678 PlatformLoc = ConsumeToken();
679
680 // Parse the ',' following the platform name.
681 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", tok::r_paren))
682 return;
683
684 // If we haven't grabbed the pointers for the identifiers
685 // "introduced", "deprecated", and "obsoleted", do so now.
686 if (!Ident_introduced) {
687 Ident_introduced = PP.getIdentifierInfo("introduced");
688 Ident_deprecated = PP.getIdentifierInfo("deprecated");
689 Ident_obsoleted = PP.getIdentifierInfo("obsoleted");
Douglas Gregorb53e4172011-03-26 03:35:55 +0000690 Ident_unavailable = PP.getIdentifierInfo("unavailable");
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000691 Ident_message = PP.getIdentifierInfo("message");
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000692 }
693
694 // Parse the set of introductions/deprecations/removals.
Douglas Gregorb53e4172011-03-26 03:35:55 +0000695 SourceLocation UnavailableLoc;
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000696 do {
697 if (Tok.isNot(tok::identifier)) {
698 Diag(Tok, diag::err_availability_expected_change);
699 SkipUntil(tok::r_paren);
700 return;
701 }
702 IdentifierInfo *Keyword = Tok.getIdentifierInfo();
703 SourceLocation KeywordLoc = ConsumeToken();
704
Douglas Gregorb53e4172011-03-26 03:35:55 +0000705 if (Keyword == Ident_unavailable) {
706 if (UnavailableLoc.isValid()) {
707 Diag(KeywordLoc, diag::err_availability_redundant)
708 << Keyword << SourceRange(UnavailableLoc);
709 }
710 UnavailableLoc = KeywordLoc;
711
712 if (Tok.isNot(tok::comma))
713 break;
714
715 ConsumeToken();
716 continue;
717 }
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000718
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000719 if (Tok.isNot(tok::equal)) {
720 Diag(Tok, diag::err_expected_equal_after)
721 << Keyword;
722 SkipUntil(tok::r_paren);
723 return;
724 }
725 ConsumeToken();
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000726 if (Keyword == Ident_message) {
727 if (!isTokenStringLiteral()) {
728 Diag(Tok, diag::err_expected_string_literal);
729 SkipUntil(tok::r_paren);
730 return;
731 }
732 MessageExpr = ParseStringLiteralExpression();
733 break;
734 }
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000735
736 SourceRange VersionRange;
737 VersionTuple Version = ParseVersionTuple(VersionRange);
738
739 if (Version.empty()) {
740 SkipUntil(tok::r_paren);
741 return;
742 }
743
744 unsigned Index;
745 if (Keyword == Ident_introduced)
746 Index = Introduced;
747 else if (Keyword == Ident_deprecated)
748 Index = Deprecated;
749 else if (Keyword == Ident_obsoleted)
750 Index = Obsoleted;
751 else
752 Index = Unknown;
753
754 if (Index < Unknown) {
755 if (!Changes[Index].KeywordLoc.isInvalid()) {
756 Diag(KeywordLoc, diag::err_availability_redundant)
757 << Keyword
758 << SourceRange(Changes[Index].KeywordLoc,
759 Changes[Index].VersionRange.getEnd());
760 }
761
762 Changes[Index].KeywordLoc = KeywordLoc;
763 Changes[Index].Version = Version;
764 Changes[Index].VersionRange = VersionRange;
765 } else {
766 Diag(KeywordLoc, diag::err_availability_unknown_change)
767 << Keyword << VersionRange;
768 }
769
770 if (Tok.isNot(tok::comma))
771 break;
772
773 ConsumeToken();
774 } while (true);
775
776 // Closing ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000777 if (T.consumeClose())
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000778 return;
779
780 if (endLoc)
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000781 *endLoc = T.getCloseLocation();
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000782
Douglas Gregorb53e4172011-03-26 03:35:55 +0000783 // The 'unavailable' availability cannot be combined with any other
784 // availability changes. Make sure that hasn't happened.
785 if (UnavailableLoc.isValid()) {
786 bool Complained = false;
787 for (unsigned Index = Introduced; Index != Unknown; ++Index) {
788 if (Changes[Index].KeywordLoc.isValid()) {
789 if (!Complained) {
790 Diag(UnavailableLoc, diag::warn_availability_and_unavailable)
791 << SourceRange(Changes[Index].KeywordLoc,
792 Changes[Index].VersionRange.getEnd());
793 Complained = true;
794 }
795
796 // Clear out the availability.
797 Changes[Index] = AvailabilityChange();
798 }
799 }
800 }
801
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000802 // Record this attribute
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000803 attrs.addNew(&Availability,
804 SourceRange(AvailabilityLoc, T.getCloseLocation()),
Fariborz Jahanianf96708d2012-01-23 23:38:32 +0000805 0, AvailabilityLoc,
John McCall0b7e6782011-03-24 11:26:52 +0000806 Platform, PlatformLoc,
807 Changes[Introduced],
808 Changes[Deprecated],
Douglas Gregorb53e4172011-03-26 03:35:55 +0000809 Changes[Obsoleted],
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000810 UnavailableLoc, MessageExpr.take(),
Sean Hunt93f95f22012-06-18 16:13:52 +0000811 AttributeList::AS_GNU);
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000812}
813
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000814
815// Late Parsed Attributes:
816// See other examples of late parsing in lib/Parse/ParseCXXInlineMethods
817
818void Parser::LateParsedDeclaration::ParseLexedAttributes() {}
819
820void Parser::LateParsedClass::ParseLexedAttributes() {
821 Self->ParseLexedAttributes(*Class);
822}
823
824void Parser::LateParsedAttribute::ParseLexedAttributes() {
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000825 Self->ParseLexedAttribute(*this, true, false);
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000826}
827
828/// Wrapper class which calls ParseLexedAttribute, after setting up the
829/// scope appropriately.
830void Parser::ParseLexedAttributes(ParsingClass &Class) {
831 // Deal with templates
832 // FIXME: Test cases to make sure this does the right thing for templates.
833 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
834 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
835 HasTemplateScope);
836 if (HasTemplateScope)
837 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
838
Douglas Gregorcefc3af2012-04-16 07:05:22 +0000839 // Set or update the scope flags.
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000840 bool AlreadyHasClassScope = Class.TopLevelClass;
Douglas Gregorcefc3af2012-04-16 07:05:22 +0000841 unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope;
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000842 ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope);
843 ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope);
844
DeLesley Hutchinscf2fa2f2012-04-06 15:10:17 +0000845 // Enter the scope of nested classes
846 if (!AlreadyHasClassScope)
847 Actions.ActOnStartDelayedMemberDeclarations(getCurScope(),
848 Class.TagOrTemplate);
Benjamin Kramer268efba2012-05-17 12:01:52 +0000849 if (!Class.LateParsedDeclarations.empty()) {
Douglas Gregorcefc3af2012-04-16 07:05:22 +0000850 // Allow 'this' within late-parsed attributes.
851 Sema::CXXThisScopeRAII ThisScope(Actions, Class.TagOrTemplate,
852 /*TypeQuals=*/0);
853
854 for (unsigned i = 0, ni = Class.LateParsedDeclarations.size(); i < ni; ++i){
855 Class.LateParsedDeclarations[i]->ParseLexedAttributes();
856 }
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000857 }
Douglas Gregorcefc3af2012-04-16 07:05:22 +0000858
DeLesley Hutchinscf2fa2f2012-04-06 15:10:17 +0000859 if (!AlreadyHasClassScope)
860 Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(),
861 Class.TagOrTemplate);
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000862}
863
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000864
865/// \brief Parse all attributes in LAs, and attach them to Decl D.
866void Parser::ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D,
867 bool EnterScope, bool OnDefinition) {
868 for (unsigned i = 0, ni = LAs.size(); i < ni; ++i) {
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +0000869 LAs[i]->addDecl(D);
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000870 ParseLexedAttribute(*LAs[i], EnterScope, OnDefinition);
Benjamin Kramerd306cf72012-04-14 12:44:47 +0000871 delete LAs[i];
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000872 }
873 LAs.clear();
874}
875
876
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000877/// \brief Finish parsing an attribute for which parsing was delayed.
878/// This will be called at the end of parsing a class declaration
879/// for each LateParsedAttribute. We consume the saved tokens and
880/// create an attribute with the arguments filled in. We add this
881/// to the Attribute list for the decl.
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000882void Parser::ParseLexedAttribute(LateParsedAttribute &LA,
883 bool EnterScope, bool OnDefinition) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000884 // Save the current token position.
885 SourceLocation OrigLoc = Tok.getLocation();
886
887 // Append the current token at the end of the new token stream so that it
888 // doesn't get lost.
889 LA.Toks.push_back(Tok);
890 PP.EnterTokenStream(LA.Toks.data(), LA.Toks.size(), true, false);
891 // Consume the previously pushed token.
892 ConsumeAnyToken();
893
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000894 if (OnDefinition && !IsThreadSafetyAttribute(LA.AttrName.getName())) {
895 Diag(Tok, diag::warn_attribute_on_function_definition)
896 << LA.AttrName.getName();
897 }
898
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000899 ParsedAttributes Attrs(AttrFactory);
900 SourceLocation endLoc;
901
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +0000902 if (LA.Decls.size() == 1) {
903 Decl *D = LA.Decls[0];
Caitlin Sadowskied9d84a2011-09-08 17:42:31 +0000904
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +0000905 // If the Decl is templatized, add template parameters to scope.
906 bool HasTemplateScope = EnterScope && D->isTemplateDecl();
907 ParseScope TempScope(this, Scope::TemplateParamScope, HasTemplateScope);
908 if (HasTemplateScope)
909 Actions.ActOnReenterTemplateScope(Actions.CurScope, D);
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000910
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +0000911 // If the Decl is on a function, add function parameters to the scope.
912 bool HasFunctionScope = EnterScope && D->isFunctionOrFunctionTemplate();
913 ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope, HasFunctionScope);
914 if (HasFunctionScope)
915 Actions.ActOnReenterFunctionContext(Actions.CurScope, D);
916
917 ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc);
918
919 if (HasFunctionScope) {
920 Actions.ActOnExitFunctionContext();
921 FnScope.Exit(); // Pop scope, and remove Decls from IdResolver
922 }
923 if (HasTemplateScope) {
924 TempScope.Exit();
925 }
DeLesley Hutchins7ec419a2012-03-02 22:29:50 +0000926 } else if (LA.Decls.size() > 0) {
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +0000927 // If there are multiple decls, then the decl cannot be within the
928 // function scope.
929 ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc);
DeLesley Hutchins7ec419a2012-03-02 22:29:50 +0000930 } else {
931 Diag(Tok, diag::warn_attribute_no_decl) << LA.AttrName.getName();
Caitlin Sadowskied9d84a2011-09-08 17:42:31 +0000932 }
933
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +0000934 for (unsigned i = 0, ni = LA.Decls.size(); i < ni; ++i) {
935 Actions.ActOnFinishDelayedAttribute(getCurScope(), LA.Decls[i], Attrs);
936 }
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000937
938 if (Tok.getLocation() != OrigLoc) {
939 // Due to a parsing error, we either went over the cached tokens or
940 // there are still cached tokens left, so we skip the leftover tokens.
941 // Since this is an uncommon situation that should be avoided, use the
942 // expensive isBeforeInTranslationUnit call.
943 if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(),
944 OrigLoc))
945 while (Tok.getLocation() != OrigLoc && Tok.isNot(tok::eof))
Douglas Gregord78ef5b2012-03-08 01:00:17 +0000946 ConsumeAnyToken();
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000947 }
948}
949
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000950/// \brief Wrapper around a case statement checking if AttrName is
951/// one of the thread safety attributes
952bool Parser::IsThreadSafetyAttribute(llvm::StringRef AttrName){
953 return llvm::StringSwitch<bool>(AttrName)
954 .Case("guarded_by", true)
955 .Case("guarded_var", true)
956 .Case("pt_guarded_by", true)
957 .Case("pt_guarded_var", true)
958 .Case("lockable", true)
959 .Case("scoped_lockable", true)
960 .Case("no_thread_safety_analysis", true)
961 .Case("acquired_after", true)
962 .Case("acquired_before", true)
963 .Case("exclusive_lock_function", true)
964 .Case("shared_lock_function", true)
965 .Case("exclusive_trylock_function", true)
966 .Case("shared_trylock_function", true)
967 .Case("unlock_function", true)
968 .Case("lock_returned", true)
969 .Case("locks_excluded", true)
970 .Case("exclusive_locks_required", true)
971 .Case("shared_locks_required", true)
972 .Default(false);
973}
974
975/// \brief Parse the contents of thread safety attributes. These
976/// should always be parsed as an expression list.
977///
978/// We need to special case the parsing due to the fact that if the first token
979/// of the first argument is an identifier, the main parse loop will store
980/// that token as a "parameter" and the rest of
981/// the arguments will be added to a list of "arguments". However,
982/// subsequent tokens in the first argument are lost. We instead parse each
983/// argument as an expression and add all arguments to the list of "arguments".
984/// In future, we will take advantage of this special case to also
985/// deal with some argument scoping issues here (for example, referring to a
986/// function parameter in the attribute on that function).
987void Parser::ParseThreadSafetyAttribute(IdentifierInfo &AttrName,
988 SourceLocation AttrNameLoc,
989 ParsedAttributes &Attrs,
990 SourceLocation *EndLoc) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000991 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000992
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000993 BalancedDelimiterTracker T(*this, tok::l_paren);
994 T.consumeOpen();
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000995
996 ExprVector ArgExprs(Actions);
997 bool ArgExprsOk = true;
998
999 // now parse the list of expressions
DeLesley Hutchins4805f152011-12-14 19:36:06 +00001000 while (Tok.isNot(tok::r_paren)) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +00001001 ExprResult ArgExpr(ParseAssignmentExpression());
1002 if (ArgExpr.isInvalid()) {
1003 ArgExprsOk = false;
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001004 T.consumeClose();
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +00001005 break;
1006 } else {
1007 ArgExprs.push_back(ArgExpr.release());
Caitlin Sadowskib51e0312011-08-09 17:59:31 +00001008 }
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +00001009 if (Tok.isNot(tok::comma))
1010 break;
1011 ConsumeToken(); // Eat the comma, move to the next argument
1012 }
1013 // Match the ')'.
DeLesley Hutchins23323e02012-01-20 22:50:54 +00001014 if (ArgExprsOk && !T.consumeClose()) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +00001015 Attrs.addNew(&AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(),
Sean Hunt93f95f22012-06-18 16:13:52 +00001016 ArgExprs.take(), ArgExprs.size(), AttributeList::AS_GNU);
Caitlin Sadowskib51e0312011-08-09 17:59:31 +00001017 }
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001018 if (EndLoc)
1019 *EndLoc = T.getCloseLocation();
Caitlin Sadowskib51e0312011-08-09 17:59:31 +00001020}
1021
Richard Smith6ee326a2012-04-10 01:32:12 +00001022/// DiagnoseProhibitedCXX11Attribute - We have found the opening square brackets
1023/// of a C++11 attribute-specifier in a location where an attribute is not
1024/// permitted. By C++11 [dcl.attr.grammar]p6, this is ill-formed. Diagnose this
1025/// situation.
1026///
1027/// \return \c true if we skipped an attribute-like chunk of tokens, \c false if
1028/// this doesn't appear to actually be an attribute-specifier, and the caller
1029/// should try to parse it.
1030bool Parser::DiagnoseProhibitedCXX11Attribute() {
1031 assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square));
1032
1033 switch (isCXX11AttributeSpecifier(/*Disambiguate*/true)) {
1034 case CAK_NotAttributeSpecifier:
1035 // No diagnostic: we're in Obj-C++11 and this is not actually an attribute.
1036 return false;
1037
1038 case CAK_InvalidAttributeSpecifier:
1039 Diag(Tok.getLocation(), diag::err_l_square_l_square_not_attribute);
1040 return false;
1041
1042 case CAK_AttributeSpecifier:
1043 // Parse and discard the attributes.
1044 SourceLocation BeginLoc = ConsumeBracket();
1045 ConsumeBracket();
1046 SkipUntil(tok::r_square, /*StopAtSemi*/ false);
1047 assert(Tok.is(tok::r_square) && "isCXX11AttributeSpecifier lied");
1048 SourceLocation EndLoc = ConsumeBracket();
1049 Diag(BeginLoc, diag::err_attributes_not_allowed)
1050 << SourceRange(BeginLoc, EndLoc);
1051 return true;
1052 }
Chandler Carruth2c6dbd72012-04-10 16:03:08 +00001053 llvm_unreachable("All cases handled above.");
Richard Smith6ee326a2012-04-10 01:32:12 +00001054}
1055
John McCall7f040a92010-12-24 02:08:15 +00001056void Parser::DiagnoseProhibitedAttributes(ParsedAttributesWithRange &attrs) {
1057 Diag(attrs.Range.getBegin(), diag::err_attributes_not_allowed)
1058 << attrs.Range;
Dawn Perchik52fc3142010-09-03 01:29:35 +00001059}
1060
Reid Spencer5f016e22007-07-11 17:01:13 +00001061/// ParseDeclaration - Parse a full 'declaration', which consists of
1062/// declaration-specifiers, some number of declarators, and a semicolon.
Chris Lattner97144fc2009-04-02 04:16:50 +00001063/// 'Context' should be a Declarator::TheContext value. This returns the
1064/// location of the semicolon in DeclEnd.
Chris Lattner8f08cb72007-08-25 06:57:03 +00001065///
1066/// declaration: [C99 6.7]
1067/// block-declaration ->
1068/// simple-declaration
1069/// others [FIXME]
Douglas Gregoradcac882008-12-01 23:54:00 +00001070/// [C++] template-declaration
Chris Lattner8f08cb72007-08-25 06:57:03 +00001071/// [C++] namespace-definition
Douglas Gregorf780abc2008-12-30 03:27:21 +00001072/// [C++] using-directive
Douglas Gregord7f37bf2009-06-22 23:06:13 +00001073/// [C++] using-declaration
Richard Smith534986f2012-04-14 00:33:13 +00001074/// [C++11/C11] static_assert-declaration
Chris Lattner8f08cb72007-08-25 06:57:03 +00001075/// others... [FIXME]
1076///
Fariborz Jahanianc5be7b02010-09-28 20:42:35 +00001077Parser::DeclGroupPtrTy Parser::ParseDeclaration(StmtVector &Stmts,
1078 unsigned Context,
Sean Huntbbd37c62009-11-21 08:43:09 +00001079 SourceLocation &DeclEnd,
John McCall7f040a92010-12-24 02:08:15 +00001080 ParsedAttributesWithRange &attrs) {
Argyrios Kyrtzidis36d36802010-06-17 10:52:18 +00001081 ParenBraceBracketBalancer BalancerRAIIObj(*this);
Fariborz Jahaniane8cff362011-08-30 17:10:52 +00001082 // Must temporarily exit the objective-c container scope for
1083 // parsing c none objective-c decls.
1084 ObjCDeclContextSwitch ObjCDC(*this);
Argyrios Kyrtzidis36d36802010-06-17 10:52:18 +00001085
John McCalld226f652010-08-21 09:40:31 +00001086 Decl *SingleDecl = 0;
Richard Smithc89edf52011-07-01 19:46:12 +00001087 Decl *OwnedType = 0;
Chris Lattner8f08cb72007-08-25 06:57:03 +00001088 switch (Tok.getKind()) {
Douglas Gregoradcac882008-12-01 23:54:00 +00001089 case tok::kw_template:
Douglas Gregor1426e532009-05-12 21:31:51 +00001090 case tok::kw_export:
John McCall7f040a92010-12-24 02:08:15 +00001091 ProhibitAttributes(attrs);
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001092 SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +00001093 break;
Sebastian Redld078e642010-08-27 23:12:46 +00001094 case tok::kw_inline:
Sebastian Redl88e64ca2010-08-31 00:36:45 +00001095 // Could be the start of an inline namespace. Allowed as an ext in C++03.
David Blaikie4e4d0842012-03-11 07:00:24 +00001096 if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_namespace)) {
John McCall7f040a92010-12-24 02:08:15 +00001097 ProhibitAttributes(attrs);
Sebastian Redld078e642010-08-27 23:12:46 +00001098 SourceLocation InlineLoc = ConsumeToken();
1099 SingleDecl = ParseNamespace(Context, DeclEnd, InlineLoc);
1100 break;
1101 }
John McCall7f040a92010-12-24 02:08:15 +00001102 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs,
Fariborz Jahanianc5be7b02010-09-28 20:42:35 +00001103 true);
Chris Lattner8f08cb72007-08-25 06:57:03 +00001104 case tok::kw_namespace:
John McCall7f040a92010-12-24 02:08:15 +00001105 ProhibitAttributes(attrs);
Chris Lattner97144fc2009-04-02 04:16:50 +00001106 SingleDecl = ParseNamespace(Context, DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +00001107 break;
Douglas Gregorf780abc2008-12-30 03:27:21 +00001108 case tok::kw_using:
John McCall78b81052010-11-10 02:40:36 +00001109 SingleDecl = ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(),
Richard Smithc89edf52011-07-01 19:46:12 +00001110 DeclEnd, attrs, &OwnedType);
Chris Lattner682bf922009-03-29 16:50:03 +00001111 break;
Anders Carlsson511d7ab2009-03-11 16:27:10 +00001112 case tok::kw_static_assert:
Peter Collingbournec6eb44b2011-04-15 00:35:57 +00001113 case tok::kw__Static_assert:
John McCall7f040a92010-12-24 02:08:15 +00001114 ProhibitAttributes(attrs);
Chris Lattner97144fc2009-04-02 04:16:50 +00001115 SingleDecl = ParseStaticAssertDeclaration(DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +00001116 break;
Chris Lattner8f08cb72007-08-25 06:57:03 +00001117 default:
John McCall7f040a92010-12-24 02:08:15 +00001118 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs, true);
Chris Lattner8f08cb72007-08-25 06:57:03 +00001119 }
Sean Huntbbd37c62009-11-21 08:43:09 +00001120
Chris Lattner682bf922009-03-29 16:50:03 +00001121 // This routine returns a DeclGroup, if the thing we parsed only contains a
Richard Smithc89edf52011-07-01 19:46:12 +00001122 // single decl, convert it now. Alias declarations can also declare a type;
1123 // include that too if it is present.
1124 return Actions.ConvertDeclToDeclGroup(SingleDecl, OwnedType);
Chris Lattner8f08cb72007-08-25 06:57:03 +00001125}
1126
1127/// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
1128/// declaration-specifiers init-declarator-list[opt] ';'
Sean Hunt2edf0a22012-06-23 05:07:58 +00001129/// [C++11] attribute-specifier-seq decl-specifier-seq[opt]
1130/// init-declarator-list ';'
Chris Lattner8f08cb72007-08-25 06:57:03 +00001131///[C90/C++]init-declarator-list ';' [TODO]
1132/// [OMP] threadprivate-directive [TODO]
Chris Lattnercd147752009-03-29 17:27:48 +00001133///
Sean Hunt2edf0a22012-06-23 05:07:58 +00001134/// for-range-declaration: [C++11 6.5p1: stmt.ranged]
Richard Smithad762fc2011-04-14 22:09:26 +00001135/// attribute-specifier-seq[opt] type-specifier-seq declarator
1136///
Chris Lattnercd147752009-03-29 17:27:48 +00001137/// If RequireSemi is false, this does not check for a ';' at the end of the
Chris Lattner5c5db552010-04-05 18:18:31 +00001138/// declaration. If it is true, it checks for and eats it.
Richard Smithad762fc2011-04-14 22:09:26 +00001139///
1140/// If FRI is non-null, we might be parsing a for-range-declaration instead
1141/// of a simple-declaration. If we find that we are, we also parse the
1142/// for-range-initializer, and place it here.
Sean Hunt2edf0a22012-06-23 05:07:58 +00001143Parser::DeclGroupPtrTy
1144Parser::ParseSimpleDeclaration(StmtVector &Stmts, unsigned Context,
1145 SourceLocation &DeclEnd,
1146 ParsedAttributesWithRange &attrs,
1147 bool RequireSemi, ForRangeInit *FRI) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001148 // Parse the common declaration-specifiers piece.
John McCall54abf7d2009-11-04 02:18:39 +00001149 ParsingDeclSpec DS(*this);
John McCall7f040a92010-12-24 02:08:15 +00001150 DS.takeAttributesFrom(attrs);
Douglas Gregor312eadb2011-04-24 05:37:28 +00001151
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001152 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none,
Richard Smith34b41d92011-02-20 03:19:35 +00001153 getDeclSpecContextFromDeclaratorContext(Context));
Abramo Bagnara06284c12012-01-07 10:52:36 +00001154
Reid Spencer5f016e22007-07-11 17:01:13 +00001155 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
1156 // declaration-specifiers init-declarator-list[opt] ';'
Chris Lattner04d66662007-10-09 17:33:22 +00001157 if (Tok.is(tok::semi)) {
Argyrios Kyrtzidis5641b0d2012-05-16 23:49:15 +00001158 DeclEnd = Tok.getLocation();
Chris Lattner5c5db552010-04-05 18:18:31 +00001159 if (RequireSemi) ConsumeToken();
John McCalld226f652010-08-21 09:40:31 +00001160 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
Douglas Gregor312eadb2011-04-24 05:37:28 +00001161 DS);
John McCall54abf7d2009-11-04 02:18:39 +00001162 DS.complete(TheDecl);
Chris Lattner682bf922009-03-29 16:50:03 +00001163 return Actions.ConvertDeclToDeclGroup(TheDecl);
Reid Spencer5f016e22007-07-11 17:01:13 +00001164 }
Douglas Gregor312eadb2011-04-24 05:37:28 +00001165
1166 return ParseDeclGroup(DS, Context, /*FunctionDefs=*/ false, &DeclEnd, FRI);
John McCalld8ac0572009-11-03 19:26:08 +00001167}
Mike Stump1eb44332009-09-09 15:08:12 +00001168
Richard Smith0706df42011-10-19 21:33:05 +00001169/// Returns true if this might be the start of a declarator, or a common typo
1170/// for a declarator.
1171bool Parser::MightBeDeclarator(unsigned Context) {
1172 switch (Tok.getKind()) {
1173 case tok::annot_cxxscope:
1174 case tok::annot_template_id:
1175 case tok::caret:
1176 case tok::code_completion:
1177 case tok::coloncolon:
1178 case tok::ellipsis:
1179 case tok::kw___attribute:
1180 case tok::kw_operator:
1181 case tok::l_paren:
1182 case tok::star:
1183 return true;
1184
1185 case tok::amp:
1186 case tok::ampamp:
David Blaikie4e4d0842012-03-11 07:00:24 +00001187 return getLangOpts().CPlusPlus;
Richard Smith0706df42011-10-19 21:33:05 +00001188
Richard Smith1c94c162012-01-09 22:31:44 +00001189 case tok::l_square: // Might be an attribute on an unnamed bit-field.
David Blaikie4e4d0842012-03-11 07:00:24 +00001190 return Context == Declarator::MemberContext && getLangOpts().CPlusPlus0x &&
Richard Smith1c94c162012-01-09 22:31:44 +00001191 NextToken().is(tok::l_square);
1192
1193 case tok::colon: // Might be a typo for '::' or an unnamed bit-field.
David Blaikie4e4d0842012-03-11 07:00:24 +00001194 return Context == Declarator::MemberContext || getLangOpts().CPlusPlus;
Richard Smith1c94c162012-01-09 22:31:44 +00001195
Richard Smith0706df42011-10-19 21:33:05 +00001196 case tok::identifier:
1197 switch (NextToken().getKind()) {
1198 case tok::code_completion:
1199 case tok::coloncolon:
1200 case tok::comma:
1201 case tok::equal:
1202 case tok::equalequal: // Might be a typo for '='.
1203 case tok::kw_alignas:
1204 case tok::kw_asm:
1205 case tok::kw___attribute:
1206 case tok::l_brace:
1207 case tok::l_paren:
1208 case tok::l_square:
1209 case tok::less:
1210 case tok::r_brace:
1211 case tok::r_paren:
1212 case tok::r_square:
1213 case tok::semi:
1214 return true;
1215
1216 case tok::colon:
1217 // At namespace scope, 'identifier:' is probably a typo for 'identifier::'
Richard Smith1c94c162012-01-09 22:31:44 +00001218 // and in block scope it's probably a label. Inside a class definition,
1219 // this is a bit-field.
1220 return Context == Declarator::MemberContext ||
David Blaikie4e4d0842012-03-11 07:00:24 +00001221 (getLangOpts().CPlusPlus && Context == Declarator::FileContext);
Richard Smith1c94c162012-01-09 22:31:44 +00001222
1223 case tok::identifier: // Possible virt-specifier.
David Blaikie4e4d0842012-03-11 07:00:24 +00001224 return getLangOpts().CPlusPlus0x && isCXX0XVirtSpecifier(NextToken());
Richard Smith0706df42011-10-19 21:33:05 +00001225
1226 default:
1227 return false;
1228 }
1229
1230 default:
1231 return false;
1232 }
1233}
1234
Richard Smith994d73f2012-04-11 20:59:20 +00001235/// Skip until we reach something which seems like a sensible place to pick
1236/// up parsing after a malformed declaration. This will sometimes stop sooner
1237/// than SkipUntil(tok::r_brace) would, but will never stop later.
1238void Parser::SkipMalformedDecl() {
1239 while (true) {
1240 switch (Tok.getKind()) {
1241 case tok::l_brace:
1242 // Skip until matching }, then stop. We've probably skipped over
1243 // a malformed class or function definition or similar.
1244 ConsumeBrace();
1245 SkipUntil(tok::r_brace, /*StopAtSemi*/false);
1246 if (Tok.is(tok::comma) || Tok.is(tok::l_brace) || Tok.is(tok::kw_try)) {
1247 // This declaration isn't over yet. Keep skipping.
1248 continue;
1249 }
1250 if (Tok.is(tok::semi))
1251 ConsumeToken();
1252 return;
1253
1254 case tok::l_square:
1255 ConsumeBracket();
1256 SkipUntil(tok::r_square, /*StopAtSemi*/false);
1257 continue;
1258
1259 case tok::l_paren:
1260 ConsumeParen();
1261 SkipUntil(tok::r_paren, /*StopAtSemi*/false);
1262 continue;
1263
1264 case tok::r_brace:
1265 return;
1266
1267 case tok::semi:
1268 ConsumeToken();
1269 return;
1270
1271 case tok::kw_inline:
1272 // 'inline namespace' at the start of a line is almost certainly
1273 // a good place to pick back up parsing.
1274 if (Tok.isAtStartOfLine() && NextToken().is(tok::kw_namespace))
1275 return;
1276 break;
1277
1278 case tok::kw_namespace:
1279 // 'namespace' at the start of a line is almost certainly a good
1280 // place to pick back up parsing.
1281 if (Tok.isAtStartOfLine())
1282 return;
1283 break;
1284
1285 case tok::eof:
1286 return;
1287
1288 default:
1289 break;
1290 }
1291
1292 ConsumeAnyToken();
1293 }
1294}
1295
John McCalld8ac0572009-11-03 19:26:08 +00001296/// ParseDeclGroup - Having concluded that this is either a function
1297/// definition or a group of object declarations, actually parse the
1298/// result.
John McCall54abf7d2009-11-04 02:18:39 +00001299Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS,
1300 unsigned Context,
John McCalld8ac0572009-11-03 19:26:08 +00001301 bool AllowFunctionDefinitions,
Richard Smithad762fc2011-04-14 22:09:26 +00001302 SourceLocation *DeclEnd,
1303 ForRangeInit *FRI) {
John McCalld8ac0572009-11-03 19:26:08 +00001304 // Parse the first declarator.
John McCall54abf7d2009-11-04 02:18:39 +00001305 ParsingDeclarator D(*this, DS, static_cast<Declarator::TheContext>(Context));
John McCalld8ac0572009-11-03 19:26:08 +00001306 ParseDeclarator(D);
Chris Lattnercd147752009-03-29 17:27:48 +00001307
John McCalld8ac0572009-11-03 19:26:08 +00001308 // Bail out if the first declarator didn't seem well-formed.
1309 if (!D.hasName() && !D.mayOmitIdentifier()) {
Richard Smith994d73f2012-04-11 20:59:20 +00001310 SkipMalformedDecl();
John McCalld8ac0572009-11-03 19:26:08 +00001311 return DeclGroupPtrTy();
Chris Lattner23c4b182009-03-29 17:18:04 +00001312 }
Mike Stump1eb44332009-09-09 15:08:12 +00001313
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001314 // Save late-parsed attributes for now; they need to be parsed in the
1315 // appropriate function scope after the function Decl has been constructed.
1316 LateParsedAttrList LateParsedAttrs;
1317 if (D.isFunctionDeclarator())
1318 MaybeParseGNUAttributes(D, &LateParsedAttrs);
1319
Chris Lattnerc82daef2010-07-11 22:24:20 +00001320 // Check to see if we have a function *definition* which must have a body.
1321 if (AllowFunctionDefinitions && D.isFunctionDeclarator() &&
1322 // Look at the next token to make sure that this isn't a function
1323 // declaration. We have to check this because __attribute__ might be the
1324 // start of a function definition in GCC-extended K&R C.
1325 !isDeclarationAfterDeclarator()) {
Richard Smith58196dc2011-11-30 23:45:35 +00001326
Chris Lattner004659a2010-07-11 22:42:07 +00001327 if (isStartOfFunctionDefinition(D)) {
John McCalld8ac0572009-11-03 19:26:08 +00001328 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
1329 Diag(Tok, diag::err_function_declared_typedef);
1330
1331 // Recover by treating the 'typedef' as spurious.
1332 DS.ClearStorageClassSpecs();
1333 }
1334
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001335 Decl *TheDecl =
1336 ParseFunctionDefinition(D, ParsedTemplateInfo(), &LateParsedAttrs);
John McCalld8ac0572009-11-03 19:26:08 +00001337 return Actions.ConvertDeclToDeclGroup(TheDecl);
Chris Lattner004659a2010-07-11 22:42:07 +00001338 }
1339
1340 if (isDeclarationSpecifier()) {
1341 // If there is an invalid declaration specifier right after the function
1342 // prototype, then we must be in a missing semicolon case where this isn't
1343 // actually a body. Just fall through into the code that handles it as a
1344 // prototype, and let the top-level code handle the erroneous declspec
1345 // where it would otherwise expect a comma or semicolon.
John McCalld8ac0572009-11-03 19:26:08 +00001346 } else {
1347 Diag(Tok, diag::err_expected_fn_body);
1348 SkipUntil(tok::semi);
1349 return DeclGroupPtrTy();
1350 }
1351 }
1352
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001353 if (ParseAsmAttributesAfterDeclarator(D))
Richard Smithad762fc2011-04-14 22:09:26 +00001354 return DeclGroupPtrTy();
1355
1356 // C++0x [stmt.iter]p1: Check if we have a for-range-declarator. If so, we
1357 // must parse and analyze the for-range-initializer before the declaration is
1358 // analyzed.
1359 if (FRI && Tok.is(tok::colon)) {
1360 FRI->ColonLoc = ConsumeToken();
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001361 if (Tok.is(tok::l_brace))
1362 FRI->RangeExpr = ParseBraceInitializer();
1363 else
1364 FRI->RangeExpr = ParseExpression();
Richard Smithad762fc2011-04-14 22:09:26 +00001365 Decl *ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
1366 Actions.ActOnCXXForRangeDecl(ThisDecl);
1367 Actions.FinalizeDeclaration(ThisDecl);
John McCall6895a642012-01-27 01:29:43 +00001368 D.complete(ThisDecl);
Richard Smithad762fc2011-04-14 22:09:26 +00001369 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, &ThisDecl, 1);
1370 }
1371
Chris Lattner5f9e2722011-07-23 10:55:15 +00001372 SmallVector<Decl *, 8> DeclsInGroup;
Richard Smithad762fc2011-04-14 22:09:26 +00001373 Decl *FirstDecl = ParseDeclarationAfterDeclaratorAndAttributes(D);
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001374 if (LateParsedAttrs.size() > 0)
1375 ParseLexedAttributeList(LateParsedAttrs, FirstDecl, true, false);
John McCall54abf7d2009-11-04 02:18:39 +00001376 D.complete(FirstDecl);
John McCalld226f652010-08-21 09:40:31 +00001377 if (FirstDecl)
John McCalld8ac0572009-11-03 19:26:08 +00001378 DeclsInGroup.push_back(FirstDecl);
1379
Richard Smith0706df42011-10-19 21:33:05 +00001380 bool ExpectSemi = Context != Declarator::ForContext;
1381
John McCalld8ac0572009-11-03 19:26:08 +00001382 // If we don't have a comma, it is either the end of the list (a ';') or an
1383 // error, bail out.
1384 while (Tok.is(tok::comma)) {
Richard Smith0706df42011-10-19 21:33:05 +00001385 SourceLocation CommaLoc = ConsumeToken();
1386
1387 if (Tok.isAtStartOfLine() && ExpectSemi && !MightBeDeclarator(Context)) {
1388 // This comma was followed by a line-break and something which can't be
1389 // the start of a declarator. The comma was probably a typo for a
1390 // semicolon.
1391 Diag(CommaLoc, diag::err_expected_semi_declaration)
1392 << FixItHint::CreateReplacement(CommaLoc, ";");
1393 ExpectSemi = false;
1394 break;
1395 }
John McCalld8ac0572009-11-03 19:26:08 +00001396
1397 // Parse the next declarator.
1398 D.clear();
Richard Smith7984de32012-01-12 23:53:29 +00001399 D.setCommaLoc(CommaLoc);
John McCalld8ac0572009-11-03 19:26:08 +00001400
1401 // Accept attributes in an init-declarator. In the first declarator in a
1402 // declaration, these would be part of the declspec. In subsequent
1403 // declarators, they become part of the declarator itself, so that they
1404 // don't apply to declarators after *this* one. Examples:
1405 // short __attribute__((common)) var; -> declspec
1406 // short var __attribute__((common)); -> declarator
1407 // short x, __attribute__((common)) var; -> declarator
John McCall7f040a92010-12-24 02:08:15 +00001408 MaybeParseGNUAttributes(D);
John McCalld8ac0572009-11-03 19:26:08 +00001409
1410 ParseDeclarator(D);
Fariborz Jahanian9baf39d2012-01-13 00:14:12 +00001411 if (!D.isInvalidType()) {
1412 Decl *ThisDecl = ParseDeclarationAfterDeclarator(D);
1413 D.complete(ThisDecl);
1414 if (ThisDecl)
1415 DeclsInGroup.push_back(ThisDecl);
1416 }
John McCalld8ac0572009-11-03 19:26:08 +00001417 }
1418
1419 if (DeclEnd)
1420 *DeclEnd = Tok.getLocation();
1421
Richard Smith0706df42011-10-19 21:33:05 +00001422 if (ExpectSemi &&
Chris Lattner8bb21d32012-04-28 16:12:17 +00001423 ExpectAndConsumeSemi(Context == Declarator::FileContext
1424 ? diag::err_invalid_token_after_toplevel_declarator
1425 : diag::err_expected_semi_declaration)) {
Chris Lattner004659a2010-07-11 22:42:07 +00001426 // Okay, there was no semicolon and one was expected. If we see a
1427 // declaration specifier, just assume it was missing and continue parsing.
1428 // Otherwise things are very confused and we skip to recover.
1429 if (!isDeclarationSpecifier()) {
1430 SkipUntil(tok::r_brace, true, true);
1431 if (Tok.is(tok::semi))
1432 ConsumeToken();
1433 }
John McCalld8ac0572009-11-03 19:26:08 +00001434 }
1435
Douglas Gregor23c94db2010-07-02 17:43:08 +00001436 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS,
John McCalld8ac0572009-11-03 19:26:08 +00001437 DeclsInGroup.data(),
1438 DeclsInGroup.size());
Reid Spencer5f016e22007-07-11 17:01:13 +00001439}
1440
Richard Smithad762fc2011-04-14 22:09:26 +00001441/// Parse an optional simple-asm-expr and attributes, and attach them to a
1442/// declarator. Returns true on an error.
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001443bool Parser::ParseAsmAttributesAfterDeclarator(Declarator &D) {
Richard Smithad762fc2011-04-14 22:09:26 +00001444 // If a simple-asm-expr is present, parse it.
1445 if (Tok.is(tok::kw_asm)) {
1446 SourceLocation Loc;
1447 ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1448 if (AsmLabel.isInvalid()) {
1449 SkipUntil(tok::semi, true, true);
1450 return true;
1451 }
1452
1453 D.setAsmLabel(AsmLabel.release());
1454 D.SetRangeEnd(Loc);
1455 }
1456
1457 MaybeParseGNUAttributes(D);
1458 return false;
1459}
1460
Douglas Gregor1426e532009-05-12 21:31:51 +00001461/// \brief Parse 'declaration' after parsing 'declaration-specifiers
1462/// declarator'. This method parses the remainder of the declaration
1463/// (including any attributes or initializer, among other things) and
1464/// finalizes the declaration.
Reid Spencer5f016e22007-07-11 17:01:13 +00001465///
Reid Spencer5f016e22007-07-11 17:01:13 +00001466/// init-declarator: [C99 6.7]
1467/// declarator
1468/// declarator '=' initializer
1469/// [GNU] declarator simple-asm-expr[opt] attributes[opt]
1470/// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001471/// [C++] declarator initializer[opt]
1472///
1473/// [C++] initializer:
1474/// [C++] '=' initializer-clause
1475/// [C++] '(' expression-list ')'
Sebastian Redl50de12f2009-03-24 22:27:57 +00001476/// [C++0x] '=' 'default' [TODO]
1477/// [C++0x] '=' 'delete'
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001478/// [C++0x] braced-init-list
Sebastian Redl50de12f2009-03-24 22:27:57 +00001479///
1480/// According to the standard grammar, =default and =delete are function
1481/// definitions, but that definitely doesn't fit with the parser here.
Reid Spencer5f016e22007-07-11 17:01:13 +00001482///
John McCalld226f652010-08-21 09:40:31 +00001483Decl *Parser::ParseDeclarationAfterDeclarator(Declarator &D,
Douglas Gregore542c862009-06-23 23:11:28 +00001484 const ParsedTemplateInfo &TemplateInfo) {
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001485 if (ParseAsmAttributesAfterDeclarator(D))
Richard Smithad762fc2011-04-14 22:09:26 +00001486 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001487
Richard Smithad762fc2011-04-14 22:09:26 +00001488 return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo);
1489}
Mike Stump1eb44332009-09-09 15:08:12 +00001490
Richard Smithad762fc2011-04-14 22:09:26 +00001491Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(Declarator &D,
1492 const ParsedTemplateInfo &TemplateInfo) {
Douglas Gregor1426e532009-05-12 21:31:51 +00001493 // Inform the current actions module that we just parsed this declarator.
John McCalld226f652010-08-21 09:40:31 +00001494 Decl *ThisDecl = 0;
Douglas Gregord5a423b2009-09-25 18:43:00 +00001495 switch (TemplateInfo.Kind) {
1496 case ParsedTemplateInfo::NonTemplate:
Douglas Gregor23c94db2010-07-02 17:43:08 +00001497 ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
Douglas Gregord5a423b2009-09-25 18:43:00 +00001498 break;
1499
1500 case ParsedTemplateInfo::Template:
1501 case ParsedTemplateInfo::ExplicitSpecialization:
Douglas Gregor23c94db2010-07-02 17:43:08 +00001502 ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
John McCallf312b1e2010-08-26 23:41:50 +00001503 MultiTemplateParamsArg(Actions,
Douglas Gregore542c862009-06-23 23:11:28 +00001504 TemplateInfo.TemplateParams->data(),
1505 TemplateInfo.TemplateParams->size()),
Douglas Gregord5a423b2009-09-25 18:43:00 +00001506 D);
1507 break;
1508
1509 case ParsedTemplateInfo::ExplicitInstantiation: {
John McCalld226f652010-08-21 09:40:31 +00001510 DeclResult ThisRes
Douglas Gregor23c94db2010-07-02 17:43:08 +00001511 = Actions.ActOnExplicitInstantiation(getCurScope(),
Douglas Gregord5a423b2009-09-25 18:43:00 +00001512 TemplateInfo.ExternLoc,
1513 TemplateInfo.TemplateLoc,
1514 D);
1515 if (ThisRes.isInvalid()) {
1516 SkipUntil(tok::semi, true, true);
John McCalld226f652010-08-21 09:40:31 +00001517 return 0;
Douglas Gregord5a423b2009-09-25 18:43:00 +00001518 }
1519
1520 ThisDecl = ThisRes.get();
1521 break;
1522 }
1523 }
Mike Stump1eb44332009-09-09 15:08:12 +00001524
Richard Smith34b41d92011-02-20 03:19:35 +00001525 bool TypeContainsAuto =
1526 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto;
1527
Douglas Gregor1426e532009-05-12 21:31:51 +00001528 // Parse declarator '=' initializer.
Richard Trieud6c7c672012-01-18 22:54:52 +00001529 // If a '==' or '+=' is found, suggest a fixit to '='.
Richard Trieufcaf27e2012-01-19 22:01:51 +00001530 if (isTokenEqualOrEqualTypo()) {
Douglas Gregor1426e532009-05-12 21:31:51 +00001531 ConsumeToken();
Anders Carlsson37bf9d22010-09-24 21:25:25 +00001532 if (Tok.is(tok::kw_delete)) {
Sean Hunte4246a62011-05-12 06:15:49 +00001533 if (D.isFunctionDeclarator())
1534 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
1535 << 1 /* delete */;
1536 else
1537 Diag(ConsumeToken(), diag::err_deleted_non_function);
Sean Huntfe2695e2011-05-06 01:42:00 +00001538 } else if (Tok.is(tok::kw_default)) {
Sean Hunte4246a62011-05-12 06:15:49 +00001539 if (D.isFunctionDeclarator())
Sebastian Redlecfcd562012-02-11 23:51:21 +00001540 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
1541 << 0 /* default */;
Sean Hunte4246a62011-05-12 06:15:49 +00001542 else
1543 Diag(ConsumeToken(), diag::err_default_special_members);
Douglas Gregor1426e532009-05-12 21:31:51 +00001544 } else {
David Blaikie4e4d0842012-03-11 07:00:24 +00001545 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
John McCall731ad842009-12-19 09:28:58 +00001546 EnterScope(0);
Douglas Gregor23c94db2010-07-02 17:43:08 +00001547 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
John McCall731ad842009-12-19 09:28:58 +00001548 }
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00001549
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00001550 if (Tok.is(tok::code_completion)) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001551 Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00001552 cutOffParsing();
1553 return 0;
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00001554 }
1555
John McCall60d7b3a2010-08-24 06:29:42 +00001556 ExprResult Init(ParseInitializer());
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00001557
David Blaikie4e4d0842012-03-11 07:00:24 +00001558 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001559 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
John McCall731ad842009-12-19 09:28:58 +00001560 ExitScope();
1561 }
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00001562
Douglas Gregor1426e532009-05-12 21:31:51 +00001563 if (Init.isInvalid()) {
Douglas Gregor00225542010-03-01 18:27:54 +00001564 SkipUntil(tok::comma, true, true);
1565 Actions.ActOnInitializerError(ThisDecl);
1566 } else
Richard Smith34b41d92011-02-20 03:19:35 +00001567 Actions.AddInitializerToDecl(ThisDecl, Init.take(),
1568 /*DirectInit=*/false, TypeContainsAuto);
Douglas Gregor1426e532009-05-12 21:31:51 +00001569 }
1570 } else if (Tok.is(tok::l_paren)) {
1571 // Parse C++ direct initializer: '(' expression-list ')'
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001572 BalancedDelimiterTracker T(*this, tok::l_paren);
1573 T.consumeOpen();
1574
Douglas Gregor1426e532009-05-12 21:31:51 +00001575 ExprVector Exprs(Actions);
1576 CommaLocsTy CommaLocs;
1577
David Blaikie4e4d0842012-03-11 07:00:24 +00001578 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregorb4debae2009-12-22 17:47:17 +00001579 EnterScope(0);
Douglas Gregor23c94db2010-07-02 17:43:08 +00001580 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001581 }
1582
Douglas Gregor1426e532009-05-12 21:31:51 +00001583 if (ParseExpressionList(Exprs, CommaLocs)) {
1584 SkipUntil(tok::r_paren);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001585
David Blaikie4e4d0842012-03-11 07:00:24 +00001586 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001587 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001588 ExitScope();
1589 }
Douglas Gregor1426e532009-05-12 21:31:51 +00001590 } else {
1591 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001592 T.consumeClose();
Douglas Gregor1426e532009-05-12 21:31:51 +00001593
1594 assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() &&
1595 "Unexpected number of commas!");
Douglas Gregorb4debae2009-12-22 17:47:17 +00001596
David Blaikie4e4d0842012-03-11 07:00:24 +00001597 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001598 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001599 ExitScope();
1600 }
1601
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001602 ExprResult Initializer = Actions.ActOnParenListExpr(T.getOpenLocation(),
1603 T.getCloseLocation(),
1604 move_arg(Exprs));
1605 Actions.AddInitializerToDecl(ThisDecl, Initializer.take(),
1606 /*DirectInit=*/true, TypeContainsAuto);
Douglas Gregor1426e532009-05-12 21:31:51 +00001607 }
David Blaikie4e4d0842012-03-11 07:00:24 +00001608 } else if (getLangOpts().CPlusPlus0x && Tok.is(tok::l_brace)) {
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001609 // Parse C++0x braced-init-list.
Richard Smith7fe62082011-10-15 05:09:34 +00001610 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
1611
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001612 if (D.getCXXScopeSpec().isSet()) {
1613 EnterScope(0);
1614 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
1615 }
1616
1617 ExprResult Init(ParseBraceInitializer());
1618
1619 if (D.getCXXScopeSpec().isSet()) {
1620 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
1621 ExitScope();
1622 }
1623
1624 if (Init.isInvalid()) {
1625 Actions.ActOnInitializerError(ThisDecl);
1626 } else
1627 Actions.AddInitializerToDecl(ThisDecl, Init.take(),
1628 /*DirectInit=*/true, TypeContainsAuto);
1629
Douglas Gregor1426e532009-05-12 21:31:51 +00001630 } else {
Richard Smith34b41d92011-02-20 03:19:35 +00001631 Actions.ActOnUninitializedDecl(ThisDecl, TypeContainsAuto);
Douglas Gregor1426e532009-05-12 21:31:51 +00001632 }
1633
Richard Smith483b9f32011-02-21 20:05:19 +00001634 Actions.FinalizeDeclaration(ThisDecl);
1635
Douglas Gregor1426e532009-05-12 21:31:51 +00001636 return ThisDecl;
1637}
1638
Reid Spencer5f016e22007-07-11 17:01:13 +00001639/// ParseSpecifierQualifierList
1640/// specifier-qualifier-list:
1641/// type-specifier specifier-qualifier-list[opt]
1642/// type-qualifier specifier-qualifier-list[opt]
1643/// [GNU] attributes specifier-qualifier-list[opt]
1644///
Richard Smith69730c12012-03-12 07:56:15 +00001645void Parser::ParseSpecifierQualifierList(DeclSpec &DS, AccessSpecifier AS,
1646 DeclSpecContext DSC) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001647 /// specifier-qualifier-list is a subset of declaration-specifiers. Just
1648 /// parse declaration-specifiers and complain about extra stuff.
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001649 /// TODO: diagnose attribute-specifiers and alignment-specifiers.
Richard Smith69730c12012-03-12 07:56:15 +00001650 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC);
Mike Stump1eb44332009-09-09 15:08:12 +00001651
Reid Spencer5f016e22007-07-11 17:01:13 +00001652 // Validate declspec for type-name.
1653 unsigned Specs = DS.getParsedSpecifiers();
Richard Smitha971d242012-05-09 20:55:26 +00001654 if ((DSC == DSC_type_specifier || DSC == DSC_trailing) &&
1655 !DS.hasTypeSpecifier()) {
Richard Smith69730c12012-03-12 07:56:15 +00001656 Diag(Tok, diag::err_expected_type);
1657 DS.SetTypeSpecError();
1658 } else if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers() &&
1659 !DS.hasAttributes()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001660 Diag(Tok, diag::err_typename_requires_specqual);
Richard Smith69730c12012-03-12 07:56:15 +00001661 if (!DS.hasTypeSpecifier())
1662 DS.SetTypeSpecError();
1663 }
Mike Stump1eb44332009-09-09 15:08:12 +00001664
Reid Spencer5f016e22007-07-11 17:01:13 +00001665 // Issue diagnostic and remove storage class if present.
1666 if (Specs & DeclSpec::PQ_StorageClassSpecifier) {
1667 if (DS.getStorageClassSpecLoc().isValid())
1668 Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass);
1669 else
1670 Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass);
1671 DS.ClearStorageClassSpecs();
1672 }
Mike Stump1eb44332009-09-09 15:08:12 +00001673
Reid Spencer5f016e22007-07-11 17:01:13 +00001674 // Issue diagnostic and remove function specfier if present.
1675 if (Specs & DeclSpec::PQ_FunctionSpecifier) {
Douglas Gregorb48fe382008-10-31 09:07:45 +00001676 if (DS.isInlineSpecified())
1677 Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
1678 if (DS.isVirtualSpecified())
1679 Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
1680 if (DS.isExplicitSpecified())
1681 Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
Reid Spencer5f016e22007-07-11 17:01:13 +00001682 DS.ClearFunctionSpecs();
1683 }
Richard Smith69730c12012-03-12 07:56:15 +00001684
1685 // Issue diagnostic and remove constexpr specfier if present.
1686 if (DS.isConstexprSpecified()) {
1687 Diag(DS.getConstexprSpecLoc(), diag::err_typename_invalid_constexpr);
1688 DS.ClearConstexprSpec();
1689 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001690}
1691
Chris Lattnerc199ab32009-04-12 20:42:31 +00001692/// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
1693/// specified token is valid after the identifier in a declarator which
1694/// immediately follows the declspec. For example, these things are valid:
1695///
1696/// int x [ 4]; // direct-declarator
1697/// int x ( int y); // direct-declarator
1698/// int(int x ) // direct-declarator
1699/// int x ; // simple-declaration
1700/// int x = 17; // init-declarator-list
1701/// int x , y; // init-declarator-list
1702/// int x __asm__ ("foo"); // init-declarator-list
Chris Lattnerb6645dd2009-04-14 21:16:09 +00001703/// int x : 4; // struct-declarator
Chris Lattnerc83c27a2009-04-12 22:29:43 +00001704/// int x { 5}; // C++'0x unified initializers
Chris Lattnerc199ab32009-04-12 20:42:31 +00001705///
1706/// This is not, because 'x' does not immediately follow the declspec (though
1707/// ')' happens to be valid anyway).
1708/// int (x)
1709///
1710static bool isValidAfterIdentifierInDeclarator(const Token &T) {
1711 return T.is(tok::l_square) || T.is(tok::l_paren) || T.is(tok::r_paren) ||
1712 T.is(tok::semi) || T.is(tok::comma) || T.is(tok::equal) ||
Chris Lattnerb6645dd2009-04-14 21:16:09 +00001713 T.is(tok::kw_asm) || T.is(tok::l_brace) || T.is(tok::colon);
Chris Lattnerc199ab32009-04-12 20:42:31 +00001714}
1715
Chris Lattnere40c2952009-04-14 21:34:55 +00001716
1717/// ParseImplicitInt - This method is called when we have an non-typename
1718/// identifier in a declspec (which normally terminates the decl spec) when
1719/// the declspec has no type specifier. In this case, the declspec is either
1720/// malformed or is "implicit int" (in K&R and C89).
1721///
1722/// This method handles diagnosing this prettily and returns false if the
1723/// declspec is done being processed. If it recovers and thinks there may be
1724/// other pieces of declspec after it, it returns true.
1725///
Chris Lattnerf4382f52009-04-14 22:17:06 +00001726bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001727 const ParsedTemplateInfo &TemplateInfo,
Richard Smith69730c12012-03-12 07:56:15 +00001728 AccessSpecifier AS, DeclSpecContext DSC) {
Chris Lattnerf4382f52009-04-14 22:17:06 +00001729 assert(Tok.is(tok::identifier) && "should have identifier");
Mike Stump1eb44332009-09-09 15:08:12 +00001730
Chris Lattnere40c2952009-04-14 21:34:55 +00001731 SourceLocation Loc = Tok.getLocation();
1732 // If we see an identifier that is not a type name, we normally would
1733 // parse it as the identifer being declared. However, when a typename
1734 // is typo'd or the definition is not included, this will incorrectly
1735 // parse the typename as the identifier name and fall over misparsing
1736 // later parts of the diagnostic.
1737 //
1738 // As such, we try to do some look-ahead in cases where this would
1739 // otherwise be an "implicit-int" case to see if this is invalid. For
1740 // example: "static foo_t x = 4;" In this case, if we parsed foo_t as
1741 // an identifier with implicit int, we'd get a parse error because the
1742 // next token is obviously invalid for a type. Parse these as a case
1743 // with an invalid type specifier.
1744 assert(!DS.hasTypeSpecifier() && "Type specifier checked above");
Mike Stump1eb44332009-09-09 15:08:12 +00001745
Chris Lattnere40c2952009-04-14 21:34:55 +00001746 // Since we know that this either implicit int (which is rare) or an
Richard Smith827adaf2012-05-15 21:01:51 +00001747 // error, do lookahead to try to do better recovery. This never applies
1748 // within a type specifier. Outside of C++, we allow this even if the
1749 // language doesn't "officially" support implicit int -- we support
1750 // implicit int as an extension in C99 and C11. Allegedly, MS also
1751 // supports implicit int in C++ mode.
Richard Smitha971d242012-05-09 20:55:26 +00001752 if (DSC != DSC_type_specifier && DSC != DSC_trailing &&
Richard Smith827adaf2012-05-15 21:01:51 +00001753 (!getLangOpts().CPlusPlus || getLangOpts().MicrosoftExt) &&
Richard Smith69730c12012-03-12 07:56:15 +00001754 isValidAfterIdentifierInDeclarator(NextToken())) {
Chris Lattnere40c2952009-04-14 21:34:55 +00001755 // If this token is valid for implicit int, e.g. "static x = 4", then
1756 // we just avoid eating the identifier, so it will be parsed as the
1757 // identifier in the declarator.
1758 return false;
1759 }
Mike Stump1eb44332009-09-09 15:08:12 +00001760
Richard Smith827adaf2012-05-15 21:01:51 +00001761 if (getLangOpts().CPlusPlus &&
1762 DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
1763 // Don't require a type specifier if we have the 'auto' storage class
1764 // specifier in C++98 -- we'll promote it to a type specifier.
1765 return false;
1766 }
1767
Chris Lattnere40c2952009-04-14 21:34:55 +00001768 // Otherwise, if we don't consume this token, we are going to emit an
1769 // error anyway. Try to recover from various common problems. Check
1770 // to see if this was a reference to a tag name without a tag specified.
1771 // This is a common problem in C (saying 'foo' instead of 'struct foo').
Chris Lattnerf4382f52009-04-14 22:17:06 +00001772 //
1773 // C++ doesn't need this, and isTagName doesn't take SS.
1774 if (SS == 0) {
Argyrios Kyrtzidisb8a9d3b2011-04-21 17:29:47 +00001775 const char *TagName = 0, *FixitTagName = 0;
Chris Lattnerf4382f52009-04-14 22:17:06 +00001776 tok::TokenKind TagKind = tok::unknown;
Mike Stump1eb44332009-09-09 15:08:12 +00001777
Douglas Gregor23c94db2010-07-02 17:43:08 +00001778 switch (Actions.isTagName(*Tok.getIdentifierInfo(), getCurScope())) {
Chris Lattnere40c2952009-04-14 21:34:55 +00001779 default: break;
Argyrios Kyrtzidisb8a9d3b2011-04-21 17:29:47 +00001780 case DeclSpec::TST_enum:
1781 TagName="enum" ; FixitTagName = "enum " ; TagKind=tok::kw_enum ;break;
1782 case DeclSpec::TST_union:
1783 TagName="union" ; FixitTagName = "union " ;TagKind=tok::kw_union ;break;
1784 case DeclSpec::TST_struct:
1785 TagName="struct"; FixitTagName = "struct ";TagKind=tok::kw_struct;break;
1786 case DeclSpec::TST_class:
1787 TagName="class" ; FixitTagName = "class " ;TagKind=tok::kw_class ;break;
Chris Lattnere40c2952009-04-14 21:34:55 +00001788 }
Mike Stump1eb44332009-09-09 15:08:12 +00001789
Chris Lattnerf4382f52009-04-14 22:17:06 +00001790 if (TagName) {
Kaelyn Uhrainaec2ac62012-04-26 23:36:17 +00001791 IdentifierInfo *TokenName = Tok.getIdentifierInfo();
1792 LookupResult R(Actions, TokenName, SourceLocation(),
1793 Sema::LookupOrdinaryName);
1794
Chris Lattnerf4382f52009-04-14 22:17:06 +00001795 Diag(Loc, diag::err_use_of_tag_name_without_tag)
Kaelyn Uhrainaec2ac62012-04-26 23:36:17 +00001796 << TokenName << TagName << getLangOpts().CPlusPlus
1797 << FixItHint::CreateInsertion(Tok.getLocation(), FixitTagName);
1798
1799 if (Actions.LookupParsedName(R, getCurScope(), SS)) {
1800 for (LookupResult::iterator I = R.begin(), IEnd = R.end();
1801 I != IEnd; ++I)
Kaelyn Uhrain392b3f52012-04-27 18:26:49 +00001802 Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
Kaelyn Uhrainaec2ac62012-04-26 23:36:17 +00001803 << TokenName << TagName;
1804 }
Mike Stump1eb44332009-09-09 15:08:12 +00001805
Chris Lattnerf4382f52009-04-14 22:17:06 +00001806 // Parse this as a tag as if the missing tag were present.
1807 if (TagKind == tok::kw_enum)
Richard Smith69730c12012-03-12 07:56:15 +00001808 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS, DSC_normal);
Chris Lattnerf4382f52009-04-14 22:17:06 +00001809 else
Richard Smith69730c12012-03-12 07:56:15 +00001810 ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS,
1811 /*EnteringContext*/ false, DSC_normal);
Chris Lattnerf4382f52009-04-14 22:17:06 +00001812 return true;
1813 }
Chris Lattnere40c2952009-04-14 21:34:55 +00001814 }
Mike Stump1eb44332009-09-09 15:08:12 +00001815
Richard Smith8f0a7e72012-05-15 21:29:55 +00001816 // Determine whether this identifier could plausibly be the name of something
Richard Smith7514db22012-05-15 21:42:17 +00001817 // being declared (with a missing type).
Richard Smith8f0a7e72012-05-15 21:29:55 +00001818 if (DSC != DSC_type_specifier && DSC != DSC_trailing &&
1819 (!SS || DSC == DSC_top_level || DSC == DSC_class)) {
Richard Smith827adaf2012-05-15 21:01:51 +00001820 // Look ahead to the next token to try to figure out what this declaration
1821 // was supposed to be.
1822 switch (NextToken().getKind()) {
1823 case tok::comma:
1824 case tok::equal:
1825 case tok::kw_asm:
1826 case tok::l_brace:
1827 case tok::l_square:
1828 case tok::semi:
1829 // This looks like a variable declaration. The type is probably missing.
1830 // We're done parsing decl-specifiers.
1831 return false;
1832
1833 case tok::l_paren: {
1834 // static x(4); // 'x' is not a type
1835 // x(int n); // 'x' is not a type
1836 // x (*p)[]; // 'x' is a type
1837 //
1838 // Since we're in an error case (or the rare 'implicit int in C++' MS
1839 // extension), we can afford to perform a tentative parse to determine
1840 // which case we're in.
1841 TentativeParsingAction PA(*this);
1842 ConsumeToken();
1843 TPResult TPR = TryParseDeclarator(/*mayBeAbstract*/false);
1844 PA.Revert();
1845 if (TPR == TPResult::False())
1846 return false;
1847 // The identifier is followed by a parenthesized declarator.
1848 // It's supposed to be a type.
1849 break;
1850 }
1851
1852 default:
1853 // This is probably supposed to be a type. This includes cases like:
1854 // int f(itn);
1855 // struct S { unsinged : 4; };
1856 break;
1857 }
1858 }
1859
Douglas Gregora786fdb2009-10-13 23:27:22 +00001860 // This is almost certainly an invalid type name. Let the action emit a
1861 // diagnostic and attempt to recover.
John McCallb3d87482010-08-24 05:47:05 +00001862 ParsedType T;
Kaelyn Uhrain50dc12a2012-06-15 23:45:58 +00001863 IdentifierInfo *II = Tok.getIdentifierInfo();
1864 if (Actions.DiagnoseUnknownTypeName(II, Loc, getCurScope(), SS, T)) {
Douglas Gregora786fdb2009-10-13 23:27:22 +00001865 // The action emitted a diagnostic, so we don't have to.
1866 if (T) {
1867 // The action has suggested that the type T could be used. Set that as
1868 // the type in the declaration specifiers, consume the would-be type
1869 // name token, and we're done.
1870 const char *PrevSpec;
1871 unsigned DiagID;
John McCallb3d87482010-08-24 05:47:05 +00001872 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T);
Douglas Gregora786fdb2009-10-13 23:27:22 +00001873 DS.SetRangeEnd(Tok.getLocation());
1874 ConsumeToken();
Kaelyn Uhrain50dc12a2012-06-15 23:45:58 +00001875 // There may be other declaration specifiers after this.
1876 return true;
1877 } else if (II != Tok.getIdentifierInfo()) {
1878 // If no type was suggested, the correction is to a keyword
1879 Tok.setKind(II->getTokenID());
Douglas Gregora786fdb2009-10-13 23:27:22 +00001880 // There may be other declaration specifiers after this.
1881 return true;
1882 }
1883
1884 // Fall through; the action had no suggestion for us.
1885 } else {
1886 // The action did not emit a diagnostic, so emit one now.
1887 SourceRange R;
1888 if (SS) R = SS->getRange();
1889 Diag(Loc, diag::err_unknown_typename) << Tok.getIdentifierInfo() << R;
1890 }
Mike Stump1eb44332009-09-09 15:08:12 +00001891
Douglas Gregora786fdb2009-10-13 23:27:22 +00001892 // Mark this as an error.
Richard Smith69730c12012-03-12 07:56:15 +00001893 DS.SetTypeSpecError();
Chris Lattnere40c2952009-04-14 21:34:55 +00001894 DS.SetRangeEnd(Tok.getLocation());
1895 ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00001896
Chris Lattnere40c2952009-04-14 21:34:55 +00001897 // TODO: Could inject an invalid typedef decl in an enclosing scope to
1898 // avoid rippling error messages on subsequent uses of the same type,
1899 // could be useful if #include was forgotten.
1900 return false;
1901}
1902
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001903/// \brief Determine the declaration specifier context from the declarator
1904/// context.
1905///
1906/// \param Context the declarator context, which is one of the
1907/// Declarator::TheContext enumerator values.
1908Parser::DeclSpecContext
1909Parser::getDeclSpecContextFromDeclaratorContext(unsigned Context) {
1910 if (Context == Declarator::MemberContext)
1911 return DSC_class;
1912 if (Context == Declarator::FileContext)
1913 return DSC_top_level;
Richard Smith6d96d3a2012-03-15 01:02:11 +00001914 if (Context == Declarator::TrailingReturnContext)
1915 return DSC_trailing;
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001916 return DSC_normal;
1917}
1918
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001919/// ParseAlignArgument - Parse the argument to an alignment-specifier.
1920///
1921/// FIXME: Simply returns an alignof() expression if the argument is a
1922/// type. Ideally, the type should be propagated directly into Sema.
1923///
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00001924/// [C11] type-id
1925/// [C11] constant-expression
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001926/// [C++0x] type-id ...[opt]
1927/// [C++0x] assignment-expression ...[opt]
1928ExprResult Parser::ParseAlignArgument(SourceLocation Start,
1929 SourceLocation &EllipsisLoc) {
1930 ExprResult ER;
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001931 if (isTypeIdInParens()) {
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001932 SourceLocation TypeLoc = Tok.getLocation();
1933 ParsedType Ty = ParseTypeName().get();
1934 SourceRange TypeRange(Start, Tok.getLocation());
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001935 ER = Actions.ActOnUnaryExprOrTypeTraitExpr(TypeLoc, UETT_AlignOf, true,
1936 Ty.getAsOpaquePtr(), TypeRange);
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001937 } else
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001938 ER = ParseConstantExpression();
1939
David Blaikie4e4d0842012-03-11 07:00:24 +00001940 if (getLangOpts().CPlusPlus0x && Tok.is(tok::ellipsis))
Peter Collingbournefe9b2a82011-10-24 17:56:00 +00001941 EllipsisLoc = ConsumeToken();
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001942
1943 return ER;
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001944}
1945
1946/// ParseAlignmentSpecifier - Parse an alignment-specifier, and add the
1947/// attribute to Attrs.
1948///
1949/// alignment-specifier:
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00001950/// [C11] '_Alignas' '(' type-id ')'
1951/// [C11] '_Alignas' '(' constant-expression ')'
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001952/// [C++0x] 'alignas' '(' type-id ...[opt] ')'
1953/// [C++0x] 'alignas' '(' assignment-expression ...[opt] ')'
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001954void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs,
1955 SourceLocation *endLoc) {
1956 assert((Tok.is(tok::kw_alignas) || Tok.is(tok::kw__Alignas)) &&
1957 "Not an alignment-specifier!");
1958
1959 SourceLocation KWLoc = Tok.getLocation();
1960 ConsumeToken();
1961
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001962 BalancedDelimiterTracker T(*this, tok::l_paren);
1963 if (T.expectAndConsume(diag::err_expected_lparen))
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001964 return;
1965
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001966 SourceLocation EllipsisLoc;
1967 ExprResult ArgExpr = ParseAlignArgument(T.getOpenLocation(), EllipsisLoc);
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001968 if (ArgExpr.isInvalid()) {
1969 SkipUntil(tok::r_paren);
1970 return;
1971 }
1972
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001973 T.consumeClose();
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001974 if (endLoc)
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001975 *endLoc = T.getCloseLocation();
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001976
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00001977 // FIXME: Handle pack-expansions here.
1978 if (EllipsisLoc.isValid()) {
1979 Diag(EllipsisLoc, diag::err_alignas_pack_exp_unsupported);
1980 return;
1981 }
1982
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001983 ExprVector ArgExprs(Actions);
1984 ArgExprs.push_back(ArgExpr.release());
Sean Hunt8e083e72012-06-19 23:57:03 +00001985 // FIXME: This should not be GNU, but we since the attribute used is
1986 // based on the spelling, and there is no true spelling for
1987 // C++11 attributes, this isn't accepted.
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001988 Attrs.addNew(PP.getIdentifierInfo("aligned"), KWLoc, 0, KWLoc,
Sean Hunt93f95f22012-06-18 16:13:52 +00001989 0, T.getOpenLocation(), ArgExprs.take(), 1,
Sean Hunt8e083e72012-06-19 23:57:03 +00001990 AttributeList::AS_GNU);
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001991}
1992
Reid Spencer5f016e22007-07-11 17:01:13 +00001993/// ParseDeclarationSpecifiers
1994/// declaration-specifiers: [C99 6.7]
1995/// storage-class-specifier declaration-specifiers[opt]
1996/// type-specifier declaration-specifiers[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00001997/// [C99] function-specifier declaration-specifiers[opt]
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00001998/// [C11] alignment-specifier declaration-specifiers[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00001999/// [GNU] attributes declaration-specifiers[opt]
Douglas Gregor8d267c52011-09-09 02:06:17 +00002000/// [Clang] '__module_private__' declaration-specifiers[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00002001///
2002/// storage-class-specifier: [C99 6.7.1]
2003/// 'typedef'
2004/// 'extern'
2005/// 'static'
2006/// 'auto'
2007/// 'register'
Sebastian Redl669d5d72008-11-14 23:42:31 +00002008/// [C++] 'mutable'
Reid Spencer5f016e22007-07-11 17:01:13 +00002009/// [GNU] '__thread'
Reid Spencer5f016e22007-07-11 17:01:13 +00002010/// function-specifier: [C99 6.7.4]
2011/// [C99] 'inline'
Douglas Gregorb48fe382008-10-31 09:07:45 +00002012/// [C++] 'virtual'
2013/// [C++] 'explicit'
Peter Collingbournef315fa82011-02-14 01:42:53 +00002014/// [OpenCL] '__kernel'
Anders Carlssonf47f7a12009-05-06 04:46:28 +00002015/// 'friend': [C++ dcl.friend]
Sebastian Redl2ac67232009-11-05 15:47:02 +00002016/// 'constexpr': [C++0x dcl.constexpr]
Anders Carlssonf47f7a12009-05-06 04:46:28 +00002017
Reid Spencer5f016e22007-07-11 17:01:13 +00002018///
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002019void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00002020 const ParsedTemplateInfo &TemplateInfo,
John McCall67d1a672009-08-06 02:15:43 +00002021 AccessSpecifier AS,
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +00002022 DeclSpecContext DSContext,
2023 LateParsedAttrList *LateAttrs) {
Douglas Gregor312eadb2011-04-24 05:37:28 +00002024 if (DS.getSourceRange().isInvalid()) {
2025 DS.SetRangeStart(Tok.getLocation());
2026 DS.SetRangeEnd(Tok.getLocation());
2027 }
2028
Douglas Gregorefaa93a2011-11-07 17:33:42 +00002029 bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level);
Sean Hunt2edf0a22012-06-23 05:07:58 +00002030 bool AttrsLastTime = false;
2031 ParsedAttributesWithRange attrs(AttrFactory);
Reid Spencer5f016e22007-07-11 17:01:13 +00002032 while (1) {
John McCallfec54012009-08-03 20:12:06 +00002033 bool isInvalid = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00002034 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00002035 unsigned DiagID = 0;
2036
Reid Spencer5f016e22007-07-11 17:01:13 +00002037 SourceLocation Loc = Tok.getLocation();
Douglas Gregor12e083c2008-11-07 15:42:26 +00002038
Reid Spencer5f016e22007-07-11 17:01:13 +00002039 switch (Tok.getKind()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002040 default:
Chris Lattnerbce61352008-07-26 00:20:22 +00002041 DoneWithDeclSpec:
Sean Hunt2edf0a22012-06-23 05:07:58 +00002042 if (!AttrsLastTime)
2043 ProhibitAttributes(attrs);
2044 else
2045 DS.takeAttributesFrom(attrs);
Peter Collingbournef1907682011-09-29 18:03:57 +00002046
Reid Spencer5f016e22007-07-11 17:01:13 +00002047 // If this is not a declaration specifier token, we're done reading decl
2048 // specifiers. First verify that DeclSpec's are consistent.
Douglas Gregor9b3064b2009-04-01 22:41:11 +00002049 DS.Finish(Diags, PP);
Reid Spencer5f016e22007-07-11 17:01:13 +00002050 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002051
Sean Hunt2edf0a22012-06-23 05:07:58 +00002052 case tok::l_square:
2053 case tok::kw_alignas:
2054 if (!isCXX11AttributeSpecifier())
2055 goto DoneWithDeclSpec;
2056
2057 ProhibitAttributes(attrs);
2058 // FIXME: It would be good to recover by accepting the attributes,
2059 // but attempting to do that now would cause serious
2060 // madness in terms of diagnostics.
2061 attrs.clear();
2062 attrs.Range = SourceRange();
2063
2064 ParseCXX11Attributes(attrs);
2065 AttrsLastTime = true;
2066 continue;
2067
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002068 case tok::code_completion: {
John McCallf312b1e2010-08-26 23:41:50 +00002069 Sema::ParserCompletionContext CCC = Sema::PCC_Namespace;
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002070 if (DS.hasTypeSpecifier()) {
2071 bool AllowNonIdentifiers
2072 = (getCurScope()->getFlags() & (Scope::ControlScope |
2073 Scope::BlockScope |
2074 Scope::TemplateParamScope |
2075 Scope::FunctionPrototypeScope |
2076 Scope::AtCatchScope)) == 0;
2077 bool AllowNestedNameSpecifiers
2078 = DSContext == DSC_top_level ||
2079 (DSContext == DSC_class && DS.isFriendSpecified());
2080
Douglas Gregorc7b6d882010-09-16 15:14:18 +00002081 Actions.CodeCompleteDeclSpec(getCurScope(), DS,
2082 AllowNonIdentifiers,
2083 AllowNestedNameSpecifiers);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00002084 return cutOffParsing();
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002085 }
2086
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00002087 if (getCurScope()->getFnParent() || getCurScope()->getBlockParent())
2088 CCC = Sema::PCC_LocalDeclarationSpecifiers;
2089 else if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate)
John McCallf312b1e2010-08-26 23:41:50 +00002090 CCC = DSContext == DSC_class? Sema::PCC_MemberTemplate
2091 : Sema::PCC_Template;
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002092 else if (DSContext == DSC_class)
John McCallf312b1e2010-08-26 23:41:50 +00002093 CCC = Sema::PCC_Class;
Argyrios Kyrtzidis849639d2012-02-07 16:50:53 +00002094 else if (CurParsedObjCImpl)
John McCallf312b1e2010-08-26 23:41:50 +00002095 CCC = Sema::PCC_ObjCImplementation;
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002096
2097 Actions.CodeCompleteOrdinaryName(getCurScope(), CCC);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00002098 return cutOffParsing();
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002099 }
2100
Chris Lattner5e02c472009-01-05 00:07:25 +00002101 case tok::coloncolon: // ::foo::bar
John McCall9ba61662010-02-26 08:45:28 +00002102 // C++ scope specifier. Annotate and loop, or bail out on error.
2103 if (TryAnnotateCXXScopeToken(true)) {
2104 if (!DS.hasTypeSpecifier())
2105 DS.SetTypeSpecError();
2106 goto DoneWithDeclSpec;
2107 }
John McCall2e0a7152010-03-01 18:20:46 +00002108 if (Tok.is(tok::coloncolon)) // ::new or ::delete
2109 goto DoneWithDeclSpec;
John McCall9ba61662010-02-26 08:45:28 +00002110 continue;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002111
2112 case tok::annot_cxxscope: {
Richard Smithf63eee72012-05-09 18:56:43 +00002113 if (DS.hasTypeSpecifier() || DS.isTypeAltiVecVector())
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002114 goto DoneWithDeclSpec;
2115
John McCallaa87d332009-12-12 11:40:51 +00002116 CXXScopeSpec SS;
Douglas Gregorc34348a2011-02-24 17:54:50 +00002117 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
2118 Tok.getAnnotationRange(),
2119 SS);
John McCallaa87d332009-12-12 11:40:51 +00002120
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002121 // We are looking for a qualified typename.
Douglas Gregor9135c722009-03-25 15:40:00 +00002122 Token Next = NextToken();
Mike Stump1eb44332009-09-09 15:08:12 +00002123 if (Next.is(tok::annot_template_id) &&
Douglas Gregor9135c722009-03-25 15:40:00 +00002124 static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue())
Douglas Gregorc45c2322009-03-31 00:43:58 +00002125 ->Kind == TNK_Type_template) {
Douglas Gregor9135c722009-03-25 15:40:00 +00002126 // We have a qualified template-id, e.g., N::A<int>
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002127
2128 // C++ [class.qual]p2:
2129 // In a lookup in which the constructor is an acceptable lookup
2130 // result and the nested-name-specifier nominates a class C:
2131 //
2132 // - if the name specified after the
2133 // nested-name-specifier, when looked up in C, is the
2134 // injected-class-name of C (Clause 9), or
2135 //
2136 // - if the name specified after the nested-name-specifier
2137 // is the same as the identifier or the
2138 // simple-template-id's template-name in the last
2139 // component of the nested-name-specifier,
2140 //
2141 // the name is instead considered to name the constructor of
2142 // class C.
2143 //
2144 // Thus, if the template-name is actually the constructor
2145 // name, then the code is ill-formed; this interpretation is
2146 // reinforced by the NAD status of core issue 635.
Argyrios Kyrtzidis25a76762011-06-22 06:09:49 +00002147 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Next);
John McCallba9d8532010-04-13 06:39:49 +00002148 if ((DSContext == DSC_top_level ||
2149 (DSContext == DSC_class && DS.isFriendSpecified())) &&
2150 TemplateId->Name &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00002151 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002152 if (isConstructorDeclarator()) {
2153 // The user meant this to be an out-of-line constructor
2154 // definition, but template arguments are not allowed
2155 // there. Just allow this as a constructor; we'll
2156 // complain about it later.
2157 goto DoneWithDeclSpec;
2158 }
2159
2160 // The user meant this to name a type, but it actually names
2161 // a constructor with some extraneous template
2162 // arguments. Complain, then parse it as a type as the user
2163 // intended.
2164 Diag(TemplateId->TemplateNameLoc,
2165 diag::err_out_of_line_template_id_names_constructor)
2166 << TemplateId->Name;
2167 }
2168
John McCallaa87d332009-12-12 11:40:51 +00002169 DS.getTypeSpecScope() = SS;
2170 ConsumeToken(); // The C++ scope.
Mike Stump1eb44332009-09-09 15:08:12 +00002171 assert(Tok.is(tok::annot_template_id) &&
Douglas Gregor9135c722009-03-25 15:40:00 +00002172 "ParseOptionalCXXScopeSpecifier not working");
Douglas Gregor059101f2011-03-02 00:47:37 +00002173 AnnotateTemplateIdTokenAsType();
Douglas Gregor9135c722009-03-25 15:40:00 +00002174 continue;
2175 }
2176
Douglas Gregor9d7b3532009-09-28 07:26:33 +00002177 if (Next.is(tok::annot_typename)) {
John McCallaa87d332009-12-12 11:40:51 +00002178 DS.getTypeSpecScope() = SS;
2179 ConsumeToken(); // The C++ scope.
John McCallb3d87482010-08-24 05:47:05 +00002180 if (Tok.getAnnotationValue()) {
2181 ParsedType T = getTypeAnnotation(Tok);
Nico Weber253e80b2010-11-22 10:30:56 +00002182 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename,
2183 Tok.getAnnotationEndLoc(),
John McCallb3d87482010-08-24 05:47:05 +00002184 PrevSpec, DiagID, T);
2185 }
Douglas Gregor9d7b3532009-09-28 07:26:33 +00002186 else
2187 DS.SetTypeSpecError();
2188 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
2189 ConsumeToken(); // The typename
2190 }
2191
Douglas Gregor9135c722009-03-25 15:40:00 +00002192 if (Next.isNot(tok::identifier))
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002193 goto DoneWithDeclSpec;
2194
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002195 // If we're in a context where the identifier could be a class name,
2196 // check whether this is a constructor declaration.
John McCallba9d8532010-04-13 06:39:49 +00002197 if ((DSContext == DSC_top_level ||
2198 (DSContext == DSC_class && DS.isFriendSpecified())) &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00002199 Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(),
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002200 &SS)) {
2201 if (isConstructorDeclarator())
2202 goto DoneWithDeclSpec;
2203
2204 // As noted in C++ [class.qual]p2 (cited above), when the name
2205 // of the class is qualified in a context where it could name
2206 // a constructor, its a constructor name. However, we've
2207 // looked at the declarator, and the user probably meant this
2208 // to be a type. Complain that it isn't supposed to be treated
2209 // as a type, then proceed to parse it as a type.
2210 Diag(Next.getLocation(), diag::err_out_of_line_type_names_constructor)
2211 << Next.getIdentifierInfo();
2212 }
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002213
John McCallb3d87482010-08-24 05:47:05 +00002214 ParsedType TypeRep = Actions.getTypeName(*Next.getIdentifierInfo(),
2215 Next.getLocation(),
Douglas Gregor9e876872011-03-01 18:12:44 +00002216 getCurScope(), &SS,
2217 false, false, ParsedType(),
Abramo Bagnarafad03b72012-01-27 08:46:19 +00002218 /*IsCtorOrDtorName=*/false,
Douglas Gregor9e876872011-03-01 18:12:44 +00002219 /*NonTrivialSourceInfo=*/true);
Douglas Gregor55f6b142009-02-09 18:46:07 +00002220
Chris Lattnerf4382f52009-04-14 22:17:06 +00002221 // If the referenced identifier is not a type, then this declspec is
2222 // erroneous: We already checked about that it has no type specifier, and
2223 // C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the
Mike Stump1eb44332009-09-09 15:08:12 +00002224 // typename.
Chris Lattnerf4382f52009-04-14 22:17:06 +00002225 if (TypeRep == 0) {
2226 ConsumeToken(); // Eat the scope spec so the identifier is current.
Richard Smith69730c12012-03-12 07:56:15 +00002227 if (ParseImplicitInt(DS, &SS, TemplateInfo, AS, DSContext)) continue;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002228 goto DoneWithDeclSpec;
Chris Lattnerf4382f52009-04-14 22:17:06 +00002229 }
Mike Stump1eb44332009-09-09 15:08:12 +00002230
John McCallaa87d332009-12-12 11:40:51 +00002231 DS.getTypeSpecScope() = SS;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002232 ConsumeToken(); // The C++ scope.
2233
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00002234 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00002235 DiagID, TypeRep);
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002236 if (isInvalid)
2237 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002238
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002239 DS.SetRangeEnd(Tok.getLocation());
2240 ConsumeToken(); // The typename.
2241
2242 continue;
2243 }
Mike Stump1eb44332009-09-09 15:08:12 +00002244
Chris Lattner80d0c892009-01-21 19:48:37 +00002245 case tok::annot_typename: {
John McCallb3d87482010-08-24 05:47:05 +00002246 if (Tok.getAnnotationValue()) {
2247 ParsedType T = getTypeAnnotation(Tok);
Nico Weberc43271e2010-11-22 12:50:03 +00002248 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCallb3d87482010-08-24 05:47:05 +00002249 DiagID, T);
2250 } else
Douglas Gregor31a19b62009-04-01 21:51:26 +00002251 DS.SetTypeSpecError();
Chris Lattner5c5db552010-04-05 18:18:31 +00002252
2253 if (isInvalid)
2254 break;
2255
Chris Lattner80d0c892009-01-21 19:48:37 +00002256 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
2257 ConsumeToken(); // The typename
Mike Stump1eb44332009-09-09 15:08:12 +00002258
Chris Lattner80d0c892009-01-21 19:48:37 +00002259 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
2260 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00002261 // Objective-C interface.
David Blaikie4e4d0842012-03-11 07:00:24 +00002262 if (Tok.is(tok::less) && getLangOpts().ObjC1)
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00002263 ParseObjCProtocolQualifiers(DS);
2264
Chris Lattner80d0c892009-01-21 19:48:37 +00002265 continue;
2266 }
Mike Stump1eb44332009-09-09 15:08:12 +00002267
Douglas Gregorbfad9152011-04-28 15:48:45 +00002268 case tok::kw___is_signed:
2269 // GNU libstdc++ 4.4 uses __is_signed as an identifier, but Clang
2270 // typically treats it as a trait. If we see __is_signed as it appears
2271 // in libstdc++, e.g.,
2272 //
2273 // static const bool __is_signed;
2274 //
2275 // then treat __is_signed as an identifier rather than as a keyword.
2276 if (DS.getTypeSpecType() == TST_bool &&
2277 DS.getTypeQualifiers() == DeclSpec::TQ_const &&
2278 DS.getStorageClassSpec() == DeclSpec::SCS_static) {
2279 Tok.getIdentifierInfo()->RevertTokenIDToIdentifier();
2280 Tok.setKind(tok::identifier);
2281 }
2282
2283 // We're done with the declaration-specifiers.
2284 goto DoneWithDeclSpec;
2285
Chris Lattner3bd934a2008-07-26 01:18:38 +00002286 // typedef-name
David Blaikie42d6d0c2011-12-04 05:04:18 +00002287 case tok::kw_decltype:
Chris Lattner3bd934a2008-07-26 01:18:38 +00002288 case tok::identifier: {
Chris Lattner5e02c472009-01-05 00:07:25 +00002289 // In C++, check to see if this is a scope specifier like foo::bar::, if
2290 // so handle it as such. This is important for ctor parsing.
David Blaikie4e4d0842012-03-11 07:00:24 +00002291 if (getLangOpts().CPlusPlus) {
John McCall9ba61662010-02-26 08:45:28 +00002292 if (TryAnnotateCXXScopeToken(true)) {
2293 if (!DS.hasTypeSpecifier())
2294 DS.SetTypeSpecError();
2295 goto DoneWithDeclSpec;
2296 }
2297 if (!Tok.is(tok::identifier))
2298 continue;
2299 }
Mike Stump1eb44332009-09-09 15:08:12 +00002300
Chris Lattner3bd934a2008-07-26 01:18:38 +00002301 // This identifier can only be a typedef name if we haven't already seen
2302 // a type-specifier. Without this check we misparse:
2303 // typedef int X; struct Y { short X; }; as 'short int'.
2304 if (DS.hasTypeSpecifier())
2305 goto DoneWithDeclSpec;
Mike Stump1eb44332009-09-09 15:08:12 +00002306
John Thompson82287d12010-02-05 00:12:22 +00002307 // Check for need to substitute AltiVec keyword tokens.
2308 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
2309 break;
2310
Richard Smithf63eee72012-05-09 18:56:43 +00002311 // [AltiVec] 2.2: [If the 'vector' specifier is used] The syntax does not
2312 // allow the use of a typedef name as a type specifier.
2313 if (DS.isTypeAltiVecVector())
2314 goto DoneWithDeclSpec;
2315
John McCallb3d87482010-08-24 05:47:05 +00002316 ParsedType TypeRep =
2317 Actions.getTypeName(*Tok.getIdentifierInfo(),
2318 Tok.getLocation(), getCurScope());
Douglas Gregor55f6b142009-02-09 18:46:07 +00002319
Chris Lattnerc199ab32009-04-12 20:42:31 +00002320 // If this is not a typedef name, don't parse it as part of the declspec,
2321 // it must be an implicit int or an error.
John McCallb3d87482010-08-24 05:47:05 +00002322 if (!TypeRep) {
Richard Smith69730c12012-03-12 07:56:15 +00002323 if (ParseImplicitInt(DS, 0, TemplateInfo, AS, DSContext)) continue;
Chris Lattner3bd934a2008-07-26 01:18:38 +00002324 goto DoneWithDeclSpec;
Chris Lattnerc199ab32009-04-12 20:42:31 +00002325 }
Douglas Gregor55f6b142009-02-09 18:46:07 +00002326
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002327 // If we're in a context where the identifier could be a class name,
2328 // check whether this is a constructor declaration.
David Blaikie4e4d0842012-03-11 07:00:24 +00002329 if (getLangOpts().CPlusPlus && DSContext == DSC_class &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00002330 Actions.isCurrentClassName(*Tok.getIdentifierInfo(), getCurScope()) &&
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002331 isConstructorDeclarator())
Douglas Gregorb48fe382008-10-31 09:07:45 +00002332 goto DoneWithDeclSpec;
2333
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00002334 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00002335 DiagID, TypeRep);
Chris Lattner3bd934a2008-07-26 01:18:38 +00002336 if (isInvalid)
2337 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002338
Chris Lattner3bd934a2008-07-26 01:18:38 +00002339 DS.SetRangeEnd(Tok.getLocation());
2340 ConsumeToken(); // The identifier
2341
2342 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
2343 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00002344 // Objective-C interface.
David Blaikie4e4d0842012-03-11 07:00:24 +00002345 if (Tok.is(tok::less) && getLangOpts().ObjC1)
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00002346 ParseObjCProtocolQualifiers(DS);
2347
Steve Naroff4f9b9f12008-09-22 10:28:57 +00002348 // Need to support trailing type qualifiers (e.g. "id<p> const").
2349 // If a type specifier follows, it will be diagnosed elsewhere.
2350 continue;
Chris Lattner3bd934a2008-07-26 01:18:38 +00002351 }
Douglas Gregor39a8de12009-02-25 19:37:18 +00002352
2353 // type-name
2354 case tok::annot_template_id: {
Argyrios Kyrtzidis25a76762011-06-22 06:09:49 +00002355 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
Douglas Gregorc45c2322009-03-31 00:43:58 +00002356 if (TemplateId->Kind != TNK_Type_template) {
Douglas Gregor39a8de12009-02-25 19:37:18 +00002357 // This template-id does not refer to a type name, so we're
2358 // done with the type-specifiers.
2359 goto DoneWithDeclSpec;
2360 }
2361
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002362 // If we're in a context where the template-id could be a
2363 // constructor name or specialization, check whether this is a
2364 // constructor declaration.
David Blaikie4e4d0842012-03-11 07:00:24 +00002365 if (getLangOpts().CPlusPlus && DSContext == DSC_class &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00002366 Actions.isCurrentClassName(*TemplateId->Name, getCurScope()) &&
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002367 isConstructorDeclarator())
2368 goto DoneWithDeclSpec;
2369
Douglas Gregor39a8de12009-02-25 19:37:18 +00002370 // Turn the template-id annotation token into a type annotation
2371 // token, then try again to parse it as a type-specifier.
Douglas Gregor31a19b62009-04-01 21:51:26 +00002372 AnnotateTemplateIdTokenAsType();
Douglas Gregor39a8de12009-02-25 19:37:18 +00002373 continue;
2374 }
2375
Reid Spencer5f016e22007-07-11 17:01:13 +00002376 // GNU attributes support.
2377 case tok::kw___attribute:
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +00002378 ParseGNUAttributes(DS.getAttributes(), 0, LateAttrs);
Reid Spencer5f016e22007-07-11 17:01:13 +00002379 continue;
Steve Narofff59e17e2008-12-24 20:59:21 +00002380
2381 // Microsoft declspec support.
2382 case tok::kw___declspec:
John McCall7f040a92010-12-24 02:08:15 +00002383 ParseMicrosoftDeclSpec(DS.getAttributes());
Steve Narofff59e17e2008-12-24 20:59:21 +00002384 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00002385
Steve Naroff239f0732008-12-25 14:16:32 +00002386 // Microsoft single token adornments.
Michael J. Spenceradc6cbf2012-06-18 07:00:48 +00002387 case tok::kw___forceinline: {
2388 isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec, DiagID);
2389 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
2390 SourceLocation AttrNameLoc = ConsumeToken();
Sean Hunt93f95f22012-06-18 16:13:52 +00002391 // FIXME: This does not work correctly if it is set to be a declspec
2392 // attribute, and a GNU attribute is simply incorrect.
Michael J. Spenceradc6cbf2012-06-18 07:00:48 +00002393 DS.getAttributes().addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
Sean Hunt93f95f22012-06-18 16:13:52 +00002394 SourceLocation(), 0, 0, AttributeList::AS_GNU);
Michael J. Spenceradc6cbf2012-06-18 07:00:48 +00002395 continue;
2396 }
Eli Friedman290eeb02009-06-08 23:27:34 +00002397
2398 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00002399 case tok::kw___ptr32:
Steve Naroff86bc6cf2008-12-25 14:41:26 +00002400 case tok::kw___w64:
Steve Naroff239f0732008-12-25 14:16:32 +00002401 case tok::kw___cdecl:
2402 case tok::kw___stdcall:
2403 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00002404 case tok::kw___thiscall:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00002405 case tok::kw___unaligned:
John McCall7f040a92010-12-24 02:08:15 +00002406 ParseMicrosoftTypeAttributes(DS.getAttributes());
Eli Friedman290eeb02009-06-08 23:27:34 +00002407 continue;
2408
Dawn Perchik52fc3142010-09-03 01:29:35 +00002409 // Borland single token adornments.
2410 case tok::kw___pascal:
John McCall7f040a92010-12-24 02:08:15 +00002411 ParseBorlandTypeAttributes(DS.getAttributes());
Dawn Perchik52fc3142010-09-03 01:29:35 +00002412 continue;
2413
Peter Collingbournef315fa82011-02-14 01:42:53 +00002414 // OpenCL single token adornments.
2415 case tok::kw___kernel:
2416 ParseOpenCLAttributes(DS.getAttributes());
2417 continue;
2418
Reid Spencer5f016e22007-07-11 17:01:13 +00002419 // storage-class-specifier
2420 case tok::kw_typedef:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002421 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc,
2422 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002423 break;
2424 case tok::kw_extern:
2425 if (DS.isThreadSpecified())
Chris Lattner1ab3b962008-11-18 07:48:38 +00002426 Diag(Tok, diag::ext_thread_before) << "extern";
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002427 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_extern, Loc,
2428 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002429 break;
Steve Naroff8d54bf22007-12-18 00:16:02 +00002430 case tok::kw___private_extern__:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002431 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_private_extern,
2432 Loc, PrevSpec, DiagID);
Steve Naroff8d54bf22007-12-18 00:16:02 +00002433 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00002434 case tok::kw_static:
2435 if (DS.isThreadSpecified())
Chris Lattner1ab3b962008-11-18 07:48:38 +00002436 Diag(Tok, diag::ext_thread_before) << "static";
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002437 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_static, Loc,
2438 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002439 break;
2440 case tok::kw_auto:
David Blaikie4e4d0842012-03-11 07:00:24 +00002441 if (getLangOpts().CPlusPlus0x) {
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002442 if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) {
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002443 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
2444 PrevSpec, DiagID);
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002445 if (!isInvalid)
Richard Smith8f4fb192011-09-04 19:54:14 +00002446 Diag(Tok, diag::ext_auto_storage_class)
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002447 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
Richard Smith8f4fb192011-09-04 19:54:14 +00002448 } else
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002449 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec,
2450 DiagID);
Richard Smith8f4fb192011-09-04 19:54:14 +00002451 } else
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002452 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
2453 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002454 break;
2455 case tok::kw_register:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002456 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_register, Loc,
2457 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002458 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +00002459 case tok::kw_mutable:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002460 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_mutable, Loc,
2461 PrevSpec, DiagID);
Sebastian Redl669d5d72008-11-14 23:42:31 +00002462 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00002463 case tok::kw___thread:
John McCallfec54012009-08-03 20:12:06 +00002464 isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002465 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002466
Reid Spencer5f016e22007-07-11 17:01:13 +00002467 // function-specifier
2468 case tok::kw_inline:
John McCallfec54012009-08-03 20:12:06 +00002469 isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002470 break;
Douglas Gregorb48fe382008-10-31 09:07:45 +00002471 case tok::kw_virtual:
John McCallfec54012009-08-03 20:12:06 +00002472 isInvalid = DS.SetFunctionSpecVirtual(Loc, PrevSpec, DiagID);
Douglas Gregorb48fe382008-10-31 09:07:45 +00002473 break;
Douglas Gregorb48fe382008-10-31 09:07:45 +00002474 case tok::kw_explicit:
John McCallfec54012009-08-03 20:12:06 +00002475 isInvalid = DS.SetFunctionSpecExplicit(Loc, PrevSpec, DiagID);
Douglas Gregorb48fe382008-10-31 09:07:45 +00002476 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002477
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002478 // alignment-specifier
2479 case tok::kw__Alignas:
David Blaikie4e4d0842012-03-11 07:00:24 +00002480 if (!getLangOpts().C11)
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00002481 Diag(Tok, diag::ext_c11_alignas);
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002482 ParseAlignmentSpecifier(DS.getAttributes());
2483 continue;
2484
Anders Carlssonf47f7a12009-05-06 04:46:28 +00002485 // friend
2486 case tok::kw_friend:
John McCall67d1a672009-08-06 02:15:43 +00002487 if (DSContext == DSC_class)
2488 isInvalid = DS.SetFriendSpec(Loc, PrevSpec, DiagID);
2489 else {
2490 PrevSpec = ""; // not actually used by the diagnostic
2491 DiagID = diag::err_friend_invalid_in_context;
2492 isInvalid = true;
2493 }
Anders Carlssonf47f7a12009-05-06 04:46:28 +00002494 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002495
Douglas Gregor8d267c52011-09-09 02:06:17 +00002496 // Modules
2497 case tok::kw___module_private__:
2498 isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID);
2499 break;
2500
Sebastian Redl2ac67232009-11-05 15:47:02 +00002501 // constexpr
2502 case tok::kw_constexpr:
2503 isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID);
2504 break;
2505
Chris Lattner80d0c892009-01-21 19:48:37 +00002506 // type-specifier
2507 case tok::kw_short:
John McCallfec54012009-08-03 20:12:06 +00002508 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec,
2509 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002510 break;
2511 case tok::kw_long:
2512 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
John McCallfec54012009-08-03 20:12:06 +00002513 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
2514 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002515 else
John McCallfec54012009-08-03 20:12:06 +00002516 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2517 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002518 break;
Francois Pichet338d7f72011-04-28 01:59:37 +00002519 case tok::kw___int64:
2520 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2521 DiagID);
2522 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002523 case tok::kw_signed:
John McCallfec54012009-08-03 20:12:06 +00002524 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec,
2525 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002526 break;
2527 case tok::kw_unsigned:
John McCallfec54012009-08-03 20:12:06 +00002528 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec,
2529 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002530 break;
2531 case tok::kw__Complex:
John McCallfec54012009-08-03 20:12:06 +00002532 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec,
2533 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002534 break;
2535 case tok::kw__Imaginary:
John McCallfec54012009-08-03 20:12:06 +00002536 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec,
2537 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002538 break;
2539 case tok::kw_void:
John McCallfec54012009-08-03 20:12:06 +00002540 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec,
2541 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002542 break;
2543 case tok::kw_char:
John McCallfec54012009-08-03 20:12:06 +00002544 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec,
2545 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002546 break;
2547 case tok::kw_int:
John McCallfec54012009-08-03 20:12:06 +00002548 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec,
2549 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002550 break;
Richard Smith5a5a9712012-04-04 06:24:32 +00002551 case tok::kw___int128:
2552 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec,
2553 DiagID);
2554 break;
2555 case tok::kw_half:
2556 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec,
2557 DiagID);
2558 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002559 case tok::kw_float:
John McCallfec54012009-08-03 20:12:06 +00002560 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
2561 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002562 break;
2563 case tok::kw_double:
John McCallfec54012009-08-03 20:12:06 +00002564 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
2565 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002566 break;
2567 case tok::kw_wchar_t:
John McCallfec54012009-08-03 20:12:06 +00002568 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
2569 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002570 break;
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002571 case tok::kw_char16_t:
John McCallfec54012009-08-03 20:12:06 +00002572 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec,
2573 DiagID);
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002574 break;
2575 case tok::kw_char32_t:
John McCallfec54012009-08-03 20:12:06 +00002576 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec,
2577 DiagID);
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002578 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002579 case tok::kw_bool:
2580 case tok::kw__Bool:
Argyrios Kyrtzidis4383e182010-11-16 18:18:13 +00002581 if (Tok.is(tok::kw_bool) &&
2582 DS.getTypeSpecType() != DeclSpec::TST_unspecified &&
2583 DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
2584 PrevSpec = ""; // Not used by the diagnostic.
2585 DiagID = diag::err_bool_redeclaration;
Fariborz Jahaniane106a0b2011-04-19 21:42:37 +00002586 // For better error recovery.
2587 Tok.setKind(tok::identifier);
Argyrios Kyrtzidis4383e182010-11-16 18:18:13 +00002588 isInvalid = true;
2589 } else {
2590 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec,
2591 DiagID);
2592 }
Chris Lattner80d0c892009-01-21 19:48:37 +00002593 break;
2594 case tok::kw__Decimal32:
John McCallfec54012009-08-03 20:12:06 +00002595 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
2596 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002597 break;
2598 case tok::kw__Decimal64:
John McCallfec54012009-08-03 20:12:06 +00002599 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
2600 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002601 break;
2602 case tok::kw__Decimal128:
John McCallfec54012009-08-03 20:12:06 +00002603 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
2604 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002605 break;
John Thompson82287d12010-02-05 00:12:22 +00002606 case tok::kw___vector:
2607 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
2608 break;
2609 case tok::kw___pixel:
2610 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
2611 break;
John McCalla5fc4722011-04-09 22:50:59 +00002612 case tok::kw___unknown_anytype:
2613 isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc,
2614 PrevSpec, DiagID);
2615 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002616
2617 // class-specifier:
2618 case tok::kw_class:
2619 case tok::kw_struct:
Chris Lattner4c97d762009-04-12 21:49:30 +00002620 case tok::kw_union: {
2621 tok::TokenKind Kind = Tok.getKind();
2622 ConsumeToken();
Richard Smith69730c12012-03-12 07:56:15 +00002623 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS,
2624 EnteringContext, DSContext);
Chris Lattner80d0c892009-01-21 19:48:37 +00002625 continue;
Chris Lattner4c97d762009-04-12 21:49:30 +00002626 }
Chris Lattner80d0c892009-01-21 19:48:37 +00002627
2628 // enum-specifier:
2629 case tok::kw_enum:
Chris Lattner4c97d762009-04-12 21:49:30 +00002630 ConsumeToken();
Richard Smith69730c12012-03-12 07:56:15 +00002631 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS, DSContext);
Chris Lattner80d0c892009-01-21 19:48:37 +00002632 continue;
2633
2634 // cv-qualifier:
2635 case tok::kw_const:
John McCallfec54012009-08-03 20:12:06 +00002636 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID,
David Blaikie4e4d0842012-03-11 07:00:24 +00002637 getLangOpts());
Chris Lattner80d0c892009-01-21 19:48:37 +00002638 break;
2639 case tok::kw_volatile:
John McCallfec54012009-08-03 20:12:06 +00002640 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
David Blaikie4e4d0842012-03-11 07:00:24 +00002641 getLangOpts());
Chris Lattner80d0c892009-01-21 19:48:37 +00002642 break;
2643 case tok::kw_restrict:
John McCallfec54012009-08-03 20:12:06 +00002644 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
David Blaikie4e4d0842012-03-11 07:00:24 +00002645 getLangOpts());
Chris Lattner80d0c892009-01-21 19:48:37 +00002646 break;
2647
Douglas Gregord57959a2009-03-27 23:10:48 +00002648 // C++ typename-specifier:
2649 case tok::kw_typename:
John McCall9ba61662010-02-26 08:45:28 +00002650 if (TryAnnotateTypeOrScopeToken()) {
2651 DS.SetTypeSpecError();
2652 goto DoneWithDeclSpec;
2653 }
2654 if (!Tok.is(tok::kw_typename))
Douglas Gregord57959a2009-03-27 23:10:48 +00002655 continue;
2656 break;
2657
Chris Lattner80d0c892009-01-21 19:48:37 +00002658 // GNU typeof support.
2659 case tok::kw_typeof:
2660 ParseTypeofSpecifier(DS);
2661 continue;
2662
David Blaikie42d6d0c2011-12-04 05:04:18 +00002663 case tok::annot_decltype:
Anders Carlsson6fd634f2009-06-24 17:47:40 +00002664 ParseDecltypeSpecifier(DS);
2665 continue;
2666
Sean Huntdb5d44b2011-05-19 05:37:45 +00002667 case tok::kw___underlying_type:
2668 ParseUnderlyingTypeSpecifier(DS);
Eli Friedmanb001de72011-10-06 23:00:33 +00002669 continue;
2670
2671 case tok::kw__Atomic:
2672 ParseAtomicSpecifier(DS);
2673 continue;
Sean Huntdb5d44b2011-05-19 05:37:45 +00002674
Peter Collingbourne207f4d82011-03-18 22:38:29 +00002675 // OpenCL qualifiers:
2676 case tok::kw_private:
David Blaikie4e4d0842012-03-11 07:00:24 +00002677 if (!getLangOpts().OpenCL)
Peter Collingbourne207f4d82011-03-18 22:38:29 +00002678 goto DoneWithDeclSpec;
2679 case tok::kw___private:
2680 case tok::kw___global:
2681 case tok::kw___local:
2682 case tok::kw___constant:
2683 case tok::kw___read_only:
2684 case tok::kw___write_only:
2685 case tok::kw___read_write:
2686 ParseOpenCLQualifiers(DS);
2687 break;
2688
Steve Naroffd3ded1f2008-06-05 00:02:44 +00002689 case tok::less:
Chris Lattner3bd934a2008-07-26 01:18:38 +00002690 // GCC ObjC supports types like "<SomeProtocol>" as a synonym for
Chris Lattnerbce61352008-07-26 00:20:22 +00002691 // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous,
2692 // but we support it.
David Blaikie4e4d0842012-03-11 07:00:24 +00002693 if (DS.hasTypeSpecifier() || !getLangOpts().ObjC1)
Chris Lattnerbce61352008-07-26 00:20:22 +00002694 goto DoneWithDeclSpec;
Mike Stump1eb44332009-09-09 15:08:12 +00002695
Douglas Gregor46f936e2010-11-19 17:10:50 +00002696 if (!ParseObjCProtocolQualifiers(DS))
2697 Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id)
2698 << FixItHint::CreateInsertion(Loc, "id")
2699 << SourceRange(Loc, DS.getSourceRange().getEnd());
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00002700
2701 // Need to support trailing type qualifiers (e.g. "id<p> const").
2702 // If a type specifier follows, it will be diagnosed elsewhere.
2703 continue;
Reid Spencer5f016e22007-07-11 17:01:13 +00002704 }
John McCallfec54012009-08-03 20:12:06 +00002705 // If the specifier wasn't legal, issue a diagnostic.
Reid Spencer5f016e22007-07-11 17:01:13 +00002706 if (isInvalid) {
2707 assert(PrevSpec && "Method did not return previous specifier!");
John McCallfec54012009-08-03 20:12:06 +00002708 assert(DiagID);
Douglas Gregorae2fb142010-08-23 14:34:43 +00002709
2710 if (DiagID == diag::ext_duplicate_declspec)
2711 Diag(Tok, DiagID)
2712 << PrevSpec << FixItHint::CreateRemoval(Tok.getLocation());
2713 else
2714 Diag(Tok, DiagID) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00002715 }
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002716
Chris Lattner81c018d2008-03-13 06:29:04 +00002717 DS.SetRangeEnd(Tok.getLocation());
Fariborz Jahaniane106a0b2011-04-19 21:42:37 +00002718 if (DiagID != diag::err_bool_redeclaration)
2719 ConsumeToken();
Sean Hunt2edf0a22012-06-23 05:07:58 +00002720
2721 AttrsLastTime = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00002722 }
2723}
Douglas Gregoradcac882008-12-01 23:54:00 +00002724
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002725/// ParseStructDeclaration - Parse a struct declaration without the terminating
2726/// semicolon.
2727///
Reid Spencer5f016e22007-07-11 17:01:13 +00002728/// struct-declaration:
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002729/// specifier-qualifier-list struct-declarator-list
Reid Spencer5f016e22007-07-11 17:01:13 +00002730/// [GNU] __extension__ struct-declaration
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002731/// [GNU] specifier-qualifier-list
Reid Spencer5f016e22007-07-11 17:01:13 +00002732/// struct-declarator-list:
2733/// struct-declarator
2734/// struct-declarator-list ',' struct-declarator
2735/// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator
2736/// struct-declarator:
2737/// declarator
2738/// [GNU] declarator attributes[opt]
2739/// declarator[opt] ':' constant-expression
2740/// [GNU] declarator[opt] ':' constant-expression attributes[opt]
2741///
Chris Lattnere1359422008-04-10 06:46:29 +00002742void Parser::
John McCallbdd563e2009-11-03 02:38:08 +00002743ParseStructDeclaration(DeclSpec &DS, FieldCallback &Fields) {
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00002744
Chris Lattnerc46d1a12008-10-20 06:45:43 +00002745 if (Tok.is(tok::kw___extension__)) {
2746 // __extension__ silences extension warnings in the subexpression.
2747 ExtensionRAIIObject O(Diags); // Use RAII to do this.
Steve Naroff28a7ca82007-08-20 22:28:22 +00002748 ConsumeToken();
Chris Lattnerc46d1a12008-10-20 06:45:43 +00002749 return ParseStructDeclaration(DS, Fields);
2750 }
Mike Stump1eb44332009-09-09 15:08:12 +00002751
Steve Naroff28a7ca82007-08-20 22:28:22 +00002752 // Parse the common specifier-qualifiers-list piece.
Steve Naroff28a7ca82007-08-20 22:28:22 +00002753 ParseSpecifierQualifierList(DS);
Mike Stump1eb44332009-09-09 15:08:12 +00002754
Douglas Gregor4920f1f2009-01-12 22:49:06 +00002755 // If there are no declarators, this is a free-standing declaration
2756 // specifier. Let the actions module cope with it.
Chris Lattner04d66662007-10-09 17:33:22 +00002757 if (Tok.is(tok::semi)) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00002758 Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, DS);
Steve Naroff28a7ca82007-08-20 22:28:22 +00002759 return;
2760 }
2761
2762 // Read struct-declarators until we find the semicolon.
John McCallbdd563e2009-11-03 02:38:08 +00002763 bool FirstDeclarator = true;
Richard Smith7984de32012-01-12 23:53:29 +00002764 SourceLocation CommaLoc;
Steve Naroff28a7ca82007-08-20 22:28:22 +00002765 while (1) {
John McCall92576642012-05-07 06:16:41 +00002766 ParsingDeclRAIIObject PD(*this, ParsingDeclRAIIObject::NoParent);
John McCallbdd563e2009-11-03 02:38:08 +00002767 FieldDeclarator DeclaratorInfo(DS);
Richard Smith7984de32012-01-12 23:53:29 +00002768 DeclaratorInfo.D.setCommaLoc(CommaLoc);
John McCallbdd563e2009-11-03 02:38:08 +00002769
2770 // Attributes are only allowed here on successive declarators.
John McCall7f040a92010-12-24 02:08:15 +00002771 if (!FirstDeclarator)
2772 MaybeParseGNUAttributes(DeclaratorInfo.D);
Mike Stump1eb44332009-09-09 15:08:12 +00002773
Steve Naroff28a7ca82007-08-20 22:28:22 +00002774 /// struct-declarator: declarator
2775 /// struct-declarator: declarator[opt] ':' constant-expression
Chris Lattnera1efc8c2009-12-10 01:59:24 +00002776 if (Tok.isNot(tok::colon)) {
2777 // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
2778 ColonProtectionRAIIObject X(*this);
Chris Lattnere1359422008-04-10 06:46:29 +00002779 ParseDeclarator(DeclaratorInfo.D);
Chris Lattnera1efc8c2009-12-10 01:59:24 +00002780 }
Mike Stump1eb44332009-09-09 15:08:12 +00002781
Chris Lattner04d66662007-10-09 17:33:22 +00002782 if (Tok.is(tok::colon)) {
Steve Naroff28a7ca82007-08-20 22:28:22 +00002783 ConsumeToken();
John McCall60d7b3a2010-08-24 06:29:42 +00002784 ExprResult Res(ParseConstantExpression());
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00002785 if (Res.isInvalid())
Steve Naroff28a7ca82007-08-20 22:28:22 +00002786 SkipUntil(tok::semi, true, true);
Chris Lattner60b1e3e2008-04-10 06:15:14 +00002787 else
Sebastian Redleffa8d12008-12-10 00:02:53 +00002788 DeclaratorInfo.BitfieldSize = Res.release();
Steve Naroff28a7ca82007-08-20 22:28:22 +00002789 }
Sebastian Redlab197ba2009-02-09 18:23:29 +00002790
Steve Naroff28a7ca82007-08-20 22:28:22 +00002791 // If attributes exist after the declarator, parse them.
John McCall7f040a92010-12-24 02:08:15 +00002792 MaybeParseGNUAttributes(DeclaratorInfo.D);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002793
John McCallbdd563e2009-11-03 02:38:08 +00002794 // We're done with this declarator; invoke the callback.
John McCalld226f652010-08-21 09:40:31 +00002795 Decl *D = Fields.invoke(DeclaratorInfo);
John McCall54abf7d2009-11-04 02:18:39 +00002796 PD.complete(D);
John McCallbdd563e2009-11-03 02:38:08 +00002797
Steve Naroff28a7ca82007-08-20 22:28:22 +00002798 // If we don't have a comma, it is either the end of the list (a ';')
2799 // or an error, bail out.
Chris Lattner04d66662007-10-09 17:33:22 +00002800 if (Tok.isNot(tok::comma))
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002801 return;
Sebastian Redlab197ba2009-02-09 18:23:29 +00002802
Steve Naroff28a7ca82007-08-20 22:28:22 +00002803 // Consume the comma.
Richard Smith7984de32012-01-12 23:53:29 +00002804 CommaLoc = ConsumeToken();
Sebastian Redlab197ba2009-02-09 18:23:29 +00002805
John McCallbdd563e2009-11-03 02:38:08 +00002806 FirstDeclarator = false;
Steve Naroff28a7ca82007-08-20 22:28:22 +00002807 }
Steve Naroff28a7ca82007-08-20 22:28:22 +00002808}
2809
2810/// ParseStructUnionBody
2811/// struct-contents:
2812/// struct-declaration-list
2813/// [EXT] empty
2814/// [GNU] "struct-declaration-list" without terminatoring ';'
2815/// struct-declaration-list:
2816/// struct-declaration
2817/// struct-declaration-list struct-declaration
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002818/// [OBC] '@' 'defs' '(' class-name ')'
Steve Naroff28a7ca82007-08-20 22:28:22 +00002819///
Reid Spencer5f016e22007-07-11 17:01:13 +00002820void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
John McCalld226f652010-08-21 09:40:31 +00002821 unsigned TagType, Decl *TagDecl) {
John McCallf312b1e2010-08-26 23:41:50 +00002822 PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc,
2823 "parsing struct/union body");
Mike Stump1eb44332009-09-09 15:08:12 +00002824
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002825 BalancedDelimiterTracker T(*this, tok::l_brace);
2826 if (T.consumeOpen())
2827 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002828
Douglas Gregor3218c4b2009-01-09 22:42:13 +00002829 ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
Douglas Gregor23c94db2010-07-02 17:43:08 +00002830 Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
Douglas Gregor72de6672009-01-08 20:45:30 +00002831
Reid Spencer5f016e22007-07-11 17:01:13 +00002832 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in
2833 // C++.
David Blaikie4e4d0842012-03-11 07:00:24 +00002834 if (Tok.is(tok::r_brace) && !getLangOpts().CPlusPlus) {
Richard Smithd7c56e12011-12-29 21:57:33 +00002835 Diag(Tok, diag::ext_empty_struct_union) << (TagType == TST_union);
2836 Diag(Tok, diag::warn_empty_struct_union_compat) << (TagType == TST_union);
2837 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002838
Chris Lattner5f9e2722011-07-23 10:55:15 +00002839 SmallVector<Decl *, 32> FieldDecls;
Chris Lattnere1359422008-04-10 06:46:29 +00002840
Reid Spencer5f016e22007-07-11 17:01:13 +00002841 // While we still have something to read, read the declarations in the struct.
Chris Lattner04d66662007-10-09 17:33:22 +00002842 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002843 // Each iteration of this loop reads one struct-declaration.
Mike Stump1eb44332009-09-09 15:08:12 +00002844
Reid Spencer5f016e22007-07-11 17:01:13 +00002845 // Check for extraneous top-level semicolon.
Chris Lattner04d66662007-10-09 17:33:22 +00002846 if (Tok.is(tok::semi)) {
Richard Trieu4b0e6f12012-05-16 19:04:59 +00002847 ConsumeExtraSemi(InsideStruct,
2848 DeclSpec::getSpecifierName((DeclSpec::TST)TagType));
Reid Spencer5f016e22007-07-11 17:01:13 +00002849 continue;
2850 }
Chris Lattnere1359422008-04-10 06:46:29 +00002851
2852 // Parse all the comma separated declarators.
John McCall0b7e6782011-03-24 11:26:52 +00002853 DeclSpec DS(AttrFactory);
Mike Stump1eb44332009-09-09 15:08:12 +00002854
John McCallbdd563e2009-11-03 02:38:08 +00002855 if (!Tok.is(tok::at)) {
2856 struct CFieldCallback : FieldCallback {
2857 Parser &P;
John McCalld226f652010-08-21 09:40:31 +00002858 Decl *TagDecl;
Chris Lattner5f9e2722011-07-23 10:55:15 +00002859 SmallVectorImpl<Decl *> &FieldDecls;
John McCallbdd563e2009-11-03 02:38:08 +00002860
John McCalld226f652010-08-21 09:40:31 +00002861 CFieldCallback(Parser &P, Decl *TagDecl,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002862 SmallVectorImpl<Decl *> &FieldDecls) :
John McCallbdd563e2009-11-03 02:38:08 +00002863 P(P), TagDecl(TagDecl), FieldDecls(FieldDecls) {}
2864
John McCalld226f652010-08-21 09:40:31 +00002865 virtual Decl *invoke(FieldDeclarator &FD) {
John McCallbdd563e2009-11-03 02:38:08 +00002866 // Install the declarator into the current TagDecl.
John McCalld226f652010-08-21 09:40:31 +00002867 Decl *Field = P.Actions.ActOnField(P.getCurScope(), TagDecl,
John McCall4ba39712009-11-03 21:13:47 +00002868 FD.D.getDeclSpec().getSourceRange().getBegin(),
2869 FD.D, FD.BitfieldSize);
John McCallbdd563e2009-11-03 02:38:08 +00002870 FieldDecls.push_back(Field);
2871 return Field;
Douglas Gregor91a28862009-08-26 14:27:30 +00002872 }
John McCallbdd563e2009-11-03 02:38:08 +00002873 } Callback(*this, TagDecl, FieldDecls);
2874
2875 ParseStructDeclaration(DS, Callback);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002876 } else { // Handle @defs
2877 ConsumeToken();
2878 if (!Tok.isObjCAtKeyword(tok::objc_defs)) {
2879 Diag(Tok, diag::err_unexpected_at);
Chris Lattner3e156ad2010-02-02 00:37:27 +00002880 SkipUntil(tok::semi, true);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002881 continue;
2882 }
2883 ConsumeToken();
2884 ExpectAndConsume(tok::l_paren, diag::err_expected_lparen);
2885 if (!Tok.is(tok::identifier)) {
2886 Diag(Tok, diag::err_expected_ident);
Chris Lattner3e156ad2010-02-02 00:37:27 +00002887 SkipUntil(tok::semi, true);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002888 continue;
2889 }
Chris Lattner5f9e2722011-07-23 10:55:15 +00002890 SmallVector<Decl *, 16> Fields;
Douglas Gregor23c94db2010-07-02 17:43:08 +00002891 Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(),
Douglas Gregor44b43212008-12-11 16:49:14 +00002892 Tok.getIdentifierInfo(), Fields);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002893 FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end());
2894 ConsumeToken();
2895 ExpectAndConsume(tok::r_paren, diag::err_expected_rparen);
Mike Stump1eb44332009-09-09 15:08:12 +00002896 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002897
Chris Lattner04d66662007-10-09 17:33:22 +00002898 if (Tok.is(tok::semi)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002899 ConsumeToken();
Chris Lattner04d66662007-10-09 17:33:22 +00002900 } else if (Tok.is(tok::r_brace)) {
Chris Lattner3e156ad2010-02-02 00:37:27 +00002901 ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list);
Reid Spencer5f016e22007-07-11 17:01:13 +00002902 break;
2903 } else {
Chris Lattner3e156ad2010-02-02 00:37:27 +00002904 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
2905 // Skip to end of block or statement to avoid ext-warning on extra ';'.
Reid Spencer5f016e22007-07-11 17:01:13 +00002906 SkipUntil(tok::r_brace, true, true);
Chris Lattner3e156ad2010-02-02 00:37:27 +00002907 // If we stopped at a ';', eat it.
2908 if (Tok.is(tok::semi)) ConsumeToken();
Reid Spencer5f016e22007-07-11 17:01:13 +00002909 }
2910 }
Mike Stump1eb44332009-09-09 15:08:12 +00002911
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002912 T.consumeClose();
Mike Stump1eb44332009-09-09 15:08:12 +00002913
John McCall0b7e6782011-03-24 11:26:52 +00002914 ParsedAttributes attrs(AttrFactory);
Reid Spencer5f016e22007-07-11 17:01:13 +00002915 // If attributes exist after struct contents, parse them.
John McCall7f040a92010-12-24 02:08:15 +00002916 MaybeParseGNUAttributes(attrs);
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00002917
Douglas Gregor23c94db2010-07-02 17:43:08 +00002918 Actions.ActOnFields(getCurScope(),
David Blaikie77b6de02011-09-22 02:58:26 +00002919 RecordLoc, TagDecl, FieldDecls,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002920 T.getOpenLocation(), T.getCloseLocation(),
John McCall7f040a92010-12-24 02:08:15 +00002921 attrs.getList());
Douglas Gregor72de6672009-01-08 20:45:30 +00002922 StructScope.Exit();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002923 Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl,
2924 T.getCloseLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00002925}
2926
Reid Spencer5f016e22007-07-11 17:01:13 +00002927/// ParseEnumSpecifier
2928/// enum-specifier: [C99 6.7.2.2]
2929/// 'enum' identifier[opt] '{' enumerator-list '}'
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002930///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
Reid Spencer5f016e22007-07-11 17:01:13 +00002931/// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
2932/// '}' attributes[opt]
Aaron Ballman6454a022012-03-01 04:09:28 +00002933/// [MS] 'enum' __declspec[opt] identifier[opt] '{' enumerator-list ',' [opt]
2934/// '}'
Reid Spencer5f016e22007-07-11 17:01:13 +00002935/// 'enum' identifier
2936/// [GNU] 'enum' attributes[opt] identifier
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002937///
Richard Smith1af83c42012-03-23 03:33:32 +00002938/// [C++11] enum-head '{' enumerator-list[opt] '}'
2939/// [C++11] enum-head '{' enumerator-list ',' '}'
Douglas Gregor1274ccd2010-10-08 23:50:27 +00002940///
Richard Smith1af83c42012-03-23 03:33:32 +00002941/// enum-head: [C++11]
2942/// enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]
2943/// enum-key attribute-specifier-seq[opt] nested-name-specifier
2944/// identifier enum-base[opt]
Douglas Gregor1274ccd2010-10-08 23:50:27 +00002945///
Richard Smith1af83c42012-03-23 03:33:32 +00002946/// enum-key: [C++11]
Douglas Gregor1274ccd2010-10-08 23:50:27 +00002947/// 'enum'
2948/// 'enum' 'class'
2949/// 'enum' 'struct'
2950///
Richard Smith1af83c42012-03-23 03:33:32 +00002951/// enum-base: [C++11]
Douglas Gregor1274ccd2010-10-08 23:50:27 +00002952/// ':' type-specifier-seq
2953///
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002954/// [C++] elaborated-type-specifier:
2955/// [C++] 'enum' '::'[opt] nested-name-specifier[opt] identifier
2956///
Chris Lattner4c97d762009-04-12 21:49:30 +00002957void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
Douglas Gregor9b9edd62010-03-02 17:53:14 +00002958 const ParsedTemplateInfo &TemplateInfo,
Richard Smith69730c12012-03-12 07:56:15 +00002959 AccessSpecifier AS, DeclSpecContext DSC) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002960 // Parse the tag portion of this.
Douglas Gregor374929f2009-09-18 15:37:17 +00002961 if (Tok.is(tok::code_completion)) {
2962 // Code completion for an enum name.
Douglas Gregor23c94db2010-07-02 17:43:08 +00002963 Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00002964 return cutOffParsing();
Douglas Gregor374929f2009-09-18 15:37:17 +00002965 }
John McCall57c13002011-07-06 05:58:41 +00002966
Sean Hunt2edf0a22012-06-23 05:07:58 +00002967 // If attributes exist after tag, parse them.
2968 ParsedAttributesWithRange attrs(AttrFactory);
2969 MaybeParseGNUAttributes(attrs);
2970 MaybeParseCXX0XAttributes(attrs);
2971
2972 // If declspecs exist after tag, parse them.
2973 while (Tok.is(tok::kw___declspec))
2974 ParseMicrosoftDeclSpec(attrs);
2975
Richard Smithbdad7a22012-01-10 01:33:14 +00002976 SourceLocation ScopedEnumKWLoc;
John McCall57c13002011-07-06 05:58:41 +00002977 bool IsScopedUsingClassTag = false;
2978
John McCall1e12b3d2012-06-23 22:30:04 +00002979 // In C++11, recognize 'enum class' and 'enum struct'.
David Blaikie4e4d0842012-03-11 07:00:24 +00002980 if (getLangOpts().CPlusPlus0x &&
John McCall57c13002011-07-06 05:58:41 +00002981 (Tok.is(tok::kw_class) || Tok.is(tok::kw_struct))) {
Richard Smith7fe62082011-10-15 05:09:34 +00002982 Diag(Tok, diag::warn_cxx98_compat_scoped_enum);
John McCall57c13002011-07-06 05:58:41 +00002983 IsScopedUsingClassTag = Tok.is(tok::kw_class);
Richard Smithbdad7a22012-01-10 01:33:14 +00002984 ScopedEnumKWLoc = ConsumeToken();
Sean Hunt2edf0a22012-06-23 05:07:58 +00002985
John McCall1e12b3d2012-06-23 22:30:04 +00002986 // Attributes are not allowed between these keywords. Diagnose,
2987 // but then just treat them like they appeared in the right place.
Sean Hunt2edf0a22012-06-23 05:07:58 +00002988 ProhibitAttributes(attrs);
John McCall1e12b3d2012-06-23 22:30:04 +00002989
2990 // They are allowed afterwards, though.
2991 MaybeParseGNUAttributes(attrs);
Sean Hunt2edf0a22012-06-23 05:07:58 +00002992 MaybeParseCXX0XAttributes(attrs);
John McCall1e12b3d2012-06-23 22:30:04 +00002993 while (Tok.is(tok::kw___declspec))
2994 ParseMicrosoftDeclSpec(attrs);
John McCall57c13002011-07-06 05:58:41 +00002995 }
Richard Smith1af83c42012-03-23 03:33:32 +00002996
John McCall13489672012-05-07 06:16:58 +00002997 // C++11 [temp.explicit]p12:
2998 // The usual access controls do not apply to names used to specify
2999 // explicit instantiations.
3000 // We extend this to also cover explicit specializations. Note that
3001 // we don't suppress if this turns out to be an elaborated type
3002 // specifier.
3003 bool shouldDelayDiagsInTag =
3004 (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
3005 TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
3006 SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag);
Richard Smith1af83c42012-03-23 03:33:32 +00003007
Richard Smith7796eb52012-03-12 08:56:40 +00003008 // Enum definitions should not be parsed in a trailing-return-type.
3009 bool AllowDeclaration = DSC != DSC_trailing;
3010
3011 bool AllowFixedUnderlyingType = AllowDeclaration &&
3012 (getLangOpts().CPlusPlus0x || getLangOpts().MicrosoftExt ||
3013 getLangOpts().ObjC2);
John McCall57c13002011-07-06 05:58:41 +00003014
Abramo Bagnarae4da7a02010-05-19 21:37:53 +00003015 CXXScopeSpec &SS = DS.getTypeSpecScope();
David Blaikie4e4d0842012-03-11 07:00:24 +00003016 if (getLangOpts().CPlusPlus) {
John McCall57c13002011-07-06 05:58:41 +00003017 // "enum foo : bar;" is not a potential typo for "enum foo::bar;"
3018 // if a fixed underlying type is allowed.
3019 ColonProtectionRAIIObject X(*this, AllowFixedUnderlyingType);
3020
Douglas Gregorefaa93a2011-11-07 17:33:42 +00003021 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
3022 /*EnteringContext=*/false))
John McCall9ba61662010-02-26 08:45:28 +00003023 return;
3024
3025 if (SS.isSet() && Tok.isNot(tok::identifier)) {
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003026 Diag(Tok, diag::err_expected_ident);
3027 if (Tok.isNot(tok::l_brace)) {
3028 // Has no name and is not a definition.
3029 // Skip the rest of this declarator, up until the comma or semicolon.
3030 SkipUntil(tok::comma, true);
3031 return;
3032 }
3033 }
3034 }
Mike Stump1eb44332009-09-09 15:08:12 +00003035
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003036 // Must have either 'enum name' or 'enum {...}'.
Douglas Gregorb9075602011-02-22 02:55:24 +00003037 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) &&
Richard Smith7796eb52012-03-12 08:56:40 +00003038 !(AllowFixedUnderlyingType && Tok.is(tok::colon))) {
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003039 Diag(Tok, diag::err_expected_ident_lbrace);
Mike Stump1eb44332009-09-09 15:08:12 +00003040
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003041 // Skip the rest of this declarator, up until the comma or semicolon.
3042 SkipUntil(tok::comma, true);
Reid Spencer5f016e22007-07-11 17:01:13 +00003043 return;
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003044 }
Mike Stump1eb44332009-09-09 15:08:12 +00003045
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003046 // If an identifier is present, consume and remember it.
3047 IdentifierInfo *Name = 0;
3048 SourceLocation NameLoc;
3049 if (Tok.is(tok::identifier)) {
3050 Name = Tok.getIdentifierInfo();
3051 NameLoc = ConsumeToken();
3052 }
Mike Stump1eb44332009-09-09 15:08:12 +00003053
Richard Smithbdad7a22012-01-10 01:33:14 +00003054 if (!Name && ScopedEnumKWLoc.isValid()) {
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003055 // C++0x 7.2p2: The optional identifier shall not be omitted in the
3056 // declaration of a scoped enumeration.
3057 Diag(Tok, diag::err_scoped_enum_missing_identifier);
Richard Smithbdad7a22012-01-10 01:33:14 +00003058 ScopedEnumKWLoc = SourceLocation();
Abramo Bagnaraa88cefd2010-12-03 18:54:17 +00003059 IsScopedUsingClassTag = false;
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003060 }
3061
John McCall13489672012-05-07 06:16:58 +00003062 // Okay, end the suppression area. We'll decide whether to emit the
3063 // diagnostics in a second.
3064 if (shouldDelayDiagsInTag)
3065 diagsFromTag.done();
Richard Smith1af83c42012-03-23 03:33:32 +00003066
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003067 TypeResult BaseType;
3068
Douglas Gregora61b3e72010-12-01 17:42:47 +00003069 // Parse the fixed underlying type.
Douglas Gregorb9075602011-02-22 02:55:24 +00003070 if (AllowFixedUnderlyingType && Tok.is(tok::colon)) {
Douglas Gregora61b3e72010-12-01 17:42:47 +00003071 bool PossibleBitfield = false;
3072 if (getCurScope()->getFlags() & Scope::ClassScope) {
3073 // If we're in class scope, this can either be an enum declaration with
3074 // an underlying type, or a declaration of a bitfield member. We try to
3075 // use a simple disambiguation scheme first to catch the common cases
3076 // (integer literal, sizeof); if it's still ambiguous, we then consider
3077 // anything that's a simple-type-specifier followed by '(' as an
3078 // expression. This suffices because function types are not valid
3079 // underlying types anyway.
3080 TPResult TPR = isExpressionOrTypeSpecifierSimple(NextToken().getKind());
3081 // If the next token starts an expression, we know we're parsing a
3082 // bit-field. This is the common case.
3083 if (TPR == TPResult::True())
3084 PossibleBitfield = true;
3085 // If the next token starts a type-specifier-seq, it may be either a
3086 // a fixed underlying type or the start of a function-style cast in C++;
3087 // lookahead one more token to see if it's obvious that we have a
3088 // fixed underlying type.
3089 else if (TPR == TPResult::False() &&
3090 GetLookAheadToken(2).getKind() == tok::semi) {
3091 // Consume the ':'.
3092 ConsumeToken();
3093 } else {
3094 // We have the start of a type-specifier-seq, so we have to perform
3095 // tentative parsing to determine whether we have an expression or a
3096 // type.
3097 TentativeParsingAction TPA(*this);
3098
3099 // Consume the ':'.
3100 ConsumeToken();
Richard Smithd81e9612012-02-23 01:36:12 +00003101
3102 // If we see a type specifier followed by an open-brace, we have an
3103 // ambiguity between an underlying type and a C++11 braced
3104 // function-style cast. Resolve this by always treating it as an
3105 // underlying type.
3106 // FIXME: The standard is not entirely clear on how to disambiguate in
3107 // this case.
David Blaikie4e4d0842012-03-11 07:00:24 +00003108 if ((getLangOpts().CPlusPlus &&
Richard Smithd81e9612012-02-23 01:36:12 +00003109 isCXXDeclarationSpecifier(TPResult::True()) != TPResult::True()) ||
David Blaikie4e4d0842012-03-11 07:00:24 +00003110 (!getLangOpts().CPlusPlus && !isDeclarationSpecifier(true))) {
Douglas Gregora61b3e72010-12-01 17:42:47 +00003111 // We'll parse this as a bitfield later.
3112 PossibleBitfield = true;
3113 TPA.Revert();
3114 } else {
3115 // We have a type-specifier-seq.
3116 TPA.Commit();
3117 }
3118 }
3119 } else {
3120 // Consume the ':'.
3121 ConsumeToken();
3122 }
3123
3124 if (!PossibleBitfield) {
3125 SourceRange Range;
3126 BaseType = ParseTypeName(&Range);
Douglas Gregor86f208c2011-02-22 20:32:04 +00003127
David Blaikie4e4d0842012-03-11 07:00:24 +00003128 if (!getLangOpts().CPlusPlus0x && !getLangOpts().ObjC2)
Douglas Gregor86f208c2011-02-22 20:32:04 +00003129 Diag(StartLoc, diag::ext_ms_enum_fixed_underlying_type)
3130 << Range;
David Blaikie4e4d0842012-03-11 07:00:24 +00003131 if (getLangOpts().CPlusPlus0x)
Richard Smith7fe62082011-10-15 05:09:34 +00003132 Diag(StartLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type);
Douglas Gregora61b3e72010-12-01 17:42:47 +00003133 }
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003134 }
3135
Richard Smithbdad7a22012-01-10 01:33:14 +00003136 // There are four options here. If we have 'friend enum foo;' then this is a
3137 // friend declaration, and cannot have an accompanying definition. If we have
3138 // 'enum foo;', then this is a forward declaration. If we have
3139 // 'enum foo {...' then this is a definition. Otherwise we have something
3140 // like 'enum foo xyz', a reference.
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003141 //
3142 // This is needed to handle stuff like this right (C99 6.7.2.3p11):
3143 // enum foo {..}; void bar() { enum foo; } <- new foo in bar.
3144 // enum foo {..}; void bar() { enum foo x; } <- use of old foo.
3145 //
John McCallf312b1e2010-08-26 23:41:50 +00003146 Sema::TagUseKind TUK;
John McCall13489672012-05-07 06:16:58 +00003147 if (!AllowDeclaration) {
Richard Smith7796eb52012-03-12 08:56:40 +00003148 TUK = Sema::TUK_Reference;
John McCall13489672012-05-07 06:16:58 +00003149 } else if (Tok.is(tok::l_brace)) {
3150 if (DS.isFriendSpecified()) {
3151 Diag(Tok.getLocation(), diag::err_friend_decl_defines_type)
3152 << SourceRange(DS.getFriendSpecLoc());
3153 ConsumeBrace();
3154 SkipUntil(tok::r_brace);
3155 TUK = Sema::TUK_Friend;
3156 } else {
3157 TUK = Sema::TUK_Definition;
3158 }
3159 } else if (Tok.is(tok::semi) && DSC != DSC_type_specifier) {
3160 TUK = (DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration);
3161 } else {
John McCallf312b1e2010-08-26 23:41:50 +00003162 TUK = Sema::TUK_Reference;
John McCall13489672012-05-07 06:16:58 +00003163 }
3164
3165 // If this is an elaborated type specifier, and we delayed
3166 // diagnostics before, just merge them into the current pool.
3167 if (TUK == Sema::TUK_Reference && shouldDelayDiagsInTag) {
3168 diagsFromTag.redelay();
3169 }
Richard Smith1af83c42012-03-23 03:33:32 +00003170
3171 MultiTemplateParamsArg TParams;
Douglas Gregor8fc6d232010-05-03 17:48:54 +00003172 if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
John McCallf312b1e2010-08-26 23:41:50 +00003173 TUK != Sema::TUK_Reference) {
Richard Smith1af83c42012-03-23 03:33:32 +00003174 if (!getLangOpts().CPlusPlus0x || !SS.isSet()) {
3175 // Skip the rest of this declarator, up until the comma or semicolon.
3176 Diag(Tok, diag::err_enum_template);
3177 SkipUntil(tok::comma, true);
3178 return;
3179 }
3180
3181 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
3182 // Enumerations can't be explicitly instantiated.
3183 DS.SetTypeSpecError();
3184 Diag(StartLoc, diag::err_explicit_instantiation_enum);
3185 return;
3186 }
3187
3188 assert(TemplateInfo.TemplateParams && "no template parameters");
3189 TParams = MultiTemplateParamsArg(TemplateInfo.TemplateParams->data(),
3190 TemplateInfo.TemplateParams->size());
Douglas Gregor8fc6d232010-05-03 17:48:54 +00003191 }
Sean Hunt2edf0a22012-06-23 05:07:58 +00003192
3193 if (TUK == Sema::TUK_Reference)
3194 ProhibitAttributes(attrs);
Richard Smith1af83c42012-03-23 03:33:32 +00003195
Douglas Gregorb9075602011-02-22 02:55:24 +00003196 if (!Name && TUK != Sema::TUK_Definition) {
3197 Diag(Tok, diag::err_enumerator_unnamed_no_def);
Richard Smith1af83c42012-03-23 03:33:32 +00003198
Douglas Gregorb9075602011-02-22 02:55:24 +00003199 // Skip the rest of this declarator, up until the comma or semicolon.
3200 SkipUntil(tok::comma, true);
3201 return;
3202 }
Richard Smith1af83c42012-03-23 03:33:32 +00003203
Douglas Gregor402abb52009-05-28 23:31:59 +00003204 bool Owned = false;
John McCallc4e70192009-09-11 04:59:25 +00003205 bool IsDependent = false;
Douglas Gregor48c89f42010-04-24 16:38:41 +00003206 const char *PrevSpec = 0;
3207 unsigned DiagID;
John McCalld226f652010-08-21 09:40:31 +00003208 Decl *TagDecl = Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK,
John McCall7f040a92010-12-24 02:08:15 +00003209 StartLoc, SS, Name, NameLoc, attrs.getList(),
Richard Smith1af83c42012-03-23 03:33:32 +00003210 AS, DS.getModulePrivateSpecLoc(), TParams,
Richard Smithbdad7a22012-01-10 01:33:14 +00003211 Owned, IsDependent, ScopedEnumKWLoc,
Abramo Bagnaraa88cefd2010-12-03 18:54:17 +00003212 IsScopedUsingClassTag, BaseType);
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003213
Douglas Gregor48c89f42010-04-24 16:38:41 +00003214 if (IsDependent) {
3215 // This enum has a dependent nested-name-specifier. Handle it as a
3216 // dependent tag.
3217 if (!Name) {
3218 DS.SetTypeSpecError();
3219 Diag(Tok, diag::err_expected_type_name_after_typename);
3220 return;
3221 }
3222
Douglas Gregor23c94db2010-07-02 17:43:08 +00003223 TypeResult Type = Actions.ActOnDependentTag(getCurScope(), DeclSpec::TST_enum,
Douglas Gregor48c89f42010-04-24 16:38:41 +00003224 TUK, SS, Name, StartLoc,
3225 NameLoc);
3226 if (Type.isInvalid()) {
3227 DS.SetTypeSpecError();
3228 return;
3229 }
3230
Abramo Bagnara0daaf322011-03-16 20:16:18 +00003231 if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
3232 NameLoc.isValid() ? NameLoc : StartLoc,
3233 PrevSpec, DiagID, Type.get()))
Douglas Gregor48c89f42010-04-24 16:38:41 +00003234 Diag(StartLoc, DiagID) << PrevSpec;
3235
3236 return;
3237 }
Mike Stump1eb44332009-09-09 15:08:12 +00003238
John McCalld226f652010-08-21 09:40:31 +00003239 if (!TagDecl) {
Douglas Gregor48c89f42010-04-24 16:38:41 +00003240 // The action failed to produce an enumeration tag. If this is a
3241 // definition, consume the entire definition.
Richard Smith7796eb52012-03-12 08:56:40 +00003242 if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference) {
Douglas Gregor48c89f42010-04-24 16:38:41 +00003243 ConsumeBrace();
3244 SkipUntil(tok::r_brace);
3245 }
3246
3247 DS.SetTypeSpecError();
3248 return;
3249 }
Richard Smithbdad7a22012-01-10 01:33:14 +00003250
Richard Smith7796eb52012-03-12 08:56:40 +00003251 if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference) {
John McCall13489672012-05-07 06:16:58 +00003252 ParseEnumBody(StartLoc, TagDecl);
Richard Smithbdad7a22012-01-10 01:33:14 +00003253 }
Mike Stump1eb44332009-09-09 15:08:12 +00003254
Abramo Bagnara0daaf322011-03-16 20:16:18 +00003255 if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
3256 NameLoc.isValid() ? NameLoc : StartLoc,
3257 PrevSpec, DiagID, TagDecl, Owned))
John McCallfec54012009-08-03 20:12:06 +00003258 Diag(StartLoc, DiagID) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00003259}
3260
3261/// ParseEnumBody - Parse a {} enclosed enumerator-list.
3262/// enumerator-list:
3263/// enumerator
3264/// enumerator-list ',' enumerator
3265/// enumerator:
3266/// enumeration-constant
3267/// enumeration-constant '=' constant-expression
3268/// enumeration-constant:
3269/// identifier
3270///
John McCalld226f652010-08-21 09:40:31 +00003271void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {
Douglas Gregor074149e2009-01-05 19:45:36 +00003272 // Enter the scope of the enum body and start the definition.
3273 ParseScope EnumScope(this, Scope::DeclScope);
Douglas Gregor23c94db2010-07-02 17:43:08 +00003274 Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl);
Douglas Gregor074149e2009-01-05 19:45:36 +00003275
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003276 BalancedDelimiterTracker T(*this, tok::l_brace);
3277 T.consumeOpen();
Mike Stump1eb44332009-09-09 15:08:12 +00003278
Chris Lattner7946dd32007-08-27 17:24:30 +00003279 // C does not allow an empty enumerator-list, C++ does [dcl.enum].
David Blaikie4e4d0842012-03-11 07:00:24 +00003280 if (Tok.is(tok::r_brace) && !getLangOpts().CPlusPlus)
Fariborz Jahanian05115522010-05-28 22:23:22 +00003281 Diag(Tok, diag::error_empty_enum);
Mike Stump1eb44332009-09-09 15:08:12 +00003282
Chris Lattner5f9e2722011-07-23 10:55:15 +00003283 SmallVector<Decl *, 32> EnumConstantDecls;
Reid Spencer5f016e22007-07-11 17:01:13 +00003284
John McCalld226f652010-08-21 09:40:31 +00003285 Decl *LastEnumConstDecl = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00003286
Reid Spencer5f016e22007-07-11 17:01:13 +00003287 // Parse the enumerator-list.
Chris Lattner04d66662007-10-09 17:33:22 +00003288 while (Tok.is(tok::identifier)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003289 IdentifierInfo *Ident = Tok.getIdentifierInfo();
3290 SourceLocation IdentLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00003291
John McCall5b629aa2010-10-22 23:36:17 +00003292 // If attributes exist after the enumerator, parse them.
Sean Hunt2edf0a22012-06-23 05:07:58 +00003293 ParsedAttributesWithRange attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00003294 MaybeParseGNUAttributes(attrs);
Sean Hunt2edf0a22012-06-23 05:07:58 +00003295 MaybeParseCXX0XAttributes(attrs);
3296 ProhibitAttributes(attrs);
John McCall5b629aa2010-10-22 23:36:17 +00003297
Reid Spencer5f016e22007-07-11 17:01:13 +00003298 SourceLocation EqualLoc;
John McCall60d7b3a2010-08-24 06:29:42 +00003299 ExprResult AssignedVal;
John McCall92576642012-05-07 06:16:41 +00003300 ParsingDeclRAIIObject PD(*this, ParsingDeclRAIIObject::NoParent);
Fariborz Jahanian5a477db2011-12-09 01:15:54 +00003301
Chris Lattner04d66662007-10-09 17:33:22 +00003302 if (Tok.is(tok::equal)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003303 EqualLoc = ConsumeToken();
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00003304 AssignedVal = ParseConstantExpression();
3305 if (AssignedVal.isInvalid())
Reid Spencer5f016e22007-07-11 17:01:13 +00003306 SkipUntil(tok::comma, tok::r_brace, true, true);
Reid Spencer5f016e22007-07-11 17:01:13 +00003307 }
Mike Stump1eb44332009-09-09 15:08:12 +00003308
Reid Spencer5f016e22007-07-11 17:01:13 +00003309 // Install the enumerator constant into EnumDecl.
John McCalld226f652010-08-21 09:40:31 +00003310 Decl *EnumConstDecl = Actions.ActOnEnumConstant(getCurScope(), EnumDecl,
3311 LastEnumConstDecl,
3312 IdentLoc, Ident,
John McCall7f040a92010-12-24 02:08:15 +00003313 attrs.getList(), EqualLoc,
John McCalld226f652010-08-21 09:40:31 +00003314 AssignedVal.release());
Fariborz Jahanian5a477db2011-12-09 01:15:54 +00003315 PD.complete(EnumConstDecl);
3316
Reid Spencer5f016e22007-07-11 17:01:13 +00003317 EnumConstantDecls.push_back(EnumConstDecl);
3318 LastEnumConstDecl = EnumConstDecl;
Mike Stump1eb44332009-09-09 15:08:12 +00003319
Douglas Gregor751f6922010-09-07 14:51:08 +00003320 if (Tok.is(tok::identifier)) {
3321 // We're missing a comma between enumerators.
3322 SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation);
3323 Diag(Loc, diag::err_enumerator_list_missing_comma)
3324 << FixItHint::CreateInsertion(Loc, ", ");
3325 continue;
3326 }
3327
Chris Lattner04d66662007-10-09 17:33:22 +00003328 if (Tok.isNot(tok::comma))
Reid Spencer5f016e22007-07-11 17:01:13 +00003329 break;
3330 SourceLocation CommaLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00003331
Richard Smith7fe62082011-10-15 05:09:34 +00003332 if (Tok.isNot(tok::identifier)) {
David Blaikie4e4d0842012-03-11 07:00:24 +00003333 if (!getLangOpts().C99 && !getLangOpts().CPlusPlus0x)
Richard Smith7fe62082011-10-15 05:09:34 +00003334 Diag(CommaLoc, diag::ext_enumerator_list_comma)
David Blaikie4e4d0842012-03-11 07:00:24 +00003335 << getLangOpts().CPlusPlus
Richard Smith7fe62082011-10-15 05:09:34 +00003336 << FixItHint::CreateRemoval(CommaLoc);
David Blaikie4e4d0842012-03-11 07:00:24 +00003337 else if (getLangOpts().CPlusPlus0x)
Richard Smith7fe62082011-10-15 05:09:34 +00003338 Diag(CommaLoc, diag::warn_cxx98_compat_enumerator_list_comma)
3339 << FixItHint::CreateRemoval(CommaLoc);
3340 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003341 }
Mike Stump1eb44332009-09-09 15:08:12 +00003342
Reid Spencer5f016e22007-07-11 17:01:13 +00003343 // Eat the }.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003344 T.consumeClose();
Reid Spencer5f016e22007-07-11 17:01:13 +00003345
Reid Spencer5f016e22007-07-11 17:01:13 +00003346 // If attributes exist after the identifier list, parse them.
John McCall0b7e6782011-03-24 11:26:52 +00003347 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00003348 MaybeParseGNUAttributes(attrs);
Douglas Gregor72de6672009-01-08 20:45:30 +00003349
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003350 Actions.ActOnEnumBody(StartLoc, T.getOpenLocation(), T.getCloseLocation(),
3351 EnumDecl, EnumConstantDecls.data(),
3352 EnumConstantDecls.size(), getCurScope(),
3353 attrs.getList());
Mike Stump1eb44332009-09-09 15:08:12 +00003354
Douglas Gregor72de6672009-01-08 20:45:30 +00003355 EnumScope.Exit();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003356 Actions.ActOnTagFinishDefinition(getCurScope(), EnumDecl,
3357 T.getCloseLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00003358}
3359
3360/// isTypeSpecifierQualifier - Return true if the current token could be the
Steve Naroff5f8aa692008-02-11 23:15:56 +00003361/// start of a type-qualifier-list.
3362bool Parser::isTypeQualifier() const {
3363 switch (Tok.getKind()) {
3364 default: return false;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003365
3366 // type-qualifier only in OpenCL
3367 case tok::kw_private:
David Blaikie4e4d0842012-03-11 07:00:24 +00003368 return getLangOpts().OpenCL;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003369
Steve Naroff5f8aa692008-02-11 23:15:56 +00003370 // type-qualifier
3371 case tok::kw_const:
3372 case tok::kw_volatile:
3373 case tok::kw_restrict:
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003374 case tok::kw___private:
3375 case tok::kw___local:
3376 case tok::kw___global:
3377 case tok::kw___constant:
3378 case tok::kw___read_only:
3379 case tok::kw___read_write:
3380 case tok::kw___write_only:
Steve Naroff5f8aa692008-02-11 23:15:56 +00003381 return true;
3382 }
3383}
3384
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003385/// isKnownToBeTypeSpecifier - Return true if we know that the specified token
3386/// is definitely a type-specifier. Return false if it isn't part of a type
3387/// specifier or if we're not sure.
3388bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const {
3389 switch (Tok.getKind()) {
3390 default: return false;
3391 // type-specifiers
3392 case tok::kw_short:
3393 case tok::kw_long:
Francois Pichet338d7f72011-04-28 01:59:37 +00003394 case tok::kw___int64:
Richard Smith5a5a9712012-04-04 06:24:32 +00003395 case tok::kw___int128:
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003396 case tok::kw_signed:
3397 case tok::kw_unsigned:
3398 case tok::kw__Complex:
3399 case tok::kw__Imaginary:
3400 case tok::kw_void:
3401 case tok::kw_char:
3402 case tok::kw_wchar_t:
3403 case tok::kw_char16_t:
3404 case tok::kw_char32_t:
3405 case tok::kw_int:
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00003406 case tok::kw_half:
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003407 case tok::kw_float:
3408 case tok::kw_double:
3409 case tok::kw_bool:
3410 case tok::kw__Bool:
3411 case tok::kw__Decimal32:
3412 case tok::kw__Decimal64:
3413 case tok::kw__Decimal128:
3414 case tok::kw___vector:
3415
3416 // struct-or-union-specifier (C99) or class-specifier (C++)
3417 case tok::kw_class:
3418 case tok::kw_struct:
3419 case tok::kw_union:
3420 // enum-specifier
3421 case tok::kw_enum:
3422
3423 // typedef-name
3424 case tok::annot_typename:
3425 return true;
3426 }
3427}
3428
Steve Naroff5f8aa692008-02-11 23:15:56 +00003429/// isTypeSpecifierQualifier - Return true if the current token could be the
Reid Spencer5f016e22007-07-11 17:01:13 +00003430/// start of a specifier-qualifier-list.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003431bool Parser::isTypeSpecifierQualifier() {
Reid Spencer5f016e22007-07-11 17:01:13 +00003432 switch (Tok.getKind()) {
3433 default: return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003434
Chris Lattner166a8fc2009-01-04 23:41:41 +00003435 case tok::identifier: // foo::bar
John Thompson82287d12010-02-05 00:12:22 +00003436 if (TryAltiVecVectorToken())
3437 return true;
3438 // Fall through.
Douglas Gregord57959a2009-03-27 23:10:48 +00003439 case tok::kw_typename: // typename T::type
Chris Lattner166a8fc2009-01-04 23:41:41 +00003440 // Annotate typenames and C++ scope specifiers. If we get one, just
3441 // recurse to handle whatever we get.
3442 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003443 return true;
3444 if (Tok.is(tok::identifier))
3445 return false;
3446 return isTypeSpecifierQualifier();
Douglas Gregord57959a2009-03-27 23:10:48 +00003447
Chris Lattner166a8fc2009-01-04 23:41:41 +00003448 case tok::coloncolon: // ::foo::bar
3449 if (NextToken().is(tok::kw_new) || // ::new
3450 NextToken().is(tok::kw_delete)) // ::delete
3451 return false;
3452
Chris Lattner166a8fc2009-01-04 23:41:41 +00003453 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003454 return true;
3455 return isTypeSpecifierQualifier();
Mike Stump1eb44332009-09-09 15:08:12 +00003456
Reid Spencer5f016e22007-07-11 17:01:13 +00003457 // GNU attributes support.
3458 case tok::kw___attribute:
Steve Naroffd1861fd2007-07-31 12:34:36 +00003459 // GNU typeof support.
3460 case tok::kw_typeof:
Mike Stump1eb44332009-09-09 15:08:12 +00003461
Reid Spencer5f016e22007-07-11 17:01:13 +00003462 // type-specifiers
3463 case tok::kw_short:
3464 case tok::kw_long:
Francois Pichet338d7f72011-04-28 01:59:37 +00003465 case tok::kw___int64:
Richard Smith5a5a9712012-04-04 06:24:32 +00003466 case tok::kw___int128:
Reid Spencer5f016e22007-07-11 17:01:13 +00003467 case tok::kw_signed:
3468 case tok::kw_unsigned:
3469 case tok::kw__Complex:
3470 case tok::kw__Imaginary:
3471 case tok::kw_void:
3472 case tok::kw_char:
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +00003473 case tok::kw_wchar_t:
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00003474 case tok::kw_char16_t:
3475 case tok::kw_char32_t:
Reid Spencer5f016e22007-07-11 17:01:13 +00003476 case tok::kw_int:
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00003477 case tok::kw_half:
Reid Spencer5f016e22007-07-11 17:01:13 +00003478 case tok::kw_float:
3479 case tok::kw_double:
Chris Lattner9298d962007-11-15 05:25:19 +00003480 case tok::kw_bool:
Reid Spencer5f016e22007-07-11 17:01:13 +00003481 case tok::kw__Bool:
3482 case tok::kw__Decimal32:
3483 case tok::kw__Decimal64:
3484 case tok::kw__Decimal128:
John Thompson82287d12010-02-05 00:12:22 +00003485 case tok::kw___vector:
Mike Stump1eb44332009-09-09 15:08:12 +00003486
Chris Lattner99dc9142008-04-13 18:59:07 +00003487 // struct-or-union-specifier (C99) or class-specifier (C++)
3488 case tok::kw_class:
Reid Spencer5f016e22007-07-11 17:01:13 +00003489 case tok::kw_struct:
3490 case tok::kw_union:
3491 // enum-specifier
3492 case tok::kw_enum:
Mike Stump1eb44332009-09-09 15:08:12 +00003493
Reid Spencer5f016e22007-07-11 17:01:13 +00003494 // type-qualifier
3495 case tok::kw_const:
3496 case tok::kw_volatile:
3497 case tok::kw_restrict:
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003498
3499 // typedef-name
Chris Lattnerb31757b2009-01-06 05:06:21 +00003500 case tok::annot_typename:
Reid Spencer5f016e22007-07-11 17:01:13 +00003501 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00003502
Chris Lattner7c186be2008-10-20 00:25:30 +00003503 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
3504 case tok::less:
David Blaikie4e4d0842012-03-11 07:00:24 +00003505 return getLangOpts().ObjC1;
Mike Stump1eb44332009-09-09 15:08:12 +00003506
Steve Naroff239f0732008-12-25 14:16:32 +00003507 case tok::kw___cdecl:
3508 case tok::kw___stdcall:
3509 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00003510 case tok::kw___thiscall:
Eli Friedman290eeb02009-06-08 23:27:34 +00003511 case tok::kw___w64:
3512 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00003513 case tok::kw___ptr32:
Dawn Perchik52fc3142010-09-03 01:29:35 +00003514 case tok::kw___pascal:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00003515 case tok::kw___unaligned:
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003516
3517 case tok::kw___private:
3518 case tok::kw___local:
3519 case tok::kw___global:
3520 case tok::kw___constant:
3521 case tok::kw___read_only:
3522 case tok::kw___read_write:
3523 case tok::kw___write_only:
3524
Eli Friedman290eeb02009-06-08 23:27:34 +00003525 return true;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003526
3527 case tok::kw_private:
David Blaikie4e4d0842012-03-11 07:00:24 +00003528 return getLangOpts().OpenCL;
Eli Friedmanb001de72011-10-06 23:00:33 +00003529
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00003530 // C11 _Atomic()
Eli Friedmanb001de72011-10-06 23:00:33 +00003531 case tok::kw__Atomic:
3532 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00003533 }
3534}
3535
3536/// isDeclarationSpecifier() - Return true if the current token is part of a
3537/// declaration specifier.
Douglas Gregor9497a732010-09-16 01:51:54 +00003538///
3539/// \param DisambiguatingWithExpression True to indicate that the purpose of
3540/// this check is to disambiguate between an expression and a declaration.
3541bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003542 switch (Tok.getKind()) {
3543 default: return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003544
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003545 case tok::kw_private:
David Blaikie4e4d0842012-03-11 07:00:24 +00003546 return getLangOpts().OpenCL;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003547
Chris Lattner166a8fc2009-01-04 23:41:41 +00003548 case tok::identifier: // foo::bar
Steve Naroff61f72cb2009-03-09 21:12:44 +00003549 // Unfortunate hack to support "Class.factoryMethod" notation.
David Blaikie4e4d0842012-03-11 07:00:24 +00003550 if (getLangOpts().ObjC1 && NextToken().is(tok::period))
Steve Naroff61f72cb2009-03-09 21:12:44 +00003551 return false;
John Thompson82287d12010-02-05 00:12:22 +00003552 if (TryAltiVecVectorToken())
3553 return true;
3554 // Fall through.
David Blaikie42d6d0c2011-12-04 05:04:18 +00003555 case tok::kw_decltype: // decltype(T())::type
Douglas Gregord57959a2009-03-27 23:10:48 +00003556 case tok::kw_typename: // typename T::type
Chris Lattner166a8fc2009-01-04 23:41:41 +00003557 // Annotate typenames and C++ scope specifiers. If we get one, just
3558 // recurse to handle whatever we get.
3559 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003560 return true;
3561 if (Tok.is(tok::identifier))
3562 return false;
Douglas Gregor9497a732010-09-16 01:51:54 +00003563
3564 // If we're in Objective-C and we have an Objective-C class type followed
3565 // by an identifier and then either ':' or ']', in a place where an
3566 // expression is permitted, then this is probably a class message send
3567 // missing the initial '['. In this case, we won't consider this to be
3568 // the start of a declaration.
3569 if (DisambiguatingWithExpression &&
3570 isStartOfObjCClassMessageMissingOpenBracket())
3571 return false;
3572
John McCall9ba61662010-02-26 08:45:28 +00003573 return isDeclarationSpecifier();
3574
Chris Lattner166a8fc2009-01-04 23:41:41 +00003575 case tok::coloncolon: // ::foo::bar
3576 if (NextToken().is(tok::kw_new) || // ::new
3577 NextToken().is(tok::kw_delete)) // ::delete
3578 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003579
Chris Lattner166a8fc2009-01-04 23:41:41 +00003580 // Annotate typenames and C++ scope specifiers. If we get one, just
3581 // recurse to handle whatever we get.
3582 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003583 return true;
3584 return isDeclarationSpecifier();
Mike Stump1eb44332009-09-09 15:08:12 +00003585
Reid Spencer5f016e22007-07-11 17:01:13 +00003586 // storage-class-specifier
3587 case tok::kw_typedef:
3588 case tok::kw_extern:
Steve Naroff8d54bf22007-12-18 00:16:02 +00003589 case tok::kw___private_extern__:
Reid Spencer5f016e22007-07-11 17:01:13 +00003590 case tok::kw_static:
3591 case tok::kw_auto:
3592 case tok::kw_register:
3593 case tok::kw___thread:
Mike Stump1eb44332009-09-09 15:08:12 +00003594
Douglas Gregor8d267c52011-09-09 02:06:17 +00003595 // Modules
3596 case tok::kw___module_private__:
3597
Reid Spencer5f016e22007-07-11 17:01:13 +00003598 // type-specifiers
3599 case tok::kw_short:
3600 case tok::kw_long:
Francois Pichet338d7f72011-04-28 01:59:37 +00003601 case tok::kw___int64:
Richard Smith5a5a9712012-04-04 06:24:32 +00003602 case tok::kw___int128:
Reid Spencer5f016e22007-07-11 17:01:13 +00003603 case tok::kw_signed:
3604 case tok::kw_unsigned:
3605 case tok::kw__Complex:
3606 case tok::kw__Imaginary:
3607 case tok::kw_void:
3608 case tok::kw_char:
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +00003609 case tok::kw_wchar_t:
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00003610 case tok::kw_char16_t:
3611 case tok::kw_char32_t:
3612
Reid Spencer5f016e22007-07-11 17:01:13 +00003613 case tok::kw_int:
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00003614 case tok::kw_half:
Reid Spencer5f016e22007-07-11 17:01:13 +00003615 case tok::kw_float:
3616 case tok::kw_double:
Chris Lattner9298d962007-11-15 05:25:19 +00003617 case tok::kw_bool:
Reid Spencer5f016e22007-07-11 17:01:13 +00003618 case tok::kw__Bool:
3619 case tok::kw__Decimal32:
3620 case tok::kw__Decimal64:
3621 case tok::kw__Decimal128:
John Thompson82287d12010-02-05 00:12:22 +00003622 case tok::kw___vector:
Mike Stump1eb44332009-09-09 15:08:12 +00003623
Chris Lattner99dc9142008-04-13 18:59:07 +00003624 // struct-or-union-specifier (C99) or class-specifier (C++)
3625 case tok::kw_class:
Reid Spencer5f016e22007-07-11 17:01:13 +00003626 case tok::kw_struct:
3627 case tok::kw_union:
3628 // enum-specifier
3629 case tok::kw_enum:
Mike Stump1eb44332009-09-09 15:08:12 +00003630
Reid Spencer5f016e22007-07-11 17:01:13 +00003631 // type-qualifier
3632 case tok::kw_const:
3633 case tok::kw_volatile:
3634 case tok::kw_restrict:
Steve Naroffd1861fd2007-07-31 12:34:36 +00003635
Reid Spencer5f016e22007-07-11 17:01:13 +00003636 // function-specifier
3637 case tok::kw_inline:
Douglas Gregorb48fe382008-10-31 09:07:45 +00003638 case tok::kw_virtual:
3639 case tok::kw_explicit:
Chris Lattnerd6c7c182007-08-09 16:40:21 +00003640
Peter Collingbournec6eb44b2011-04-15 00:35:57 +00003641 // static_assert-declaration
3642 case tok::kw__Static_assert:
3643
Chris Lattner1ef08762007-08-09 17:01:07 +00003644 // GNU typeof support.
3645 case tok::kw_typeof:
Mike Stump1eb44332009-09-09 15:08:12 +00003646
Chris Lattner1ef08762007-08-09 17:01:07 +00003647 // GNU attributes.
Chris Lattnerd6c7c182007-08-09 16:40:21 +00003648 case tok::kw___attribute:
Reid Spencer5f016e22007-07-11 17:01:13 +00003649 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00003650
Francois Pichete3d49b42011-06-19 08:02:06 +00003651 // C++0x decltype.
David Blaikie42d6d0c2011-12-04 05:04:18 +00003652 case tok::annot_decltype:
Francois Pichete3d49b42011-06-19 08:02:06 +00003653 return true;
3654
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00003655 // C11 _Atomic()
Eli Friedmanb001de72011-10-06 23:00:33 +00003656 case tok::kw__Atomic:
3657 return true;
3658
Chris Lattnerf3948c42008-07-26 03:38:44 +00003659 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
3660 case tok::less:
David Blaikie4e4d0842012-03-11 07:00:24 +00003661 return getLangOpts().ObjC1;
Mike Stump1eb44332009-09-09 15:08:12 +00003662
Douglas Gregord9d75e52011-04-27 05:41:15 +00003663 // typedef-name
3664 case tok::annot_typename:
3665 return !DisambiguatingWithExpression ||
3666 !isStartOfObjCClassMessageMissingOpenBracket();
3667
Steve Naroff47f52092009-01-06 19:34:12 +00003668 case tok::kw___declspec:
Steve Naroff239f0732008-12-25 14:16:32 +00003669 case tok::kw___cdecl:
3670 case tok::kw___stdcall:
3671 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00003672 case tok::kw___thiscall:
Eli Friedman290eeb02009-06-08 23:27:34 +00003673 case tok::kw___w64:
3674 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00003675 case tok::kw___ptr32:
Eli Friedman290eeb02009-06-08 23:27:34 +00003676 case tok::kw___forceinline:
Dawn Perchik52fc3142010-09-03 01:29:35 +00003677 case tok::kw___pascal:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00003678 case tok::kw___unaligned:
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003679
3680 case tok::kw___private:
3681 case tok::kw___local:
3682 case tok::kw___global:
3683 case tok::kw___constant:
3684 case tok::kw___read_only:
3685 case tok::kw___read_write:
3686 case tok::kw___write_only:
3687
Eli Friedman290eeb02009-06-08 23:27:34 +00003688 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00003689 }
3690}
3691
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003692bool Parser::isConstructorDeclarator() {
3693 TentativeParsingAction TPA(*this);
3694
3695 // Parse the C++ scope specifier.
3696 CXXScopeSpec SS;
Douglas Gregorefaa93a2011-11-07 17:33:42 +00003697 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
3698 /*EnteringContext=*/true)) {
John McCall9ba61662010-02-26 08:45:28 +00003699 TPA.Revert();
3700 return false;
3701 }
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003702
3703 // Parse the constructor name.
3704 if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id)) {
3705 // We already know that we have a constructor name; just consume
3706 // the token.
3707 ConsumeToken();
3708 } else {
3709 TPA.Revert();
3710 return false;
3711 }
3712
Richard Smith22592862012-03-27 23:05:05 +00003713 // Current class name must be followed by a left parenthesis.
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003714 if (Tok.isNot(tok::l_paren)) {
3715 TPA.Revert();
3716 return false;
3717 }
3718 ConsumeParen();
3719
Richard Smith22592862012-03-27 23:05:05 +00003720 // A right parenthesis, or ellipsis followed by a right parenthesis signals
3721 // that we have a constructor.
3722 if (Tok.is(tok::r_paren) ||
3723 (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren))) {
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003724 TPA.Revert();
3725 return true;
3726 }
3727
3728 // If we need to, enter the specified scope.
3729 DeclaratorScopeObj DeclScopeObj(*this, SS);
Douglas Gregor23c94db2010-07-02 17:43:08 +00003730 if (SS.isSet() && Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003731 DeclScopeObj.EnterDeclaratorScope();
3732
Francois Pichetdfaa5fb2011-01-31 04:54:32 +00003733 // Optionally skip Microsoft attributes.
John McCall0b7e6782011-03-24 11:26:52 +00003734 ParsedAttributes Attrs(AttrFactory);
Francois Pichetdfaa5fb2011-01-31 04:54:32 +00003735 MaybeParseMicrosoftAttributes(Attrs);
3736
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003737 // Check whether the next token(s) are part of a declaration
3738 // specifier, in which case we have the start of a parameter and,
3739 // therefore, we know that this is a constructor.
Richard Smith412e0cc2012-03-27 00:56:56 +00003740 bool IsConstructor = false;
3741 if (isDeclarationSpecifier())
3742 IsConstructor = true;
3743 else if (Tok.is(tok::identifier) ||
3744 (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier))) {
3745 // We've seen "C ( X" or "C ( X::Y", but "X" / "X::Y" is not a type.
3746 // This might be a parenthesized member name, but is more likely to
3747 // be a constructor declaration with an invalid argument type. Keep
3748 // looking.
3749 if (Tok.is(tok::annot_cxxscope))
3750 ConsumeToken();
3751 ConsumeToken();
3752
3753 // If this is not a constructor, we must be parsing a declarator,
Richard Smith5d8388c2012-03-27 01:42:32 +00003754 // which must have one of the following syntactic forms (see the
3755 // grammar extract at the start of ParseDirectDeclarator):
Richard Smith412e0cc2012-03-27 00:56:56 +00003756 switch (Tok.getKind()) {
3757 case tok::l_paren:
3758 // C(X ( int));
3759 case tok::l_square:
3760 // C(X [ 5]);
3761 // C(X [ [attribute]]);
3762 case tok::coloncolon:
3763 // C(X :: Y);
3764 // C(X :: *p);
3765 case tok::r_paren:
3766 // C(X )
3767 // Assume this isn't a constructor, rather than assuming it's a
3768 // constructor with an unnamed parameter of an ill-formed type.
3769 break;
3770
3771 default:
3772 IsConstructor = true;
3773 break;
3774 }
3775 }
3776
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003777 TPA.Revert();
3778 return IsConstructor;
3779}
Reid Spencer5f016e22007-07-11 17:01:13 +00003780
3781/// ParseTypeQualifierListOpt
Dawn Perchik52fc3142010-09-03 01:29:35 +00003782/// type-qualifier-list: [C99 6.7.5]
3783/// type-qualifier
3784/// [vendor] attributes
3785/// [ only if VendorAttributesAllowed=true ]
3786/// type-qualifier-list type-qualifier
3787/// [vendor] type-qualifier-list attributes
3788/// [ only if VendorAttributesAllowed=true ]
3789/// [C++0x] attribute-specifier[opt] is allowed before cv-qualifier-seq
3790/// [ only if CXX0XAttributesAllowed=true ]
3791/// Note: vendor can be GNU, MS, etc.
Reid Spencer5f016e22007-07-11 17:01:13 +00003792///
Dawn Perchik52fc3142010-09-03 01:29:35 +00003793void Parser::ParseTypeQualifierListOpt(DeclSpec &DS,
3794 bool VendorAttributesAllowed,
Richard Smithc56298d2012-04-10 03:25:07 +00003795 bool CXX11AttributesAllowed) {
3796 if (getLangOpts().CPlusPlus0x && CXX11AttributesAllowed &&
Richard Smith6ee326a2012-04-10 01:32:12 +00003797 isCXX11AttributeSpecifier()) {
John McCall0b7e6782011-03-24 11:26:52 +00003798 ParsedAttributesWithRange attrs(AttrFactory);
Richard Smithc56298d2012-04-10 03:25:07 +00003799 ParseCXX11Attributes(attrs);
Richard Smith6ee326a2012-04-10 01:32:12 +00003800 DS.takeAttributesFrom(attrs);
Sean Huntbbd37c62009-11-21 08:43:09 +00003801 }
Abramo Bagnara796aa442011-03-12 11:17:06 +00003802
3803 SourceLocation EndLoc;
3804
Reid Spencer5f016e22007-07-11 17:01:13 +00003805 while (1) {
John McCallfec54012009-08-03 20:12:06 +00003806 bool isInvalid = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00003807 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00003808 unsigned DiagID = 0;
Reid Spencer5f016e22007-07-11 17:01:13 +00003809 SourceLocation Loc = Tok.getLocation();
3810
3811 switch (Tok.getKind()) {
Douglas Gregor1a480c42010-08-27 17:35:51 +00003812 case tok::code_completion:
3813 Actions.CodeCompleteTypeQualifiers(DS);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00003814 return cutOffParsing();
Douglas Gregor1a480c42010-08-27 17:35:51 +00003815
Reid Spencer5f016e22007-07-11 17:01:13 +00003816 case tok::kw_const:
John McCallfec54012009-08-03 20:12:06 +00003817 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, DiagID,
David Blaikie4e4d0842012-03-11 07:00:24 +00003818 getLangOpts());
Reid Spencer5f016e22007-07-11 17:01:13 +00003819 break;
3820 case tok::kw_volatile:
John McCallfec54012009-08-03 20:12:06 +00003821 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
David Blaikie4e4d0842012-03-11 07:00:24 +00003822 getLangOpts());
Reid Spencer5f016e22007-07-11 17:01:13 +00003823 break;
3824 case tok::kw_restrict:
John McCallfec54012009-08-03 20:12:06 +00003825 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
David Blaikie4e4d0842012-03-11 07:00:24 +00003826 getLangOpts());
Reid Spencer5f016e22007-07-11 17:01:13 +00003827 break;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003828
3829 // OpenCL qualifiers:
3830 case tok::kw_private:
David Blaikie4e4d0842012-03-11 07:00:24 +00003831 if (!getLangOpts().OpenCL)
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003832 goto DoneWithTypeQuals;
3833 case tok::kw___private:
3834 case tok::kw___global:
3835 case tok::kw___local:
3836 case tok::kw___constant:
3837 case tok::kw___read_only:
3838 case tok::kw___write_only:
3839 case tok::kw___read_write:
3840 ParseOpenCLQualifiers(DS);
3841 break;
3842
Eli Friedman290eeb02009-06-08 23:27:34 +00003843 case tok::kw___w64:
Steve Naroff86bc6cf2008-12-25 14:41:26 +00003844 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00003845 case tok::kw___ptr32:
Steve Naroff239f0732008-12-25 14:16:32 +00003846 case tok::kw___cdecl:
3847 case tok::kw___stdcall:
3848 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00003849 case tok::kw___thiscall:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00003850 case tok::kw___unaligned:
Dawn Perchik52fc3142010-09-03 01:29:35 +00003851 if (VendorAttributesAllowed) {
John McCall7f040a92010-12-24 02:08:15 +00003852 ParseMicrosoftTypeAttributes(DS.getAttributes());
Eli Friedman290eeb02009-06-08 23:27:34 +00003853 continue;
3854 }
3855 goto DoneWithTypeQuals;
Dawn Perchik52fc3142010-09-03 01:29:35 +00003856 case tok::kw___pascal:
3857 if (VendorAttributesAllowed) {
John McCall7f040a92010-12-24 02:08:15 +00003858 ParseBorlandTypeAttributes(DS.getAttributes());
Dawn Perchik52fc3142010-09-03 01:29:35 +00003859 continue;
3860 }
3861 goto DoneWithTypeQuals;
Reid Spencer5f016e22007-07-11 17:01:13 +00003862 case tok::kw___attribute:
Dawn Perchik52fc3142010-09-03 01:29:35 +00003863 if (VendorAttributesAllowed) {
John McCall7f040a92010-12-24 02:08:15 +00003864 ParseGNUAttributes(DS.getAttributes());
Chris Lattner5a69d1c2008-12-18 07:02:59 +00003865 continue; // do *not* consume the next token!
3866 }
3867 // otherwise, FALL THROUGH!
3868 default:
Steve Naroff239f0732008-12-25 14:16:32 +00003869 DoneWithTypeQuals:
Chris Lattner5a69d1c2008-12-18 07:02:59 +00003870 // If this is not a type-qualifier token, we're done reading type
3871 // qualifiers. First verify that DeclSpec's are consistent.
Douglas Gregor9b3064b2009-04-01 22:41:11 +00003872 DS.Finish(Diags, PP);
Abramo Bagnara796aa442011-03-12 11:17:06 +00003873 if (EndLoc.isValid())
3874 DS.SetRangeEnd(EndLoc);
Chris Lattner5a69d1c2008-12-18 07:02:59 +00003875 return;
Reid Spencer5f016e22007-07-11 17:01:13 +00003876 }
Chris Lattnera1fcbad2008-12-18 06:50:14 +00003877
Reid Spencer5f016e22007-07-11 17:01:13 +00003878 // If the specifier combination wasn't legal, issue a diagnostic.
3879 if (isInvalid) {
3880 assert(PrevSpec && "Method did not return previous specifier!");
Chris Lattner1ab3b962008-11-18 07:48:38 +00003881 Diag(Tok, DiagID) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00003882 }
Abramo Bagnara796aa442011-03-12 11:17:06 +00003883 EndLoc = ConsumeToken();
Reid Spencer5f016e22007-07-11 17:01:13 +00003884 }
3885}
3886
3887
3888/// ParseDeclarator - Parse and verify a newly-initialized declarator.
3889///
3890void Parser::ParseDeclarator(Declarator &D) {
3891 /// This implements the 'declarator' production in the C grammar, then checks
3892 /// for well-formedness and issues diagnostics.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003893 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
Reid Spencer5f016e22007-07-11 17:01:13 +00003894}
3895
Richard Smith9988f282012-03-29 01:16:42 +00003896static bool isPtrOperatorToken(tok::TokenKind Kind, const LangOptions &Lang) {
3897 if (Kind == tok::star || Kind == tok::caret)
3898 return true;
3899
3900 // We parse rvalue refs in C++03, because otherwise the errors are scary.
3901 if (!Lang.CPlusPlus)
3902 return false;
3903
3904 return Kind == tok::amp || Kind == tok::ampamp;
3905}
3906
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003907/// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator
3908/// is parsed by the function passed to it. Pass null, and the direct-declarator
3909/// isn't parsed at all, making this function effectively parse the C++
Douglas Gregor2f1bc522008-11-07 20:08:42 +00003910/// ptr-operator production.
3911///
Richard Smith0706df42011-10-19 21:33:05 +00003912/// If the grammar of this construct is extended, matching changes must also be
Richard Smith5d8388c2012-03-27 01:42:32 +00003913/// made to TryParseDeclarator and MightBeDeclarator, and possibly to
3914/// isConstructorDeclarator.
Richard Smith0706df42011-10-19 21:33:05 +00003915///
Sebastian Redlf30208a2009-01-24 21:16:55 +00003916/// declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
3917/// [C] pointer[opt] direct-declarator
3918/// [C++] direct-declarator
3919/// [C++] ptr-operator declarator
Reid Spencer5f016e22007-07-11 17:01:13 +00003920///
3921/// pointer: [C99 6.7.5]
3922/// '*' type-qualifier-list[opt]
3923/// '*' type-qualifier-list[opt] pointer
3924///
Douglas Gregor2f1bc522008-11-07 20:08:42 +00003925/// ptr-operator:
3926/// '*' cv-qualifier-seq[opt]
3927/// '&'
Sebastian Redl05532f22009-03-15 22:02:01 +00003928/// [C++0x] '&&'
Douglas Gregor2f1bc522008-11-07 20:08:42 +00003929/// [GNU] '&' restrict[opt] attributes[opt]
Sebastian Redl05532f22009-03-15 22:02:01 +00003930/// [GNU?] '&&' restrict[opt] attributes[opt]
Sebastian Redlf30208a2009-01-24 21:16:55 +00003931/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003932void Parser::ParseDeclaratorInternal(Declarator &D,
3933 DirectDeclParseFunction DirectDeclParser) {
Douglas Gregor91a28862009-08-26 14:27:30 +00003934 if (Diags.hasAllExtensionsSilenced())
3935 D.setExtension();
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003936
Sebastian Redlf30208a2009-01-24 21:16:55 +00003937 // C++ member pointers start with a '::' or a nested-name.
3938 // Member pointers get special handling, since there's no place for the
3939 // scope spec in the generic path below.
David Blaikie4e4d0842012-03-11 07:00:24 +00003940 if (getLangOpts().CPlusPlus &&
Chris Lattnerf919bfe2009-03-24 17:04:48 +00003941 (Tok.is(tok::coloncolon) || Tok.is(tok::identifier) ||
3942 Tok.is(tok::annot_cxxscope))) {
Douglas Gregorefaa93a2011-11-07 17:33:42 +00003943 bool EnteringContext = D.getContext() == Declarator::FileContext ||
3944 D.getContext() == Declarator::MemberContext;
Sebastian Redlf30208a2009-01-24 21:16:55 +00003945 CXXScopeSpec SS;
Douglas Gregorefaa93a2011-11-07 17:33:42 +00003946 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext);
John McCall9ba61662010-02-26 08:45:28 +00003947
Jeffrey Yasskinedc28772010-04-07 23:29:58 +00003948 if (SS.isNotEmpty()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003949 if (Tok.isNot(tok::star)) {
Sebastian Redlf30208a2009-01-24 21:16:55 +00003950 // The scope spec really belongs to the direct-declarator.
3951 D.getCXXScopeSpec() = SS;
3952 if (DirectDeclParser)
3953 (this->*DirectDeclParser)(D);
3954 return;
3955 }
3956
3957 SourceLocation Loc = ConsumeToken();
Sebastian Redlab197ba2009-02-09 18:23:29 +00003958 D.SetRangeEnd(Loc);
John McCall0b7e6782011-03-24 11:26:52 +00003959 DeclSpec DS(AttrFactory);
Sebastian Redlf30208a2009-01-24 21:16:55 +00003960 ParseTypeQualifierListOpt(DS);
Sebastian Redlab197ba2009-02-09 18:23:29 +00003961 D.ExtendWithDeclSpec(DS);
Sebastian Redlf30208a2009-01-24 21:16:55 +00003962
3963 // Recurse to parse whatever is left.
3964 ParseDeclaratorInternal(D, DirectDeclParser);
3965
3966 // Sema will have to catch (syntactically invalid) pointers into global
3967 // scope. It has to catch pointers into namespace scope anyway.
3968 D.AddTypeInfo(DeclaratorChunk::getMemberPointer(SS,DS.getTypeQualifiers(),
John McCall0b7e6782011-03-24 11:26:52 +00003969 Loc),
3970 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00003971 /* Don't replace range end. */SourceLocation());
Sebastian Redlf30208a2009-01-24 21:16:55 +00003972 return;
3973 }
3974 }
3975
3976 tok::TokenKind Kind = Tok.getKind();
Steve Naroff5618bd42008-08-27 16:04:49 +00003977 // Not a pointer, C++ reference, or block.
Richard Smith9988f282012-03-29 01:16:42 +00003978 if (!isPtrOperatorToken(Kind, getLangOpts())) {
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003979 if (DirectDeclParser)
3980 (this->*DirectDeclParser)(D);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00003981 return;
3982 }
Sebastian Redlf30208a2009-01-24 21:16:55 +00003983
Sebastian Redl05532f22009-03-15 22:02:01 +00003984 // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference,
3985 // '&&' -> rvalue reference
Sebastian Redl743de1f2009-03-23 00:00:23 +00003986 SourceLocation Loc = ConsumeToken(); // Eat the *, ^, & or &&.
Sebastian Redlab197ba2009-02-09 18:23:29 +00003987 D.SetRangeEnd(Loc);
Reid Spencer5f016e22007-07-11 17:01:13 +00003988
Chris Lattner9af55002009-03-27 04:18:06 +00003989 if (Kind == tok::star || Kind == tok::caret) {
Chris Lattner76549142008-02-21 01:32:26 +00003990 // Is a pointer.
John McCall0b7e6782011-03-24 11:26:52 +00003991 DeclSpec DS(AttrFactory);
Sebastian Redlf30208a2009-01-24 21:16:55 +00003992
Richard Smith6ee326a2012-04-10 01:32:12 +00003993 // FIXME: GNU attributes are not allowed here in a new-type-id.
Reid Spencer5f016e22007-07-11 17:01:13 +00003994 ParseTypeQualifierListOpt(DS);
Sebastian Redlab197ba2009-02-09 18:23:29 +00003995 D.ExtendWithDeclSpec(DS);
Sebastian Redlf30208a2009-01-24 21:16:55 +00003996
Reid Spencer5f016e22007-07-11 17:01:13 +00003997 // Recursively parse the declarator.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00003998 ParseDeclaratorInternal(D, DirectDeclParser);
Steve Naroff5618bd42008-08-27 16:04:49 +00003999 if (Kind == tok::star)
4000 // Remember that we parsed a pointer type, and remember the type-quals.
4001 D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc,
Chandler Carruthd067c072011-02-23 18:51:59 +00004002 DS.getConstSpecLoc(),
4003 DS.getVolatileSpecLoc(),
John McCall0b7e6782011-03-24 11:26:52 +00004004 DS.getRestrictSpecLoc()),
4005 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00004006 SourceLocation());
Steve Naroff5618bd42008-08-27 16:04:49 +00004007 else
4008 // Remember that we parsed a Block type, and remember the type-quals.
Mike Stump1eb44332009-09-09 15:08:12 +00004009 D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(),
John McCall0b7e6782011-03-24 11:26:52 +00004010 Loc),
4011 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00004012 SourceLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00004013 } else {
4014 // Is a reference
John McCall0b7e6782011-03-24 11:26:52 +00004015 DeclSpec DS(AttrFactory);
Reid Spencer5f016e22007-07-11 17:01:13 +00004016
Sebastian Redl743de1f2009-03-23 00:00:23 +00004017 // Complain about rvalue references in C++03, but then go on and build
4018 // the declarator.
Richard Smith7fe62082011-10-15 05:09:34 +00004019 if (Kind == tok::ampamp)
David Blaikie4e4d0842012-03-11 07:00:24 +00004020 Diag(Loc, getLangOpts().CPlusPlus0x ?
Richard Smith7fe62082011-10-15 05:09:34 +00004021 diag::warn_cxx98_compat_rvalue_reference :
4022 diag::ext_rvalue_reference);
Sebastian Redl743de1f2009-03-23 00:00:23 +00004023
Richard Smith6ee326a2012-04-10 01:32:12 +00004024 // GNU-style and C++11 attributes are allowed here, as is restrict.
4025 ParseTypeQualifierListOpt(DS);
4026 D.ExtendWithDeclSpec(DS);
4027
Reid Spencer5f016e22007-07-11 17:01:13 +00004028 // C++ 8.3.2p1: cv-qualified references are ill-formed except when the
4029 // cv-qualifiers are introduced through the use of a typedef or of a
4030 // template type argument, in which case the cv-qualifiers are ignored.
Reid Spencer5f016e22007-07-11 17:01:13 +00004031 if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
4032 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
4033 Diag(DS.getConstSpecLoc(),
Chris Lattner1ab3b962008-11-18 07:48:38 +00004034 diag::err_invalid_reference_qualifier_application) << "const";
Reid Spencer5f016e22007-07-11 17:01:13 +00004035 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
4036 Diag(DS.getVolatileSpecLoc(),
Chris Lattner1ab3b962008-11-18 07:48:38 +00004037 diag::err_invalid_reference_qualifier_application) << "volatile";
Reid Spencer5f016e22007-07-11 17:01:13 +00004038 }
4039
4040 // Recursively parse the declarator.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004041 ParseDeclaratorInternal(D, DirectDeclParser);
Reid Spencer5f016e22007-07-11 17:01:13 +00004042
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00004043 if (D.getNumTypeObjects() > 0) {
4044 // C++ [dcl.ref]p4: There shall be no references to references.
4045 DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1);
4046 if (InnerChunk.Kind == DeclaratorChunk::Reference) {
Chris Lattnerda83bac2008-11-19 07:37:42 +00004047 if (const IdentifierInfo *II = D.getIdentifier())
4048 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
4049 << II;
4050 else
4051 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
4052 << "type name";
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00004053
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004054 // Once we've complained about the reference-to-reference, we
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00004055 // can go ahead and build the (technically ill-formed)
4056 // declarator: reference collapsing will take care of it.
4057 }
4058 }
4059
Reid Spencer5f016e22007-07-11 17:01:13 +00004060 // Remember that we parsed a reference type. It doesn't have type-quals.
Chris Lattner76549142008-02-21 01:32:26 +00004061 D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc,
Sebastian Redl05532f22009-03-15 22:02:01 +00004062 Kind == tok::amp),
John McCall0b7e6782011-03-24 11:26:52 +00004063 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00004064 SourceLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00004065 }
4066}
4067
Richard Smith9988f282012-03-29 01:16:42 +00004068static void diagnoseMisplacedEllipsis(Parser &P, Declarator &D,
4069 SourceLocation EllipsisLoc) {
4070 if (EllipsisLoc.isValid()) {
4071 FixItHint Insertion;
4072 if (!D.getEllipsisLoc().isValid()) {
4073 Insertion = FixItHint::CreateInsertion(D.getIdentifierLoc(), "...");
4074 D.setEllipsisLoc(EllipsisLoc);
4075 }
4076 P.Diag(EllipsisLoc, diag::err_misplaced_ellipsis_in_declaration)
4077 << FixItHint::CreateRemoval(EllipsisLoc) << Insertion << !D.hasName();
4078 }
4079}
4080
Reid Spencer5f016e22007-07-11 17:01:13 +00004081/// ParseDirectDeclarator
4082/// direct-declarator: [C99 6.7.5]
Douglas Gregor42a552f2008-11-05 20:51:48 +00004083/// [C99] identifier
Reid Spencer5f016e22007-07-11 17:01:13 +00004084/// '(' declarator ')'
4085/// [GNU] '(' attributes declarator ')'
4086/// [C90] direct-declarator '[' constant-expression[opt] ']'
4087/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
4088/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
4089/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
4090/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
Richard Smith6ee326a2012-04-10 01:32:12 +00004091/// [C++11] direct-declarator '[' constant-expression[opt] ']'
4092/// attribute-specifier-seq[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00004093/// direct-declarator '(' parameter-type-list ')'
4094/// direct-declarator '(' identifier-list[opt] ')'
4095/// [GNU] direct-declarator '(' parameter-forward-declarations
4096/// parameter-type-list[opt] ')'
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00004097/// [C++] direct-declarator '(' parameter-declaration-clause ')'
4098/// cv-qualifier-seq[opt] exception-specification[opt]
Richard Smith6ee326a2012-04-10 01:32:12 +00004099/// [C++11] direct-declarator '(' parameter-declaration-clause ')'
4100/// attribute-specifier-seq[opt] cv-qualifier-seq[opt]
4101/// ref-qualifier[opt] exception-specification[opt]
Douglas Gregorb48fe382008-10-31 09:07:45 +00004102/// [C++] declarator-id
Richard Smith6ee326a2012-04-10 01:32:12 +00004103/// [C++11] declarator-id attribute-specifier-seq[opt]
Douglas Gregor42a552f2008-11-05 20:51:48 +00004104///
4105/// declarator-id: [C++ 8]
Douglas Gregora8bc8c92010-12-23 22:44:42 +00004106/// '...'[opt] id-expression
Douglas Gregor42a552f2008-11-05 20:51:48 +00004107/// '::'[opt] nested-name-specifier[opt] type-name
4108///
4109/// id-expression: [C++ 5.1]
4110/// unqualified-id
Douglas Gregordb422df2009-09-25 21:45:23 +00004111/// qualified-id
Douglas Gregor42a552f2008-11-05 20:51:48 +00004112///
4113/// unqualified-id: [C++ 5.1]
Mike Stump1eb44332009-09-09 15:08:12 +00004114/// identifier
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00004115/// operator-function-id
Douglas Gregordb422df2009-09-25 21:45:23 +00004116/// conversion-function-id
Mike Stump1eb44332009-09-09 15:08:12 +00004117/// '~' class-name
Douglas Gregor39a8de12009-02-25 19:37:18 +00004118/// template-id
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +00004119///
Richard Smith5d8388c2012-03-27 01:42:32 +00004120/// Note, any additional constructs added here may need corresponding changes
4121/// in isConstructorDeclarator.
Reid Spencer5f016e22007-07-11 17:01:13 +00004122void Parser::ParseDirectDeclarator(Declarator &D) {
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00004123 DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec());
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00004124
David Blaikie4e4d0842012-03-11 07:00:24 +00004125 if (getLangOpts().CPlusPlus && D.mayHaveIdentifier()) {
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004126 // ParseDeclaratorInternal might already have parsed the scope.
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00004127 if (D.getCXXScopeSpec().isEmpty()) {
Douglas Gregorefaa93a2011-11-07 17:33:42 +00004128 bool EnteringContext = D.getContext() == Declarator::FileContext ||
4129 D.getContext() == Declarator::MemberContext;
4130 ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec(), ParsedType(),
4131 EnteringContext);
John McCall9ba61662010-02-26 08:45:28 +00004132 }
4133
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00004134 if (D.getCXXScopeSpec().isValid()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00004135 if (Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec()))
John McCalle7e278b2009-12-11 20:04:54 +00004136 // Change the declaration context for name lookup, until this function
4137 // is exited (and the declarator has been parsed).
4138 DeclScopeObj.EnterDeclaratorScope();
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00004139 }
4140
Douglas Gregora8bc8c92010-12-23 22:44:42 +00004141 // C++0x [dcl.fct]p14:
4142 // There is a syntactic ambiguity when an ellipsis occurs at the end
4143 // of a parameter-declaration-clause without a preceding comma. In
4144 // this case, the ellipsis is parsed as part of the
4145 // abstract-declarator if the type of the parameter names a template
4146 // parameter pack that has not been expanded; otherwise, it is parsed
4147 // as part of the parameter-declaration-clause.
Richard Smith9988f282012-03-29 01:16:42 +00004148 if (Tok.is(tok::ellipsis) && D.getCXXScopeSpec().isEmpty() &&
Douglas Gregora8bc8c92010-12-23 22:44:42 +00004149 !((D.getContext() == Declarator::PrototypeContext ||
4150 D.getContext() == Declarator::BlockLiteralContext) &&
Douglas Gregora8bc8c92010-12-23 22:44:42 +00004151 NextToken().is(tok::r_paren) &&
Richard Smith9988f282012-03-29 01:16:42 +00004152 !Actions.containsUnexpandedParameterPacks(D))) {
4153 SourceLocation EllipsisLoc = ConsumeToken();
4154 if (isPtrOperatorToken(Tok.getKind(), getLangOpts())) {
4155 // The ellipsis was put in the wrong place. Recover, and explain to
4156 // the user what they should have done.
4157 ParseDeclarator(D);
4158 diagnoseMisplacedEllipsis(*this, D, EllipsisLoc);
4159 return;
4160 } else
4161 D.setEllipsisLoc(EllipsisLoc);
4162
4163 // The ellipsis can't be followed by a parenthesized declarator. We
4164 // check for that in ParseParenDeclarator, after we have disambiguated
4165 // the l_paren token.
4166 }
4167
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004168 if (Tok.is(tok::identifier) || Tok.is(tok::kw_operator) ||
4169 Tok.is(tok::annot_template_id) || Tok.is(tok::tilde)) {
4170 // We found something that indicates the start of an unqualified-id.
4171 // Parse that unqualified-id.
John McCallba9d8532010-04-13 06:39:49 +00004172 bool AllowConstructorName;
4173 if (D.getDeclSpec().hasTypeSpecifier())
4174 AllowConstructorName = false;
4175 else if (D.getCXXScopeSpec().isSet())
4176 AllowConstructorName =
4177 (D.getContext() == Declarator::FileContext ||
4178 (D.getContext() == Declarator::MemberContext &&
4179 D.getDeclSpec().isFriendSpecified()));
4180 else
4181 AllowConstructorName = (D.getContext() == Declarator::MemberContext);
4182
Abramo Bagnarae4b92762012-01-27 09:46:47 +00004183 SourceLocation TemplateKWLoc;
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004184 if (ParseUnqualifiedId(D.getCXXScopeSpec(),
4185 /*EnteringContext=*/true,
4186 /*AllowDestructorName=*/true,
Douglas Gregor0efc2c12010-01-13 17:31:36 +00004187 AllowConstructorName,
John McCallb3d87482010-08-24 05:47:05 +00004188 ParsedType(),
Abramo Bagnarae4b92762012-01-27 09:46:47 +00004189 TemplateKWLoc,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00004190 D.getName()) ||
4191 // Once we're past the identifier, if the scope was bad, mark the
4192 // whole declarator bad.
4193 D.getCXXScopeSpec().isInvalid()) {
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00004194 D.SetIdentifier(0, Tok.getLocation());
4195 D.setInvalidType(true);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004196 } else {
4197 // Parsed the unqualified-id; update range information and move along.
4198 if (D.getSourceRange().getBegin().isInvalid())
4199 D.SetRangeBegin(D.getName().getSourceRange().getBegin());
4200 D.SetRangeEnd(D.getName().getSourceRange().getEnd());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00004201 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004202 goto PastIdentifier;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004203 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004204 } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
David Blaikie4e4d0842012-03-11 07:00:24 +00004205 assert(!getLangOpts().CPlusPlus &&
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00004206 "There's a C++-specific check for tok::identifier above");
4207 assert(Tok.getIdentifierInfo() && "Not an identifier?");
4208 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
4209 ConsumeToken();
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004210 goto PastIdentifier;
4211 }
Richard Smith9988f282012-03-29 01:16:42 +00004212
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004213 if (Tok.is(tok::l_paren)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00004214 // direct-declarator: '(' declarator ')'
4215 // direct-declarator: '(' attributes declarator ')'
4216 // Example: 'char (*X)' or 'int (*XX)(void)'
4217 ParseParenDeclarator(D);
Douglas Gregor0efc2c12010-01-13 17:31:36 +00004218
4219 // If the declarator was parenthesized, we entered the declarator
4220 // scope when parsing the parenthesized declarator, then exited
4221 // the scope already. Re-enter the scope, if we need to.
4222 if (D.getCXXScopeSpec().isSet()) {
Fariborz Jahanian46877cd2010-08-17 23:50:37 +00004223 // If there was an error parsing parenthesized declarator, declarator
Richard Smith9988f282012-03-29 01:16:42 +00004224 // scope may have been entered before. Don't do it again.
Fariborz Jahanian46877cd2010-08-17 23:50:37 +00004225 if (!D.isInvalidType() &&
4226 Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec()))
Douglas Gregor0efc2c12010-01-13 17:31:36 +00004227 // Change the declaration context for name lookup, until this function
4228 // is exited (and the declarator has been parsed).
Fariborz Jahanian46877cd2010-08-17 23:50:37 +00004229 DeclScopeObj.EnterDeclaratorScope();
Douglas Gregor0efc2c12010-01-13 17:31:36 +00004230 }
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00004231 } else if (D.mayOmitIdentifier()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00004232 // This could be something simple like "int" (in which case the declarator
4233 // portion is empty), if an abstract-declarator is allowed.
4234 D.SetIdentifier(0, Tok.getLocation());
4235 } else {
Douglas Gregore950d4b2009-03-06 23:28:18 +00004236 if (D.getContext() == Declarator::MemberContext)
4237 Diag(Tok, diag::err_expected_member_name_or_semi)
4238 << D.getDeclSpec().getSourceRange();
David Blaikie4e4d0842012-03-11 07:00:24 +00004239 else if (getLangOpts().CPlusPlus)
4240 Diag(Tok, diag::err_expected_unqualified_id) << getLangOpts().CPlusPlus;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00004241 else
Chris Lattner1ab3b962008-11-18 07:48:38 +00004242 Diag(Tok, diag::err_expected_ident_lparen);
Reid Spencer5f016e22007-07-11 17:01:13 +00004243 D.SetIdentifier(0, Tok.getLocation());
Chris Lattner1f6f54b2008-11-11 06:13:16 +00004244 D.setInvalidType(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00004245 }
Mike Stump1eb44332009-09-09 15:08:12 +00004246
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00004247 PastIdentifier:
Reid Spencer5f016e22007-07-11 17:01:13 +00004248 assert(D.isPastIdentifier() &&
4249 "Haven't past the location of the identifier yet?");
Mike Stump1eb44332009-09-09 15:08:12 +00004250
Richard Smith6ee326a2012-04-10 01:32:12 +00004251 // Don't parse attributes unless we have parsed an unparenthesized name.
4252 if (D.hasName() && !D.getNumTypeObjects())
John McCall7f040a92010-12-24 02:08:15 +00004253 MaybeParseCXX0XAttributes(D);
Sean Huntbbd37c62009-11-21 08:43:09 +00004254
Reid Spencer5f016e22007-07-11 17:01:13 +00004255 while (1) {
Chris Lattner04d66662007-10-09 17:33:22 +00004256 if (Tok.is(tok::l_paren)) {
David Blaikie42d6d0c2011-12-04 05:04:18 +00004257 // Enter function-declaration scope, limiting any declarators to the
4258 // function prototype scope, including parameter declarators.
4259 ParseScope PrototypeScope(this,
4260 Scope::FunctionPrototypeScope|Scope::DeclScope);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004261 // The paren may be part of a C++ direct initializer, eg. "int x(1);".
4262 // In such a case, check if we actually have a function declarator; if it
4263 // is not, the declarator has been fully parsed.
David Blaikie4e4d0842012-03-11 07:00:24 +00004264 if (getLangOpts().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) {
Chris Lattner7399ee02008-10-20 02:05:46 +00004265 // When not in file scope, warn for ambiguous function declarators, just
4266 // in case the author intended it as a variable definition.
4267 bool warnIfAmbiguous = D.getContext() != Declarator::FileContext;
4268 if (!isCXXFunctionDeclarator(warnIfAmbiguous))
4269 break;
4270 }
John McCall0b7e6782011-03-24 11:26:52 +00004271 ParsedAttributes attrs(AttrFactory);
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004272 BalancedDelimiterTracker T(*this, tok::l_paren);
4273 T.consumeOpen();
4274 ParseFunctionDeclarator(D, attrs, T);
David Blaikie42d6d0c2011-12-04 05:04:18 +00004275 PrototypeScope.Exit();
Chris Lattner04d66662007-10-09 17:33:22 +00004276 } else if (Tok.is(tok::l_square)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00004277 ParseBracketDeclarator(D);
4278 } else {
4279 break;
4280 }
4281 }
David Blaikie42d6d0c2011-12-04 05:04:18 +00004282}
Reid Spencer5f016e22007-07-11 17:01:13 +00004283
Chris Lattneref4715c2008-04-06 05:45:57 +00004284/// ParseParenDeclarator - We parsed the declarator D up to a paren. This is
4285/// only called before the identifier, so these are most likely just grouping
Mike Stump1eb44332009-09-09 15:08:12 +00004286/// parens for precedence. If we find that these are actually function
Chris Lattneref4715c2008-04-06 05:45:57 +00004287/// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator.
4288///
4289/// direct-declarator:
4290/// '(' declarator ')'
4291/// [GNU] '(' attributes declarator ')'
Chris Lattner7399ee02008-10-20 02:05:46 +00004292/// direct-declarator '(' parameter-type-list ')'
4293/// direct-declarator '(' identifier-list[opt] ')'
4294/// [GNU] direct-declarator '(' parameter-forward-declarations
4295/// parameter-type-list[opt] ')'
Chris Lattneref4715c2008-04-06 05:45:57 +00004296///
4297void Parser::ParseParenDeclarator(Declarator &D) {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004298 BalancedDelimiterTracker T(*this, tok::l_paren);
4299 T.consumeOpen();
4300
Chris Lattneref4715c2008-04-06 05:45:57 +00004301 assert(!D.isPastIdentifier() && "Should be called before passing identifier");
Mike Stump1eb44332009-09-09 15:08:12 +00004302
Chris Lattner7399ee02008-10-20 02:05:46 +00004303 // Eat any attributes before we look at whether this is a grouping or function
4304 // declarator paren. If this is a grouping paren, the attribute applies to
4305 // the type being built up, for example:
4306 // int (__attribute__(()) *x)(long y)
4307 // If this ends up not being a grouping paren, the attribute applies to the
4308 // first argument, for example:
4309 // int (__attribute__(()) int x)
4310 // In either case, we need to eat any attributes to be able to determine what
4311 // sort of paren this is.
4312 //
John McCall0b7e6782011-03-24 11:26:52 +00004313 ParsedAttributes attrs(AttrFactory);
Chris Lattner7399ee02008-10-20 02:05:46 +00004314 bool RequiresArg = false;
4315 if (Tok.is(tok::kw___attribute)) {
John McCall7f040a92010-12-24 02:08:15 +00004316 ParseGNUAttributes(attrs);
Mike Stump1eb44332009-09-09 15:08:12 +00004317
Chris Lattner7399ee02008-10-20 02:05:46 +00004318 // We require that the argument list (if this is a non-grouping paren) be
4319 // present even if the attribute list was empty.
4320 RequiresArg = true;
4321 }
Steve Naroff239f0732008-12-25 14:16:32 +00004322 // Eat any Microsoft extensions.
Eli Friedman290eeb02009-06-08 23:27:34 +00004323 if (Tok.is(tok::kw___cdecl) || Tok.is(tok::kw___stdcall) ||
Douglas Gregorf813a2c2010-05-18 16:57:00 +00004324 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___fastcall) ||
Francois Pichet3bd9aa42011-08-18 09:59:55 +00004325 Tok.is(tok::kw___w64) || Tok.is(tok::kw___ptr64) ||
Francois Pichet58fd97a2011-08-25 00:36:46 +00004326 Tok.is(tok::kw___ptr32) || Tok.is(tok::kw___unaligned)) {
John McCall7f040a92010-12-24 02:08:15 +00004327 ParseMicrosoftTypeAttributes(attrs);
Eli Friedman290eeb02009-06-08 23:27:34 +00004328 }
Dawn Perchik52fc3142010-09-03 01:29:35 +00004329 // Eat any Borland extensions.
Ted Kremenek8113ecf2010-11-10 05:59:39 +00004330 if (Tok.is(tok::kw___pascal))
John McCall7f040a92010-12-24 02:08:15 +00004331 ParseBorlandTypeAttributes(attrs);
Mike Stump1eb44332009-09-09 15:08:12 +00004332
Chris Lattneref4715c2008-04-06 05:45:57 +00004333 // If we haven't past the identifier yet (or where the identifier would be
4334 // stored, if this is an abstract declarator), then this is probably just
4335 // grouping parens. However, if this could be an abstract-declarator, then
4336 // this could also be the start of function arguments (consider 'void()').
4337 bool isGrouping;
Mike Stump1eb44332009-09-09 15:08:12 +00004338
Chris Lattneref4715c2008-04-06 05:45:57 +00004339 if (!D.mayOmitIdentifier()) {
4340 // If this can't be an abstract-declarator, this *must* be a grouping
4341 // paren, because we haven't seen the identifier yet.
4342 isGrouping = true;
4343 } else if (Tok.is(tok::r_paren) || // 'int()' is a function.
Richard Smith22592862012-03-27 23:05:05 +00004344 (getLangOpts().CPlusPlus && Tok.is(tok::ellipsis) &&
4345 NextToken().is(tok::r_paren)) || // C++ int(...)
Richard Smith6ce48a72012-04-11 04:01:28 +00004346 isDeclarationSpecifier() || // 'int(int)' is a function.
4347 isCXX11AttributeSpecifier()) { // 'int([[]]int)' is a function.
Chris Lattneref4715c2008-04-06 05:45:57 +00004348 // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is
4349 // considered to be a type, not a K&R identifier-list.
4350 isGrouping = false;
4351 } else {
4352 // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'.
4353 isGrouping = true;
4354 }
Mike Stump1eb44332009-09-09 15:08:12 +00004355
Chris Lattneref4715c2008-04-06 05:45:57 +00004356 // If this is a grouping paren, handle:
4357 // direct-declarator: '(' declarator ')'
4358 // direct-declarator: '(' attributes declarator ')'
4359 if (isGrouping) {
Richard Smith9988f282012-03-29 01:16:42 +00004360 SourceLocation EllipsisLoc = D.getEllipsisLoc();
4361 D.setEllipsisLoc(SourceLocation());
4362
Argyrios Kyrtzidis3f2a8a02008-10-07 10:21:57 +00004363 bool hadGroupingParens = D.hasGroupingParens();
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004364 D.setGroupingParens(true);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004365 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
Chris Lattneref4715c2008-04-06 05:45:57 +00004366 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004367 T.consumeClose();
4368 D.AddTypeInfo(DeclaratorChunk::getParen(T.getOpenLocation(),
4369 T.getCloseLocation()),
4370 attrs, T.getCloseLocation());
Argyrios Kyrtzidis3f2a8a02008-10-07 10:21:57 +00004371
4372 D.setGroupingParens(hadGroupingParens);
Richard Smith9988f282012-03-29 01:16:42 +00004373
4374 // An ellipsis cannot be placed outside parentheses.
4375 if (EllipsisLoc.isValid())
4376 diagnoseMisplacedEllipsis(*this, D, EllipsisLoc);
4377
Chris Lattneref4715c2008-04-06 05:45:57 +00004378 return;
4379 }
Mike Stump1eb44332009-09-09 15:08:12 +00004380
Chris Lattneref4715c2008-04-06 05:45:57 +00004381 // Okay, if this wasn't a grouping paren, it must be the start of a function
4382 // argument list. Recognize that this declarator will never have an
Chris Lattner7399ee02008-10-20 02:05:46 +00004383 // identifier (and remember where it would have been), then call into
4384 // ParseFunctionDeclarator to handle of argument list.
Chris Lattneref4715c2008-04-06 05:45:57 +00004385 D.SetIdentifier(0, Tok.getLocation());
4386
David Blaikie42d6d0c2011-12-04 05:04:18 +00004387 // Enter function-declaration scope, limiting any declarators to the
4388 // function prototype scope, including parameter declarators.
4389 ParseScope PrototypeScope(this,
4390 Scope::FunctionPrototypeScope|Scope::DeclScope);
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004391 ParseFunctionDeclarator(D, attrs, T, RequiresArg);
David Blaikie42d6d0c2011-12-04 05:04:18 +00004392 PrototypeScope.Exit();
Chris Lattneref4715c2008-04-06 05:45:57 +00004393}
4394
4395/// ParseFunctionDeclarator - We are after the identifier and have parsed the
4396/// declarator D up to a paren, which indicates that we are parsing function
4397/// arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00004398///
Richard Smith6ee326a2012-04-10 01:32:12 +00004399/// If FirstArgAttrs is non-null, then the caller parsed those arguments
4400/// immediately after the open paren - they should be considered to be the
4401/// first argument of a parameter.
Chris Lattner7399ee02008-10-20 02:05:46 +00004402///
Richard Smith6ee326a2012-04-10 01:32:12 +00004403/// If RequiresArg is true, then the first argument of the function is required
4404/// to be present and required to not be an identifier list.
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004405///
Richard Smith6ee326a2012-04-10 01:32:12 +00004406/// For C++, after the parameter-list, it also parses the cv-qualifier-seq[opt],
4407/// (C++11) ref-qualifier[opt], exception-specification[opt],
4408/// (C++11) attribute-specifier-seq[opt], and (C++11) trailing-return-type[opt].
4409///
4410/// [C++11] exception-specification:
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004411/// dynamic-exception-specification
4412/// noexcept-specification
4413///
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004414void Parser::ParseFunctionDeclarator(Declarator &D,
Richard Smith6ee326a2012-04-10 01:32:12 +00004415 ParsedAttributes &FirstArgAttrs,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004416 BalancedDelimiterTracker &Tracker,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004417 bool RequiresArg) {
David Blaikie42d6d0c2011-12-04 05:04:18 +00004418 assert(getCurScope()->isFunctionPrototypeScope() &&
4419 "Should call from a Function scope");
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004420 // lparen is already consumed!
4421 assert(D.isPastIdentifier() && "Should not call before identifier!");
4422
4423 // This should be true when the function has typed arguments.
4424 // Otherwise, it is treated as a K&R-style function.
4425 bool HasProto = false;
4426 // Build up an array of information about the parsed arguments.
Chris Lattner5f9e2722011-07-23 10:55:15 +00004427 SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004428 // Remember where we see an ellipsis, if any.
4429 SourceLocation EllipsisLoc;
4430
4431 DeclSpec DS(AttrFactory);
4432 bool RefQualifierIsLValueRef = true;
4433 SourceLocation RefQualifierLoc;
Douglas Gregor43f51032011-10-19 06:04:55 +00004434 SourceLocation ConstQualifierLoc;
4435 SourceLocation VolatileQualifierLoc;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004436 ExceptionSpecificationType ESpecType = EST_None;
4437 SourceRange ESpecRange;
Chris Lattner5f9e2722011-07-23 10:55:15 +00004438 SmallVector<ParsedType, 2> DynamicExceptions;
4439 SmallVector<SourceRange, 2> DynamicExceptionRanges;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004440 ExprResult NoexceptExpr;
Richard Smith6ee326a2012-04-10 01:32:12 +00004441 ParsedAttributes FnAttrs(AttrFactory);
Richard Smith54655be2012-06-12 01:51:59 +00004442 TypeResult TrailingReturnType;
Richard Smith6ee326a2012-04-10 01:32:12 +00004443
James Molloy16f1f712012-02-29 10:24:19 +00004444 Actions.ActOnStartFunctionDeclarator();
4445
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004446 SourceLocation EndLoc;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004447 if (isFunctionDeclaratorIdentifierList()) {
4448 if (RequiresArg)
4449 Diag(Tok, diag::err_argument_required_after_attribute);
4450
4451 ParseFunctionDeclaratorIdentifierList(D, ParamInfo);
4452
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004453 Tracker.consumeClose();
4454 EndLoc = Tracker.getCloseLocation();
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004455 } else {
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004456 if (Tok.isNot(tok::r_paren))
Richard Smith6ee326a2012-04-10 01:32:12 +00004457 ParseParameterDeclarationClause(D, FirstArgAttrs, ParamInfo, EllipsisLoc);
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004458 else if (RequiresArg)
4459 Diag(Tok, diag::err_argument_required_after_attribute);
4460
David Blaikie4e4d0842012-03-11 07:00:24 +00004461 HasProto = ParamInfo.size() || getLangOpts().CPlusPlus;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004462
4463 // If we have the closing ')', eat it.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004464 Tracker.consumeClose();
4465 EndLoc = Tracker.getCloseLocation();
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004466
David Blaikie4e4d0842012-03-11 07:00:24 +00004467 if (getLangOpts().CPlusPlus) {
Richard Smith6ee326a2012-04-10 01:32:12 +00004468 // FIXME: Accept these components in any order, and produce fixits to
4469 // correct the order if the user gets it wrong. Ideally we should deal
4470 // with the virt-specifier-seq and pure-specifier in the same way.
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004471
4472 // Parse cv-qualifier-seq[opt].
Richard Smith6ee326a2012-04-10 01:32:12 +00004473 ParseTypeQualifierListOpt(DS, false /*no attributes*/, false);
4474 if (!DS.getSourceRange().getEnd().isInvalid()) {
4475 EndLoc = DS.getSourceRange().getEnd();
4476 ConstQualifierLoc = DS.getConstSpecLoc();
4477 VolatileQualifierLoc = DS.getVolatileSpecLoc();
4478 }
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004479
4480 // Parse ref-qualifier[opt].
4481 if (Tok.is(tok::amp) || Tok.is(tok::ampamp)) {
David Blaikie4e4d0842012-03-11 07:00:24 +00004482 Diag(Tok, getLangOpts().CPlusPlus0x ?
Richard Smith7fe62082011-10-15 05:09:34 +00004483 diag::warn_cxx98_compat_ref_qualifier :
4484 diag::ext_ref_qualifier);
Richard Smith6ee326a2012-04-10 01:32:12 +00004485
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004486 RefQualifierIsLValueRef = Tok.is(tok::amp);
4487 RefQualifierLoc = ConsumeToken();
4488 EndLoc = RefQualifierLoc;
4489 }
4490
Douglas Gregorcefc3af2012-04-16 07:05:22 +00004491 // C++11 [expr.prim.general]p3:
4492 // If a declaration declares a member function or member function
4493 // template of a class X, the expression this is a prvalue of type
4494 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
4495 // and the end of the function-definition, member-declarator, or
4496 // declarator.
4497 bool IsCXX11MemberFunction =
4498 getLangOpts().CPlusPlus0x &&
4499 (D.getContext() == Declarator::MemberContext ||
4500 (D.getContext() == Declarator::FileContext &&
4501 D.getCXXScopeSpec().isValid() &&
4502 Actions.CurContext->isRecord()));
4503 Sema::CXXThisScopeRAII ThisScope(Actions,
4504 dyn_cast<CXXRecordDecl>(Actions.CurContext),
4505 DS.getTypeQualifiers(),
4506 IsCXX11MemberFunction);
Richard Smitha058fd42012-05-02 22:22:32 +00004507
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004508 // Parse exception-specification[opt].
Richard Smitha058fd42012-05-02 22:22:32 +00004509 ESpecType = tryParseExceptionSpecification(ESpecRange,
Douglas Gregor74e2fc32012-04-16 18:27:27 +00004510 DynamicExceptions,
4511 DynamicExceptionRanges,
Richard Smitha058fd42012-05-02 22:22:32 +00004512 NoexceptExpr);
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004513 if (ESpecType != EST_None)
4514 EndLoc = ESpecRange.getEnd();
4515
Richard Smith6ee326a2012-04-10 01:32:12 +00004516 // Parse attribute-specifier-seq[opt]. Per DR 979 and DR 1297, this goes
4517 // after the exception-specification.
4518 MaybeParseCXX0XAttributes(FnAttrs);
4519
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004520 // Parse trailing-return-type[opt].
David Blaikie4e4d0842012-03-11 07:00:24 +00004521 if (getLangOpts().CPlusPlus0x && Tok.is(tok::arrow)) {
Richard Smith7fe62082011-10-15 05:09:34 +00004522 Diag(Tok, diag::warn_cxx98_compat_trailing_return_type);
Douglas Gregorae7902c2011-08-04 15:30:47 +00004523 SourceRange Range;
Richard Smith54655be2012-06-12 01:51:59 +00004524 TrailingReturnType = ParseTrailingReturnType(Range);
Douglas Gregorae7902c2011-08-04 15:30:47 +00004525 if (Range.getEnd().isValid())
4526 EndLoc = Range.getEnd();
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004527 }
4528 }
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004529 }
4530
4531 // Remember that we parsed a function type, and remember the attributes.
4532 D.AddTypeInfo(DeclaratorChunk::getFunction(HasProto,
4533 /*isVariadic=*/EllipsisLoc.isValid(),
4534 EllipsisLoc,
4535 ParamInfo.data(), ParamInfo.size(),
4536 DS.getTypeQualifiers(),
4537 RefQualifierIsLValueRef,
Douglas Gregor43f51032011-10-19 06:04:55 +00004538 RefQualifierLoc, ConstQualifierLoc,
4539 VolatileQualifierLoc,
Douglas Gregor90ebed02011-07-13 21:47:47 +00004540 /*MutableLoc=*/SourceLocation(),
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004541 ESpecType, ESpecRange.getBegin(),
4542 DynamicExceptions.data(),
4543 DynamicExceptionRanges.data(),
4544 DynamicExceptions.size(),
4545 NoexceptExpr.isUsable() ?
4546 NoexceptExpr.get() : 0,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004547 Tracker.getOpenLocation(),
4548 EndLoc, D,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004549 TrailingReturnType),
Richard Smith6ee326a2012-04-10 01:32:12 +00004550 FnAttrs, EndLoc);
James Molloy16f1f712012-02-29 10:24:19 +00004551
4552 Actions.ActOnEndFunctionDeclarator();
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004553}
4554
4555/// isFunctionDeclaratorIdentifierList - This parameter list may have an
4556/// identifier list form for a K&R-style function: void foo(a,b,c)
4557///
4558/// Note that identifier-lists are only allowed for normal declarators, not for
4559/// abstract-declarators.
4560bool Parser::isFunctionDeclaratorIdentifierList() {
David Blaikie4e4d0842012-03-11 07:00:24 +00004561 return !getLangOpts().CPlusPlus
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004562 && Tok.is(tok::identifier)
4563 && !TryAltiVecVectorToken()
4564 // K&R identifier lists can't have typedefs as identifiers, per C99
4565 // 6.7.5.3p11.
4566 && (TryAnnotateTypeOrScopeToken() || !Tok.is(tok::annot_typename))
4567 // Identifier lists follow a really simple grammar: the identifiers can
4568 // be followed *only* by a ", identifier" or ")". However, K&R
4569 // identifier lists are really rare in the brave new modern world, and
4570 // it is very common for someone to typo a type in a non-K&R style
4571 // list. If we are presented with something like: "void foo(intptr x,
4572 // float y)", we don't want to start parsing the function declarator as
4573 // though it is a K&R style declarator just because intptr is an
4574 // invalid type.
4575 //
4576 // To handle this, we check to see if the token after the first
4577 // identifier is a "," or ")". Only then do we parse it as an
4578 // identifier list.
4579 && (NextToken().is(tok::comma) || NextToken().is(tok::r_paren));
4580}
4581
4582/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator
4583/// we found a K&R-style identifier list instead of a typed parameter list.
4584///
4585/// After returning, ParamInfo will hold the parsed parameters.
4586///
4587/// identifier-list: [C99 6.7.5]
4588/// identifier
4589/// identifier-list ',' identifier
4590///
4591void Parser::ParseFunctionDeclaratorIdentifierList(
4592 Declarator &D,
Chris Lattner5f9e2722011-07-23 10:55:15 +00004593 SmallVector<DeclaratorChunk::ParamInfo, 16> &ParamInfo) {
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004594 // If there was no identifier specified for the declarator, either we are in
4595 // an abstract-declarator, or we are in a parameter declarator which was found
4596 // to be abstract. In abstract-declarators, identifier lists are not valid:
4597 // diagnose this.
4598 if (!D.getIdentifier())
4599 Diag(Tok, diag::ext_ident_list_in_param);
4600
4601 // Maintain an efficient lookup of params we have seen so far.
4602 llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
4603
4604 while (1) {
4605 // If this isn't an identifier, report the error and skip until ')'.
4606 if (Tok.isNot(tok::identifier)) {
4607 Diag(Tok, diag::err_expected_ident);
4608 SkipUntil(tok::r_paren, /*StopAtSemi=*/true, /*DontConsume=*/true);
4609 // Forget we parsed anything.
4610 ParamInfo.clear();
4611 return;
4612 }
4613
4614 IdentifierInfo *ParmII = Tok.getIdentifierInfo();
4615
4616 // Reject 'typedef int y; int test(x, y)', but continue parsing.
4617 if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope()))
4618 Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;
4619
4620 // Verify that the argument identifier has not already been mentioned.
4621 if (!ParamsSoFar.insert(ParmII)) {
4622 Diag(Tok, diag::err_param_redefinition) << ParmII;
4623 } else {
4624 // Remember this identifier in ParamInfo.
4625 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
4626 Tok.getLocation(),
4627 0));
4628 }
4629
4630 // Eat the identifier.
4631 ConsumeToken();
4632
4633 // The list continues if we see a comma.
4634 if (Tok.isNot(tok::comma))
4635 break;
4636 ConsumeToken();
4637 }
4638}
4639
4640/// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list
4641/// after the opening parenthesis. This function will not parse a K&R-style
4642/// identifier list.
4643///
Richard Smith6ce48a72012-04-11 04:01:28 +00004644/// D is the declarator being parsed. If FirstArgAttrs is non-null, then the
4645/// caller parsed those arguments immediately after the open paren - they should
4646/// be considered to be part of the first parameter.
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004647///
4648/// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will
4649/// be the location of the ellipsis, if any was parsed.
4650///
Reid Spencer5f016e22007-07-11 17:01:13 +00004651/// parameter-type-list: [C99 6.7.5]
4652/// parameter-list
4653/// parameter-list ',' '...'
Douglas Gregored5d6512009-09-22 21:41:40 +00004654/// [C++] parameter-list '...'
Reid Spencer5f016e22007-07-11 17:01:13 +00004655///
4656/// parameter-list: [C99 6.7.5]
4657/// parameter-declaration
4658/// parameter-list ',' parameter-declaration
4659///
4660/// parameter-declaration: [C99 6.7.5]
4661/// declaration-specifiers declarator
Chris Lattner04421082008-04-08 04:40:51 +00004662/// [C++] declaration-specifiers declarator '=' assignment-expression
Sebastian Redl84407ba2012-03-14 15:54:00 +00004663/// [C++11] initializer-clause
Reid Spencer5f016e22007-07-11 17:01:13 +00004664/// [GNU] declaration-specifiers declarator attributes
Sebastian Redl50de12f2009-03-24 22:27:57 +00004665/// declaration-specifiers abstract-declarator[opt]
4666/// [C++] declaration-specifiers abstract-declarator[opt]
Chris Lattner8123a952008-04-10 02:22:51 +00004667/// '=' assignment-expression
Reid Spencer5f016e22007-07-11 17:01:13 +00004668/// [GNU] declaration-specifiers abstract-declarator[opt] attributes
Richard Smith6ce48a72012-04-11 04:01:28 +00004669/// [C++11] attribute-specifier-seq parameter-declaration
Reid Spencer5f016e22007-07-11 17:01:13 +00004670///
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004671void Parser::ParseParameterDeclarationClause(
4672 Declarator &D,
Richard Smith6ce48a72012-04-11 04:01:28 +00004673 ParsedAttributes &FirstArgAttrs,
Chris Lattner5f9e2722011-07-23 10:55:15 +00004674 SmallVector<DeclaratorChunk::ParamInfo, 16> &ParamInfo,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004675 SourceLocation &EllipsisLoc) {
Mike Stump1eb44332009-09-09 15:08:12 +00004676
Chris Lattnerf97409f2008-04-06 06:57:35 +00004677 while (1) {
4678 if (Tok.is(tok::ellipsis)) {
Richard Smith6ce48a72012-04-11 04:01:28 +00004679 // FIXME: Issue a diagnostic if we parsed an attribute-specifier-seq
4680 // before deciding this was a parameter-declaration-clause.
Douglas Gregor965acbb2009-02-18 07:07:28 +00004681 EllipsisLoc = ConsumeToken(); // Consume the ellipsis.
Chris Lattnerf97409f2008-04-06 06:57:35 +00004682 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00004683 }
Mike Stump1eb44332009-09-09 15:08:12 +00004684
Chris Lattnerf97409f2008-04-06 06:57:35 +00004685 // Parse the declaration-specifiers.
John McCall54abf7d2009-11-04 02:18:39 +00004686 // Just use the ParsingDeclaration "scope" of the declarator.
John McCall0b7e6782011-03-24 11:26:52 +00004687 DeclSpec DS(AttrFactory);
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004688
Richard Smith6ce48a72012-04-11 04:01:28 +00004689 // Parse any C++11 attributes.
4690 MaybeParseCXX0XAttributes(DS.getAttributes());
4691
John McCall7f040a92010-12-24 02:08:15 +00004692 // Skip any Microsoft attributes before a param.
David Blaikie4e4d0842012-03-11 07:00:24 +00004693 if (getLangOpts().MicrosoftExt && Tok.is(tok::l_square))
John McCall7f040a92010-12-24 02:08:15 +00004694 ParseMicrosoftAttributes(DS.getAttributes());
4695
4696 SourceLocation DSStart = Tok.getLocation();
Chris Lattner7399ee02008-10-20 02:05:46 +00004697
4698 // If the caller parsed attributes for the first argument, add them now.
John McCall7f040a92010-12-24 02:08:15 +00004699 // Take them so that we only apply the attributes to the first parameter.
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004700 // FIXME: If we can leave the attributes in the token stream somehow, we can
Richard Smith6ce48a72012-04-11 04:01:28 +00004701 // get rid of a parameter (FirstArgAttrs) and this statement. It might be
4702 // too much hassle.
4703 DS.takeAttributesFrom(FirstArgAttrs);
John McCall7f040a92010-12-24 02:08:15 +00004704
Chris Lattnere64c5492009-02-27 18:38:20 +00004705 ParseDeclarationSpecifiers(DS);
Mike Stump1eb44332009-09-09 15:08:12 +00004706
Chris Lattnerf97409f2008-04-06 06:57:35 +00004707 // Parse the declarator. This is "PrototypeContext", because we must
4708 // accept either 'declarator' or 'abstract-declarator' here.
4709 Declarator ParmDecl(DS, Declarator::PrototypeContext);
4710 ParseDeclarator(ParmDecl);
4711
4712 // Parse GNU attributes, if present.
John McCall7f040a92010-12-24 02:08:15 +00004713 MaybeParseGNUAttributes(ParmDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00004714
Chris Lattnerf97409f2008-04-06 06:57:35 +00004715 // Remember this parsed parameter in ParamInfo.
4716 IdentifierInfo *ParmII = ParmDecl.getIdentifier();
Mike Stump1eb44332009-09-09 15:08:12 +00004717
Douglas Gregor72b505b2008-12-16 21:30:33 +00004718 // DefArgToks is used when the parsing of default arguments needs
4719 // to be delayed.
4720 CachedTokens *DefArgToks = 0;
4721
Chris Lattnerf97409f2008-04-06 06:57:35 +00004722 // If no parameter was specified, verify that *something* was specified,
4723 // otherwise we have a missing type and identifier.
Chris Lattnere64c5492009-02-27 18:38:20 +00004724 if (DS.isEmpty() && ParmDecl.getIdentifier() == 0 &&
4725 ParmDecl.getNumTypeObjects() == 0) {
Chris Lattnerf97409f2008-04-06 06:57:35 +00004726 // Completely missing, emit error.
4727 Diag(DSStart, diag::err_missing_param);
4728 } else {
4729 // Otherwise, we have something. Add it and let semantic analysis try
4730 // to grok it and add the result to the ParamInfo we are building.
Mike Stump1eb44332009-09-09 15:08:12 +00004731
Chris Lattnerf97409f2008-04-06 06:57:35 +00004732 // Inform the actions module about the parameter declarator, so it gets
4733 // added to the current scope.
John McCalld226f652010-08-21 09:40:31 +00004734 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
Chris Lattner04421082008-04-08 04:40:51 +00004735
4736 // Parse the default argument, if any. We parse the default
4737 // arguments in all dialects; the semantic analysis in
4738 // ActOnParamDefaultArgument will reject the default argument in
4739 // C.
4740 if (Tok.is(tok::equal)) {
Douglas Gregor61366e92008-12-24 00:01:03 +00004741 SourceLocation EqualLoc = Tok.getLocation();
4742
Chris Lattner04421082008-04-08 04:40:51 +00004743 // Parse the default argument
Douglas Gregor72b505b2008-12-16 21:30:33 +00004744 if (D.getContext() == Declarator::MemberContext) {
4745 // If we're inside a class definition, cache the tokens
4746 // corresponding to the default argument. We'll actually parse
4747 // them when we see the end of the class definition.
Douglas Gregor72b505b2008-12-16 21:30:33 +00004748 // FIXME: Can we use a smart pointer for Toks?
4749 DefArgToks = new CachedTokens;
4750
Mike Stump1eb44332009-09-09 15:08:12 +00004751 if (!ConsumeAndStoreUntil(tok::comma, tok::r_paren, *DefArgToks,
Argyrios Kyrtzidis14b91622010-04-23 21:20:12 +00004752 /*StopAtSemi=*/true,
4753 /*ConsumeFinalToken=*/false)) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00004754 delete DefArgToks;
4755 DefArgToks = 0;
Douglas Gregor61366e92008-12-24 00:01:03 +00004756 Actions.ActOnParamDefaultArgumentError(Param);
Argyrios Kyrtzidis2b602ad2010-08-06 09:47:24 +00004757 } else {
4758 // Mark the end of the default argument so that we know when to
4759 // stop when we parse it later on.
4760 Token DefArgEnd;
4761 DefArgEnd.startToken();
4762 DefArgEnd.setKind(tok::cxx_defaultarg_end);
4763 DefArgEnd.setLocation(Tok.getLocation());
4764 DefArgToks->push_back(DefArgEnd);
Mike Stump1eb44332009-09-09 15:08:12 +00004765 Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc,
Anders Carlsson5e300d12009-06-12 16:51:40 +00004766 (*DefArgToks)[1].getLocation());
Argyrios Kyrtzidis2b602ad2010-08-06 09:47:24 +00004767 }
Chris Lattner04421082008-04-08 04:40:51 +00004768 } else {
Douglas Gregor72b505b2008-12-16 21:30:33 +00004769 // Consume the '='.
Douglas Gregor61366e92008-12-24 00:01:03 +00004770 ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00004771
Douglas Gregorbe0f7bd2010-09-11 20:24:53 +00004772 // The argument isn't actually potentially evaluated unless it is
4773 // used.
4774 EnterExpressionEvaluationContext Eval(Actions,
Douglas Gregorccc1b5e2012-02-21 00:37:24 +00004775 Sema::PotentiallyEvaluatedIfUsed,
4776 Param);
Douglas Gregorbe0f7bd2010-09-11 20:24:53 +00004777
Sebastian Redl84407ba2012-03-14 15:54:00 +00004778 ExprResult DefArgResult;
Sebastian Redl3e280b52012-03-18 22:25:45 +00004779 if (getLangOpts().CPlusPlus0x && Tok.is(tok::l_brace)) {
4780 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
Sebastian Redl84407ba2012-03-14 15:54:00 +00004781 DefArgResult = ParseBraceInitializer();
Sebastian Redl3e280b52012-03-18 22:25:45 +00004782 } else
Sebastian Redl84407ba2012-03-14 15:54:00 +00004783 DefArgResult = ParseAssignmentExpression();
Douglas Gregor72b505b2008-12-16 21:30:33 +00004784 if (DefArgResult.isInvalid()) {
4785 Actions.ActOnParamDefaultArgumentError(Param);
4786 SkipUntil(tok::comma, tok::r_paren, true, true);
4787 } else {
4788 // Inform the actions module about the default argument
4789 Actions.ActOnParamDefaultArgument(Param, EqualLoc,
John McCall9ae2f072010-08-23 23:25:46 +00004790 DefArgResult.take());
Douglas Gregor72b505b2008-12-16 21:30:33 +00004791 }
Chris Lattner04421082008-04-08 04:40:51 +00004792 }
4793 }
Mike Stump1eb44332009-09-09 15:08:12 +00004794
4795 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
4796 ParmDecl.getIdentifierLoc(), Param,
Douglas Gregor72b505b2008-12-16 21:30:33 +00004797 DefArgToks));
Chris Lattnerf97409f2008-04-06 06:57:35 +00004798 }
4799
4800 // If the next token is a comma, consume it and keep reading arguments.
Douglas Gregored5d6512009-09-22 21:41:40 +00004801 if (Tok.isNot(tok::comma)) {
4802 if (Tok.is(tok::ellipsis)) {
Douglas Gregored5d6512009-09-22 21:41:40 +00004803 EllipsisLoc = ConsumeToken(); // Consume the ellipsis.
4804
David Blaikie4e4d0842012-03-11 07:00:24 +00004805 if (!getLangOpts().CPlusPlus) {
Douglas Gregored5d6512009-09-22 21:41:40 +00004806 // We have ellipsis without a preceding ',', which is ill-formed
4807 // in C. Complain and provide the fix.
4808 Diag(EllipsisLoc, diag::err_missing_comma_before_ellipsis)
Douglas Gregor849b2432010-03-31 17:46:05 +00004809 << FixItHint::CreateInsertion(EllipsisLoc, ", ");
Douglas Gregored5d6512009-09-22 21:41:40 +00004810 }
4811 }
4812
4813 break;
4814 }
Mike Stump1eb44332009-09-09 15:08:12 +00004815
Chris Lattnerf97409f2008-04-06 06:57:35 +00004816 // Consume the comma.
4817 ConsumeToken();
Reid Spencer5f016e22007-07-11 17:01:13 +00004818 }
Mike Stump1eb44332009-09-09 15:08:12 +00004819
Chris Lattner66d28652008-04-06 06:34:08 +00004820}
Chris Lattneref4715c2008-04-06 05:45:57 +00004821
Reid Spencer5f016e22007-07-11 17:01:13 +00004822/// [C90] direct-declarator '[' constant-expression[opt] ']'
4823/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
4824/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
4825/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
4826/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
Richard Smith6ee326a2012-04-10 01:32:12 +00004827/// [C++11] direct-declarator '[' constant-expression[opt] ']'
4828/// attribute-specifier-seq[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00004829void Parser::ParseBracketDeclarator(Declarator &D) {
Richard Smith6ee326a2012-04-10 01:32:12 +00004830 if (CheckProhibitedCXX11Attribute())
4831 return;
4832
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004833 BalancedDelimiterTracker T(*this, tok::l_square);
4834 T.consumeOpen();
Mike Stump1eb44332009-09-09 15:08:12 +00004835
Chris Lattner378c7e42008-12-18 07:27:21 +00004836 // C array syntax has many features, but by-far the most common is [] and [4].
4837 // This code does a fast path to handle some of the most obvious cases.
4838 if (Tok.getKind() == tok::r_square) {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004839 T.consumeClose();
John McCall0b7e6782011-03-24 11:26:52 +00004840 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00004841 MaybeParseCXX0XAttributes(attrs);
Sean Huntbbd37c62009-11-21 08:43:09 +00004842
Chris Lattner378c7e42008-12-18 07:27:21 +00004843 // Remember that we parsed the empty array type.
John McCall60d7b3a2010-08-24 06:29:42 +00004844 ExprResult NumElements;
John McCall0b7e6782011-03-24 11:26:52 +00004845 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, 0,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004846 T.getOpenLocation(),
4847 T.getCloseLocation()),
4848 attrs, T.getCloseLocation());
Chris Lattner378c7e42008-12-18 07:27:21 +00004849 return;
4850 } else if (Tok.getKind() == tok::numeric_constant &&
4851 GetLookAheadToken(1).is(tok::r_square)) {
4852 // [4] is very common. Parse the numeric constant expression.
Richard Smith36f5cfe2012-03-09 08:00:36 +00004853 ExprResult ExprRes(Actions.ActOnNumericConstant(Tok, getCurScope()));
Chris Lattner378c7e42008-12-18 07:27:21 +00004854 ConsumeToken();
4855
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004856 T.consumeClose();
John McCall0b7e6782011-03-24 11:26:52 +00004857 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00004858 MaybeParseCXX0XAttributes(attrs);
Mike Stump1eb44332009-09-09 15:08:12 +00004859
Chris Lattner378c7e42008-12-18 07:27:21 +00004860 // Remember that we parsed a array type, and remember its features.
John McCall0b7e6782011-03-24 11:26:52 +00004861 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, 0,
John McCall7f040a92010-12-24 02:08:15 +00004862 ExprRes.release(),
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004863 T.getOpenLocation(),
4864 T.getCloseLocation()),
4865 attrs, T.getCloseLocation());
Chris Lattner378c7e42008-12-18 07:27:21 +00004866 return;
4867 }
Mike Stump1eb44332009-09-09 15:08:12 +00004868
Reid Spencer5f016e22007-07-11 17:01:13 +00004869 // If valid, this location is the position where we read the 'static' keyword.
4870 SourceLocation StaticLoc;
Chris Lattner04d66662007-10-09 17:33:22 +00004871 if (Tok.is(tok::kw_static))
Reid Spencer5f016e22007-07-11 17:01:13 +00004872 StaticLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00004873
Reid Spencer5f016e22007-07-11 17:01:13 +00004874 // If there is a type-qualifier-list, read it now.
Chris Lattnera1fcbad2008-12-18 06:50:14 +00004875 // Type qualifiers in an array subscript are a C99 feature.
John McCall0b7e6782011-03-24 11:26:52 +00004876 DeclSpec DS(AttrFactory);
Chris Lattner5a69d1c2008-12-18 07:02:59 +00004877 ParseTypeQualifierListOpt(DS, false /*no attributes*/);
Mike Stump1eb44332009-09-09 15:08:12 +00004878
Reid Spencer5f016e22007-07-11 17:01:13 +00004879 // If we haven't already read 'static', check to see if there is one after the
4880 // type-qualifier-list.
Chris Lattner04d66662007-10-09 17:33:22 +00004881 if (!StaticLoc.isValid() && Tok.is(tok::kw_static))
Reid Spencer5f016e22007-07-11 17:01:13 +00004882 StaticLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00004883
Reid Spencer5f016e22007-07-11 17:01:13 +00004884 // Handle "direct-declarator [ type-qual-list[opt] * ]".
4885 bool isStar = false;
John McCall60d7b3a2010-08-24 06:29:42 +00004886 ExprResult NumElements;
Mike Stump1eb44332009-09-09 15:08:12 +00004887
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00004888 // Handle the case where we have '[*]' as the array size. However, a leading
4889 // star could be the start of an expression, for example 'X[*p + 4]'. Verify
4890 // the the token after the star is a ']'. Since stars in arrays are
4891 // infrequent, use of lookahead is not costly here.
4892 if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
Chris Lattnera711dd02008-04-06 05:27:21 +00004893 ConsumeToken(); // Eat the '*'.
Reid Spencer5f016e22007-07-11 17:01:13 +00004894
Chris Lattnera1fcbad2008-12-18 06:50:14 +00004895 if (StaticLoc.isValid()) {
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00004896 Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);
Chris Lattnera1fcbad2008-12-18 06:50:14 +00004897 StaticLoc = SourceLocation(); // Drop the static.
4898 }
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00004899 isStar = true;
Chris Lattner04d66662007-10-09 17:33:22 +00004900 } else if (Tok.isNot(tok::r_square)) {
Chris Lattner378c7e42008-12-18 07:27:21 +00004901 // Note, in C89, this production uses the constant-expr production instead
4902 // of assignment-expr. The only difference is that assignment-expr allows
4903 // things like '=' and '*='. Sema rejects these in C89 mode because they
4904 // are not i-c-e's, so we don't need to distinguish between the two here.
Mike Stump1eb44332009-09-09 15:08:12 +00004905
Douglas Gregore0762c92009-06-19 23:52:42 +00004906 // Parse the constant-expression or assignment-expression now (depending
4907 // on dialect).
David Blaikie4e4d0842012-03-11 07:00:24 +00004908 if (getLangOpts().CPlusPlus) {
Douglas Gregore0762c92009-06-19 23:52:42 +00004909 NumElements = ParseConstantExpression();
Eli Friedman71b8fb52012-01-21 01:01:51 +00004910 } else {
4911 EnterExpressionEvaluationContext Unevaluated(Actions,
4912 Sema::ConstantEvaluated);
Douglas Gregore0762c92009-06-19 23:52:42 +00004913 NumElements = ParseAssignmentExpression();
Eli Friedman71b8fb52012-01-21 01:01:51 +00004914 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004915 }
Mike Stump1eb44332009-09-09 15:08:12 +00004916
Reid Spencer5f016e22007-07-11 17:01:13 +00004917 // If there was an error parsing the assignment-expression, recover.
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00004918 if (NumElements.isInvalid()) {
Chris Lattner5cb10d32009-04-24 22:30:50 +00004919 D.setInvalidType(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00004920 // If the expression was invalid, skip it.
4921 SkipUntil(tok::r_square);
4922 return;
4923 }
Sebastian Redlab197ba2009-02-09 18:23:29 +00004924
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004925 T.consumeClose();
Sebastian Redlab197ba2009-02-09 18:23:29 +00004926
John McCall0b7e6782011-03-24 11:26:52 +00004927 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00004928 MaybeParseCXX0XAttributes(attrs);
Sean Huntbbd37c62009-11-21 08:43:09 +00004929
Chris Lattner378c7e42008-12-18 07:27:21 +00004930 // Remember that we parsed a array type, and remember its features.
John McCall0b7e6782011-03-24 11:26:52 +00004931 D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(),
Reid Spencer5f016e22007-07-11 17:01:13 +00004932 StaticLoc.isValid(), isStar,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00004933 NumElements.release(),
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004934 T.getOpenLocation(),
4935 T.getCloseLocation()),
4936 attrs, T.getCloseLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00004937}
4938
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00004939/// [GNU] typeof-specifier:
4940/// typeof ( expressions )
4941/// typeof ( type-name )
4942/// [GNU/C++] typeof unary-expression
Steve Naroffd1861fd2007-07-31 12:34:36 +00004943///
4944void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
Chris Lattner04d66662007-10-09 17:33:22 +00004945 assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier");
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004946 Token OpTok = Tok;
Steve Naroffd1861fd2007-07-31 12:34:36 +00004947 SourceLocation StartLoc = ConsumeToken();
4948
John McCallcfb708c2010-01-13 20:03:27 +00004949 const bool hasParens = Tok.is(tok::l_paren);
4950
Eli Friedman71b8fb52012-01-21 01:01:51 +00004951 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
4952
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004953 bool isCastExpr;
John McCallb3d87482010-08-24 05:47:05 +00004954 ParsedType CastTy;
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004955 SourceRange CastRange;
Peter Collingbournef4e3cfb2011-03-11 19:24:49 +00004956 ExprResult Operand = ParseExprAfterUnaryExprOrTypeTrait(OpTok, isCastExpr,
4957 CastTy, CastRange);
John McCallcfb708c2010-01-13 20:03:27 +00004958 if (hasParens)
4959 DS.setTypeofParensRange(CastRange);
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004960
4961 if (CastRange.getEnd().isInvalid())
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00004962 // FIXME: Not accurate, the range gets one token more than it should.
4963 DS.SetRangeEnd(Tok.getLocation());
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004964 else
4965 DS.SetRangeEnd(CastRange.getEnd());
Mike Stump1eb44332009-09-09 15:08:12 +00004966
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004967 if (isCastExpr) {
4968 if (!CastTy) {
4969 DS.SetTypeSpecError();
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00004970 return;
Douglas Gregor809070a2009-02-18 17:45:20 +00004971 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00004972
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004973 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00004974 unsigned DiagID;
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004975 // Check for duplicate type specifiers (e.g. "int typeof(int)").
4976 if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00004977 DiagID, CastTy))
4978 Diag(StartLoc, DiagID) << PrevSpec;
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00004979 return;
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00004980 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00004981
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00004982 // If we get here, the operand to the typeof was an expresion.
4983 if (Operand.isInvalid()) {
4984 DS.SetTypeSpecError();
Steve Naroff9dfa7b42007-08-02 02:53:48 +00004985 return;
Steve Naroffd1861fd2007-07-31 12:34:36 +00004986 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00004987
Eli Friedman71b8fb52012-01-21 01:01:51 +00004988 // We might need to transform the operand if it is potentially evaluated.
4989 Operand = Actions.HandleExprEvaluationContextForTypeof(Operand.get());
4990 if (Operand.isInvalid()) {
4991 DS.SetTypeSpecError();
4992 return;
4993 }
4994
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00004995 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00004996 unsigned DiagID;
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00004997 // Check for duplicate type specifiers (e.g. "int typeof(int)").
4998 if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
John McCallb3d87482010-08-24 05:47:05 +00004999 DiagID, Operand.get()))
John McCallfec54012009-08-03 20:12:06 +00005000 Diag(StartLoc, DiagID) << PrevSpec;
Steve Naroffd1861fd2007-07-31 12:34:36 +00005001}
Chris Lattner1b492422010-02-28 18:33:55 +00005002
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00005003/// [C11] atomic-specifier:
Eli Friedmanb001de72011-10-06 23:00:33 +00005004/// _Atomic ( type-name )
5005///
5006void Parser::ParseAtomicSpecifier(DeclSpec &DS) {
5007 assert(Tok.is(tok::kw__Atomic) && "Not an atomic specifier");
5008
5009 SourceLocation StartLoc = ConsumeToken();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005010 BalancedDelimiterTracker T(*this, tok::l_paren);
5011 if (T.expectAndConsume(diag::err_expected_lparen_after, "_Atomic")) {
Eli Friedmanb001de72011-10-06 23:00:33 +00005012 SkipUntil(tok::r_paren);
5013 return;
5014 }
5015
5016 TypeResult Result = ParseTypeName();
5017 if (Result.isInvalid()) {
5018 SkipUntil(tok::r_paren);
5019 return;
5020 }
5021
5022 // Match the ')'
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005023 T.consumeClose();
Eli Friedmanb001de72011-10-06 23:00:33 +00005024
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005025 if (T.getCloseLocation().isInvalid())
Eli Friedmanb001de72011-10-06 23:00:33 +00005026 return;
5027
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005028 DS.setTypeofParensRange(T.getRange());
5029 DS.SetRangeEnd(T.getCloseLocation());
Eli Friedmanb001de72011-10-06 23:00:33 +00005030
5031 const char *PrevSpec = 0;
5032 unsigned DiagID;
5033 if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec,
5034 DiagID, Result.release()))
5035 Diag(StartLoc, DiagID) << PrevSpec;
5036}
5037
Chris Lattner1b492422010-02-28 18:33:55 +00005038
5039/// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be called
5040/// from TryAltiVecVectorToken.
5041bool Parser::TryAltiVecVectorTokenOutOfLine() {
5042 Token Next = NextToken();
5043 switch (Next.getKind()) {
5044 default: return false;
5045 case tok::kw_short:
5046 case tok::kw_long:
5047 case tok::kw_signed:
5048 case tok::kw_unsigned:
5049 case tok::kw_void:
5050 case tok::kw_char:
5051 case tok::kw_int:
5052 case tok::kw_float:
5053 case tok::kw_double:
5054 case tok::kw_bool:
5055 case tok::kw___pixel:
5056 Tok.setKind(tok::kw___vector);
5057 return true;
5058 case tok::identifier:
5059 if (Next.getIdentifierInfo() == Ident_pixel) {
5060 Tok.setKind(tok::kw___vector);
5061 return true;
5062 }
5063 return false;
5064 }
5065}
5066
5067bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
5068 const char *&PrevSpec, unsigned &DiagID,
5069 bool &isInvalid) {
5070 if (Tok.getIdentifierInfo() == Ident_vector) {
5071 Token Next = NextToken();
5072 switch (Next.getKind()) {
5073 case tok::kw_short:
5074 case tok::kw_long:
5075 case tok::kw_signed:
5076 case tok::kw_unsigned:
5077 case tok::kw_void:
5078 case tok::kw_char:
5079 case tok::kw_int:
5080 case tok::kw_float:
5081 case tok::kw_double:
5082 case tok::kw_bool:
5083 case tok::kw___pixel:
5084 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
5085 return true;
5086 case tok::identifier:
5087 if (Next.getIdentifierInfo() == Ident_pixel) {
5088 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
5089 return true;
5090 }
5091 break;
5092 default:
5093 break;
5094 }
Douglas Gregora8f031f2010-06-16 15:28:57 +00005095 } else if ((Tok.getIdentifierInfo() == Ident_pixel) &&
Chris Lattner1b492422010-02-28 18:33:55 +00005096 DS.isTypeAltiVecVector()) {
5097 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
5098 return true;
5099 }
5100 return false;
5101}