blob: 23d1f40e9ebac311d529a04a44cb4a7646ab81dc [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
Sean Huntbbd37c62009-11-21 08:43:09 +000071/// ParseGNUAttributes - Parse a non-empty attributes list.
Reid Spencer5f016e22007-07-11 17:01:13 +000072///
73/// [GNU] attributes:
74/// attribute
75/// attributes attribute
76///
77/// [GNU] attribute:
78/// '__attribute__' '(' '(' attribute-list ')' ')'
79///
80/// [GNU] attribute-list:
81/// attrib
82/// attribute_list ',' attrib
83///
84/// [GNU] attrib:
85/// empty
86/// attrib-name
87/// attrib-name '(' identifier ')'
88/// attrib-name '(' identifier ',' nonempty-expr-list ')'
89/// attrib-name '(' argument-expression-list [C99 6.5.2] ')'
90///
91/// [GNU] attrib-name:
92/// identifier
93/// typespec
94/// typequal
95/// storageclass
Mike Stump1eb44332009-09-09 15:08:12 +000096///
Reid Spencer5f016e22007-07-11 17:01:13 +000097/// FIXME: The GCC grammar/code for this construct implies we need two
Mike Stump1eb44332009-09-09 15:08:12 +000098/// token lookahead. Comment from gcc: "If they start with an identifier
99/// which is followed by a comma or close parenthesis, then the arguments
Reid Spencer5f016e22007-07-11 17:01:13 +0000100/// start with that identifier; otherwise they are an expression list."
101///
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000102/// GCC does not require the ',' between attribs in an attribute-list.
103///
Reid Spencer5f016e22007-07-11 17:01:13 +0000104/// At the moment, I am not doing 2 token lookahead. I am also unaware of
105/// any attributes that don't work (based on my limited testing). Most
106/// attributes are very simple in practice. Until we find a bug, I don't see
107/// a pressing need to implement the 2 token lookahead.
108
John McCall7f040a92010-12-24 02:08:15 +0000109void Parser::ParseGNUAttributes(ParsedAttributes &attrs,
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000110 SourceLocation *endLoc,
111 LateParsedAttrList *LateAttrs) {
Sean Huntbbd37c62009-11-21 08:43:09 +0000112 assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!");
Mike Stump1eb44332009-09-09 15:08:12 +0000113
Chris Lattner04d66662007-10-09 17:33:22 +0000114 while (Tok.is(tok::kw___attribute)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000115 ConsumeToken();
116 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
117 "attribute")) {
118 SkipUntil(tok::r_paren, true); // skip until ) or ;
John McCall7f040a92010-12-24 02:08:15 +0000119 return;
Reid Spencer5f016e22007-07-11 17:01:13 +0000120 }
121 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
122 SkipUntil(tok::r_paren, true); // skip until ) or ;
John McCall7f040a92010-12-24 02:08:15 +0000123 return;
Reid Spencer5f016e22007-07-11 17:01:13 +0000124 }
125 // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") ))
Chris Lattner04d66662007-10-09 17:33:22 +0000126 while (Tok.is(tok::identifier) || isDeclarationSpecifier() ||
127 Tok.is(tok::comma)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000128 if (Tok.is(tok::comma)) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000129 // allows for empty/non-empty attributes. ((__vector_size__(16),,,,))
130 ConsumeToken();
131 continue;
132 }
133 // we have an identifier or declaration specifier (const, int, etc.)
134 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
135 SourceLocation AttrNameLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +0000136
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000137 if (Tok.is(tok::l_paren)) {
138 // handle "parameterized" attributes
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000139 if (LateAttrs && isAttributeLateParsed(*AttrName)) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000140 LateParsedAttribute *LA =
141 new LateParsedAttribute(this, *AttrName, AttrNameLoc);
142 LateAttrs->push_back(LA);
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000143
144 // Attributes in a class are parsed at the end of the class, along
145 // with other late-parsed declarations.
DeLesley Hutchins161db022012-11-02 21:44:32 +0000146 if (!ClassStack.empty() && !LateAttrs->parseSoon())
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000147 getCurrentClass().LateParsedDeclarations.push_back(LA);
Mike Stump1eb44332009-09-09 15:08:12 +0000148
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000149 // consume everything up to and including the matching right parens
150 ConsumeAndStoreUntil(tok::r_paren, LA->Toks, true, false);
Mike Stump1eb44332009-09-09 15:08:12 +0000151
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000152 Token Eof;
153 Eof.startToken();
154 Eof.setLocation(Tok.getLocation());
155 LA->Toks.push_back(Eof);
156 } else {
Michael Han6880f492012-10-03 01:56:22 +0000157 ParseGNUAttributeArgs(AttrName, AttrNameLoc, attrs, endLoc,
Michael Han45bed132012-10-04 16:42:52 +0000158 0, SourceLocation(), AttributeList::AS_GNU);
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
Michael Han6880f492012-10-03 01:56:22 +0000177/// Parse the arguments to a parameterized GNU attribute or
178/// a C++11 attribute in "gnu" namespace.
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000179void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName,
180 SourceLocation AttrNameLoc,
181 ParsedAttributes &Attrs,
Michael Han6880f492012-10-03 01:56:22 +0000182 SourceLocation *EndLoc,
183 IdentifierInfo *ScopeName,
184 SourceLocation ScopeLoc,
185 AttributeList::Syntax Syntax) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000186
187 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
188
189 // Availability attributes have their own grammar.
190 if (AttrName->isStr("availability")) {
191 ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc);
192 return;
193 }
194 // Thread safety attributes fit into the FIXME case above, so we
195 // just parse the arguments as a list of expressions
196 if (IsThreadSafetyAttribute(AttrName->getName())) {
197 ParseThreadSafetyAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc);
198 return;
199 }
Dmitri Gribenko0d5a0692012-08-17 00:08:38 +0000200 // Type safety attributes have their own grammar.
201 if (AttrName->isStr("type_tag_for_datatype")) {
202 ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc);
203 return;
204 }
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000205
206 ConsumeParen(); // ignore the left paren loc for now
207
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000208 IdentifierInfo *ParmName = 0;
209 SourceLocation ParmLoc;
210 bool BuiltinType = false;
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000211
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000212 switch (Tok.getKind()) {
213 case tok::kw_char:
214 case tok::kw_wchar_t:
215 case tok::kw_char16_t:
216 case tok::kw_char32_t:
217 case tok::kw_bool:
218 case tok::kw_short:
219 case tok::kw_int:
220 case tok::kw_long:
221 case tok::kw___int64:
Richard Smith5a5a9712012-04-04 06:24:32 +0000222 case tok::kw___int128:
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000223 case tok::kw_signed:
224 case tok::kw_unsigned:
225 case tok::kw_float:
226 case tok::kw_double:
227 case tok::kw_void:
228 case tok::kw_typeof:
229 // __attribute__(( vec_type_hint(char) ))
230 // FIXME: Don't just discard the builtin type token.
231 ConsumeToken();
232 BuiltinType = true;
233 break;
234
235 case tok::identifier:
236 ParmName = Tok.getIdentifierInfo();
237 ParmLoc = ConsumeToken();
238 break;
239
240 default:
241 break;
242 }
243
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +0000244 ExprVector ArgExprs;
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000245
246 if (!BuiltinType &&
247 (ParmLoc.isValid() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren))) {
248 // Eat the comma.
249 if (ParmLoc.isValid())
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000250 ConsumeToken();
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000251
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000252 // Parse the non-empty comma-separated list of expressions.
253 while (1) {
254 ExprResult ArgExpr(ParseAssignmentExpression());
255 if (ArgExpr.isInvalid()) {
256 SkipUntil(tok::r_paren);
257 return;
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000258 }
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000259 ArgExprs.push_back(ArgExpr.release());
260 if (Tok.isNot(tok::comma))
261 break;
262 ConsumeToken(); // Eat the comma, move to the next argument
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000263 }
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000264 }
Fariborz Jahanian7a81e412011-10-18 17:11:10 +0000265 else if (Tok.is(tok::less) && AttrName->isStr("iboutletcollection")) {
266 if (!ExpectAndConsume(tok::less, diag::err_expected_less_after, "<",
267 tok::greater)) {
Fariborz Jahanianb2243432011-10-18 23:13:50 +0000268 while (Tok.is(tok::identifier)) {
269 ConsumeToken();
270 if (Tok.is(tok::greater))
271 break;
272 if (Tok.is(tok::comma)) {
273 ConsumeToken();
274 continue;
275 }
276 }
277 if (Tok.isNot(tok::greater))
278 Diag(Tok, diag::err_iboutletcollection_with_protocol);
Fariborz Jahanian7a81e412011-10-18 17:11:10 +0000279 SkipUntil(tok::r_paren, false, true); // skip until ')'
280 }
281 }
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000282
283 SourceLocation RParen = Tok.getLocation();
284 if (!ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) {
Michael Han45bed132012-10-04 16:42:52 +0000285 SourceLocation AttrLoc = ScopeLoc.isValid() ? ScopeLoc : AttrNameLoc;
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000286 AttributeList *attr =
Michael Han45bed132012-10-04 16:42:52 +0000287 Attrs.addNew(AttrName, SourceRange(AttrLoc, RParen),
Michael Han6880f492012-10-03 01:56:22 +0000288 ScopeName, ScopeLoc, ParmName, ParmLoc,
289 ArgExprs.data(), ArgExprs.size(), Syntax);
Sean Hunt8e083e72012-06-19 23:57:03 +0000290 if (BuiltinType && attr->getKind() == AttributeList::AT_IBOutletCollection)
Richard Smithfe0a0fb2011-10-17 21:20:17 +0000291 Diag(Tok, diag::err_iboutletcollection_builtintype);
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000292 }
293}
294
Chad Rosier8decdee2012-06-26 22:30:43 +0000295/// \brief Parses a single argument for a declspec, including the
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000296/// surrounding parens.
Chad Rosier8decdee2012-06-26 22:30:43 +0000297void Parser::ParseMicrosoftDeclSpecWithSingleArg(IdentifierInfo *AttrName,
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000298 SourceLocation AttrNameLoc,
299 ParsedAttributes &Attrs)
300{
301 BalancedDelimiterTracker T(*this, tok::l_paren);
Chad Rosier8decdee2012-06-26 22:30:43 +0000302 if (T.expectAndConsume(diag::err_expected_lparen_after,
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000303 AttrName->getNameStart(), tok::r_paren))
304 return;
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000305
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000306 ExprResult ArgExpr(ParseConstantExpression());
307 if (ArgExpr.isInvalid()) {
308 T.skipToEnd();
309 return;
310 }
311 Expr *ExprList = ArgExpr.take();
Chad Rosier8decdee2012-06-26 22:30:43 +0000312 Attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(),
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000313 &ExprList, 1, AttributeList::AS_Declspec);
314
315 T.consumeClose();
316}
317
Chad Rosier8decdee2012-06-26 22:30:43 +0000318/// \brief Determines whether a declspec is a "simple" one requiring no
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000319/// arguments.
320bool Parser::IsSimpleMicrosoftDeclSpec(IdentifierInfo *Ident) {
321 return llvm::StringSwitch<bool>(Ident->getName())
322 .Case("dllimport", true)
323 .Case("dllexport", true)
324 .Case("noreturn", true)
325 .Case("nothrow", true)
326 .Case("noinline", true)
327 .Case("naked", true)
328 .Case("appdomain", true)
329 .Case("process", true)
330 .Case("jitintrinsic", true)
331 .Case("noalias", true)
332 .Case("restrict", true)
333 .Case("novtable", true)
334 .Case("selectany", true)
335 .Case("thread", true)
336 .Default(false);
337}
338
Chad Rosier8decdee2012-06-26 22:30:43 +0000339/// \brief Attempts to parse a declspec which is not simple (one that takes
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000340/// parameters). Will return false if we properly handled the declspec, or
341/// true if it is an unknown declspec.
Chad Rosier8decdee2012-06-26 22:30:43 +0000342void Parser::ParseComplexMicrosoftDeclSpec(IdentifierInfo *Ident,
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000343 SourceLocation Loc,
344 ParsedAttributes &Attrs) {
345 // Try to handle the easy case first -- these declspecs all take a single
346 // parameter as their argument.
347 if (llvm::StringSwitch<bool>(Ident->getName())
348 .Case("uuid", true)
349 .Case("align", true)
350 .Case("allocate", true)
351 .Default(false)) {
352 ParseMicrosoftDeclSpecWithSingleArg(Ident, Loc, Attrs);
353 } else if (Ident->getName() == "deprecated") {
Chad Rosier8decdee2012-06-26 22:30:43 +0000354 // The deprecated declspec has an optional single argument, so we will
355 // check for a l-paren to decide whether we should parse an argument or
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000356 // not.
357 if (Tok.getKind() == tok::l_paren)
358 ParseMicrosoftDeclSpecWithSingleArg(Ident, Loc, Attrs);
359 else
Chad Rosier8decdee2012-06-26 22:30:43 +0000360 Attrs.addNew(Ident, Loc, 0, Loc, 0, SourceLocation(), 0, 0,
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000361 AttributeList::AS_Declspec);
362 } else if (Ident->getName() == "property") {
363 // The property declspec is more complex in that it can take one or two
Chad Rosier8decdee2012-06-26 22:30:43 +0000364 // assignment expressions as a parameter, but the lhs of the assignment
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000365 // must be named get or put.
366 //
Chad Rosier8decdee2012-06-26 22:30:43 +0000367 // For right now, we will just skip to the closing right paren of the
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000368 // property expression.
369 //
370 // FIXME: we should deal with __declspec(property) at some point because it
371 // is used in the platform SDK headers for the Parallel Patterns Library
372 // and ATL.
373 BalancedDelimiterTracker T(*this, tok::l_paren);
Chad Rosier8decdee2012-06-26 22:30:43 +0000374 if (T.expectAndConsume(diag::err_expected_lparen_after,
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000375 Ident->getNameStart(), tok::r_paren))
376 return;
377 T.skipToEnd();
378 } else {
379 // We don't recognize this as a valid declspec, but instead of creating the
380 // attribute and allowing sema to warn about it, we will warn here instead.
381 // This is because some attributes have multiple spellings, but we need to
382 // disallow that for declspecs (such as align vs aligned). If we made the
Chad Rosier8decdee2012-06-26 22:30:43 +0000383 // attribute, we'd have to split the valid declspec spelling logic into
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000384 // both locations.
385 Diag(Loc, diag::warn_ms_declspec_unknown) << Ident;
386
387 // If there's an open paren, we should eat the open and close parens under
388 // the assumption that this unknown declspec has parameters.
389 BalancedDelimiterTracker T(*this, tok::l_paren);
390 if (!T.consumeOpen())
391 T.skipToEnd();
392 }
393}
394
Eli Friedmana23b4852009-06-08 07:21:15 +0000395/// [MS] decl-specifier:
396/// __declspec ( extended-decl-modifier-seq )
397///
398/// [MS] extended-decl-modifier-seq:
399/// extended-decl-modifier[opt]
400/// extended-decl-modifier extended-decl-modifier-seq
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000401void Parser::ParseMicrosoftDeclSpec(ParsedAttributes &Attrs) {
Steve Narofff59e17e2008-12-24 20:59:21 +0000402 assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
Eli Friedmana23b4852009-06-08 07:21:15 +0000403
Steve Narofff59e17e2008-12-24 20:59:21 +0000404 ConsumeToken();
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000405 BalancedDelimiterTracker T(*this, tok::l_paren);
Chad Rosier8decdee2012-06-26 22:30:43 +0000406 if (T.expectAndConsume(diag::err_expected_lparen_after, "__declspec",
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000407 tok::r_paren))
John McCall7f040a92010-12-24 02:08:15 +0000408 return;
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000409
Chad Rosier8decdee2012-06-26 22:30:43 +0000410 // An empty declspec is perfectly legal and should not warn. Additionally,
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000411 // you can specify multiple attributes per declspec.
412 while (Tok.getKind() != tok::r_paren) {
413 // We expect either a well-known identifier or a generic string. Anything
414 // else is a malformed declspec.
415 bool IsString = Tok.getKind() == tok::string_literal ? true : false;
Chad Rosier8decdee2012-06-26 22:30:43 +0000416 if (!IsString && Tok.getKind() != tok::identifier &&
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000417 Tok.getKind() != tok::kw_restrict) {
418 Diag(Tok, diag::err_ms_declspec_type);
419 T.skipToEnd();
420 return;
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000421 }
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000422
423 IdentifierInfo *AttrName;
424 SourceLocation AttrNameLoc;
425 if (IsString) {
426 SmallString<8> StrBuffer;
427 bool Invalid = false;
428 StringRef Str = PP.getSpelling(Tok, StrBuffer, &Invalid);
429 if (Invalid) {
430 T.skipToEnd();
431 return;
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000432 }
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000433 AttrName = PP.getIdentifierInfo(Str);
434 AttrNameLoc = ConsumeStringToken();
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000435 } else {
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000436 AttrName = Tok.getIdentifierInfo();
437 AttrNameLoc = ConsumeToken();
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000438 }
Chad Rosier8decdee2012-06-26 22:30:43 +0000439
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000440 if (IsString || IsSimpleMicrosoftDeclSpec(AttrName))
Chad Rosier8decdee2012-06-26 22:30:43 +0000441 // If we have a generic string, we will allow it because there is no
442 // documented list of allowable string declspecs, but we know they exist
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000443 // (for instance, SAL declspecs in older versions of MSVC).
444 //
Chad Rosier8decdee2012-06-26 22:30:43 +0000445 // Alternatively, if the identifier is a simple one, then it requires no
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000446 // arguments and can be turned into an attribute directly.
Chad Rosier8decdee2012-06-26 22:30:43 +0000447 Attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(),
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000448 0, 0, AttributeList::AS_Declspec);
449 else
450 ParseComplexMicrosoftDeclSpec(AttrName, AttrNameLoc, Attrs);
Jakob Stoklund Olesen35329362012-06-19 21:48:43 +0000451 }
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000452 T.consumeClose();
Eli Friedman290eeb02009-06-08 23:27:34 +0000453}
454
John McCall7f040a92010-12-24 02:08:15 +0000455void Parser::ParseMicrosoftTypeAttributes(ParsedAttributes &attrs) {
Eli Friedman290eeb02009-06-08 23:27:34 +0000456 // Treat these like attributes
Eli Friedman290eeb02009-06-08 23:27:34 +0000457 while (Tok.is(tok::kw___fastcall) || Tok.is(tok::kw___stdcall) ||
Douglas Gregorf813a2c2010-05-18 16:57:00 +0000458 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___cdecl) ||
Francois Pichet3bd9aa42011-08-18 09:59:55 +0000459 Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64) ||
Francois Pichet58fd97a2011-08-25 00:36:46 +0000460 Tok.is(tok::kw___ptr32) ||
Francois Pichet3bd9aa42011-08-18 09:59:55 +0000461 Tok.is(tok::kw___unaligned)) {
Eli Friedman290eeb02009-06-08 23:27:34 +0000462 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);
Eli Friedman290eeb02009-06-08 23:27:34 +0000466 }
Steve Narofff59e17e2008-12-24 20:59:21 +0000467}
468
John McCall7f040a92010-12-24 02:08:15 +0000469void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) {
Dawn Perchik52fc3142010-09-03 01:29:35 +0000470 // Treat these like attributes
471 while (Tok.is(tok::kw___pascal)) {
472 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
473 SourceLocation AttrNameLoc = ConsumeToken();
John McCall0b7e6782011-03-24 11:26:52 +0000474 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
Aaron Ballmanfc685ac2012-06-19 22:09:27 +0000475 SourceLocation(), 0, 0, AttributeList::AS_MSTypespec);
Dawn Perchik52fc3142010-09-03 01:29:35 +0000476 }
John McCall7f040a92010-12-24 02:08:15 +0000477}
478
Peter Collingbournef315fa82011-02-14 01:42:53 +0000479void Parser::ParseOpenCLAttributes(ParsedAttributes &attrs) {
480 // Treat these like attributes
481 while (Tok.is(tok::kw___kernel)) {
482 SourceLocation AttrNameLoc = ConsumeToken();
John McCall0b7e6782011-03-24 11:26:52 +0000483 attrs.addNew(PP.getIdentifierInfo("opencl_kernel_function"),
484 AttrNameLoc, 0, AttrNameLoc, 0,
Sean Hunt93f95f22012-06-18 16:13:52 +0000485 SourceLocation(), 0, 0, AttributeList::AS_GNU);
Peter Collingbournef315fa82011-02-14 01:42:53 +0000486 }
487}
488
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000489void Parser::ParseOpenCLQualifiers(DeclSpec &DS) {
490 SourceLocation Loc = Tok.getLocation();
491 switch(Tok.getKind()) {
492 // OpenCL qualifiers:
493 case tok::kw___private:
Chad Rosier8decdee2012-06-26 22:30:43 +0000494 case tok::kw_private:
John McCall0b7e6782011-03-24 11:26:52 +0000495 DS.getAttributes().addNewInteger(
Chad Rosier8decdee2012-06-26 22:30:43 +0000496 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000497 PP.getIdentifierInfo("address_space"), Loc, 0);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000498 break;
Chad Rosier8decdee2012-06-26 22:30:43 +0000499
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000500 case tok::kw___global:
John McCall0b7e6782011-03-24 11:26:52 +0000501 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000502 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000503 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_global);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000504 break;
Chad Rosier8decdee2012-06-26 22:30:43 +0000505
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000506 case tok::kw___local:
John McCall0b7e6782011-03-24 11:26:52 +0000507 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000508 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000509 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_local);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000510 break;
Chad Rosier8decdee2012-06-26 22:30:43 +0000511
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000512 case tok::kw___constant:
John McCall0b7e6782011-03-24 11:26:52 +0000513 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000514 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000515 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_constant);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000516 break;
Chad Rosier8decdee2012-06-26 22:30:43 +0000517
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000518 case tok::kw___read_only:
John McCall0b7e6782011-03-24 11:26:52 +0000519 DS.getAttributes().addNewInteger(
Chad Rosier8decdee2012-06-26 22:30:43 +0000520 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000521 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_only);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000522 break;
Chad Rosier8decdee2012-06-26 22:30:43 +0000523
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000524 case tok::kw___write_only:
John McCall0b7e6782011-03-24 11:26:52 +0000525 DS.getAttributes().addNewInteger(
Chad Rosier8decdee2012-06-26 22:30:43 +0000526 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000527 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_write_only);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000528 break;
Chad Rosier8decdee2012-06-26 22:30:43 +0000529
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000530 case tok::kw___read_write:
John McCall0b7e6782011-03-24 11:26:52 +0000531 DS.getAttributes().addNewInteger(
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000532 Actions.getASTContext(),
John McCall0b7e6782011-03-24 11:26:52 +0000533 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_write);
Peter Collingbourne207f4d82011-03-18 22:38:29 +0000534 break;
535 default: break;
536 }
537}
538
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000539/// \brief Parse a version number.
540///
541/// version:
542/// simple-integer
543/// simple-integer ',' simple-integer
544/// simple-integer ',' simple-integer ',' simple-integer
545VersionTuple Parser::ParseVersionTuple(SourceRange &Range) {
546 Range = Tok.getLocation();
547
548 if (!Tok.is(tok::numeric_constant)) {
549 Diag(Tok, diag::err_expected_version);
550 SkipUntil(tok::comma, tok::r_paren, true, true, true);
551 return VersionTuple();
552 }
553
554 // Parse the major (and possibly minor and subminor) versions, which
555 // are stored in the numeric constant. We utilize a quirk of the
556 // lexer, which is that it handles something like 1.2.3 as a single
557 // numeric constant, rather than two separate tokens.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000558 SmallString<512> Buffer;
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000559 Buffer.resize(Tok.getLength()+1);
560 const char *ThisTokBegin = &Buffer[0];
561
562 // Get the spelling of the token, which eliminates trigraphs, etc.
563 bool Invalid = false;
564 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid);
565 if (Invalid)
566 return VersionTuple();
567
568 // Parse the major version.
569 unsigned AfterMajor = 0;
570 unsigned Major = 0;
571 while (AfterMajor < ActualLength && isdigit(ThisTokBegin[AfterMajor])) {
572 Major = Major * 10 + ThisTokBegin[AfterMajor] - '0';
573 ++AfterMajor;
574 }
575
576 if (AfterMajor == 0) {
577 Diag(Tok, diag::err_expected_version);
578 SkipUntil(tok::comma, tok::r_paren, true, true, true);
579 return VersionTuple();
580 }
581
582 if (AfterMajor == ActualLength) {
583 ConsumeToken();
584
585 // We only had a single version component.
586 if (Major == 0) {
587 Diag(Tok, diag::err_zero_version);
588 return VersionTuple();
589 }
590
591 return VersionTuple(Major);
592 }
593
594 if (ThisTokBegin[AfterMajor] != '.' || (AfterMajor + 1 == ActualLength)) {
595 Diag(Tok, diag::err_expected_version);
596 SkipUntil(tok::comma, tok::r_paren, true, true, true);
597 return VersionTuple();
598 }
599
600 // Parse the minor version.
601 unsigned AfterMinor = AfterMajor + 1;
602 unsigned Minor = 0;
603 while (AfterMinor < ActualLength && isdigit(ThisTokBegin[AfterMinor])) {
604 Minor = Minor * 10 + ThisTokBegin[AfterMinor] - '0';
605 ++AfterMinor;
606 }
607
608 if (AfterMinor == ActualLength) {
609 ConsumeToken();
Chad Rosier8decdee2012-06-26 22:30:43 +0000610
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000611 // We had major.minor.
612 if (Major == 0 && Minor == 0) {
613 Diag(Tok, diag::err_zero_version);
614 return VersionTuple();
615 }
616
Chad Rosier8decdee2012-06-26 22:30:43 +0000617 return VersionTuple(Major, Minor);
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000618 }
619
620 // If what follows is not a '.', we have a problem.
621 if (ThisTokBegin[AfterMinor] != '.') {
622 Diag(Tok, diag::err_expected_version);
623 SkipUntil(tok::comma, tok::r_paren, true, true, true);
Chad Rosier8decdee2012-06-26 22:30:43 +0000624 return VersionTuple();
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000625 }
626
627 // Parse the subminor version.
628 unsigned AfterSubminor = AfterMinor + 1;
629 unsigned Subminor = 0;
630 while (AfterSubminor < ActualLength && isdigit(ThisTokBegin[AfterSubminor])) {
631 Subminor = Subminor * 10 + ThisTokBegin[AfterSubminor] - '0';
632 ++AfterSubminor;
633 }
634
635 if (AfterSubminor != ActualLength) {
636 Diag(Tok, diag::err_expected_version);
637 SkipUntil(tok::comma, tok::r_paren, true, true, true);
638 return VersionTuple();
639 }
640 ConsumeToken();
641 return VersionTuple(Major, Minor, Subminor);
642}
643
644/// \brief Parse the contents of the "availability" attribute.
645///
646/// availability-attribute:
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000647/// 'availability' '(' platform ',' version-arg-list, opt-message')'
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000648///
649/// platform:
650/// identifier
651///
652/// version-arg-list:
653/// version-arg
654/// version-arg ',' version-arg-list
655///
656/// version-arg:
657/// 'introduced' '=' version
658/// 'deprecated' '=' version
Douglas Gregor93a70672012-03-11 04:53:21 +0000659/// 'obsoleted' = version
Douglas Gregorb53e4172011-03-26 03:35:55 +0000660/// 'unavailable'
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000661/// opt-message:
662/// 'message' '=' <string>
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000663void Parser::ParseAvailabilityAttribute(IdentifierInfo &Availability,
664 SourceLocation AvailabilityLoc,
665 ParsedAttributes &attrs,
666 SourceLocation *endLoc) {
667 SourceLocation PlatformLoc;
668 IdentifierInfo *Platform = 0;
669
670 enum { Introduced, Deprecated, Obsoleted, Unknown };
671 AvailabilityChange Changes[Unknown];
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000672 ExprResult MessageExpr;
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000673
674 // Opening '('.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000675 BalancedDelimiterTracker T(*this, tok::l_paren);
676 if (T.consumeOpen()) {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000677 Diag(Tok, diag::err_expected_lparen);
678 return;
679 }
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000680
681 // Parse the platform name,
682 if (Tok.isNot(tok::identifier)) {
683 Diag(Tok, diag::err_availability_expected_platform);
684 SkipUntil(tok::r_paren);
685 return;
686 }
687 Platform = Tok.getIdentifierInfo();
688 PlatformLoc = ConsumeToken();
689
690 // Parse the ',' following the platform name.
691 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", tok::r_paren))
692 return;
693
694 // If we haven't grabbed the pointers for the identifiers
695 // "introduced", "deprecated", and "obsoleted", do so now.
696 if (!Ident_introduced) {
697 Ident_introduced = PP.getIdentifierInfo("introduced");
698 Ident_deprecated = PP.getIdentifierInfo("deprecated");
699 Ident_obsoleted = PP.getIdentifierInfo("obsoleted");
Douglas Gregorb53e4172011-03-26 03:35:55 +0000700 Ident_unavailable = PP.getIdentifierInfo("unavailable");
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000701 Ident_message = PP.getIdentifierInfo("message");
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000702 }
703
704 // Parse the set of introductions/deprecations/removals.
Douglas Gregorb53e4172011-03-26 03:35:55 +0000705 SourceLocation UnavailableLoc;
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000706 do {
707 if (Tok.isNot(tok::identifier)) {
708 Diag(Tok, diag::err_availability_expected_change);
709 SkipUntil(tok::r_paren);
710 return;
711 }
712 IdentifierInfo *Keyword = Tok.getIdentifierInfo();
713 SourceLocation KeywordLoc = ConsumeToken();
714
Douglas Gregorb53e4172011-03-26 03:35:55 +0000715 if (Keyword == Ident_unavailable) {
716 if (UnavailableLoc.isValid()) {
717 Diag(KeywordLoc, diag::err_availability_redundant)
718 << Keyword << SourceRange(UnavailableLoc);
Chad Rosier8decdee2012-06-26 22:30:43 +0000719 }
Douglas Gregorb53e4172011-03-26 03:35:55 +0000720 UnavailableLoc = KeywordLoc;
721
722 if (Tok.isNot(tok::comma))
723 break;
724
725 ConsumeToken();
726 continue;
Chad Rosier8decdee2012-06-26 22:30:43 +0000727 }
728
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000729 if (Tok.isNot(tok::equal)) {
730 Diag(Tok, diag::err_expected_equal_after)
731 << Keyword;
732 SkipUntil(tok::r_paren);
733 return;
734 }
735 ConsumeToken();
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000736 if (Keyword == Ident_message) {
737 if (!isTokenStringLiteral()) {
Andy Gibbs97f84612012-11-17 19:16:52 +0000738 Diag(Tok, diag::err_expected_string_literal)
739 << /*Source='availability attribute'*/2;
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000740 SkipUntil(tok::r_paren);
741 return;
742 }
743 MessageExpr = ParseStringLiteralExpression();
744 break;
745 }
Chad Rosier8decdee2012-06-26 22:30:43 +0000746
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000747 SourceRange VersionRange;
748 VersionTuple Version = ParseVersionTuple(VersionRange);
Chad Rosier8decdee2012-06-26 22:30:43 +0000749
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000750 if (Version.empty()) {
751 SkipUntil(tok::r_paren);
752 return;
753 }
754
755 unsigned Index;
756 if (Keyword == Ident_introduced)
757 Index = Introduced;
758 else if (Keyword == Ident_deprecated)
759 Index = Deprecated;
760 else if (Keyword == Ident_obsoleted)
761 Index = Obsoleted;
Chad Rosier8decdee2012-06-26 22:30:43 +0000762 else
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000763 Index = Unknown;
764
765 if (Index < Unknown) {
766 if (!Changes[Index].KeywordLoc.isInvalid()) {
767 Diag(KeywordLoc, diag::err_availability_redundant)
Chad Rosier8decdee2012-06-26 22:30:43 +0000768 << Keyword
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000769 << SourceRange(Changes[Index].KeywordLoc,
770 Changes[Index].VersionRange.getEnd());
771 }
772
773 Changes[Index].KeywordLoc = KeywordLoc;
774 Changes[Index].Version = Version;
775 Changes[Index].VersionRange = VersionRange;
776 } else {
777 Diag(KeywordLoc, diag::err_availability_unknown_change)
778 << Keyword << VersionRange;
779 }
780
781 if (Tok.isNot(tok::comma))
782 break;
783
784 ConsumeToken();
785 } while (true);
786
787 // Closing ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000788 if (T.consumeClose())
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000789 return;
790
791 if (endLoc)
Douglas Gregor4a8dfb52011-10-12 16:37:45 +0000792 *endLoc = T.getCloseLocation();
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000793
Douglas Gregorb53e4172011-03-26 03:35:55 +0000794 // The 'unavailable' availability cannot be combined with any other
795 // availability changes. Make sure that hasn't happened.
796 if (UnavailableLoc.isValid()) {
797 bool Complained = false;
798 for (unsigned Index = Introduced; Index != Unknown; ++Index) {
799 if (Changes[Index].KeywordLoc.isValid()) {
800 if (!Complained) {
801 Diag(UnavailableLoc, diag::warn_availability_and_unavailable)
802 << SourceRange(Changes[Index].KeywordLoc,
803 Changes[Index].VersionRange.getEnd());
804 Complained = true;
805 }
806
807 // Clear out the availability.
808 Changes[Index] = AvailabilityChange();
809 }
810 }
811 }
812
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000813 // Record this attribute
Chad Rosier8decdee2012-06-26 22:30:43 +0000814 attrs.addNew(&Availability,
815 SourceRange(AvailabilityLoc, T.getCloseLocation()),
Fariborz Jahanianf96708d2012-01-23 23:38:32 +0000816 0, AvailabilityLoc,
John McCall0b7e6782011-03-24 11:26:52 +0000817 Platform, PlatformLoc,
818 Changes[Introduced],
819 Changes[Deprecated],
Chad Rosier8decdee2012-06-26 22:30:43 +0000820 Changes[Obsoleted],
Fariborz Jahanian006e42f2011-12-10 00:28:41 +0000821 UnavailableLoc, MessageExpr.take(),
Sean Hunt93f95f22012-06-18 16:13:52 +0000822 AttributeList::AS_GNU);
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000823}
824
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000825
826// Late Parsed Attributes:
827// See other examples of late parsing in lib/Parse/ParseCXXInlineMethods
828
829void Parser::LateParsedDeclaration::ParseLexedAttributes() {}
830
831void Parser::LateParsedClass::ParseLexedAttributes() {
832 Self->ParseLexedAttributes(*Class);
833}
834
835void Parser::LateParsedAttribute::ParseLexedAttributes() {
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000836 Self->ParseLexedAttribute(*this, true, false);
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000837}
838
839/// Wrapper class which calls ParseLexedAttribute, after setting up the
840/// scope appropriately.
841void Parser::ParseLexedAttributes(ParsingClass &Class) {
842 // Deal with templates
843 // FIXME: Test cases to make sure this does the right thing for templates.
844 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
845 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
846 HasTemplateScope);
847 if (HasTemplateScope)
848 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
849
Douglas Gregorcefc3af2012-04-16 07:05:22 +0000850 // Set or update the scope flags.
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000851 bool AlreadyHasClassScope = Class.TopLevelClass;
Douglas Gregorcefc3af2012-04-16 07:05:22 +0000852 unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope;
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000853 ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope);
854 ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope);
855
DeLesley Hutchinscf2fa2f2012-04-06 15:10:17 +0000856 // Enter the scope of nested classes
857 if (!AlreadyHasClassScope)
858 Actions.ActOnStartDelayedMemberDeclarations(getCurScope(),
859 Class.TagOrTemplate);
Benjamin Kramer268efba2012-05-17 12:01:52 +0000860 if (!Class.LateParsedDeclarations.empty()) {
Douglas Gregorcefc3af2012-04-16 07:05:22 +0000861 for (unsigned i = 0, ni = Class.LateParsedDeclarations.size(); i < ni; ++i){
862 Class.LateParsedDeclarations[i]->ParseLexedAttributes();
863 }
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000864 }
Chad Rosier8decdee2012-06-26 22:30:43 +0000865
DeLesley Hutchinscf2fa2f2012-04-06 15:10:17 +0000866 if (!AlreadyHasClassScope)
867 Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(),
868 Class.TagOrTemplate);
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000869}
870
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000871
872/// \brief Parse all attributes in LAs, and attach them to Decl D.
873void Parser::ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D,
874 bool EnterScope, bool OnDefinition) {
DeLesley Hutchins161db022012-11-02 21:44:32 +0000875 assert(LAs.parseSoon() &&
876 "Attribute list should be marked for immediate parsing.");
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000877 for (unsigned i = 0, ni = LAs.size(); i < ni; ++i) {
DeLesley Hutchins95526a42012-08-15 22:41:04 +0000878 if (D)
879 LAs[i]->addDecl(D);
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000880 ParseLexedAttribute(*LAs[i], EnterScope, OnDefinition);
Benjamin Kramerd306cf72012-04-14 12:44:47 +0000881 delete LAs[i];
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000882 }
883 LAs.clear();
884}
885
886
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000887/// \brief Finish parsing an attribute for which parsing was delayed.
888/// This will be called at the end of parsing a class declaration
889/// for each LateParsedAttribute. We consume the saved tokens and
Chad Rosier8decdee2012-06-26 22:30:43 +0000890/// create an attribute with the arguments filled in. We add this
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000891/// to the Attribute list for the decl.
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000892void Parser::ParseLexedAttribute(LateParsedAttribute &LA,
893 bool EnterScope, bool OnDefinition) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000894 // Save the current token position.
895 SourceLocation OrigLoc = Tok.getLocation();
896
897 // Append the current token at the end of the new token stream so that it
898 // doesn't get lost.
899 LA.Toks.push_back(Tok);
900 PP.EnterTokenStream(LA.Toks.data(), LA.Toks.size(), true, false);
901 // Consume the previously pushed token.
902 ConsumeAnyToken();
903
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +0000904 if (OnDefinition && !IsThreadSafetyAttribute(LA.AttrName.getName())) {
905 Diag(Tok, diag::warn_attribute_on_function_definition)
906 << LA.AttrName.getName();
907 }
908
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000909 ParsedAttributes Attrs(AttrFactory);
910 SourceLocation endLoc;
911
DeLesley Hutchinsd30fb9e2012-08-20 21:32:18 +0000912 if (LA.Decls.size() > 0) {
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +0000913 Decl *D = LA.Decls[0];
DeLesley Hutchinsd30fb9e2012-08-20 21:32:18 +0000914 NamedDecl *ND = dyn_cast<NamedDecl>(D);
915 RecordDecl *RD = dyn_cast_or_null<RecordDecl>(D->getDeclContext());
Caitlin Sadowskied9d84a2011-09-08 17:42:31 +0000916
DeLesley Hutchinsd30fb9e2012-08-20 21:32:18 +0000917 // Allow 'this' within late-parsed attributes.
918 Sema::CXXThisScopeRAII ThisScope(Actions, RD,
919 /*TypeQuals=*/0,
920 ND && RD && ND->isCXXInstanceMember());
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000921
DeLesley Hutchinsd30fb9e2012-08-20 21:32:18 +0000922 if (LA.Decls.size() == 1) {
923 // If the Decl is templatized, add template parameters to scope.
924 bool HasTemplateScope = EnterScope && D->isTemplateDecl();
925 ParseScope TempScope(this, Scope::TemplateParamScope, HasTemplateScope);
926 if (HasTemplateScope)
927 Actions.ActOnReenterTemplateScope(Actions.CurScope, D);
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +0000928
DeLesley Hutchinsd30fb9e2012-08-20 21:32:18 +0000929 // If the Decl is on a function, add function parameters to the scope.
930 bool HasFunScope = EnterScope && D->isFunctionOrFunctionTemplate();
931 ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope, HasFunScope);
932 if (HasFunScope)
933 Actions.ActOnReenterFunctionContext(Actions.CurScope, D);
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +0000934
Michael Han6880f492012-10-03 01:56:22 +0000935 ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc,
Michael Han45bed132012-10-04 16:42:52 +0000936 0, SourceLocation(), AttributeList::AS_GNU);
DeLesley Hutchinsd30fb9e2012-08-20 21:32:18 +0000937
938 if (HasFunScope) {
939 Actions.ActOnExitFunctionContext();
940 FnScope.Exit(); // Pop scope, and remove Decls from IdResolver
941 }
942 if (HasTemplateScope) {
943 TempScope.Exit();
944 }
945 } else {
946 // If there are multiple decls, then the decl cannot be within the
947 // function scope.
Michael Han6880f492012-10-03 01:56:22 +0000948 ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc,
Michael Han45bed132012-10-04 16:42:52 +0000949 0, SourceLocation(), AttributeList::AS_GNU);
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +0000950 }
DeLesley Hutchins7ec419a2012-03-02 22:29:50 +0000951 } else {
952 Diag(Tok, diag::warn_attribute_no_decl) << LA.AttrName.getName();
Caitlin Sadowskied9d84a2011-09-08 17:42:31 +0000953 }
954
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +0000955 for (unsigned i = 0, ni = LA.Decls.size(); i < ni; ++i) {
956 Actions.ActOnFinishDelayedAttribute(getCurScope(), LA.Decls[i], Attrs);
957 }
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000958
959 if (Tok.getLocation() != OrigLoc) {
960 // Due to a parsing error, we either went over the cached tokens or
961 // there are still cached tokens left, so we skip the leftover tokens.
962 // Since this is an uncommon situation that should be avoided, use the
963 // expensive isBeforeInTranslationUnit call.
964 if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(),
965 OrigLoc))
966 while (Tok.getLocation() != OrigLoc && Tok.isNot(tok::eof))
Douglas Gregord78ef5b2012-03-08 01:00:17 +0000967 ConsumeAnyToken();
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +0000968 }
969}
970
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000971/// \brief Wrapper around a case statement checking if AttrName is
972/// one of the thread safety attributes
973bool Parser::IsThreadSafetyAttribute(llvm::StringRef AttrName){
974 return llvm::StringSwitch<bool>(AttrName)
975 .Case("guarded_by", true)
976 .Case("guarded_var", true)
977 .Case("pt_guarded_by", true)
978 .Case("pt_guarded_var", true)
979 .Case("lockable", true)
980 .Case("scoped_lockable", true)
981 .Case("no_thread_safety_analysis", true)
982 .Case("acquired_after", true)
983 .Case("acquired_before", true)
984 .Case("exclusive_lock_function", true)
985 .Case("shared_lock_function", true)
986 .Case("exclusive_trylock_function", true)
987 .Case("shared_trylock_function", true)
988 .Case("unlock_function", true)
989 .Case("lock_returned", true)
990 .Case("locks_excluded", true)
991 .Case("exclusive_locks_required", true)
992 .Case("shared_locks_required", true)
993 .Default(false);
994}
995
996/// \brief Parse the contents of thread safety attributes. These
997/// should always be parsed as an expression list.
998///
999/// We need to special case the parsing due to the fact that if the first token
1000/// of the first argument is an identifier, the main parse loop will store
1001/// that token as a "parameter" and the rest of
1002/// the arguments will be added to a list of "arguments". However,
1003/// subsequent tokens in the first argument are lost. We instead parse each
1004/// argument as an expression and add all arguments to the list of "arguments".
1005/// In future, we will take advantage of this special case to also
1006/// deal with some argument scoping issues here (for example, referring to a
1007/// function parameter in the attribute on that function).
1008void Parser::ParseThreadSafetyAttribute(IdentifierInfo &AttrName,
1009 SourceLocation AttrNameLoc,
1010 ParsedAttributes &Attrs,
1011 SourceLocation *EndLoc) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +00001012 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
Caitlin Sadowskib51e0312011-08-09 17:59:31 +00001013
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001014 BalancedDelimiterTracker T(*this, tok::l_paren);
1015 T.consumeOpen();
Chad Rosier8decdee2012-06-26 22:30:43 +00001016
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00001017 ExprVector ArgExprs;
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +00001018 bool ArgExprsOk = true;
Chad Rosier8decdee2012-06-26 22:30:43 +00001019
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +00001020 // now parse the list of expressions
DeLesley Hutchins4805f152011-12-14 19:36:06 +00001021 while (Tok.isNot(tok::r_paren)) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +00001022 ExprResult ArgExpr(ParseAssignmentExpression());
1023 if (ArgExpr.isInvalid()) {
1024 ArgExprsOk = false;
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001025 T.consumeClose();
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +00001026 break;
1027 } else {
1028 ArgExprs.push_back(ArgExpr.release());
Caitlin Sadowskib51e0312011-08-09 17:59:31 +00001029 }
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +00001030 if (Tok.isNot(tok::comma))
1031 break;
1032 ConsumeToken(); // Eat the comma, move to the next argument
1033 }
1034 // Match the ')'.
DeLesley Hutchins23323e02012-01-20 22:50:54 +00001035 if (ArgExprsOk && !T.consumeClose()) {
Caitlin Sadowskieff98fc2011-09-08 17:42:22 +00001036 Attrs.addNew(&AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(),
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00001037 ArgExprs.data(), ArgExprs.size(), AttributeList::AS_GNU);
Caitlin Sadowskib51e0312011-08-09 17:59:31 +00001038 }
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001039 if (EndLoc)
1040 *EndLoc = T.getCloseLocation();
Caitlin Sadowskib51e0312011-08-09 17:59:31 +00001041}
1042
Dmitri Gribenko0d5a0692012-08-17 00:08:38 +00001043void Parser::ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName,
1044 SourceLocation AttrNameLoc,
1045 ParsedAttributes &Attrs,
1046 SourceLocation *EndLoc) {
1047 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
1048
1049 BalancedDelimiterTracker T(*this, tok::l_paren);
1050 T.consumeOpen();
1051
1052 if (Tok.isNot(tok::identifier)) {
1053 Diag(Tok, diag::err_expected_ident);
1054 T.skipToEnd();
1055 return;
1056 }
1057 IdentifierInfo *ArgumentKind = Tok.getIdentifierInfo();
1058 SourceLocation ArgumentKindLoc = ConsumeToken();
1059
1060 if (Tok.isNot(tok::comma)) {
1061 Diag(Tok, diag::err_expected_comma);
1062 T.skipToEnd();
1063 return;
1064 }
1065 ConsumeToken();
1066
1067 SourceRange MatchingCTypeRange;
1068 TypeResult MatchingCType = ParseTypeName(&MatchingCTypeRange);
1069 if (MatchingCType.isInvalid()) {
1070 T.skipToEnd();
1071 return;
1072 }
1073
1074 bool LayoutCompatible = false;
1075 bool MustBeNull = false;
1076 while (Tok.is(tok::comma)) {
1077 ConsumeToken();
1078 if (Tok.isNot(tok::identifier)) {
1079 Diag(Tok, diag::err_expected_ident);
1080 T.skipToEnd();
1081 return;
1082 }
1083 IdentifierInfo *Flag = Tok.getIdentifierInfo();
1084 if (Flag->isStr("layout_compatible"))
1085 LayoutCompatible = true;
1086 else if (Flag->isStr("must_be_null"))
1087 MustBeNull = true;
1088 else {
1089 Diag(Tok, diag::err_type_safety_unknown_flag) << Flag;
1090 T.skipToEnd();
1091 return;
1092 }
1093 ConsumeToken(); // consume flag
1094 }
1095
1096 if (!T.consumeClose()) {
1097 Attrs.addNewTypeTagForDatatype(&AttrName, AttrNameLoc, 0, AttrNameLoc,
1098 ArgumentKind, ArgumentKindLoc,
1099 MatchingCType.release(), LayoutCompatible,
1100 MustBeNull, AttributeList::AS_GNU);
1101 }
1102
1103 if (EndLoc)
1104 *EndLoc = T.getCloseLocation();
1105}
1106
Richard Smith6ee326a2012-04-10 01:32:12 +00001107/// DiagnoseProhibitedCXX11Attribute - We have found the opening square brackets
1108/// of a C++11 attribute-specifier in a location where an attribute is not
1109/// permitted. By C++11 [dcl.attr.grammar]p6, this is ill-formed. Diagnose this
1110/// situation.
1111///
1112/// \return \c true if we skipped an attribute-like chunk of tokens, \c false if
1113/// this doesn't appear to actually be an attribute-specifier, and the caller
1114/// should try to parse it.
1115bool Parser::DiagnoseProhibitedCXX11Attribute() {
1116 assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square));
1117
1118 switch (isCXX11AttributeSpecifier(/*Disambiguate*/true)) {
1119 case CAK_NotAttributeSpecifier:
1120 // No diagnostic: we're in Obj-C++11 and this is not actually an attribute.
1121 return false;
1122
1123 case CAK_InvalidAttributeSpecifier:
1124 Diag(Tok.getLocation(), diag::err_l_square_l_square_not_attribute);
1125 return false;
1126
1127 case CAK_AttributeSpecifier:
1128 // Parse and discard the attributes.
1129 SourceLocation BeginLoc = ConsumeBracket();
1130 ConsumeBracket();
1131 SkipUntil(tok::r_square, /*StopAtSemi*/ false);
1132 assert(Tok.is(tok::r_square) && "isCXX11AttributeSpecifier lied");
1133 SourceLocation EndLoc = ConsumeBracket();
1134 Diag(BeginLoc, diag::err_attributes_not_allowed)
1135 << SourceRange(BeginLoc, EndLoc);
1136 return true;
1137 }
Chandler Carruth2c6dbd72012-04-10 16:03:08 +00001138 llvm_unreachable("All cases handled above.");
Richard Smith6ee326a2012-04-10 01:32:12 +00001139}
1140
John McCall7f040a92010-12-24 02:08:15 +00001141void Parser::DiagnoseProhibitedAttributes(ParsedAttributesWithRange &attrs) {
1142 Diag(attrs.Range.getBegin(), diag::err_attributes_not_allowed)
1143 << attrs.Range;
Dawn Perchik52fc3142010-09-03 01:29:35 +00001144}
1145
Michael Hanf64231e2012-11-06 19:34:54 +00001146void Parser::ProhibitCXX11Attributes(ParsedAttributesWithRange &attrs) {
1147 AttributeList *AttrList = attrs.getList();
1148 while (AttrList) {
1149 if (AttrList->isCXX0XAttribute()) {
1150 Diag(AttrList->getLoc(), diag::warn_attribute_no_decl)
1151 << AttrList->getName();
1152 AttrList->setInvalid();
1153 }
1154 AttrList = AttrList->getNext();
1155 }
1156}
1157
Reid Spencer5f016e22007-07-11 17:01:13 +00001158/// ParseDeclaration - Parse a full 'declaration', which consists of
1159/// declaration-specifiers, some number of declarators, and a semicolon.
Chris Lattner97144fc2009-04-02 04:16:50 +00001160/// 'Context' should be a Declarator::TheContext value. This returns the
1161/// location of the semicolon in DeclEnd.
Chris Lattner8f08cb72007-08-25 06:57:03 +00001162///
1163/// declaration: [C99 6.7]
1164/// block-declaration ->
1165/// simple-declaration
1166/// others [FIXME]
Douglas Gregoradcac882008-12-01 23:54:00 +00001167/// [C++] template-declaration
Chris Lattner8f08cb72007-08-25 06:57:03 +00001168/// [C++] namespace-definition
Douglas Gregorf780abc2008-12-30 03:27:21 +00001169/// [C++] using-directive
Douglas Gregord7f37bf2009-06-22 23:06:13 +00001170/// [C++] using-declaration
Richard Smith534986f2012-04-14 00:33:13 +00001171/// [C++11/C11] static_assert-declaration
Chris Lattner8f08cb72007-08-25 06:57:03 +00001172/// others... [FIXME]
1173///
Fariborz Jahanianc5be7b02010-09-28 20:42:35 +00001174Parser::DeclGroupPtrTy Parser::ParseDeclaration(StmtVector &Stmts,
1175 unsigned Context,
Sean Huntbbd37c62009-11-21 08:43:09 +00001176 SourceLocation &DeclEnd,
John McCall7f040a92010-12-24 02:08:15 +00001177 ParsedAttributesWithRange &attrs) {
Argyrios Kyrtzidis36d36802010-06-17 10:52:18 +00001178 ParenBraceBracketBalancer BalancerRAIIObj(*this);
Fariborz Jahaniane8cff362011-08-30 17:10:52 +00001179 // Must temporarily exit the objective-c container scope for
1180 // parsing c none objective-c decls.
1181 ObjCDeclContextSwitch ObjCDC(*this);
Chad Rosier8decdee2012-06-26 22:30:43 +00001182
John McCalld226f652010-08-21 09:40:31 +00001183 Decl *SingleDecl = 0;
Richard Smithc89edf52011-07-01 19:46:12 +00001184 Decl *OwnedType = 0;
Chris Lattner8f08cb72007-08-25 06:57:03 +00001185 switch (Tok.getKind()) {
Douglas Gregoradcac882008-12-01 23:54:00 +00001186 case tok::kw_template:
Douglas Gregor1426e532009-05-12 21:31:51 +00001187 case tok::kw_export:
John McCall7f040a92010-12-24 02:08:15 +00001188 ProhibitAttributes(attrs);
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001189 SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +00001190 break;
Sebastian Redld078e642010-08-27 23:12:46 +00001191 case tok::kw_inline:
Sebastian Redl88e64ca2010-08-31 00:36:45 +00001192 // Could be the start of an inline namespace. Allowed as an ext in C++03.
David Blaikie4e4d0842012-03-11 07:00:24 +00001193 if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_namespace)) {
John McCall7f040a92010-12-24 02:08:15 +00001194 ProhibitAttributes(attrs);
Sebastian Redld078e642010-08-27 23:12:46 +00001195 SourceLocation InlineLoc = ConsumeToken();
1196 SingleDecl = ParseNamespace(Context, DeclEnd, InlineLoc);
1197 break;
1198 }
Chad Rosier8decdee2012-06-26 22:30:43 +00001199 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs,
Fariborz Jahanianc5be7b02010-09-28 20:42:35 +00001200 true);
Chris Lattner8f08cb72007-08-25 06:57:03 +00001201 case tok::kw_namespace:
John McCall7f040a92010-12-24 02:08:15 +00001202 ProhibitAttributes(attrs);
Chris Lattner97144fc2009-04-02 04:16:50 +00001203 SingleDecl = ParseNamespace(Context, DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +00001204 break;
Douglas Gregorf780abc2008-12-30 03:27:21 +00001205 case tok::kw_using:
John McCall78b81052010-11-10 02:40:36 +00001206 SingleDecl = ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(),
Richard Smithc89edf52011-07-01 19:46:12 +00001207 DeclEnd, attrs, &OwnedType);
Chris Lattner682bf922009-03-29 16:50:03 +00001208 break;
Anders Carlsson511d7ab2009-03-11 16:27:10 +00001209 case tok::kw_static_assert:
Peter Collingbournec6eb44b2011-04-15 00:35:57 +00001210 case tok::kw__Static_assert:
John McCall7f040a92010-12-24 02:08:15 +00001211 ProhibitAttributes(attrs);
Chris Lattner97144fc2009-04-02 04:16:50 +00001212 SingleDecl = ParseStaticAssertDeclaration(DeclEnd);
Chris Lattner682bf922009-03-29 16:50:03 +00001213 break;
Chris Lattner8f08cb72007-08-25 06:57:03 +00001214 default:
John McCall7f040a92010-12-24 02:08:15 +00001215 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs, true);
Chris Lattner8f08cb72007-08-25 06:57:03 +00001216 }
Chad Rosier8decdee2012-06-26 22:30:43 +00001217
Chris Lattner682bf922009-03-29 16:50:03 +00001218 // This routine returns a DeclGroup, if the thing we parsed only contains a
Richard Smithc89edf52011-07-01 19:46:12 +00001219 // single decl, convert it now. Alias declarations can also declare a type;
1220 // include that too if it is present.
1221 return Actions.ConvertDeclToDeclGroup(SingleDecl, OwnedType);
Chris Lattner8f08cb72007-08-25 06:57:03 +00001222}
1223
1224/// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
1225/// declaration-specifiers init-declarator-list[opt] ';'
Sean Hunt2edf0a22012-06-23 05:07:58 +00001226/// [C++11] attribute-specifier-seq decl-specifier-seq[opt]
1227/// init-declarator-list ';'
Chris Lattner8f08cb72007-08-25 06:57:03 +00001228///[C90/C++]init-declarator-list ';' [TODO]
1229/// [OMP] threadprivate-directive [TODO]
Chris Lattnercd147752009-03-29 17:27:48 +00001230///
Sean Hunt2edf0a22012-06-23 05:07:58 +00001231/// for-range-declaration: [C++11 6.5p1: stmt.ranged]
Richard Smithad762fc2011-04-14 22:09:26 +00001232/// attribute-specifier-seq[opt] type-specifier-seq declarator
1233///
Chris Lattnercd147752009-03-29 17:27:48 +00001234/// If RequireSemi is false, this does not check for a ';' at the end of the
Chris Lattner5c5db552010-04-05 18:18:31 +00001235/// declaration. If it is true, it checks for and eats it.
Richard Smithad762fc2011-04-14 22:09:26 +00001236///
1237/// If FRI is non-null, we might be parsing a for-range-declaration instead
1238/// of a simple-declaration. If we find that we are, we also parse the
1239/// for-range-initializer, and place it here.
Sean Hunt2edf0a22012-06-23 05:07:58 +00001240Parser::DeclGroupPtrTy
1241Parser::ParseSimpleDeclaration(StmtVector &Stmts, unsigned Context,
1242 SourceLocation &DeclEnd,
1243 ParsedAttributesWithRange &attrs,
1244 bool RequireSemi, ForRangeInit *FRI) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001245 // Parse the common declaration-specifiers piece.
John McCall54abf7d2009-11-04 02:18:39 +00001246 ParsingDeclSpec DS(*this);
John McCall7f040a92010-12-24 02:08:15 +00001247 DS.takeAttributesFrom(attrs);
Douglas Gregor312eadb2011-04-24 05:37:28 +00001248
Douglas Gregor0efc2c12010-01-13 17:31:36 +00001249 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none,
Richard Smith34b41d92011-02-20 03:19:35 +00001250 getDeclSpecContextFromDeclaratorContext(Context));
Abramo Bagnara06284c12012-01-07 10:52:36 +00001251
Reid Spencer5f016e22007-07-11 17:01:13 +00001252 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
1253 // declaration-specifiers init-declarator-list[opt] ';'
Chris Lattner04d66662007-10-09 17:33:22 +00001254 if (Tok.is(tok::semi)) {
Argyrios Kyrtzidis5641b0d2012-05-16 23:49:15 +00001255 DeclEnd = Tok.getLocation();
Chris Lattner5c5db552010-04-05 18:18:31 +00001256 if (RequireSemi) ConsumeToken();
John McCalld226f652010-08-21 09:40:31 +00001257 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
Douglas Gregor312eadb2011-04-24 05:37:28 +00001258 DS);
John McCall54abf7d2009-11-04 02:18:39 +00001259 DS.complete(TheDecl);
Chris Lattner682bf922009-03-29 16:50:03 +00001260 return Actions.ConvertDeclToDeclGroup(TheDecl);
Reid Spencer5f016e22007-07-11 17:01:13 +00001261 }
Chad Rosier8decdee2012-06-26 22:30:43 +00001262
1263 return ParseDeclGroup(DS, Context, /*FunctionDefs=*/ false, &DeclEnd, FRI);
John McCalld8ac0572009-11-03 19:26:08 +00001264}
Mike Stump1eb44332009-09-09 15:08:12 +00001265
Richard Smith0706df42011-10-19 21:33:05 +00001266/// Returns true if this might be the start of a declarator, or a common typo
1267/// for a declarator.
1268bool Parser::MightBeDeclarator(unsigned Context) {
1269 switch (Tok.getKind()) {
1270 case tok::annot_cxxscope:
1271 case tok::annot_template_id:
1272 case tok::caret:
1273 case tok::code_completion:
1274 case tok::coloncolon:
1275 case tok::ellipsis:
1276 case tok::kw___attribute:
1277 case tok::kw_operator:
1278 case tok::l_paren:
1279 case tok::star:
1280 return true;
1281
1282 case tok::amp:
1283 case tok::ampamp:
David Blaikie4e4d0842012-03-11 07:00:24 +00001284 return getLangOpts().CPlusPlus;
Richard Smith0706df42011-10-19 21:33:05 +00001285
Richard Smith1c94c162012-01-09 22:31:44 +00001286 case tok::l_square: // Might be an attribute on an unnamed bit-field.
David Blaikie4e4d0842012-03-11 07:00:24 +00001287 return Context == Declarator::MemberContext && getLangOpts().CPlusPlus0x &&
Richard Smith1c94c162012-01-09 22:31:44 +00001288 NextToken().is(tok::l_square);
1289
1290 case tok::colon: // Might be a typo for '::' or an unnamed bit-field.
David Blaikie4e4d0842012-03-11 07:00:24 +00001291 return Context == Declarator::MemberContext || getLangOpts().CPlusPlus;
Richard Smith1c94c162012-01-09 22:31:44 +00001292
Richard Smith0706df42011-10-19 21:33:05 +00001293 case tok::identifier:
1294 switch (NextToken().getKind()) {
1295 case tok::code_completion:
1296 case tok::coloncolon:
1297 case tok::comma:
1298 case tok::equal:
1299 case tok::equalequal: // Might be a typo for '='.
1300 case tok::kw_alignas:
1301 case tok::kw_asm:
1302 case tok::kw___attribute:
1303 case tok::l_brace:
1304 case tok::l_paren:
1305 case tok::l_square:
1306 case tok::less:
1307 case tok::r_brace:
1308 case tok::r_paren:
1309 case tok::r_square:
1310 case tok::semi:
1311 return true;
1312
1313 case tok::colon:
1314 // At namespace scope, 'identifier:' is probably a typo for 'identifier::'
Richard Smith1c94c162012-01-09 22:31:44 +00001315 // and in block scope it's probably a label. Inside a class definition,
1316 // this is a bit-field.
1317 return Context == Declarator::MemberContext ||
David Blaikie4e4d0842012-03-11 07:00:24 +00001318 (getLangOpts().CPlusPlus && Context == Declarator::FileContext);
Richard Smith1c94c162012-01-09 22:31:44 +00001319
1320 case tok::identifier: // Possible virt-specifier.
David Blaikie4e4d0842012-03-11 07:00:24 +00001321 return getLangOpts().CPlusPlus0x && isCXX0XVirtSpecifier(NextToken());
Richard Smith0706df42011-10-19 21:33:05 +00001322
1323 default:
1324 return false;
1325 }
1326
1327 default:
1328 return false;
1329 }
1330}
1331
Richard Smith994d73f2012-04-11 20:59:20 +00001332/// Skip until we reach something which seems like a sensible place to pick
1333/// up parsing after a malformed declaration. This will sometimes stop sooner
1334/// than SkipUntil(tok::r_brace) would, but will never stop later.
1335void Parser::SkipMalformedDecl() {
1336 while (true) {
1337 switch (Tok.getKind()) {
1338 case tok::l_brace:
1339 // Skip until matching }, then stop. We've probably skipped over
1340 // a malformed class or function definition or similar.
1341 ConsumeBrace();
1342 SkipUntil(tok::r_brace, /*StopAtSemi*/false);
1343 if (Tok.is(tok::comma) || Tok.is(tok::l_brace) || Tok.is(tok::kw_try)) {
1344 // This declaration isn't over yet. Keep skipping.
1345 continue;
1346 }
1347 if (Tok.is(tok::semi))
1348 ConsumeToken();
1349 return;
1350
1351 case tok::l_square:
1352 ConsumeBracket();
1353 SkipUntil(tok::r_square, /*StopAtSemi*/false);
1354 continue;
1355
1356 case tok::l_paren:
1357 ConsumeParen();
1358 SkipUntil(tok::r_paren, /*StopAtSemi*/false);
1359 continue;
1360
1361 case tok::r_brace:
1362 return;
1363
1364 case tok::semi:
1365 ConsumeToken();
1366 return;
1367
1368 case tok::kw_inline:
1369 // 'inline namespace' at the start of a line is almost certainly
Jordan Rose94f29f42012-07-09 16:54:53 +00001370 // a good place to pick back up parsing, except in an Objective-C
1371 // @interface context.
1372 if (Tok.isAtStartOfLine() && NextToken().is(tok::kw_namespace) &&
1373 (!ParsingInObjCContainer || CurParsedObjCImpl))
Richard Smith994d73f2012-04-11 20:59:20 +00001374 return;
1375 break;
1376
1377 case tok::kw_namespace:
1378 // 'namespace' at the start of a line is almost certainly a good
Jordan Rose94f29f42012-07-09 16:54:53 +00001379 // place to pick back up parsing, except in an Objective-C
1380 // @interface context.
1381 if (Tok.isAtStartOfLine() &&
1382 (!ParsingInObjCContainer || CurParsedObjCImpl))
1383 return;
1384 break;
1385
1386 case tok::at:
1387 // @end is very much like } in Objective-C contexts.
1388 if (NextToken().isObjCAtKeyword(tok::objc_end) &&
1389 ParsingInObjCContainer)
1390 return;
1391 break;
1392
1393 case tok::minus:
1394 case tok::plus:
1395 // - and + probably start new method declarations in Objective-C contexts.
1396 if (Tok.isAtStartOfLine() && ParsingInObjCContainer)
Richard Smith994d73f2012-04-11 20:59:20 +00001397 return;
1398 break;
1399
1400 case tok::eof:
1401 return;
1402
1403 default:
1404 break;
1405 }
1406
1407 ConsumeAnyToken();
1408 }
1409}
1410
John McCalld8ac0572009-11-03 19:26:08 +00001411/// ParseDeclGroup - Having concluded that this is either a function
1412/// definition or a group of object declarations, actually parse the
1413/// result.
John McCall54abf7d2009-11-04 02:18:39 +00001414Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS,
1415 unsigned Context,
John McCalld8ac0572009-11-03 19:26:08 +00001416 bool AllowFunctionDefinitions,
Richard Smithad762fc2011-04-14 22:09:26 +00001417 SourceLocation *DeclEnd,
1418 ForRangeInit *FRI) {
John McCalld8ac0572009-11-03 19:26:08 +00001419 // Parse the first declarator.
John McCall54abf7d2009-11-04 02:18:39 +00001420 ParsingDeclarator D(*this, DS, static_cast<Declarator::TheContext>(Context));
John McCalld8ac0572009-11-03 19:26:08 +00001421 ParseDeclarator(D);
Chris Lattnercd147752009-03-29 17:27:48 +00001422
John McCalld8ac0572009-11-03 19:26:08 +00001423 // Bail out if the first declarator didn't seem well-formed.
1424 if (!D.hasName() && !D.mayOmitIdentifier()) {
Richard Smith994d73f2012-04-11 20:59:20 +00001425 SkipMalformedDecl();
John McCalld8ac0572009-11-03 19:26:08 +00001426 return DeclGroupPtrTy();
Chris Lattner23c4b182009-03-29 17:18:04 +00001427 }
Mike Stump1eb44332009-09-09 15:08:12 +00001428
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001429 // Save late-parsed attributes for now; they need to be parsed in the
1430 // appropriate function scope after the function Decl has been constructed.
DeLesley Hutchins161db022012-11-02 21:44:32 +00001431 // These will be parsed in ParseFunctionDefinition or ParseLexedAttrList.
1432 LateParsedAttrList LateParsedAttrs(true);
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001433 if (D.isFunctionDeclarator())
1434 MaybeParseGNUAttributes(D, &LateParsedAttrs);
1435
Chris Lattnerc82daef2010-07-11 22:24:20 +00001436 // Check to see if we have a function *definition* which must have a body.
1437 if (AllowFunctionDefinitions && D.isFunctionDeclarator() &&
1438 // Look at the next token to make sure that this isn't a function
1439 // declaration. We have to check this because __attribute__ might be the
1440 // start of a function definition in GCC-extended K&R C.
Fariborz Jahanianbe1d4ec2012-08-10 15:54:40 +00001441 !isDeclarationAfterDeclarator()) {
Chad Rosier8decdee2012-06-26 22:30:43 +00001442
Chris Lattner004659a2010-07-11 22:42:07 +00001443 if (isStartOfFunctionDefinition(D)) {
John McCalld8ac0572009-11-03 19:26:08 +00001444 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
1445 Diag(Tok, diag::err_function_declared_typedef);
1446
1447 // Recover by treating the 'typedef' as spurious.
1448 DS.ClearStorageClassSpecs();
1449 }
1450
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001451 Decl *TheDecl =
1452 ParseFunctionDefinition(D, ParsedTemplateInfo(), &LateParsedAttrs);
John McCalld8ac0572009-11-03 19:26:08 +00001453 return Actions.ConvertDeclToDeclGroup(TheDecl);
Chris Lattner004659a2010-07-11 22:42:07 +00001454 }
Chad Rosier8decdee2012-06-26 22:30:43 +00001455
Chris Lattner004659a2010-07-11 22:42:07 +00001456 if (isDeclarationSpecifier()) {
1457 // If there is an invalid declaration specifier right after the function
1458 // prototype, then we must be in a missing semicolon case where this isn't
1459 // actually a body. Just fall through into the code that handles it as a
1460 // prototype, and let the top-level code handle the erroneous declspec
1461 // where it would otherwise expect a comma or semicolon.
John McCalld8ac0572009-11-03 19:26:08 +00001462 } else {
1463 Diag(Tok, diag::err_expected_fn_body);
1464 SkipUntil(tok::semi);
1465 return DeclGroupPtrTy();
1466 }
1467 }
1468
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001469 if (ParseAsmAttributesAfterDeclarator(D))
Richard Smithad762fc2011-04-14 22:09:26 +00001470 return DeclGroupPtrTy();
1471
1472 // C++0x [stmt.iter]p1: Check if we have a for-range-declarator. If so, we
1473 // must parse and analyze the for-range-initializer before the declaration is
1474 // analyzed.
1475 if (FRI && Tok.is(tok::colon)) {
1476 FRI->ColonLoc = ConsumeToken();
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001477 if (Tok.is(tok::l_brace))
1478 FRI->RangeExpr = ParseBraceInitializer();
1479 else
1480 FRI->RangeExpr = ParseExpression();
Richard Smithad762fc2011-04-14 22:09:26 +00001481 Decl *ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
1482 Actions.ActOnCXXForRangeDecl(ThisDecl);
1483 Actions.FinalizeDeclaration(ThisDecl);
John McCall6895a642012-01-27 01:29:43 +00001484 D.complete(ThisDecl);
Richard Smithad762fc2011-04-14 22:09:26 +00001485 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, &ThisDecl, 1);
1486 }
1487
Chris Lattner5f9e2722011-07-23 10:55:15 +00001488 SmallVector<Decl *, 8> DeclsInGroup;
Richard Smithad762fc2011-04-14 22:09:26 +00001489 Decl *FirstDecl = ParseDeclarationAfterDeclaratorAndAttributes(D);
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001490 if (LateParsedAttrs.size() > 0)
1491 ParseLexedAttributeList(LateParsedAttrs, FirstDecl, true, false);
John McCall54abf7d2009-11-04 02:18:39 +00001492 D.complete(FirstDecl);
John McCalld226f652010-08-21 09:40:31 +00001493 if (FirstDecl)
John McCalld8ac0572009-11-03 19:26:08 +00001494 DeclsInGroup.push_back(FirstDecl);
1495
Richard Smith0706df42011-10-19 21:33:05 +00001496 bool ExpectSemi = Context != Declarator::ForContext;
Fariborz Jahanian6c89eaf2012-07-02 23:37:09 +00001497
John McCalld8ac0572009-11-03 19:26:08 +00001498 // If we don't have a comma, it is either the end of the list (a ';') or an
1499 // error, bail out.
1500 while (Tok.is(tok::comma)) {
Richard Smith0706df42011-10-19 21:33:05 +00001501 SourceLocation CommaLoc = ConsumeToken();
1502
1503 if (Tok.isAtStartOfLine() && ExpectSemi && !MightBeDeclarator(Context)) {
1504 // This comma was followed by a line-break and something which can't be
1505 // the start of a declarator. The comma was probably a typo for a
1506 // semicolon.
1507 Diag(CommaLoc, diag::err_expected_semi_declaration)
1508 << FixItHint::CreateReplacement(CommaLoc, ";");
1509 ExpectSemi = false;
1510 break;
1511 }
John McCalld8ac0572009-11-03 19:26:08 +00001512
1513 // Parse the next declarator.
1514 D.clear();
Richard Smith7984de32012-01-12 23:53:29 +00001515 D.setCommaLoc(CommaLoc);
John McCalld8ac0572009-11-03 19:26:08 +00001516
1517 // Accept attributes in an init-declarator. In the first declarator in a
1518 // declaration, these would be part of the declspec. In subsequent
1519 // declarators, they become part of the declarator itself, so that they
1520 // don't apply to declarators after *this* one. Examples:
1521 // short __attribute__((common)) var; -> declspec
1522 // short var __attribute__((common)); -> declarator
1523 // short x, __attribute__((common)) var; -> declarator
John McCall7f040a92010-12-24 02:08:15 +00001524 MaybeParseGNUAttributes(D);
John McCalld8ac0572009-11-03 19:26:08 +00001525
1526 ParseDeclarator(D);
Fariborz Jahanian9baf39d2012-01-13 00:14:12 +00001527 if (!D.isInvalidType()) {
1528 Decl *ThisDecl = ParseDeclarationAfterDeclarator(D);
1529 D.complete(ThisDecl);
1530 if (ThisDecl)
Chad Rosier8decdee2012-06-26 22:30:43 +00001531 DeclsInGroup.push_back(ThisDecl);
Fariborz Jahanian9baf39d2012-01-13 00:14:12 +00001532 }
John McCalld8ac0572009-11-03 19:26:08 +00001533 }
1534
1535 if (DeclEnd)
1536 *DeclEnd = Tok.getLocation();
1537
Richard Smith0706df42011-10-19 21:33:05 +00001538 if (ExpectSemi &&
Chris Lattner8bb21d32012-04-28 16:12:17 +00001539 ExpectAndConsumeSemi(Context == Declarator::FileContext
1540 ? diag::err_invalid_token_after_toplevel_declarator
1541 : diag::err_expected_semi_declaration)) {
Chris Lattner004659a2010-07-11 22:42:07 +00001542 // Okay, there was no semicolon and one was expected. If we see a
1543 // declaration specifier, just assume it was missing and continue parsing.
1544 // Otherwise things are very confused and we skip to recover.
1545 if (!isDeclarationSpecifier()) {
1546 SkipUntil(tok::r_brace, true, true);
1547 if (Tok.is(tok::semi))
1548 ConsumeToken();
1549 }
John McCalld8ac0572009-11-03 19:26:08 +00001550 }
1551
Douglas Gregor23c94db2010-07-02 17:43:08 +00001552 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS,
John McCalld8ac0572009-11-03 19:26:08 +00001553 DeclsInGroup.data(),
1554 DeclsInGroup.size());
Reid Spencer5f016e22007-07-11 17:01:13 +00001555}
1556
Richard Smithad762fc2011-04-14 22:09:26 +00001557/// Parse an optional simple-asm-expr and attributes, and attach them to a
1558/// declarator. Returns true on an error.
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001559bool Parser::ParseAsmAttributesAfterDeclarator(Declarator &D) {
Richard Smithad762fc2011-04-14 22:09:26 +00001560 // If a simple-asm-expr is present, parse it.
1561 if (Tok.is(tok::kw_asm)) {
1562 SourceLocation Loc;
1563 ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1564 if (AsmLabel.isInvalid()) {
1565 SkipUntil(tok::semi, true, true);
1566 return true;
1567 }
1568
1569 D.setAsmLabel(AsmLabel.release());
1570 D.SetRangeEnd(Loc);
1571 }
1572
1573 MaybeParseGNUAttributes(D);
1574 return false;
1575}
1576
Douglas Gregor1426e532009-05-12 21:31:51 +00001577/// \brief Parse 'declaration' after parsing 'declaration-specifiers
1578/// declarator'. This method parses the remainder of the declaration
1579/// (including any attributes or initializer, among other things) and
1580/// finalizes the declaration.
Reid Spencer5f016e22007-07-11 17:01:13 +00001581///
Reid Spencer5f016e22007-07-11 17:01:13 +00001582/// init-declarator: [C99 6.7]
1583/// declarator
1584/// declarator '=' initializer
1585/// [GNU] declarator simple-asm-expr[opt] attributes[opt]
1586/// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001587/// [C++] declarator initializer[opt]
1588///
1589/// [C++] initializer:
1590/// [C++] '=' initializer-clause
1591/// [C++] '(' expression-list ')'
Sebastian Redl50de12f2009-03-24 22:27:57 +00001592/// [C++0x] '=' 'default' [TODO]
1593/// [C++0x] '=' 'delete'
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001594/// [C++0x] braced-init-list
Sebastian Redl50de12f2009-03-24 22:27:57 +00001595///
1596/// According to the standard grammar, =default and =delete are function
1597/// definitions, but that definitely doesn't fit with the parser here.
Reid Spencer5f016e22007-07-11 17:01:13 +00001598///
John McCalld226f652010-08-21 09:40:31 +00001599Decl *Parser::ParseDeclarationAfterDeclarator(Declarator &D,
Douglas Gregore542c862009-06-23 23:11:28 +00001600 const ParsedTemplateInfo &TemplateInfo) {
DeLesley Hutchinsc24a2332012-02-16 16:50:43 +00001601 if (ParseAsmAttributesAfterDeclarator(D))
Richard Smithad762fc2011-04-14 22:09:26 +00001602 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001603
Richard Smithad762fc2011-04-14 22:09:26 +00001604 return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo);
1605}
Mike Stump1eb44332009-09-09 15:08:12 +00001606
Richard Smithad762fc2011-04-14 22:09:26 +00001607Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(Declarator &D,
1608 const ParsedTemplateInfo &TemplateInfo) {
Douglas Gregor1426e532009-05-12 21:31:51 +00001609 // Inform the current actions module that we just parsed this declarator.
John McCalld226f652010-08-21 09:40:31 +00001610 Decl *ThisDecl = 0;
Douglas Gregord5a423b2009-09-25 18:43:00 +00001611 switch (TemplateInfo.Kind) {
1612 case ParsedTemplateInfo::NonTemplate:
Douglas Gregor23c94db2010-07-02 17:43:08 +00001613 ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
Douglas Gregord5a423b2009-09-25 18:43:00 +00001614 break;
Chad Rosier8decdee2012-06-26 22:30:43 +00001615
Douglas Gregord5a423b2009-09-25 18:43:00 +00001616 case ParsedTemplateInfo::Template:
1617 case ParsedTemplateInfo::ExplicitSpecialization:
Douglas Gregor23c94db2010-07-02 17:43:08 +00001618 ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
Benjamin Kramer5354e772012-08-23 23:38:35 +00001619 *TemplateInfo.TemplateParams,
Douglas Gregord5a423b2009-09-25 18:43:00 +00001620 D);
1621 break;
Chad Rosier8decdee2012-06-26 22:30:43 +00001622
Douglas Gregord5a423b2009-09-25 18:43:00 +00001623 case ParsedTemplateInfo::ExplicitInstantiation: {
Chad Rosier8decdee2012-06-26 22:30:43 +00001624 DeclResult ThisRes
Douglas Gregor23c94db2010-07-02 17:43:08 +00001625 = Actions.ActOnExplicitInstantiation(getCurScope(),
Douglas Gregord5a423b2009-09-25 18:43:00 +00001626 TemplateInfo.ExternLoc,
1627 TemplateInfo.TemplateLoc,
1628 D);
1629 if (ThisRes.isInvalid()) {
1630 SkipUntil(tok::semi, true, true);
John McCalld226f652010-08-21 09:40:31 +00001631 return 0;
Douglas Gregord5a423b2009-09-25 18:43:00 +00001632 }
Chad Rosier8decdee2012-06-26 22:30:43 +00001633
Douglas Gregord5a423b2009-09-25 18:43:00 +00001634 ThisDecl = ThisRes.get();
1635 break;
1636 }
1637 }
Mike Stump1eb44332009-09-09 15:08:12 +00001638
Richard Smith34b41d92011-02-20 03:19:35 +00001639 bool TypeContainsAuto =
1640 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto;
1641
Douglas Gregor1426e532009-05-12 21:31:51 +00001642 // Parse declarator '=' initializer.
Richard Trieud6c7c672012-01-18 22:54:52 +00001643 // If a '==' or '+=' is found, suggest a fixit to '='.
Richard Trieufcaf27e2012-01-19 22:01:51 +00001644 if (isTokenEqualOrEqualTypo()) {
Douglas Gregor1426e532009-05-12 21:31:51 +00001645 ConsumeToken();
Anders Carlsson37bf9d22010-09-24 21:25:25 +00001646 if (Tok.is(tok::kw_delete)) {
Sean Hunte4246a62011-05-12 06:15:49 +00001647 if (D.isFunctionDeclarator())
1648 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
1649 << 1 /* delete */;
1650 else
1651 Diag(ConsumeToken(), diag::err_deleted_non_function);
Sean Huntfe2695e2011-05-06 01:42:00 +00001652 } else if (Tok.is(tok::kw_default)) {
Sean Hunte4246a62011-05-12 06:15:49 +00001653 if (D.isFunctionDeclarator())
Sebastian Redlecfcd562012-02-11 23:51:21 +00001654 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
1655 << 0 /* default */;
Sean Hunte4246a62011-05-12 06:15:49 +00001656 else
1657 Diag(ConsumeToken(), diag::err_default_special_members);
Douglas Gregor1426e532009-05-12 21:31:51 +00001658 } else {
David Blaikie4e4d0842012-03-11 07:00:24 +00001659 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
John McCall731ad842009-12-19 09:28:58 +00001660 EnterScope(0);
Douglas Gregor23c94db2010-07-02 17:43:08 +00001661 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
John McCall731ad842009-12-19 09:28:58 +00001662 }
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00001663
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00001664 if (Tok.is(tok::code_completion)) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001665 Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
Peter Collingbourneec98f2f2012-07-27 12:56:09 +00001666 Actions.FinalizeDeclaration(ThisDecl);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00001667 cutOffParsing();
1668 return 0;
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00001669 }
Chad Rosier8decdee2012-06-26 22:30:43 +00001670
John McCall60d7b3a2010-08-24 06:29:42 +00001671 ExprResult Init(ParseInitializer());
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00001672
David Blaikie4e4d0842012-03-11 07:00:24 +00001673 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001674 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
John McCall731ad842009-12-19 09:28:58 +00001675 ExitScope();
1676 }
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00001677
Douglas Gregor1426e532009-05-12 21:31:51 +00001678 if (Init.isInvalid()) {
Douglas Gregor00225542010-03-01 18:27:54 +00001679 SkipUntil(tok::comma, true, true);
1680 Actions.ActOnInitializerError(ThisDecl);
1681 } else
Richard Smith34b41d92011-02-20 03:19:35 +00001682 Actions.AddInitializerToDecl(ThisDecl, Init.take(),
1683 /*DirectInit=*/false, TypeContainsAuto);
Douglas Gregor1426e532009-05-12 21:31:51 +00001684 }
1685 } else if (Tok.is(tok::l_paren)) {
1686 // Parse C++ direct initializer: '(' expression-list ')'
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001687 BalancedDelimiterTracker T(*this, tok::l_paren);
1688 T.consumeOpen();
1689
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00001690 ExprVector Exprs;
Douglas Gregor1426e532009-05-12 21:31:51 +00001691 CommaLocsTy CommaLocs;
1692
David Blaikie4e4d0842012-03-11 07:00:24 +00001693 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregorb4debae2009-12-22 17:47:17 +00001694 EnterScope(0);
Douglas Gregor23c94db2010-07-02 17:43:08 +00001695 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001696 }
1697
Douglas Gregor1426e532009-05-12 21:31:51 +00001698 if (ParseExpressionList(Exprs, CommaLocs)) {
David Blaikie3ea19c82012-10-10 23:15:05 +00001699 Actions.ActOnInitializerError(ThisDecl);
Douglas Gregor1426e532009-05-12 21:31:51 +00001700 SkipUntil(tok::r_paren);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001701
David Blaikie4e4d0842012-03-11 07:00:24 +00001702 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001703 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001704 ExitScope();
1705 }
Douglas Gregor1426e532009-05-12 21:31:51 +00001706 } else {
1707 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00001708 T.consumeClose();
Douglas Gregor1426e532009-05-12 21:31:51 +00001709
1710 assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() &&
1711 "Unexpected number of commas!");
Douglas Gregorb4debae2009-12-22 17:47:17 +00001712
David Blaikie4e4d0842012-03-11 07:00:24 +00001713 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00001714 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
Douglas Gregorb4debae2009-12-22 17:47:17 +00001715 ExitScope();
1716 }
1717
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001718 ExprResult Initializer = Actions.ActOnParenListExpr(T.getOpenLocation(),
1719 T.getCloseLocation(),
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00001720 Exprs);
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001721 Actions.AddInitializerToDecl(ThisDecl, Initializer.take(),
1722 /*DirectInit=*/true, TypeContainsAuto);
Douglas Gregor1426e532009-05-12 21:31:51 +00001723 }
Fariborz Jahanian3b5f9dc2012-07-03 22:54:28 +00001724 } else if (getLangOpts().CPlusPlus0x && Tok.is(tok::l_brace) &&
Fariborz Jahanianb0ed95c2012-07-03 23:22:13 +00001725 (!CurParsedObjCImpl || !D.isFunctionDeclarator())) {
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001726 // Parse C++0x braced-init-list.
Richard Smith7fe62082011-10-15 05:09:34 +00001727 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
1728
Sebastian Redldbef1bb2011-06-05 12:23:16 +00001729 if (D.getCXXScopeSpec().isSet()) {
1730 EnterScope(0);
1731 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
1732 }
1733
1734 ExprResult Init(ParseBraceInitializer());
1735
1736 if (D.getCXXScopeSpec().isSet()) {
1737 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
1738 ExitScope();
1739 }
1740
1741 if (Init.isInvalid()) {
1742 Actions.ActOnInitializerError(ThisDecl);
1743 } else
1744 Actions.AddInitializerToDecl(ThisDecl, Init.take(),
1745 /*DirectInit=*/true, TypeContainsAuto);
1746
Douglas Gregor1426e532009-05-12 21:31:51 +00001747 } else {
Richard Smith34b41d92011-02-20 03:19:35 +00001748 Actions.ActOnUninitializedDecl(ThisDecl, TypeContainsAuto);
Douglas Gregor1426e532009-05-12 21:31:51 +00001749 }
1750
Richard Smith483b9f32011-02-21 20:05:19 +00001751 Actions.FinalizeDeclaration(ThisDecl);
1752
Douglas Gregor1426e532009-05-12 21:31:51 +00001753 return ThisDecl;
1754}
1755
Reid Spencer5f016e22007-07-11 17:01:13 +00001756/// ParseSpecifierQualifierList
1757/// specifier-qualifier-list:
1758/// type-specifier specifier-qualifier-list[opt]
1759/// type-qualifier specifier-qualifier-list[opt]
1760/// [GNU] attributes specifier-qualifier-list[opt]
1761///
Richard Smith69730c12012-03-12 07:56:15 +00001762void Parser::ParseSpecifierQualifierList(DeclSpec &DS, AccessSpecifier AS,
1763 DeclSpecContext DSC) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001764 /// specifier-qualifier-list is a subset of declaration-specifiers. Just
1765 /// parse declaration-specifiers and complain about extra stuff.
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00001766 /// TODO: diagnose attribute-specifiers and alignment-specifiers.
Richard Smith69730c12012-03-12 07:56:15 +00001767 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC);
Mike Stump1eb44332009-09-09 15:08:12 +00001768
Reid Spencer5f016e22007-07-11 17:01:13 +00001769 // Validate declspec for type-name.
1770 unsigned Specs = DS.getParsedSpecifiers();
Richard Smitha971d242012-05-09 20:55:26 +00001771 if ((DSC == DSC_type_specifier || DSC == DSC_trailing) &&
1772 !DS.hasTypeSpecifier()) {
Richard Smith69730c12012-03-12 07:56:15 +00001773 Diag(Tok, diag::err_expected_type);
1774 DS.SetTypeSpecError();
1775 } else if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers() &&
1776 !DS.hasAttributes()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001777 Diag(Tok, diag::err_typename_requires_specqual);
Richard Smith69730c12012-03-12 07:56:15 +00001778 if (!DS.hasTypeSpecifier())
1779 DS.SetTypeSpecError();
1780 }
Mike Stump1eb44332009-09-09 15:08:12 +00001781
Reid Spencer5f016e22007-07-11 17:01:13 +00001782 // Issue diagnostic and remove storage class if present.
1783 if (Specs & DeclSpec::PQ_StorageClassSpecifier) {
1784 if (DS.getStorageClassSpecLoc().isValid())
1785 Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass);
1786 else
1787 Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass);
1788 DS.ClearStorageClassSpecs();
1789 }
Mike Stump1eb44332009-09-09 15:08:12 +00001790
Reid Spencer5f016e22007-07-11 17:01:13 +00001791 // Issue diagnostic and remove function specfier if present.
1792 if (Specs & DeclSpec::PQ_FunctionSpecifier) {
Douglas Gregorb48fe382008-10-31 09:07:45 +00001793 if (DS.isInlineSpecified())
1794 Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
1795 if (DS.isVirtualSpecified())
1796 Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
1797 if (DS.isExplicitSpecified())
1798 Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
Reid Spencer5f016e22007-07-11 17:01:13 +00001799 DS.ClearFunctionSpecs();
1800 }
Richard Smith69730c12012-03-12 07:56:15 +00001801
1802 // Issue diagnostic and remove constexpr specfier if present.
1803 if (DS.isConstexprSpecified()) {
1804 Diag(DS.getConstexprSpecLoc(), diag::err_typename_invalid_constexpr);
1805 DS.ClearConstexprSpec();
1806 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001807}
1808
Chris Lattnerc199ab32009-04-12 20:42:31 +00001809/// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
1810/// specified token is valid after the identifier in a declarator which
1811/// immediately follows the declspec. For example, these things are valid:
1812///
1813/// int x [ 4]; // direct-declarator
1814/// int x ( int y); // direct-declarator
1815/// int(int x ) // direct-declarator
1816/// int x ; // simple-declaration
1817/// int x = 17; // init-declarator-list
1818/// int x , y; // init-declarator-list
1819/// int x __asm__ ("foo"); // init-declarator-list
Chris Lattnerb6645dd2009-04-14 21:16:09 +00001820/// int x : 4; // struct-declarator
Chris Lattnerc83c27a2009-04-12 22:29:43 +00001821/// int x { 5}; // C++'0x unified initializers
Chris Lattnerc199ab32009-04-12 20:42:31 +00001822///
1823/// This is not, because 'x' does not immediately follow the declspec (though
1824/// ')' happens to be valid anyway).
1825/// int (x)
1826///
1827static bool isValidAfterIdentifierInDeclarator(const Token &T) {
1828 return T.is(tok::l_square) || T.is(tok::l_paren) || T.is(tok::r_paren) ||
1829 T.is(tok::semi) || T.is(tok::comma) || T.is(tok::equal) ||
Chris Lattnerb6645dd2009-04-14 21:16:09 +00001830 T.is(tok::kw_asm) || T.is(tok::l_brace) || T.is(tok::colon);
Chris Lattnerc199ab32009-04-12 20:42:31 +00001831}
1832
Chris Lattnere40c2952009-04-14 21:34:55 +00001833
1834/// ParseImplicitInt - This method is called when we have an non-typename
1835/// identifier in a declspec (which normally terminates the decl spec) when
1836/// the declspec has no type specifier. In this case, the declspec is either
1837/// malformed or is "implicit int" (in K&R and C89).
1838///
1839/// This method handles diagnosing this prettily and returns false if the
1840/// declspec is done being processed. If it recovers and thinks there may be
1841/// other pieces of declspec after it, it returns true.
1842///
Chris Lattnerf4382f52009-04-14 22:17:06 +00001843bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00001844 const ParsedTemplateInfo &TemplateInfo,
Michael Han2e397132012-11-26 22:54:45 +00001845 AccessSpecifier AS, DeclSpecContext DSC,
1846 ParsedAttributesWithRange &Attrs) {
Chris Lattnerf4382f52009-04-14 22:17:06 +00001847 assert(Tok.is(tok::identifier) && "should have identifier");
Mike Stump1eb44332009-09-09 15:08:12 +00001848
Chris Lattnere40c2952009-04-14 21:34:55 +00001849 SourceLocation Loc = Tok.getLocation();
1850 // If we see an identifier that is not a type name, we normally would
1851 // parse it as the identifer being declared. However, when a typename
1852 // is typo'd or the definition is not included, this will incorrectly
1853 // parse the typename as the identifier name and fall over misparsing
1854 // later parts of the diagnostic.
1855 //
1856 // As such, we try to do some look-ahead in cases where this would
1857 // otherwise be an "implicit-int" case to see if this is invalid. For
1858 // example: "static foo_t x = 4;" In this case, if we parsed foo_t as
1859 // an identifier with implicit int, we'd get a parse error because the
1860 // next token is obviously invalid for a type. Parse these as a case
1861 // with an invalid type specifier.
1862 assert(!DS.hasTypeSpecifier() && "Type specifier checked above");
Mike Stump1eb44332009-09-09 15:08:12 +00001863
Chris Lattnere40c2952009-04-14 21:34:55 +00001864 // Since we know that this either implicit int (which is rare) or an
Richard Smith827adaf2012-05-15 21:01:51 +00001865 // error, do lookahead to try to do better recovery. This never applies
1866 // within a type specifier. Outside of C++, we allow this even if the
1867 // language doesn't "officially" support implicit int -- we support
1868 // implicit int as an extension in C99 and C11. Allegedly, MS also
1869 // supports implicit int in C++ mode.
Richard Smitha971d242012-05-09 20:55:26 +00001870 if (DSC != DSC_type_specifier && DSC != DSC_trailing &&
Richard Smith827adaf2012-05-15 21:01:51 +00001871 (!getLangOpts().CPlusPlus || getLangOpts().MicrosoftExt) &&
Richard Smith69730c12012-03-12 07:56:15 +00001872 isValidAfterIdentifierInDeclarator(NextToken())) {
Chris Lattnere40c2952009-04-14 21:34:55 +00001873 // If this token is valid for implicit int, e.g. "static x = 4", then
1874 // we just avoid eating the identifier, so it will be parsed as the
1875 // identifier in the declarator.
1876 return false;
1877 }
Mike Stump1eb44332009-09-09 15:08:12 +00001878
Richard Smith827adaf2012-05-15 21:01:51 +00001879 if (getLangOpts().CPlusPlus &&
1880 DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
1881 // Don't require a type specifier if we have the 'auto' storage class
1882 // specifier in C++98 -- we'll promote it to a type specifier.
1883 return false;
1884 }
1885
Chris Lattnere40c2952009-04-14 21:34:55 +00001886 // Otherwise, if we don't consume this token, we are going to emit an
1887 // error anyway. Try to recover from various common problems. Check
1888 // to see if this was a reference to a tag name without a tag specified.
1889 // This is a common problem in C (saying 'foo' instead of 'struct foo').
Chris Lattnerf4382f52009-04-14 22:17:06 +00001890 //
1891 // C++ doesn't need this, and isTagName doesn't take SS.
1892 if (SS == 0) {
Argyrios Kyrtzidisb8a9d3b2011-04-21 17:29:47 +00001893 const char *TagName = 0, *FixitTagName = 0;
Chris Lattnerf4382f52009-04-14 22:17:06 +00001894 tok::TokenKind TagKind = tok::unknown;
Mike Stump1eb44332009-09-09 15:08:12 +00001895
Douglas Gregor23c94db2010-07-02 17:43:08 +00001896 switch (Actions.isTagName(*Tok.getIdentifierInfo(), getCurScope())) {
Chris Lattnere40c2952009-04-14 21:34:55 +00001897 default: break;
Argyrios Kyrtzidisb8a9d3b2011-04-21 17:29:47 +00001898 case DeclSpec::TST_enum:
1899 TagName="enum" ; FixitTagName = "enum " ; TagKind=tok::kw_enum ;break;
1900 case DeclSpec::TST_union:
1901 TagName="union" ; FixitTagName = "union " ;TagKind=tok::kw_union ;break;
1902 case DeclSpec::TST_struct:
1903 TagName="struct"; FixitTagName = "struct ";TagKind=tok::kw_struct;break;
Joao Matos6666ed42012-08-31 18:45:21 +00001904 case DeclSpec::TST_interface:
1905 TagName="__interface"; FixitTagName = "__interface ";
1906 TagKind=tok::kw___interface;break;
Argyrios Kyrtzidisb8a9d3b2011-04-21 17:29:47 +00001907 case DeclSpec::TST_class:
1908 TagName="class" ; FixitTagName = "class " ;TagKind=tok::kw_class ;break;
Chris Lattnere40c2952009-04-14 21:34:55 +00001909 }
Mike Stump1eb44332009-09-09 15:08:12 +00001910
Chris Lattnerf4382f52009-04-14 22:17:06 +00001911 if (TagName) {
Kaelyn Uhrainaec2ac62012-04-26 23:36:17 +00001912 IdentifierInfo *TokenName = Tok.getIdentifierInfo();
1913 LookupResult R(Actions, TokenName, SourceLocation(),
1914 Sema::LookupOrdinaryName);
1915
Chris Lattnerf4382f52009-04-14 22:17:06 +00001916 Diag(Loc, diag::err_use_of_tag_name_without_tag)
Kaelyn Uhrainaec2ac62012-04-26 23:36:17 +00001917 << TokenName << TagName << getLangOpts().CPlusPlus
1918 << FixItHint::CreateInsertion(Tok.getLocation(), FixitTagName);
1919
1920 if (Actions.LookupParsedName(R, getCurScope(), SS)) {
1921 for (LookupResult::iterator I = R.begin(), IEnd = R.end();
1922 I != IEnd; ++I)
Kaelyn Uhrain392b3f52012-04-27 18:26:49 +00001923 Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
Kaelyn Uhrainaec2ac62012-04-26 23:36:17 +00001924 << TokenName << TagName;
1925 }
Mike Stump1eb44332009-09-09 15:08:12 +00001926
Chris Lattnerf4382f52009-04-14 22:17:06 +00001927 // Parse this as a tag as if the missing tag were present.
1928 if (TagKind == tok::kw_enum)
Richard Smith69730c12012-03-12 07:56:15 +00001929 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS, DSC_normal);
Chris Lattnerf4382f52009-04-14 22:17:06 +00001930 else
Richard Smith69730c12012-03-12 07:56:15 +00001931 ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS,
Michael Han2e397132012-11-26 22:54:45 +00001932 /*EnteringContext*/ false, DSC_normal, Attrs);
Chris Lattnerf4382f52009-04-14 22:17:06 +00001933 return true;
1934 }
Chris Lattnere40c2952009-04-14 21:34:55 +00001935 }
Mike Stump1eb44332009-09-09 15:08:12 +00001936
Richard Smith8f0a7e72012-05-15 21:29:55 +00001937 // Determine whether this identifier could plausibly be the name of something
Richard Smith7514db22012-05-15 21:42:17 +00001938 // being declared (with a missing type).
Richard Smith8f0a7e72012-05-15 21:29:55 +00001939 if (DSC != DSC_type_specifier && DSC != DSC_trailing &&
1940 (!SS || DSC == DSC_top_level || DSC == DSC_class)) {
Richard Smith827adaf2012-05-15 21:01:51 +00001941 // Look ahead to the next token to try to figure out what this declaration
1942 // was supposed to be.
1943 switch (NextToken().getKind()) {
1944 case tok::comma:
1945 case tok::equal:
1946 case tok::kw_asm:
1947 case tok::l_brace:
1948 case tok::l_square:
1949 case tok::semi:
1950 // This looks like a variable declaration. The type is probably missing.
1951 // We're done parsing decl-specifiers.
1952 return false;
1953
1954 case tok::l_paren: {
1955 // static x(4); // 'x' is not a type
1956 // x(int n); // 'x' is not a type
1957 // x (*p)[]; // 'x' is a type
1958 //
1959 // Since we're in an error case (or the rare 'implicit int in C++' MS
1960 // extension), we can afford to perform a tentative parse to determine
1961 // which case we're in.
1962 TentativeParsingAction PA(*this);
1963 ConsumeToken();
1964 TPResult TPR = TryParseDeclarator(/*mayBeAbstract*/false);
1965 PA.Revert();
1966 if (TPR == TPResult::False())
1967 return false;
1968 // The identifier is followed by a parenthesized declarator.
1969 // It's supposed to be a type.
1970 break;
1971 }
1972
1973 default:
1974 // This is probably supposed to be a type. This includes cases like:
1975 // int f(itn);
1976 // struct S { unsinged : 4; };
1977 break;
1978 }
1979 }
1980
Chad Rosier8decdee2012-06-26 22:30:43 +00001981 // This is almost certainly an invalid type name. Let the action emit a
Douglas Gregora786fdb2009-10-13 23:27:22 +00001982 // diagnostic and attempt to recover.
John McCallb3d87482010-08-24 05:47:05 +00001983 ParsedType T;
Kaelyn Uhrain50dc12a2012-06-15 23:45:58 +00001984 IdentifierInfo *II = Tok.getIdentifierInfo();
1985 if (Actions.DiagnoseUnknownTypeName(II, Loc, getCurScope(), SS, T)) {
Douglas Gregora786fdb2009-10-13 23:27:22 +00001986 // The action emitted a diagnostic, so we don't have to.
1987 if (T) {
1988 // The action has suggested that the type T could be used. Set that as
1989 // the type in the declaration specifiers, consume the would-be type
1990 // name token, and we're done.
1991 const char *PrevSpec;
1992 unsigned DiagID;
John McCallb3d87482010-08-24 05:47:05 +00001993 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T);
Douglas Gregora786fdb2009-10-13 23:27:22 +00001994 DS.SetRangeEnd(Tok.getLocation());
1995 ConsumeToken();
Kaelyn Uhrain50dc12a2012-06-15 23:45:58 +00001996 // There may be other declaration specifiers after this.
1997 return true;
1998 } else if (II != Tok.getIdentifierInfo()) {
1999 // If no type was suggested, the correction is to a keyword
2000 Tok.setKind(II->getTokenID());
Douglas Gregora786fdb2009-10-13 23:27:22 +00002001 // There may be other declaration specifiers after this.
2002 return true;
2003 }
Chad Rosier8decdee2012-06-26 22:30:43 +00002004
Douglas Gregora786fdb2009-10-13 23:27:22 +00002005 // Fall through; the action had no suggestion for us.
2006 } else {
2007 // The action did not emit a diagnostic, so emit one now.
2008 SourceRange R;
2009 if (SS) R = SS->getRange();
2010 Diag(Loc, diag::err_unknown_typename) << Tok.getIdentifierInfo() << R;
2011 }
Mike Stump1eb44332009-09-09 15:08:12 +00002012
Douglas Gregora786fdb2009-10-13 23:27:22 +00002013 // Mark this as an error.
Richard Smith69730c12012-03-12 07:56:15 +00002014 DS.SetTypeSpecError();
Chris Lattnere40c2952009-04-14 21:34:55 +00002015 DS.SetRangeEnd(Tok.getLocation());
2016 ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00002017
Chris Lattnere40c2952009-04-14 21:34:55 +00002018 // TODO: Could inject an invalid typedef decl in an enclosing scope to
2019 // avoid rippling error messages on subsequent uses of the same type,
2020 // could be useful if #include was forgotten.
2021 return false;
2022}
2023
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002024/// \brief Determine the declaration specifier context from the declarator
2025/// context.
2026///
2027/// \param Context the declarator context, which is one of the
2028/// Declarator::TheContext enumerator values.
Chad Rosier8decdee2012-06-26 22:30:43 +00002029Parser::DeclSpecContext
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002030Parser::getDeclSpecContextFromDeclaratorContext(unsigned Context) {
2031 if (Context == Declarator::MemberContext)
2032 return DSC_class;
2033 if (Context == Declarator::FileContext)
2034 return DSC_top_level;
Richard Smith6d96d3a2012-03-15 01:02:11 +00002035 if (Context == Declarator::TrailingReturnContext)
2036 return DSC_trailing;
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002037 return DSC_normal;
2038}
2039
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002040/// ParseAlignArgument - Parse the argument to an alignment-specifier.
2041///
2042/// FIXME: Simply returns an alignof() expression if the argument is a
2043/// type. Ideally, the type should be propagated directly into Sema.
2044///
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00002045/// [C11] type-id
2046/// [C11] constant-expression
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00002047/// [C++0x] type-id ...[opt]
2048/// [C++0x] assignment-expression ...[opt]
2049ExprResult Parser::ParseAlignArgument(SourceLocation Start,
2050 SourceLocation &EllipsisLoc) {
2051 ExprResult ER;
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002052 if (isTypeIdInParens()) {
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002053 SourceLocation TypeLoc = Tok.getLocation();
2054 ParsedType Ty = ParseTypeName().get();
2055 SourceRange TypeRange(Start, Tok.getLocation());
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00002056 ER = Actions.ActOnUnaryExprOrTypeTraitExpr(TypeLoc, UETT_AlignOf, true,
2057 Ty.getAsOpaquePtr(), TypeRange);
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002058 } else
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00002059 ER = ParseConstantExpression();
2060
David Blaikie4e4d0842012-03-11 07:00:24 +00002061 if (getLangOpts().CPlusPlus0x && Tok.is(tok::ellipsis))
Peter Collingbournefe9b2a82011-10-24 17:56:00 +00002062 EllipsisLoc = ConsumeToken();
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00002063
2064 return ER;
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002065}
2066
2067/// ParseAlignmentSpecifier - Parse an alignment-specifier, and add the
2068/// attribute to Attrs.
2069///
2070/// alignment-specifier:
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00002071/// [C11] '_Alignas' '(' type-id ')'
2072/// [C11] '_Alignas' '(' constant-expression ')'
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00002073/// [C++0x] 'alignas' '(' type-id ...[opt] ')'
2074/// [C++0x] 'alignas' '(' assignment-expression ...[opt] ')'
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002075void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs,
2076 SourceLocation *endLoc) {
2077 assert((Tok.is(tok::kw_alignas) || Tok.is(tok::kw__Alignas)) &&
2078 "Not an alignment-specifier!");
2079
2080 SourceLocation KWLoc = Tok.getLocation();
2081 ConsumeToken();
2082
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002083 BalancedDelimiterTracker T(*this, tok::l_paren);
2084 if (T.expectAndConsume(diag::err_expected_lparen))
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002085 return;
2086
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00002087 SourceLocation EllipsisLoc;
2088 ExprResult ArgExpr = ParseAlignArgument(T.getOpenLocation(), EllipsisLoc);
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002089 if (ArgExpr.isInvalid()) {
2090 SkipUntil(tok::r_paren);
2091 return;
2092 }
2093
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002094 T.consumeClose();
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002095 if (endLoc)
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002096 *endLoc = T.getCloseLocation();
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002097
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00002098 // FIXME: Handle pack-expansions here.
2099 if (EllipsisLoc.isValid()) {
2100 Diag(EllipsisLoc, diag::err_alignas_pack_exp_unsupported);
2101 return;
2102 }
2103
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00002104 ExprVector ArgExprs;
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002105 ArgExprs.push_back(ArgExpr.release());
Sean Hunt8e083e72012-06-19 23:57:03 +00002106 // FIXME: This should not be GNU, but we since the attribute used is
2107 // based on the spelling, and there is no true spelling for
2108 // C++11 attributes, this isn't accepted.
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002109 Attrs.addNew(PP.getIdentifierInfo("aligned"), KWLoc, 0, KWLoc,
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00002110 0, T.getOpenLocation(), ArgExprs.data(), 1,
Sean Hunt8e083e72012-06-19 23:57:03 +00002111 AttributeList::AS_GNU);
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002112}
2113
Reid Spencer5f016e22007-07-11 17:01:13 +00002114/// ParseDeclarationSpecifiers
2115/// declaration-specifiers: [C99 6.7]
2116/// storage-class-specifier declaration-specifiers[opt]
2117/// type-specifier declaration-specifiers[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00002118/// [C99] function-specifier declaration-specifiers[opt]
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00002119/// [C11] alignment-specifier declaration-specifiers[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00002120/// [GNU] attributes declaration-specifiers[opt]
Douglas Gregor8d267c52011-09-09 02:06:17 +00002121/// [Clang] '__module_private__' declaration-specifiers[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00002122///
2123/// storage-class-specifier: [C99 6.7.1]
2124/// 'typedef'
2125/// 'extern'
2126/// 'static'
2127/// 'auto'
2128/// 'register'
Sebastian Redl669d5d72008-11-14 23:42:31 +00002129/// [C++] 'mutable'
Reid Spencer5f016e22007-07-11 17:01:13 +00002130/// [GNU] '__thread'
Reid Spencer5f016e22007-07-11 17:01:13 +00002131/// function-specifier: [C99 6.7.4]
2132/// [C99] 'inline'
Douglas Gregorb48fe382008-10-31 09:07:45 +00002133/// [C++] 'virtual'
2134/// [C++] 'explicit'
Peter Collingbournef315fa82011-02-14 01:42:53 +00002135/// [OpenCL] '__kernel'
Anders Carlssonf47f7a12009-05-06 04:46:28 +00002136/// 'friend': [C++ dcl.friend]
Sebastian Redl2ac67232009-11-05 15:47:02 +00002137/// 'constexpr': [C++0x dcl.constexpr]
Anders Carlssonf47f7a12009-05-06 04:46:28 +00002138
Reid Spencer5f016e22007-07-11 17:01:13 +00002139///
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002140void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
Douglas Gregor4d9a16f2009-05-12 23:25:50 +00002141 const ParsedTemplateInfo &TemplateInfo,
John McCall67d1a672009-08-06 02:15:43 +00002142 AccessSpecifier AS,
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +00002143 DeclSpecContext DSContext,
2144 LateParsedAttrList *LateAttrs) {
Douglas Gregor312eadb2011-04-24 05:37:28 +00002145 if (DS.getSourceRange().isInvalid()) {
2146 DS.SetRangeStart(Tok.getLocation());
2147 DS.SetRangeEnd(Tok.getLocation());
2148 }
Chad Rosier8decdee2012-06-26 22:30:43 +00002149
Douglas Gregorefaa93a2011-11-07 17:33:42 +00002150 bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level);
Sean Hunt2edf0a22012-06-23 05:07:58 +00002151 bool AttrsLastTime = false;
2152 ParsedAttributesWithRange attrs(AttrFactory);
Reid Spencer5f016e22007-07-11 17:01:13 +00002153 while (1) {
John McCallfec54012009-08-03 20:12:06 +00002154 bool isInvalid = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00002155 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00002156 unsigned DiagID = 0;
2157
Reid Spencer5f016e22007-07-11 17:01:13 +00002158 SourceLocation Loc = Tok.getLocation();
Douglas Gregor12e083c2008-11-07 15:42:26 +00002159
Reid Spencer5f016e22007-07-11 17:01:13 +00002160 switch (Tok.getKind()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002161 default:
Chris Lattnerbce61352008-07-26 00:20:22 +00002162 DoneWithDeclSpec:
Sean Hunt2edf0a22012-06-23 05:07:58 +00002163 if (!AttrsLastTime)
2164 ProhibitAttributes(attrs);
Michael Hanf64231e2012-11-06 19:34:54 +00002165 else {
2166 // Reject C++11 attributes that appertain to decl specifiers as
2167 // we don't support any C++11 attributes that appertain to decl
2168 // specifiers. This also conforms to what g++ 4.8 is doing.
2169 ProhibitCXX11Attributes(attrs);
2170
Sean Hunt2edf0a22012-06-23 05:07:58 +00002171 DS.takeAttributesFrom(attrs);
Michael Hanf64231e2012-11-06 19:34:54 +00002172 }
Peter Collingbournef1907682011-09-29 18:03:57 +00002173
Reid Spencer5f016e22007-07-11 17:01:13 +00002174 // If this is not a declaration specifier token, we're done reading decl
2175 // specifiers. First verify that DeclSpec's are consistent.
Douglas Gregor9b3064b2009-04-01 22:41:11 +00002176 DS.Finish(Diags, PP);
Reid Spencer5f016e22007-07-11 17:01:13 +00002177 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002178
Sean Hunt2edf0a22012-06-23 05:07:58 +00002179 case tok::l_square:
2180 case tok::kw_alignas:
2181 if (!isCXX11AttributeSpecifier())
2182 goto DoneWithDeclSpec;
2183
2184 ProhibitAttributes(attrs);
2185 // FIXME: It would be good to recover by accepting the attributes,
2186 // but attempting to do that now would cause serious
2187 // madness in terms of diagnostics.
2188 attrs.clear();
2189 attrs.Range = SourceRange();
2190
2191 ParseCXX11Attributes(attrs);
2192 AttrsLastTime = true;
Chad Rosier8decdee2012-06-26 22:30:43 +00002193 continue;
Sean Hunt2edf0a22012-06-23 05:07:58 +00002194
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002195 case tok::code_completion: {
John McCallf312b1e2010-08-26 23:41:50 +00002196 Sema::ParserCompletionContext CCC = Sema::PCC_Namespace;
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002197 if (DS.hasTypeSpecifier()) {
2198 bool AllowNonIdentifiers
2199 = (getCurScope()->getFlags() & (Scope::ControlScope |
2200 Scope::BlockScope |
2201 Scope::TemplateParamScope |
2202 Scope::FunctionPrototypeScope |
2203 Scope::AtCatchScope)) == 0;
2204 bool AllowNestedNameSpecifiers
Chad Rosier8decdee2012-06-26 22:30:43 +00002205 = DSContext == DSC_top_level ||
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002206 (DSContext == DSC_class && DS.isFriendSpecified());
2207
Douglas Gregorc7b6d882010-09-16 15:14:18 +00002208 Actions.CodeCompleteDeclSpec(getCurScope(), DS,
Chad Rosier8decdee2012-06-26 22:30:43 +00002209 AllowNonIdentifiers,
Douglas Gregorc7b6d882010-09-16 15:14:18 +00002210 AllowNestedNameSpecifiers);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00002211 return cutOffParsing();
Chad Rosier8decdee2012-06-26 22:30:43 +00002212 }
2213
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00002214 if (getCurScope()->getFnParent() || getCurScope()->getBlockParent())
2215 CCC = Sema::PCC_LocalDeclarationSpecifiers;
2216 else if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate)
Chad Rosier8decdee2012-06-26 22:30:43 +00002217 CCC = DSContext == DSC_class? Sema::PCC_MemberTemplate
John McCallf312b1e2010-08-26 23:41:50 +00002218 : Sema::PCC_Template;
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002219 else if (DSContext == DSC_class)
John McCallf312b1e2010-08-26 23:41:50 +00002220 CCC = Sema::PCC_Class;
Argyrios Kyrtzidis849639d2012-02-07 16:50:53 +00002221 else if (CurParsedObjCImpl)
John McCallf312b1e2010-08-26 23:41:50 +00002222 CCC = Sema::PCC_ObjCImplementation;
Chad Rosier8decdee2012-06-26 22:30:43 +00002223
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002224 Actions.CodeCompleteOrdinaryName(getCurScope(), CCC);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00002225 return cutOffParsing();
Douglas Gregor2ccccb32010-08-23 18:23:48 +00002226 }
2227
Chris Lattner5e02c472009-01-05 00:07:25 +00002228 case tok::coloncolon: // ::foo::bar
John McCall9ba61662010-02-26 08:45:28 +00002229 // C++ scope specifier. Annotate and loop, or bail out on error.
2230 if (TryAnnotateCXXScopeToken(true)) {
2231 if (!DS.hasTypeSpecifier())
2232 DS.SetTypeSpecError();
2233 goto DoneWithDeclSpec;
2234 }
John McCall2e0a7152010-03-01 18:20:46 +00002235 if (Tok.is(tok::coloncolon)) // ::new or ::delete
2236 goto DoneWithDeclSpec;
John McCall9ba61662010-02-26 08:45:28 +00002237 continue;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002238
2239 case tok::annot_cxxscope: {
Richard Smithf63eee72012-05-09 18:56:43 +00002240 if (DS.hasTypeSpecifier() || DS.isTypeAltiVecVector())
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002241 goto DoneWithDeclSpec;
2242
John McCallaa87d332009-12-12 11:40:51 +00002243 CXXScopeSpec SS;
Douglas Gregorc34348a2011-02-24 17:54:50 +00002244 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
2245 Tok.getAnnotationRange(),
2246 SS);
John McCallaa87d332009-12-12 11:40:51 +00002247
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002248 // We are looking for a qualified typename.
Douglas Gregor9135c722009-03-25 15:40:00 +00002249 Token Next = NextToken();
Mike Stump1eb44332009-09-09 15:08:12 +00002250 if (Next.is(tok::annot_template_id) &&
Douglas Gregor9135c722009-03-25 15:40:00 +00002251 static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue())
Douglas Gregorc45c2322009-03-31 00:43:58 +00002252 ->Kind == TNK_Type_template) {
Douglas Gregor9135c722009-03-25 15:40:00 +00002253 // We have a qualified template-id, e.g., N::A<int>
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002254
2255 // C++ [class.qual]p2:
2256 // In a lookup in which the constructor is an acceptable lookup
2257 // result and the nested-name-specifier nominates a class C:
2258 //
2259 // - if the name specified after the
2260 // nested-name-specifier, when looked up in C, is the
2261 // injected-class-name of C (Clause 9), or
2262 //
2263 // - if the name specified after the nested-name-specifier
2264 // is the same as the identifier or the
2265 // simple-template-id's template-name in the last
2266 // component of the nested-name-specifier,
2267 //
2268 // the name is instead considered to name the constructor of
2269 // class C.
Chad Rosier8decdee2012-06-26 22:30:43 +00002270 //
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002271 // Thus, if the template-name is actually the constructor
2272 // name, then the code is ill-formed; this interpretation is
Chad Rosier8decdee2012-06-26 22:30:43 +00002273 // reinforced by the NAD status of core issue 635.
Argyrios Kyrtzidis25a76762011-06-22 06:09:49 +00002274 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Next);
John McCallba9d8532010-04-13 06:39:49 +00002275 if ((DSContext == DSC_top_level ||
2276 (DSContext == DSC_class && DS.isFriendSpecified())) &&
2277 TemplateId->Name &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00002278 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002279 if (isConstructorDeclarator()) {
2280 // The user meant this to be an out-of-line constructor
2281 // definition, but template arguments are not allowed
2282 // there. Just allow this as a constructor; we'll
2283 // complain about it later.
2284 goto DoneWithDeclSpec;
2285 }
2286
2287 // The user meant this to name a type, but it actually names
2288 // a constructor with some extraneous template
2289 // arguments. Complain, then parse it as a type as the user
2290 // intended.
2291 Diag(TemplateId->TemplateNameLoc,
2292 diag::err_out_of_line_template_id_names_constructor)
2293 << TemplateId->Name;
2294 }
2295
John McCallaa87d332009-12-12 11:40:51 +00002296 DS.getTypeSpecScope() = SS;
2297 ConsumeToken(); // The C++ scope.
Mike Stump1eb44332009-09-09 15:08:12 +00002298 assert(Tok.is(tok::annot_template_id) &&
Douglas Gregor9135c722009-03-25 15:40:00 +00002299 "ParseOptionalCXXScopeSpecifier not working");
Douglas Gregor059101f2011-03-02 00:47:37 +00002300 AnnotateTemplateIdTokenAsType();
Douglas Gregor9135c722009-03-25 15:40:00 +00002301 continue;
2302 }
2303
Douglas Gregor9d7b3532009-09-28 07:26:33 +00002304 if (Next.is(tok::annot_typename)) {
John McCallaa87d332009-12-12 11:40:51 +00002305 DS.getTypeSpecScope() = SS;
2306 ConsumeToken(); // The C++ scope.
John McCallb3d87482010-08-24 05:47:05 +00002307 if (Tok.getAnnotationValue()) {
2308 ParsedType T = getTypeAnnotation(Tok);
Nico Weber253e80b2010-11-22 10:30:56 +00002309 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename,
Chad Rosier8decdee2012-06-26 22:30:43 +00002310 Tok.getAnnotationEndLoc(),
John McCallb3d87482010-08-24 05:47:05 +00002311 PrevSpec, DiagID, T);
Richard Smithb3cd3c02012-09-14 18:27:01 +00002312 if (isInvalid)
2313 break;
John McCallb3d87482010-08-24 05:47:05 +00002314 }
Douglas Gregor9d7b3532009-09-28 07:26:33 +00002315 else
2316 DS.SetTypeSpecError();
2317 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
2318 ConsumeToken(); // The typename
2319 }
2320
Douglas Gregor9135c722009-03-25 15:40:00 +00002321 if (Next.isNot(tok::identifier))
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002322 goto DoneWithDeclSpec;
2323
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002324 // If we're in a context where the identifier could be a class name,
2325 // check whether this is a constructor declaration.
John McCallba9d8532010-04-13 06:39:49 +00002326 if ((DSContext == DSC_top_level ||
2327 (DSContext == DSC_class && DS.isFriendSpecified())) &&
Chad Rosier8decdee2012-06-26 22:30:43 +00002328 Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(),
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002329 &SS)) {
2330 if (isConstructorDeclarator())
2331 goto DoneWithDeclSpec;
2332
2333 // As noted in C++ [class.qual]p2 (cited above), when the name
2334 // of the class is qualified in a context where it could name
2335 // a constructor, its a constructor name. However, we've
2336 // looked at the declarator, and the user probably meant this
2337 // to be a type. Complain that it isn't supposed to be treated
2338 // as a type, then proceed to parse it as a type.
2339 Diag(Next.getLocation(), diag::err_out_of_line_type_names_constructor)
2340 << Next.getIdentifierInfo();
2341 }
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002342
John McCallb3d87482010-08-24 05:47:05 +00002343 ParsedType TypeRep = Actions.getTypeName(*Next.getIdentifierInfo(),
2344 Next.getLocation(),
Douglas Gregor9e876872011-03-01 18:12:44 +00002345 getCurScope(), &SS,
2346 false, false, ParsedType(),
Abramo Bagnarafad03b72012-01-27 08:46:19 +00002347 /*IsCtorOrDtorName=*/false,
Douglas Gregor9e876872011-03-01 18:12:44 +00002348 /*NonTrivialSourceInfo=*/true);
Douglas Gregor55f6b142009-02-09 18:46:07 +00002349
Chris Lattnerf4382f52009-04-14 22:17:06 +00002350 // If the referenced identifier is not a type, then this declspec is
2351 // erroneous: We already checked about that it has no type specifier, and
2352 // C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the
Mike Stump1eb44332009-09-09 15:08:12 +00002353 // typename.
Chris Lattnerf4382f52009-04-14 22:17:06 +00002354 if (TypeRep == 0) {
2355 ConsumeToken(); // Eat the scope spec so the identifier is current.
Michael Han2e397132012-11-26 22:54:45 +00002356 ParsedAttributesWithRange Attrs(AttrFactory);
2357 if (ParseImplicitInt(DS, &SS, TemplateInfo, AS, DSContext, Attrs)) {
2358 if (!Attrs.empty()) {
2359 AttrsLastTime = true;
2360 attrs.takeAllFrom(Attrs);
2361 }
2362 continue;
2363 }
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002364 goto DoneWithDeclSpec;
Chris Lattnerf4382f52009-04-14 22:17:06 +00002365 }
Mike Stump1eb44332009-09-09 15:08:12 +00002366
John McCallaa87d332009-12-12 11:40:51 +00002367 DS.getTypeSpecScope() = SS;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002368 ConsumeToken(); // The C++ scope.
2369
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00002370 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00002371 DiagID, TypeRep);
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002372 if (isInvalid)
2373 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002374
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002375 DS.SetRangeEnd(Tok.getLocation());
2376 ConsumeToken(); // The typename.
2377
2378 continue;
2379 }
Mike Stump1eb44332009-09-09 15:08:12 +00002380
Chris Lattner80d0c892009-01-21 19:48:37 +00002381 case tok::annot_typename: {
John McCallb3d87482010-08-24 05:47:05 +00002382 if (Tok.getAnnotationValue()) {
2383 ParsedType T = getTypeAnnotation(Tok);
Nico Weberc43271e2010-11-22 12:50:03 +00002384 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCallb3d87482010-08-24 05:47:05 +00002385 DiagID, T);
2386 } else
Douglas Gregor31a19b62009-04-01 21:51:26 +00002387 DS.SetTypeSpecError();
Chad Rosier8decdee2012-06-26 22:30:43 +00002388
Chris Lattner5c5db552010-04-05 18:18:31 +00002389 if (isInvalid)
2390 break;
2391
Chris Lattner80d0c892009-01-21 19:48:37 +00002392 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
2393 ConsumeToken(); // The typename
Mike Stump1eb44332009-09-09 15:08:12 +00002394
Chris Lattner80d0c892009-01-21 19:48:37 +00002395 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
2396 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
Chad Rosier8decdee2012-06-26 22:30:43 +00002397 // Objective-C interface.
David Blaikie4e4d0842012-03-11 07:00:24 +00002398 if (Tok.is(tok::less) && getLangOpts().ObjC1)
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00002399 ParseObjCProtocolQualifiers(DS);
Chad Rosier8decdee2012-06-26 22:30:43 +00002400
Chris Lattner80d0c892009-01-21 19:48:37 +00002401 continue;
2402 }
Mike Stump1eb44332009-09-09 15:08:12 +00002403
Douglas Gregorbfad9152011-04-28 15:48:45 +00002404 case tok::kw___is_signed:
2405 // GNU libstdc++ 4.4 uses __is_signed as an identifier, but Clang
2406 // typically treats it as a trait. If we see __is_signed as it appears
2407 // in libstdc++, e.g.,
2408 //
2409 // static const bool __is_signed;
2410 //
2411 // then treat __is_signed as an identifier rather than as a keyword.
2412 if (DS.getTypeSpecType() == TST_bool &&
2413 DS.getTypeQualifiers() == DeclSpec::TQ_const &&
2414 DS.getStorageClassSpec() == DeclSpec::SCS_static) {
2415 Tok.getIdentifierInfo()->RevertTokenIDToIdentifier();
2416 Tok.setKind(tok::identifier);
2417 }
2418
2419 // We're done with the declaration-specifiers.
2420 goto DoneWithDeclSpec;
Chad Rosier8decdee2012-06-26 22:30:43 +00002421
Chris Lattner3bd934a2008-07-26 01:18:38 +00002422 // typedef-name
David Blaikie42d6d0c2011-12-04 05:04:18 +00002423 case tok::kw_decltype:
Chris Lattner3bd934a2008-07-26 01:18:38 +00002424 case tok::identifier: {
Chris Lattner5e02c472009-01-05 00:07:25 +00002425 // In C++, check to see if this is a scope specifier like foo::bar::, if
2426 // so handle it as such. This is important for ctor parsing.
David Blaikie4e4d0842012-03-11 07:00:24 +00002427 if (getLangOpts().CPlusPlus) {
John McCall9ba61662010-02-26 08:45:28 +00002428 if (TryAnnotateCXXScopeToken(true)) {
2429 if (!DS.hasTypeSpecifier())
2430 DS.SetTypeSpecError();
2431 goto DoneWithDeclSpec;
2432 }
2433 if (!Tok.is(tok::identifier))
2434 continue;
2435 }
Mike Stump1eb44332009-09-09 15:08:12 +00002436
Chris Lattner3bd934a2008-07-26 01:18:38 +00002437 // This identifier can only be a typedef name if we haven't already seen
2438 // a type-specifier. Without this check we misparse:
2439 // typedef int X; struct Y { short X; }; as 'short int'.
2440 if (DS.hasTypeSpecifier())
2441 goto DoneWithDeclSpec;
Mike Stump1eb44332009-09-09 15:08:12 +00002442
John Thompson82287d12010-02-05 00:12:22 +00002443 // Check for need to substitute AltiVec keyword tokens.
2444 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
2445 break;
2446
Richard Smithf63eee72012-05-09 18:56:43 +00002447 // [AltiVec] 2.2: [If the 'vector' specifier is used] The syntax does not
2448 // allow the use of a typedef name as a type specifier.
2449 if (DS.isTypeAltiVecVector())
2450 goto DoneWithDeclSpec;
2451
John McCallb3d87482010-08-24 05:47:05 +00002452 ParsedType TypeRep =
2453 Actions.getTypeName(*Tok.getIdentifierInfo(),
2454 Tok.getLocation(), getCurScope());
Douglas Gregor55f6b142009-02-09 18:46:07 +00002455
Chris Lattnerc199ab32009-04-12 20:42:31 +00002456 // If this is not a typedef name, don't parse it as part of the declspec,
2457 // it must be an implicit int or an error.
John McCallb3d87482010-08-24 05:47:05 +00002458 if (!TypeRep) {
Michael Han2e397132012-11-26 22:54:45 +00002459 ParsedAttributesWithRange Attrs(AttrFactory);
2460 if (ParseImplicitInt(DS, 0, TemplateInfo, AS, DSContext, Attrs)) {
2461 if (!Attrs.empty()) {
2462 AttrsLastTime = true;
2463 attrs.takeAllFrom(Attrs);
2464 }
2465 continue;
2466 }
Chris Lattner3bd934a2008-07-26 01:18:38 +00002467 goto DoneWithDeclSpec;
Chris Lattnerc199ab32009-04-12 20:42:31 +00002468 }
Douglas Gregor55f6b142009-02-09 18:46:07 +00002469
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002470 // If we're in a context where the identifier could be a class name,
2471 // check whether this is a constructor declaration.
David Blaikie4e4d0842012-03-11 07:00:24 +00002472 if (getLangOpts().CPlusPlus && DSContext == DSC_class &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00002473 Actions.isCurrentClassName(*Tok.getIdentifierInfo(), getCurScope()) &&
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002474 isConstructorDeclarator())
Douglas Gregorb48fe382008-10-31 09:07:45 +00002475 goto DoneWithDeclSpec;
2476
Douglas Gregor1a51b4a2009-02-09 15:09:02 +00002477 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00002478 DiagID, TypeRep);
Chris Lattner3bd934a2008-07-26 01:18:38 +00002479 if (isInvalid)
2480 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002481
Chris Lattner3bd934a2008-07-26 01:18:38 +00002482 DS.SetRangeEnd(Tok.getLocation());
2483 ConsumeToken(); // The identifier
2484
2485 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
2486 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
Chad Rosier8decdee2012-06-26 22:30:43 +00002487 // Objective-C interface.
David Blaikie4e4d0842012-03-11 07:00:24 +00002488 if (Tok.is(tok::less) && getLangOpts().ObjC1)
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00002489 ParseObjCProtocolQualifiers(DS);
Chad Rosier8decdee2012-06-26 22:30:43 +00002490
Steve Naroff4f9b9f12008-09-22 10:28:57 +00002491 // Need to support trailing type qualifiers (e.g. "id<p> const").
2492 // If a type specifier follows, it will be diagnosed elsewhere.
2493 continue;
Chris Lattner3bd934a2008-07-26 01:18:38 +00002494 }
Douglas Gregor39a8de12009-02-25 19:37:18 +00002495
2496 // type-name
2497 case tok::annot_template_id: {
Argyrios Kyrtzidis25a76762011-06-22 06:09:49 +00002498 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
Douglas Gregorc45c2322009-03-31 00:43:58 +00002499 if (TemplateId->Kind != TNK_Type_template) {
Douglas Gregor39a8de12009-02-25 19:37:18 +00002500 // This template-id does not refer to a type name, so we're
2501 // done with the type-specifiers.
2502 goto DoneWithDeclSpec;
2503 }
2504
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002505 // If we're in a context where the template-id could be a
2506 // constructor name or specialization, check whether this is a
2507 // constructor declaration.
David Blaikie4e4d0842012-03-11 07:00:24 +00002508 if (getLangOpts().CPlusPlus && DSContext == DSC_class &&
Douglas Gregor23c94db2010-07-02 17:43:08 +00002509 Actions.isCurrentClassName(*TemplateId->Name, getCurScope()) &&
Douglas Gregor0efc2c12010-01-13 17:31:36 +00002510 isConstructorDeclarator())
2511 goto DoneWithDeclSpec;
2512
Douglas Gregor39a8de12009-02-25 19:37:18 +00002513 // Turn the template-id annotation token into a type annotation
2514 // token, then try again to parse it as a type-specifier.
Douglas Gregor31a19b62009-04-01 21:51:26 +00002515 AnnotateTemplateIdTokenAsType();
Douglas Gregor39a8de12009-02-25 19:37:18 +00002516 continue;
2517 }
2518
Reid Spencer5f016e22007-07-11 17:01:13 +00002519 // GNU attributes support.
2520 case tok::kw___attribute:
DeLesley Hutchins2287c5e2012-03-02 22:12:59 +00002521 ParseGNUAttributes(DS.getAttributes(), 0, LateAttrs);
Reid Spencer5f016e22007-07-11 17:01:13 +00002522 continue;
Steve Narofff59e17e2008-12-24 20:59:21 +00002523
2524 // Microsoft declspec support.
2525 case tok::kw___declspec:
John McCall7f040a92010-12-24 02:08:15 +00002526 ParseMicrosoftDeclSpec(DS.getAttributes());
Steve Narofff59e17e2008-12-24 20:59:21 +00002527 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00002528
Steve Naroff239f0732008-12-25 14:16:32 +00002529 // Microsoft single token adornments.
Michael J. Spenceradc6cbf2012-06-18 07:00:48 +00002530 case tok::kw___forceinline: {
2531 isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec, DiagID);
2532 IdentifierInfo *AttrName = Tok.getIdentifierInfo();
Richard Smithb3cd3c02012-09-14 18:27:01 +00002533 SourceLocation AttrNameLoc = Tok.getLocation();
Sean Hunt93f95f22012-06-18 16:13:52 +00002534 // FIXME: This does not work correctly if it is set to be a declspec
2535 // attribute, and a GNU attribute is simply incorrect.
Michael J. Spenceradc6cbf2012-06-18 07:00:48 +00002536 DS.getAttributes().addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0,
Sean Hunt93f95f22012-06-18 16:13:52 +00002537 SourceLocation(), 0, 0, AttributeList::AS_GNU);
Richard Smithb3cd3c02012-09-14 18:27:01 +00002538 break;
Michael J. Spenceradc6cbf2012-06-18 07:00:48 +00002539 }
Eli Friedman290eeb02009-06-08 23:27:34 +00002540
2541 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00002542 case tok::kw___ptr32:
Steve Naroff86bc6cf2008-12-25 14:41:26 +00002543 case tok::kw___w64:
Steve Naroff239f0732008-12-25 14:16:32 +00002544 case tok::kw___cdecl:
2545 case tok::kw___stdcall:
2546 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00002547 case tok::kw___thiscall:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00002548 case tok::kw___unaligned:
John McCall7f040a92010-12-24 02:08:15 +00002549 ParseMicrosoftTypeAttributes(DS.getAttributes());
Eli Friedman290eeb02009-06-08 23:27:34 +00002550 continue;
2551
Dawn Perchik52fc3142010-09-03 01:29:35 +00002552 // Borland single token adornments.
2553 case tok::kw___pascal:
John McCall7f040a92010-12-24 02:08:15 +00002554 ParseBorlandTypeAttributes(DS.getAttributes());
Dawn Perchik52fc3142010-09-03 01:29:35 +00002555 continue;
2556
Peter Collingbournef315fa82011-02-14 01:42:53 +00002557 // OpenCL single token adornments.
2558 case tok::kw___kernel:
2559 ParseOpenCLAttributes(DS.getAttributes());
2560 continue;
2561
Reid Spencer5f016e22007-07-11 17:01:13 +00002562 // storage-class-specifier
2563 case tok::kw_typedef:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002564 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc,
2565 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002566 break;
2567 case tok::kw_extern:
2568 if (DS.isThreadSpecified())
Chris Lattner1ab3b962008-11-18 07:48:38 +00002569 Diag(Tok, diag::ext_thread_before) << "extern";
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002570 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_extern, Loc,
2571 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002572 break;
Steve Naroff8d54bf22007-12-18 00:16:02 +00002573 case tok::kw___private_extern__:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002574 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_private_extern,
2575 Loc, PrevSpec, DiagID);
Steve Naroff8d54bf22007-12-18 00:16:02 +00002576 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00002577 case tok::kw_static:
2578 if (DS.isThreadSpecified())
Chris Lattner1ab3b962008-11-18 07:48:38 +00002579 Diag(Tok, diag::ext_thread_before) << "static";
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002580 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_static, Loc,
2581 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002582 break;
2583 case tok::kw_auto:
David Blaikie4e4d0842012-03-11 07:00:24 +00002584 if (getLangOpts().CPlusPlus0x) {
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002585 if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) {
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002586 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
2587 PrevSpec, DiagID);
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002588 if (!isInvalid)
Richard Smith8f4fb192011-09-04 19:54:14 +00002589 Diag(Tok, diag::ext_auto_storage_class)
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002590 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
Richard Smith8f4fb192011-09-04 19:54:14 +00002591 } else
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002592 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec,
2593 DiagID);
Richard Smith8f4fb192011-09-04 19:54:14 +00002594 } else
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002595 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
2596 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002597 break;
2598 case tok::kw_register:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002599 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_register, Loc,
2600 PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002601 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +00002602 case tok::kw_mutable:
Peter Collingbourneb8b0e752011-10-06 03:01:00 +00002603 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_mutable, Loc,
2604 PrevSpec, DiagID);
Sebastian Redl669d5d72008-11-14 23:42:31 +00002605 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00002606 case tok::kw___thread:
John McCallfec54012009-08-03 20:12:06 +00002607 isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002608 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002609
Reid Spencer5f016e22007-07-11 17:01:13 +00002610 // function-specifier
2611 case tok::kw_inline:
John McCallfec54012009-08-03 20:12:06 +00002612 isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec, DiagID);
Reid Spencer5f016e22007-07-11 17:01:13 +00002613 break;
Douglas Gregorb48fe382008-10-31 09:07:45 +00002614 case tok::kw_virtual:
John McCallfec54012009-08-03 20:12:06 +00002615 isInvalid = DS.SetFunctionSpecVirtual(Loc, PrevSpec, DiagID);
Douglas Gregorb48fe382008-10-31 09:07:45 +00002616 break;
Douglas Gregorb48fe382008-10-31 09:07:45 +00002617 case tok::kw_explicit:
John McCallfec54012009-08-03 20:12:06 +00002618 isInvalid = DS.SetFunctionSpecExplicit(Loc, PrevSpec, DiagID);
Douglas Gregorb48fe382008-10-31 09:07:45 +00002619 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002620
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002621 // alignment-specifier
2622 case tok::kw__Alignas:
David Blaikie4e4d0842012-03-11 07:00:24 +00002623 if (!getLangOpts().C11)
Jordan Rosef70a8862012-06-30 21:33:57 +00002624 Diag(Tok, diag::ext_c11_alignment) << Tok.getName();
Peter Collingbourne82d0b0a2011-09-29 18:04:28 +00002625 ParseAlignmentSpecifier(DS.getAttributes());
2626 continue;
2627
Anders Carlssonf47f7a12009-05-06 04:46:28 +00002628 // friend
2629 case tok::kw_friend:
John McCall67d1a672009-08-06 02:15:43 +00002630 if (DSContext == DSC_class)
2631 isInvalid = DS.SetFriendSpec(Loc, PrevSpec, DiagID);
2632 else {
2633 PrevSpec = ""; // not actually used by the diagnostic
2634 DiagID = diag::err_friend_invalid_in_context;
2635 isInvalid = true;
2636 }
Anders Carlssonf47f7a12009-05-06 04:46:28 +00002637 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002638
Douglas Gregor8d267c52011-09-09 02:06:17 +00002639 // Modules
2640 case tok::kw___module_private__:
2641 isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID);
2642 break;
Chad Rosier8decdee2012-06-26 22:30:43 +00002643
Sebastian Redl2ac67232009-11-05 15:47:02 +00002644 // constexpr
2645 case tok::kw_constexpr:
2646 isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID);
2647 break;
2648
Chris Lattner80d0c892009-01-21 19:48:37 +00002649 // type-specifier
2650 case tok::kw_short:
John McCallfec54012009-08-03 20:12:06 +00002651 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec,
2652 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002653 break;
2654 case tok::kw_long:
2655 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
John McCallfec54012009-08-03 20:12:06 +00002656 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
2657 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002658 else
John McCallfec54012009-08-03 20:12:06 +00002659 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2660 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002661 break;
Francois Pichet338d7f72011-04-28 01:59:37 +00002662 case tok::kw___int64:
2663 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
2664 DiagID);
2665 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002666 case tok::kw_signed:
John McCallfec54012009-08-03 20:12:06 +00002667 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec,
2668 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002669 break;
2670 case tok::kw_unsigned:
John McCallfec54012009-08-03 20:12:06 +00002671 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec,
2672 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002673 break;
2674 case tok::kw__Complex:
John McCallfec54012009-08-03 20:12:06 +00002675 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec,
2676 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002677 break;
2678 case tok::kw__Imaginary:
John McCallfec54012009-08-03 20:12:06 +00002679 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec,
2680 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002681 break;
2682 case tok::kw_void:
John McCallfec54012009-08-03 20:12:06 +00002683 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec,
2684 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002685 break;
2686 case tok::kw_char:
John McCallfec54012009-08-03 20:12:06 +00002687 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec,
2688 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002689 break;
2690 case tok::kw_int:
John McCallfec54012009-08-03 20:12:06 +00002691 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec,
2692 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002693 break;
Richard Smith5a5a9712012-04-04 06:24:32 +00002694 case tok::kw___int128:
2695 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec,
2696 DiagID);
2697 break;
2698 case tok::kw_half:
2699 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec,
2700 DiagID);
2701 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002702 case tok::kw_float:
John McCallfec54012009-08-03 20:12:06 +00002703 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
2704 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002705 break;
2706 case tok::kw_double:
John McCallfec54012009-08-03 20:12:06 +00002707 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
2708 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002709 break;
2710 case tok::kw_wchar_t:
John McCallfec54012009-08-03 20:12:06 +00002711 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
2712 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002713 break;
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002714 case tok::kw_char16_t:
John McCallfec54012009-08-03 20:12:06 +00002715 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec,
2716 DiagID);
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002717 break;
2718 case tok::kw_char32_t:
John McCallfec54012009-08-03 20:12:06 +00002719 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec,
2720 DiagID);
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002721 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002722 case tok::kw_bool:
2723 case tok::kw__Bool:
Argyrios Kyrtzidis4383e182010-11-16 18:18:13 +00002724 if (Tok.is(tok::kw_bool) &&
2725 DS.getTypeSpecType() != DeclSpec::TST_unspecified &&
2726 DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
2727 PrevSpec = ""; // Not used by the diagnostic.
2728 DiagID = diag::err_bool_redeclaration;
Fariborz Jahaniane106a0b2011-04-19 21:42:37 +00002729 // For better error recovery.
2730 Tok.setKind(tok::identifier);
Argyrios Kyrtzidis4383e182010-11-16 18:18:13 +00002731 isInvalid = true;
2732 } else {
2733 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec,
2734 DiagID);
2735 }
Chris Lattner80d0c892009-01-21 19:48:37 +00002736 break;
2737 case tok::kw__Decimal32:
John McCallfec54012009-08-03 20:12:06 +00002738 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
2739 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002740 break;
2741 case tok::kw__Decimal64:
John McCallfec54012009-08-03 20:12:06 +00002742 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
2743 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002744 break;
2745 case tok::kw__Decimal128:
John McCallfec54012009-08-03 20:12:06 +00002746 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
2747 DiagID);
Chris Lattner80d0c892009-01-21 19:48:37 +00002748 break;
John Thompson82287d12010-02-05 00:12:22 +00002749 case tok::kw___vector:
2750 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
2751 break;
2752 case tok::kw___pixel:
2753 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
2754 break;
John McCalla5fc4722011-04-09 22:50:59 +00002755 case tok::kw___unknown_anytype:
2756 isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc,
2757 PrevSpec, DiagID);
2758 break;
Chris Lattner80d0c892009-01-21 19:48:37 +00002759
2760 // class-specifier:
2761 case tok::kw_class:
2762 case tok::kw_struct:
Joao Matos6666ed42012-08-31 18:45:21 +00002763 case tok::kw___interface:
Chris Lattner4c97d762009-04-12 21:49:30 +00002764 case tok::kw_union: {
2765 tok::TokenKind Kind = Tok.getKind();
2766 ConsumeToken();
Michael Han2e397132012-11-26 22:54:45 +00002767
2768 // These are attributes following class specifiers.
2769 // To produce better diagnostic, we parse them when
2770 // parsing class specifier.
2771 ParsedAttributesWithRange Attributes(AttrFactory);
Richard Smith69730c12012-03-12 07:56:15 +00002772 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS,
Michael Han2e397132012-11-26 22:54:45 +00002773 EnteringContext, DSContext, Attributes);
2774
2775 // If there are attributes following class specifier,
2776 // take them over and handle them here.
2777 if (!Attributes.empty()) {
2778 AttrsLastTime = true;
2779 attrs.takeAllFrom(Attributes);
2780 }
Chris Lattner80d0c892009-01-21 19:48:37 +00002781 continue;
Chris Lattner4c97d762009-04-12 21:49:30 +00002782 }
Chris Lattner80d0c892009-01-21 19:48:37 +00002783
2784 // enum-specifier:
2785 case tok::kw_enum:
Chris Lattner4c97d762009-04-12 21:49:30 +00002786 ConsumeToken();
Richard Smith69730c12012-03-12 07:56:15 +00002787 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS, DSContext);
Chris Lattner80d0c892009-01-21 19:48:37 +00002788 continue;
2789
2790 // cv-qualifier:
2791 case tok::kw_const:
John McCallfec54012009-08-03 20:12:06 +00002792 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID,
Richard Smithd654f2d2012-10-17 23:31:46 +00002793 getLangOpts());
Chris Lattner80d0c892009-01-21 19:48:37 +00002794 break;
2795 case tok::kw_volatile:
John McCallfec54012009-08-03 20:12:06 +00002796 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
Richard Smithd654f2d2012-10-17 23:31:46 +00002797 getLangOpts());
Chris Lattner80d0c892009-01-21 19:48:37 +00002798 break;
2799 case tok::kw_restrict:
John McCallfec54012009-08-03 20:12:06 +00002800 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
Richard Smithd654f2d2012-10-17 23:31:46 +00002801 getLangOpts());
Chris Lattner80d0c892009-01-21 19:48:37 +00002802 break;
2803
Douglas Gregord57959a2009-03-27 23:10:48 +00002804 // C++ typename-specifier:
2805 case tok::kw_typename:
John McCall9ba61662010-02-26 08:45:28 +00002806 if (TryAnnotateTypeOrScopeToken()) {
2807 DS.SetTypeSpecError();
2808 goto DoneWithDeclSpec;
2809 }
2810 if (!Tok.is(tok::kw_typename))
Douglas Gregord57959a2009-03-27 23:10:48 +00002811 continue;
2812 break;
2813
Chris Lattner80d0c892009-01-21 19:48:37 +00002814 // GNU typeof support.
2815 case tok::kw_typeof:
2816 ParseTypeofSpecifier(DS);
2817 continue;
2818
David Blaikie42d6d0c2011-12-04 05:04:18 +00002819 case tok::annot_decltype:
Anders Carlsson6fd634f2009-06-24 17:47:40 +00002820 ParseDecltypeSpecifier(DS);
2821 continue;
2822
Sean Huntdb5d44b2011-05-19 05:37:45 +00002823 case tok::kw___underlying_type:
2824 ParseUnderlyingTypeSpecifier(DS);
Eli Friedmanb001de72011-10-06 23:00:33 +00002825 continue;
2826
2827 case tok::kw__Atomic:
2828 ParseAtomicSpecifier(DS);
2829 continue;
Sean Huntdb5d44b2011-05-19 05:37:45 +00002830
Peter Collingbourne207f4d82011-03-18 22:38:29 +00002831 // OpenCL qualifiers:
Chad Rosier8decdee2012-06-26 22:30:43 +00002832 case tok::kw_private:
David Blaikie4e4d0842012-03-11 07:00:24 +00002833 if (!getLangOpts().OpenCL)
Peter Collingbourne207f4d82011-03-18 22:38:29 +00002834 goto DoneWithDeclSpec;
2835 case tok::kw___private:
2836 case tok::kw___global:
2837 case tok::kw___local:
2838 case tok::kw___constant:
2839 case tok::kw___read_only:
2840 case tok::kw___write_only:
2841 case tok::kw___read_write:
2842 ParseOpenCLQualifiers(DS);
2843 break;
Chad Rosier8decdee2012-06-26 22:30:43 +00002844
Steve Naroffd3ded1f2008-06-05 00:02:44 +00002845 case tok::less:
Chris Lattner3bd934a2008-07-26 01:18:38 +00002846 // GCC ObjC supports types like "<SomeProtocol>" as a synonym for
Chris Lattnerbce61352008-07-26 00:20:22 +00002847 // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous,
2848 // but we support it.
David Blaikie4e4d0842012-03-11 07:00:24 +00002849 if (DS.hasTypeSpecifier() || !getLangOpts().ObjC1)
Chris Lattnerbce61352008-07-26 00:20:22 +00002850 goto DoneWithDeclSpec;
Mike Stump1eb44332009-09-09 15:08:12 +00002851
Douglas Gregor46f936e2010-11-19 17:10:50 +00002852 if (!ParseObjCProtocolQualifiers(DS))
2853 Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id)
2854 << FixItHint::CreateInsertion(Loc, "id")
2855 << SourceRange(Loc, DS.getSourceRange().getEnd());
Chad Rosier8decdee2012-06-26 22:30:43 +00002856
Douglas Gregor9bd1d8d2010-10-21 23:17:00 +00002857 // Need to support trailing type qualifiers (e.g. "id<p> const").
2858 // If a type specifier follows, it will be diagnosed elsewhere.
2859 continue;
Reid Spencer5f016e22007-07-11 17:01:13 +00002860 }
John McCallfec54012009-08-03 20:12:06 +00002861 // If the specifier wasn't legal, issue a diagnostic.
Reid Spencer5f016e22007-07-11 17:01:13 +00002862 if (isInvalid) {
2863 assert(PrevSpec && "Method did not return previous specifier!");
John McCallfec54012009-08-03 20:12:06 +00002864 assert(DiagID);
Chad Rosier8decdee2012-06-26 22:30:43 +00002865
Douglas Gregorae2fb142010-08-23 14:34:43 +00002866 if (DiagID == diag::ext_duplicate_declspec)
2867 Diag(Tok, DiagID)
2868 << PrevSpec << FixItHint::CreateRemoval(Tok.getLocation());
2869 else
2870 Diag(Tok, DiagID) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00002871 }
Fariborz Jahanian12e3ece2011-02-22 23:17:49 +00002872
Chris Lattner81c018d2008-03-13 06:29:04 +00002873 DS.SetRangeEnd(Tok.getLocation());
Fariborz Jahaniane106a0b2011-04-19 21:42:37 +00002874 if (DiagID != diag::err_bool_redeclaration)
2875 ConsumeToken();
Sean Hunt2edf0a22012-06-23 05:07:58 +00002876
2877 AttrsLastTime = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00002878 }
2879}
Douglas Gregoradcac882008-12-01 23:54:00 +00002880
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002881/// ParseStructDeclaration - Parse a struct declaration without the terminating
2882/// semicolon.
2883///
Reid Spencer5f016e22007-07-11 17:01:13 +00002884/// struct-declaration:
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002885/// specifier-qualifier-list struct-declarator-list
Reid Spencer5f016e22007-07-11 17:01:13 +00002886/// [GNU] __extension__ struct-declaration
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002887/// [GNU] specifier-qualifier-list
Reid Spencer5f016e22007-07-11 17:01:13 +00002888/// struct-declarator-list:
2889/// struct-declarator
2890/// struct-declarator-list ',' struct-declarator
2891/// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator
2892/// struct-declarator:
2893/// declarator
2894/// [GNU] declarator attributes[opt]
2895/// declarator[opt] ':' constant-expression
2896/// [GNU] declarator[opt] ':' constant-expression attributes[opt]
2897///
Chris Lattnere1359422008-04-10 06:46:29 +00002898void Parser::
Eli Friedmanf66a0dd2012-08-08 23:04:35 +00002899ParseStructDeclaration(ParsingDeclSpec &DS, FieldCallback &Fields) {
Chad Rosier8decdee2012-06-26 22:30:43 +00002900
Chris Lattnerc46d1a12008-10-20 06:45:43 +00002901 if (Tok.is(tok::kw___extension__)) {
2902 // __extension__ silences extension warnings in the subexpression.
2903 ExtensionRAIIObject O(Diags); // Use RAII to do this.
Steve Naroff28a7ca82007-08-20 22:28:22 +00002904 ConsumeToken();
Chris Lattnerc46d1a12008-10-20 06:45:43 +00002905 return ParseStructDeclaration(DS, Fields);
2906 }
Mike Stump1eb44332009-09-09 15:08:12 +00002907
Steve Naroff28a7ca82007-08-20 22:28:22 +00002908 // Parse the common specifier-qualifiers-list piece.
Steve Naroff28a7ca82007-08-20 22:28:22 +00002909 ParseSpecifierQualifierList(DS);
Mike Stump1eb44332009-09-09 15:08:12 +00002910
Douglas Gregor4920f1f2009-01-12 22:49:06 +00002911 // If there are no declarators, this is a free-standing declaration
2912 // specifier. Let the actions module cope with it.
Chris Lattner04d66662007-10-09 17:33:22 +00002913 if (Tok.is(tok::semi)) {
Eli Friedmanf66a0dd2012-08-08 23:04:35 +00002914 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
2915 DS);
2916 DS.complete(TheDecl);
Steve Naroff28a7ca82007-08-20 22:28:22 +00002917 return;
2918 }
2919
2920 // Read struct-declarators until we find the semicolon.
John McCallbdd563e2009-11-03 02:38:08 +00002921 bool FirstDeclarator = true;
Richard Smith7984de32012-01-12 23:53:29 +00002922 SourceLocation CommaLoc;
Steve Naroff28a7ca82007-08-20 22:28:22 +00002923 while (1) {
Eli Friedmanf66a0dd2012-08-08 23:04:35 +00002924 ParsingFieldDeclarator DeclaratorInfo(*this, DS);
Richard Smith7984de32012-01-12 23:53:29 +00002925 DeclaratorInfo.D.setCommaLoc(CommaLoc);
John McCallbdd563e2009-11-03 02:38:08 +00002926
2927 // Attributes are only allowed here on successive declarators.
John McCall7f040a92010-12-24 02:08:15 +00002928 if (!FirstDeclarator)
2929 MaybeParseGNUAttributes(DeclaratorInfo.D);
Mike Stump1eb44332009-09-09 15:08:12 +00002930
Steve Naroff28a7ca82007-08-20 22:28:22 +00002931 /// struct-declarator: declarator
2932 /// struct-declarator: declarator[opt] ':' constant-expression
Chris Lattnera1efc8c2009-12-10 01:59:24 +00002933 if (Tok.isNot(tok::colon)) {
2934 // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
2935 ColonProtectionRAIIObject X(*this);
Chris Lattnere1359422008-04-10 06:46:29 +00002936 ParseDeclarator(DeclaratorInfo.D);
Chris Lattnera1efc8c2009-12-10 01:59:24 +00002937 }
Mike Stump1eb44332009-09-09 15:08:12 +00002938
Chris Lattner04d66662007-10-09 17:33:22 +00002939 if (Tok.is(tok::colon)) {
Steve Naroff28a7ca82007-08-20 22:28:22 +00002940 ConsumeToken();
John McCall60d7b3a2010-08-24 06:29:42 +00002941 ExprResult Res(ParseConstantExpression());
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00002942 if (Res.isInvalid())
Steve Naroff28a7ca82007-08-20 22:28:22 +00002943 SkipUntil(tok::semi, true, true);
Chris Lattner60b1e3e2008-04-10 06:15:14 +00002944 else
Sebastian Redleffa8d12008-12-10 00:02:53 +00002945 DeclaratorInfo.BitfieldSize = Res.release();
Steve Naroff28a7ca82007-08-20 22:28:22 +00002946 }
Sebastian Redlab197ba2009-02-09 18:23:29 +00002947
Steve Naroff28a7ca82007-08-20 22:28:22 +00002948 // If attributes exist after the declarator, parse them.
John McCall7f040a92010-12-24 02:08:15 +00002949 MaybeParseGNUAttributes(DeclaratorInfo.D);
Sebastian Redlab197ba2009-02-09 18:23:29 +00002950
John McCallbdd563e2009-11-03 02:38:08 +00002951 // We're done with this declarator; invoke the callback.
Eli Friedman817a8862012-08-08 23:35:12 +00002952 Fields.invoke(DeclaratorInfo);
John McCallbdd563e2009-11-03 02:38:08 +00002953
Steve Naroff28a7ca82007-08-20 22:28:22 +00002954 // If we don't have a comma, it is either the end of the list (a ';')
2955 // or an error, bail out.
Chris Lattner04d66662007-10-09 17:33:22 +00002956 if (Tok.isNot(tok::comma))
Chris Lattnercd4b83c2007-10-29 04:42:53 +00002957 return;
Sebastian Redlab197ba2009-02-09 18:23:29 +00002958
Steve Naroff28a7ca82007-08-20 22:28:22 +00002959 // Consume the comma.
Richard Smith7984de32012-01-12 23:53:29 +00002960 CommaLoc = ConsumeToken();
Sebastian Redlab197ba2009-02-09 18:23:29 +00002961
John McCallbdd563e2009-11-03 02:38:08 +00002962 FirstDeclarator = false;
Steve Naroff28a7ca82007-08-20 22:28:22 +00002963 }
Steve Naroff28a7ca82007-08-20 22:28:22 +00002964}
2965
2966/// ParseStructUnionBody
2967/// struct-contents:
2968/// struct-declaration-list
2969/// [EXT] empty
2970/// [GNU] "struct-declaration-list" without terminatoring ';'
2971/// struct-declaration-list:
2972/// struct-declaration
2973/// struct-declaration-list struct-declaration
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00002974/// [OBC] '@' 'defs' '(' class-name ')'
Steve Naroff28a7ca82007-08-20 22:28:22 +00002975///
Reid Spencer5f016e22007-07-11 17:01:13 +00002976void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
John McCalld226f652010-08-21 09:40:31 +00002977 unsigned TagType, Decl *TagDecl) {
John McCallf312b1e2010-08-26 23:41:50 +00002978 PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc,
2979 "parsing struct/union body");
Mike Stump1eb44332009-09-09 15:08:12 +00002980
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00002981 BalancedDelimiterTracker T(*this, tok::l_brace);
2982 if (T.consumeOpen())
2983 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002984
Douglas Gregor3218c4b2009-01-09 22:42:13 +00002985 ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
Douglas Gregor23c94db2010-07-02 17:43:08 +00002986 Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
Douglas Gregor72de6672009-01-08 20:45:30 +00002987
Reid Spencer5f016e22007-07-11 17:01:13 +00002988 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in
2989 // C++.
David Blaikie4e4d0842012-03-11 07:00:24 +00002990 if (Tok.is(tok::r_brace) && !getLangOpts().CPlusPlus) {
Richard Smithd7c56e12011-12-29 21:57:33 +00002991 Diag(Tok, diag::ext_empty_struct_union) << (TagType == TST_union);
2992 Diag(Tok, diag::warn_empty_struct_union_compat) << (TagType == TST_union);
2993 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002994
Chris Lattner5f9e2722011-07-23 10:55:15 +00002995 SmallVector<Decl *, 32> FieldDecls;
Chris Lattnere1359422008-04-10 06:46:29 +00002996
Reid Spencer5f016e22007-07-11 17:01:13 +00002997 // While we still have something to read, read the declarations in the struct.
Chris Lattner04d66662007-10-09 17:33:22 +00002998 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00002999 // Each iteration of this loop reads one struct-declaration.
Mike Stump1eb44332009-09-09 15:08:12 +00003000
Reid Spencer5f016e22007-07-11 17:01:13 +00003001 // Check for extraneous top-level semicolon.
Chris Lattner04d66662007-10-09 17:33:22 +00003002 if (Tok.is(tok::semi)) {
Richard Smitheab9d6f2012-07-23 05:45:25 +00003003 ConsumeExtraSemi(InsideStruct, TagType);
Reid Spencer5f016e22007-07-11 17:01:13 +00003004 continue;
3005 }
Chris Lattnere1359422008-04-10 06:46:29 +00003006
John McCallbdd563e2009-11-03 02:38:08 +00003007 if (!Tok.is(tok::at)) {
3008 struct CFieldCallback : FieldCallback {
3009 Parser &P;
John McCalld226f652010-08-21 09:40:31 +00003010 Decl *TagDecl;
Chris Lattner5f9e2722011-07-23 10:55:15 +00003011 SmallVectorImpl<Decl *> &FieldDecls;
John McCallbdd563e2009-11-03 02:38:08 +00003012
John McCalld226f652010-08-21 09:40:31 +00003013 CFieldCallback(Parser &P, Decl *TagDecl,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003014 SmallVectorImpl<Decl *> &FieldDecls) :
John McCallbdd563e2009-11-03 02:38:08 +00003015 P(P), TagDecl(TagDecl), FieldDecls(FieldDecls) {}
3016
Eli Friedmandcdff462012-08-08 23:53:27 +00003017 void invoke(ParsingFieldDeclarator &FD) {
John McCallbdd563e2009-11-03 02:38:08 +00003018 // Install the declarator into the current TagDecl.
John McCalld226f652010-08-21 09:40:31 +00003019 Decl *Field = P.Actions.ActOnField(P.getCurScope(), TagDecl,
John McCall4ba39712009-11-03 21:13:47 +00003020 FD.D.getDeclSpec().getSourceRange().getBegin(),
3021 FD.D, FD.BitfieldSize);
John McCallbdd563e2009-11-03 02:38:08 +00003022 FieldDecls.push_back(Field);
Eli Friedmanf66a0dd2012-08-08 23:04:35 +00003023 FD.complete(Field);
Douglas Gregor91a28862009-08-26 14:27:30 +00003024 }
John McCallbdd563e2009-11-03 02:38:08 +00003025 } Callback(*this, TagDecl, FieldDecls);
3026
Eli Friedmanf66a0dd2012-08-08 23:04:35 +00003027 // Parse all the comma separated declarators.
3028 ParsingDeclSpec DS(*this);
John McCallbdd563e2009-11-03 02:38:08 +00003029 ParseStructDeclaration(DS, Callback);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00003030 } else { // Handle @defs
3031 ConsumeToken();
3032 if (!Tok.isObjCAtKeyword(tok::objc_defs)) {
3033 Diag(Tok, diag::err_unexpected_at);
Chris Lattner3e156ad2010-02-02 00:37:27 +00003034 SkipUntil(tok::semi, true);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00003035 continue;
3036 }
3037 ConsumeToken();
3038 ExpectAndConsume(tok::l_paren, diag::err_expected_lparen);
3039 if (!Tok.is(tok::identifier)) {
3040 Diag(Tok, diag::err_expected_ident);
Chris Lattner3e156ad2010-02-02 00:37:27 +00003041 SkipUntil(tok::semi, true);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00003042 continue;
3043 }
Chris Lattner5f9e2722011-07-23 10:55:15 +00003044 SmallVector<Decl *, 16> Fields;
Douglas Gregor23c94db2010-07-02 17:43:08 +00003045 Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(),
Douglas Gregor44b43212008-12-11 16:49:14 +00003046 Tok.getIdentifierInfo(), Fields);
Chris Lattner5a6ddbf2008-06-21 19:39:06 +00003047 FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end());
3048 ConsumeToken();
3049 ExpectAndConsume(tok::r_paren, diag::err_expected_rparen);
Mike Stump1eb44332009-09-09 15:08:12 +00003050 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003051
Chris Lattner04d66662007-10-09 17:33:22 +00003052 if (Tok.is(tok::semi)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003053 ConsumeToken();
Chris Lattner04d66662007-10-09 17:33:22 +00003054 } else if (Tok.is(tok::r_brace)) {
Chris Lattner3e156ad2010-02-02 00:37:27 +00003055 ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list);
Reid Spencer5f016e22007-07-11 17:01:13 +00003056 break;
3057 } else {
Chris Lattner3e156ad2010-02-02 00:37:27 +00003058 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
3059 // Skip to end of block or statement to avoid ext-warning on extra ';'.
Reid Spencer5f016e22007-07-11 17:01:13 +00003060 SkipUntil(tok::r_brace, true, true);
Chris Lattner3e156ad2010-02-02 00:37:27 +00003061 // If we stopped at a ';', eat it.
3062 if (Tok.is(tok::semi)) ConsumeToken();
Reid Spencer5f016e22007-07-11 17:01:13 +00003063 }
3064 }
Mike Stump1eb44332009-09-09 15:08:12 +00003065
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003066 T.consumeClose();
Mike Stump1eb44332009-09-09 15:08:12 +00003067
John McCall0b7e6782011-03-24 11:26:52 +00003068 ParsedAttributes attrs(AttrFactory);
Reid Spencer5f016e22007-07-11 17:01:13 +00003069 // If attributes exist after struct contents, parse them.
John McCall7f040a92010-12-24 02:08:15 +00003070 MaybeParseGNUAttributes(attrs);
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +00003071
Douglas Gregor23c94db2010-07-02 17:43:08 +00003072 Actions.ActOnFields(getCurScope(),
David Blaikie77b6de02011-09-22 02:58:26 +00003073 RecordLoc, TagDecl, FieldDecls,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003074 T.getOpenLocation(), T.getCloseLocation(),
John McCall7f040a92010-12-24 02:08:15 +00003075 attrs.getList());
Douglas Gregor72de6672009-01-08 20:45:30 +00003076 StructScope.Exit();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003077 Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl,
3078 T.getCloseLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00003079}
3080
Reid Spencer5f016e22007-07-11 17:01:13 +00003081/// ParseEnumSpecifier
3082/// enum-specifier: [C99 6.7.2.2]
3083/// 'enum' identifier[opt] '{' enumerator-list '}'
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003084///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
Reid Spencer5f016e22007-07-11 17:01:13 +00003085/// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
3086/// '}' attributes[opt]
Aaron Ballman6454a022012-03-01 04:09:28 +00003087/// [MS] 'enum' __declspec[opt] identifier[opt] '{' enumerator-list ',' [opt]
3088/// '}'
Reid Spencer5f016e22007-07-11 17:01:13 +00003089/// 'enum' identifier
3090/// [GNU] 'enum' attributes[opt] identifier
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003091///
Richard Smith1af83c42012-03-23 03:33:32 +00003092/// [C++11] enum-head '{' enumerator-list[opt] '}'
3093/// [C++11] enum-head '{' enumerator-list ',' '}'
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003094///
Richard Smith1af83c42012-03-23 03:33:32 +00003095/// enum-head: [C++11]
3096/// enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]
3097/// enum-key attribute-specifier-seq[opt] nested-name-specifier
3098/// identifier enum-base[opt]
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003099///
Richard Smith1af83c42012-03-23 03:33:32 +00003100/// enum-key: [C++11]
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003101/// 'enum'
3102/// 'enum' 'class'
3103/// 'enum' 'struct'
3104///
Richard Smith1af83c42012-03-23 03:33:32 +00003105/// enum-base: [C++11]
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003106/// ':' type-specifier-seq
3107///
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003108/// [C++] elaborated-type-specifier:
3109/// [C++] 'enum' '::'[opt] nested-name-specifier[opt] identifier
3110///
Chris Lattner4c97d762009-04-12 21:49:30 +00003111void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
Douglas Gregor9b9edd62010-03-02 17:53:14 +00003112 const ParsedTemplateInfo &TemplateInfo,
Richard Smith69730c12012-03-12 07:56:15 +00003113 AccessSpecifier AS, DeclSpecContext DSC) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003114 // Parse the tag portion of this.
Douglas Gregor374929f2009-09-18 15:37:17 +00003115 if (Tok.is(tok::code_completion)) {
3116 // Code completion for an enum name.
Douglas Gregor23c94db2010-07-02 17:43:08 +00003117 Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00003118 return cutOffParsing();
Douglas Gregor374929f2009-09-18 15:37:17 +00003119 }
John McCall57c13002011-07-06 05:58:41 +00003120
Sean Hunt2edf0a22012-06-23 05:07:58 +00003121 // If attributes exist after tag, parse them.
3122 ParsedAttributesWithRange attrs(AttrFactory);
3123 MaybeParseGNUAttributes(attrs);
3124 MaybeParseCXX0XAttributes(attrs);
3125
3126 // If declspecs exist after tag, parse them.
3127 while (Tok.is(tok::kw___declspec))
3128 ParseMicrosoftDeclSpec(attrs);
3129
Richard Smithbdad7a22012-01-10 01:33:14 +00003130 SourceLocation ScopedEnumKWLoc;
John McCall57c13002011-07-06 05:58:41 +00003131 bool IsScopedUsingClassTag = false;
3132
John McCall1e12b3d2012-06-23 22:30:04 +00003133 // In C++11, recognize 'enum class' and 'enum struct'.
David Blaikie4e4d0842012-03-11 07:00:24 +00003134 if (getLangOpts().CPlusPlus0x &&
John McCall57c13002011-07-06 05:58:41 +00003135 (Tok.is(tok::kw_class) || Tok.is(tok::kw_struct))) {
Richard Smith7fe62082011-10-15 05:09:34 +00003136 Diag(Tok, diag::warn_cxx98_compat_scoped_enum);
John McCall57c13002011-07-06 05:58:41 +00003137 IsScopedUsingClassTag = Tok.is(tok::kw_class);
Richard Smithbdad7a22012-01-10 01:33:14 +00003138 ScopedEnumKWLoc = ConsumeToken();
Chad Rosier8decdee2012-06-26 22:30:43 +00003139
John McCall1e12b3d2012-06-23 22:30:04 +00003140 // Attributes are not allowed between these keywords. Diagnose,
3141 // but then just treat them like they appeared in the right place.
Sean Hunt2edf0a22012-06-23 05:07:58 +00003142 ProhibitAttributes(attrs);
John McCall1e12b3d2012-06-23 22:30:04 +00003143
3144 // They are allowed afterwards, though.
3145 MaybeParseGNUAttributes(attrs);
Sean Hunt2edf0a22012-06-23 05:07:58 +00003146 MaybeParseCXX0XAttributes(attrs);
John McCall1e12b3d2012-06-23 22:30:04 +00003147 while (Tok.is(tok::kw___declspec))
3148 ParseMicrosoftDeclSpec(attrs);
John McCall57c13002011-07-06 05:58:41 +00003149 }
Richard Smith1af83c42012-03-23 03:33:32 +00003150
John McCall13489672012-05-07 06:16:58 +00003151 // C++11 [temp.explicit]p12:
3152 // The usual access controls do not apply to names used to specify
3153 // explicit instantiations.
3154 // We extend this to also cover explicit specializations. Note that
3155 // we don't suppress if this turns out to be an elaborated type
3156 // specifier.
3157 bool shouldDelayDiagsInTag =
3158 (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
3159 TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
3160 SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag);
Richard Smith1af83c42012-03-23 03:33:32 +00003161
Richard Smith7796eb52012-03-12 08:56:40 +00003162 // Enum definitions should not be parsed in a trailing-return-type.
3163 bool AllowDeclaration = DSC != DSC_trailing;
3164
3165 bool AllowFixedUnderlyingType = AllowDeclaration &&
3166 (getLangOpts().CPlusPlus0x || getLangOpts().MicrosoftExt ||
3167 getLangOpts().ObjC2);
John McCall57c13002011-07-06 05:58:41 +00003168
Abramo Bagnarae4da7a02010-05-19 21:37:53 +00003169 CXXScopeSpec &SS = DS.getTypeSpecScope();
David Blaikie4e4d0842012-03-11 07:00:24 +00003170 if (getLangOpts().CPlusPlus) {
John McCall57c13002011-07-06 05:58:41 +00003171 // "enum foo : bar;" is not a potential typo for "enum foo::bar;"
3172 // if a fixed underlying type is allowed.
3173 ColonProtectionRAIIObject X(*this, AllowFixedUnderlyingType);
Chad Rosier8decdee2012-06-26 22:30:43 +00003174
3175 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
Douglas Gregorefaa93a2011-11-07 17:33:42 +00003176 /*EnteringContext=*/false))
John McCall9ba61662010-02-26 08:45:28 +00003177 return;
3178
3179 if (SS.isSet() && Tok.isNot(tok::identifier)) {
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003180 Diag(Tok, diag::err_expected_ident);
3181 if (Tok.isNot(tok::l_brace)) {
3182 // Has no name and is not a definition.
3183 // Skip the rest of this declarator, up until the comma or semicolon.
3184 SkipUntil(tok::comma, true);
3185 return;
3186 }
3187 }
3188 }
Mike Stump1eb44332009-09-09 15:08:12 +00003189
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003190 // Must have either 'enum name' or 'enum {...}'.
Douglas Gregorb9075602011-02-22 02:55:24 +00003191 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) &&
Richard Smith7796eb52012-03-12 08:56:40 +00003192 !(AllowFixedUnderlyingType && Tok.is(tok::colon))) {
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003193 Diag(Tok, diag::err_expected_ident_lbrace);
Mike Stump1eb44332009-09-09 15:08:12 +00003194
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003195 // Skip the rest of this declarator, up until the comma or semicolon.
3196 SkipUntil(tok::comma, true);
Reid Spencer5f016e22007-07-11 17:01:13 +00003197 return;
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003198 }
Mike Stump1eb44332009-09-09 15:08:12 +00003199
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003200 // If an identifier is present, consume and remember it.
3201 IdentifierInfo *Name = 0;
3202 SourceLocation NameLoc;
3203 if (Tok.is(tok::identifier)) {
3204 Name = Tok.getIdentifierInfo();
3205 NameLoc = ConsumeToken();
3206 }
Mike Stump1eb44332009-09-09 15:08:12 +00003207
Richard Smithbdad7a22012-01-10 01:33:14 +00003208 if (!Name && ScopedEnumKWLoc.isValid()) {
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003209 // C++0x 7.2p2: The optional identifier shall not be omitted in the
3210 // declaration of a scoped enumeration.
3211 Diag(Tok, diag::err_scoped_enum_missing_identifier);
Richard Smithbdad7a22012-01-10 01:33:14 +00003212 ScopedEnumKWLoc = SourceLocation();
Abramo Bagnaraa88cefd2010-12-03 18:54:17 +00003213 IsScopedUsingClassTag = false;
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003214 }
3215
John McCall13489672012-05-07 06:16:58 +00003216 // Okay, end the suppression area. We'll decide whether to emit the
3217 // diagnostics in a second.
3218 if (shouldDelayDiagsInTag)
3219 diagsFromTag.done();
Richard Smith1af83c42012-03-23 03:33:32 +00003220
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003221 TypeResult BaseType;
3222
Douglas Gregora61b3e72010-12-01 17:42:47 +00003223 // Parse the fixed underlying type.
Richard Smith139be702012-07-02 19:14:01 +00003224 bool CanBeBitfield = getCurScope()->getFlags() & Scope::ClassScope;
Douglas Gregorb9075602011-02-22 02:55:24 +00003225 if (AllowFixedUnderlyingType && Tok.is(tok::colon)) {
Douglas Gregora61b3e72010-12-01 17:42:47 +00003226 bool PossibleBitfield = false;
Richard Smith139be702012-07-02 19:14:01 +00003227 if (CanBeBitfield) {
Douglas Gregora61b3e72010-12-01 17:42:47 +00003228 // If we're in class scope, this can either be an enum declaration with
3229 // an underlying type, or a declaration of a bitfield member. We try to
3230 // use a simple disambiguation scheme first to catch the common cases
Chad Rosier8decdee2012-06-26 22:30:43 +00003231 // (integer literal, sizeof); if it's still ambiguous, we then consider
3232 // anything that's a simple-type-specifier followed by '(' as an
3233 // expression. This suffices because function types are not valid
Douglas Gregora61b3e72010-12-01 17:42:47 +00003234 // underlying types anyway.
Richard Smith05766812012-08-18 00:55:03 +00003235 EnterExpressionEvaluationContext Unevaluated(Actions,
3236 Sema::ConstantEvaluated);
Douglas Gregora61b3e72010-12-01 17:42:47 +00003237 TPResult TPR = isExpressionOrTypeSpecifierSimple(NextToken().getKind());
Chad Rosier8decdee2012-06-26 22:30:43 +00003238 // If the next token starts an expression, we know we're parsing a
Douglas Gregora61b3e72010-12-01 17:42:47 +00003239 // bit-field. This is the common case.
3240 if (TPR == TPResult::True())
3241 PossibleBitfield = true;
3242 // If the next token starts a type-specifier-seq, it may be either a
3243 // a fixed underlying type or the start of a function-style cast in C++;
Chad Rosier8decdee2012-06-26 22:30:43 +00003244 // lookahead one more token to see if it's obvious that we have a
Douglas Gregora61b3e72010-12-01 17:42:47 +00003245 // fixed underlying type.
Chad Rosier8decdee2012-06-26 22:30:43 +00003246 else if (TPR == TPResult::False() &&
Douglas Gregora61b3e72010-12-01 17:42:47 +00003247 GetLookAheadToken(2).getKind() == tok::semi) {
3248 // Consume the ':'.
3249 ConsumeToken();
3250 } else {
3251 // We have the start of a type-specifier-seq, so we have to perform
3252 // tentative parsing to determine whether we have an expression or a
3253 // type.
3254 TentativeParsingAction TPA(*this);
3255
3256 // Consume the ':'.
3257 ConsumeToken();
Richard Smithd81e9612012-02-23 01:36:12 +00003258
3259 // If we see a type specifier followed by an open-brace, we have an
3260 // ambiguity between an underlying type and a C++11 braced
3261 // function-style cast. Resolve this by always treating it as an
3262 // underlying type.
3263 // FIXME: The standard is not entirely clear on how to disambiguate in
3264 // this case.
David Blaikie4e4d0842012-03-11 07:00:24 +00003265 if ((getLangOpts().CPlusPlus &&
Richard Smithd81e9612012-02-23 01:36:12 +00003266 isCXXDeclarationSpecifier(TPResult::True()) != TPResult::True()) ||
David Blaikie4e4d0842012-03-11 07:00:24 +00003267 (!getLangOpts().CPlusPlus && !isDeclarationSpecifier(true))) {
Douglas Gregora61b3e72010-12-01 17:42:47 +00003268 // We'll parse this as a bitfield later.
3269 PossibleBitfield = true;
3270 TPA.Revert();
3271 } else {
3272 // We have a type-specifier-seq.
3273 TPA.Commit();
3274 }
3275 }
3276 } else {
3277 // Consume the ':'.
3278 ConsumeToken();
3279 }
3280
3281 if (!PossibleBitfield) {
3282 SourceRange Range;
3283 BaseType = ParseTypeName(&Range);
Chad Rosier8decdee2012-06-26 22:30:43 +00003284
Eli Friedmancef3a7b2012-11-02 01:34:28 +00003285 if (getLangOpts().CPlusPlus0x) {
Richard Smith7fe62082011-10-15 05:09:34 +00003286 Diag(StartLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type);
Eli Friedmancef3a7b2012-11-02 01:34:28 +00003287 } else if (!getLangOpts().ObjC2) {
3288 if (getLangOpts().CPlusPlus)
3289 Diag(StartLoc, diag::ext_cxx11_enum_fixed_underlying_type) << Range;
3290 else
3291 Diag(StartLoc, diag::ext_c_enum_fixed_underlying_type) << Range;
3292 }
Douglas Gregora61b3e72010-12-01 17:42:47 +00003293 }
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003294 }
3295
Richard Smithbdad7a22012-01-10 01:33:14 +00003296 // There are four options here. If we have 'friend enum foo;' then this is a
3297 // friend declaration, and cannot have an accompanying definition. If we have
3298 // 'enum foo;', then this is a forward declaration. If we have
3299 // 'enum foo {...' then this is a definition. Otherwise we have something
3300 // like 'enum foo xyz', a reference.
Argyrios Kyrtzidise281b4c2008-09-11 00:21:41 +00003301 //
3302 // This is needed to handle stuff like this right (C99 6.7.2.3p11):
3303 // enum foo {..}; void bar() { enum foo; } <- new foo in bar.
3304 // enum foo {..}; void bar() { enum foo x; } <- use of old foo.
3305 //
John McCallf312b1e2010-08-26 23:41:50 +00003306 Sema::TagUseKind TUK;
John McCall13489672012-05-07 06:16:58 +00003307 if (!AllowDeclaration) {
Richard Smith7796eb52012-03-12 08:56:40 +00003308 TUK = Sema::TUK_Reference;
John McCall13489672012-05-07 06:16:58 +00003309 } else if (Tok.is(tok::l_brace)) {
3310 if (DS.isFriendSpecified()) {
3311 Diag(Tok.getLocation(), diag::err_friend_decl_defines_type)
3312 << SourceRange(DS.getFriendSpecLoc());
3313 ConsumeBrace();
3314 SkipUntil(tok::r_brace);
3315 TUK = Sema::TUK_Friend;
3316 } else {
3317 TUK = Sema::TUK_Definition;
3318 }
Richard Smithc9f35172012-06-25 21:37:02 +00003319 } else if (DSC != DSC_type_specifier &&
3320 (Tok.is(tok::semi) ||
Richard Smith139be702012-07-02 19:14:01 +00003321 (Tok.isAtStartOfLine() &&
3322 !isValidAfterTypeSpecifier(CanBeBitfield)))) {
Richard Smithc9f35172012-06-25 21:37:02 +00003323 TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration;
3324 if (Tok.isNot(tok::semi)) {
3325 // A semicolon was missing after this declaration. Diagnose and recover.
3326 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_tagdecl,
3327 "enum");
3328 PP.EnterToken(Tok);
3329 Tok.setKind(tok::semi);
3330 }
John McCall13489672012-05-07 06:16:58 +00003331 } else {
John McCallf312b1e2010-08-26 23:41:50 +00003332 TUK = Sema::TUK_Reference;
John McCall13489672012-05-07 06:16:58 +00003333 }
3334
3335 // If this is an elaborated type specifier, and we delayed
3336 // diagnostics before, just merge them into the current pool.
3337 if (TUK == Sema::TUK_Reference && shouldDelayDiagsInTag) {
3338 diagsFromTag.redelay();
3339 }
Richard Smith1af83c42012-03-23 03:33:32 +00003340
3341 MultiTemplateParamsArg TParams;
Douglas Gregor8fc6d232010-05-03 17:48:54 +00003342 if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
John McCallf312b1e2010-08-26 23:41:50 +00003343 TUK != Sema::TUK_Reference) {
Richard Smith1af83c42012-03-23 03:33:32 +00003344 if (!getLangOpts().CPlusPlus0x || !SS.isSet()) {
3345 // Skip the rest of this declarator, up until the comma or semicolon.
3346 Diag(Tok, diag::err_enum_template);
3347 SkipUntil(tok::comma, true);
3348 return;
3349 }
3350
3351 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
3352 // Enumerations can't be explicitly instantiated.
3353 DS.SetTypeSpecError();
3354 Diag(StartLoc, diag::err_explicit_instantiation_enum);
3355 return;
3356 }
3357
3358 assert(TemplateInfo.TemplateParams && "no template parameters");
3359 TParams = MultiTemplateParamsArg(TemplateInfo.TemplateParams->data(),
3360 TemplateInfo.TemplateParams->size());
Douglas Gregor8fc6d232010-05-03 17:48:54 +00003361 }
Chad Rosier8decdee2012-06-26 22:30:43 +00003362
Sean Hunt2edf0a22012-06-23 05:07:58 +00003363 if (TUK == Sema::TUK_Reference)
3364 ProhibitAttributes(attrs);
Richard Smith1af83c42012-03-23 03:33:32 +00003365
Douglas Gregorb9075602011-02-22 02:55:24 +00003366 if (!Name && TUK != Sema::TUK_Definition) {
3367 Diag(Tok, diag::err_enumerator_unnamed_no_def);
Richard Smith1af83c42012-03-23 03:33:32 +00003368
Douglas Gregorb9075602011-02-22 02:55:24 +00003369 // Skip the rest of this declarator, up until the comma or semicolon.
3370 SkipUntil(tok::comma, true);
3371 return;
3372 }
Richard Smith1af83c42012-03-23 03:33:32 +00003373
Douglas Gregor402abb52009-05-28 23:31:59 +00003374 bool Owned = false;
John McCallc4e70192009-09-11 04:59:25 +00003375 bool IsDependent = false;
Douglas Gregor48c89f42010-04-24 16:38:41 +00003376 const char *PrevSpec = 0;
3377 unsigned DiagID;
John McCalld226f652010-08-21 09:40:31 +00003378 Decl *TagDecl = Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK,
John McCall7f040a92010-12-24 02:08:15 +00003379 StartLoc, SS, Name, NameLoc, attrs.getList(),
Richard Smith1af83c42012-03-23 03:33:32 +00003380 AS, DS.getModulePrivateSpecLoc(), TParams,
Richard Smithbdad7a22012-01-10 01:33:14 +00003381 Owned, IsDependent, ScopedEnumKWLoc,
Abramo Bagnaraa88cefd2010-12-03 18:54:17 +00003382 IsScopedUsingClassTag, BaseType);
Douglas Gregor1274ccd2010-10-08 23:50:27 +00003383
Douglas Gregor48c89f42010-04-24 16:38:41 +00003384 if (IsDependent) {
Chad Rosier8decdee2012-06-26 22:30:43 +00003385 // This enum has a dependent nested-name-specifier. Handle it as a
Douglas Gregor48c89f42010-04-24 16:38:41 +00003386 // dependent tag.
3387 if (!Name) {
3388 DS.SetTypeSpecError();
3389 Diag(Tok, diag::err_expected_type_name_after_typename);
3390 return;
3391 }
Chad Rosier8decdee2012-06-26 22:30:43 +00003392
Douglas Gregor23c94db2010-07-02 17:43:08 +00003393 TypeResult Type = Actions.ActOnDependentTag(getCurScope(), DeclSpec::TST_enum,
Chad Rosier8decdee2012-06-26 22:30:43 +00003394 TUK, SS, Name, StartLoc,
Douglas Gregor48c89f42010-04-24 16:38:41 +00003395 NameLoc);
3396 if (Type.isInvalid()) {
3397 DS.SetTypeSpecError();
3398 return;
3399 }
Chad Rosier8decdee2012-06-26 22:30:43 +00003400
Abramo Bagnara0daaf322011-03-16 20:16:18 +00003401 if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
3402 NameLoc.isValid() ? NameLoc : StartLoc,
3403 PrevSpec, DiagID, Type.get()))
Douglas Gregor48c89f42010-04-24 16:38:41 +00003404 Diag(StartLoc, DiagID) << PrevSpec;
Chad Rosier8decdee2012-06-26 22:30:43 +00003405
Douglas Gregor48c89f42010-04-24 16:38:41 +00003406 return;
3407 }
Mike Stump1eb44332009-09-09 15:08:12 +00003408
John McCalld226f652010-08-21 09:40:31 +00003409 if (!TagDecl) {
Chad Rosier8decdee2012-06-26 22:30:43 +00003410 // The action failed to produce an enumeration tag. If this is a
Douglas Gregor48c89f42010-04-24 16:38:41 +00003411 // definition, consume the entire definition.
Richard Smith7796eb52012-03-12 08:56:40 +00003412 if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference) {
Douglas Gregor48c89f42010-04-24 16:38:41 +00003413 ConsumeBrace();
3414 SkipUntil(tok::r_brace);
3415 }
Chad Rosier8decdee2012-06-26 22:30:43 +00003416
Douglas Gregor48c89f42010-04-24 16:38:41 +00003417 DS.SetTypeSpecError();
3418 return;
3419 }
Richard Smithbdad7a22012-01-10 01:33:14 +00003420
Richard Smithc9f35172012-06-25 21:37:02 +00003421 if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference)
John McCall13489672012-05-07 06:16:58 +00003422 ParseEnumBody(StartLoc, TagDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00003423
Abramo Bagnara0daaf322011-03-16 20:16:18 +00003424 if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
3425 NameLoc.isValid() ? NameLoc : StartLoc,
3426 PrevSpec, DiagID, TagDecl, Owned))
John McCallfec54012009-08-03 20:12:06 +00003427 Diag(StartLoc, DiagID) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00003428}
3429
3430/// ParseEnumBody - Parse a {} enclosed enumerator-list.
3431/// enumerator-list:
3432/// enumerator
3433/// enumerator-list ',' enumerator
3434/// enumerator:
3435/// enumeration-constant
3436/// enumeration-constant '=' constant-expression
3437/// enumeration-constant:
3438/// identifier
3439///
John McCalld226f652010-08-21 09:40:31 +00003440void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {
Douglas Gregor074149e2009-01-05 19:45:36 +00003441 // Enter the scope of the enum body and start the definition.
3442 ParseScope EnumScope(this, Scope::DeclScope);
Douglas Gregor23c94db2010-07-02 17:43:08 +00003443 Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl);
Douglas Gregor074149e2009-01-05 19:45:36 +00003444
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003445 BalancedDelimiterTracker T(*this, tok::l_brace);
3446 T.consumeOpen();
Mike Stump1eb44332009-09-09 15:08:12 +00003447
Chris Lattner7946dd32007-08-27 17:24:30 +00003448 // C does not allow an empty enumerator-list, C++ does [dcl.enum].
David Blaikie4e4d0842012-03-11 07:00:24 +00003449 if (Tok.is(tok::r_brace) && !getLangOpts().CPlusPlus)
Fariborz Jahanian05115522010-05-28 22:23:22 +00003450 Diag(Tok, diag::error_empty_enum);
Mike Stump1eb44332009-09-09 15:08:12 +00003451
Chris Lattner5f9e2722011-07-23 10:55:15 +00003452 SmallVector<Decl *, 32> EnumConstantDecls;
Reid Spencer5f016e22007-07-11 17:01:13 +00003453
John McCalld226f652010-08-21 09:40:31 +00003454 Decl *LastEnumConstDecl = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00003455
Reid Spencer5f016e22007-07-11 17:01:13 +00003456 // Parse the enumerator-list.
Chris Lattner04d66662007-10-09 17:33:22 +00003457 while (Tok.is(tok::identifier)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003458 IdentifierInfo *Ident = Tok.getIdentifierInfo();
3459 SourceLocation IdentLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00003460
John McCall5b629aa2010-10-22 23:36:17 +00003461 // If attributes exist after the enumerator, parse them.
Sean Hunt2edf0a22012-06-23 05:07:58 +00003462 ParsedAttributesWithRange attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00003463 MaybeParseGNUAttributes(attrs);
Sean Hunt2edf0a22012-06-23 05:07:58 +00003464 MaybeParseCXX0XAttributes(attrs);
3465 ProhibitAttributes(attrs);
John McCall5b629aa2010-10-22 23:36:17 +00003466
Reid Spencer5f016e22007-07-11 17:01:13 +00003467 SourceLocation EqualLoc;
John McCall60d7b3a2010-08-24 06:29:42 +00003468 ExprResult AssignedVal;
John McCall92576642012-05-07 06:16:41 +00003469 ParsingDeclRAIIObject PD(*this, ParsingDeclRAIIObject::NoParent);
Chad Rosier8decdee2012-06-26 22:30:43 +00003470
Chris Lattner04d66662007-10-09 17:33:22 +00003471 if (Tok.is(tok::equal)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003472 EqualLoc = ConsumeToken();
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00003473 AssignedVal = ParseConstantExpression();
3474 if (AssignedVal.isInvalid())
Reid Spencer5f016e22007-07-11 17:01:13 +00003475 SkipUntil(tok::comma, tok::r_brace, true, true);
Reid Spencer5f016e22007-07-11 17:01:13 +00003476 }
Mike Stump1eb44332009-09-09 15:08:12 +00003477
Reid Spencer5f016e22007-07-11 17:01:13 +00003478 // Install the enumerator constant into EnumDecl.
John McCalld226f652010-08-21 09:40:31 +00003479 Decl *EnumConstDecl = Actions.ActOnEnumConstant(getCurScope(), EnumDecl,
3480 LastEnumConstDecl,
3481 IdentLoc, Ident,
John McCall7f040a92010-12-24 02:08:15 +00003482 attrs.getList(), EqualLoc,
John McCalld226f652010-08-21 09:40:31 +00003483 AssignedVal.release());
Fariborz Jahanian5a477db2011-12-09 01:15:54 +00003484 PD.complete(EnumConstDecl);
Chad Rosier8decdee2012-06-26 22:30:43 +00003485
Reid Spencer5f016e22007-07-11 17:01:13 +00003486 EnumConstantDecls.push_back(EnumConstDecl);
3487 LastEnumConstDecl = EnumConstDecl;
Mike Stump1eb44332009-09-09 15:08:12 +00003488
Douglas Gregor751f6922010-09-07 14:51:08 +00003489 if (Tok.is(tok::identifier)) {
3490 // We're missing a comma between enumerators.
3491 SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation);
Chad Rosier8decdee2012-06-26 22:30:43 +00003492 Diag(Loc, diag::err_enumerator_list_missing_comma)
Douglas Gregor751f6922010-09-07 14:51:08 +00003493 << FixItHint::CreateInsertion(Loc, ", ");
3494 continue;
3495 }
Chad Rosier8decdee2012-06-26 22:30:43 +00003496
Chris Lattner04d66662007-10-09 17:33:22 +00003497 if (Tok.isNot(tok::comma))
Reid Spencer5f016e22007-07-11 17:01:13 +00003498 break;
3499 SourceLocation CommaLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00003500
Richard Smith7fe62082011-10-15 05:09:34 +00003501 if (Tok.isNot(tok::identifier)) {
David Blaikie4e4d0842012-03-11 07:00:24 +00003502 if (!getLangOpts().C99 && !getLangOpts().CPlusPlus0x)
Richard Smitheab9d6f2012-07-23 05:45:25 +00003503 Diag(CommaLoc, getLangOpts().CPlusPlus ?
3504 diag::ext_enumerator_list_comma_cxx :
3505 diag::ext_enumerator_list_comma_c)
Richard Smith7fe62082011-10-15 05:09:34 +00003506 << FixItHint::CreateRemoval(CommaLoc);
David Blaikie4e4d0842012-03-11 07:00:24 +00003507 else if (getLangOpts().CPlusPlus0x)
Richard Smith7fe62082011-10-15 05:09:34 +00003508 Diag(CommaLoc, diag::warn_cxx98_compat_enumerator_list_comma)
3509 << FixItHint::CreateRemoval(CommaLoc);
3510 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003511 }
Mike Stump1eb44332009-09-09 15:08:12 +00003512
Reid Spencer5f016e22007-07-11 17:01:13 +00003513 // Eat the }.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003514 T.consumeClose();
Reid Spencer5f016e22007-07-11 17:01:13 +00003515
Reid Spencer5f016e22007-07-11 17:01:13 +00003516 // If attributes exist after the identifier list, parse them.
John McCall0b7e6782011-03-24 11:26:52 +00003517 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00003518 MaybeParseGNUAttributes(attrs);
Douglas Gregor72de6672009-01-08 20:45:30 +00003519
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003520 Actions.ActOnEnumBody(StartLoc, T.getOpenLocation(), T.getCloseLocation(),
3521 EnumDecl, EnumConstantDecls.data(),
3522 EnumConstantDecls.size(), getCurScope(),
3523 attrs.getList());
Mike Stump1eb44332009-09-09 15:08:12 +00003524
Douglas Gregor72de6672009-01-08 20:45:30 +00003525 EnumScope.Exit();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00003526 Actions.ActOnTagFinishDefinition(getCurScope(), EnumDecl,
3527 T.getCloseLocation());
Richard Smithc9f35172012-06-25 21:37:02 +00003528
3529 // The next token must be valid after an enum definition. If not, a ';'
3530 // was probably forgotten.
Richard Smith139be702012-07-02 19:14:01 +00003531 bool CanBeBitfield = getCurScope()->getFlags() & Scope::ClassScope;
3532 if (!isValidAfterTypeSpecifier(CanBeBitfield)) {
Richard Smithc9f35172012-06-25 21:37:02 +00003533 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_tagdecl, "enum");
3534 // Push this token back into the preprocessor and change our current token
3535 // to ';' so that the rest of the code recovers as though there were an
3536 // ';' after the definition.
3537 PP.EnterToken(Tok);
3538 Tok.setKind(tok::semi);
3539 }
Reid Spencer5f016e22007-07-11 17:01:13 +00003540}
3541
3542/// isTypeSpecifierQualifier - Return true if the current token could be the
Steve Naroff5f8aa692008-02-11 23:15:56 +00003543/// start of a type-qualifier-list.
3544bool Parser::isTypeQualifier() const {
3545 switch (Tok.getKind()) {
3546 default: return false;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003547
3548 // type-qualifier only in OpenCL
3549 case tok::kw_private:
David Blaikie4e4d0842012-03-11 07:00:24 +00003550 return getLangOpts().OpenCL;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003551
Steve Naroff5f8aa692008-02-11 23:15:56 +00003552 // type-qualifier
3553 case tok::kw_const:
3554 case tok::kw_volatile:
3555 case tok::kw_restrict:
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003556 case tok::kw___private:
3557 case tok::kw___local:
3558 case tok::kw___global:
3559 case tok::kw___constant:
3560 case tok::kw___read_only:
3561 case tok::kw___read_write:
3562 case tok::kw___write_only:
Steve Naroff5f8aa692008-02-11 23:15:56 +00003563 return true;
3564 }
3565}
3566
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003567/// isKnownToBeTypeSpecifier - Return true if we know that the specified token
3568/// is definitely a type-specifier. Return false if it isn't part of a type
3569/// specifier or if we're not sure.
3570bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const {
3571 switch (Tok.getKind()) {
3572 default: return false;
3573 // type-specifiers
3574 case tok::kw_short:
3575 case tok::kw_long:
Francois Pichet338d7f72011-04-28 01:59:37 +00003576 case tok::kw___int64:
Richard Smith5a5a9712012-04-04 06:24:32 +00003577 case tok::kw___int128:
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003578 case tok::kw_signed:
3579 case tok::kw_unsigned:
3580 case tok::kw__Complex:
3581 case tok::kw__Imaginary:
3582 case tok::kw_void:
3583 case tok::kw_char:
3584 case tok::kw_wchar_t:
3585 case tok::kw_char16_t:
3586 case tok::kw_char32_t:
3587 case tok::kw_int:
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00003588 case tok::kw_half:
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003589 case tok::kw_float:
3590 case tok::kw_double:
3591 case tok::kw_bool:
3592 case tok::kw__Bool:
3593 case tok::kw__Decimal32:
3594 case tok::kw__Decimal64:
3595 case tok::kw__Decimal128:
3596 case tok::kw___vector:
Chad Rosier8decdee2012-06-26 22:30:43 +00003597
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003598 // struct-or-union-specifier (C99) or class-specifier (C++)
3599 case tok::kw_class:
3600 case tok::kw_struct:
Joao Matos6666ed42012-08-31 18:45:21 +00003601 case tok::kw___interface:
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003602 case tok::kw_union:
3603 // enum-specifier
3604 case tok::kw_enum:
Chad Rosier8decdee2012-06-26 22:30:43 +00003605
Chris Lattnerb3a4e432010-02-28 18:18:36 +00003606 // typedef-name
3607 case tok::annot_typename:
3608 return true;
3609 }
3610}
3611
Steve Naroff5f8aa692008-02-11 23:15:56 +00003612/// isTypeSpecifierQualifier - Return true if the current token could be the
Reid Spencer5f016e22007-07-11 17:01:13 +00003613/// start of a specifier-qualifier-list.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003614bool Parser::isTypeSpecifierQualifier() {
Reid Spencer5f016e22007-07-11 17:01:13 +00003615 switch (Tok.getKind()) {
3616 default: return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003617
Chris Lattner166a8fc2009-01-04 23:41:41 +00003618 case tok::identifier: // foo::bar
John Thompson82287d12010-02-05 00:12:22 +00003619 if (TryAltiVecVectorToken())
3620 return true;
3621 // Fall through.
Douglas Gregord57959a2009-03-27 23:10:48 +00003622 case tok::kw_typename: // typename T::type
Chris Lattner166a8fc2009-01-04 23:41:41 +00003623 // Annotate typenames and C++ scope specifiers. If we get one, just
3624 // recurse to handle whatever we get.
3625 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003626 return true;
3627 if (Tok.is(tok::identifier))
3628 return false;
3629 return isTypeSpecifierQualifier();
Douglas Gregord57959a2009-03-27 23:10:48 +00003630
Chris Lattner166a8fc2009-01-04 23:41:41 +00003631 case tok::coloncolon: // ::foo::bar
3632 if (NextToken().is(tok::kw_new) || // ::new
3633 NextToken().is(tok::kw_delete)) // ::delete
3634 return false;
3635
Chris Lattner166a8fc2009-01-04 23:41:41 +00003636 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003637 return true;
3638 return isTypeSpecifierQualifier();
Mike Stump1eb44332009-09-09 15:08:12 +00003639
Reid Spencer5f016e22007-07-11 17:01:13 +00003640 // GNU attributes support.
3641 case tok::kw___attribute:
Steve Naroffd1861fd2007-07-31 12:34:36 +00003642 // GNU typeof support.
3643 case tok::kw_typeof:
Mike Stump1eb44332009-09-09 15:08:12 +00003644
Reid Spencer5f016e22007-07-11 17:01:13 +00003645 // type-specifiers
3646 case tok::kw_short:
3647 case tok::kw_long:
Francois Pichet338d7f72011-04-28 01:59:37 +00003648 case tok::kw___int64:
Richard Smith5a5a9712012-04-04 06:24:32 +00003649 case tok::kw___int128:
Reid Spencer5f016e22007-07-11 17:01:13 +00003650 case tok::kw_signed:
3651 case tok::kw_unsigned:
3652 case tok::kw__Complex:
3653 case tok::kw__Imaginary:
3654 case tok::kw_void:
3655 case tok::kw_char:
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +00003656 case tok::kw_wchar_t:
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00003657 case tok::kw_char16_t:
3658 case tok::kw_char32_t:
Reid Spencer5f016e22007-07-11 17:01:13 +00003659 case tok::kw_int:
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00003660 case tok::kw_half:
Reid Spencer5f016e22007-07-11 17:01:13 +00003661 case tok::kw_float:
3662 case tok::kw_double:
Chris Lattner9298d962007-11-15 05:25:19 +00003663 case tok::kw_bool:
Reid Spencer5f016e22007-07-11 17:01:13 +00003664 case tok::kw__Bool:
3665 case tok::kw__Decimal32:
3666 case tok::kw__Decimal64:
3667 case tok::kw__Decimal128:
John Thompson82287d12010-02-05 00:12:22 +00003668 case tok::kw___vector:
Mike Stump1eb44332009-09-09 15:08:12 +00003669
Chris Lattner99dc9142008-04-13 18:59:07 +00003670 // struct-or-union-specifier (C99) or class-specifier (C++)
3671 case tok::kw_class:
Reid Spencer5f016e22007-07-11 17:01:13 +00003672 case tok::kw_struct:
Joao Matos6666ed42012-08-31 18:45:21 +00003673 case tok::kw___interface:
Reid Spencer5f016e22007-07-11 17:01:13 +00003674 case tok::kw_union:
3675 // enum-specifier
3676 case tok::kw_enum:
Mike Stump1eb44332009-09-09 15:08:12 +00003677
Reid Spencer5f016e22007-07-11 17:01:13 +00003678 // type-qualifier
3679 case tok::kw_const:
3680 case tok::kw_volatile:
3681 case tok::kw_restrict:
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003682
John McCallb8a8de32012-11-14 00:49:39 +00003683 // Debugger support.
3684 case tok::kw___unknown_anytype:
3685
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00003686 // typedef-name
Chris Lattnerb31757b2009-01-06 05:06:21 +00003687 case tok::annot_typename:
Reid Spencer5f016e22007-07-11 17:01:13 +00003688 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00003689
Chris Lattner7c186be2008-10-20 00:25:30 +00003690 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
3691 case tok::less:
David Blaikie4e4d0842012-03-11 07:00:24 +00003692 return getLangOpts().ObjC1;
Mike Stump1eb44332009-09-09 15:08:12 +00003693
Steve Naroff239f0732008-12-25 14:16:32 +00003694 case tok::kw___cdecl:
3695 case tok::kw___stdcall:
3696 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00003697 case tok::kw___thiscall:
Eli Friedman290eeb02009-06-08 23:27:34 +00003698 case tok::kw___w64:
3699 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00003700 case tok::kw___ptr32:
Dawn Perchik52fc3142010-09-03 01:29:35 +00003701 case tok::kw___pascal:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00003702 case tok::kw___unaligned:
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003703
3704 case tok::kw___private:
3705 case tok::kw___local:
3706 case tok::kw___global:
3707 case tok::kw___constant:
3708 case tok::kw___read_only:
3709 case tok::kw___read_write:
3710 case tok::kw___write_only:
3711
Eli Friedman290eeb02009-06-08 23:27:34 +00003712 return true;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003713
3714 case tok::kw_private:
David Blaikie4e4d0842012-03-11 07:00:24 +00003715 return getLangOpts().OpenCL;
Eli Friedmanb001de72011-10-06 23:00:33 +00003716
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00003717 // C11 _Atomic()
Eli Friedmanb001de72011-10-06 23:00:33 +00003718 case tok::kw__Atomic:
3719 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00003720 }
3721}
3722
3723/// isDeclarationSpecifier() - Return true if the current token is part of a
3724/// declaration specifier.
Douglas Gregor9497a732010-09-16 01:51:54 +00003725///
3726/// \param DisambiguatingWithExpression True to indicate that the purpose of
3727/// this check is to disambiguate between an expression and a declaration.
3728bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
Reid Spencer5f016e22007-07-11 17:01:13 +00003729 switch (Tok.getKind()) {
3730 default: return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003731
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003732 case tok::kw_private:
David Blaikie4e4d0842012-03-11 07:00:24 +00003733 return getLangOpts().OpenCL;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003734
Chris Lattner166a8fc2009-01-04 23:41:41 +00003735 case tok::identifier: // foo::bar
Steve Naroff61f72cb2009-03-09 21:12:44 +00003736 // Unfortunate hack to support "Class.factoryMethod" notation.
David Blaikie4e4d0842012-03-11 07:00:24 +00003737 if (getLangOpts().ObjC1 && NextToken().is(tok::period))
Steve Naroff61f72cb2009-03-09 21:12:44 +00003738 return false;
John Thompson82287d12010-02-05 00:12:22 +00003739 if (TryAltiVecVectorToken())
3740 return true;
3741 // Fall through.
David Blaikie42d6d0c2011-12-04 05:04:18 +00003742 case tok::kw_decltype: // decltype(T())::type
Douglas Gregord57959a2009-03-27 23:10:48 +00003743 case tok::kw_typename: // typename T::type
Chris Lattner166a8fc2009-01-04 23:41:41 +00003744 // Annotate typenames and C++ scope specifiers. If we get one, just
3745 // recurse to handle whatever we get.
3746 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003747 return true;
3748 if (Tok.is(tok::identifier))
3749 return false;
Chad Rosier8decdee2012-06-26 22:30:43 +00003750
Douglas Gregor9497a732010-09-16 01:51:54 +00003751 // If we're in Objective-C and we have an Objective-C class type followed
Chad Rosier8decdee2012-06-26 22:30:43 +00003752 // by an identifier and then either ':' or ']', in a place where an
Douglas Gregor9497a732010-09-16 01:51:54 +00003753 // expression is permitted, then this is probably a class message send
3754 // missing the initial '['. In this case, we won't consider this to be
3755 // the start of a declaration.
Chad Rosier8decdee2012-06-26 22:30:43 +00003756 if (DisambiguatingWithExpression &&
Douglas Gregor9497a732010-09-16 01:51:54 +00003757 isStartOfObjCClassMessageMissingOpenBracket())
3758 return false;
Chad Rosier8decdee2012-06-26 22:30:43 +00003759
John McCall9ba61662010-02-26 08:45:28 +00003760 return isDeclarationSpecifier();
3761
Chris Lattner166a8fc2009-01-04 23:41:41 +00003762 case tok::coloncolon: // ::foo::bar
3763 if (NextToken().is(tok::kw_new) || // ::new
3764 NextToken().is(tok::kw_delete)) // ::delete
3765 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003766
Chris Lattner166a8fc2009-01-04 23:41:41 +00003767 // Annotate typenames and C++ scope specifiers. If we get one, just
3768 // recurse to handle whatever we get.
3769 if (TryAnnotateTypeOrScopeToken())
John McCall9ba61662010-02-26 08:45:28 +00003770 return true;
3771 return isDeclarationSpecifier();
Mike Stump1eb44332009-09-09 15:08:12 +00003772
Reid Spencer5f016e22007-07-11 17:01:13 +00003773 // storage-class-specifier
3774 case tok::kw_typedef:
3775 case tok::kw_extern:
Steve Naroff8d54bf22007-12-18 00:16:02 +00003776 case tok::kw___private_extern__:
Reid Spencer5f016e22007-07-11 17:01:13 +00003777 case tok::kw_static:
3778 case tok::kw_auto:
3779 case tok::kw_register:
3780 case tok::kw___thread:
Mike Stump1eb44332009-09-09 15:08:12 +00003781
Douglas Gregor8d267c52011-09-09 02:06:17 +00003782 // Modules
3783 case tok::kw___module_private__:
Chad Rosier8decdee2012-06-26 22:30:43 +00003784
John McCallb8a8de32012-11-14 00:49:39 +00003785 // Debugger support
3786 case tok::kw___unknown_anytype:
3787
Reid Spencer5f016e22007-07-11 17:01:13 +00003788 // type-specifiers
3789 case tok::kw_short:
3790 case tok::kw_long:
Francois Pichet338d7f72011-04-28 01:59:37 +00003791 case tok::kw___int64:
Richard Smith5a5a9712012-04-04 06:24:32 +00003792 case tok::kw___int128:
Reid Spencer5f016e22007-07-11 17:01:13 +00003793 case tok::kw_signed:
3794 case tok::kw_unsigned:
3795 case tok::kw__Complex:
3796 case tok::kw__Imaginary:
3797 case tok::kw_void:
3798 case tok::kw_char:
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +00003799 case tok::kw_wchar_t:
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00003800 case tok::kw_char16_t:
3801 case tok::kw_char32_t:
3802
Reid Spencer5f016e22007-07-11 17:01:13 +00003803 case tok::kw_int:
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +00003804 case tok::kw_half:
Reid Spencer5f016e22007-07-11 17:01:13 +00003805 case tok::kw_float:
3806 case tok::kw_double:
Chris Lattner9298d962007-11-15 05:25:19 +00003807 case tok::kw_bool:
Reid Spencer5f016e22007-07-11 17:01:13 +00003808 case tok::kw__Bool:
3809 case tok::kw__Decimal32:
3810 case tok::kw__Decimal64:
3811 case tok::kw__Decimal128:
John Thompson82287d12010-02-05 00:12:22 +00003812 case tok::kw___vector:
Mike Stump1eb44332009-09-09 15:08:12 +00003813
Chris Lattner99dc9142008-04-13 18:59:07 +00003814 // struct-or-union-specifier (C99) or class-specifier (C++)
3815 case tok::kw_class:
Reid Spencer5f016e22007-07-11 17:01:13 +00003816 case tok::kw_struct:
3817 case tok::kw_union:
Joao Matos6666ed42012-08-31 18:45:21 +00003818 case tok::kw___interface:
Reid Spencer5f016e22007-07-11 17:01:13 +00003819 // enum-specifier
3820 case tok::kw_enum:
Mike Stump1eb44332009-09-09 15:08:12 +00003821
Reid Spencer5f016e22007-07-11 17:01:13 +00003822 // type-qualifier
3823 case tok::kw_const:
3824 case tok::kw_volatile:
3825 case tok::kw_restrict:
Steve Naroffd1861fd2007-07-31 12:34:36 +00003826
Reid Spencer5f016e22007-07-11 17:01:13 +00003827 // function-specifier
3828 case tok::kw_inline:
Douglas Gregorb48fe382008-10-31 09:07:45 +00003829 case tok::kw_virtual:
3830 case tok::kw_explicit:
Chris Lattnerd6c7c182007-08-09 16:40:21 +00003831
Richard Smith53aec2a2012-10-25 00:00:53 +00003832 // friend keyword.
3833 case tok::kw_friend:
3834
Peter Collingbournec6eb44b2011-04-15 00:35:57 +00003835 // static_assert-declaration
3836 case tok::kw__Static_assert:
3837
Chris Lattner1ef08762007-08-09 17:01:07 +00003838 // GNU typeof support.
3839 case tok::kw_typeof:
Mike Stump1eb44332009-09-09 15:08:12 +00003840
Chris Lattner1ef08762007-08-09 17:01:07 +00003841 // GNU attributes.
Chris Lattnerd6c7c182007-08-09 16:40:21 +00003842 case tok::kw___attribute:
Mike Stump1eb44332009-09-09 15:08:12 +00003843
Richard Smith53aec2a2012-10-25 00:00:53 +00003844 // C++11 decltype and constexpr.
David Blaikie42d6d0c2011-12-04 05:04:18 +00003845 case tok::annot_decltype:
Richard Smith53aec2a2012-10-25 00:00:53 +00003846 case tok::kw_constexpr:
Francois Pichete3d49b42011-06-19 08:02:06 +00003847
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00003848 // C11 _Atomic()
Eli Friedmanb001de72011-10-06 23:00:33 +00003849 case tok::kw__Atomic:
3850 return true;
3851
Chris Lattnerf3948c42008-07-26 03:38:44 +00003852 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
3853 case tok::less:
David Blaikie4e4d0842012-03-11 07:00:24 +00003854 return getLangOpts().ObjC1;
Mike Stump1eb44332009-09-09 15:08:12 +00003855
Douglas Gregord9d75e52011-04-27 05:41:15 +00003856 // typedef-name
3857 case tok::annot_typename:
3858 return !DisambiguatingWithExpression ||
3859 !isStartOfObjCClassMessageMissingOpenBracket();
Chad Rosier8decdee2012-06-26 22:30:43 +00003860
Steve Naroff47f52092009-01-06 19:34:12 +00003861 case tok::kw___declspec:
Steve Naroff239f0732008-12-25 14:16:32 +00003862 case tok::kw___cdecl:
3863 case tok::kw___stdcall:
3864 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00003865 case tok::kw___thiscall:
Eli Friedman290eeb02009-06-08 23:27:34 +00003866 case tok::kw___w64:
3867 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00003868 case tok::kw___ptr32:
Eli Friedman290eeb02009-06-08 23:27:34 +00003869 case tok::kw___forceinline:
Dawn Perchik52fc3142010-09-03 01:29:35 +00003870 case tok::kw___pascal:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00003871 case tok::kw___unaligned:
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003872
3873 case tok::kw___private:
3874 case tok::kw___local:
3875 case tok::kw___global:
3876 case tok::kw___constant:
3877 case tok::kw___read_only:
3878 case tok::kw___read_write:
3879 case tok::kw___write_only:
3880
Eli Friedman290eeb02009-06-08 23:27:34 +00003881 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00003882 }
3883}
3884
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003885bool Parser::isConstructorDeclarator() {
3886 TentativeParsingAction TPA(*this);
3887
3888 // Parse the C++ scope specifier.
3889 CXXScopeSpec SS;
Chad Rosier8decdee2012-06-26 22:30:43 +00003890 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
Douglas Gregorefaa93a2011-11-07 17:33:42 +00003891 /*EnteringContext=*/true)) {
John McCall9ba61662010-02-26 08:45:28 +00003892 TPA.Revert();
3893 return false;
3894 }
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003895
3896 // Parse the constructor name.
3897 if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id)) {
3898 // We already know that we have a constructor name; just consume
3899 // the token.
3900 ConsumeToken();
3901 } else {
3902 TPA.Revert();
3903 return false;
3904 }
3905
Richard Smith22592862012-03-27 23:05:05 +00003906 // Current class name must be followed by a left parenthesis.
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003907 if (Tok.isNot(tok::l_paren)) {
3908 TPA.Revert();
3909 return false;
3910 }
3911 ConsumeParen();
3912
Richard Smith22592862012-03-27 23:05:05 +00003913 // A right parenthesis, or ellipsis followed by a right parenthesis signals
3914 // that we have a constructor.
3915 if (Tok.is(tok::r_paren) ||
3916 (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren))) {
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003917 TPA.Revert();
3918 return true;
3919 }
3920
3921 // If we need to, enter the specified scope.
3922 DeclaratorScopeObj DeclScopeObj(*this, SS);
Douglas Gregor23c94db2010-07-02 17:43:08 +00003923 if (SS.isSet() && Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003924 DeclScopeObj.EnterDeclaratorScope();
3925
Francois Pichetdfaa5fb2011-01-31 04:54:32 +00003926 // Optionally skip Microsoft attributes.
John McCall0b7e6782011-03-24 11:26:52 +00003927 ParsedAttributes Attrs(AttrFactory);
Francois Pichetdfaa5fb2011-01-31 04:54:32 +00003928 MaybeParseMicrosoftAttributes(Attrs);
3929
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003930 // Check whether the next token(s) are part of a declaration
3931 // specifier, in which case we have the start of a parameter and,
3932 // therefore, we know that this is a constructor.
Richard Smith412e0cc2012-03-27 00:56:56 +00003933 bool IsConstructor = false;
3934 if (isDeclarationSpecifier())
3935 IsConstructor = true;
3936 else if (Tok.is(tok::identifier) ||
3937 (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier))) {
3938 // We've seen "C ( X" or "C ( X::Y", but "X" / "X::Y" is not a type.
3939 // This might be a parenthesized member name, but is more likely to
3940 // be a constructor declaration with an invalid argument type. Keep
3941 // looking.
3942 if (Tok.is(tok::annot_cxxscope))
3943 ConsumeToken();
3944 ConsumeToken();
3945
3946 // If this is not a constructor, we must be parsing a declarator,
Richard Smith5d8388c2012-03-27 01:42:32 +00003947 // which must have one of the following syntactic forms (see the
3948 // grammar extract at the start of ParseDirectDeclarator):
Richard Smith412e0cc2012-03-27 00:56:56 +00003949 switch (Tok.getKind()) {
3950 case tok::l_paren:
3951 // C(X ( int));
3952 case tok::l_square:
3953 // C(X [ 5]);
3954 // C(X [ [attribute]]);
3955 case tok::coloncolon:
3956 // C(X :: Y);
3957 // C(X :: *p);
3958 case tok::r_paren:
3959 // C(X )
3960 // Assume this isn't a constructor, rather than assuming it's a
3961 // constructor with an unnamed parameter of an ill-formed type.
3962 break;
3963
3964 default:
3965 IsConstructor = true;
3966 break;
3967 }
3968 }
3969
Douglas Gregor0efc2c12010-01-13 17:31:36 +00003970 TPA.Revert();
3971 return IsConstructor;
3972}
Reid Spencer5f016e22007-07-11 17:01:13 +00003973
3974/// ParseTypeQualifierListOpt
Dawn Perchik52fc3142010-09-03 01:29:35 +00003975/// type-qualifier-list: [C99 6.7.5]
3976/// type-qualifier
Chad Rosier8decdee2012-06-26 22:30:43 +00003977/// [vendor] attributes
Dawn Perchik52fc3142010-09-03 01:29:35 +00003978/// [ only if VendorAttributesAllowed=true ]
3979/// type-qualifier-list type-qualifier
Chad Rosier8decdee2012-06-26 22:30:43 +00003980/// [vendor] type-qualifier-list attributes
Dawn Perchik52fc3142010-09-03 01:29:35 +00003981/// [ only if VendorAttributesAllowed=true ]
3982/// [C++0x] attribute-specifier[opt] is allowed before cv-qualifier-seq
3983/// [ only if CXX0XAttributesAllowed=true ]
3984/// Note: vendor can be GNU, MS, etc.
Reid Spencer5f016e22007-07-11 17:01:13 +00003985///
Dawn Perchik52fc3142010-09-03 01:29:35 +00003986void Parser::ParseTypeQualifierListOpt(DeclSpec &DS,
3987 bool VendorAttributesAllowed,
Richard Smithc56298d2012-04-10 03:25:07 +00003988 bool CXX11AttributesAllowed) {
3989 if (getLangOpts().CPlusPlus0x && CXX11AttributesAllowed &&
Richard Smith6ee326a2012-04-10 01:32:12 +00003990 isCXX11AttributeSpecifier()) {
John McCall0b7e6782011-03-24 11:26:52 +00003991 ParsedAttributesWithRange attrs(AttrFactory);
Richard Smithc56298d2012-04-10 03:25:07 +00003992 ParseCXX11Attributes(attrs);
Richard Smith6ee326a2012-04-10 01:32:12 +00003993 DS.takeAttributesFrom(attrs);
Sean Huntbbd37c62009-11-21 08:43:09 +00003994 }
Abramo Bagnara796aa442011-03-12 11:17:06 +00003995
3996 SourceLocation EndLoc;
3997
Reid Spencer5f016e22007-07-11 17:01:13 +00003998 while (1) {
John McCallfec54012009-08-03 20:12:06 +00003999 bool isInvalid = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00004000 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00004001 unsigned DiagID = 0;
Reid Spencer5f016e22007-07-11 17:01:13 +00004002 SourceLocation Loc = Tok.getLocation();
4003
4004 switch (Tok.getKind()) {
Douglas Gregor1a480c42010-08-27 17:35:51 +00004005 case tok::code_completion:
4006 Actions.CodeCompleteTypeQualifiers(DS);
Argyrios Kyrtzidis7d100872011-09-04 03:32:15 +00004007 return cutOffParsing();
Chad Rosier8decdee2012-06-26 22:30:43 +00004008
Reid Spencer5f016e22007-07-11 17:01:13 +00004009 case tok::kw_const:
John McCallfec54012009-08-03 20:12:06 +00004010 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, DiagID,
Richard Smithd654f2d2012-10-17 23:31:46 +00004011 getLangOpts());
Reid Spencer5f016e22007-07-11 17:01:13 +00004012 break;
4013 case tok::kw_volatile:
John McCallfec54012009-08-03 20:12:06 +00004014 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
Richard Smithd654f2d2012-10-17 23:31:46 +00004015 getLangOpts());
Reid Spencer5f016e22007-07-11 17:01:13 +00004016 break;
4017 case tok::kw_restrict:
John McCallfec54012009-08-03 20:12:06 +00004018 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
Richard Smithd654f2d2012-10-17 23:31:46 +00004019 getLangOpts());
Reid Spencer5f016e22007-07-11 17:01:13 +00004020 break;
Peter Collingbourne207f4d82011-03-18 22:38:29 +00004021
4022 // OpenCL qualifiers:
Chad Rosier8decdee2012-06-26 22:30:43 +00004023 case tok::kw_private:
David Blaikie4e4d0842012-03-11 07:00:24 +00004024 if (!getLangOpts().OpenCL)
Peter Collingbourne207f4d82011-03-18 22:38:29 +00004025 goto DoneWithTypeQuals;
4026 case tok::kw___private:
4027 case tok::kw___global:
4028 case tok::kw___local:
4029 case tok::kw___constant:
4030 case tok::kw___read_only:
4031 case tok::kw___write_only:
4032 case tok::kw___read_write:
4033 ParseOpenCLQualifiers(DS);
4034 break;
4035
Eli Friedman290eeb02009-06-08 23:27:34 +00004036 case tok::kw___w64:
Steve Naroff86bc6cf2008-12-25 14:41:26 +00004037 case tok::kw___ptr64:
Francois Pichet58fd97a2011-08-25 00:36:46 +00004038 case tok::kw___ptr32:
Steve Naroff239f0732008-12-25 14:16:32 +00004039 case tok::kw___cdecl:
4040 case tok::kw___stdcall:
4041 case tok::kw___fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00004042 case tok::kw___thiscall:
Francois Pichet3bd9aa42011-08-18 09:59:55 +00004043 case tok::kw___unaligned:
Dawn Perchik52fc3142010-09-03 01:29:35 +00004044 if (VendorAttributesAllowed) {
John McCall7f040a92010-12-24 02:08:15 +00004045 ParseMicrosoftTypeAttributes(DS.getAttributes());
Eli Friedman290eeb02009-06-08 23:27:34 +00004046 continue;
4047 }
4048 goto DoneWithTypeQuals;
Dawn Perchik52fc3142010-09-03 01:29:35 +00004049 case tok::kw___pascal:
4050 if (VendorAttributesAllowed) {
John McCall7f040a92010-12-24 02:08:15 +00004051 ParseBorlandTypeAttributes(DS.getAttributes());
Dawn Perchik52fc3142010-09-03 01:29:35 +00004052 continue;
4053 }
4054 goto DoneWithTypeQuals;
Reid Spencer5f016e22007-07-11 17:01:13 +00004055 case tok::kw___attribute:
Dawn Perchik52fc3142010-09-03 01:29:35 +00004056 if (VendorAttributesAllowed) {
John McCall7f040a92010-12-24 02:08:15 +00004057 ParseGNUAttributes(DS.getAttributes());
Chris Lattner5a69d1c2008-12-18 07:02:59 +00004058 continue; // do *not* consume the next token!
4059 }
4060 // otherwise, FALL THROUGH!
4061 default:
Steve Naroff239f0732008-12-25 14:16:32 +00004062 DoneWithTypeQuals:
Chris Lattner5a69d1c2008-12-18 07:02:59 +00004063 // If this is not a type-qualifier token, we're done reading type
4064 // qualifiers. First verify that DeclSpec's are consistent.
Douglas Gregor9b3064b2009-04-01 22:41:11 +00004065 DS.Finish(Diags, PP);
Abramo Bagnara796aa442011-03-12 11:17:06 +00004066 if (EndLoc.isValid())
4067 DS.SetRangeEnd(EndLoc);
Chris Lattner5a69d1c2008-12-18 07:02:59 +00004068 return;
Reid Spencer5f016e22007-07-11 17:01:13 +00004069 }
Chris Lattnera1fcbad2008-12-18 06:50:14 +00004070
Reid Spencer5f016e22007-07-11 17:01:13 +00004071 // If the specifier combination wasn't legal, issue a diagnostic.
4072 if (isInvalid) {
4073 assert(PrevSpec && "Method did not return previous specifier!");
Chris Lattner1ab3b962008-11-18 07:48:38 +00004074 Diag(Tok, DiagID) << PrevSpec;
Reid Spencer5f016e22007-07-11 17:01:13 +00004075 }
Abramo Bagnara796aa442011-03-12 11:17:06 +00004076 EndLoc = ConsumeToken();
Reid Spencer5f016e22007-07-11 17:01:13 +00004077 }
4078}
4079
4080
4081/// ParseDeclarator - Parse and verify a newly-initialized declarator.
4082///
4083void Parser::ParseDeclarator(Declarator &D) {
4084 /// This implements the 'declarator' production in the C grammar, then checks
4085 /// for well-formedness and issues diagnostics.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004086 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
Reid Spencer5f016e22007-07-11 17:01:13 +00004087}
4088
Richard Smith9988f282012-03-29 01:16:42 +00004089static bool isPtrOperatorToken(tok::TokenKind Kind, const LangOptions &Lang) {
4090 if (Kind == tok::star || Kind == tok::caret)
4091 return true;
4092
4093 // We parse rvalue refs in C++03, because otherwise the errors are scary.
4094 if (!Lang.CPlusPlus)
4095 return false;
4096
4097 return Kind == tok::amp || Kind == tok::ampamp;
4098}
4099
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004100/// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator
4101/// is parsed by the function passed to it. Pass null, and the direct-declarator
4102/// isn't parsed at all, making this function effectively parse the C++
Douglas Gregor2f1bc522008-11-07 20:08:42 +00004103/// ptr-operator production.
4104///
Richard Smith0706df42011-10-19 21:33:05 +00004105/// If the grammar of this construct is extended, matching changes must also be
Richard Smith5d8388c2012-03-27 01:42:32 +00004106/// made to TryParseDeclarator and MightBeDeclarator, and possibly to
4107/// isConstructorDeclarator.
Richard Smith0706df42011-10-19 21:33:05 +00004108///
Sebastian Redlf30208a2009-01-24 21:16:55 +00004109/// declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
4110/// [C] pointer[opt] direct-declarator
4111/// [C++] direct-declarator
4112/// [C++] ptr-operator declarator
Reid Spencer5f016e22007-07-11 17:01:13 +00004113///
4114/// pointer: [C99 6.7.5]
4115/// '*' type-qualifier-list[opt]
4116/// '*' type-qualifier-list[opt] pointer
4117///
Douglas Gregor2f1bc522008-11-07 20:08:42 +00004118/// ptr-operator:
4119/// '*' cv-qualifier-seq[opt]
4120/// '&'
Sebastian Redl05532f22009-03-15 22:02:01 +00004121/// [C++0x] '&&'
Douglas Gregor2f1bc522008-11-07 20:08:42 +00004122/// [GNU] '&' restrict[opt] attributes[opt]
Sebastian Redl05532f22009-03-15 22:02:01 +00004123/// [GNU?] '&&' restrict[opt] attributes[opt]
Sebastian Redlf30208a2009-01-24 21:16:55 +00004124/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004125void Parser::ParseDeclaratorInternal(Declarator &D,
4126 DirectDeclParseFunction DirectDeclParser) {
Douglas Gregor91a28862009-08-26 14:27:30 +00004127 if (Diags.hasAllExtensionsSilenced())
4128 D.setExtension();
Chad Rosier8decdee2012-06-26 22:30:43 +00004129
Sebastian Redlf30208a2009-01-24 21:16:55 +00004130 // C++ member pointers start with a '::' or a nested-name.
4131 // Member pointers get special handling, since there's no place for the
4132 // scope spec in the generic path below.
David Blaikie4e4d0842012-03-11 07:00:24 +00004133 if (getLangOpts().CPlusPlus &&
Chris Lattnerf919bfe2009-03-24 17:04:48 +00004134 (Tok.is(tok::coloncolon) || Tok.is(tok::identifier) ||
4135 Tok.is(tok::annot_cxxscope))) {
Douglas Gregorefaa93a2011-11-07 17:33:42 +00004136 bool EnteringContext = D.getContext() == Declarator::FileContext ||
4137 D.getContext() == Declarator::MemberContext;
Sebastian Redlf30208a2009-01-24 21:16:55 +00004138 CXXScopeSpec SS;
Douglas Gregorefaa93a2011-11-07 17:33:42 +00004139 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext);
John McCall9ba61662010-02-26 08:45:28 +00004140
Jeffrey Yasskinedc28772010-04-07 23:29:58 +00004141 if (SS.isNotEmpty()) {
Mike Stump1eb44332009-09-09 15:08:12 +00004142 if (Tok.isNot(tok::star)) {
Sebastian Redlf30208a2009-01-24 21:16:55 +00004143 // The scope spec really belongs to the direct-declarator.
4144 D.getCXXScopeSpec() = SS;
4145 if (DirectDeclParser)
4146 (this->*DirectDeclParser)(D);
4147 return;
4148 }
4149
4150 SourceLocation Loc = ConsumeToken();
Sebastian Redlab197ba2009-02-09 18:23:29 +00004151 D.SetRangeEnd(Loc);
John McCall0b7e6782011-03-24 11:26:52 +00004152 DeclSpec DS(AttrFactory);
Sebastian Redlf30208a2009-01-24 21:16:55 +00004153 ParseTypeQualifierListOpt(DS);
Sebastian Redlab197ba2009-02-09 18:23:29 +00004154 D.ExtendWithDeclSpec(DS);
Sebastian Redlf30208a2009-01-24 21:16:55 +00004155
4156 // Recurse to parse whatever is left.
4157 ParseDeclaratorInternal(D, DirectDeclParser);
4158
4159 // Sema will have to catch (syntactically invalid) pointers into global
4160 // scope. It has to catch pointers into namespace scope anyway.
4161 D.AddTypeInfo(DeclaratorChunk::getMemberPointer(SS,DS.getTypeQualifiers(),
John McCall0b7e6782011-03-24 11:26:52 +00004162 Loc),
4163 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00004164 /* Don't replace range end. */SourceLocation());
Sebastian Redlf30208a2009-01-24 21:16:55 +00004165 return;
4166 }
4167 }
4168
4169 tok::TokenKind Kind = Tok.getKind();
Steve Naroff5618bd42008-08-27 16:04:49 +00004170 // Not a pointer, C++ reference, or block.
Richard Smith9988f282012-03-29 01:16:42 +00004171 if (!isPtrOperatorToken(Kind, getLangOpts())) {
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004172 if (DirectDeclParser)
4173 (this->*DirectDeclParser)(D);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00004174 return;
4175 }
Sebastian Redlf30208a2009-01-24 21:16:55 +00004176
Sebastian Redl05532f22009-03-15 22:02:01 +00004177 // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference,
4178 // '&&' -> rvalue reference
Sebastian Redl743de1f2009-03-23 00:00:23 +00004179 SourceLocation Loc = ConsumeToken(); // Eat the *, ^, & or &&.
Sebastian Redlab197ba2009-02-09 18:23:29 +00004180 D.SetRangeEnd(Loc);
Reid Spencer5f016e22007-07-11 17:01:13 +00004181
Chris Lattner9af55002009-03-27 04:18:06 +00004182 if (Kind == tok::star || Kind == tok::caret) {
Chris Lattner76549142008-02-21 01:32:26 +00004183 // Is a pointer.
John McCall0b7e6782011-03-24 11:26:52 +00004184 DeclSpec DS(AttrFactory);
Sebastian Redlf30208a2009-01-24 21:16:55 +00004185
Richard Smith6ee326a2012-04-10 01:32:12 +00004186 // FIXME: GNU attributes are not allowed here in a new-type-id.
Reid Spencer5f016e22007-07-11 17:01:13 +00004187 ParseTypeQualifierListOpt(DS);
Sebastian Redlab197ba2009-02-09 18:23:29 +00004188 D.ExtendWithDeclSpec(DS);
Sebastian Redlf30208a2009-01-24 21:16:55 +00004189
Reid Spencer5f016e22007-07-11 17:01:13 +00004190 // Recursively parse the declarator.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004191 ParseDeclaratorInternal(D, DirectDeclParser);
Steve Naroff5618bd42008-08-27 16:04:49 +00004192 if (Kind == tok::star)
4193 // Remember that we parsed a pointer type, and remember the type-quals.
4194 D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc,
Chandler Carruthd067c072011-02-23 18:51:59 +00004195 DS.getConstSpecLoc(),
4196 DS.getVolatileSpecLoc(),
John McCall0b7e6782011-03-24 11:26:52 +00004197 DS.getRestrictSpecLoc()),
4198 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00004199 SourceLocation());
Steve Naroff5618bd42008-08-27 16:04:49 +00004200 else
4201 // Remember that we parsed a Block type, and remember the type-quals.
Mike Stump1eb44332009-09-09 15:08:12 +00004202 D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(),
John McCall0b7e6782011-03-24 11:26:52 +00004203 Loc),
4204 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00004205 SourceLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00004206 } else {
4207 // Is a reference
John McCall0b7e6782011-03-24 11:26:52 +00004208 DeclSpec DS(AttrFactory);
Reid Spencer5f016e22007-07-11 17:01:13 +00004209
Sebastian Redl743de1f2009-03-23 00:00:23 +00004210 // Complain about rvalue references in C++03, but then go on and build
4211 // the declarator.
Richard Smith7fe62082011-10-15 05:09:34 +00004212 if (Kind == tok::ampamp)
David Blaikie4e4d0842012-03-11 07:00:24 +00004213 Diag(Loc, getLangOpts().CPlusPlus0x ?
Richard Smith7fe62082011-10-15 05:09:34 +00004214 diag::warn_cxx98_compat_rvalue_reference :
4215 diag::ext_rvalue_reference);
Sebastian Redl743de1f2009-03-23 00:00:23 +00004216
Richard Smith6ee326a2012-04-10 01:32:12 +00004217 // GNU-style and C++11 attributes are allowed here, as is restrict.
4218 ParseTypeQualifierListOpt(DS);
4219 D.ExtendWithDeclSpec(DS);
4220
Reid Spencer5f016e22007-07-11 17:01:13 +00004221 // C++ 8.3.2p1: cv-qualified references are ill-formed except when the
4222 // cv-qualifiers are introduced through the use of a typedef or of a
4223 // template type argument, in which case the cv-qualifiers are ignored.
Reid Spencer5f016e22007-07-11 17:01:13 +00004224 if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
4225 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
4226 Diag(DS.getConstSpecLoc(),
Chris Lattner1ab3b962008-11-18 07:48:38 +00004227 diag::err_invalid_reference_qualifier_application) << "const";
Reid Spencer5f016e22007-07-11 17:01:13 +00004228 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
4229 Diag(DS.getVolatileSpecLoc(),
Chris Lattner1ab3b962008-11-18 07:48:38 +00004230 diag::err_invalid_reference_qualifier_application) << "volatile";
Reid Spencer5f016e22007-07-11 17:01:13 +00004231 }
4232
4233 // Recursively parse the declarator.
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004234 ParseDeclaratorInternal(D, DirectDeclParser);
Reid Spencer5f016e22007-07-11 17:01:13 +00004235
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00004236 if (D.getNumTypeObjects() > 0) {
4237 // C++ [dcl.ref]p4: There shall be no references to references.
4238 DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1);
4239 if (InnerChunk.Kind == DeclaratorChunk::Reference) {
Chris Lattnerda83bac2008-11-19 07:37:42 +00004240 if (const IdentifierInfo *II = D.getIdentifier())
4241 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
4242 << II;
4243 else
4244 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
4245 << "type name";
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00004246
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004247 // Once we've complained about the reference-to-reference, we
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +00004248 // can go ahead and build the (technically ill-formed)
4249 // declarator: reference collapsing will take care of it.
4250 }
4251 }
4252
Reid Spencer5f016e22007-07-11 17:01:13 +00004253 // Remember that we parsed a reference type. It doesn't have type-quals.
Chris Lattner76549142008-02-21 01:32:26 +00004254 D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc,
Sebastian Redl05532f22009-03-15 22:02:01 +00004255 Kind == tok::amp),
John McCall0b7e6782011-03-24 11:26:52 +00004256 DS.getAttributes(),
Sebastian Redlab197ba2009-02-09 18:23:29 +00004257 SourceLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00004258 }
4259}
4260
Richard Smith9988f282012-03-29 01:16:42 +00004261static void diagnoseMisplacedEllipsis(Parser &P, Declarator &D,
4262 SourceLocation EllipsisLoc) {
4263 if (EllipsisLoc.isValid()) {
4264 FixItHint Insertion;
4265 if (!D.getEllipsisLoc().isValid()) {
4266 Insertion = FixItHint::CreateInsertion(D.getIdentifierLoc(), "...");
4267 D.setEllipsisLoc(EllipsisLoc);
4268 }
4269 P.Diag(EllipsisLoc, diag::err_misplaced_ellipsis_in_declaration)
4270 << FixItHint::CreateRemoval(EllipsisLoc) << Insertion << !D.hasName();
4271 }
4272}
4273
Reid Spencer5f016e22007-07-11 17:01:13 +00004274/// ParseDirectDeclarator
4275/// direct-declarator: [C99 6.7.5]
Douglas Gregor42a552f2008-11-05 20:51:48 +00004276/// [C99] identifier
Reid Spencer5f016e22007-07-11 17:01:13 +00004277/// '(' declarator ')'
4278/// [GNU] '(' attributes declarator ')'
4279/// [C90] direct-declarator '[' constant-expression[opt] ']'
4280/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
4281/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
4282/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
4283/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
Richard Smith6ee326a2012-04-10 01:32:12 +00004284/// [C++11] direct-declarator '[' constant-expression[opt] ']'
4285/// attribute-specifier-seq[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00004286/// direct-declarator '(' parameter-type-list ')'
4287/// direct-declarator '(' identifier-list[opt] ')'
4288/// [GNU] direct-declarator '(' parameter-forward-declarations
4289/// parameter-type-list[opt] ')'
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00004290/// [C++] direct-declarator '(' parameter-declaration-clause ')'
4291/// cv-qualifier-seq[opt] exception-specification[opt]
Richard Smith6ee326a2012-04-10 01:32:12 +00004292/// [C++11] direct-declarator '(' parameter-declaration-clause ')'
4293/// attribute-specifier-seq[opt] cv-qualifier-seq[opt]
4294/// ref-qualifier[opt] exception-specification[opt]
Douglas Gregorb48fe382008-10-31 09:07:45 +00004295/// [C++] declarator-id
Richard Smith6ee326a2012-04-10 01:32:12 +00004296/// [C++11] declarator-id attribute-specifier-seq[opt]
Douglas Gregor42a552f2008-11-05 20:51:48 +00004297///
4298/// declarator-id: [C++ 8]
Douglas Gregora8bc8c92010-12-23 22:44:42 +00004299/// '...'[opt] id-expression
Douglas Gregor42a552f2008-11-05 20:51:48 +00004300/// '::'[opt] nested-name-specifier[opt] type-name
4301///
4302/// id-expression: [C++ 5.1]
4303/// unqualified-id
Douglas Gregordb422df2009-09-25 21:45:23 +00004304/// qualified-id
Douglas Gregor42a552f2008-11-05 20:51:48 +00004305///
4306/// unqualified-id: [C++ 5.1]
Mike Stump1eb44332009-09-09 15:08:12 +00004307/// identifier
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00004308/// operator-function-id
Douglas Gregordb422df2009-09-25 21:45:23 +00004309/// conversion-function-id
Mike Stump1eb44332009-09-09 15:08:12 +00004310/// '~' class-name
Douglas Gregor39a8de12009-02-25 19:37:18 +00004311/// template-id
Argyrios Kyrtzidisc7ed9c62008-11-07 22:02:30 +00004312///
Richard Smith5d8388c2012-03-27 01:42:32 +00004313/// Note, any additional constructs added here may need corresponding changes
4314/// in isConstructorDeclarator.
Reid Spencer5f016e22007-07-11 17:01:13 +00004315void Parser::ParseDirectDeclarator(Declarator &D) {
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00004316 DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec());
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00004317
David Blaikie4e4d0842012-03-11 07:00:24 +00004318 if (getLangOpts().CPlusPlus && D.mayHaveIdentifier()) {
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004319 // ParseDeclaratorInternal might already have parsed the scope.
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00004320 if (D.getCXXScopeSpec().isEmpty()) {
Douglas Gregorefaa93a2011-11-07 17:33:42 +00004321 bool EnteringContext = D.getContext() == Declarator::FileContext ||
4322 D.getContext() == Declarator::MemberContext;
Chad Rosier8decdee2012-06-26 22:30:43 +00004323 ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec(), ParsedType(),
Douglas Gregorefaa93a2011-11-07 17:33:42 +00004324 EnteringContext);
John McCall9ba61662010-02-26 08:45:28 +00004325 }
4326
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00004327 if (D.getCXXScopeSpec().isValid()) {
Douglas Gregor23c94db2010-07-02 17:43:08 +00004328 if (Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec()))
John McCalle7e278b2009-12-11 20:04:54 +00004329 // Change the declaration context for name lookup, until this function
4330 // is exited (and the declarator has been parsed).
4331 DeclScopeObj.EnterDeclaratorScope();
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00004332 }
4333
Douglas Gregora8bc8c92010-12-23 22:44:42 +00004334 // C++0x [dcl.fct]p14:
4335 // There is a syntactic ambiguity when an ellipsis occurs at the end
Chad Rosier8decdee2012-06-26 22:30:43 +00004336 // of a parameter-declaration-clause without a preceding comma. In
4337 // this case, the ellipsis is parsed as part of the
4338 // abstract-declarator if the type of the parameter names a template
Douglas Gregora8bc8c92010-12-23 22:44:42 +00004339 // parameter pack that has not been expanded; otherwise, it is parsed
4340 // as part of the parameter-declaration-clause.
Richard Smith9988f282012-03-29 01:16:42 +00004341 if (Tok.is(tok::ellipsis) && D.getCXXScopeSpec().isEmpty() &&
Douglas Gregora8bc8c92010-12-23 22:44:42 +00004342 !((D.getContext() == Declarator::PrototypeContext ||
4343 D.getContext() == Declarator::BlockLiteralContext) &&
Douglas Gregora8bc8c92010-12-23 22:44:42 +00004344 NextToken().is(tok::r_paren) &&
Richard Smith9988f282012-03-29 01:16:42 +00004345 !Actions.containsUnexpandedParameterPacks(D))) {
4346 SourceLocation EllipsisLoc = ConsumeToken();
4347 if (isPtrOperatorToken(Tok.getKind(), getLangOpts())) {
4348 // The ellipsis was put in the wrong place. Recover, and explain to
4349 // the user what they should have done.
4350 ParseDeclarator(D);
4351 diagnoseMisplacedEllipsis(*this, D, EllipsisLoc);
4352 return;
4353 } else
4354 D.setEllipsisLoc(EllipsisLoc);
4355
4356 // The ellipsis can't be followed by a parenthesized declarator. We
4357 // check for that in ParseParenDeclarator, after we have disambiguated
4358 // the l_paren token.
4359 }
4360
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004361 if (Tok.is(tok::identifier) || Tok.is(tok::kw_operator) ||
4362 Tok.is(tok::annot_template_id) || Tok.is(tok::tilde)) {
4363 // We found something that indicates the start of an unqualified-id.
4364 // Parse that unqualified-id.
John McCallba9d8532010-04-13 06:39:49 +00004365 bool AllowConstructorName;
4366 if (D.getDeclSpec().hasTypeSpecifier())
4367 AllowConstructorName = false;
4368 else if (D.getCXXScopeSpec().isSet())
4369 AllowConstructorName =
4370 (D.getContext() == Declarator::FileContext ||
4371 (D.getContext() == Declarator::MemberContext &&
4372 D.getDeclSpec().isFriendSpecified()));
4373 else
4374 AllowConstructorName = (D.getContext() == Declarator::MemberContext);
4375
Abramo Bagnarae4b92762012-01-27 09:46:47 +00004376 SourceLocation TemplateKWLoc;
Chad Rosier8decdee2012-06-26 22:30:43 +00004377 if (ParseUnqualifiedId(D.getCXXScopeSpec(),
4378 /*EnteringContext=*/true,
4379 /*AllowDestructorName=*/true,
Douglas Gregor0efc2c12010-01-13 17:31:36 +00004380 AllowConstructorName,
John McCallb3d87482010-08-24 05:47:05 +00004381 ParsedType(),
Abramo Bagnarae4b92762012-01-27 09:46:47 +00004382 TemplateKWLoc,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00004383 D.getName()) ||
4384 // Once we're past the identifier, if the scope was bad, mark the
4385 // whole declarator bad.
4386 D.getCXXScopeSpec().isInvalid()) {
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00004387 D.SetIdentifier(0, Tok.getLocation());
4388 D.setInvalidType(true);
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004389 } else {
4390 // Parsed the unqualified-id; update range information and move along.
4391 if (D.getSourceRange().getBegin().isInvalid())
4392 D.SetRangeBegin(D.getName().getSourceRange().getBegin());
4393 D.SetRangeEnd(D.getName().getSourceRange().getEnd());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00004394 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004395 goto PastIdentifier;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00004396 }
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004397 } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
David Blaikie4e4d0842012-03-11 07:00:24 +00004398 assert(!getLangOpts().CPlusPlus &&
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00004399 "There's a C++-specific check for tok::identifier above");
4400 assert(Tok.getIdentifierInfo() && "Not an identifier?");
4401 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
4402 ConsumeToken();
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004403 goto PastIdentifier;
4404 }
Richard Smith9988f282012-03-29 01:16:42 +00004405
Douglas Gregor3f9a0562009-11-03 01:35:08 +00004406 if (Tok.is(tok::l_paren)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00004407 // direct-declarator: '(' declarator ')'
4408 // direct-declarator: '(' attributes declarator ')'
4409 // Example: 'char (*X)' or 'int (*XX)(void)'
4410 ParseParenDeclarator(D);
Douglas Gregor0efc2c12010-01-13 17:31:36 +00004411
4412 // If the declarator was parenthesized, we entered the declarator
4413 // scope when parsing the parenthesized declarator, then exited
4414 // the scope already. Re-enter the scope, if we need to.
4415 if (D.getCXXScopeSpec().isSet()) {
Fariborz Jahanian46877cd2010-08-17 23:50:37 +00004416 // If there was an error parsing parenthesized declarator, declarator
Richard Smith9988f282012-03-29 01:16:42 +00004417 // scope may have been entered before. Don't do it again.
Fariborz Jahanian46877cd2010-08-17 23:50:37 +00004418 if (!D.isInvalidType() &&
4419 Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec()))
Douglas Gregor0efc2c12010-01-13 17:31:36 +00004420 // Change the declaration context for name lookup, until this function
4421 // is exited (and the declarator has been parsed).
Fariborz Jahanian46877cd2010-08-17 23:50:37 +00004422 DeclScopeObj.EnterDeclaratorScope();
Douglas Gregor0efc2c12010-01-13 17:31:36 +00004423 }
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00004424 } else if (D.mayOmitIdentifier()) {
Reid Spencer5f016e22007-07-11 17:01:13 +00004425 // This could be something simple like "int" (in which case the declarator
4426 // portion is empty), if an abstract-declarator is allowed.
4427 D.SetIdentifier(0, Tok.getLocation());
4428 } else {
David Blaikiee75d9cf2012-06-29 22:03:56 +00004429 if (Tok.getKind() == tok::annot_pragma_parser_crash)
David Blaikie377da4c2012-08-21 18:56:49 +00004430 LLVM_BUILTIN_TRAP;
Douglas Gregore950d4b2009-03-06 23:28:18 +00004431 if (D.getContext() == Declarator::MemberContext)
4432 Diag(Tok, diag::err_expected_member_name_or_semi)
4433 << D.getDeclSpec().getSourceRange();
David Blaikie4e4d0842012-03-11 07:00:24 +00004434 else if (getLangOpts().CPlusPlus)
4435 Diag(Tok, diag::err_expected_unqualified_id) << getLangOpts().CPlusPlus;
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00004436 else
Chris Lattner1ab3b962008-11-18 07:48:38 +00004437 Diag(Tok, diag::err_expected_ident_lparen);
Reid Spencer5f016e22007-07-11 17:01:13 +00004438 D.SetIdentifier(0, Tok.getLocation());
Chris Lattner1f6f54b2008-11-11 06:13:16 +00004439 D.setInvalidType(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00004440 }
Mike Stump1eb44332009-09-09 15:08:12 +00004441
Argyrios Kyrtzidis314fe782008-11-26 22:40:03 +00004442 PastIdentifier:
Reid Spencer5f016e22007-07-11 17:01:13 +00004443 assert(D.isPastIdentifier() &&
4444 "Haven't past the location of the identifier yet?");
Mike Stump1eb44332009-09-09 15:08:12 +00004445
Richard Smith6ee326a2012-04-10 01:32:12 +00004446 // Don't parse attributes unless we have parsed an unparenthesized name.
4447 if (D.hasName() && !D.getNumTypeObjects())
John McCall7f040a92010-12-24 02:08:15 +00004448 MaybeParseCXX0XAttributes(D);
Sean Huntbbd37c62009-11-21 08:43:09 +00004449
Reid Spencer5f016e22007-07-11 17:01:13 +00004450 while (1) {
Chris Lattner04d66662007-10-09 17:33:22 +00004451 if (Tok.is(tok::l_paren)) {
David Blaikie42d6d0c2011-12-04 05:04:18 +00004452 // Enter function-declaration scope, limiting any declarators to the
4453 // function prototype scope, including parameter declarators.
4454 ParseScope PrototypeScope(this,
4455 Scope::FunctionPrototypeScope|Scope::DeclScope);
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004456 // The paren may be part of a C++ direct initializer, eg. "int x(1);".
4457 // In such a case, check if we actually have a function declarator; if it
4458 // is not, the declarator has been fully parsed.
Richard Smithb9c62612012-07-30 21:30:52 +00004459 bool IsAmbiguous = false;
Richard Smith05766812012-08-18 00:55:03 +00004460 if (getLangOpts().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) {
4461 // The name of the declarator, if any, is tentatively declared within
4462 // a possible direct initializer.
4463 TentativelyDeclaredIdentifiers.push_back(D.getIdentifier());
4464 bool IsFunctionDecl = isCXXFunctionDeclarator(&IsAmbiguous);
4465 TentativelyDeclaredIdentifiers.pop_back();
4466 if (!IsFunctionDecl)
4467 break;
4468 }
John McCall0b7e6782011-03-24 11:26:52 +00004469 ParsedAttributes attrs(AttrFactory);
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004470 BalancedDelimiterTracker T(*this, tok::l_paren);
4471 T.consumeOpen();
Richard Smithb9c62612012-07-30 21:30:52 +00004472 ParseFunctionDeclarator(D, attrs, T, IsAmbiguous);
David Blaikie42d6d0c2011-12-04 05:04:18 +00004473 PrototypeScope.Exit();
Chris Lattner04d66662007-10-09 17:33:22 +00004474 } else if (Tok.is(tok::l_square)) {
Reid Spencer5f016e22007-07-11 17:01:13 +00004475 ParseBracketDeclarator(D);
4476 } else {
4477 break;
4478 }
4479 }
Chad Rosier8decdee2012-06-26 22:30:43 +00004480}
Reid Spencer5f016e22007-07-11 17:01:13 +00004481
Chris Lattneref4715c2008-04-06 05:45:57 +00004482/// ParseParenDeclarator - We parsed the declarator D up to a paren. This is
4483/// only called before the identifier, so these are most likely just grouping
Mike Stump1eb44332009-09-09 15:08:12 +00004484/// parens for precedence. If we find that these are actually function
Chris Lattneref4715c2008-04-06 05:45:57 +00004485/// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator.
4486///
4487/// direct-declarator:
4488/// '(' declarator ')'
4489/// [GNU] '(' attributes declarator ')'
Chris Lattner7399ee02008-10-20 02:05:46 +00004490/// direct-declarator '(' parameter-type-list ')'
4491/// direct-declarator '(' identifier-list[opt] ')'
4492/// [GNU] direct-declarator '(' parameter-forward-declarations
4493/// parameter-type-list[opt] ')'
Chris Lattneref4715c2008-04-06 05:45:57 +00004494///
4495void Parser::ParseParenDeclarator(Declarator &D) {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004496 BalancedDelimiterTracker T(*this, tok::l_paren);
4497 T.consumeOpen();
4498
Chris Lattneref4715c2008-04-06 05:45:57 +00004499 assert(!D.isPastIdentifier() && "Should be called before passing identifier");
Mike Stump1eb44332009-09-09 15:08:12 +00004500
Chris Lattner7399ee02008-10-20 02:05:46 +00004501 // Eat any attributes before we look at whether this is a grouping or function
4502 // declarator paren. If this is a grouping paren, the attribute applies to
4503 // the type being built up, for example:
4504 // int (__attribute__(()) *x)(long y)
4505 // If this ends up not being a grouping paren, the attribute applies to the
4506 // first argument, for example:
4507 // int (__attribute__(()) int x)
4508 // In either case, we need to eat any attributes to be able to determine what
4509 // sort of paren this is.
4510 //
John McCall0b7e6782011-03-24 11:26:52 +00004511 ParsedAttributes attrs(AttrFactory);
Chris Lattner7399ee02008-10-20 02:05:46 +00004512 bool RequiresArg = false;
4513 if (Tok.is(tok::kw___attribute)) {
John McCall7f040a92010-12-24 02:08:15 +00004514 ParseGNUAttributes(attrs);
Mike Stump1eb44332009-09-09 15:08:12 +00004515
Chris Lattner7399ee02008-10-20 02:05:46 +00004516 // We require that the argument list (if this is a non-grouping paren) be
4517 // present even if the attribute list was empty.
4518 RequiresArg = true;
4519 }
Steve Naroff239f0732008-12-25 14:16:32 +00004520 // Eat any Microsoft extensions.
Eli Friedman290eeb02009-06-08 23:27:34 +00004521 if (Tok.is(tok::kw___cdecl) || Tok.is(tok::kw___stdcall) ||
Douglas Gregorf813a2c2010-05-18 16:57:00 +00004522 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___fastcall) ||
Francois Pichet3bd9aa42011-08-18 09:59:55 +00004523 Tok.is(tok::kw___w64) || Tok.is(tok::kw___ptr64) ||
Francois Pichet58fd97a2011-08-25 00:36:46 +00004524 Tok.is(tok::kw___ptr32) || Tok.is(tok::kw___unaligned)) {
John McCall7f040a92010-12-24 02:08:15 +00004525 ParseMicrosoftTypeAttributes(attrs);
Eli Friedman290eeb02009-06-08 23:27:34 +00004526 }
Dawn Perchik52fc3142010-09-03 01:29:35 +00004527 // Eat any Borland extensions.
Ted Kremenek8113ecf2010-11-10 05:59:39 +00004528 if (Tok.is(tok::kw___pascal))
John McCall7f040a92010-12-24 02:08:15 +00004529 ParseBorlandTypeAttributes(attrs);
Mike Stump1eb44332009-09-09 15:08:12 +00004530
Chris Lattneref4715c2008-04-06 05:45:57 +00004531 // If we haven't past the identifier yet (or where the identifier would be
4532 // stored, if this is an abstract declarator), then this is probably just
4533 // grouping parens. However, if this could be an abstract-declarator, then
4534 // this could also be the start of function arguments (consider 'void()').
4535 bool isGrouping;
Mike Stump1eb44332009-09-09 15:08:12 +00004536
Chris Lattneref4715c2008-04-06 05:45:57 +00004537 if (!D.mayOmitIdentifier()) {
4538 // If this can't be an abstract-declarator, this *must* be a grouping
4539 // paren, because we haven't seen the identifier yet.
4540 isGrouping = true;
4541 } else if (Tok.is(tok::r_paren) || // 'int()' is a function.
Richard Smith22592862012-03-27 23:05:05 +00004542 (getLangOpts().CPlusPlus && Tok.is(tok::ellipsis) &&
4543 NextToken().is(tok::r_paren)) || // C++ int(...)
Richard Smith6ce48a72012-04-11 04:01:28 +00004544 isDeclarationSpecifier() || // 'int(int)' is a function.
4545 isCXX11AttributeSpecifier()) { // 'int([[]]int)' is a function.
Chris Lattneref4715c2008-04-06 05:45:57 +00004546 // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is
4547 // considered to be a type, not a K&R identifier-list.
4548 isGrouping = false;
4549 } else {
4550 // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'.
4551 isGrouping = true;
4552 }
Mike Stump1eb44332009-09-09 15:08:12 +00004553
Chris Lattneref4715c2008-04-06 05:45:57 +00004554 // If this is a grouping paren, handle:
4555 // direct-declarator: '(' declarator ')'
4556 // direct-declarator: '(' attributes declarator ')'
4557 if (isGrouping) {
Richard Smith9988f282012-03-29 01:16:42 +00004558 SourceLocation EllipsisLoc = D.getEllipsisLoc();
4559 D.setEllipsisLoc(SourceLocation());
4560
Argyrios Kyrtzidis3f2a8a02008-10-07 10:21:57 +00004561 bool hadGroupingParens = D.hasGroupingParens();
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00004562 D.setGroupingParens(true);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00004563 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
Chris Lattneref4715c2008-04-06 05:45:57 +00004564 // Match the ')'.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004565 T.consumeClose();
Chad Rosier8decdee2012-06-26 22:30:43 +00004566 D.AddTypeInfo(DeclaratorChunk::getParen(T.getOpenLocation(),
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004567 T.getCloseLocation()),
4568 attrs, T.getCloseLocation());
Argyrios Kyrtzidis3f2a8a02008-10-07 10:21:57 +00004569
4570 D.setGroupingParens(hadGroupingParens);
Richard Smith9988f282012-03-29 01:16:42 +00004571
4572 // An ellipsis cannot be placed outside parentheses.
4573 if (EllipsisLoc.isValid())
4574 diagnoseMisplacedEllipsis(*this, D, EllipsisLoc);
4575
Chris Lattneref4715c2008-04-06 05:45:57 +00004576 return;
4577 }
Mike Stump1eb44332009-09-09 15:08:12 +00004578
Chris Lattneref4715c2008-04-06 05:45:57 +00004579 // Okay, if this wasn't a grouping paren, it must be the start of a function
4580 // argument list. Recognize that this declarator will never have an
Chris Lattner7399ee02008-10-20 02:05:46 +00004581 // identifier (and remember where it would have been), then call into
4582 // ParseFunctionDeclarator to handle of argument list.
Chris Lattneref4715c2008-04-06 05:45:57 +00004583 D.SetIdentifier(0, Tok.getLocation());
4584
David Blaikie42d6d0c2011-12-04 05:04:18 +00004585 // Enter function-declaration scope, limiting any declarators to the
4586 // function prototype scope, including parameter declarators.
4587 ParseScope PrototypeScope(this,
4588 Scope::FunctionPrototypeScope|Scope::DeclScope);
Richard Smithb9c62612012-07-30 21:30:52 +00004589 ParseFunctionDeclarator(D, attrs, T, false, RequiresArg);
David Blaikie42d6d0c2011-12-04 05:04:18 +00004590 PrototypeScope.Exit();
Chris Lattneref4715c2008-04-06 05:45:57 +00004591}
4592
4593/// ParseFunctionDeclarator - We are after the identifier and have parsed the
4594/// declarator D up to a paren, which indicates that we are parsing function
4595/// arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00004596///
Richard Smith6ee326a2012-04-10 01:32:12 +00004597/// If FirstArgAttrs is non-null, then the caller parsed those arguments
4598/// immediately after the open paren - they should be considered to be the
4599/// first argument of a parameter.
Chris Lattner7399ee02008-10-20 02:05:46 +00004600///
Richard Smith6ee326a2012-04-10 01:32:12 +00004601/// If RequiresArg is true, then the first argument of the function is required
4602/// to be present and required to not be an identifier list.
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004603///
Richard Smith6ee326a2012-04-10 01:32:12 +00004604/// For C++, after the parameter-list, it also parses the cv-qualifier-seq[opt],
4605/// (C++11) ref-qualifier[opt], exception-specification[opt],
4606/// (C++11) attribute-specifier-seq[opt], and (C++11) trailing-return-type[opt].
4607///
4608/// [C++11] exception-specification:
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004609/// dynamic-exception-specification
4610/// noexcept-specification
4611///
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004612void Parser::ParseFunctionDeclarator(Declarator &D,
Richard Smith6ee326a2012-04-10 01:32:12 +00004613 ParsedAttributes &FirstArgAttrs,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004614 BalancedDelimiterTracker &Tracker,
Richard Smithb9c62612012-07-30 21:30:52 +00004615 bool IsAmbiguous,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004616 bool RequiresArg) {
Chad Rosier8decdee2012-06-26 22:30:43 +00004617 assert(getCurScope()->isFunctionPrototypeScope() &&
David Blaikie42d6d0c2011-12-04 05:04:18 +00004618 "Should call from a Function scope");
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004619 // lparen is already consumed!
4620 assert(D.isPastIdentifier() && "Should not call before identifier!");
4621
4622 // This should be true when the function has typed arguments.
4623 // Otherwise, it is treated as a K&R-style function.
4624 bool HasProto = false;
4625 // Build up an array of information about the parsed arguments.
Chris Lattner5f9e2722011-07-23 10:55:15 +00004626 SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004627 // Remember where we see an ellipsis, if any.
4628 SourceLocation EllipsisLoc;
4629
4630 DeclSpec DS(AttrFactory);
4631 bool RefQualifierIsLValueRef = true;
4632 SourceLocation RefQualifierLoc;
Douglas Gregor43f51032011-10-19 06:04:55 +00004633 SourceLocation ConstQualifierLoc;
4634 SourceLocation VolatileQualifierLoc;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004635 ExceptionSpecificationType ESpecType = EST_None;
4636 SourceRange ESpecRange;
Chris Lattner5f9e2722011-07-23 10:55:15 +00004637 SmallVector<ParsedType, 2> DynamicExceptions;
4638 SmallVector<SourceRange, 2> DynamicExceptionRanges;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004639 ExprResult NoexceptExpr;
Richard Smith6ee326a2012-04-10 01:32:12 +00004640 ParsedAttributes FnAttrs(AttrFactory);
Richard Smith54655be2012-06-12 01:51:59 +00004641 TypeResult TrailingReturnType;
Richard Smith6ee326a2012-04-10 01:32:12 +00004642
James Molloy16f1f712012-02-29 10:24:19 +00004643 Actions.ActOnStartFunctionDeclarator();
4644
Abramo Bagnaraac8ea052012-10-15 21:05:46 +00004645 /* LocalEndLoc is the end location for the local FunctionTypeLoc.
4646 EndLoc is the end location for the function declarator.
4647 They differ for trailing return types. */
4648 SourceLocation StartLoc, LocalEndLoc, EndLoc;
Abramo Bagnara59c0a812012-10-04 21:42:10 +00004649 SourceLocation LParenLoc, RParenLoc;
4650 LParenLoc = Tracker.getOpenLocation();
4651 StartLoc = LParenLoc;
4652
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004653 if (isFunctionDeclaratorIdentifierList()) {
4654 if (RequiresArg)
4655 Diag(Tok, diag::err_argument_required_after_attribute);
4656
4657 ParseFunctionDeclaratorIdentifierList(D, ParamInfo);
4658
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004659 Tracker.consumeClose();
Abramo Bagnara59c0a812012-10-04 21:42:10 +00004660 RParenLoc = Tracker.getCloseLocation();
Abramo Bagnaraac8ea052012-10-15 21:05:46 +00004661 LocalEndLoc = RParenLoc;
Abramo Bagnara59c0a812012-10-04 21:42:10 +00004662 EndLoc = RParenLoc;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004663 } else {
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004664 if (Tok.isNot(tok::r_paren))
Richard Smith6ee326a2012-04-10 01:32:12 +00004665 ParseParameterDeclarationClause(D, FirstArgAttrs, ParamInfo, EllipsisLoc);
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004666 else if (RequiresArg)
4667 Diag(Tok, diag::err_argument_required_after_attribute);
4668
David Blaikie4e4d0842012-03-11 07:00:24 +00004669 HasProto = ParamInfo.size() || getLangOpts().CPlusPlus;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004670
4671 // If we have the closing ')', eat it.
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004672 Tracker.consumeClose();
Abramo Bagnara59c0a812012-10-04 21:42:10 +00004673 RParenLoc = Tracker.getCloseLocation();
Abramo Bagnaraac8ea052012-10-15 21:05:46 +00004674 LocalEndLoc = RParenLoc;
Abramo Bagnara59c0a812012-10-04 21:42:10 +00004675 EndLoc = RParenLoc;
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004676
David Blaikie4e4d0842012-03-11 07:00:24 +00004677 if (getLangOpts().CPlusPlus) {
Richard Smith6ee326a2012-04-10 01:32:12 +00004678 // FIXME: Accept these components in any order, and produce fixits to
4679 // correct the order if the user gets it wrong. Ideally we should deal
4680 // with the virt-specifier-seq and pure-specifier in the same way.
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004681
4682 // Parse cv-qualifier-seq[opt].
Richard Smith6ee326a2012-04-10 01:32:12 +00004683 ParseTypeQualifierListOpt(DS, false /*no attributes*/, false);
4684 if (!DS.getSourceRange().getEnd().isInvalid()) {
4685 EndLoc = DS.getSourceRange().getEnd();
4686 ConstQualifierLoc = DS.getConstSpecLoc();
4687 VolatileQualifierLoc = DS.getVolatileSpecLoc();
4688 }
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004689
4690 // Parse ref-qualifier[opt].
4691 if (Tok.is(tok::amp) || Tok.is(tok::ampamp)) {
David Blaikie4e4d0842012-03-11 07:00:24 +00004692 Diag(Tok, getLangOpts().CPlusPlus0x ?
Richard Smith7fe62082011-10-15 05:09:34 +00004693 diag::warn_cxx98_compat_ref_qualifier :
4694 diag::ext_ref_qualifier);
Richard Smith6ee326a2012-04-10 01:32:12 +00004695
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004696 RefQualifierIsLValueRef = Tok.is(tok::amp);
4697 RefQualifierLoc = ConsumeToken();
4698 EndLoc = RefQualifierLoc;
4699 }
4700
Douglas Gregorcefc3af2012-04-16 07:05:22 +00004701 // C++11 [expr.prim.general]p3:
Chad Rosier8decdee2012-06-26 22:30:43 +00004702 // If a declaration declares a member function or member function
4703 // template of a class X, the expression this is a prvalue of type
Douglas Gregorcefc3af2012-04-16 07:05:22 +00004704 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
Chad Rosier8decdee2012-06-26 22:30:43 +00004705 // and the end of the function-definition, member-declarator, or
Douglas Gregorcefc3af2012-04-16 07:05:22 +00004706 // declarator.
Chad Rosier8decdee2012-06-26 22:30:43 +00004707 bool IsCXX11MemberFunction =
Douglas Gregorcefc3af2012-04-16 07:05:22 +00004708 getLangOpts().CPlusPlus0x &&
4709 (D.getContext() == Declarator::MemberContext ||
4710 (D.getContext() == Declarator::FileContext &&
Chad Rosier8decdee2012-06-26 22:30:43 +00004711 D.getCXXScopeSpec().isValid() &&
Douglas Gregorcefc3af2012-04-16 07:05:22 +00004712 Actions.CurContext->isRecord()));
4713 Sema::CXXThisScopeRAII ThisScope(Actions,
4714 dyn_cast<CXXRecordDecl>(Actions.CurContext),
4715 DS.getTypeQualifiers(),
4716 IsCXX11MemberFunction);
Richard Smitha058fd42012-05-02 22:22:32 +00004717
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004718 // Parse exception-specification[opt].
Richard Smitha058fd42012-05-02 22:22:32 +00004719 ESpecType = tryParseExceptionSpecification(ESpecRange,
Douglas Gregor74e2fc32012-04-16 18:27:27 +00004720 DynamicExceptions,
4721 DynamicExceptionRanges,
Richard Smitha058fd42012-05-02 22:22:32 +00004722 NoexceptExpr);
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004723 if (ESpecType != EST_None)
4724 EndLoc = ESpecRange.getEnd();
4725
Richard Smith6ee326a2012-04-10 01:32:12 +00004726 // Parse attribute-specifier-seq[opt]. Per DR 979 and DR 1297, this goes
4727 // after the exception-specification.
4728 MaybeParseCXX0XAttributes(FnAttrs);
4729
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004730 // Parse trailing-return-type[opt].
Abramo Bagnaraac8ea052012-10-15 21:05:46 +00004731 LocalEndLoc = EndLoc;
David Blaikie4e4d0842012-03-11 07:00:24 +00004732 if (getLangOpts().CPlusPlus0x && Tok.is(tok::arrow)) {
Richard Smith7fe62082011-10-15 05:09:34 +00004733 Diag(Tok, diag::warn_cxx98_compat_trailing_return_type);
Abramo Bagnara59c0a812012-10-04 21:42:10 +00004734 if (D.getDeclSpec().getTypeSpecType() == TST_auto)
4735 StartLoc = D.getDeclSpec().getTypeSpecTypeLoc();
Abramo Bagnaraac8ea052012-10-15 21:05:46 +00004736 LocalEndLoc = Tok.getLocation();
Douglas Gregorae7902c2011-08-04 15:30:47 +00004737 SourceRange Range;
Richard Smith54655be2012-06-12 01:51:59 +00004738 TrailingReturnType = ParseTrailingReturnType(Range);
Abramo Bagnaraac8ea052012-10-15 21:05:46 +00004739 EndLoc = Range.getEnd();
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004740 }
4741 }
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004742 }
4743
4744 // Remember that we parsed a function type, and remember the attributes.
4745 D.AddTypeInfo(DeclaratorChunk::getFunction(HasProto,
Abramo Bagnara59c0a812012-10-04 21:42:10 +00004746 IsAmbiguous,
4747 LParenLoc,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004748 ParamInfo.data(), ParamInfo.size(),
Abramo Bagnara59c0a812012-10-04 21:42:10 +00004749 EllipsisLoc, RParenLoc,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004750 DS.getTypeQualifiers(),
4751 RefQualifierIsLValueRef,
Douglas Gregor43f51032011-10-19 06:04:55 +00004752 RefQualifierLoc, ConstQualifierLoc,
4753 VolatileQualifierLoc,
Douglas Gregor90ebed02011-07-13 21:47:47 +00004754 /*MutableLoc=*/SourceLocation(),
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004755 ESpecType, ESpecRange.getBegin(),
4756 DynamicExceptions.data(),
4757 DynamicExceptionRanges.data(),
4758 DynamicExceptions.size(),
4759 NoexceptExpr.isUsable() ?
4760 NoexceptExpr.get() : 0,
Abramo Bagnaraac8ea052012-10-15 21:05:46 +00004761 StartLoc, LocalEndLoc, D,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004762 TrailingReturnType),
Richard Smith6ee326a2012-04-10 01:32:12 +00004763 FnAttrs, EndLoc);
James Molloy16f1f712012-02-29 10:24:19 +00004764
4765 Actions.ActOnEndFunctionDeclarator();
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004766}
4767
4768/// isFunctionDeclaratorIdentifierList - This parameter list may have an
4769/// identifier list form for a K&R-style function: void foo(a,b,c)
4770///
4771/// Note that identifier-lists are only allowed for normal declarators, not for
4772/// abstract-declarators.
4773bool Parser::isFunctionDeclaratorIdentifierList() {
David Blaikie4e4d0842012-03-11 07:00:24 +00004774 return !getLangOpts().CPlusPlus
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004775 && Tok.is(tok::identifier)
4776 && !TryAltiVecVectorToken()
4777 // K&R identifier lists can't have typedefs as identifiers, per C99
4778 // 6.7.5.3p11.
4779 && (TryAnnotateTypeOrScopeToken() || !Tok.is(tok::annot_typename))
4780 // Identifier lists follow a really simple grammar: the identifiers can
4781 // be followed *only* by a ", identifier" or ")". However, K&R
4782 // identifier lists are really rare in the brave new modern world, and
4783 // it is very common for someone to typo a type in a non-K&R style
4784 // list. If we are presented with something like: "void foo(intptr x,
4785 // float y)", we don't want to start parsing the function declarator as
4786 // though it is a K&R style declarator just because intptr is an
4787 // invalid type.
4788 //
4789 // To handle this, we check to see if the token after the first
4790 // identifier is a "," or ")". Only then do we parse it as an
4791 // identifier list.
4792 && (NextToken().is(tok::comma) || NextToken().is(tok::r_paren));
4793}
4794
4795/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator
4796/// we found a K&R-style identifier list instead of a typed parameter list.
4797///
4798/// After returning, ParamInfo will hold the parsed parameters.
4799///
4800/// identifier-list: [C99 6.7.5]
4801/// identifier
4802/// identifier-list ',' identifier
4803///
4804void Parser::ParseFunctionDeclaratorIdentifierList(
4805 Declarator &D,
Chris Lattner5f9e2722011-07-23 10:55:15 +00004806 SmallVector<DeclaratorChunk::ParamInfo, 16> &ParamInfo) {
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004807 // If there was no identifier specified for the declarator, either we are in
4808 // an abstract-declarator, or we are in a parameter declarator which was found
4809 // to be abstract. In abstract-declarators, identifier lists are not valid:
4810 // diagnose this.
4811 if (!D.getIdentifier())
4812 Diag(Tok, diag::ext_ident_list_in_param);
4813
4814 // Maintain an efficient lookup of params we have seen so far.
4815 llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
4816
4817 while (1) {
4818 // If this isn't an identifier, report the error and skip until ')'.
4819 if (Tok.isNot(tok::identifier)) {
4820 Diag(Tok, diag::err_expected_ident);
4821 SkipUntil(tok::r_paren, /*StopAtSemi=*/true, /*DontConsume=*/true);
4822 // Forget we parsed anything.
4823 ParamInfo.clear();
4824 return;
4825 }
4826
4827 IdentifierInfo *ParmII = Tok.getIdentifierInfo();
4828
4829 // Reject 'typedef int y; int test(x, y)', but continue parsing.
4830 if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope()))
4831 Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;
4832
4833 // Verify that the argument identifier has not already been mentioned.
4834 if (!ParamsSoFar.insert(ParmII)) {
4835 Diag(Tok, diag::err_param_redefinition) << ParmII;
4836 } else {
4837 // Remember this identifier in ParamInfo.
4838 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
4839 Tok.getLocation(),
4840 0));
4841 }
4842
4843 // Eat the identifier.
4844 ConsumeToken();
4845
4846 // The list continues if we see a comma.
4847 if (Tok.isNot(tok::comma))
4848 break;
4849 ConsumeToken();
4850 }
4851}
4852
4853/// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list
4854/// after the opening parenthesis. This function will not parse a K&R-style
4855/// identifier list.
4856///
Richard Smith6ce48a72012-04-11 04:01:28 +00004857/// D is the declarator being parsed. If FirstArgAttrs is non-null, then the
4858/// caller parsed those arguments immediately after the open paren - they should
4859/// be considered to be part of the first parameter.
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004860///
4861/// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will
4862/// be the location of the ellipsis, if any was parsed.
4863///
Reid Spencer5f016e22007-07-11 17:01:13 +00004864/// parameter-type-list: [C99 6.7.5]
4865/// parameter-list
4866/// parameter-list ',' '...'
Douglas Gregored5d6512009-09-22 21:41:40 +00004867/// [C++] parameter-list '...'
Reid Spencer5f016e22007-07-11 17:01:13 +00004868///
4869/// parameter-list: [C99 6.7.5]
4870/// parameter-declaration
4871/// parameter-list ',' parameter-declaration
4872///
4873/// parameter-declaration: [C99 6.7.5]
4874/// declaration-specifiers declarator
Chris Lattner04421082008-04-08 04:40:51 +00004875/// [C++] declaration-specifiers declarator '=' assignment-expression
Sebastian Redl84407ba2012-03-14 15:54:00 +00004876/// [C++11] initializer-clause
Reid Spencer5f016e22007-07-11 17:01:13 +00004877/// [GNU] declaration-specifiers declarator attributes
Sebastian Redl50de12f2009-03-24 22:27:57 +00004878/// declaration-specifiers abstract-declarator[opt]
4879/// [C++] declaration-specifiers abstract-declarator[opt]
Chris Lattner8123a952008-04-10 02:22:51 +00004880/// '=' assignment-expression
Reid Spencer5f016e22007-07-11 17:01:13 +00004881/// [GNU] declaration-specifiers abstract-declarator[opt] attributes
Richard Smith6ce48a72012-04-11 04:01:28 +00004882/// [C++11] attribute-specifier-seq parameter-declaration
Reid Spencer5f016e22007-07-11 17:01:13 +00004883///
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004884void Parser::ParseParameterDeclarationClause(
4885 Declarator &D,
Richard Smith6ce48a72012-04-11 04:01:28 +00004886 ParsedAttributes &FirstArgAttrs,
Chris Lattner5f9e2722011-07-23 10:55:15 +00004887 SmallVector<DeclaratorChunk::ParamInfo, 16> &ParamInfo,
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004888 SourceLocation &EllipsisLoc) {
Mike Stump1eb44332009-09-09 15:08:12 +00004889
Chris Lattnerf97409f2008-04-06 06:57:35 +00004890 while (1) {
4891 if (Tok.is(tok::ellipsis)) {
Richard Smith6ce48a72012-04-11 04:01:28 +00004892 // FIXME: Issue a diagnostic if we parsed an attribute-specifier-seq
4893 // before deciding this was a parameter-declaration-clause.
Douglas Gregor965acbb2009-02-18 07:07:28 +00004894 EllipsisLoc = ConsumeToken(); // Consume the ellipsis.
Chris Lattnerf97409f2008-04-06 06:57:35 +00004895 break;
Reid Spencer5f016e22007-07-11 17:01:13 +00004896 }
Mike Stump1eb44332009-09-09 15:08:12 +00004897
Chris Lattnerf97409f2008-04-06 06:57:35 +00004898 // Parse the declaration-specifiers.
John McCall54abf7d2009-11-04 02:18:39 +00004899 // Just use the ParsingDeclaration "scope" of the declarator.
John McCall0b7e6782011-03-24 11:26:52 +00004900 DeclSpec DS(AttrFactory);
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00004901
Richard Smith6ce48a72012-04-11 04:01:28 +00004902 // Parse any C++11 attributes.
4903 MaybeParseCXX0XAttributes(DS.getAttributes());
4904
John McCall7f040a92010-12-24 02:08:15 +00004905 // Skip any Microsoft attributes before a param.
David Blaikie4e4d0842012-03-11 07:00:24 +00004906 if (getLangOpts().MicrosoftExt && Tok.is(tok::l_square))
John McCall7f040a92010-12-24 02:08:15 +00004907 ParseMicrosoftAttributes(DS.getAttributes());
4908
4909 SourceLocation DSStart = Tok.getLocation();
Chris Lattner7399ee02008-10-20 02:05:46 +00004910
4911 // If the caller parsed attributes for the first argument, add them now.
John McCall7f040a92010-12-24 02:08:15 +00004912 // Take them so that we only apply the attributes to the first parameter.
Douglas Gregor3fd1ba02011-07-05 16:44:18 +00004913 // FIXME: If we can leave the attributes in the token stream somehow, we can
Richard Smith6ce48a72012-04-11 04:01:28 +00004914 // get rid of a parameter (FirstArgAttrs) and this statement. It might be
4915 // too much hassle.
4916 DS.takeAttributesFrom(FirstArgAttrs);
John McCall7f040a92010-12-24 02:08:15 +00004917
Chris Lattnere64c5492009-02-27 18:38:20 +00004918 ParseDeclarationSpecifiers(DS);
Mike Stump1eb44332009-09-09 15:08:12 +00004919
Chris Lattnerf97409f2008-04-06 06:57:35 +00004920 // Parse the declarator. This is "PrototypeContext", because we must
4921 // accept either 'declarator' or 'abstract-declarator' here.
4922 Declarator ParmDecl(DS, Declarator::PrototypeContext);
4923 ParseDeclarator(ParmDecl);
4924
4925 // Parse GNU attributes, if present.
John McCall7f040a92010-12-24 02:08:15 +00004926 MaybeParseGNUAttributes(ParmDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00004927
Chris Lattnerf97409f2008-04-06 06:57:35 +00004928 // Remember this parsed parameter in ParamInfo.
4929 IdentifierInfo *ParmII = ParmDecl.getIdentifier();
Mike Stump1eb44332009-09-09 15:08:12 +00004930
Douglas Gregor72b505b2008-12-16 21:30:33 +00004931 // DefArgToks is used when the parsing of default arguments needs
4932 // to be delayed.
4933 CachedTokens *DefArgToks = 0;
4934
Chris Lattnerf97409f2008-04-06 06:57:35 +00004935 // If no parameter was specified, verify that *something* was specified,
4936 // otherwise we have a missing type and identifier.
Chris Lattnere64c5492009-02-27 18:38:20 +00004937 if (DS.isEmpty() && ParmDecl.getIdentifier() == 0 &&
4938 ParmDecl.getNumTypeObjects() == 0) {
Chris Lattnerf97409f2008-04-06 06:57:35 +00004939 // Completely missing, emit error.
4940 Diag(DSStart, diag::err_missing_param);
4941 } else {
4942 // Otherwise, we have something. Add it and let semantic analysis try
4943 // to grok it and add the result to the ParamInfo we are building.
Mike Stump1eb44332009-09-09 15:08:12 +00004944
Chris Lattnerf97409f2008-04-06 06:57:35 +00004945 // Inform the actions module about the parameter declarator, so it gets
4946 // added to the current scope.
John McCalld226f652010-08-21 09:40:31 +00004947 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl);
Chris Lattner04421082008-04-08 04:40:51 +00004948
4949 // Parse the default argument, if any. We parse the default
4950 // arguments in all dialects; the semantic analysis in
4951 // ActOnParamDefaultArgument will reject the default argument in
4952 // C.
4953 if (Tok.is(tok::equal)) {
Douglas Gregor61366e92008-12-24 00:01:03 +00004954 SourceLocation EqualLoc = Tok.getLocation();
4955
Chris Lattner04421082008-04-08 04:40:51 +00004956 // Parse the default argument
Douglas Gregor72b505b2008-12-16 21:30:33 +00004957 if (D.getContext() == Declarator::MemberContext) {
4958 // If we're inside a class definition, cache the tokens
4959 // corresponding to the default argument. We'll actually parse
4960 // them when we see the end of the class definition.
Douglas Gregor72b505b2008-12-16 21:30:33 +00004961 // FIXME: Can we use a smart pointer for Toks?
4962 DefArgToks = new CachedTokens;
4963
Mike Stump1eb44332009-09-09 15:08:12 +00004964 if (!ConsumeAndStoreUntil(tok::comma, tok::r_paren, *DefArgToks,
Argyrios Kyrtzidis14b91622010-04-23 21:20:12 +00004965 /*StopAtSemi=*/true,
4966 /*ConsumeFinalToken=*/false)) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00004967 delete DefArgToks;
4968 DefArgToks = 0;
Douglas Gregor61366e92008-12-24 00:01:03 +00004969 Actions.ActOnParamDefaultArgumentError(Param);
Argyrios Kyrtzidis2b602ad2010-08-06 09:47:24 +00004970 } else {
4971 // Mark the end of the default argument so that we know when to
4972 // stop when we parse it later on.
4973 Token DefArgEnd;
4974 DefArgEnd.startToken();
4975 DefArgEnd.setKind(tok::cxx_defaultarg_end);
4976 DefArgEnd.setLocation(Tok.getLocation());
4977 DefArgToks->push_back(DefArgEnd);
Mike Stump1eb44332009-09-09 15:08:12 +00004978 Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc,
Anders Carlsson5e300d12009-06-12 16:51:40 +00004979 (*DefArgToks)[1].getLocation());
Argyrios Kyrtzidis2b602ad2010-08-06 09:47:24 +00004980 }
Chris Lattner04421082008-04-08 04:40:51 +00004981 } else {
Douglas Gregor72b505b2008-12-16 21:30:33 +00004982 // Consume the '='.
Douglas Gregor61366e92008-12-24 00:01:03 +00004983 ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00004984
Chad Rosier8decdee2012-06-26 22:30:43 +00004985 // The argument isn't actually potentially evaluated unless it is
Douglas Gregorbe0f7bd2010-09-11 20:24:53 +00004986 // used.
4987 EnterExpressionEvaluationContext Eval(Actions,
Douglas Gregorccc1b5e2012-02-21 00:37:24 +00004988 Sema::PotentiallyEvaluatedIfUsed,
4989 Param);
Douglas Gregorbe0f7bd2010-09-11 20:24:53 +00004990
Sebastian Redl84407ba2012-03-14 15:54:00 +00004991 ExprResult DefArgResult;
Sebastian Redl3e280b52012-03-18 22:25:45 +00004992 if (getLangOpts().CPlusPlus0x && Tok.is(tok::l_brace)) {
4993 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
Sebastian Redl84407ba2012-03-14 15:54:00 +00004994 DefArgResult = ParseBraceInitializer();
Sebastian Redl3e280b52012-03-18 22:25:45 +00004995 } else
Sebastian Redl84407ba2012-03-14 15:54:00 +00004996 DefArgResult = ParseAssignmentExpression();
Douglas Gregor72b505b2008-12-16 21:30:33 +00004997 if (DefArgResult.isInvalid()) {
4998 Actions.ActOnParamDefaultArgumentError(Param);
4999 SkipUntil(tok::comma, tok::r_paren, true, true);
5000 } else {
5001 // Inform the actions module about the default argument
5002 Actions.ActOnParamDefaultArgument(Param, EqualLoc,
John McCall9ae2f072010-08-23 23:25:46 +00005003 DefArgResult.take());
Douglas Gregor72b505b2008-12-16 21:30:33 +00005004 }
Chris Lattner04421082008-04-08 04:40:51 +00005005 }
5006 }
Mike Stump1eb44332009-09-09 15:08:12 +00005007
5008 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
5009 ParmDecl.getIdentifierLoc(), Param,
Douglas Gregor72b505b2008-12-16 21:30:33 +00005010 DefArgToks));
Chris Lattnerf97409f2008-04-06 06:57:35 +00005011 }
5012
5013 // If the next token is a comma, consume it and keep reading arguments.
Douglas Gregored5d6512009-09-22 21:41:40 +00005014 if (Tok.isNot(tok::comma)) {
5015 if (Tok.is(tok::ellipsis)) {
Douglas Gregored5d6512009-09-22 21:41:40 +00005016 EllipsisLoc = ConsumeToken(); // Consume the ellipsis.
Chad Rosier8decdee2012-06-26 22:30:43 +00005017
David Blaikie4e4d0842012-03-11 07:00:24 +00005018 if (!getLangOpts().CPlusPlus) {
Douglas Gregored5d6512009-09-22 21:41:40 +00005019 // We have ellipsis without a preceding ',', which is ill-formed
5020 // in C. Complain and provide the fix.
5021 Diag(EllipsisLoc, diag::err_missing_comma_before_ellipsis)
Douglas Gregor849b2432010-03-31 17:46:05 +00005022 << FixItHint::CreateInsertion(EllipsisLoc, ", ");
Douglas Gregored5d6512009-09-22 21:41:40 +00005023 }
5024 }
Chad Rosier8decdee2012-06-26 22:30:43 +00005025
Douglas Gregored5d6512009-09-22 21:41:40 +00005026 break;
5027 }
Mike Stump1eb44332009-09-09 15:08:12 +00005028
Chris Lattnerf97409f2008-04-06 06:57:35 +00005029 // Consume the comma.
5030 ConsumeToken();
Reid Spencer5f016e22007-07-11 17:01:13 +00005031 }
Mike Stump1eb44332009-09-09 15:08:12 +00005032
Chris Lattner66d28652008-04-06 06:34:08 +00005033}
Chris Lattneref4715c2008-04-06 05:45:57 +00005034
Reid Spencer5f016e22007-07-11 17:01:13 +00005035/// [C90] direct-declarator '[' constant-expression[opt] ']'
5036/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
5037/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
5038/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
5039/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
Richard Smith6ee326a2012-04-10 01:32:12 +00005040/// [C++11] direct-declarator '[' constant-expression[opt] ']'
5041/// attribute-specifier-seq[opt]
Reid Spencer5f016e22007-07-11 17:01:13 +00005042void Parser::ParseBracketDeclarator(Declarator &D) {
Richard Smith6ee326a2012-04-10 01:32:12 +00005043 if (CheckProhibitedCXX11Attribute())
5044 return;
5045
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005046 BalancedDelimiterTracker T(*this, tok::l_square);
5047 T.consumeOpen();
Mike Stump1eb44332009-09-09 15:08:12 +00005048
Chris Lattner378c7e42008-12-18 07:27:21 +00005049 // C array syntax has many features, but by-far the most common is [] and [4].
5050 // This code does a fast path to handle some of the most obvious cases.
5051 if (Tok.getKind() == tok::r_square) {
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005052 T.consumeClose();
John McCall0b7e6782011-03-24 11:26:52 +00005053 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00005054 MaybeParseCXX0XAttributes(attrs);
Chad Rosier8decdee2012-06-26 22:30:43 +00005055
Chris Lattner378c7e42008-12-18 07:27:21 +00005056 // Remember that we parsed the empty array type.
John McCall60d7b3a2010-08-24 06:29:42 +00005057 ExprResult NumElements;
John McCall0b7e6782011-03-24 11:26:52 +00005058 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, 0,
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005059 T.getOpenLocation(),
5060 T.getCloseLocation()),
5061 attrs, T.getCloseLocation());
Chris Lattner378c7e42008-12-18 07:27:21 +00005062 return;
5063 } else if (Tok.getKind() == tok::numeric_constant &&
5064 GetLookAheadToken(1).is(tok::r_square)) {
5065 // [4] is very common. Parse the numeric constant expression.
Richard Smith36f5cfe2012-03-09 08:00:36 +00005066 ExprResult ExprRes(Actions.ActOnNumericConstant(Tok, getCurScope()));
Chris Lattner378c7e42008-12-18 07:27:21 +00005067 ConsumeToken();
5068
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005069 T.consumeClose();
John McCall0b7e6782011-03-24 11:26:52 +00005070 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00005071 MaybeParseCXX0XAttributes(attrs);
Mike Stump1eb44332009-09-09 15:08:12 +00005072
Chris Lattner378c7e42008-12-18 07:27:21 +00005073 // Remember that we parsed a array type, and remember its features.
John McCall0b7e6782011-03-24 11:26:52 +00005074 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, 0,
John McCall7f040a92010-12-24 02:08:15 +00005075 ExprRes.release(),
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005076 T.getOpenLocation(),
5077 T.getCloseLocation()),
5078 attrs, T.getCloseLocation());
Chris Lattner378c7e42008-12-18 07:27:21 +00005079 return;
5080 }
Mike Stump1eb44332009-09-09 15:08:12 +00005081
Reid Spencer5f016e22007-07-11 17:01:13 +00005082 // If valid, this location is the position where we read the 'static' keyword.
5083 SourceLocation StaticLoc;
Chris Lattner04d66662007-10-09 17:33:22 +00005084 if (Tok.is(tok::kw_static))
Reid Spencer5f016e22007-07-11 17:01:13 +00005085 StaticLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00005086
Reid Spencer5f016e22007-07-11 17:01:13 +00005087 // If there is a type-qualifier-list, read it now.
Chris Lattnera1fcbad2008-12-18 06:50:14 +00005088 // Type qualifiers in an array subscript are a C99 feature.
John McCall0b7e6782011-03-24 11:26:52 +00005089 DeclSpec DS(AttrFactory);
Chris Lattner5a69d1c2008-12-18 07:02:59 +00005090 ParseTypeQualifierListOpt(DS, false /*no attributes*/);
Mike Stump1eb44332009-09-09 15:08:12 +00005091
Reid Spencer5f016e22007-07-11 17:01:13 +00005092 // If we haven't already read 'static', check to see if there is one after the
5093 // type-qualifier-list.
Chris Lattner04d66662007-10-09 17:33:22 +00005094 if (!StaticLoc.isValid() && Tok.is(tok::kw_static))
Reid Spencer5f016e22007-07-11 17:01:13 +00005095 StaticLoc = ConsumeToken();
Mike Stump1eb44332009-09-09 15:08:12 +00005096
Reid Spencer5f016e22007-07-11 17:01:13 +00005097 // Handle "direct-declarator [ type-qual-list[opt] * ]".
5098 bool isStar = false;
John McCall60d7b3a2010-08-24 06:29:42 +00005099 ExprResult NumElements;
Mike Stump1eb44332009-09-09 15:08:12 +00005100
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00005101 // Handle the case where we have '[*]' as the array size. However, a leading
5102 // star could be the start of an expression, for example 'X[*p + 4]'. Verify
Sylvestre Ledrubed28ac2012-07-23 08:59:39 +00005103 // the token after the star is a ']'. Since stars in arrays are
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00005104 // infrequent, use of lookahead is not costly here.
5105 if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
Chris Lattnera711dd02008-04-06 05:27:21 +00005106 ConsumeToken(); // Eat the '*'.
Reid Spencer5f016e22007-07-11 17:01:13 +00005107
Chris Lattnera1fcbad2008-12-18 06:50:14 +00005108 if (StaticLoc.isValid()) {
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00005109 Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);
Chris Lattnera1fcbad2008-12-18 06:50:14 +00005110 StaticLoc = SourceLocation(); // Drop the static.
5111 }
Chris Lattner5dcc6ce2008-04-06 05:26:30 +00005112 isStar = true;
Chris Lattner04d66662007-10-09 17:33:22 +00005113 } else if (Tok.isNot(tok::r_square)) {
Chris Lattner378c7e42008-12-18 07:27:21 +00005114 // Note, in C89, this production uses the constant-expr production instead
5115 // of assignment-expr. The only difference is that assignment-expr allows
5116 // things like '=' and '*='. Sema rejects these in C89 mode because they
5117 // are not i-c-e's, so we don't need to distinguish between the two here.
Mike Stump1eb44332009-09-09 15:08:12 +00005118
Douglas Gregore0762c92009-06-19 23:52:42 +00005119 // Parse the constant-expression or assignment-expression now (depending
5120 // on dialect).
David Blaikie4e4d0842012-03-11 07:00:24 +00005121 if (getLangOpts().CPlusPlus) {
Douglas Gregore0762c92009-06-19 23:52:42 +00005122 NumElements = ParseConstantExpression();
Eli Friedman71b8fb52012-01-21 01:01:51 +00005123 } else {
5124 EnterExpressionEvaluationContext Unevaluated(Actions,
5125 Sema::ConstantEvaluated);
Douglas Gregore0762c92009-06-19 23:52:42 +00005126 NumElements = ParseAssignmentExpression();
Eli Friedman71b8fb52012-01-21 01:01:51 +00005127 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005128 }
Mike Stump1eb44332009-09-09 15:08:12 +00005129
Reid Spencer5f016e22007-07-11 17:01:13 +00005130 // If there was an error parsing the assignment-expression, recover.
Sebastian Redl0e9eabc2008-12-09 13:15:23 +00005131 if (NumElements.isInvalid()) {
Chris Lattner5cb10d32009-04-24 22:30:50 +00005132 D.setInvalidType(true);
Reid Spencer5f016e22007-07-11 17:01:13 +00005133 // If the expression was invalid, skip it.
5134 SkipUntil(tok::r_square);
5135 return;
5136 }
Sebastian Redlab197ba2009-02-09 18:23:29 +00005137
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005138 T.consumeClose();
Sebastian Redlab197ba2009-02-09 18:23:29 +00005139
John McCall0b7e6782011-03-24 11:26:52 +00005140 ParsedAttributes attrs(AttrFactory);
John McCall7f040a92010-12-24 02:08:15 +00005141 MaybeParseCXX0XAttributes(attrs);
Sean Huntbbd37c62009-11-21 08:43:09 +00005142
Chris Lattner378c7e42008-12-18 07:27:21 +00005143 // Remember that we parsed a array type, and remember its features.
John McCall0b7e6782011-03-24 11:26:52 +00005144 D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(),
Reid Spencer5f016e22007-07-11 17:01:13 +00005145 StaticLoc.isValid(), isStar,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00005146 NumElements.release(),
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005147 T.getOpenLocation(),
5148 T.getCloseLocation()),
5149 attrs, T.getCloseLocation());
Reid Spencer5f016e22007-07-11 17:01:13 +00005150}
5151
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00005152/// [GNU] typeof-specifier:
5153/// typeof ( expressions )
5154/// typeof ( type-name )
5155/// [GNU/C++] typeof unary-expression
Steve Naroffd1861fd2007-07-31 12:34:36 +00005156///
5157void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
Chris Lattner04d66662007-10-09 17:33:22 +00005158 assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier");
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00005159 Token OpTok = Tok;
Steve Naroffd1861fd2007-07-31 12:34:36 +00005160 SourceLocation StartLoc = ConsumeToken();
5161
John McCallcfb708c2010-01-13 20:03:27 +00005162 const bool hasParens = Tok.is(tok::l_paren);
5163
Eli Friedman80bfa3d2012-09-26 04:34:21 +00005164 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated,
5165 Sema::ReuseLambdaContextDecl);
Eli Friedman71b8fb52012-01-21 01:01:51 +00005166
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00005167 bool isCastExpr;
John McCallb3d87482010-08-24 05:47:05 +00005168 ParsedType CastTy;
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00005169 SourceRange CastRange;
Peter Collingbournef4e3cfb2011-03-11 19:24:49 +00005170 ExprResult Operand = ParseExprAfterUnaryExprOrTypeTrait(OpTok, isCastExpr,
5171 CastTy, CastRange);
John McCallcfb708c2010-01-13 20:03:27 +00005172 if (hasParens)
5173 DS.setTypeofParensRange(CastRange);
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00005174
5175 if (CastRange.getEnd().isInvalid())
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00005176 // FIXME: Not accurate, the range gets one token more than it should.
5177 DS.SetRangeEnd(Tok.getLocation());
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00005178 else
5179 DS.SetRangeEnd(CastRange.getEnd());
Mike Stump1eb44332009-09-09 15:08:12 +00005180
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00005181 if (isCastExpr) {
5182 if (!CastTy) {
5183 DS.SetTypeSpecError();
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00005184 return;
Douglas Gregor809070a2009-02-18 17:45:20 +00005185 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00005186
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00005187 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00005188 unsigned DiagID;
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00005189 // Check for duplicate type specifiers (e.g. "int typeof(int)").
5190 if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec,
John McCallfec54012009-08-03 20:12:06 +00005191 DiagID, CastTy))
5192 Diag(StartLoc, DiagID) << PrevSpec;
Argyrios Kyrtzidis5ab06402009-05-22 10:22:50 +00005193 return;
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00005194 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00005195
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00005196 // If we get here, the operand to the typeof was an expresion.
5197 if (Operand.isInvalid()) {
5198 DS.SetTypeSpecError();
Steve Naroff9dfa7b42007-08-02 02:53:48 +00005199 return;
Steve Naroffd1861fd2007-07-31 12:34:36 +00005200 }
Argyrios Kyrtzidis0f072032008-09-05 11:26:19 +00005201
Eli Friedman71b8fb52012-01-21 01:01:51 +00005202 // We might need to transform the operand if it is potentially evaluated.
5203 Operand = Actions.HandleExprEvaluationContextForTypeof(Operand.get());
5204 if (Operand.isInvalid()) {
5205 DS.SetTypeSpecError();
5206 return;
5207 }
5208
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00005209 const char *PrevSpec = 0;
John McCallfec54012009-08-03 20:12:06 +00005210 unsigned DiagID;
Argyrios Kyrtzidis64096252009-05-22 10:22:18 +00005211 // Check for duplicate type specifiers (e.g. "int typeof(int)").
5212 if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
John McCallb3d87482010-08-24 05:47:05 +00005213 DiagID, Operand.get()))
John McCallfec54012009-08-03 20:12:06 +00005214 Diag(StartLoc, DiagID) << PrevSpec;
Steve Naroffd1861fd2007-07-31 12:34:36 +00005215}
Chris Lattner1b492422010-02-28 18:33:55 +00005216
Benjamin Kramerffbe9b92011-12-23 17:00:35 +00005217/// [C11] atomic-specifier:
Eli Friedmanb001de72011-10-06 23:00:33 +00005218/// _Atomic ( type-name )
5219///
5220void Parser::ParseAtomicSpecifier(DeclSpec &DS) {
5221 assert(Tok.is(tok::kw__Atomic) && "Not an atomic specifier");
5222
5223 SourceLocation StartLoc = ConsumeToken();
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005224 BalancedDelimiterTracker T(*this, tok::l_paren);
5225 if (T.expectAndConsume(diag::err_expected_lparen_after, "_Atomic")) {
Eli Friedmanb001de72011-10-06 23:00:33 +00005226 SkipUntil(tok::r_paren);
5227 return;
5228 }
5229
5230 TypeResult Result = ParseTypeName();
5231 if (Result.isInvalid()) {
5232 SkipUntil(tok::r_paren);
5233 return;
5234 }
5235
5236 // Match the ')'
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005237 T.consumeClose();
Eli Friedmanb001de72011-10-06 23:00:33 +00005238
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005239 if (T.getCloseLocation().isInvalid())
Eli Friedmanb001de72011-10-06 23:00:33 +00005240 return;
5241
Douglas Gregor4a8dfb52011-10-12 16:37:45 +00005242 DS.setTypeofParensRange(T.getRange());
5243 DS.SetRangeEnd(T.getCloseLocation());
Eli Friedmanb001de72011-10-06 23:00:33 +00005244
5245 const char *PrevSpec = 0;
5246 unsigned DiagID;
5247 if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec,
5248 DiagID, Result.release()))
5249 Diag(StartLoc, DiagID) << PrevSpec;
5250}
5251
Chris Lattner1b492422010-02-28 18:33:55 +00005252
5253/// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be called
5254/// from TryAltiVecVectorToken.
5255bool Parser::TryAltiVecVectorTokenOutOfLine() {
5256 Token Next = NextToken();
5257 switch (Next.getKind()) {
5258 default: return false;
5259 case tok::kw_short:
5260 case tok::kw_long:
5261 case tok::kw_signed:
5262 case tok::kw_unsigned:
5263 case tok::kw_void:
5264 case tok::kw_char:
5265 case tok::kw_int:
5266 case tok::kw_float:
5267 case tok::kw_double:
5268 case tok::kw_bool:
5269 case tok::kw___pixel:
5270 Tok.setKind(tok::kw___vector);
5271 return true;
5272 case tok::identifier:
5273 if (Next.getIdentifierInfo() == Ident_pixel) {
5274 Tok.setKind(tok::kw___vector);
5275 return true;
5276 }
5277 return false;
5278 }
5279}
5280
5281bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
5282 const char *&PrevSpec, unsigned &DiagID,
5283 bool &isInvalid) {
5284 if (Tok.getIdentifierInfo() == Ident_vector) {
5285 Token Next = NextToken();
5286 switch (Next.getKind()) {
5287 case tok::kw_short:
5288 case tok::kw_long:
5289 case tok::kw_signed:
5290 case tok::kw_unsigned:
5291 case tok::kw_void:
5292 case tok::kw_char:
5293 case tok::kw_int:
5294 case tok::kw_float:
5295 case tok::kw_double:
5296 case tok::kw_bool:
5297 case tok::kw___pixel:
5298 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
5299 return true;
5300 case tok::identifier:
5301 if (Next.getIdentifierInfo() == Ident_pixel) {
5302 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID);
5303 return true;
5304 }
5305 break;
5306 default:
5307 break;
5308 }
Douglas Gregora8f031f2010-06-16 15:28:57 +00005309 } else if ((Tok.getIdentifierInfo() == Ident_pixel) &&
Chris Lattner1b492422010-02-28 18:33:55 +00005310 DS.isTypeAltiVecVector()) {
5311 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID);
5312 return true;
5313 }
5314 return false;
5315}