clang  3.9.0
ParseDecl.cpp
Go to the documentation of this file.
1 //===--- ParseDecl.cpp - Declaration Parsing --------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Declaration portions of the Parser interfaces.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Parse/Parser.h"
15 #include "RAIIObjectsForParser.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclTemplate.h"
19 #include "clang/Basic/Attributes.h"
20 #include "clang/Basic/CharInfo.h"
21 #include "clang/Basic/TargetInfo.h"
23 #include "clang/Sema/Lookup.h"
26 #include "clang/Sema/Scope.h"
28 #include "llvm/ADT/SmallSet.h"
29 #include "llvm/ADT/SmallString.h"
30 #include "llvm/ADT/StringSwitch.h"
31 #include "llvm/Support/ScopedPrinter.h"
32 
33 using namespace clang;
34 
35 //===----------------------------------------------------------------------===//
36 // C99 6.7: Declarations.
37 //===----------------------------------------------------------------------===//
38 
39 /// ParseTypeName
40 /// type-name: [C99 6.7.6]
41 /// specifier-qualifier-list abstract-declarator[opt]
42 ///
43 /// Called type-id in C++.
46  AccessSpecifier AS,
47  Decl **OwnedType,
48  ParsedAttributes *Attrs) {
49  DeclSpecContext DSC = getDeclSpecContextFromDeclaratorContext(Context);
50  if (DSC == DSC_normal)
51  DSC = DSC_type_specifier;
52 
53  // Parse the common declaration-specifiers piece.
54  DeclSpec DS(AttrFactory);
55  if (Attrs)
56  DS.addAttributes(Attrs->getList());
57  ParseSpecifierQualifierList(DS, AS, DSC);
58  if (OwnedType)
59  *OwnedType = DS.isTypeSpecOwned() ? DS.getRepAsDecl() : nullptr;
60 
61  // Parse the abstract-declarator, if present.
62  Declarator DeclaratorInfo(DS, Context);
63  ParseDeclarator(DeclaratorInfo);
64  if (Range)
65  *Range = DeclaratorInfo.getSourceRange();
66 
67  if (DeclaratorInfo.isInvalidType())
68  return true;
69 
70  return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
71 }
72 
73 /// isAttributeLateParsed - Return true if the attribute has arguments that
74 /// require late parsing.
75 static bool isAttributeLateParsed(const IdentifierInfo &II) {
76 #define CLANG_ATTR_LATE_PARSED_LIST
77  return llvm::StringSwitch<bool>(II.getName())
78 #include "clang/Parse/AttrParserStringSwitches.inc"
79  .Default(false);
80 #undef CLANG_ATTR_LATE_PARSED_LIST
81 }
82 
83 /// ParseGNUAttributes - Parse a non-empty attributes list.
84 ///
85 /// [GNU] attributes:
86 /// attribute
87 /// attributes attribute
88 ///
89 /// [GNU] attribute:
90 /// '__attribute__' '(' '(' attribute-list ')' ')'
91 ///
92 /// [GNU] attribute-list:
93 /// attrib
94 /// attribute_list ',' attrib
95 ///
96 /// [GNU] attrib:
97 /// empty
98 /// attrib-name
99 /// attrib-name '(' identifier ')'
100 /// attrib-name '(' identifier ',' nonempty-expr-list ')'
101 /// attrib-name '(' argument-expression-list [C99 6.5.2] ')'
102 ///
103 /// [GNU] attrib-name:
104 /// identifier
105 /// typespec
106 /// typequal
107 /// storageclass
108 ///
109 /// Whether an attribute takes an 'identifier' is determined by the
110 /// attrib-name. GCC's behavior here is not worth imitating:
111 ///
112 /// * In C mode, if the attribute argument list starts with an identifier
113 /// followed by a ',' or an ')', and the identifier doesn't resolve to
114 /// a type, it is parsed as an identifier. If the attribute actually
115 /// wanted an expression, it's out of luck (but it turns out that no
116 /// attributes work that way, because C constant expressions are very
117 /// limited).
118 /// * In C++ mode, if the attribute argument list starts with an identifier,
119 /// and the attribute *wants* an identifier, it is parsed as an identifier.
120 /// At block scope, any additional tokens between the identifier and the
121 /// ',' or ')' are ignored, otherwise they produce a parse error.
122 ///
123 /// We follow the C++ model, but don't allow junk after the identifier.
124 void Parser::ParseGNUAttributes(ParsedAttributes &attrs,
125  SourceLocation *endLoc,
126  LateParsedAttrList *LateAttrs,
127  Declarator *D) {
128  assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!");
129 
130  while (Tok.is(tok::kw___attribute)) {
131  ConsumeToken();
132  if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
133  "attribute")) {
134  SkipUntil(tok::r_paren, StopAtSemi); // skip until ) or ;
135  return;
136  }
137  if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
138  SkipUntil(tok::r_paren, StopAtSemi); // skip until ) or ;
139  return;
140  }
141  // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") ))
142  while (true) {
143  // Allow empty/non-empty attributes. ((__vector_size__(16),,,,))
144  if (TryConsumeToken(tok::comma))
145  continue;
146 
147  // Expect an identifier or declaration specifier (const, int, etc.)
148  if (Tok.isAnnotation())
149  break;
150  IdentifierInfo *AttrName = Tok.getIdentifierInfo();
151  if (!AttrName)
152  break;
153 
154  SourceLocation AttrNameLoc = ConsumeToken();
155 
156  if (Tok.isNot(tok::l_paren)) {
157  attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
159  continue;
160  }
161 
162  // Handle "parameterized" attributes
163  if (!LateAttrs || !isAttributeLateParsed(*AttrName)) {
164  ParseGNUAttributeArgs(AttrName, AttrNameLoc, attrs, endLoc, nullptr,
166  continue;
167  }
168 
169  // Handle attributes with arguments that require late parsing.
170  LateParsedAttribute *LA =
171  new LateParsedAttribute(this, *AttrName, AttrNameLoc);
172  LateAttrs->push_back(LA);
173 
174  // Attributes in a class are parsed at the end of the class, along
175  // with other late-parsed declarations.
176  if (!ClassStack.empty() && !LateAttrs->parseSoon())
177  getCurrentClass().LateParsedDeclarations.push_back(LA);
178 
179  // consume everything up to and including the matching right parens
180  ConsumeAndStoreUntil(tok::r_paren, LA->Toks, true, false);
181 
182  Token Eof;
183  Eof.startToken();
184  Eof.setLocation(Tok.getLocation());
185  LA->Toks.push_back(Eof);
186  }
187 
188  if (ExpectAndConsume(tok::r_paren))
189  SkipUntil(tok::r_paren, StopAtSemi);
190  SourceLocation Loc = Tok.getLocation();
191  if (ExpectAndConsume(tok::r_paren))
192  SkipUntil(tok::r_paren, StopAtSemi);
193  if (endLoc)
194  *endLoc = Loc;
195  }
196 }
197 
198 /// \brief Normalizes an attribute name by dropping prefixed and suffixed __.
199 static StringRef normalizeAttrName(StringRef Name) {
200  if (Name.size() >= 4 && Name.startswith("__") && Name.endswith("__"))
201  Name = Name.drop_front(2).drop_back(2);
202  return Name;
203 }
204 
205 /// \brief Determine whether the given attribute has an identifier argument.
207 #define CLANG_ATTR_IDENTIFIER_ARG_LIST
208  return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
209 #include "clang/Parse/AttrParserStringSwitches.inc"
210  .Default(false);
211 #undef CLANG_ATTR_IDENTIFIER_ARG_LIST
212 }
213 
214 /// \brief Determine whether the given attribute parses a type argument.
215 static bool attributeIsTypeArgAttr(const IdentifierInfo &II) {
216 #define CLANG_ATTR_TYPE_ARG_LIST
217  return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
218 #include "clang/Parse/AttrParserStringSwitches.inc"
219  .Default(false);
220 #undef CLANG_ATTR_TYPE_ARG_LIST
221 }
222 
223 /// \brief Determine whether the given attribute requires parsing its arguments
224 /// in an unevaluated context or not.
226 #define CLANG_ATTR_ARG_CONTEXT_LIST
227  return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
228 #include "clang/Parse/AttrParserStringSwitches.inc"
229  .Default(false);
230 #undef CLANG_ATTR_ARG_CONTEXT_LIST
231 }
232 
233 IdentifierLoc *Parser::ParseIdentifierLoc() {
234  assert(Tok.is(tok::identifier) && "expected an identifier");
236  Tok.getLocation(),
237  Tok.getIdentifierInfo());
238  ConsumeToken();
239  return IL;
240 }
241 
242 void Parser::ParseAttributeWithTypeArg(IdentifierInfo &AttrName,
243  SourceLocation AttrNameLoc,
244  ParsedAttributes &Attrs,
245  SourceLocation *EndLoc,
246  IdentifierInfo *ScopeName,
247  SourceLocation ScopeLoc,
248  AttributeList::Syntax Syntax) {
249  BalancedDelimiterTracker Parens(*this, tok::l_paren);
250  Parens.consumeOpen();
251 
252  TypeResult T;
253  if (Tok.isNot(tok::r_paren))
254  T = ParseTypeName();
255 
256  if (Parens.consumeClose())
257  return;
258 
259  if (T.isInvalid())
260  return;
261 
262  if (T.isUsable())
263  Attrs.addNewTypeAttr(&AttrName,
264  SourceRange(AttrNameLoc, Parens.getCloseLocation()),
265  ScopeName, ScopeLoc, T.get(), Syntax);
266  else
267  Attrs.addNew(&AttrName, SourceRange(AttrNameLoc, Parens.getCloseLocation()),
268  ScopeName, ScopeLoc, nullptr, 0, Syntax);
269 }
270 
271 unsigned Parser::ParseAttributeArgsCommon(
272  IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
273  ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
274  SourceLocation ScopeLoc, AttributeList::Syntax Syntax) {
275  // Ignore the left paren location for now.
276  ConsumeParen();
277 
278  ArgsVector ArgExprs;
279  if (Tok.is(tok::identifier)) {
280  // If this attribute wants an 'identifier' argument, make it so.
281  bool IsIdentifierArg = attributeHasIdentifierArg(*AttrName);
282  AttributeList::Kind AttrKind =
283  AttributeList::getKind(AttrName, ScopeName, Syntax);
284 
285  // If we don't know how to parse this attribute, but this is the only
286  // token in this argument, assume it's meant to be an identifier.
287  if (AttrKind == AttributeList::UnknownAttribute ||
288  AttrKind == AttributeList::IgnoredAttribute) {
289  const Token &Next = NextToken();
290  IsIdentifierArg = Next.isOneOf(tok::r_paren, tok::comma);
291  }
292 
293  if (IsIdentifierArg)
294  ArgExprs.push_back(ParseIdentifierLoc());
295  }
296 
297  if (!ArgExprs.empty() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren)) {
298  // Eat the comma.
299  if (!ArgExprs.empty())
300  ConsumeToken();
301 
302  // Parse the non-empty comma-separated list of expressions.
303  do {
304  std::unique_ptr<EnterExpressionEvaluationContext> Unevaluated;
305  if (attributeParsedArgsUnevaluated(*AttrName))
306  Unevaluated.reset(
308 
309  ExprResult ArgExpr(
311  if (ArgExpr.isInvalid()) {
312  SkipUntil(tok::r_paren, StopAtSemi);
313  return 0;
314  }
315  ArgExprs.push_back(ArgExpr.get());
316  // Eat the comma, move to the next argument
317  } while (TryConsumeToken(tok::comma));
318  }
319 
320  SourceLocation RParen = Tok.getLocation();
321  if (!ExpectAndConsume(tok::r_paren)) {
322  SourceLocation AttrLoc = ScopeLoc.isValid() ? ScopeLoc : AttrNameLoc;
323  Attrs.addNew(AttrName, SourceRange(AttrLoc, RParen), ScopeName, ScopeLoc,
324  ArgExprs.data(), ArgExprs.size(), Syntax);
325  }
326 
327  if (EndLoc)
328  *EndLoc = RParen;
329 
330  return static_cast<unsigned>(ArgExprs.size());
331 }
332 
333 /// Parse the arguments to a parameterized GNU attribute or
334 /// a C++11 attribute in "gnu" namespace.
335 void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName,
336  SourceLocation AttrNameLoc,
337  ParsedAttributes &Attrs,
338  SourceLocation *EndLoc,
339  IdentifierInfo *ScopeName,
340  SourceLocation ScopeLoc,
341  AttributeList::Syntax Syntax,
342  Declarator *D) {
343 
344  assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
345 
346  AttributeList::Kind AttrKind =
347  AttributeList::getKind(AttrName, ScopeName, Syntax);
348 
349  if (AttrKind == AttributeList::AT_Availability) {
350  ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
351  ScopeLoc, Syntax);
352  return;
353  } else if (AttrKind == AttributeList::AT_ObjCBridgeRelated) {
354  ParseObjCBridgeRelatedAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
355  ScopeName, ScopeLoc, Syntax);
356  return;
357  } else if (AttrKind == AttributeList::AT_TypeTagForDatatype) {
358  ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
359  ScopeName, ScopeLoc, Syntax);
360  return;
361  } else if (attributeIsTypeArgAttr(*AttrName)) {
362  ParseAttributeWithTypeArg(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
363  ScopeLoc, Syntax);
364  return;
365  }
366 
367  // These may refer to the function arguments, but need to be parsed early to
368  // participate in determining whether it's a redeclaration.
369  std::unique_ptr<ParseScope> PrototypeScope;
370  if (normalizeAttrName(AttrName->getName()) == "enable_if" &&
371  D && D->isFunctionDeclarator()) {
373  PrototypeScope.reset(new ParseScope(this, Scope::FunctionPrototypeScope |
376  for (unsigned i = 0; i != FTI.NumParams; ++i) {
377  ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
379  }
380  }
381 
382  ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
383  ScopeLoc, Syntax);
384 }
385 
386 bool Parser::ParseMicrosoftDeclSpecArgs(IdentifierInfo *AttrName,
387  SourceLocation AttrNameLoc,
388  ParsedAttributes &Attrs) {
389  // If the attribute isn't known, we will not attempt to parse any
390  // arguments.
391  if (!hasAttribute(AttrSyntax::Declspec, nullptr, AttrName,
392  getTargetInfo(), getLangOpts())) {
393  // Eat the left paren, then skip to the ending right paren.
394  ConsumeParen();
395  SkipUntil(tok::r_paren);
396  return false;
397  }
398 
399  SourceLocation OpenParenLoc = Tok.getLocation();
400 
401  if (AttrName->getName() == "property") {
402  // The property declspec is more complex in that it can take one or two
403  // assignment expressions as a parameter, but the lhs of the assignment
404  // must be named get or put.
405 
406  BalancedDelimiterTracker T(*this, tok::l_paren);
407  T.expectAndConsume(diag::err_expected_lparen_after,
408  AttrName->getNameStart(), tok::r_paren);
409 
410  enum AccessorKind {
411  AK_Invalid = -1,
412  AK_Put = 0,
413  AK_Get = 1 // indices into AccessorNames
414  };
415  IdentifierInfo *AccessorNames[] = {nullptr, nullptr};
416  bool HasInvalidAccessor = false;
417 
418  // Parse the accessor specifications.
419  while (true) {
420  // Stop if this doesn't look like an accessor spec.
421  if (!Tok.is(tok::identifier)) {
422  // If the user wrote a completely empty list, use a special diagnostic.
423  if (Tok.is(tok::r_paren) && !HasInvalidAccessor &&
424  AccessorNames[AK_Put] == nullptr &&
425  AccessorNames[AK_Get] == nullptr) {
426  Diag(AttrNameLoc, diag::err_ms_property_no_getter_or_putter);
427  break;
428  }
429 
430  Diag(Tok.getLocation(), diag::err_ms_property_unknown_accessor);
431  break;
432  }
433 
434  AccessorKind Kind;
435  SourceLocation KindLoc = Tok.getLocation();
436  StringRef KindStr = Tok.getIdentifierInfo()->getName();
437  if (KindStr == "get") {
438  Kind = AK_Get;
439  } else if (KindStr == "put") {
440  Kind = AK_Put;
441 
442  // Recover from the common mistake of using 'set' instead of 'put'.
443  } else if (KindStr == "set") {
444  Diag(KindLoc, diag::err_ms_property_has_set_accessor)
445  << FixItHint::CreateReplacement(KindLoc, "put");
446  Kind = AK_Put;
447 
448  // Handle the mistake of forgetting the accessor kind by skipping
449  // this accessor.
450  } else if (NextToken().is(tok::comma) || NextToken().is(tok::r_paren)) {
451  Diag(KindLoc, diag::err_ms_property_missing_accessor_kind);
452  ConsumeToken();
453  HasInvalidAccessor = true;
454  goto next_property_accessor;
455 
456  // Otherwise, complain about the unknown accessor kind.
457  } else {
458  Diag(KindLoc, diag::err_ms_property_unknown_accessor);
459  HasInvalidAccessor = true;
460  Kind = AK_Invalid;
461 
462  // Try to keep parsing unless it doesn't look like an accessor spec.
463  if (!NextToken().is(tok::equal))
464  break;
465  }
466 
467  // Consume the identifier.
468  ConsumeToken();
469 
470  // Consume the '='.
471  if (!TryConsumeToken(tok::equal)) {
472  Diag(Tok.getLocation(), diag::err_ms_property_expected_equal)
473  << KindStr;
474  break;
475  }
476 
477  // Expect the method name.
478  if (!Tok.is(tok::identifier)) {
479  Diag(Tok.getLocation(), diag::err_ms_property_expected_accessor_name);
480  break;
481  }
482 
483  if (Kind == AK_Invalid) {
484  // Just drop invalid accessors.
485  } else if (AccessorNames[Kind] != nullptr) {
486  // Complain about the repeated accessor, ignore it, and keep parsing.
487  Diag(KindLoc, diag::err_ms_property_duplicate_accessor) << KindStr;
488  } else {
489  AccessorNames[Kind] = Tok.getIdentifierInfo();
490  }
491  ConsumeToken();
492 
493  next_property_accessor:
494  // Keep processing accessors until we run out.
495  if (TryConsumeToken(tok::comma))
496  continue;
497 
498  // If we run into the ')', stop without consuming it.
499  if (Tok.is(tok::r_paren))
500  break;
501 
502  Diag(Tok.getLocation(), diag::err_ms_property_expected_comma_or_rparen);
503  break;
504  }
505 
506  // Only add the property attribute if it was well-formed.
507  if (!HasInvalidAccessor)
508  Attrs.addNewPropertyAttr(AttrName, AttrNameLoc, nullptr, SourceLocation(),
509  AccessorNames[AK_Get], AccessorNames[AK_Put],
511  T.skipToEnd();
512  return !HasInvalidAccessor;
513  }
514 
515  unsigned NumArgs =
516  ParseAttributeArgsCommon(AttrName, AttrNameLoc, Attrs, nullptr, nullptr,
518 
519  // If this attribute's args were parsed, and it was expected to have
520  // arguments but none were provided, emit a diagnostic.
521  const AttributeList *Attr = Attrs.getList();
522  if (Attr && Attr->getMaxArgs() && !NumArgs) {
523  Diag(OpenParenLoc, diag::err_attribute_requires_arguments) << AttrName;
524  return false;
525  }
526  return true;
527 }
528 
529 /// [MS] decl-specifier:
530 /// __declspec ( extended-decl-modifier-seq )
531 ///
532 /// [MS] extended-decl-modifier-seq:
533 /// extended-decl-modifier[opt]
534 /// extended-decl-modifier extended-decl-modifier-seq
535 void Parser::ParseMicrosoftDeclSpecs(ParsedAttributes &Attrs,
536  SourceLocation *End) {
537  assert(getLangOpts().DeclSpecKeyword && "__declspec keyword is not enabled");
538  assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
539 
540  while (Tok.is(tok::kw___declspec)) {
541  ConsumeToken();
542  BalancedDelimiterTracker T(*this, tok::l_paren);
543  if (T.expectAndConsume(diag::err_expected_lparen_after, "__declspec",
544  tok::r_paren))
545  return;
546 
547  // An empty declspec is perfectly legal and should not warn. Additionally,
548  // you can specify multiple attributes per declspec.
549  while (Tok.isNot(tok::r_paren)) {
550  // Attribute not present.
551  if (TryConsumeToken(tok::comma))
552  continue;
553 
554  // We expect either a well-known identifier or a generic string. Anything
555  // else is a malformed declspec.
556  bool IsString = Tok.getKind() == tok::string_literal;
557  if (!IsString && Tok.getKind() != tok::identifier &&
558  Tok.getKind() != tok::kw_restrict) {
559  Diag(Tok, diag::err_ms_declspec_type);
560  T.skipToEnd();
561  return;
562  }
563 
564  IdentifierInfo *AttrName;
565  SourceLocation AttrNameLoc;
566  if (IsString) {
567  SmallString<8> StrBuffer;
568  bool Invalid = false;
569  StringRef Str = PP.getSpelling(Tok, StrBuffer, &Invalid);
570  if (Invalid) {
571  T.skipToEnd();
572  return;
573  }
574  AttrName = PP.getIdentifierInfo(Str);
575  AttrNameLoc = ConsumeStringToken();
576  } else {
577  AttrName = Tok.getIdentifierInfo();
578  AttrNameLoc = ConsumeToken();
579  }
580 
581  bool AttrHandled = false;
582 
583  // Parse attribute arguments.
584  if (Tok.is(tok::l_paren))
585  AttrHandled = ParseMicrosoftDeclSpecArgs(AttrName, AttrNameLoc, Attrs);
586  else if (AttrName->getName() == "property")
587  // The property attribute must have an argument list.
588  Diag(Tok.getLocation(), diag::err_expected_lparen_after)
589  << AttrName->getName();
590 
591  if (!AttrHandled)
592  Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
594  }
595  T.consumeClose();
596  if (End)
597  *End = T.getCloseLocation();
598  }
599 }
600 
601 void Parser::ParseMicrosoftTypeAttributes(ParsedAttributes &attrs) {
602  // Treat these like attributes
603  while (true) {
604  switch (Tok.getKind()) {
605  case tok::kw___fastcall:
606  case tok::kw___stdcall:
607  case tok::kw___thiscall:
608  case tok::kw___cdecl:
609  case tok::kw___vectorcall:
610  case tok::kw___ptr64:
611  case tok::kw___w64:
612  case tok::kw___ptr32:
613  case tok::kw___sptr:
614  case tok::kw___uptr: {
615  IdentifierInfo *AttrName = Tok.getIdentifierInfo();
616  SourceLocation AttrNameLoc = ConsumeToken();
617  attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
619  break;
620  }
621  default:
622  return;
623  }
624  }
625 }
626 
627 void Parser::DiagnoseAndSkipExtendedMicrosoftTypeAttributes() {
628  SourceLocation StartLoc = Tok.getLocation();
629  SourceLocation EndLoc = SkipExtendedMicrosoftTypeAttributes();
630 
631  if (EndLoc.isValid()) {
632  SourceRange Range(StartLoc, EndLoc);
633  Diag(StartLoc, diag::warn_microsoft_qualifiers_ignored) << Range;
634  }
635 }
636 
637 SourceLocation Parser::SkipExtendedMicrosoftTypeAttributes() {
638  SourceLocation EndLoc;
639 
640  while (true) {
641  switch (Tok.getKind()) {
642  case tok::kw_const:
643  case tok::kw_volatile:
644  case tok::kw___fastcall:
645  case tok::kw___stdcall:
646  case tok::kw___thiscall:
647  case tok::kw___cdecl:
648  case tok::kw___vectorcall:
649  case tok::kw___ptr32:
650  case tok::kw___ptr64:
651  case tok::kw___w64:
652  case tok::kw___unaligned:
653  case tok::kw___sptr:
654  case tok::kw___uptr:
655  EndLoc = ConsumeToken();
656  break;
657  default:
658  return EndLoc;
659  }
660  }
661 }
662 
663 void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) {
664  // Treat these like attributes
665  while (Tok.is(tok::kw___pascal)) {
666  IdentifierInfo *AttrName = Tok.getIdentifierInfo();
667  SourceLocation AttrNameLoc = ConsumeToken();
668  attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
670  }
671 }
672 
673 void Parser::ParseOpenCLKernelAttributes(ParsedAttributes &attrs) {
674  // Treat these like attributes
675  while (Tok.is(tok::kw___kernel)) {
676  IdentifierInfo *AttrName = Tok.getIdentifierInfo();
677  SourceLocation AttrNameLoc = ConsumeToken();
678  attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
680  }
681 }
682 
683 void Parser::ParseOpenCLQualifiers(ParsedAttributes &Attrs) {
684  IdentifierInfo *AttrName = Tok.getIdentifierInfo();
685  SourceLocation AttrNameLoc = Tok.getLocation();
686  Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
688 }
689 
690 void Parser::ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs) {
691  // Treat these like attributes, even though they're type specifiers.
692  while (true) {
693  switch (Tok.getKind()) {
694  case tok::kw__Nonnull:
695  case tok::kw__Nullable:
696  case tok::kw__Null_unspecified: {
697  IdentifierInfo *AttrName = Tok.getIdentifierInfo();
698  SourceLocation AttrNameLoc = ConsumeToken();
699  if (!getLangOpts().ObjC1)
700  Diag(AttrNameLoc, diag::ext_nullability)
701  << AttrName;
702  attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
704  break;
705  }
706  default:
707  return;
708  }
709  }
710 }
711 
712 static bool VersionNumberSeparator(const char Separator) {
713  return (Separator == '.' || Separator == '_');
714 }
715 
716 /// \brief Parse a version number.
717 ///
718 /// version:
719 /// simple-integer
720 /// simple-integer ',' simple-integer
721 /// simple-integer ',' simple-integer ',' simple-integer
722 VersionTuple Parser::ParseVersionTuple(SourceRange &Range) {
723  Range = SourceRange(Tok.getLocation(), Tok.getEndLoc());
724 
725  if (!Tok.is(tok::numeric_constant)) {
726  Diag(Tok, diag::err_expected_version);
727  SkipUntil(tok::comma, tok::r_paren,
729  return VersionTuple();
730  }
731 
732  // Parse the major (and possibly minor and subminor) versions, which
733  // are stored in the numeric constant. We utilize a quirk of the
734  // lexer, which is that it handles something like 1.2.3 as a single
735  // numeric constant, rather than two separate tokens.
737  Buffer.resize(Tok.getLength()+1);
738  const char *ThisTokBegin = &Buffer[0];
739 
740  // Get the spelling of the token, which eliminates trigraphs, etc.
741  bool Invalid = false;
742  unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid);
743  if (Invalid)
744  return VersionTuple();
745 
746  // Parse the major version.
747  unsigned AfterMajor = 0;
748  unsigned Major = 0;
749  while (AfterMajor < ActualLength && isDigit(ThisTokBegin[AfterMajor])) {
750  Major = Major * 10 + ThisTokBegin[AfterMajor] - '0';
751  ++AfterMajor;
752  }
753 
754  if (AfterMajor == 0) {
755  Diag(Tok, diag::err_expected_version);
756  SkipUntil(tok::comma, tok::r_paren,
758  return VersionTuple();
759  }
760 
761  if (AfterMajor == ActualLength) {
762  ConsumeToken();
763 
764  // We only had a single version component.
765  if (Major == 0) {
766  Diag(Tok, diag::err_zero_version);
767  return VersionTuple();
768  }
769 
770  return VersionTuple(Major);
771  }
772 
773  const char AfterMajorSeparator = ThisTokBegin[AfterMajor];
774  if (!VersionNumberSeparator(AfterMajorSeparator)
775  || (AfterMajor + 1 == ActualLength)) {
776  Diag(Tok, diag::err_expected_version);
777  SkipUntil(tok::comma, tok::r_paren,
779  return VersionTuple();
780  }
781 
782  // Parse the minor version.
783  unsigned AfterMinor = AfterMajor + 1;
784  unsigned Minor = 0;
785  while (AfterMinor < ActualLength && isDigit(ThisTokBegin[AfterMinor])) {
786  Minor = Minor * 10 + ThisTokBegin[AfterMinor] - '0';
787  ++AfterMinor;
788  }
789 
790  if (AfterMinor == ActualLength) {
791  ConsumeToken();
792 
793  // We had major.minor.
794  if (Major == 0 && Minor == 0) {
795  Diag(Tok, diag::err_zero_version);
796  return VersionTuple();
797  }
798 
799  return VersionTuple(Major, Minor, (AfterMajorSeparator == '_'));
800  }
801 
802  const char AfterMinorSeparator = ThisTokBegin[AfterMinor];
803  // If what follows is not a '.' or '_', we have a problem.
804  if (!VersionNumberSeparator(AfterMinorSeparator)) {
805  Diag(Tok, diag::err_expected_version);
806  SkipUntil(tok::comma, tok::r_paren,
808  return VersionTuple();
809  }
810 
811  // Warn if separators, be it '.' or '_', do not match.
812  if (AfterMajorSeparator != AfterMinorSeparator)
813  Diag(Tok, diag::warn_expected_consistent_version_separator);
814 
815  // Parse the subminor version.
816  unsigned AfterSubminor = AfterMinor + 1;
817  unsigned Subminor = 0;
818  while (AfterSubminor < ActualLength && isDigit(ThisTokBegin[AfterSubminor])) {
819  Subminor = Subminor * 10 + ThisTokBegin[AfterSubminor] - '0';
820  ++AfterSubminor;
821  }
822 
823  if (AfterSubminor != ActualLength) {
824  Diag(Tok, diag::err_expected_version);
825  SkipUntil(tok::comma, tok::r_paren,
827  return VersionTuple();
828  }
829  ConsumeToken();
830  return VersionTuple(Major, Minor, Subminor, (AfterMajorSeparator == '_'));
831 }
832 
833 /// \brief Parse the contents of the "availability" attribute.
834 ///
835 /// availability-attribute:
836 /// 'availability' '(' platform ',' opt-strict version-arg-list,
837 /// opt-replacement, opt-message')'
838 ///
839 /// platform:
840 /// identifier
841 ///
842 /// opt-strict:
843 /// 'strict' ','
844 ///
845 /// version-arg-list:
846 /// version-arg
847 /// version-arg ',' version-arg-list
848 ///
849 /// version-arg:
850 /// 'introduced' '=' version
851 /// 'deprecated' '=' version
852 /// 'obsoleted' = version
853 /// 'unavailable'
854 /// opt-replacement:
855 /// 'replacement' '=' <string>
856 /// opt-message:
857 /// 'message' '=' <string>
858 void Parser::ParseAvailabilityAttribute(IdentifierInfo &Availability,
859  SourceLocation AvailabilityLoc,
860  ParsedAttributes &attrs,
861  SourceLocation *endLoc,
862  IdentifierInfo *ScopeName,
863  SourceLocation ScopeLoc,
864  AttributeList::Syntax Syntax) {
865  enum { Introduced, Deprecated, Obsoleted, Unknown };
867  ExprResult MessageExpr, ReplacementExpr;
868 
869  // Opening '('.
870  BalancedDelimiterTracker T(*this, tok::l_paren);
871  if (T.consumeOpen()) {
872  Diag(Tok, diag::err_expected) << tok::l_paren;
873  return;
874  }
875 
876  // Parse the platform name.
877  if (Tok.isNot(tok::identifier)) {
878  Diag(Tok, diag::err_availability_expected_platform);
879  SkipUntil(tok::r_paren, StopAtSemi);
880  return;
881  }
882  IdentifierLoc *Platform = ParseIdentifierLoc();
883  // Canonicalize platform name from "macosx" to "macos".
884  if (Platform->Ident && Platform->Ident->getName() == "macosx")
885  Platform->Ident = PP.getIdentifierInfo("macos");
886  // Canonicalize platform name from "macosx_app_extension" to
887  // "macos_app_extension".
888  if (Platform->Ident && Platform->Ident->getName() == "macosx_app_extension")
889  Platform->Ident = PP.getIdentifierInfo("macos_app_extension");
890 
891  // Parse the ',' following the platform name.
892  if (ExpectAndConsume(tok::comma)) {
893  SkipUntil(tok::r_paren, StopAtSemi);
894  return;
895  }
896 
897  // If we haven't grabbed the pointers for the identifiers
898  // "introduced", "deprecated", and "obsoleted", do so now.
899  if (!Ident_introduced) {
900  Ident_introduced = PP.getIdentifierInfo("introduced");
901  Ident_deprecated = PP.getIdentifierInfo("deprecated");
902  Ident_obsoleted = PP.getIdentifierInfo("obsoleted");
903  Ident_unavailable = PP.getIdentifierInfo("unavailable");
904  Ident_message = PP.getIdentifierInfo("message");
905  Ident_strict = PP.getIdentifierInfo("strict");
906  Ident_replacement = PP.getIdentifierInfo("replacement");
907  }
908 
909  // Parse the optional "strict", the optional "replacement" and the set of
910  // introductions/deprecations/removals.
911  SourceLocation UnavailableLoc, StrictLoc;
912  do {
913  if (Tok.isNot(tok::identifier)) {
914  Diag(Tok, diag::err_availability_expected_change);
915  SkipUntil(tok::r_paren, StopAtSemi);
916  return;
917  }
918  IdentifierInfo *Keyword = Tok.getIdentifierInfo();
919  SourceLocation KeywordLoc = ConsumeToken();
920 
921  if (Keyword == Ident_strict) {
922  if (StrictLoc.isValid()) {
923  Diag(KeywordLoc, diag::err_availability_redundant)
924  << Keyword << SourceRange(StrictLoc);
925  }
926  StrictLoc = KeywordLoc;
927  continue;
928  }
929 
930  if (Keyword == Ident_unavailable) {
931  if (UnavailableLoc.isValid()) {
932  Diag(KeywordLoc, diag::err_availability_redundant)
933  << Keyword << SourceRange(UnavailableLoc);
934  }
935  UnavailableLoc = KeywordLoc;
936  continue;
937  }
938 
939  if (Tok.isNot(tok::equal)) {
940  Diag(Tok, diag::err_expected_after) << Keyword << tok::equal;
941  SkipUntil(tok::r_paren, StopAtSemi);
942  return;
943  }
944  ConsumeToken();
945  if (Keyword == Ident_message || Keyword == Ident_replacement) {
946  if (Tok.isNot(tok::string_literal)) {
947  Diag(Tok, diag::err_expected_string_literal)
948  << /*Source='availability attribute'*/2;
949  SkipUntil(tok::r_paren, StopAtSemi);
950  return;
951  }
952  if (Keyword == Ident_message)
953  MessageExpr = ParseStringLiteralExpression();
954  else
955  ReplacementExpr = ParseStringLiteralExpression();
956  // Also reject wide string literals.
957  if (StringLiteral *MessageStringLiteral =
958  cast_or_null<StringLiteral>(MessageExpr.get())) {
959  if (MessageStringLiteral->getCharByteWidth() != 1) {
960  Diag(MessageStringLiteral->getSourceRange().getBegin(),
961  diag::err_expected_string_literal)
962  << /*Source='availability attribute'*/ 2;
963  SkipUntil(tok::r_paren, StopAtSemi);
964  return;
965  }
966  }
967  if (Keyword == Ident_message)
968  break;
969  else
970  continue;
971  }
972 
973  // Special handling of 'NA' only when applied to introduced or
974  // deprecated.
975  if ((Keyword == Ident_introduced || Keyword == Ident_deprecated) &&
976  Tok.is(tok::identifier)) {
977  IdentifierInfo *NA = Tok.getIdentifierInfo();
978  if (NA->getName() == "NA") {
979  ConsumeToken();
980  if (Keyword == Ident_introduced)
981  UnavailableLoc = KeywordLoc;
982  continue;
983  }
984  }
985 
986  SourceRange VersionRange;
987  VersionTuple Version = ParseVersionTuple(VersionRange);
988 
989  if (Version.empty()) {
990  SkipUntil(tok::r_paren, StopAtSemi);
991  return;
992  }
993 
994  unsigned Index;
995  if (Keyword == Ident_introduced)
996  Index = Introduced;
997  else if (Keyword == Ident_deprecated)
998  Index = Deprecated;
999  else if (Keyword == Ident_obsoleted)
1000  Index = Obsoleted;
1001  else
1002  Index = Unknown;
1003 
1004  if (Index < Unknown) {
1005  if (!Changes[Index].KeywordLoc.isInvalid()) {
1006  Diag(KeywordLoc, diag::err_availability_redundant)
1007  << Keyword
1008  << SourceRange(Changes[Index].KeywordLoc,
1009  Changes[Index].VersionRange.getEnd());
1010  }
1011 
1012  Changes[Index].KeywordLoc = KeywordLoc;
1013  Changes[Index].Version = Version;
1014  Changes[Index].VersionRange = VersionRange;
1015  } else {
1016  Diag(KeywordLoc, diag::err_availability_unknown_change)
1017  << Keyword << VersionRange;
1018  }
1019 
1020  } while (TryConsumeToken(tok::comma));
1021 
1022  // Closing ')'.
1023  if (T.consumeClose())
1024  return;
1025 
1026  if (endLoc)
1027  *endLoc = T.getCloseLocation();
1028 
1029  // The 'unavailable' availability cannot be combined with any other
1030  // availability changes. Make sure that hasn't happened.
1031  if (UnavailableLoc.isValid()) {
1032  bool Complained = false;
1033  for (unsigned Index = Introduced; Index != Unknown; ++Index) {
1034  if (Changes[Index].KeywordLoc.isValid()) {
1035  if (!Complained) {
1036  Diag(UnavailableLoc, diag::warn_availability_and_unavailable)
1037  << SourceRange(Changes[Index].KeywordLoc,
1038  Changes[Index].VersionRange.getEnd());
1039  Complained = true;
1040  }
1041 
1042  // Clear out the availability.
1043  Changes[Index] = AvailabilityChange();
1044  }
1045  }
1046  }
1047 
1048  // Record this attribute
1049  attrs.addNew(&Availability,
1050  SourceRange(AvailabilityLoc, T.getCloseLocation()),
1051  ScopeName, ScopeLoc,
1052  Platform,
1053  Changes[Introduced],
1054  Changes[Deprecated],
1055  Changes[Obsoleted],
1056  UnavailableLoc, MessageExpr.get(),
1057  Syntax, StrictLoc, ReplacementExpr.get());
1058 }
1059 
1060 /// \brief Parse the contents of the "objc_bridge_related" attribute.
1061 /// objc_bridge_related '(' related_class ',' opt-class_method ',' opt-instance_method ')'
1062 /// related_class:
1063 /// Identifier
1064 ///
1065 /// opt-class_method:
1066 /// Identifier: | <empty>
1067 ///
1068 /// opt-instance_method:
1069 /// Identifier | <empty>
1070 ///
1071 void Parser::ParseObjCBridgeRelatedAttribute(IdentifierInfo &ObjCBridgeRelated,
1072  SourceLocation ObjCBridgeRelatedLoc,
1073  ParsedAttributes &attrs,
1074  SourceLocation *endLoc,
1075  IdentifierInfo *ScopeName,
1076  SourceLocation ScopeLoc,
1077  AttributeList::Syntax Syntax) {
1078  // Opening '('.
1079  BalancedDelimiterTracker T(*this, tok::l_paren);
1080  if (T.consumeOpen()) {
1081  Diag(Tok, diag::err_expected) << tok::l_paren;
1082  return;
1083  }
1084 
1085  // Parse the related class name.
1086  if (Tok.isNot(tok::identifier)) {
1087  Diag(Tok, diag::err_objcbridge_related_expected_related_class);
1088  SkipUntil(tok::r_paren, StopAtSemi);
1089  return;
1090  }
1091  IdentifierLoc *RelatedClass = ParseIdentifierLoc();
1092  if (ExpectAndConsume(tok::comma)) {
1093  SkipUntil(tok::r_paren, StopAtSemi);
1094  return;
1095  }
1096 
1097  // Parse optional class method name.
1098  IdentifierLoc *ClassMethod = nullptr;
1099  if (Tok.is(tok::identifier)) {
1100  ClassMethod = ParseIdentifierLoc();
1101  if (!TryConsumeToken(tok::colon)) {
1102  Diag(Tok, diag::err_objcbridge_related_selector_name);
1103  SkipUntil(tok::r_paren, StopAtSemi);
1104  return;
1105  }
1106  }
1107  if (!TryConsumeToken(tok::comma)) {
1108  if (Tok.is(tok::colon))
1109  Diag(Tok, diag::err_objcbridge_related_selector_name);
1110  else
1111  Diag(Tok, diag::err_expected) << tok::comma;
1112  SkipUntil(tok::r_paren, StopAtSemi);
1113  return;
1114  }
1115 
1116  // Parse optional instance method name.
1117  IdentifierLoc *InstanceMethod = nullptr;
1118  if (Tok.is(tok::identifier))
1119  InstanceMethod = ParseIdentifierLoc();
1120  else if (Tok.isNot(tok::r_paren)) {
1121  Diag(Tok, diag::err_expected) << tok::r_paren;
1122  SkipUntil(tok::r_paren, StopAtSemi);
1123  return;
1124  }
1125 
1126  // Closing ')'.
1127  if (T.consumeClose())
1128  return;
1129 
1130  if (endLoc)
1131  *endLoc = T.getCloseLocation();
1132 
1133  // Record this attribute
1134  attrs.addNew(&ObjCBridgeRelated,
1135  SourceRange(ObjCBridgeRelatedLoc, T.getCloseLocation()),
1136  ScopeName, ScopeLoc,
1137  RelatedClass,
1138  ClassMethod,
1139  InstanceMethod,
1140  Syntax);
1141 }
1142 
1143 // Late Parsed Attributes:
1144 // See other examples of late parsing in lib/Parse/ParseCXXInlineMethods
1145 
1146 void Parser::LateParsedDeclaration::ParseLexedAttributes() {}
1147 
1148 void Parser::LateParsedClass::ParseLexedAttributes() {
1149  Self->ParseLexedAttributes(*Class);
1150 }
1151 
1152 void Parser::LateParsedAttribute::ParseLexedAttributes() {
1153  Self->ParseLexedAttribute(*this, true, false);
1154 }
1155 
1156 /// Wrapper class which calls ParseLexedAttribute, after setting up the
1157 /// scope appropriately.
1158 void Parser::ParseLexedAttributes(ParsingClass &Class) {
1159  // Deal with templates
1160  // FIXME: Test cases to make sure this does the right thing for templates.
1161  bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
1162  ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
1163  HasTemplateScope);
1164  if (HasTemplateScope)
1165  Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
1166 
1167  // Set or update the scope flags.
1168  bool AlreadyHasClassScope = Class.TopLevelClass;
1169  unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope;
1170  ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope);
1171  ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope);
1172 
1173  // Enter the scope of nested classes
1174  if (!AlreadyHasClassScope)
1176  Class.TagOrTemplate);
1177  if (!Class.LateParsedDeclarations.empty()) {
1178  for (unsigned i = 0, ni = Class.LateParsedDeclarations.size(); i < ni; ++i){
1179  Class.LateParsedDeclarations[i]->ParseLexedAttributes();
1180  }
1181  }
1182 
1183  if (!AlreadyHasClassScope)
1185  Class.TagOrTemplate);
1186 }
1187 
1188 /// \brief Parse all attributes in LAs, and attach them to Decl D.
1189 void Parser::ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D,
1190  bool EnterScope, bool OnDefinition) {
1191  assert(LAs.parseSoon() &&
1192  "Attribute list should be marked for immediate parsing.");
1193  for (unsigned i = 0, ni = LAs.size(); i < ni; ++i) {
1194  if (D)
1195  LAs[i]->addDecl(D);
1196  ParseLexedAttribute(*LAs[i], EnterScope, OnDefinition);
1197  delete LAs[i];
1198  }
1199  LAs.clear();
1200 }
1201 
1202 /// \brief Finish parsing an attribute for which parsing was delayed.
1203 /// This will be called at the end of parsing a class declaration
1204 /// for each LateParsedAttribute. We consume the saved tokens and
1205 /// create an attribute with the arguments filled in. We add this
1206 /// to the Attribute list for the decl.
1207 void Parser::ParseLexedAttribute(LateParsedAttribute &LA,
1208  bool EnterScope, bool OnDefinition) {
1209  // Create a fake EOF so that attribute parsing won't go off the end of the
1210  // attribute.
1211  Token AttrEnd;
1212  AttrEnd.startToken();
1213  AttrEnd.setKind(tok::eof);
1214  AttrEnd.setLocation(Tok.getLocation());
1215  AttrEnd.setEofData(LA.Toks.data());
1216  LA.Toks.push_back(AttrEnd);
1217 
1218  // Append the current token at the end of the new token stream so that it
1219  // doesn't get lost.
1220  LA.Toks.push_back(Tok);
1221  PP.EnterTokenStream(LA.Toks, true);
1222  // Consume the previously pushed token.
1223  ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
1224 
1225  ParsedAttributes Attrs(AttrFactory);
1226  SourceLocation endLoc;
1227 
1228  if (LA.Decls.size() > 0) {
1229  Decl *D = LA.Decls[0];
1230  NamedDecl *ND = dyn_cast<NamedDecl>(D);
1231  RecordDecl *RD = dyn_cast_or_null<RecordDecl>(D->getDeclContext());
1232 
1233  // Allow 'this' within late-parsed attributes.
1234  Sema::CXXThisScopeRAII ThisScope(Actions, RD, /*TypeQuals=*/0,
1235  ND && ND->isCXXInstanceMember());
1236 
1237  if (LA.Decls.size() == 1) {
1238  // If the Decl is templatized, add template parameters to scope.
1239  bool HasTemplateScope = EnterScope && D->isTemplateDecl();
1240  ParseScope TempScope(this, Scope::TemplateParamScope, HasTemplateScope);
1241  if (HasTemplateScope)
1242  Actions.ActOnReenterTemplateScope(Actions.CurScope, D);
1243 
1244  // If the Decl is on a function, add function parameters to the scope.
1245  bool HasFunScope = EnterScope && D->isFunctionOrFunctionTemplate();
1246  ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope, HasFunScope);
1247  if (HasFunScope)
1248  Actions.ActOnReenterFunctionContext(Actions.CurScope, D);
1249 
1250  ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc,
1252  nullptr);
1253 
1254  if (HasFunScope) {
1255  Actions.ActOnExitFunctionContext();
1256  FnScope.Exit(); // Pop scope, and remove Decls from IdResolver
1257  }
1258  if (HasTemplateScope) {
1259  TempScope.Exit();
1260  }
1261  } else {
1262  // If there are multiple decls, then the decl cannot be within the
1263  // function scope.
1264  ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc,
1266  nullptr);
1267  }
1268  } else {
1269  Diag(Tok, diag::warn_attribute_no_decl) << LA.AttrName.getName();
1270  }
1271 
1272  const AttributeList *AL = Attrs.getList();
1273  if (OnDefinition && AL && !AL->isCXX11Attribute() &&
1274  AL->isKnownToGCC())
1275  Diag(Tok, diag::warn_attribute_on_function_definition)
1276  << &LA.AttrName;
1277 
1278  for (unsigned i = 0, ni = LA.Decls.size(); i < ni; ++i)
1279  Actions.ActOnFinishDelayedAttribute(getCurScope(), LA.Decls[i], Attrs);
1280 
1281  // Due to a parsing error, we either went over the cached tokens or
1282  // there are still cached tokens left, so we skip the leftover tokens.
1283  while (Tok.isNot(tok::eof))
1284  ConsumeAnyToken();
1285 
1286  if (Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData())
1287  ConsumeAnyToken();
1288 }
1289 
1290 void Parser::ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName,
1291  SourceLocation AttrNameLoc,
1292  ParsedAttributes &Attrs,
1293  SourceLocation *EndLoc,
1294  IdentifierInfo *ScopeName,
1295  SourceLocation ScopeLoc,
1296  AttributeList::Syntax Syntax) {
1297  assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
1298 
1299  BalancedDelimiterTracker T(*this, tok::l_paren);
1300  T.consumeOpen();
1301 
1302  if (Tok.isNot(tok::identifier)) {
1303  Diag(Tok, diag::err_expected) << tok::identifier;
1304  T.skipToEnd();
1305  return;
1306  }
1307  IdentifierLoc *ArgumentKind = ParseIdentifierLoc();
1308 
1309  if (ExpectAndConsume(tok::comma)) {
1310  T.skipToEnd();
1311  return;
1312  }
1313 
1314  SourceRange MatchingCTypeRange;
1315  TypeResult MatchingCType = ParseTypeName(&MatchingCTypeRange);
1316  if (MatchingCType.isInvalid()) {
1317  T.skipToEnd();
1318  return;
1319  }
1320 
1321  bool LayoutCompatible = false;
1322  bool MustBeNull = false;
1323  while (TryConsumeToken(tok::comma)) {
1324  if (Tok.isNot(tok::identifier)) {
1325  Diag(Tok, diag::err_expected) << tok::identifier;
1326  T.skipToEnd();
1327  return;
1328  }
1329  IdentifierInfo *Flag = Tok.getIdentifierInfo();
1330  if (Flag->isStr("layout_compatible"))
1331  LayoutCompatible = true;
1332  else if (Flag->isStr("must_be_null"))
1333  MustBeNull = true;
1334  else {
1335  Diag(Tok, diag::err_type_safety_unknown_flag) << Flag;
1336  T.skipToEnd();
1337  return;
1338  }
1339  ConsumeToken(); // consume flag
1340  }
1341 
1342  if (!T.consumeClose()) {
1343  Attrs.addNewTypeTagForDatatype(&AttrName, AttrNameLoc, ScopeName, ScopeLoc,
1344  ArgumentKind, MatchingCType.get(),
1345  LayoutCompatible, MustBeNull, Syntax);
1346  }
1347 
1348  if (EndLoc)
1349  *EndLoc = T.getCloseLocation();
1350 }
1351 
1352 /// DiagnoseProhibitedCXX11Attribute - We have found the opening square brackets
1353 /// of a C++11 attribute-specifier in a location where an attribute is not
1354 /// permitted. By C++11 [dcl.attr.grammar]p6, this is ill-formed. Diagnose this
1355 /// situation.
1356 ///
1357 /// \return \c true if we skipped an attribute-like chunk of tokens, \c false if
1358 /// this doesn't appear to actually be an attribute-specifier, and the caller
1359 /// should try to parse it.
1360 bool Parser::DiagnoseProhibitedCXX11Attribute() {
1361  assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square));
1362 
1363  switch (isCXX11AttributeSpecifier(/*Disambiguate*/true)) {
1364  case CAK_NotAttributeSpecifier:
1365  // No diagnostic: we're in Obj-C++11 and this is not actually an attribute.
1366  return false;
1367 
1368  case CAK_InvalidAttributeSpecifier:
1369  Diag(Tok.getLocation(), diag::err_l_square_l_square_not_attribute);
1370  return false;
1371 
1372  case CAK_AttributeSpecifier:
1373  // Parse and discard the attributes.
1374  SourceLocation BeginLoc = ConsumeBracket();
1375  ConsumeBracket();
1376  SkipUntil(tok::r_square);
1377  assert(Tok.is(tok::r_square) && "isCXX11AttributeSpecifier lied");
1378  SourceLocation EndLoc = ConsumeBracket();
1379  Diag(BeginLoc, diag::err_attributes_not_allowed)
1380  << SourceRange(BeginLoc, EndLoc);
1381  return true;
1382  }
1383  llvm_unreachable("All cases handled above.");
1384 }
1385 
1386 /// \brief We have found the opening square brackets of a C++11
1387 /// attribute-specifier in a location where an attribute is not permitted, but
1388 /// we know where the attributes ought to be written. Parse them anyway, and
1389 /// provide a fixit moving them to the right place.
1390 void Parser::DiagnoseMisplacedCXX11Attribute(ParsedAttributesWithRange &Attrs,
1391  SourceLocation CorrectLocation) {
1392  assert((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) ||
1393  Tok.is(tok::kw_alignas));
1394 
1395  // Consume the attributes.
1396  SourceLocation Loc = Tok.getLocation();
1397  ParseCXX11Attributes(Attrs);
1398  CharSourceRange AttrRange(SourceRange(Loc, Attrs.Range.getEnd()), true);
1399 
1400  Diag(Loc, diag::err_attributes_not_allowed)
1401  << FixItHint::CreateInsertionFromRange(CorrectLocation, AttrRange)
1402  << FixItHint::CreateRemoval(AttrRange);
1403 }
1404 
1405 void Parser::DiagnoseProhibitedAttributes(ParsedAttributesWithRange &attrs) {
1406  Diag(attrs.Range.getBegin(), diag::err_attributes_not_allowed)
1407  << attrs.Range;
1408 }
1409 
1410 void Parser::ProhibitCXX11Attributes(ParsedAttributesWithRange &attrs) {
1411  AttributeList *AttrList = attrs.getList();
1412  while (AttrList) {
1413  if (AttrList->isCXX11Attribute()) {
1414  Diag(AttrList->getLoc(), diag::err_attribute_not_type_attr)
1415  << AttrList->getName();
1416  AttrList->setInvalid();
1417  }
1418  AttrList = AttrList->getNext();
1419  }
1420 }
1421 
1422 // As an exception to the rule, __declspec(align(...)) before the
1423 // class-key affects the type instead of the variable.
1424 void Parser::handleDeclspecAlignBeforeClassKey(ParsedAttributesWithRange &Attrs,
1425  DeclSpec &DS,
1426  Sema::TagUseKind TUK) {
1427  if (TUK == Sema::TUK_Reference)
1428  return;
1429 
1430  ParsedAttributes &PA = DS.getAttributes();
1431  AttributeList *AL = PA.getList();
1432  AttributeList *Prev = nullptr;
1433  while (AL) {
1434  AttributeList *Next = AL->getNext();
1435 
1436  // We only consider attributes using the appropriate '__declspec' spelling.
1437  // This behavior doesn't extend to any other spellings.
1438  if (AL->getKind() == AttributeList::AT_Aligned &&
1439  AL->isDeclspecAttribute()) {
1440  // Stitch the attribute into the tag's attribute list.
1441  AL->setNext(nullptr);
1442  Attrs.add(AL);
1443 
1444  // Remove the attribute from the variable's attribute list.
1445  if (Prev) {
1446  // Set the last variable attribute's next attribute to be the attribute
1447  // after the current one.
1448  Prev->setNext(Next);
1449  } else {
1450  // Removing the head of the list requires us to reset the head to the
1451  // next attribute.
1452  PA.set(Next);
1453  }
1454  } else {
1455  Prev = AL;
1456  }
1457 
1458  AL = Next;
1459  }
1460 }
1461 
1462 /// ParseDeclaration - Parse a full 'declaration', which consists of
1463 /// declaration-specifiers, some number of declarators, and a semicolon.
1464 /// 'Context' should be a Declarator::TheContext value. This returns the
1465 /// location of the semicolon in DeclEnd.
1466 ///
1467 /// declaration: [C99 6.7]
1468 /// block-declaration ->
1469 /// simple-declaration
1470 /// others [FIXME]
1471 /// [C++] template-declaration
1472 /// [C++] namespace-definition
1473 /// [C++] using-directive
1474 /// [C++] using-declaration
1475 /// [C++11/C11] static_assert-declaration
1476 /// others... [FIXME]
1477 ///
1478 Parser::DeclGroupPtrTy Parser::ParseDeclaration(unsigned Context,
1479  SourceLocation &DeclEnd,
1480  ParsedAttributesWithRange &attrs) {
1481  ParenBraceBracketBalancer BalancerRAIIObj(*this);
1482  // Must temporarily exit the objective-c container scope for
1483  // parsing c none objective-c decls.
1484  ObjCDeclContextSwitch ObjCDC(*this);
1485 
1486  Decl *SingleDecl = nullptr;
1487  Decl *OwnedType = nullptr;
1488  switch (Tok.getKind()) {
1489  case tok::kw_template:
1490  case tok::kw_export:
1491  ProhibitAttributes(attrs);
1492  SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd);
1493  break;
1494  case tok::kw_inline:
1495  // Could be the start of an inline namespace. Allowed as an ext in C++03.
1496  if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_namespace)) {
1497  ProhibitAttributes(attrs);
1498  SourceLocation InlineLoc = ConsumeToken();
1499  return ParseNamespace(Context, DeclEnd, InlineLoc);
1500  }
1501  return ParseSimpleDeclaration(Context, DeclEnd, attrs,
1502  true);
1503  case tok::kw_namespace:
1504  ProhibitAttributes(attrs);
1505  return ParseNamespace(Context, DeclEnd);
1506  case tok::kw_using:
1507  SingleDecl = ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(),
1508  DeclEnd, attrs, &OwnedType);
1509  break;
1510  case tok::kw_static_assert:
1511  case tok::kw__Static_assert:
1512  ProhibitAttributes(attrs);
1513  SingleDecl = ParseStaticAssertDeclaration(DeclEnd);
1514  break;
1515  default:
1516  return ParseSimpleDeclaration(Context, DeclEnd, attrs, true);
1517  }
1518 
1519  // This routine returns a DeclGroup, if the thing we parsed only contains a
1520  // single decl, convert it now. Alias declarations can also declare a type;
1521  // include that too if it is present.
1522  return Actions.ConvertDeclToDeclGroup(SingleDecl, OwnedType);
1523 }
1524 
1525 /// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
1526 /// declaration-specifiers init-declarator-list[opt] ';'
1527 /// [C++11] attribute-specifier-seq decl-specifier-seq[opt]
1528 /// init-declarator-list ';'
1529 ///[C90/C++]init-declarator-list ';' [TODO]
1530 /// [OMP] threadprivate-directive [TODO]
1531 ///
1532 /// for-range-declaration: [C++11 6.5p1: stmt.ranged]
1533 /// attribute-specifier-seq[opt] type-specifier-seq declarator
1534 ///
1535 /// If RequireSemi is false, this does not check for a ';' at the end of the
1536 /// declaration. If it is true, it checks for and eats it.
1537 ///
1538 /// If FRI is non-null, we might be parsing a for-range-declaration instead
1539 /// of a simple-declaration. If we find that we are, we also parse the
1540 /// for-range-initializer, and place it here.
1542 Parser::ParseSimpleDeclaration(unsigned Context,
1543  SourceLocation &DeclEnd,
1544  ParsedAttributesWithRange &Attrs,
1545  bool RequireSemi, ForRangeInit *FRI) {
1546  // Parse the common declaration-specifiers piece.
1547  ParsingDeclSpec DS(*this);
1548 
1549  DeclSpecContext DSContext = getDeclSpecContextFromDeclaratorContext(Context);
1550  ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none, DSContext);
1551 
1552  // If we had a free-standing type definition with a missing semicolon, we
1553  // may get this far before the problem becomes obvious.
1554  if (DS.hasTagDefinition() &&
1555  DiagnoseMissingSemiAfterTagDefinition(DS, AS_none, DSContext))
1556  return nullptr;
1557 
1558  // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
1559  // declaration-specifiers init-declarator-list[opt] ';'
1560  if (Tok.is(tok::semi)) {
1561  ProhibitAttributes(Attrs);
1562  DeclEnd = Tok.getLocation();
1563  if (RequireSemi) ConsumeToken();
1564  RecordDecl *AnonRecord = nullptr;
1565  Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
1566  DS, AnonRecord);
1567  DS.complete(TheDecl);
1568  if (AnonRecord) {
1569  Decl* decls[] = {AnonRecord, TheDecl};
1570  return Actions.BuildDeclaratorGroup(decls, /*TypeMayContainAuto=*/false);
1571  }
1572  return Actions.ConvertDeclToDeclGroup(TheDecl);
1573  }
1574 
1575  DS.takeAttributesFrom(Attrs);
1576  return ParseDeclGroup(DS, Context, &DeclEnd, FRI);
1577 }
1578 
1579 /// Returns true if this might be the start of a declarator, or a common typo
1580 /// for a declarator.
1581 bool Parser::MightBeDeclarator(unsigned Context) {
1582  switch (Tok.getKind()) {
1583  case tok::annot_cxxscope:
1584  case tok::annot_template_id:
1585  case tok::caret:
1586  case tok::code_completion:
1587  case tok::coloncolon:
1588  case tok::ellipsis:
1589  case tok::kw___attribute:
1590  case tok::kw_operator:
1591  case tok::l_paren:
1592  case tok::star:
1593  return true;
1594 
1595  case tok::amp:
1596  case tok::ampamp:
1597  return getLangOpts().CPlusPlus;
1598 
1599  case tok::l_square: // Might be an attribute on an unnamed bit-field.
1600  return Context == Declarator::MemberContext && getLangOpts().CPlusPlus11 &&
1601  NextToken().is(tok::l_square);
1602 
1603  case tok::colon: // Might be a typo for '::' or an unnamed bit-field.
1604  return Context == Declarator::MemberContext || getLangOpts().CPlusPlus;
1605 
1606  case tok::identifier:
1607  switch (NextToken().getKind()) {
1608  case tok::code_completion:
1609  case tok::coloncolon:
1610  case tok::comma:
1611  case tok::equal:
1612  case tok::equalequal: // Might be a typo for '='.
1613  case tok::kw_alignas:
1614  case tok::kw_asm:
1615  case tok::kw___attribute:
1616  case tok::l_brace:
1617  case tok::l_paren:
1618  case tok::l_square:
1619  case tok::less:
1620  case tok::r_brace:
1621  case tok::r_paren:
1622  case tok::r_square:
1623  case tok::semi:
1624  return true;
1625 
1626  case tok::colon:
1627  // At namespace scope, 'identifier:' is probably a typo for 'identifier::'
1628  // and in block scope it's probably a label. Inside a class definition,
1629  // this is a bit-field.
1630  return Context == Declarator::MemberContext ||
1631  (getLangOpts().CPlusPlus && Context == Declarator::FileContext);
1632 
1633  case tok::identifier: // Possible virt-specifier.
1634  return getLangOpts().CPlusPlus11 && isCXX11VirtSpecifier(NextToken());
1635 
1636  default:
1637  return false;
1638  }
1639 
1640  default:
1641  return false;
1642  }
1643 }
1644 
1645 /// Skip until we reach something which seems like a sensible place to pick
1646 /// up parsing after a malformed declaration. This will sometimes stop sooner
1647 /// than SkipUntil(tok::r_brace) would, but will never stop later.
1649  while (true) {
1650  switch (Tok.getKind()) {
1651  case tok::l_brace:
1652  // Skip until matching }, then stop. We've probably skipped over
1653  // a malformed class or function definition or similar.
1654  ConsumeBrace();
1655  SkipUntil(tok::r_brace);
1656  if (Tok.isOneOf(tok::comma, tok::l_brace, tok::kw_try)) {
1657  // This declaration isn't over yet. Keep skipping.
1658  continue;
1659  }
1660  TryConsumeToken(tok::semi);
1661  return;
1662 
1663  case tok::l_square:
1664  ConsumeBracket();
1665  SkipUntil(tok::r_square);
1666  continue;
1667 
1668  case tok::l_paren:
1669  ConsumeParen();
1670  SkipUntil(tok::r_paren);
1671  continue;
1672 
1673  case tok::r_brace:
1674  return;
1675 
1676  case tok::semi:
1677  ConsumeToken();
1678  return;
1679 
1680  case tok::kw_inline:
1681  // 'inline namespace' at the start of a line is almost certainly
1682  // a good place to pick back up parsing, except in an Objective-C
1683  // @interface context.
1684  if (Tok.isAtStartOfLine() && NextToken().is(tok::kw_namespace) &&
1685  (!ParsingInObjCContainer || CurParsedObjCImpl))
1686  return;
1687  break;
1688 
1689  case tok::kw_namespace:
1690  // 'namespace' at the start of a line is almost certainly a good
1691  // place to pick back up parsing, except in an Objective-C
1692  // @interface context.
1693  if (Tok.isAtStartOfLine() &&
1694  (!ParsingInObjCContainer || CurParsedObjCImpl))
1695  return;
1696  break;
1697 
1698  case tok::at:
1699  // @end is very much like } in Objective-C contexts.
1700  if (NextToken().isObjCAtKeyword(tok::objc_end) &&
1701  ParsingInObjCContainer)
1702  return;
1703  break;
1704 
1705  case tok::minus:
1706  case tok::plus:
1707  // - and + probably start new method declarations in Objective-C contexts.
1708  if (Tok.isAtStartOfLine() && ParsingInObjCContainer)
1709  return;
1710  break;
1711 
1712  case tok::eof:
1713  case tok::annot_module_begin:
1714  case tok::annot_module_end:
1715  case tok::annot_module_include:
1716  return;
1717 
1718  default:
1719  break;
1720  }
1721 
1722  ConsumeAnyToken();
1723  }
1724 }
1725 
1726 /// ParseDeclGroup - Having concluded that this is either a function
1727 /// definition or a group of object declarations, actually parse the
1728 /// result.
1729 Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS,
1730  unsigned Context,
1731  SourceLocation *DeclEnd,
1732  ForRangeInit *FRI) {
1733  // Parse the first declarator.
1734  ParsingDeclarator D(*this, DS, static_cast<Declarator::TheContext>(Context));
1735  ParseDeclarator(D);
1736 
1737  // Bail out if the first declarator didn't seem well-formed.
1738  if (!D.hasName() && !D.mayOmitIdentifier()) {
1740  return nullptr;
1741  }
1742 
1743  // Save late-parsed attributes for now; they need to be parsed in the
1744  // appropriate function scope after the function Decl has been constructed.
1745  // These will be parsed in ParseFunctionDefinition or ParseLexedAttrList.
1746  LateParsedAttrList LateParsedAttrs(true);
1747  if (D.isFunctionDeclarator()) {
1748  MaybeParseGNUAttributes(D, &LateParsedAttrs);
1749 
1750  // The _Noreturn keyword can't appear here, unlike the GNU noreturn
1751  // attribute. If we find the keyword here, tell the user to put it
1752  // at the start instead.
1753  if (Tok.is(tok::kw__Noreturn)) {
1754  SourceLocation Loc = ConsumeToken();
1755  const char *PrevSpec;
1756  unsigned DiagID;
1757 
1758  // We can offer a fixit if it's valid to mark this function as _Noreturn
1759  // and we don't have any other declarators in this declaration.
1760  bool Fixit = !DS.setFunctionSpecNoreturn(Loc, PrevSpec, DiagID);
1761  MaybeParseGNUAttributes(D, &LateParsedAttrs);
1762  Fixit &= Tok.isOneOf(tok::semi, tok::l_brace, tok::kw_try);
1763 
1764  Diag(Loc, diag::err_c11_noreturn_misplaced)
1765  << (Fixit ? FixItHint::CreateRemoval(Loc) : FixItHint())
1766  << (Fixit ? FixItHint::CreateInsertion(D.getLocStart(), "_Noreturn ")
1767  : FixItHint());
1768  }
1769  }
1770 
1771  // Check to see if we have a function *definition* which must have a body.
1772  if (D.isFunctionDeclarator() &&
1773  // Look at the next token to make sure that this isn't a function
1774  // declaration. We have to check this because __attribute__ might be the
1775  // start of a function definition in GCC-extended K&R C.
1776  !isDeclarationAfterDeclarator()) {
1777 
1778  // Function definitions are only allowed at file scope and in C++ classes.
1779  // The C++ inline method definition case is handled elsewhere, so we only
1780  // need to handle the file scope definition case.
1781  if (Context == Declarator::FileContext) {
1782  if (isStartOfFunctionDefinition(D)) {
1784  Diag(Tok, diag::err_function_declared_typedef);
1785 
1786  // Recover by treating the 'typedef' as spurious.
1788  }
1789 
1790  Decl *TheDecl =
1791  ParseFunctionDefinition(D, ParsedTemplateInfo(), &LateParsedAttrs);
1792  return Actions.ConvertDeclToDeclGroup(TheDecl);
1793  }
1794 
1795  if (isDeclarationSpecifier()) {
1796  // If there is an invalid declaration specifier right after the
1797  // function prototype, then we must be in a missing semicolon case
1798  // where this isn't actually a body. Just fall through into the code
1799  // that handles it as a prototype, and let the top-level code handle
1800  // the erroneous declspec where it would otherwise expect a comma or
1801  // semicolon.
1802  } else {
1803  Diag(Tok, diag::err_expected_fn_body);
1804  SkipUntil(tok::semi);
1805  return nullptr;
1806  }
1807  } else {
1808  if (Tok.is(tok::l_brace)) {
1809  Diag(Tok, diag::err_function_definition_not_allowed);
1811  return nullptr;
1812  }
1813  }
1814  }
1815 
1816  if (ParseAsmAttributesAfterDeclarator(D))
1817  return nullptr;
1818 
1819  // C++0x [stmt.iter]p1: Check if we have a for-range-declarator. If so, we
1820  // must parse and analyze the for-range-initializer before the declaration is
1821  // analyzed.
1822  //
1823  // Handle the Objective-C for-in loop variable similarly, although we
1824  // don't need to parse the container in advance.
1825  if (FRI && (Tok.is(tok::colon) || isTokIdentifier_in())) {
1826  bool IsForRangeLoop = false;
1827  if (TryConsumeToken(tok::colon, FRI->ColonLoc)) {
1828  IsForRangeLoop = true;
1829  if (Tok.is(tok::l_brace))
1830  FRI->RangeExpr = ParseBraceInitializer();
1831  else
1832  FRI->RangeExpr = ParseExpression();
1833  }
1834 
1835  Decl *ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
1836  if (IsForRangeLoop)
1837  Actions.ActOnCXXForRangeDecl(ThisDecl);
1838  Actions.FinalizeDeclaration(ThisDecl);
1839  D.complete(ThisDecl);
1840  return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, ThisDecl);
1841  }
1842 
1843  SmallVector<Decl *, 8> DeclsInGroup;
1844  Decl *FirstDecl = ParseDeclarationAfterDeclaratorAndAttributes(
1845  D, ParsedTemplateInfo(), FRI);
1846  if (LateParsedAttrs.size() > 0)
1847  ParseLexedAttributeList(LateParsedAttrs, FirstDecl, true, false);
1848  D.complete(FirstDecl);
1849  if (FirstDecl)
1850  DeclsInGroup.push_back(FirstDecl);
1851 
1852  bool ExpectSemi = Context != Declarator::ForContext;
1853 
1854  // If we don't have a comma, it is either the end of the list (a ';') or an
1855  // error, bail out.
1856  SourceLocation CommaLoc;
1857  while (TryConsumeToken(tok::comma, CommaLoc)) {
1858  if (Tok.isAtStartOfLine() && ExpectSemi && !MightBeDeclarator(Context)) {
1859  // This comma was followed by a line-break and something which can't be
1860  // the start of a declarator. The comma was probably a typo for a
1861  // semicolon.
1862  Diag(CommaLoc, diag::err_expected_semi_declaration)
1863  << FixItHint::CreateReplacement(CommaLoc, ";");
1864  ExpectSemi = false;
1865  break;
1866  }
1867 
1868  // Parse the next declarator.
1869  D.clear();
1870  D.setCommaLoc(CommaLoc);
1871 
1872  // Accept attributes in an init-declarator. In the first declarator in a
1873  // declaration, these would be part of the declspec. In subsequent
1874  // declarators, they become part of the declarator itself, so that they
1875  // don't apply to declarators after *this* one. Examples:
1876  // short __attribute__((common)) var; -> declspec
1877  // short var __attribute__((common)); -> declarator
1878  // short x, __attribute__((common)) var; -> declarator
1879  MaybeParseGNUAttributes(D);
1880 
1881  // MSVC parses but ignores qualifiers after the comma as an extension.
1882  if (getLangOpts().MicrosoftExt)
1883  DiagnoseAndSkipExtendedMicrosoftTypeAttributes();
1884 
1885  ParseDeclarator(D);
1886  if (!D.isInvalidType()) {
1887  Decl *ThisDecl = ParseDeclarationAfterDeclarator(D);
1888  D.complete(ThisDecl);
1889  if (ThisDecl)
1890  DeclsInGroup.push_back(ThisDecl);
1891  }
1892  }
1893 
1894  if (DeclEnd)
1895  *DeclEnd = Tok.getLocation();
1896 
1897  if (ExpectSemi &&
1898  ExpectAndConsumeSemi(Context == Declarator::FileContext
1899  ? diag::err_invalid_token_after_toplevel_declarator
1900  : diag::err_expected_semi_declaration)) {
1901  // Okay, there was no semicolon and one was expected. If we see a
1902  // declaration specifier, just assume it was missing and continue parsing.
1903  // Otherwise things are very confused and we skip to recover.
1904  if (!isDeclarationSpecifier()) {
1905  SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
1906  TryConsumeToken(tok::semi);
1907  }
1908  }
1909 
1910  return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, DeclsInGroup);
1911 }
1912 
1913 /// Parse an optional simple-asm-expr and attributes, and attach them to a
1914 /// declarator. Returns true on an error.
1915 bool Parser::ParseAsmAttributesAfterDeclarator(Declarator &D) {
1916  // If a simple-asm-expr is present, parse it.
1917  if (Tok.is(tok::kw_asm)) {
1918  SourceLocation Loc;
1919  ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1920  if (AsmLabel.isInvalid()) {
1921  SkipUntil(tok::semi, StopBeforeMatch);
1922  return true;
1923  }
1924 
1925  D.setAsmLabel(AsmLabel.get());
1926  D.SetRangeEnd(Loc);
1927  }
1928 
1929  MaybeParseGNUAttributes(D);
1930  return false;
1931 }
1932 
1933 /// \brief Parse 'declaration' after parsing 'declaration-specifiers
1934 /// declarator'. This method parses the remainder of the declaration
1935 /// (including any attributes or initializer, among other things) and
1936 /// finalizes the declaration.
1937 ///
1938 /// init-declarator: [C99 6.7]
1939 /// declarator
1940 /// declarator '=' initializer
1941 /// [GNU] declarator simple-asm-expr[opt] attributes[opt]
1942 /// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer
1943 /// [C++] declarator initializer[opt]
1944 ///
1945 /// [C++] initializer:
1946 /// [C++] '=' initializer-clause
1947 /// [C++] '(' expression-list ')'
1948 /// [C++0x] '=' 'default' [TODO]
1949 /// [C++0x] '=' 'delete'
1950 /// [C++0x] braced-init-list
1951 ///
1952 /// According to the standard grammar, =default and =delete are function
1953 /// definitions, but that definitely doesn't fit with the parser here.
1954 ///
1955 Decl *Parser::ParseDeclarationAfterDeclarator(
1956  Declarator &D, const ParsedTemplateInfo &TemplateInfo) {
1957  if (ParseAsmAttributesAfterDeclarator(D))
1958  return nullptr;
1959 
1960  return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo);
1961 }
1962 
1963 Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(
1964  Declarator &D, const ParsedTemplateInfo &TemplateInfo, ForRangeInit *FRI) {
1965  // Inform the current actions module that we just parsed this declarator.
1966  Decl *ThisDecl = nullptr;
1967  switch (TemplateInfo.Kind) {
1968  case ParsedTemplateInfo::NonTemplate:
1969  ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
1970  break;
1971 
1972  case ParsedTemplateInfo::Template:
1973  case ParsedTemplateInfo::ExplicitSpecialization: {
1974  ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
1975  *TemplateInfo.TemplateParams,
1976  D);
1977  if (VarTemplateDecl *VT = dyn_cast_or_null<VarTemplateDecl>(ThisDecl))
1978  // Re-direct this decl to refer to the templated decl so that we can
1979  // initialize it.
1980  ThisDecl = VT->getTemplatedDecl();
1981  break;
1982  }
1983  case ParsedTemplateInfo::ExplicitInstantiation: {
1984  if (Tok.is(tok::semi)) {
1985  DeclResult ThisRes = Actions.ActOnExplicitInstantiation(
1986  getCurScope(), TemplateInfo.ExternLoc, TemplateInfo.TemplateLoc, D);
1987  if (ThisRes.isInvalid()) {
1988  SkipUntil(tok::semi, StopBeforeMatch);
1989  return nullptr;
1990  }
1991  ThisDecl = ThisRes.get();
1992  } else {
1993  // FIXME: This check should be for a variable template instantiation only.
1994 
1995  // Check that this is a valid instantiation
1997  // If the declarator-id is not a template-id, issue a diagnostic and
1998  // recover by ignoring the 'template' keyword.
1999  Diag(Tok, diag::err_template_defn_explicit_instantiation)
2000  << 2 << FixItHint::CreateRemoval(TemplateInfo.TemplateLoc);
2001  ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
2002  } else {
2003  SourceLocation LAngleLoc =
2004  PP.getLocForEndOfToken(TemplateInfo.TemplateLoc);
2005  Diag(D.getIdentifierLoc(),
2006  diag::err_explicit_instantiation_with_definition)
2007  << SourceRange(TemplateInfo.TemplateLoc)
2008  << FixItHint::CreateInsertion(LAngleLoc, "<>");
2009 
2010  // Recover as if it were an explicit specialization.
2011  TemplateParameterLists FakedParamLists;
2012  FakedParamLists.push_back(Actions.ActOnTemplateParameterList(
2013  0, SourceLocation(), TemplateInfo.TemplateLoc, LAngleLoc, None,
2014  LAngleLoc, nullptr));
2015 
2016  ThisDecl =
2017  Actions.ActOnTemplateDeclarator(getCurScope(), FakedParamLists, D);
2018  }
2019  }
2020  break;
2021  }
2022  }
2023 
2024  bool TypeContainsAuto = D.getDeclSpec().containsPlaceholderType();
2025 
2026  // Parse declarator '=' initializer.
2027  // If a '==' or '+=' is found, suggest a fixit to '='.
2028  if (isTokenEqualOrEqualTypo()) {
2029  SourceLocation EqualLoc = ConsumeToken();
2030 
2031  if (Tok.is(tok::kw_delete)) {
2032  if (D.isFunctionDeclarator())
2033  Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
2034  << 1 /* delete */;
2035  else
2036  Diag(ConsumeToken(), diag::err_deleted_non_function);
2037  } else if (Tok.is(tok::kw_default)) {
2038  if (D.isFunctionDeclarator())
2039  Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration)
2040  << 0 /* default */;
2041  else
2042  Diag(ConsumeToken(), diag::err_default_special_members);
2043  } else {
2044  if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
2045  EnterScope(0);
2046  Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
2047  }
2048 
2049  if (Tok.is(tok::code_completion)) {
2050  Actions.CodeCompleteInitializer(getCurScope(), ThisDecl);
2051  Actions.FinalizeDeclaration(ThisDecl);
2052  cutOffParsing();
2053  return nullptr;
2054  }
2055 
2056  ExprResult Init(ParseInitializer());
2057 
2058  // If this is the only decl in (possibly) range based for statement,
2059  // our best guess is that the user meant ':' instead of '='.
2060  if (Tok.is(tok::r_paren) && FRI && D.isFirstDeclarator()) {
2061  Diag(EqualLoc, diag::err_single_decl_assign_in_for_range)
2062  << FixItHint::CreateReplacement(EqualLoc, ":");
2063  // We are trying to stop parser from looking for ';' in this for
2064  // statement, therefore preventing spurious errors to be issued.
2065  FRI->ColonLoc = EqualLoc;
2066  Init = ExprError();
2067  FRI->RangeExpr = Init;
2068  }
2069 
2070  if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
2071  Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
2072  ExitScope();
2073  }
2074 
2075  if (Init.isInvalid()) {
2076  SmallVector<tok::TokenKind, 2> StopTokens;
2077  StopTokens.push_back(tok::comma);
2078  if (D.getContext() == Declarator::ForContext ||
2080  StopTokens.push_back(tok::r_paren);
2081  SkipUntil(StopTokens, StopAtSemi | StopBeforeMatch);
2082  Actions.ActOnInitializerError(ThisDecl);
2083  } else
2084  Actions.AddInitializerToDecl(ThisDecl, Init.get(),
2085  /*DirectInit=*/false, TypeContainsAuto);
2086  }
2087  } else if (Tok.is(tok::l_paren)) {
2088  // Parse C++ direct initializer: '(' expression-list ')'
2089  BalancedDelimiterTracker T(*this, tok::l_paren);
2090  T.consumeOpen();
2091 
2092  ExprVector Exprs;
2093  CommaLocsTy CommaLocs;
2094 
2095  if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
2096  EnterScope(0);
2097  Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
2098  }
2099 
2100  if (ParseExpressionList(Exprs, CommaLocs, [&] {
2102  cast<VarDecl>(ThisDecl)->getType()->getCanonicalTypeInternal(),
2103  ThisDecl->getLocation(), Exprs);
2104  })) {
2105  Actions.ActOnInitializerError(ThisDecl);
2106  SkipUntil(tok::r_paren, StopAtSemi);
2107 
2108  if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
2109  Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
2110  ExitScope();
2111  }
2112  } else {
2113  // Match the ')'.
2114  T.consumeClose();
2115 
2116  assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() &&
2117  "Unexpected number of commas!");
2118 
2119  if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) {
2120  Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
2121  ExitScope();
2122  }
2123 
2124  ExprResult Initializer = Actions.ActOnParenListExpr(T.getOpenLocation(),
2125  T.getCloseLocation(),
2126  Exprs);
2127  Actions.AddInitializerToDecl(ThisDecl, Initializer.get(),
2128  /*DirectInit=*/true, TypeContainsAuto);
2129  }
2130  } else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace) &&
2131  (!CurParsedObjCImpl || !D.isFunctionDeclarator())) {
2132  // Parse C++0x braced-init-list.
2133  Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
2134 
2135  if (D.getCXXScopeSpec().isSet()) {
2136  EnterScope(0);
2137  Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl);
2138  }
2139 
2140  ExprResult Init(ParseBraceInitializer());
2141 
2142  if (D.getCXXScopeSpec().isSet()) {
2143  Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl);
2144  ExitScope();
2145  }
2146 
2147  if (Init.isInvalid()) {
2148  Actions.ActOnInitializerError(ThisDecl);
2149  } else
2150  Actions.AddInitializerToDecl(ThisDecl, Init.get(),
2151  /*DirectInit=*/true, TypeContainsAuto);
2152 
2153  } else {
2154  Actions.ActOnUninitializedDecl(ThisDecl, TypeContainsAuto);
2155  }
2156 
2157  Actions.FinalizeDeclaration(ThisDecl);
2158 
2159  return ThisDecl;
2160 }
2161 
2162 /// ParseSpecifierQualifierList
2163 /// specifier-qualifier-list:
2164 /// type-specifier specifier-qualifier-list[opt]
2165 /// type-qualifier specifier-qualifier-list[opt]
2166 /// [GNU] attributes specifier-qualifier-list[opt]
2167 ///
2168 void Parser::ParseSpecifierQualifierList(DeclSpec &DS, AccessSpecifier AS,
2169  DeclSpecContext DSC) {
2170  /// specifier-qualifier-list is a subset of declaration-specifiers. Just
2171  /// parse declaration-specifiers and complain about extra stuff.
2172  /// TODO: diagnose attribute-specifiers and alignment-specifiers.
2173  ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC);
2174 
2175  // Validate declspec for type-name.
2176  unsigned Specs = DS.getParsedSpecifiers();
2177  if (isTypeSpecifier(DSC) && !DS.hasTypeSpecifier()) {
2178  Diag(Tok, diag::err_expected_type);
2179  DS.SetTypeSpecError();
2180  } else if (Specs == DeclSpec::PQ_None && !DS.hasAttributes()) {
2181  Diag(Tok, diag::err_typename_requires_specqual);
2182  if (!DS.hasTypeSpecifier())
2183  DS.SetTypeSpecError();
2184  }
2185 
2186  // Issue diagnostic and remove storage class if present.
2187  if (Specs & DeclSpec::PQ_StorageClassSpecifier) {
2188  if (DS.getStorageClassSpecLoc().isValid())
2189  Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass);
2190  else
2192  diag::err_typename_invalid_storageclass);
2194  }
2195 
2196  // Issue diagnostic and remove function specifier if present.
2197  if (Specs & DeclSpec::PQ_FunctionSpecifier) {
2198  if (DS.isInlineSpecified())
2199  Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
2200  if (DS.isVirtualSpecified())
2201  Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
2202  if (DS.isExplicitSpecified())
2203  Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
2204  DS.ClearFunctionSpecs();
2205  }
2206 
2207  // Issue diagnostic and remove constexpr specfier if present.
2208  if (DS.isConstexprSpecified() && DSC != DSC_condition) {
2209  Diag(DS.getConstexprSpecLoc(), diag::err_typename_invalid_constexpr);
2210  DS.ClearConstexprSpec();
2211  }
2212 }
2213 
2214 /// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
2215 /// specified token is valid after the identifier in a declarator which
2216 /// immediately follows the declspec. For example, these things are valid:
2217 ///
2218 /// int x [ 4]; // direct-declarator
2219 /// int x ( int y); // direct-declarator
2220 /// int(int x ) // direct-declarator
2221 /// int x ; // simple-declaration
2222 /// int x = 17; // init-declarator-list
2223 /// int x , y; // init-declarator-list
2224 /// int x __asm__ ("foo"); // init-declarator-list
2225 /// int x : 4; // struct-declarator
2226 /// int x { 5}; // C++'0x unified initializers
2227 ///
2228 /// This is not, because 'x' does not immediately follow the declspec (though
2229 /// ')' happens to be valid anyway).
2230 /// int (x)
2231 ///
2233  return T.isOneOf(tok::l_square, tok::l_paren, tok::r_paren, tok::semi,
2234  tok::comma, tok::equal, tok::kw_asm, tok::l_brace,
2235  tok::colon);
2236 }
2237 
2238 /// ParseImplicitInt - This method is called when we have an non-typename
2239 /// identifier in a declspec (which normally terminates the decl spec) when
2240 /// the declspec has no type specifier. In this case, the declspec is either
2241 /// malformed or is "implicit int" (in K&R and C89).
2242 ///
2243 /// This method handles diagnosing this prettily and returns false if the
2244 /// declspec is done being processed. If it recovers and thinks there may be
2245 /// other pieces of declspec after it, it returns true.
2246 ///
2247 bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
2248  const ParsedTemplateInfo &TemplateInfo,
2249  AccessSpecifier AS, DeclSpecContext DSC,
2250  ParsedAttributesWithRange &Attrs) {
2251  assert(Tok.is(tok::identifier) && "should have identifier");
2252 
2253  SourceLocation Loc = Tok.getLocation();
2254  // If we see an identifier that is not a type name, we normally would
2255  // parse it as the identifer being declared. However, when a typename
2256  // is typo'd or the definition is not included, this will incorrectly
2257  // parse the typename as the identifier name and fall over misparsing
2258  // later parts of the diagnostic.
2259  //
2260  // As such, we try to do some look-ahead in cases where this would
2261  // otherwise be an "implicit-int" case to see if this is invalid. For
2262  // example: "static foo_t x = 4;" In this case, if we parsed foo_t as
2263  // an identifier with implicit int, we'd get a parse error because the
2264  // next token is obviously invalid for a type. Parse these as a case
2265  // with an invalid type specifier.
2266  assert(!DS.hasTypeSpecifier() && "Type specifier checked above");
2267 
2268  // Since we know that this either implicit int (which is rare) or an
2269  // error, do lookahead to try to do better recovery. This never applies
2270  // within a type specifier. Outside of C++, we allow this even if the
2271  // language doesn't "officially" support implicit int -- we support
2272  // implicit int as an extension in C99 and C11.
2273  if (!isTypeSpecifier(DSC) && !getLangOpts().CPlusPlus &&
2275  // If this token is valid for implicit int, e.g. "static x = 4", then
2276  // we just avoid eating the identifier, so it will be parsed as the
2277  // identifier in the declarator.
2278  return false;
2279  }
2280 
2281  if (getLangOpts().CPlusPlus &&
2283  // Don't require a type specifier if we have the 'auto' storage class
2284  // specifier in C++98 -- we'll promote it to a type specifier.
2285  if (SS)
2286  AnnotateScopeToken(*SS, /*IsNewAnnotation*/false);
2287  return false;
2288  }
2289 
2290  if (getLangOpts().CPlusPlus && (!SS || SS->isEmpty()) &&
2291  getLangOpts().MSVCCompat) {
2292  // Lookup of an unqualified type name has failed in MSVC compatibility mode.
2293  // Give Sema a chance to recover if we are in a template with dependent base
2294  // classes.
2295  if (ParsedType T = Actions.ActOnMSVCUnknownTypeName(
2296  *Tok.getIdentifierInfo(), Tok.getLocation(),
2297  DSC == DSC_template_type_arg)) {
2298  const char *PrevSpec;
2299  unsigned DiagID;
2300  DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T,
2301  Actions.getASTContext().getPrintingPolicy());
2302  DS.SetRangeEnd(Tok.getLocation());
2303  ConsumeToken();
2304  return false;
2305  }
2306  }
2307 
2308  // Otherwise, if we don't consume this token, we are going to emit an
2309  // error anyway. Try to recover from various common problems. Check
2310  // to see if this was a reference to a tag name without a tag specified.
2311  // This is a common problem in C (saying 'foo' instead of 'struct foo').
2312  //
2313  // C++ doesn't need this, and isTagName doesn't take SS.
2314  if (SS == nullptr) {
2315  const char *TagName = nullptr, *FixitTagName = nullptr;
2316  tok::TokenKind TagKind = tok::unknown;
2317 
2318  switch (Actions.isTagName(*Tok.getIdentifierInfo(), getCurScope())) {
2319  default: break;
2320  case DeclSpec::TST_enum:
2321  TagName="enum" ; FixitTagName = "enum " ; TagKind=tok::kw_enum ;break;
2322  case DeclSpec::TST_union:
2323  TagName="union" ; FixitTagName = "union " ;TagKind=tok::kw_union ;break;
2324  case DeclSpec::TST_struct:
2325  TagName="struct"; FixitTagName = "struct ";TagKind=tok::kw_struct;break;
2327  TagName="__interface"; FixitTagName = "__interface ";
2328  TagKind=tok::kw___interface;break;
2329  case DeclSpec::TST_class:
2330  TagName="class" ; FixitTagName = "class " ;TagKind=tok::kw_class ;break;
2331  }
2332 
2333  if (TagName) {
2334  IdentifierInfo *TokenName = Tok.getIdentifierInfo();
2335  LookupResult R(Actions, TokenName, SourceLocation(),
2337 
2338  Diag(Loc, diag::err_use_of_tag_name_without_tag)
2339  << TokenName << TagName << getLangOpts().CPlusPlus
2340  << FixItHint::CreateInsertion(Tok.getLocation(), FixitTagName);
2341 
2342  if (Actions.LookupParsedName(R, getCurScope(), SS)) {
2343  for (LookupResult::iterator I = R.begin(), IEnd = R.end();
2344  I != IEnd; ++I)
2345  Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
2346  << TokenName << TagName;
2347  }
2348 
2349  // Parse this as a tag as if the missing tag were present.
2350  if (TagKind == tok::kw_enum)
2351  ParseEnumSpecifier(Loc, DS, TemplateInfo, AS, DSC_normal);
2352  else
2353  ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS,
2354  /*EnteringContext*/ false, DSC_normal, Attrs);
2355  return true;
2356  }
2357  }
2358 
2359  // Determine whether this identifier could plausibly be the name of something
2360  // being declared (with a missing type).
2361  if (!isTypeSpecifier(DSC) &&
2362  (!SS || DSC == DSC_top_level || DSC == DSC_class)) {
2363  // Look ahead to the next token to try to figure out what this declaration
2364  // was supposed to be.
2365  switch (NextToken().getKind()) {
2366  case tok::l_paren: {
2367  // static x(4); // 'x' is not a type
2368  // x(int n); // 'x' is not a type
2369  // x (*p)[]; // 'x' is a type
2370  //
2371  // Since we're in an error case, we can afford to perform a tentative
2372  // parse to determine which case we're in.
2373  TentativeParsingAction PA(*this);
2374  ConsumeToken();
2375  TPResult TPR = TryParseDeclarator(/*mayBeAbstract*/false);
2376  PA.Revert();
2377 
2378  if (TPR != TPResult::False) {
2379  // The identifier is followed by a parenthesized declarator.
2380  // It's supposed to be a type.
2381  break;
2382  }
2383 
2384  // If we're in a context where we could be declaring a constructor,
2385  // check whether this is a constructor declaration with a bogus name.
2386  if (DSC == DSC_class || (DSC == DSC_top_level && SS)) {
2387  IdentifierInfo *II = Tok.getIdentifierInfo();
2388  if (Actions.isCurrentClassNameTypo(II, SS)) {
2389  Diag(Loc, diag::err_constructor_bad_name)
2390  << Tok.getIdentifierInfo() << II
2392  Tok.setIdentifierInfo(II);
2393  }
2394  }
2395  // Fall through.
2396  }
2397  case tok::comma:
2398  case tok::equal:
2399  case tok::kw_asm:
2400  case tok::l_brace:
2401  case tok::l_square:
2402  case tok::semi:
2403  // This looks like a variable or function declaration. The type is
2404  // probably missing. We're done parsing decl-specifiers.
2405  if (SS)
2406  AnnotateScopeToken(*SS, /*IsNewAnnotation*/false);
2407  return false;
2408 
2409  default:
2410  // This is probably supposed to be a type. This includes cases like:
2411  // int f(itn);
2412  // struct S { unsinged : 4; };
2413  break;
2414  }
2415  }
2416 
2417  // This is almost certainly an invalid type name. Let Sema emit a diagnostic
2418  // and attempt to recover.
2419  ParsedType T;
2420  IdentifierInfo *II = Tok.getIdentifierInfo();
2421  Actions.DiagnoseUnknownTypeName(II, Loc, getCurScope(), SS, T,
2422  getLangOpts().CPlusPlus &&
2423  NextToken().is(tok::less));
2424  if (T) {
2425  // The action has suggested that the type T could be used. Set that as
2426  // the type in the declaration specifiers, consume the would-be type
2427  // name token, and we're done.
2428  const char *PrevSpec;
2429  unsigned DiagID;
2430  DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T,
2431  Actions.getASTContext().getPrintingPolicy());
2432  DS.SetRangeEnd(Tok.getLocation());
2433  ConsumeToken();
2434  // There may be other declaration specifiers after this.
2435  return true;
2436  } else if (II != Tok.getIdentifierInfo()) {
2437  // If no type was suggested, the correction is to a keyword
2438  Tok.setKind(II->getTokenID());
2439  // There may be other declaration specifiers after this.
2440  return true;
2441  }
2442 
2443  // Otherwise, the action had no suggestion for us. Mark this as an error.
2444  DS.SetTypeSpecError();
2445  DS.SetRangeEnd(Tok.getLocation());
2446  ConsumeToken();
2447 
2448  // TODO: Could inject an invalid typedef decl in an enclosing scope to
2449  // avoid rippling error messages on subsequent uses of the same type,
2450  // could be useful if #include was forgotten.
2451  return false;
2452 }
2453 
2454 /// \brief Determine the declaration specifier context from the declarator
2455 /// context.
2456 ///
2457 /// \param Context the declarator context, which is one of the
2458 /// Declarator::TheContext enumerator values.
2459 Parser::DeclSpecContext
2460 Parser::getDeclSpecContextFromDeclaratorContext(unsigned Context) {
2461  if (Context == Declarator::MemberContext)
2462  return DSC_class;
2463  if (Context == Declarator::FileContext)
2464  return DSC_top_level;
2465  if (Context == Declarator::TemplateTypeArgContext)
2466  return DSC_template_type_arg;
2467  if (Context == Declarator::TrailingReturnContext)
2468  return DSC_trailing;
2469  if (Context == Declarator::AliasDeclContext ||
2471  return DSC_alias_declaration;
2472  return DSC_normal;
2473 }
2474 
2475 /// ParseAlignArgument - Parse the argument to an alignment-specifier.
2476 ///
2477 /// FIXME: Simply returns an alignof() expression if the argument is a
2478 /// type. Ideally, the type should be propagated directly into Sema.
2479 ///
2480 /// [C11] type-id
2481 /// [C11] constant-expression
2482 /// [C++0x] type-id ...[opt]
2483 /// [C++0x] assignment-expression ...[opt]
2484 ExprResult Parser::ParseAlignArgument(SourceLocation Start,
2485  SourceLocation &EllipsisLoc) {
2486  ExprResult ER;
2487  if (isTypeIdInParens()) {
2489  ParsedType Ty = ParseTypeName().get();
2490  SourceRange TypeRange(Start, Tok.getLocation());
2491  ER = Actions.ActOnUnaryExprOrTypeTraitExpr(TypeLoc, UETT_AlignOf, true,
2492  Ty.getAsOpaquePtr(), TypeRange);
2493  } else
2494  ER = ParseConstantExpression();
2495 
2496  if (getLangOpts().CPlusPlus11)
2497  TryConsumeToken(tok::ellipsis, EllipsisLoc);
2498 
2499  return ER;
2500 }
2501 
2502 /// ParseAlignmentSpecifier - Parse an alignment-specifier, and add the
2503 /// attribute to Attrs.
2504 ///
2505 /// alignment-specifier:
2506 /// [C11] '_Alignas' '(' type-id ')'
2507 /// [C11] '_Alignas' '(' constant-expression ')'
2508 /// [C++11] 'alignas' '(' type-id ...[opt] ')'
2509 /// [C++11] 'alignas' '(' assignment-expression ...[opt] ')'
2510 void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs,
2511  SourceLocation *EndLoc) {
2512  assert(Tok.isOneOf(tok::kw_alignas, tok::kw__Alignas) &&
2513  "Not an alignment-specifier!");
2514 
2515  IdentifierInfo *KWName = Tok.getIdentifierInfo();
2516  SourceLocation KWLoc = ConsumeToken();
2517 
2518  BalancedDelimiterTracker T(*this, tok::l_paren);
2519  if (T.expectAndConsume())
2520  return;
2521 
2522  SourceLocation EllipsisLoc;
2523  ExprResult ArgExpr = ParseAlignArgument(T.getOpenLocation(), EllipsisLoc);
2524  if (ArgExpr.isInvalid()) {
2525  T.skipToEnd();
2526  return;
2527  }
2528 
2529  T.consumeClose();
2530  if (EndLoc)
2531  *EndLoc = T.getCloseLocation();
2532 
2533  ArgsVector ArgExprs;
2534  ArgExprs.push_back(ArgExpr.get());
2535  Attrs.addNew(KWName, KWLoc, nullptr, KWLoc, ArgExprs.data(), 1,
2536  AttributeList::AS_Keyword, EllipsisLoc);
2537 }
2538 
2539 /// Determine whether we're looking at something that might be a declarator
2540 /// in a simple-declaration. If it can't possibly be a declarator, maybe
2541 /// diagnose a missing semicolon after a prior tag definition in the decl
2542 /// specifier.
2543 ///
2544 /// \return \c true if an error occurred and this can't be any kind of
2545 /// declaration.
2546 bool
2547 Parser::DiagnoseMissingSemiAfterTagDefinition(DeclSpec &DS, AccessSpecifier AS,
2548  DeclSpecContext DSContext,
2549  LateParsedAttrList *LateAttrs) {
2550  assert(DS.hasTagDefinition() && "shouldn't call this");
2551 
2552  bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level);
2553 
2554  if (getLangOpts().CPlusPlus &&
2555  Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_decltype,
2556  tok::annot_template_id) &&
2557  TryAnnotateCXXScopeToken(EnteringContext)) {
2559  return true;
2560  }
2561 
2562  bool HasScope = Tok.is(tok::annot_cxxscope);
2563  // Make a copy in case GetLookAheadToken invalidates the result of NextToken.
2564  Token AfterScope = HasScope ? NextToken() : Tok;
2565 
2566  // Determine whether the following tokens could possibly be a
2567  // declarator.
2568  bool MightBeDeclarator = true;
2569  if (Tok.isOneOf(tok::kw_typename, tok::annot_typename)) {
2570  // A declarator-id can't start with 'typename'.
2571  MightBeDeclarator = false;
2572  } else if (AfterScope.is(tok::annot_template_id)) {
2573  // If we have a type expressed as a template-id, this cannot be a
2574  // declarator-id (such a type cannot be redeclared in a simple-declaration).
2575  TemplateIdAnnotation *Annot =
2576  static_cast<TemplateIdAnnotation *>(AfterScope.getAnnotationValue());
2577  if (Annot->Kind == TNK_Type_template)
2578  MightBeDeclarator = false;
2579  } else if (AfterScope.is(tok::identifier)) {
2580  const Token &Next = HasScope ? GetLookAheadToken(2) : NextToken();
2581 
2582  // These tokens cannot come after the declarator-id in a
2583  // simple-declaration, and are likely to come after a type-specifier.
2584  if (Next.isOneOf(tok::star, tok::amp, tok::ampamp, tok::identifier,
2585  tok::annot_cxxscope, tok::coloncolon)) {
2586  // Missing a semicolon.
2587  MightBeDeclarator = false;
2588  } else if (HasScope) {
2589  // If the declarator-id has a scope specifier, it must redeclare a
2590  // previously-declared entity. If that's a type (and this is not a
2591  // typedef), that's an error.
2592  CXXScopeSpec SS;
2594  Tok.getAnnotationValue(), Tok.getAnnotationRange(), SS);
2595  IdentifierInfo *Name = AfterScope.getIdentifierInfo();
2596  Sema::NameClassification Classification = Actions.ClassifyName(
2597  getCurScope(), SS, Name, AfterScope.getLocation(), Next,
2598  /*IsAddressOfOperand*/false);
2599  switch (Classification.getKind()) {
2600  case Sema::NC_Error:
2602  return true;
2603 
2604  case Sema::NC_Keyword:
2606  llvm_unreachable("typo correction and nested name specifiers not "
2607  "possible here");
2608 
2609  case Sema::NC_Type:
2610  case Sema::NC_TypeTemplate:
2611  // Not a previously-declared non-type entity.
2612  MightBeDeclarator = false;
2613  break;
2614 
2615  case Sema::NC_Unknown:
2616  case Sema::NC_Expression:
2617  case Sema::NC_VarTemplate:
2619  // Might be a redeclaration of a prior entity.
2620  break;
2621  }
2622  }
2623  }
2624 
2625  if (MightBeDeclarator)
2626  return false;
2627 
2628  const PrintingPolicy &PPol = Actions.getASTContext().getPrintingPolicy();
2629  Diag(PP.getLocForEndOfToken(DS.getRepAsDecl()->getLocEnd()),
2630  diag::err_expected_after)
2631  << DeclSpec::getSpecifierName(DS.getTypeSpecType(), PPol) << tok::semi;
2632 
2633  // Try to recover from the typo, by dropping the tag definition and parsing
2634  // the problematic tokens as a type.
2635  //
2636  // FIXME: Split the DeclSpec into pieces for the standalone
2637  // declaration and pieces for the following declaration, instead
2638  // of assuming that all the other pieces attach to new declaration,
2639  // and call ParsedFreeStandingDeclSpec as appropriate.
2640  DS.ClearTypeSpecType();
2641  ParsedTemplateInfo NotATemplate;
2642  ParseDeclarationSpecifiers(DS, NotATemplate, AS, DSContext, LateAttrs);
2643  return false;
2644 }
2645 
2646 /// ParseDeclarationSpecifiers
2647 /// declaration-specifiers: [C99 6.7]
2648 /// storage-class-specifier declaration-specifiers[opt]
2649 /// type-specifier declaration-specifiers[opt]
2650 /// [C99] function-specifier declaration-specifiers[opt]
2651 /// [C11] alignment-specifier declaration-specifiers[opt]
2652 /// [GNU] attributes declaration-specifiers[opt]
2653 /// [Clang] '__module_private__' declaration-specifiers[opt]
2654 /// [ObjC1] '__kindof' declaration-specifiers[opt]
2655 ///
2656 /// storage-class-specifier: [C99 6.7.1]
2657 /// 'typedef'
2658 /// 'extern'
2659 /// 'static'
2660 /// 'auto'
2661 /// 'register'
2662 /// [C++] 'mutable'
2663 /// [C++11] 'thread_local'
2664 /// [C11] '_Thread_local'
2665 /// [GNU] '__thread'
2666 /// function-specifier: [C99 6.7.4]
2667 /// [C99] 'inline'
2668 /// [C++] 'virtual'
2669 /// [C++] 'explicit'
2670 /// [OpenCL] '__kernel'
2671 /// 'friend': [C++ dcl.friend]
2672 /// 'constexpr': [C++0x dcl.constexpr]
2673 void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
2674  const ParsedTemplateInfo &TemplateInfo,
2675  AccessSpecifier AS,
2676  DeclSpecContext DSContext,
2677  LateParsedAttrList *LateAttrs) {
2678  if (DS.getSourceRange().isInvalid()) {
2679  // Start the range at the current token but make the end of the range
2680  // invalid. This will make the entire range invalid unless we successfully
2681  // consume a token.
2682  DS.SetRangeStart(Tok.getLocation());
2684  }
2685 
2686  bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level);
2687  bool AttrsLastTime = false;
2688  ParsedAttributesWithRange attrs(AttrFactory);
2689  // We use Sema's policy to get bool macros right.
2690  PrintingPolicy Policy = Actions.getPrintingPolicy();
2691  while (1) {
2692  bool isInvalid = false;
2693  bool isStorageClass = false;
2694  const char *PrevSpec = nullptr;
2695  unsigned DiagID = 0;
2696 
2697  // HACK: MSVC doesn't consider _Atomic to be a keyword and its STL
2698  // implementation for VS2013 uses _Atomic as an identifier for one of the
2699  // classes in <atomic>.
2700  //
2701  // A typedef declaration containing _Atomic<...> is among the places where
2702  // the class is used. If we are currently parsing such a declaration, treat
2703  // the token as an identifier.
2704  if (getLangOpts().MSVCCompat && Tok.is(tok::kw__Atomic) &&
2706  !DS.hasTypeSpecifier() && GetLookAheadToken(1).is(tok::less))
2707  Tok.setKind(tok::identifier);
2708 
2709  SourceLocation Loc = Tok.getLocation();
2710 
2711  switch (Tok.getKind()) {
2712  default:
2713  DoneWithDeclSpec:
2714  if (!AttrsLastTime)
2715  ProhibitAttributes(attrs);
2716  else {
2717  // Reject C++11 attributes that appertain to decl specifiers as
2718  // we don't support any C++11 attributes that appertain to decl
2719  // specifiers. This also conforms to what g++ 4.8 is doing.
2720  ProhibitCXX11Attributes(attrs);
2721 
2722  DS.takeAttributesFrom(attrs);
2723  }
2724 
2725  // If this is not a declaration specifier token, we're done reading decl
2726  // specifiers. First verify that DeclSpec's are consistent.
2727  DS.Finish(Actions, Policy);
2728  return;
2729 
2730  case tok::l_square:
2731  case tok::kw_alignas:
2732  if (!getLangOpts().CPlusPlus11 || !isCXX11AttributeSpecifier())
2733  goto DoneWithDeclSpec;
2734 
2735  ProhibitAttributes(attrs);
2736  // FIXME: It would be good to recover by accepting the attributes,
2737  // but attempting to do that now would cause serious
2738  // madness in terms of diagnostics.
2739  attrs.clear();
2740  attrs.Range = SourceRange();
2741 
2742  ParseCXX11Attributes(attrs);
2743  AttrsLastTime = true;
2744  continue;
2745 
2746  case tok::code_completion: {
2748  if (DS.hasTypeSpecifier()) {
2749  bool AllowNonIdentifiers
2754  Scope::AtCatchScope)) == 0;
2755  bool AllowNestedNameSpecifiers
2756  = DSContext == DSC_top_level ||
2757  (DSContext == DSC_class && DS.isFriendSpecified());
2758 
2759  Actions.CodeCompleteDeclSpec(getCurScope(), DS,
2760  AllowNonIdentifiers,
2761  AllowNestedNameSpecifiers);
2762  return cutOffParsing();
2763  }
2764 
2765  if (getCurScope()->getFnParent() || getCurScope()->getBlockParent())
2767  else if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate)
2768  CCC = DSContext == DSC_class? Sema::PCC_MemberTemplate
2770  else if (DSContext == DSC_class)
2771  CCC = Sema::PCC_Class;
2772  else if (CurParsedObjCImpl)
2774 
2775  Actions.CodeCompleteOrdinaryName(getCurScope(), CCC);
2776  return cutOffParsing();
2777  }
2778 
2779  case tok::coloncolon: // ::foo::bar
2780  // C++ scope specifier. Annotate and loop, or bail out on error.
2781  if (TryAnnotateCXXScopeToken(EnteringContext)) {
2782  if (!DS.hasTypeSpecifier())
2783  DS.SetTypeSpecError();
2784  goto DoneWithDeclSpec;
2785  }
2786  if (Tok.is(tok::coloncolon)) // ::new or ::delete
2787  goto DoneWithDeclSpec;
2788  continue;
2789 
2790  case tok::annot_cxxscope: {
2791  if (DS.hasTypeSpecifier() || DS.isTypeAltiVecVector())
2792  goto DoneWithDeclSpec;
2793 
2794  CXXScopeSpec SS;
2796  Tok.getAnnotationRange(),
2797  SS);
2798 
2799  // We are looking for a qualified typename.
2800  Token Next = NextToken();
2801  if (Next.is(tok::annot_template_id) &&
2802  static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue())
2803  ->Kind == TNK_Type_template) {
2804  // We have a qualified template-id, e.g., N::A<int>
2805 
2806  // C++ [class.qual]p2:
2807  // In a lookup in which the constructor is an acceptable lookup
2808  // result and the nested-name-specifier nominates a class C:
2809  //
2810  // - if the name specified after the
2811  // nested-name-specifier, when looked up in C, is the
2812  // injected-class-name of C (Clause 9), or
2813  //
2814  // - if the name specified after the nested-name-specifier
2815  // is the same as the identifier or the
2816  // simple-template-id's template-name in the last
2817  // component of the nested-name-specifier,
2818  //
2819  // the name is instead considered to name the constructor of
2820  // class C.
2821  //
2822  // Thus, if the template-name is actually the constructor
2823  // name, then the code is ill-formed; this interpretation is
2824  // reinforced by the NAD status of core issue 635.
2825  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Next);
2826  if ((DSContext == DSC_top_level || DSContext == DSC_class) &&
2827  TemplateId->Name &&
2828  Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
2829  if (isConstructorDeclarator(/*Unqualified*/false)) {
2830  // The user meant this to be an out-of-line constructor
2831  // definition, but template arguments are not allowed
2832  // there. Just allow this as a constructor; we'll
2833  // complain about it later.
2834  goto DoneWithDeclSpec;
2835  }
2836 
2837  // The user meant this to name a type, but it actually names
2838  // a constructor with some extraneous template
2839  // arguments. Complain, then parse it as a type as the user
2840  // intended.
2841  Diag(TemplateId->TemplateNameLoc,
2842  diag::err_out_of_line_template_id_type_names_constructor)
2843  << TemplateId->Name << 0 /* template name */;
2844  }
2845 
2846  DS.getTypeSpecScope() = SS;
2847  ConsumeToken(); // The C++ scope.
2848  assert(Tok.is(tok::annot_template_id) &&
2849  "ParseOptionalCXXScopeSpecifier not working");
2850  AnnotateTemplateIdTokenAsType();
2851  continue;
2852  }
2853 
2854  if (Next.is(tok::annot_typename)) {
2855  DS.getTypeSpecScope() = SS;
2856  ConsumeToken(); // The C++ scope.
2857  if (Tok.getAnnotationValue()) {
2858  ParsedType T = getTypeAnnotation(Tok);
2859  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename,
2860  Tok.getAnnotationEndLoc(),
2861  PrevSpec, DiagID, T, Policy);
2862  if (isInvalid)
2863  break;
2864  }
2865  else
2866  DS.SetTypeSpecError();
2867  DS.SetRangeEnd(Tok.getAnnotationEndLoc());
2868  ConsumeToken(); // The typename
2869  }
2870 
2871  if (Next.isNot(tok::identifier))
2872  goto DoneWithDeclSpec;
2873 
2874  // If we're in a context where the identifier could be a class name,
2875  // check whether this is a constructor declaration.
2876  if ((DSContext == DSC_top_level || DSContext == DSC_class) &&
2878  &SS)) {
2879  if (isConstructorDeclarator(/*Unqualified*/false))
2880  goto DoneWithDeclSpec;
2881 
2882  // As noted in C++ [class.qual]p2 (cited above), when the name
2883  // of the class is qualified in a context where it could name
2884  // a constructor, its a constructor name. However, we've
2885  // looked at the declarator, and the user probably meant this
2886  // to be a type. Complain that it isn't supposed to be treated
2887  // as a type, then proceed to parse it as a type.
2888  Diag(Next.getLocation(),
2889  diag::err_out_of_line_template_id_type_names_constructor)
2890  << Next.getIdentifierInfo() << 1 /* type */;
2891  }
2892 
2893  ParsedType TypeRep =
2894  Actions.getTypeName(*Next.getIdentifierInfo(), Next.getLocation(),
2895  getCurScope(), &SS, false, false, nullptr,
2896  /*IsCtorOrDtorName=*/false,
2897  /*NonTrivialSourceInfo=*/true);
2898 
2899  // If the referenced identifier is not a type, then this declspec is
2900  // erroneous: We already checked about that it has no type specifier, and
2901  // C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the
2902  // typename.
2903  if (!TypeRep) {
2904  ConsumeToken(); // Eat the scope spec so the identifier is current.
2905  ParsedAttributesWithRange Attrs(AttrFactory);
2906  if (ParseImplicitInt(DS, &SS, TemplateInfo, AS, DSContext, Attrs)) {
2907  if (!Attrs.empty()) {
2908  AttrsLastTime = true;
2909  attrs.takeAllFrom(Attrs);
2910  }
2911  continue;
2912  }
2913  goto DoneWithDeclSpec;
2914  }
2915 
2916  DS.getTypeSpecScope() = SS;
2917  ConsumeToken(); // The C++ scope.
2918 
2919  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
2920  DiagID, TypeRep, Policy);
2921  if (isInvalid)
2922  break;
2923 
2924  DS.SetRangeEnd(Tok.getLocation());
2925  ConsumeToken(); // The typename.
2926 
2927  continue;
2928  }
2929 
2930  case tok::annot_typename: {
2931  // If we've previously seen a tag definition, we were almost surely
2932  // missing a semicolon after it.
2933  if (DS.hasTypeSpecifier() && DS.hasTagDefinition())
2934  goto DoneWithDeclSpec;
2935 
2936  if (Tok.getAnnotationValue()) {
2937  ParsedType T = getTypeAnnotation(Tok);
2938  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
2939  DiagID, T, Policy);
2940  } else
2941  DS.SetTypeSpecError();
2942 
2943  if (isInvalid)
2944  break;
2945 
2946  DS.SetRangeEnd(Tok.getAnnotationEndLoc());
2947  ConsumeToken(); // The typename
2948 
2949  continue;
2950  }
2951 
2952  case tok::kw___is_signed:
2953  // GNU libstdc++ 4.4 uses __is_signed as an identifier, but Clang
2954  // typically treats it as a trait. If we see __is_signed as it appears
2955  // in libstdc++, e.g.,
2956  //
2957  // static const bool __is_signed;
2958  //
2959  // then treat __is_signed as an identifier rather than as a keyword.
2960  if (DS.getTypeSpecType() == TST_bool &&
2963  TryKeywordIdentFallback(true);
2964 
2965  // We're done with the declaration-specifiers.
2966  goto DoneWithDeclSpec;
2967 
2968  // typedef-name
2969  case tok::kw___super:
2970  case tok::kw_decltype:
2971  case tok::identifier: {
2972  // This identifier can only be a typedef name if we haven't already seen
2973  // a type-specifier. Without this check we misparse:
2974  // typedef int X; struct Y { short X; }; as 'short int'.
2975  if (DS.hasTypeSpecifier())
2976  goto DoneWithDeclSpec;
2977 
2978  // In C++, check to see if this is a scope specifier like foo::bar::, if
2979  // so handle it as such. This is important for ctor parsing.
2980  if (getLangOpts().CPlusPlus) {
2981  if (TryAnnotateCXXScopeToken(EnteringContext)) {
2982  DS.SetTypeSpecError();
2983  goto DoneWithDeclSpec;
2984  }
2985  if (!Tok.is(tok::identifier))
2986  continue;
2987  }
2988 
2989  // Check for need to substitute AltiVec keyword tokens.
2990  if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid))
2991  break;
2992 
2993  // [AltiVec] 2.2: [If the 'vector' specifier is used] The syntax does not
2994  // allow the use of a typedef name as a type specifier.
2995  if (DS.isTypeAltiVecVector())
2996  goto DoneWithDeclSpec;
2997 
2998  if (DSContext == DSC_objc_method_result && isObjCInstancetype()) {
2999  ParsedType TypeRep = Actions.ActOnObjCInstanceType(Loc);
3000  assert(TypeRep);
3001  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
3002  DiagID, TypeRep, Policy);
3003  if (isInvalid)
3004  break;
3005 
3006  DS.SetRangeEnd(Loc);
3007  ConsumeToken();
3008  continue;
3009  }
3010 
3011  ParsedType TypeRep =
3012  Actions.getTypeName(*Tok.getIdentifierInfo(),
3013  Tok.getLocation(), getCurScope());
3014 
3015  // If this is not a typedef name, don't parse it as part of the declspec,
3016  // it must be an implicit int or an error.
3017  if (!TypeRep) {
3018  ParsedAttributesWithRange Attrs(AttrFactory);
3019  if (ParseImplicitInt(DS, nullptr, TemplateInfo, AS, DSContext, Attrs)) {
3020  if (!Attrs.empty()) {
3021  AttrsLastTime = true;
3022  attrs.takeAllFrom(Attrs);
3023  }
3024  continue;
3025  }
3026  goto DoneWithDeclSpec;
3027  }
3028 
3029  // If we're in a context where the identifier could be a class name,
3030  // check whether this is a constructor declaration.
3031  if (getLangOpts().CPlusPlus && DSContext == DSC_class &&
3032  Actions.isCurrentClassName(*Tok.getIdentifierInfo(), getCurScope()) &&
3033  isConstructorDeclarator(/*Unqualified*/true))
3034  goto DoneWithDeclSpec;
3035 
3036  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
3037  DiagID, TypeRep, Policy);
3038  if (isInvalid)
3039  break;
3040 
3041  DS.SetRangeEnd(Tok.getLocation());
3042  ConsumeToken(); // The identifier
3043 
3044  // Objective-C supports type arguments and protocol references
3045  // following an Objective-C object or object pointer
3046  // type. Handle either one of them.
3047  if (Tok.is(tok::less) && getLangOpts().ObjC1) {
3048  SourceLocation NewEndLoc;
3049  TypeResult NewTypeRep = parseObjCTypeArgsAndProtocolQualifiers(
3050  Loc, TypeRep, /*consumeLastToken=*/true,
3051  NewEndLoc);
3052  if (NewTypeRep.isUsable()) {
3053  DS.UpdateTypeRep(NewTypeRep.get());
3054  DS.SetRangeEnd(NewEndLoc);
3055  }
3056  }
3057 
3058  // Need to support trailing type qualifiers (e.g. "id<p> const").
3059  // If a type specifier follows, it will be diagnosed elsewhere.
3060  continue;
3061  }
3062 
3063  // type-name
3064  case tok::annot_template_id: {
3065  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
3066  if (TemplateId->Kind != TNK_Type_template) {
3067  // This template-id does not refer to a type name, so we're
3068  // done with the type-specifiers.
3069  goto DoneWithDeclSpec;
3070  }
3071 
3072  // If we're in a context where the template-id could be a
3073  // constructor name or specialization, check whether this is a
3074  // constructor declaration.
3075  if (getLangOpts().CPlusPlus && DSContext == DSC_class &&
3076  Actions.isCurrentClassName(*TemplateId->Name, getCurScope()) &&
3077  isConstructorDeclarator(TemplateId->SS.isEmpty()))
3078  goto DoneWithDeclSpec;
3079 
3080  // Turn the template-id annotation token into a type annotation
3081  // token, then try again to parse it as a type-specifier.
3082  AnnotateTemplateIdTokenAsType();
3083  continue;
3084  }
3085 
3086  // GNU attributes support.
3087  case tok::kw___attribute:
3088  ParseGNUAttributes(DS.getAttributes(), nullptr, LateAttrs);
3089  continue;
3090 
3091  // Microsoft declspec support.
3092  case tok::kw___declspec:
3093  ParseMicrosoftDeclSpecs(DS.getAttributes());
3094  continue;
3095 
3096  // Microsoft single token adornments.
3097  case tok::kw___forceinline: {
3098  isInvalid = DS.setFunctionSpecForceInline(Loc, PrevSpec, DiagID);
3099  IdentifierInfo *AttrName = Tok.getIdentifierInfo();
3100  SourceLocation AttrNameLoc = Tok.getLocation();
3101  DS.getAttributes().addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc,
3102  nullptr, 0, AttributeList::AS_Keyword);
3103  break;
3104  }
3105 
3106  case tok::kw___unaligned:
3107  isInvalid = DS.SetTypeQual(DeclSpec::TQ_unaligned, Loc, PrevSpec, DiagID,
3108  getLangOpts());
3109  break;
3110 
3111  case tok::kw___sptr:
3112  case tok::kw___uptr:
3113  case tok::kw___ptr64:
3114  case tok::kw___ptr32:
3115  case tok::kw___w64:
3116  case tok::kw___cdecl:
3117  case tok::kw___stdcall:
3118  case tok::kw___fastcall:
3119  case tok::kw___thiscall:
3120  case tok::kw___vectorcall:
3121  ParseMicrosoftTypeAttributes(DS.getAttributes());
3122  continue;
3123 
3124  // Borland single token adornments.
3125  case tok::kw___pascal:
3126  ParseBorlandTypeAttributes(DS.getAttributes());
3127  continue;
3128 
3129  // OpenCL single token adornments.
3130  case tok::kw___kernel:
3131  ParseOpenCLKernelAttributes(DS.getAttributes());
3132  continue;
3133 
3134  // Nullability type specifiers.
3135  case tok::kw__Nonnull:
3136  case tok::kw__Nullable:
3137  case tok::kw__Null_unspecified:
3138  ParseNullabilityTypeSpecifiers(DS.getAttributes());
3139  continue;
3140 
3141  // Objective-C 'kindof' types.
3142  case tok::kw___kindof:
3143  DS.getAttributes().addNew(Tok.getIdentifierInfo(), Loc, nullptr, Loc,
3144  nullptr, 0, AttributeList::AS_Keyword);
3145  (void)ConsumeToken();
3146  continue;
3147 
3148  // storage-class-specifier
3149  case tok::kw_typedef:
3150  isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc,
3151  PrevSpec, DiagID, Policy);
3152  isStorageClass = true;
3153  break;
3154  case tok::kw_extern:
3156  Diag(Tok, diag::ext_thread_before) << "extern";
3157  isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_extern, Loc,
3158  PrevSpec, DiagID, Policy);
3159  isStorageClass = true;
3160  break;
3161  case tok::kw___private_extern__:
3162  isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_private_extern,
3163  Loc, PrevSpec, DiagID, Policy);
3164  isStorageClass = true;
3165  break;
3166  case tok::kw_static:
3168  Diag(Tok, diag::ext_thread_before) << "static";
3169  isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_static, Loc,
3170  PrevSpec, DiagID, Policy);
3171  isStorageClass = true;
3172  break;
3173  case tok::kw_auto:
3174  if (getLangOpts().CPlusPlus11) {
3175  if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) {
3176  isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
3177  PrevSpec, DiagID, Policy);
3178  if (!isInvalid)
3179  Diag(Tok, diag::ext_auto_storage_class)
3181  } else
3182  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec,
3183  DiagID, Policy);
3184  } else
3185  isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
3186  PrevSpec, DiagID, Policy);
3187  isStorageClass = true;
3188  break;
3189  case tok::kw___auto_type:
3190  Diag(Tok, diag::ext_auto_type);
3191  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto_type, Loc, PrevSpec,
3192  DiagID, Policy);
3193  break;
3194  case tok::kw_register:
3195  isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_register, Loc,
3196  PrevSpec, DiagID, Policy);
3197  isStorageClass = true;
3198  break;
3199  case tok::kw_mutable:
3200  isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_mutable, Loc,
3201  PrevSpec, DiagID, Policy);
3202  isStorageClass = true;
3203  break;
3204  case tok::kw___thread:
3206  PrevSpec, DiagID);
3207  isStorageClass = true;
3208  break;
3209  case tok::kw_thread_local:
3211  PrevSpec, DiagID);
3212  break;
3213  case tok::kw__Thread_local:
3215  Loc, PrevSpec, DiagID);
3216  isStorageClass = true;
3217  break;
3218 
3219  // function-specifier
3220  case tok::kw_inline:
3221  isInvalid = DS.setFunctionSpecInline(Loc, PrevSpec, DiagID);
3222  break;
3223  case tok::kw_virtual:
3224  isInvalid = DS.setFunctionSpecVirtual(Loc, PrevSpec, DiagID);
3225  break;
3226  case tok::kw_explicit:
3227  isInvalid = DS.setFunctionSpecExplicit(Loc, PrevSpec, DiagID);
3228  break;
3229  case tok::kw__Noreturn:
3230  if (!getLangOpts().C11)
3231  Diag(Loc, diag::ext_c11_noreturn);
3232  isInvalid = DS.setFunctionSpecNoreturn(Loc, PrevSpec, DiagID);
3233  break;
3234 
3235  // alignment-specifier
3236  case tok::kw__Alignas:
3237  if (!getLangOpts().C11)
3238  Diag(Tok, diag::ext_c11_alignment) << Tok.getName();
3239  ParseAlignmentSpecifier(DS.getAttributes());
3240  continue;
3241 
3242  // friend
3243  case tok::kw_friend:
3244  if (DSContext == DSC_class)
3245  isInvalid = DS.SetFriendSpec(Loc, PrevSpec, DiagID);
3246  else {
3247  PrevSpec = ""; // not actually used by the diagnostic
3248  DiagID = diag::err_friend_invalid_in_context;
3249  isInvalid = true;
3250  }
3251  break;
3252 
3253  // Modules
3254  case tok::kw___module_private__:
3255  isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID);
3256  break;
3257 
3258  // constexpr
3259  case tok::kw_constexpr:
3260  isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID);
3261  break;
3262 
3263  // concept
3264  case tok::kw_concept:
3265  isInvalid = DS.SetConceptSpec(Loc, PrevSpec, DiagID);
3266  break;
3267 
3268  // type-specifier
3269  case tok::kw_short:
3270  isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec,
3271  DiagID, Policy);
3272  break;
3273  case tok::kw_long:
3275  isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
3276  DiagID, Policy);
3277  else
3278  isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
3279  DiagID, Policy);
3280  break;
3281  case tok::kw___int64:
3282  isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
3283  DiagID, Policy);
3284  break;
3285  case tok::kw_signed:
3286  isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec,
3287  DiagID);
3288  break;
3289  case tok::kw_unsigned:
3290  isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec,
3291  DiagID);
3292  break;
3293  case tok::kw__Complex:
3294  isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec,
3295  DiagID);
3296  break;
3297  case tok::kw__Imaginary:
3298  isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec,
3299  DiagID);
3300  break;
3301  case tok::kw_void:
3302  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec,
3303  DiagID, Policy);
3304  break;
3305  case tok::kw_char:
3306  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec,
3307  DiagID, Policy);
3308  break;
3309  case tok::kw_int:
3310  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec,
3311  DiagID, Policy);
3312  break;
3313  case tok::kw___int128:
3314  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec,
3315  DiagID, Policy);
3316  break;
3317  case tok::kw_half:
3318  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec,
3319  DiagID, Policy);
3320  break;
3321  case tok::kw_float:
3322  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
3323  DiagID, Policy);
3324  break;
3325  case tok::kw_double:
3326  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
3327  DiagID, Policy);
3328  break;
3329  case tok::kw___float128:
3330  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec,
3331  DiagID, Policy);
3332  break;
3333  case tok::kw_wchar_t:
3334  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
3335  DiagID, Policy);
3336  break;
3337  case tok::kw_char16_t:
3338  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec,
3339  DiagID, Policy);
3340  break;
3341  case tok::kw_char32_t:
3342  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec,
3343  DiagID, Policy);
3344  break;
3345  case tok::kw_bool:
3346  case tok::kw__Bool:
3347  if (Tok.is(tok::kw_bool) &&
3350  PrevSpec = ""; // Not used by the diagnostic.
3351  DiagID = diag::err_bool_redeclaration;
3352  // For better error recovery.
3353  Tok.setKind(tok::identifier);
3354  isInvalid = true;
3355  } else {
3356  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec,
3357  DiagID, Policy);
3358  }
3359  break;
3360  case tok::kw__Decimal32:
3361  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
3362  DiagID, Policy);
3363  break;
3364  case tok::kw__Decimal64:
3365  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
3366  DiagID, Policy);
3367  break;
3368  case tok::kw__Decimal128:
3369  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
3370  DiagID, Policy);
3371  break;
3372  case tok::kw___vector:
3373  isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
3374  break;
3375  case tok::kw___pixel:
3376  isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID, Policy);
3377  break;
3378  case tok::kw___bool:
3379  isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID, Policy);
3380  break;
3381  case tok::kw_pipe:
3382  if (!getLangOpts().OpenCL || (getLangOpts().OpenCLVersion < 200)) {
3383  // OpenCL 2.0 defined this keyword. OpenCL 1.2 and earlier should
3384  // support the "pipe" word as identifier.
3386  goto DoneWithDeclSpec;
3387  }
3388  isInvalid = DS.SetTypePipe(true, Loc, PrevSpec, DiagID, Policy);
3389  break;
3390 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
3391  case tok::kw_##ImgType##_t: \
3392  isInvalid = DS.SetTypeSpecType(DeclSpec::TST_##ImgType##_t, Loc, PrevSpec, \
3393  DiagID, Policy); \
3394  break;
3395 #include "clang/Basic/OpenCLImageTypes.def"
3396  case tok::kw___unknown_anytype:
3397  isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc,
3398  PrevSpec, DiagID, Policy);
3399  break;
3400 
3401  // class-specifier:
3402  case tok::kw_class:
3403  case tok::kw_struct:
3404  case tok::kw___interface:
3405  case tok::kw_union: {
3406  tok::TokenKind Kind = Tok.getKind();
3407  ConsumeToken();
3408 
3409  // These are attributes following class specifiers.
3410  // To produce better diagnostic, we parse them when
3411  // parsing class specifier.
3412  ParsedAttributesWithRange Attributes(AttrFactory);
3413  ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS,
3414  EnteringContext, DSContext, Attributes);
3415 
3416  // If there are attributes following class specifier,
3417  // take them over and handle them here.
3418  if (!Attributes.empty()) {
3419  AttrsLastTime = true;
3420  attrs.takeAllFrom(Attributes);
3421  }
3422  continue;
3423  }
3424 
3425  // enum-specifier:
3426  case tok::kw_enum:
3427  ConsumeToken();
3428  ParseEnumSpecifier(Loc, DS, TemplateInfo, AS, DSContext);
3429  continue;
3430 
3431  // cv-qualifier:
3432  case tok::kw_const:
3433  isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID,
3434  getLangOpts());
3435  break;
3436  case tok::kw_volatile:
3437  isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
3438  getLangOpts());
3439  break;
3440  case tok::kw_restrict:
3441  isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
3442  getLangOpts());
3443  break;
3444 
3445  // C++ typename-specifier:
3446  case tok::kw_typename:
3448  DS.SetTypeSpecError();
3449  goto DoneWithDeclSpec;
3450  }
3451  if (!Tok.is(tok::kw_typename))
3452  continue;
3453  break;
3454 
3455  // GNU typeof support.
3456  case tok::kw_typeof:
3457  ParseTypeofSpecifier(DS);
3458  continue;
3459 
3460  case tok::annot_decltype:
3461  ParseDecltypeSpecifier(DS);
3462  continue;
3463 
3464  case tok::annot_pragma_pack:
3465  HandlePragmaPack();
3466  continue;
3467 
3468  case tok::annot_pragma_ms_pragma:
3469  HandlePragmaMSPragma();
3470  continue;
3471 
3472  case tok::annot_pragma_ms_vtordisp:
3473  HandlePragmaMSVtorDisp();
3474  continue;
3475 
3476  case tok::annot_pragma_ms_pointers_to_members:
3477  HandlePragmaMSPointersToMembers();
3478  continue;
3479 
3480  case tok::kw___underlying_type:
3481  ParseUnderlyingTypeSpecifier(DS);
3482  continue;
3483 
3484  case tok::kw__Atomic:
3485  // C11 6.7.2.4/4:
3486  // If the _Atomic keyword is immediately followed by a left parenthesis,
3487  // it is interpreted as a type specifier (with a type name), not as a
3488  // type qualifier.
3489  if (NextToken().is(tok::l_paren)) {
3490  ParseAtomicSpecifier(DS);
3491  continue;
3492  }
3493  isInvalid = DS.SetTypeQual(DeclSpec::TQ_atomic, Loc, PrevSpec, DiagID,
3494  getLangOpts());
3495  break;
3496 
3497  // OpenCL qualifiers:
3498  case tok::kw___generic:
3499  // generic address space is introduced only in OpenCL v2.0
3500  // see OpenCL C Spec v2.0 s6.5.5
3501  if (Actions.getLangOpts().OpenCLVersion < 200) {
3502  DiagID = diag::err_opencl_unknown_type_specifier;
3503  PrevSpec = Tok.getIdentifierInfo()->getNameStart();
3504  isInvalid = true;
3505  break;
3506  };
3507  case tok::kw___private:
3508  case tok::kw___global:
3509  case tok::kw___local:
3510  case tok::kw___constant:
3511  case tok::kw___read_only:
3512  case tok::kw___write_only:
3513  case tok::kw___read_write:
3514  ParseOpenCLQualifiers(DS.getAttributes());
3515  break;
3516 
3517  case tok::less:
3518  // GCC ObjC supports types like "<SomeProtocol>" as a synonym for
3519  // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous,
3520  // but we support it.
3521  if (DS.hasTypeSpecifier() || !getLangOpts().ObjC1)
3522  goto DoneWithDeclSpec;
3523 
3524  SourceLocation StartLoc = Tok.getLocation();
3525  SourceLocation EndLoc;
3526  TypeResult Type = parseObjCProtocolQualifierType(EndLoc);
3527  if (Type.isUsable()) {
3528  if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc, StartLoc,
3529  PrevSpec, DiagID, Type.get(),
3530  Actions.getASTContext().getPrintingPolicy()))
3531  Diag(StartLoc, DiagID) << PrevSpec;
3532 
3533  DS.SetRangeEnd(EndLoc);
3534  } else {
3535  DS.SetTypeSpecError();
3536  }
3537 
3538  // Need to support trailing type qualifiers (e.g. "id<p> const").
3539  // If a type specifier follows, it will be diagnosed elsewhere.
3540  continue;
3541  }
3542  // If the specifier wasn't legal, issue a diagnostic.
3543  if (isInvalid) {
3544  assert(PrevSpec && "Method did not return previous specifier!");
3545  assert(DiagID);
3546 
3547  if (DiagID == diag::ext_duplicate_declspec)
3548  Diag(Tok, DiagID)
3549  << PrevSpec << FixItHint::CreateRemoval(Tok.getLocation());
3550  else if (DiagID == diag::err_opencl_unknown_type_specifier) {
3551  const int OpenCLVer = getLangOpts().OpenCLVersion;
3552  std::string VerSpec = llvm::to_string(OpenCLVer / 100) +
3553  std::string (".") +
3554  llvm::to_string((OpenCLVer % 100) / 10);
3555  Diag(Tok, DiagID) << VerSpec << PrevSpec << isStorageClass;
3556  } else
3557  Diag(Tok, DiagID) << PrevSpec;
3558  }
3559 
3560  DS.SetRangeEnd(Tok.getLocation());
3561  if (DiagID != diag::err_bool_redeclaration)
3562  ConsumeToken();
3563 
3564  AttrsLastTime = false;
3565  }
3566 }
3567 
3568 /// ParseStructDeclaration - Parse a struct declaration without the terminating
3569 /// semicolon.
3570 ///
3571 /// struct-declaration:
3572 /// specifier-qualifier-list struct-declarator-list
3573 /// [GNU] __extension__ struct-declaration
3574 /// [GNU] specifier-qualifier-list
3575 /// struct-declarator-list:
3576 /// struct-declarator
3577 /// struct-declarator-list ',' struct-declarator
3578 /// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator
3579 /// struct-declarator:
3580 /// declarator
3581 /// [GNU] declarator attributes[opt]
3582 /// declarator[opt] ':' constant-expression
3583 /// [GNU] declarator[opt] ':' constant-expression attributes[opt]
3584 ///
3585 void Parser::ParseStructDeclaration(
3586  ParsingDeclSpec &DS,
3587  llvm::function_ref<void(ParsingFieldDeclarator &)> FieldsCallback) {
3588 
3589  if (Tok.is(tok::kw___extension__)) {
3590  // __extension__ silences extension warnings in the subexpression.
3591  ExtensionRAIIObject O(Diags); // Use RAII to do this.
3592  ConsumeToken();
3593  return ParseStructDeclaration(DS, FieldsCallback);
3594  }
3595 
3596  // Parse the common specifier-qualifiers-list piece.
3597  ParseSpecifierQualifierList(DS);
3598 
3599  // If there are no declarators, this is a free-standing declaration
3600  // specifier. Let the actions module cope with it.
3601  if (Tok.is(tok::semi)) {
3602  RecordDecl *AnonRecord = nullptr;
3603  Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
3604  DS, AnonRecord);
3605  assert(!AnonRecord && "Did not expect anonymous struct or union here");
3606  DS.complete(TheDecl);
3607  return;
3608  }
3609 
3610  // Read struct-declarators until we find the semicolon.
3611  bool FirstDeclarator = true;
3612  SourceLocation CommaLoc;
3613  while (1) {
3614  ParsingFieldDeclarator DeclaratorInfo(*this, DS);
3615  DeclaratorInfo.D.setCommaLoc(CommaLoc);
3616 
3617  // Attributes are only allowed here on successive declarators.
3618  if (!FirstDeclarator)
3619  MaybeParseGNUAttributes(DeclaratorInfo.D);
3620 
3621  /// struct-declarator: declarator
3622  /// struct-declarator: declarator[opt] ':' constant-expression
3623  if (Tok.isNot(tok::colon)) {
3624  // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
3626  ParseDeclarator(DeclaratorInfo.D);
3627  } else
3628  DeclaratorInfo.D.SetIdentifier(nullptr, Tok.getLocation());
3629 
3630  if (TryConsumeToken(tok::colon)) {
3632  if (Res.isInvalid())
3633  SkipUntil(tok::semi, StopBeforeMatch);
3634  else
3635  DeclaratorInfo.BitfieldSize = Res.get();
3636  }
3637 
3638  // If attributes exist after the declarator, parse them.
3639  MaybeParseGNUAttributes(DeclaratorInfo.D);
3640 
3641  // We're done with this declarator; invoke the callback.
3642  FieldsCallback(DeclaratorInfo);
3643 
3644  // If we don't have a comma, it is either the end of the list (a ';')
3645  // or an error, bail out.
3646  if (!TryConsumeToken(tok::comma, CommaLoc))
3647  return;
3648 
3649  FirstDeclarator = false;
3650  }
3651 }
3652 
3653 /// ParseStructUnionBody
3654 /// struct-contents:
3655 /// struct-declaration-list
3656 /// [EXT] empty
3657 /// [GNU] "struct-declaration-list" without terminatoring ';'
3658 /// struct-declaration-list:
3659 /// struct-declaration
3660 /// struct-declaration-list struct-declaration
3661 /// [OBC] '@' 'defs' '(' class-name ')'
3662 ///
3663 void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
3664  unsigned TagType, Decl *TagDecl) {
3665  PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc,
3666  "parsing struct/union body");
3667  assert(!getLangOpts().CPlusPlus && "C++ declarations not supported");
3668 
3669  BalancedDelimiterTracker T(*this, tok::l_brace);
3670  if (T.consumeOpen())
3671  return;
3672 
3673  ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
3674  Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
3675 
3676  SmallVector<Decl *, 32> FieldDecls;
3677 
3678  // While we still have something to read, read the declarations in the struct.
3679  while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) &&
3680  Tok.isNot(tok::eof)) {
3681  // Each iteration of this loop reads one struct-declaration.
3682 
3683  // Check for extraneous top-level semicolon.
3684  if (Tok.is(tok::semi)) {
3685  ConsumeExtraSemi(InsideStruct, TagType);
3686  continue;
3687  }
3688 
3689  // Parse _Static_assert declaration.
3690  if (Tok.is(tok::kw__Static_assert)) {
3691  SourceLocation DeclEnd;
3692  ParseStaticAssertDeclaration(DeclEnd);
3693  continue;
3694  }
3695 
3696  if (Tok.is(tok::annot_pragma_pack)) {
3697  HandlePragmaPack();
3698  continue;
3699  }
3700 
3701  if (Tok.is(tok::annot_pragma_align)) {
3702  HandlePragmaAlign();
3703  continue;
3704  }
3705 
3706  if (Tok.is(tok::annot_pragma_openmp)) {
3707  // Result can be ignored, because it must be always empty.
3708  AccessSpecifier AS = AS_none;
3709  ParsedAttributesWithRange Attrs(AttrFactory);
3710  (void)ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs);
3711  continue;
3712  }
3713 
3714  if (!Tok.is(tok::at)) {
3715  auto CFieldCallback = [&](ParsingFieldDeclarator &FD) {
3716  // Install the declarator into the current TagDecl.
3717  Decl *Field =
3718  Actions.ActOnField(getCurScope(), TagDecl,
3719  FD.D.getDeclSpec().getSourceRange().getBegin(),
3720  FD.D, FD.BitfieldSize);
3721  FieldDecls.push_back(Field);
3722  FD.complete(Field);
3723  };
3724 
3725  // Parse all the comma separated declarators.
3726  ParsingDeclSpec DS(*this);
3727  ParseStructDeclaration(DS, CFieldCallback);
3728  } else { // Handle @defs
3729  ConsumeToken();
3730  if (!Tok.isObjCAtKeyword(tok::objc_defs)) {
3731  Diag(Tok, diag::err_unexpected_at);
3732  SkipUntil(tok::semi);
3733  continue;
3734  }
3735  ConsumeToken();
3736  ExpectAndConsume(tok::l_paren);
3737  if (!Tok.is(tok::identifier)) {
3738  Diag(Tok, diag::err_expected) << tok::identifier;
3739  SkipUntil(tok::semi);
3740  continue;
3741  }
3742  SmallVector<Decl *, 16> Fields;
3743  Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(),
3744  Tok.getIdentifierInfo(), Fields);
3745  FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end());
3746  ConsumeToken();
3747  ExpectAndConsume(tok::r_paren);
3748  }
3749 
3750  if (TryConsumeToken(tok::semi))
3751  continue;
3752 
3753  if (Tok.is(tok::r_brace)) {
3754  ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list);
3755  break;
3756  }
3757 
3758  ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
3759  // Skip to end of block or statement to avoid ext-warning on extra ';'.
3760  SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
3761  // If we stopped at a ';', eat it.
3762  TryConsumeToken(tok::semi);
3763  }
3764 
3765  T.consumeClose();
3766 
3767  ParsedAttributes attrs(AttrFactory);
3768  // If attributes exist after struct contents, parse them.
3769  MaybeParseGNUAttributes(attrs);
3770 
3771  Actions.ActOnFields(getCurScope(),
3772  RecordLoc, TagDecl, FieldDecls,
3773  T.getOpenLocation(), T.getCloseLocation(),
3774  attrs.getList());
3775  StructScope.Exit();
3776  Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl, T.getRange());
3777 }
3778 
3779 /// ParseEnumSpecifier
3780 /// enum-specifier: [C99 6.7.2.2]
3781 /// 'enum' identifier[opt] '{' enumerator-list '}'
3782 ///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
3783 /// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
3784 /// '}' attributes[opt]
3785 /// [MS] 'enum' __declspec[opt] identifier[opt] '{' enumerator-list ',' [opt]
3786 /// '}'
3787 /// 'enum' identifier
3788 /// [GNU] 'enum' attributes[opt] identifier
3789 ///
3790 /// [C++11] enum-head '{' enumerator-list[opt] '}'
3791 /// [C++11] enum-head '{' enumerator-list ',' '}'
3792 ///
3793 /// enum-head: [C++11]
3794 /// enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]
3795 /// enum-key attribute-specifier-seq[opt] nested-name-specifier
3796 /// identifier enum-base[opt]
3797 ///
3798 /// enum-key: [C++11]
3799 /// 'enum'
3800 /// 'enum' 'class'
3801 /// 'enum' 'struct'
3802 ///
3803 /// enum-base: [C++11]
3804 /// ':' type-specifier-seq
3805 ///
3806 /// [C++] elaborated-type-specifier:
3807 /// [C++] 'enum' '::'[opt] nested-name-specifier[opt] identifier
3808 ///
3809 void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
3810  const ParsedTemplateInfo &TemplateInfo,
3811  AccessSpecifier AS, DeclSpecContext DSC) {
3812  // Parse the tag portion of this.
3813  if (Tok.is(tok::code_completion)) {
3814  // Code completion for an enum name.
3816  return cutOffParsing();
3817  }
3818 
3819  // If attributes exist after tag, parse them.
3820  ParsedAttributesWithRange attrs(AttrFactory);
3821  MaybeParseGNUAttributes(attrs);
3822  MaybeParseCXX11Attributes(attrs);
3823  MaybeParseMicrosoftDeclSpecs(attrs);
3824 
3825  SourceLocation ScopedEnumKWLoc;
3826  bool IsScopedUsingClassTag = false;
3827 
3828  // In C++11, recognize 'enum class' and 'enum struct'.
3829  if (Tok.isOneOf(tok::kw_class, tok::kw_struct)) {
3830  Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_scoped_enum
3831  : diag::ext_scoped_enum);
3832  IsScopedUsingClassTag = Tok.is(tok::kw_class);
3833  ScopedEnumKWLoc = ConsumeToken();
3834 
3835  // Attributes are not allowed between these keywords. Diagnose,
3836  // but then just treat them like they appeared in the right place.
3837  ProhibitAttributes(attrs);
3838 
3839  // They are allowed afterwards, though.
3840  MaybeParseGNUAttributes(attrs);
3841  MaybeParseCXX11Attributes(attrs);
3842  MaybeParseMicrosoftDeclSpecs(attrs);
3843  }
3844 
3845  // C++11 [temp.explicit]p12:
3846  // The usual access controls do not apply to names used to specify
3847  // explicit instantiations.
3848  // We extend this to also cover explicit specializations. Note that
3849  // we don't suppress if this turns out to be an elaborated type
3850  // specifier.
3851  bool shouldDelayDiagsInTag =
3852  (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
3853  TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
3854  SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag);
3855 
3856  // Enum definitions should not be parsed in a trailing-return-type.
3857  bool AllowDeclaration = DSC != DSC_trailing;
3858 
3859  bool AllowFixedUnderlyingType = AllowDeclaration &&
3860  (getLangOpts().CPlusPlus11 || getLangOpts().MicrosoftExt ||
3861  getLangOpts().ObjC2);
3862 
3863  CXXScopeSpec &SS = DS.getTypeSpecScope();
3864  if (getLangOpts().CPlusPlus) {
3865  // "enum foo : bar;" is not a potential typo for "enum foo::bar;"
3866  // if a fixed underlying type is allowed.
3867  ColonProtectionRAIIObject X(*this, AllowFixedUnderlyingType);
3868 
3869  CXXScopeSpec Spec;
3870  if (ParseOptionalCXXScopeSpecifier(Spec, nullptr,
3871  /*EnteringContext=*/true))
3872  return;
3873 
3874  if (Spec.isSet() && Tok.isNot(tok::identifier)) {
3875  Diag(Tok, diag::err_expected) << tok::identifier;
3876  if (Tok.isNot(tok::l_brace)) {
3877  // Has no name and is not a definition.
3878  // Skip the rest of this declarator, up until the comma or semicolon.
3879  SkipUntil(tok::comma, StopAtSemi);
3880  return;
3881  }
3882  }
3883 
3884  SS = Spec;
3885  }
3886 
3887  // Must have either 'enum name' or 'enum {...}'.
3888  if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) &&
3889  !(AllowFixedUnderlyingType && Tok.is(tok::colon))) {
3890  Diag(Tok, diag::err_expected_either) << tok::identifier << tok::l_brace;
3891 
3892  // Skip the rest of this declarator, up until the comma or semicolon.
3893  SkipUntil(tok::comma, StopAtSemi);
3894  return;
3895  }
3896 
3897  // If an identifier is present, consume and remember it.
3898  IdentifierInfo *Name = nullptr;
3899  SourceLocation NameLoc;
3900  if (Tok.is(tok::identifier)) {
3901  Name = Tok.getIdentifierInfo();
3902  NameLoc = ConsumeToken();
3903  }
3904 
3905  if (!Name && ScopedEnumKWLoc.isValid()) {
3906  // C++0x 7.2p2: The optional identifier shall not be omitted in the
3907  // declaration of a scoped enumeration.
3908  Diag(Tok, diag::err_scoped_enum_missing_identifier);
3909  ScopedEnumKWLoc = SourceLocation();
3910  IsScopedUsingClassTag = false;
3911  }
3912 
3913  // Okay, end the suppression area. We'll decide whether to emit the
3914  // diagnostics in a second.
3915  if (shouldDelayDiagsInTag)
3916  diagsFromTag.done();
3917 
3918  TypeResult BaseType;
3919 
3920  // Parse the fixed underlying type.
3921  bool CanBeBitfield = getCurScope()->getFlags() & Scope::ClassScope;
3922  if (AllowFixedUnderlyingType && Tok.is(tok::colon)) {
3923  bool PossibleBitfield = false;
3924  if (CanBeBitfield) {
3925  // If we're in class scope, this can either be an enum declaration with
3926  // an underlying type, or a declaration of a bitfield member. We try to
3927  // use a simple disambiguation scheme first to catch the common cases
3928  // (integer literal, sizeof); if it's still ambiguous, we then consider
3929  // anything that's a simple-type-specifier followed by '(' as an
3930  // expression. This suffices because function types are not valid
3931  // underlying types anyway.
3932  EnterExpressionEvaluationContext Unevaluated(Actions,
3934  TPResult TPR = isExpressionOrTypeSpecifierSimple(NextToken().getKind());
3935  // If the next token starts an expression, we know we're parsing a
3936  // bit-field. This is the common case.
3937  if (TPR == TPResult::True)
3938  PossibleBitfield = true;
3939  // If the next token starts a type-specifier-seq, it may be either a
3940  // a fixed underlying type or the start of a function-style cast in C++;
3941  // lookahead one more token to see if it's obvious that we have a
3942  // fixed underlying type.
3943  else if (TPR == TPResult::False &&
3944  GetLookAheadToken(2).getKind() == tok::semi) {
3945  // Consume the ':'.
3946  ConsumeToken();
3947  } else {
3948  // We have the start of a type-specifier-seq, so we have to perform
3949  // tentative parsing to determine whether we have an expression or a
3950  // type.
3951  TentativeParsingAction TPA(*this);
3952 
3953  // Consume the ':'.
3954  ConsumeToken();
3955 
3956  // If we see a type specifier followed by an open-brace, we have an
3957  // ambiguity between an underlying type and a C++11 braced
3958  // function-style cast. Resolve this by always treating it as an
3959  // underlying type.
3960  // FIXME: The standard is not entirely clear on how to disambiguate in
3961  // this case.
3962  if ((getLangOpts().CPlusPlus &&
3963  isCXXDeclarationSpecifier(TPResult::True) != TPResult::True) ||
3964  (!getLangOpts().CPlusPlus && !isDeclarationSpecifier(true))) {
3965  // We'll parse this as a bitfield later.
3966  PossibleBitfield = true;
3967  TPA.Revert();
3968  } else {
3969  // We have a type-specifier-seq.
3970  TPA.Commit();
3971  }
3972  }
3973  } else {
3974  // Consume the ':'.
3975  ConsumeToken();
3976  }
3977 
3978  if (!PossibleBitfield) {
3979  SourceRange Range;
3980  BaseType = ParseTypeName(&Range);
3981 
3982  if (getLangOpts().CPlusPlus11) {
3983  Diag(StartLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type);
3984  } else if (!getLangOpts().ObjC2) {
3985  if (getLangOpts().CPlusPlus)
3986  Diag(StartLoc, diag::ext_cxx11_enum_fixed_underlying_type) << Range;
3987  else
3988  Diag(StartLoc, diag::ext_c_enum_fixed_underlying_type) << Range;
3989  }
3990  }
3991  }
3992 
3993  // There are four options here. If we have 'friend enum foo;' then this is a
3994  // friend declaration, and cannot have an accompanying definition. If we have
3995  // 'enum foo;', then this is a forward declaration. If we have
3996  // 'enum foo {...' then this is a definition. Otherwise we have something
3997  // like 'enum foo xyz', a reference.
3998  //
3999  // This is needed to handle stuff like this right (C99 6.7.2.3p11):
4000  // enum foo {..}; void bar() { enum foo; } <- new foo in bar.
4001  // enum foo {..}; void bar() { enum foo x; } <- use of old foo.
4002  //
4003  Sema::TagUseKind TUK;
4004  if (!AllowDeclaration) {
4005  TUK = Sema::TUK_Reference;
4006  } else if (Tok.is(tok::l_brace)) {
4007  if (DS.isFriendSpecified()) {
4008  Diag(Tok.getLocation(), diag::err_friend_decl_defines_type)
4009  << SourceRange(DS.getFriendSpecLoc());
4010  ConsumeBrace();
4011  SkipUntil(tok::r_brace, StopAtSemi);
4012  TUK = Sema::TUK_Friend;
4013  } else {
4014  TUK = Sema::TUK_Definition;
4015  }
4016  } else if (!isTypeSpecifier(DSC) &&
4017  (Tok.is(tok::semi) ||
4018  (Tok.isAtStartOfLine() &&
4019  !isValidAfterTypeSpecifier(CanBeBitfield)))) {
4021  if (Tok.isNot(tok::semi)) {
4022  // A semicolon was missing after this declaration. Diagnose and recover.
4023  ExpectAndConsume(tok::semi, diag::err_expected_after, "enum");
4024  PP.EnterToken(Tok);
4025  Tok.setKind(tok::semi);
4026  }
4027  } else {
4028  TUK = Sema::TUK_Reference;
4029  }
4030 
4031  // If this is an elaborated type specifier, and we delayed
4032  // diagnostics before, just merge them into the current pool.
4033  if (TUK == Sema::TUK_Reference && shouldDelayDiagsInTag) {
4034  diagsFromTag.redelay();
4035  }
4036 
4037  MultiTemplateParamsArg TParams;
4038  if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
4039  TUK != Sema::TUK_Reference) {
4040  if (!getLangOpts().CPlusPlus11 || !SS.isSet()) {
4041  // Skip the rest of this declarator, up until the comma or semicolon.
4042  Diag(Tok, diag::err_enum_template);
4043  SkipUntil(tok::comma, StopAtSemi);
4044  return;
4045  }
4046 
4047  if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
4048  // Enumerations can't be explicitly instantiated.
4049  DS.SetTypeSpecError();
4050  Diag(StartLoc, diag::err_explicit_instantiation_enum);
4051  return;
4052  }
4053 
4054  assert(TemplateInfo.TemplateParams && "no template parameters");
4055  TParams = MultiTemplateParamsArg(TemplateInfo.TemplateParams->data(),
4056  TemplateInfo.TemplateParams->size());
4057  }
4058 
4059  if (TUK == Sema::TUK_Reference)
4060  ProhibitAttributes(attrs);
4061 
4062  if (!Name && TUK != Sema::TUK_Definition) {
4063  Diag(Tok, diag::err_enumerator_unnamed_no_def);
4064 
4065  // Skip the rest of this declarator, up until the comma or semicolon.
4066  SkipUntil(tok::comma, StopAtSemi);
4067  return;
4068  }
4069 
4070  handleDeclspecAlignBeforeClassKey(attrs, DS, TUK);
4071 
4072  Sema::SkipBodyInfo SkipBody;
4073  if (!Name && TUK == Sema::TUK_Definition && Tok.is(tok::l_brace) &&
4074  NextToken().is(tok::identifier))
4075  SkipBody = Actions.shouldSkipAnonEnumBody(getCurScope(),
4076  NextToken().getIdentifierInfo(),
4077  NextToken().getLocation());
4078 
4079  bool Owned = false;
4080  bool IsDependent = false;
4081  const char *PrevSpec = nullptr;
4082  unsigned DiagID;
4083  Decl *TagDecl = Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK,
4084  StartLoc, SS, Name, NameLoc, attrs.getList(),
4085  AS, DS.getModulePrivateSpecLoc(), TParams,
4086  Owned, IsDependent, ScopedEnumKWLoc,
4087  IsScopedUsingClassTag, BaseType,
4088  DSC == DSC_type_specifier, &SkipBody);
4089 
4090  if (SkipBody.ShouldSkip) {
4091  assert(TUK == Sema::TUK_Definition && "can only skip a definition");
4092 
4093  BalancedDelimiterTracker T(*this, tok::l_brace);
4094  T.consumeOpen();
4095  T.skipToEnd();
4096 
4097  if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
4098  NameLoc.isValid() ? NameLoc : StartLoc,
4099  PrevSpec, DiagID, TagDecl, Owned,
4100  Actions.getASTContext().getPrintingPolicy()))
4101  Diag(StartLoc, DiagID) << PrevSpec;
4102  return;
4103  }
4104 
4105  if (IsDependent) {
4106  // This enum has a dependent nested-name-specifier. Handle it as a
4107  // dependent tag.
4108  if (!Name) {
4109  DS.SetTypeSpecError();
4110  Diag(Tok, diag::err_expected_type_name_after_typename);
4111  return;
4112  }
4113 
4114  TypeResult Type = Actions.ActOnDependentTag(
4115  getCurScope(), DeclSpec::TST_enum, TUK, SS, Name, StartLoc, NameLoc);
4116  if (Type.isInvalid()) {
4117  DS.SetTypeSpecError();
4118  return;
4119  }
4120 
4121  if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
4122  NameLoc.isValid() ? NameLoc : StartLoc,
4123  PrevSpec, DiagID, Type.get(),
4124  Actions.getASTContext().getPrintingPolicy()))
4125  Diag(StartLoc, DiagID) << PrevSpec;
4126 
4127  return;
4128  }
4129 
4130  if (!TagDecl) {
4131  // The action failed to produce an enumeration tag. If this is a
4132  // definition, consume the entire definition.
4133  if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference) {
4134  ConsumeBrace();
4135  SkipUntil(tok::r_brace, StopAtSemi);
4136  }
4137 
4138  DS.SetTypeSpecError();
4139  return;
4140  }
4141 
4142  if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference)
4143  ParseEnumBody(StartLoc, TagDecl);
4144 
4145  if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
4146  NameLoc.isValid() ? NameLoc : StartLoc,
4147  PrevSpec, DiagID, TagDecl, Owned,
4148  Actions.getASTContext().getPrintingPolicy()))
4149  Diag(StartLoc, DiagID) << PrevSpec;
4150 }
4151 
4152 /// ParseEnumBody - Parse a {} enclosed enumerator-list.
4153 /// enumerator-list:
4154 /// enumerator
4155 /// enumerator-list ',' enumerator
4156 /// enumerator:
4157 /// enumeration-constant attributes[opt]
4158 /// enumeration-constant attributes[opt] '=' constant-expression
4159 /// enumeration-constant:
4160 /// identifier
4161 ///
4162 void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {
4163  // Enter the scope of the enum body and start the definition.
4164  ParseScope EnumScope(this, Scope::DeclScope | Scope::EnumScope);
4165  Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl);
4166 
4167  BalancedDelimiterTracker T(*this, tok::l_brace);
4168  T.consumeOpen();
4169 
4170  // C does not allow an empty enumerator-list, C++ does [dcl.enum].
4171  if (Tok.is(tok::r_brace) && !getLangOpts().CPlusPlus)
4172  Diag(Tok, diag::error_empty_enum);
4173 
4174  SmallVector<Decl *, 32> EnumConstantDecls;
4175  SmallVector<SuppressAccessChecks, 32> EnumAvailabilityDiags;
4176 
4177  Decl *LastEnumConstDecl = nullptr;
4178 
4179  // Parse the enumerator-list.
4180  while (Tok.isNot(tok::r_brace)) {
4181  // Parse enumerator. If failed, try skipping till the start of the next
4182  // enumerator definition.
4183  if (Tok.isNot(tok::identifier)) {
4184  Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
4185  if (SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch) &&
4186  TryConsumeToken(tok::comma))
4187  continue;
4188  break;
4189  }
4190  IdentifierInfo *Ident = Tok.getIdentifierInfo();
4191  SourceLocation IdentLoc = ConsumeToken();
4192 
4193  // If attributes exist after the enumerator, parse them.
4194  ParsedAttributesWithRange attrs(AttrFactory);
4195  MaybeParseGNUAttributes(attrs);
4196  ProhibitAttributes(attrs); // GNU-style attributes are prohibited.
4197  if (getLangOpts().CPlusPlus11 && isCXX11AttributeSpecifier()) {
4198  if (!getLangOpts().CPlusPlus1z)
4199  Diag(Tok.getLocation(), diag::warn_cxx14_compat_attribute)
4200  << 1 /*enumerator*/;
4201  ParseCXX11Attributes(attrs);
4202  }
4203 
4204  SourceLocation EqualLoc;
4205  ExprResult AssignedVal;
4206  EnumAvailabilityDiags.emplace_back(*this);
4207 
4208  if (TryConsumeToken(tok::equal, EqualLoc)) {
4209  AssignedVal = ParseConstantExpression();
4210  if (AssignedVal.isInvalid())
4211  SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch);
4212  }
4213 
4214  // Install the enumerator constant into EnumDecl.
4215  Decl *EnumConstDecl = Actions.ActOnEnumConstant(getCurScope(), EnumDecl,
4216  LastEnumConstDecl,
4217  IdentLoc, Ident,
4218  attrs.getList(), EqualLoc,
4219  AssignedVal.get());
4220  EnumAvailabilityDiags.back().done();
4221 
4222  EnumConstantDecls.push_back(EnumConstDecl);
4223  LastEnumConstDecl = EnumConstDecl;
4224 
4225  if (Tok.is(tok::identifier)) {
4226  // We're missing a comma between enumerators.
4227  SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation);
4228  Diag(Loc, diag::err_enumerator_list_missing_comma)
4229  << FixItHint::CreateInsertion(Loc, ", ");
4230  continue;
4231  }
4232 
4233  // Emumerator definition must be finished, only comma or r_brace are
4234  // allowed here.
4235  SourceLocation CommaLoc;
4236  if (Tok.isNot(tok::r_brace) && !TryConsumeToken(tok::comma, CommaLoc)) {
4237  if (EqualLoc.isValid())
4238  Diag(Tok.getLocation(), diag::err_expected_either) << tok::r_brace
4239  << tok::comma;
4240  else
4241  Diag(Tok.getLocation(), diag::err_expected_end_of_enumerator);
4242  if (SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch)) {
4243  if (TryConsumeToken(tok::comma, CommaLoc))
4244  continue;
4245  } else {
4246  break;
4247  }
4248  }
4249 
4250  // If comma is followed by r_brace, emit appropriate warning.
4251  if (Tok.is(tok::r_brace) && CommaLoc.isValid()) {
4252  if (!getLangOpts().C99 && !getLangOpts().CPlusPlus11)
4253  Diag(CommaLoc, getLangOpts().CPlusPlus ?
4254  diag::ext_enumerator_list_comma_cxx :
4255  diag::ext_enumerator_list_comma_c)
4256  << FixItHint::CreateRemoval(CommaLoc);
4257  else if (getLangOpts().CPlusPlus11)
4258  Diag(CommaLoc, diag::warn_cxx98_compat_enumerator_list_comma)
4259  << FixItHint::CreateRemoval(CommaLoc);
4260  break;
4261  }
4262  }
4263 
4264  // Eat the }.
4265  T.consumeClose();
4266 
4267  // If attributes exist after the identifier list, parse them.
4268  ParsedAttributes attrs(AttrFactory);
4269  MaybeParseGNUAttributes(attrs);
4270 
4271  Actions.ActOnEnumBody(StartLoc, T.getRange(),
4272  EnumDecl, EnumConstantDecls,
4273  getCurScope(),
4274  attrs.getList());
4275 
4276  // Now handle enum constant availability diagnostics.
4277  assert(EnumConstantDecls.size() == EnumAvailabilityDiags.size());
4278  for (size_t i = 0, e = EnumConstantDecls.size(); i != e; ++i) {
4280  EnumAvailabilityDiags[i].redelay();
4281  PD.complete(EnumConstantDecls[i]);
4282  }
4283 
4284  EnumScope.Exit();
4285  Actions.ActOnTagFinishDefinition(getCurScope(), EnumDecl, T.getRange());
4286 
4287  // The next token must be valid after an enum definition. If not, a ';'
4288  // was probably forgotten.
4289  bool CanBeBitfield = getCurScope()->getFlags() & Scope::ClassScope;
4290  if (!isValidAfterTypeSpecifier(CanBeBitfield)) {
4291  ExpectAndConsume(tok::semi, diag::err_expected_after, "enum");
4292  // Push this token back into the preprocessor and change our current token
4293  // to ';' so that the rest of the code recovers as though there were an
4294  // ';' after the definition.
4295  PP.EnterToken(Tok);
4296  Tok.setKind(tok::semi);
4297  }
4298 }
4299 
4300 /// isKnownToBeTypeSpecifier - Return true if we know that the specified token
4301 /// is definitely a type-specifier. Return false if it isn't part of a type
4302 /// specifier or if we're not sure.
4303 bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const {
4304  switch (Tok.getKind()) {
4305  default: return false;
4306  // type-specifiers
4307  case tok::kw_short:
4308  case tok::kw_long:
4309  case tok::kw___int64:
4310  case tok::kw___int128:
4311  case tok::kw_signed:
4312  case tok::kw_unsigned:
4313  case tok::kw__Complex:
4314  case tok::kw__Imaginary:
4315  case tok::kw_void:
4316  case tok::kw_char:
4317  case tok::kw_wchar_t:
4318  case tok::kw_char16_t:
4319  case tok::kw_char32_t:
4320  case tok::kw_int:
4321  case tok::kw_half:
4322  case tok::kw_float:
4323  case tok::kw_double:
4324  case tok::kw___float128:
4325  case tok::kw_bool:
4326  case tok::kw__Bool:
4327  case tok::kw__Decimal32:
4328  case tok::kw__Decimal64:
4329  case tok::kw__Decimal128:
4330  case tok::kw___vector:
4331 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
4332 #include "clang/Basic/OpenCLImageTypes.def"
4333 
4334  // struct-or-union-specifier (C99) or class-specifier (C++)
4335  case tok::kw_class:
4336  case tok::kw_struct:
4337  case tok::kw___interface:
4338  case tok::kw_union:
4339  // enum-specifier
4340  case tok::kw_enum:
4341 
4342  // typedef-name
4343  case tok::annot_typename:
4344  return true;
4345  }
4346 }
4347 
4348 /// isTypeSpecifierQualifier - Return true if the current token could be the
4349 /// start of a specifier-qualifier-list.
4350 bool Parser::isTypeSpecifierQualifier() {
4351  switch (Tok.getKind()) {
4352  default: return false;
4353 
4354  case tok::identifier: // foo::bar
4355  if (TryAltiVecVectorToken())
4356  return true;
4357  // Fall through.
4358  case tok::kw_typename: // typename T::type
4359  // Annotate typenames and C++ scope specifiers. If we get one, just
4360  // recurse to handle whatever we get.
4362  return true;
4363  if (Tok.is(tok::identifier))
4364  return false;
4365  return isTypeSpecifierQualifier();
4366 
4367  case tok::coloncolon: // ::foo::bar
4368  if (NextToken().is(tok::kw_new) || // ::new
4369  NextToken().is(tok::kw_delete)) // ::delete
4370  return false;
4371 
4373  return true;
4374  return isTypeSpecifierQualifier();
4375 
4376  // GNU attributes support.
4377  case tok::kw___attribute:
4378  // GNU typeof support.
4379  case tok::kw_typeof:
4380 
4381  // type-specifiers
4382  case tok::kw_short:
4383  case tok::kw_long:
4384  case tok::kw___int64:
4385  case tok::kw___int128:
4386  case tok::kw_signed:
4387  case tok::kw_unsigned:
4388  case tok::kw__Complex:
4389  case tok::kw__Imaginary:
4390  case tok::kw_void:
4391  case tok::kw_char:
4392  case tok::kw_wchar_t:
4393  case tok::kw_char16_t:
4394  case tok::kw_char32_t:
4395  case tok::kw_int:
4396  case tok::kw_half:
4397  case tok::kw_float:
4398  case tok::kw_double:
4399  case tok::kw___float128:
4400  case tok::kw_bool:
4401  case tok::kw__Bool:
4402  case tok::kw__Decimal32:
4403  case tok::kw__Decimal64:
4404  case tok::kw__Decimal128:
4405  case tok::kw___vector:
4406 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
4407 #include "clang/Basic/OpenCLImageTypes.def"
4408 
4409  // struct-or-union-specifier (C99) or class-specifier (C++)
4410  case tok::kw_class:
4411  case tok::kw_struct:
4412  case tok::kw___interface:
4413  case tok::kw_union:
4414  // enum-specifier
4415  case tok::kw_enum:
4416 
4417  // type-qualifier
4418  case tok::kw_const:
4419  case tok::kw_volatile:
4420  case tok::kw_restrict:
4421 
4422  // Debugger support.
4423  case tok::kw___unknown_anytype:
4424 
4425  // typedef-name
4426  case tok::annot_typename:
4427  return true;
4428 
4429  // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
4430  case tok::less:
4431  return getLangOpts().ObjC1;
4432 
4433  case tok::kw___cdecl:
4434  case tok::kw___stdcall:
4435  case tok::kw___fastcall:
4436  case tok::kw___thiscall:
4437  case tok::kw___vectorcall:
4438  case tok::kw___w64:
4439  case tok::kw___ptr64:
4440  case tok::kw___ptr32:
4441  case tok::kw___pascal:
4442  case tok::kw___unaligned:
4443 
4444  case tok::kw__Nonnull:
4445  case tok::kw__Nullable:
4446  case tok::kw__Null_unspecified:
4447 
4448  case tok::kw___kindof:
4449 
4450  case tok::kw___private:
4451  case tok::kw___local:
4452  case tok::kw___global:
4453  case tok::kw___constant:
4454  case tok::kw___generic:
4455  case tok::kw___read_only:
4456  case tok::kw___read_write:
4457  case tok::kw___write_only:
4458 
4459  return true;
4460 
4461  // C11 _Atomic
4462  case tok::kw__Atomic:
4463  return true;
4464  }
4465 }
4466 
4467 /// isDeclarationSpecifier() - Return true if the current token is part of a
4468 /// declaration specifier.
4469 ///
4470 /// \param DisambiguatingWithExpression True to indicate that the purpose of
4471 /// this check is to disambiguate between an expression and a declaration.
4472 bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
4473  switch (Tok.getKind()) {
4474  default: return false;
4475 
4476  case tok::kw_pipe:
4477  return getLangOpts().OpenCL && (getLangOpts().OpenCLVersion >= 200);
4478 
4479  case tok::identifier: // foo::bar
4480  // Unfortunate hack to support "Class.factoryMethod" notation.
4481  if (getLangOpts().ObjC1 && NextToken().is(tok::period))
4482  return false;
4483  if (TryAltiVecVectorToken())
4484  return true;
4485  // Fall through.
4486  case tok::kw_decltype: // decltype(T())::type
4487  case tok::kw_typename: // typename T::type
4488  // Annotate typenames and C++ scope specifiers. If we get one, just
4489  // recurse to handle whatever we get.
4491  return true;
4492  if (Tok.is(tok::identifier))
4493  return false;
4494 
4495  // If we're in Objective-C and we have an Objective-C class type followed
4496  // by an identifier and then either ':' or ']', in a place where an
4497  // expression is permitted, then this is probably a class message send
4498  // missing the initial '['. In this case, we won't consider this to be
4499  // the start of a declaration.
4500  if (DisambiguatingWithExpression &&
4501  isStartOfObjCClassMessageMissingOpenBracket())
4502  return false;
4503 
4504  return isDeclarationSpecifier();
4505 
4506  case tok::coloncolon: // ::foo::bar
4507  if (NextToken().is(tok::kw_new) || // ::new
4508  NextToken().is(tok::kw_delete)) // ::delete
4509  return false;
4510 
4511  // Annotate typenames and C++ scope specifiers. If we get one, just
4512  // recurse to handle whatever we get.
4514  return true;
4515  return isDeclarationSpecifier();
4516 
4517  // storage-class-specifier
4518  case tok::kw_typedef:
4519  case tok::kw_extern:
4520  case tok::kw___private_extern__:
4521  case tok::kw_static:
4522  case tok::kw_auto:
4523  case tok::kw___auto_type:
4524  case tok::kw_register:
4525  case tok::kw___thread:
4526  case tok::kw_thread_local:
4527  case tok::kw__Thread_local:
4528 
4529  // Modules
4530  case tok::kw___module_private__:
4531 
4532  // Debugger support
4533  case tok::kw___unknown_anytype:
4534 
4535  // type-specifiers
4536  case tok::kw_short:
4537  case tok::kw_long:
4538  case tok::kw___int64:
4539  case tok::kw___int128:
4540  case tok::kw_signed:
4541  case tok::kw_unsigned:
4542  case tok::kw__Complex:
4543  case tok::kw__Imaginary:
4544  case tok::kw_void:
4545  case tok::kw_char:
4546  case tok::kw_wchar_t:
4547  case tok::kw_char16_t:
4548  case tok::kw_char32_t:
4549 
4550  case tok::kw_int:
4551  case tok::kw_half:
4552  case tok::kw_float:
4553  case tok::kw_double:
4554  case tok::kw___float128:
4555  case tok::kw_bool:
4556  case tok::kw__Bool:
4557  case tok::kw__Decimal32:
4558  case tok::kw__Decimal64:
4559  case tok::kw__Decimal128:
4560  case tok::kw___vector:
4561 
4562  // struct-or-union-specifier (C99) or class-specifier (C++)
4563  case tok::kw_class:
4564  case tok::kw_struct:
4565  case tok::kw_union:
4566  case tok::kw___interface:
4567  // enum-specifier
4568  case tok::kw_enum:
4569 
4570  // type-qualifier
4571  case tok::kw_const:
4572  case tok::kw_volatile:
4573  case tok::kw_restrict:
4574 
4575  // function-specifier
4576  case tok::kw_inline:
4577  case tok::kw_virtual:
4578  case tok::kw_explicit:
4579  case tok::kw__Noreturn:
4580 
4581  // alignment-specifier
4582  case tok::kw__Alignas:
4583 
4584  // friend keyword.
4585  case tok::kw_friend:
4586 
4587  // static_assert-declaration
4588  case tok::kw__Static_assert:
4589 
4590  // GNU typeof support.
4591  case tok::kw_typeof:
4592 
4593  // GNU attributes.
4594  case tok::kw___attribute:
4595 
4596  // C++11 decltype and constexpr.
4597  case tok::annot_decltype:
4598  case tok::kw_constexpr:
4599 
4600  // C++ Concepts TS - concept
4601  case tok::kw_concept:
4602 
4603  // C11 _Atomic
4604  case tok::kw__Atomic:
4605  return true;
4606 
4607  // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
4608  case tok::less:
4609  return getLangOpts().ObjC1;
4610 
4611  // typedef-name
4612  case tok::annot_typename:
4613  return !DisambiguatingWithExpression ||
4614  !isStartOfObjCClassMessageMissingOpenBracket();
4615 
4616  case tok::kw___declspec:
4617  case tok::kw___cdecl:
4618  case tok::kw___stdcall:
4619  case tok::kw___fastcall:
4620  case tok::kw___thiscall:
4621  case tok::kw___vectorcall:
4622  case tok::kw___w64:
4623  case tok::kw___sptr:
4624  case tok::kw___uptr:
4625  case tok::kw___ptr64:
4626  case tok::kw___ptr32:
4627  case tok::kw___forceinline:
4628  case tok::kw___pascal:
4629  case tok::kw___unaligned:
4630 
4631  case tok::kw__Nonnull:
4632  case tok::kw__Nullable:
4633  case tok::kw__Null_unspecified:
4634 
4635  case tok::kw___kindof:
4636 
4637  case tok::kw___private:
4638  case tok::kw___local:
4639  case tok::kw___global:
4640  case tok::kw___constant:
4641  case tok::kw___generic:
4642  case tok::kw___read_only:
4643  case tok::kw___read_write:
4644  case tok::kw___write_only:
4645 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
4646 #include "clang/Basic/OpenCLImageTypes.def"
4647 
4648  return true;
4649  }
4650 }
4651 
4652 bool Parser::isConstructorDeclarator(bool IsUnqualified) {
4653  TentativeParsingAction TPA(*this);
4654 
4655  // Parse the C++ scope specifier.
4656  CXXScopeSpec SS;
4657  if (ParseOptionalCXXScopeSpecifier(SS, nullptr,
4658  /*EnteringContext=*/true)) {
4659  TPA.Revert();
4660  return false;
4661  }
4662 
4663  // Parse the constructor name.
4664  if (Tok.isOneOf(tok::identifier, tok::annot_template_id)) {
4665  // We already know that we have a constructor name; just consume
4666  // the token.
4667  ConsumeToken();
4668  } else {
4669  TPA.Revert();
4670  return false;
4671  }
4672 
4673  // Current class name must be followed by a left parenthesis.
4674  if (Tok.isNot(tok::l_paren)) {
4675  TPA.Revert();
4676  return false;
4677  }
4678  ConsumeParen();
4679 
4680  // A right parenthesis, or ellipsis followed by a right parenthesis signals
4681  // that we have a constructor.
4682  if (Tok.is(tok::r_paren) ||
4683  (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren))) {
4684  TPA.Revert();
4685  return true;
4686  }
4687 
4688  // A C++11 attribute here signals that we have a constructor, and is an
4689  // attribute on the first constructor parameter.
4690  if (getLangOpts().CPlusPlus11 &&
4691  isCXX11AttributeSpecifier(/*Disambiguate*/ false,
4692  /*OuterMightBeMessageSend*/ true)) {
4693  TPA.Revert();
4694  return true;
4695  }
4696 
4697  // If we need to, enter the specified scope.
4698  DeclaratorScopeObj DeclScopeObj(*this, SS);
4699  if (SS.isSet() && Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
4700  DeclScopeObj.EnterDeclaratorScope();
4701 
4702  // Optionally skip Microsoft attributes.
4703  ParsedAttributes Attrs(AttrFactory);
4704  MaybeParseMicrosoftAttributes(Attrs);
4705 
4706  // Check whether the next token(s) are part of a declaration
4707  // specifier, in which case we have the start of a parameter and,
4708  // therefore, we know that this is a constructor.
4709  bool IsConstructor = false;
4710  if (isDeclarationSpecifier())
4711  IsConstructor = true;
4712  else if (Tok.is(tok::identifier) ||
4713  (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier))) {
4714  // We've seen "C ( X" or "C ( X::Y", but "X" / "X::Y" is not a type.
4715  // This might be a parenthesized member name, but is more likely to
4716  // be a constructor declaration with an invalid argument type. Keep
4717  // looking.
4718  if (Tok.is(tok::annot_cxxscope))
4719  ConsumeToken();
4720  ConsumeToken();
4721 
4722  // If this is not a constructor, we must be parsing a declarator,
4723  // which must have one of the following syntactic forms (see the
4724  // grammar extract at the start of ParseDirectDeclarator):
4725  switch (Tok.getKind()) {
4726  case tok::l_paren:
4727  // C(X ( int));
4728  case tok::l_square:
4729  // C(X [ 5]);
4730  // C(X [ [attribute]]);
4731  case tok::coloncolon:
4732  // C(X :: Y);
4733  // C(X :: *p);
4734  // Assume this isn't a constructor, rather than assuming it's a
4735  // constructor with an unnamed parameter of an ill-formed type.
4736  break;
4737 
4738  case tok::r_paren:
4739  // C(X )
4740  if (NextToken().is(tok::colon) || NextToken().is(tok::kw_try)) {
4741  // Assume these were meant to be constructors:
4742  // C(X) : (the name of a bit-field cannot be parenthesized).
4743  // C(X) try (this is otherwise ill-formed).
4744  IsConstructor = true;
4745  }
4746  if (NextToken().is(tok::semi) || NextToken().is(tok::l_brace)) {
4747  // If we have a constructor name within the class definition,
4748  // assume these were meant to be constructors:
4749  // C(X) {
4750  // C(X) ;
4751  // ... because otherwise we would be declaring a non-static data
4752  // member that is ill-formed because it's of the same type as its
4753  // surrounding class.
4754  //
4755  // FIXME: We can actually do this whether or not the name is qualified,
4756  // because if it is qualified in this context it must be being used as
4757  // a constructor name. However, we do not implement that rule correctly
4758  // currently, so we're somewhat conservative here.
4759  IsConstructor = IsUnqualified;
4760  }
4761  break;
4762 
4763  default:
4764  IsConstructor = true;
4765  break;
4766  }
4767  }
4768 
4769  TPA.Revert();
4770  return IsConstructor;
4771 }
4772 
4773 /// ParseTypeQualifierListOpt
4774 /// type-qualifier-list: [C99 6.7.5]
4775 /// type-qualifier
4776 /// [vendor] attributes
4777 /// [ only if AttrReqs & AR_VendorAttributesParsed ]
4778 /// type-qualifier-list type-qualifier
4779 /// [vendor] type-qualifier-list attributes
4780 /// [ only if AttrReqs & AR_VendorAttributesParsed ]
4781 /// [C++0x] attribute-specifier[opt] is allowed before cv-qualifier-seq
4782 /// [ only if AttReqs & AR_CXX11AttributesParsed ]
4783 /// Note: vendor can be GNU, MS, etc and can be explicitly controlled via
4784 /// AttrRequirements bitmask values.
4785 void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, unsigned AttrReqs,
4786  bool AtomicAllowed,
4787  bool IdentifierRequired) {
4788  if (getLangOpts().CPlusPlus11 && (AttrReqs & AR_CXX11AttributesParsed) &&
4789  isCXX11AttributeSpecifier()) {
4790  ParsedAttributesWithRange attrs(AttrFactory);
4791  ParseCXX11Attributes(attrs);
4792  DS.takeAttributesFrom(attrs);
4793  }
4794 
4795  SourceLocation EndLoc;
4796 
4797  while (1) {
4798  bool isInvalid = false;
4799  const char *PrevSpec = nullptr;
4800  unsigned DiagID = 0;
4801  SourceLocation Loc = Tok.getLocation();
4802 
4803  switch (Tok.getKind()) {
4804  case tok::code_completion:
4805  Actions.CodeCompleteTypeQualifiers(DS);
4806  return cutOffParsing();
4807 
4808  case tok::kw_const:
4809  isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, DiagID,
4810  getLangOpts());
4811  break;
4812  case tok::kw_volatile:
4813  isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
4814  getLangOpts());
4815  break;
4816  case tok::kw_restrict:
4817  isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
4818  getLangOpts());
4819  break;
4820  case tok::kw__Atomic:
4821  if (!AtomicAllowed)
4822  goto DoneWithTypeQuals;
4823  isInvalid = DS.SetTypeQual(DeclSpec::TQ_atomic, Loc, PrevSpec, DiagID,
4824  getLangOpts());
4825  break;
4826 
4827  // OpenCL qualifiers:
4828  case tok::kw___private:
4829  case tok::kw___global:
4830  case tok::kw___local:
4831  case tok::kw___constant:
4832  case tok::kw___generic:
4833  case tok::kw___read_only:
4834  case tok::kw___write_only:
4835  case tok::kw___read_write:
4836  ParseOpenCLQualifiers(DS.getAttributes());
4837  break;
4838 
4839  case tok::kw___unaligned:
4840  isInvalid = DS.SetTypeQual(DeclSpec::TQ_unaligned, Loc, PrevSpec, DiagID,
4841  getLangOpts());
4842  break;
4843  case tok::kw___uptr:
4844  // GNU libc headers in C mode use '__uptr' as an identifer which conflicts
4845  // with the MS modifier keyword.
4846  if ((AttrReqs & AR_DeclspecAttributesParsed) && !getLangOpts().CPlusPlus &&
4847  IdentifierRequired && DS.isEmpty() && NextToken().is(tok::semi)) {
4848  if (TryKeywordIdentFallback(false))
4849  continue;
4850  }
4851  case tok::kw___sptr:
4852  case tok::kw___w64:
4853  case tok::kw___ptr64:
4854  case tok::kw___ptr32:
4855  case tok::kw___cdecl:
4856  case tok::kw___stdcall:
4857  case tok::kw___fastcall:
4858  case tok::kw___thiscall:
4859  case tok::kw___vectorcall:
4860  if (AttrReqs & AR_DeclspecAttributesParsed) {
4861  ParseMicrosoftTypeAttributes(DS.getAttributes());
4862  continue;
4863  }
4864  goto DoneWithTypeQuals;
4865  case tok::kw___pascal:
4866  if (AttrReqs & AR_VendorAttributesParsed) {
4867  ParseBorlandTypeAttributes(DS.getAttributes());
4868  continue;
4869  }
4870  goto DoneWithTypeQuals;
4871 
4872  // Nullability type specifiers.
4873  case tok::kw__Nonnull:
4874  case tok::kw__Nullable:
4875  case tok::kw__Null_unspecified:
4876  ParseNullabilityTypeSpecifiers(DS.getAttributes());
4877  continue;
4878 
4879  // Objective-C 'kindof' types.
4880  case tok::kw___kindof:
4881  DS.getAttributes().addNew(Tok.getIdentifierInfo(), Loc, nullptr, Loc,
4882  nullptr, 0, AttributeList::AS_Keyword);
4883  (void)ConsumeToken();
4884  continue;
4885 
4886  case tok::kw___attribute:
4887  if (AttrReqs & AR_GNUAttributesParsedAndRejected)
4888  // When GNU attributes are expressly forbidden, diagnose their usage.
4889  Diag(Tok, diag::err_attributes_not_allowed);
4890 
4891  // Parse the attributes even if they are rejected to ensure that error
4892  // recovery is graceful.
4893  if (AttrReqs & AR_GNUAttributesParsed ||
4894  AttrReqs & AR_GNUAttributesParsedAndRejected) {
4895  ParseGNUAttributes(DS.getAttributes());
4896  continue; // do *not* consume the next token!
4897  }
4898  // otherwise, FALL THROUGH!
4899  default:
4900  DoneWithTypeQuals:
4901  // If this is not a type-qualifier token, we're done reading type
4902  // qualifiers. First verify that DeclSpec's are consistent.
4903  DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
4904  if (EndLoc.isValid())
4905  DS.SetRangeEnd(EndLoc);
4906  return;
4907  }
4908 
4909  // If the specifier combination wasn't legal, issue a diagnostic.
4910  if (isInvalid) {
4911  assert(PrevSpec && "Method did not return previous specifier!");
4912  Diag(Tok, DiagID) << PrevSpec;
4913  }
4914  EndLoc = ConsumeToken();
4915  }
4916 }
4917 
4918 /// ParseDeclarator - Parse and verify a newly-initialized declarator.
4919 ///
4920 void Parser::ParseDeclarator(Declarator &D) {
4921  /// This implements the 'declarator' production in the C grammar, then checks
4922  /// for well-formedness and issues diagnostics.
4923  ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
4924 }
4925 
4926 static bool isPtrOperatorToken(tok::TokenKind Kind, const LangOptions &Lang,
4927  unsigned TheContext) {
4928  if (Kind == tok::star || Kind == tok::caret)
4929  return true;
4930 
4931  if ((Kind == tok::kw_pipe) && Lang.OpenCL && (Lang.OpenCLVersion >= 200))
4932  return true;
4933 
4934  if (!Lang.CPlusPlus)
4935  return false;
4936 
4937  if (Kind == tok::amp)
4938  return true;
4939 
4940  // We parse rvalue refs in C++03, because otherwise the errors are scary.
4941  // But we must not parse them in conversion-type-ids and new-type-ids, since
4942  // those can be legitimately followed by a && operator.
4943  // (The same thing can in theory happen after a trailing-return-type, but
4944  // since those are a C++11 feature, there is no rejects-valid issue there.)
4945  if (Kind == tok::ampamp)
4946  return Lang.CPlusPlus11 || (TheContext != Declarator::ConversionIdContext &&
4947  TheContext != Declarator::CXXNewContext);
4948 
4949  return false;
4950 }
4951 
4952 // Indicates whether the given declarator is a pipe declarator.
4953 static bool isPipeDeclerator(const Declarator &D) {
4954  const unsigned NumTypes = D.getNumTypeObjects();
4955 
4956  for (unsigned Idx = 0; Idx != NumTypes; ++Idx)
4958  return true;
4959 
4960  return false;
4961 }
4962 
4963 /// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator
4964 /// is parsed by the function passed to it. Pass null, and the direct-declarator
4965 /// isn't parsed at all, making this function effectively parse the C++
4966 /// ptr-operator production.
4967 ///
4968 /// If the grammar of this construct is extended, matching changes must also be
4969 /// made to TryParseDeclarator and MightBeDeclarator, and possibly to
4970 /// isConstructorDeclarator.
4971 ///
4972 /// declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
4973 /// [C] pointer[opt] direct-declarator
4974 /// [C++] direct-declarator
4975 /// [C++] ptr-operator declarator
4976 ///
4977 /// pointer: [C99 6.7.5]
4978 /// '*' type-qualifier-list[opt]
4979 /// '*' type-qualifier-list[opt] pointer
4980 ///
4981 /// ptr-operator:
4982 /// '*' cv-qualifier-seq[opt]
4983 /// '&'
4984 /// [C++0x] '&&'
4985 /// [GNU] '&' restrict[opt] attributes[opt]
4986 /// [GNU?] '&&' restrict[opt] attributes[opt]
4987 /// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
4988 void Parser::ParseDeclaratorInternal(Declarator &D,
4989  DirectDeclParseFunction DirectDeclParser) {
4990  if (Diags.hasAllExtensionsSilenced())
4991  D.setExtension();
4992 
4993  // C++ member pointers start with a '::' or a nested-name.
4994  // Member pointers get special handling, since there's no place for the
4995  // scope spec in the generic path below.
4996  if (getLangOpts().CPlusPlus &&
4997  (Tok.is(tok::coloncolon) || Tok.is(tok::kw_decltype) ||
4998  (Tok.is(tok::identifier) &&
4999  (NextToken().is(tok::coloncolon) || NextToken().is(tok::less))) ||
5000  Tok.is(tok::annot_cxxscope))) {
5001  bool EnteringContext = D.getContext() == Declarator::FileContext ||
5003  CXXScopeSpec SS;
5004  ParseOptionalCXXScopeSpecifier(SS, nullptr, EnteringContext);
5005 
5006  if (SS.isNotEmpty()) {
5007  if (Tok.isNot(tok::star)) {
5008  // The scope spec really belongs to the direct-declarator.
5009  if (D.mayHaveIdentifier())
5010  D.getCXXScopeSpec() = SS;
5011  else
5012  AnnotateScopeToken(SS, true);
5013 
5014  if (DirectDeclParser)
5015  (this->*DirectDeclParser)(D);
5016  return;
5017  }
5018 
5019  SourceLocation Loc = ConsumeToken();
5020  D.SetRangeEnd(Loc);
5021  DeclSpec DS(AttrFactory);
5022  ParseTypeQualifierListOpt(DS);
5023  D.ExtendWithDeclSpec(DS);
5024 
5025  // Recurse to parse whatever is left.
5026  ParseDeclaratorInternal(D, DirectDeclParser);
5027 
5028  // Sema will have to catch (syntactically invalid) pointers into global
5029  // scope. It has to catch pointers into namespace scope anyway.
5031  DS.getLocEnd()),
5032  DS.getAttributes(),
5033  /* Don't replace range end. */SourceLocation());
5034  return;
5035  }
5036  }
5037 
5038  tok::TokenKind Kind = Tok.getKind();
5039 
5040  if (D.getDeclSpec().isTypeSpecPipe() && !isPipeDeclerator(D)) {
5041  DeclSpec DS(AttrFactory);
5042  ParseTypeQualifierListOpt(DS);
5043 
5044  D.AddTypeInfo(
5046  DS.getAttributes(), SourceLocation());
5047  }
5048 
5049  // Not a pointer, C++ reference, or block.
5050  if (!isPtrOperatorToken(Kind, getLangOpts(), D.getContext())) {
5051  if (DirectDeclParser)
5052  (this->*DirectDeclParser)(D);
5053  return;
5054  }
5055 
5056  // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference,
5057  // '&&' -> rvalue reference
5058  SourceLocation Loc = ConsumeToken(); // Eat the *, ^, & or &&.
5059  D.SetRangeEnd(Loc);
5060 
5061  if (Kind == tok::star || Kind == tok::caret) {
5062  // Is a pointer.
5063  DeclSpec DS(AttrFactory);
5064 
5065  // GNU attributes are not allowed here in a new-type-id, but Declspec and
5066  // C++11 attributes are allowed.
5067  unsigned Reqs = AR_CXX11AttributesParsed | AR_DeclspecAttributesParsed |
5069  ? AR_GNUAttributesParsed
5070  : AR_GNUAttributesParsedAndRejected);
5071  ParseTypeQualifierListOpt(DS, Reqs, true, !D.mayOmitIdentifier());
5072  D.ExtendWithDeclSpec(DS);
5073 
5074  // Recursively parse the declarator.
5075  ParseDeclaratorInternal(D, DirectDeclParser);
5076  if (Kind == tok::star)
5077  // Remember that we parsed a pointer type, and remember the type-quals.
5079  DS.getConstSpecLoc(),
5080  DS.getVolatileSpecLoc(),
5081  DS.getRestrictSpecLoc(),
5082  DS.getAtomicSpecLoc(),
5083  DS.getUnalignedSpecLoc()),
5084  DS.getAttributes(),
5085  SourceLocation());
5086  else
5087  // Remember that we parsed a Block type, and remember the type-quals.
5089  Loc),
5090  DS.getAttributes(),
5091  SourceLocation());
5092  } else {
5093  // Is a reference
5094  DeclSpec DS(AttrFactory);
5095 
5096  // Complain about rvalue references in C++03, but then go on and build
5097  // the declarator.
5098  if (Kind == tok::ampamp)
5099  Diag(Loc, getLangOpts().CPlusPlus11 ?
5100  diag::warn_cxx98_compat_rvalue_reference :
5101  diag::ext_rvalue_reference);
5102 
5103  // GNU-style and C++11 attributes are allowed here, as is restrict.
5104  ParseTypeQualifierListOpt(DS);
5105  D.ExtendWithDeclSpec(DS);
5106 
5107  // C++ 8.3.2p1: cv-qualified references are ill-formed except when the
5108  // cv-qualifiers are introduced through the use of a typedef or of a
5109  // template type argument, in which case the cv-qualifiers are ignored.
5112  Diag(DS.getConstSpecLoc(),
5113  diag::err_invalid_reference_qualifier_application) << "const";
5115  Diag(DS.getVolatileSpecLoc(),
5116  diag::err_invalid_reference_qualifier_application) << "volatile";
5117  // 'restrict' is permitted as an extension.
5119  Diag(DS.getAtomicSpecLoc(),
5120  diag::err_invalid_reference_qualifier_application) << "_Atomic";
5121  }
5122 
5123  // Recursively parse the declarator.
5124  ParseDeclaratorInternal(D, DirectDeclParser);
5125 
5126  if (D.getNumTypeObjects() > 0) {
5127  // C++ [dcl.ref]p4: There shall be no references to references.
5128  DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1);
5129  if (InnerChunk.Kind == DeclaratorChunk::Reference) {
5130  if (const IdentifierInfo *II = D.getIdentifier())
5131  Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
5132  << II;
5133  else
5134  Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
5135  << "type name";
5136 
5137  // Once we've complained about the reference-to-reference, we
5138  // can go ahead and build the (technically ill-formed)
5139  // declarator: reference collapsing will take care of it.
5140  }
5141  }
5142 
5143  // Remember that we parsed a reference type.
5145  Kind == tok::amp),
5146  DS.getAttributes(),
5147  SourceLocation());
5148  }
5149 }
5150 
5151 // When correcting from misplaced brackets before the identifier, the location
5152 // is saved inside the declarator so that other diagnostic messages can use
5153 // them. This extracts and returns that location, or returns the provided
5154 // location if a stored location does not exist.
5156  SourceLocation Loc) {
5157  if (D.getName().StartLocation.isInvalid() &&
5158  D.getName().EndLocation.isValid())
5159  return D.getName().EndLocation;
5160 
5161  return Loc;
5162 }
5163 
5164 /// ParseDirectDeclarator
5165 /// direct-declarator: [C99 6.7.5]
5166 /// [C99] identifier
5167 /// '(' declarator ')'
5168 /// [GNU] '(' attributes declarator ')'
5169 /// [C90] direct-declarator '[' constant-expression[opt] ']'
5170 /// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
5171 /// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
5172 /// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
5173 /// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
5174 /// [C++11] direct-declarator '[' constant-expression[opt] ']'
5175 /// attribute-specifier-seq[opt]
5176 /// direct-declarator '(' parameter-type-list ')'
5177 /// direct-declarator '(' identifier-list[opt] ')'
5178 /// [GNU] direct-declarator '(' parameter-forward-declarations
5179 /// parameter-type-list[opt] ')'
5180 /// [C++] direct-declarator '(' parameter-declaration-clause ')'
5181 /// cv-qualifier-seq[opt] exception-specification[opt]
5182 /// [C++11] direct-declarator '(' parameter-declaration-clause ')'
5183 /// attribute-specifier-seq[opt] cv-qualifier-seq[opt]
5184 /// ref-qualifier[opt] exception-specification[opt]
5185 /// [C++] declarator-id
5186 /// [C++11] declarator-id attribute-specifier-seq[opt]
5187 ///
5188 /// declarator-id: [C++ 8]
5189 /// '...'[opt] id-expression
5190 /// '::'[opt] nested-name-specifier[opt] type-name
5191 ///
5192 /// id-expression: [C++ 5.1]
5193 /// unqualified-id
5194 /// qualified-id
5195 ///
5196 /// unqualified-id: [C++ 5.1]
5197 /// identifier
5198 /// operator-function-id
5199 /// conversion-function-id
5200 /// '~' class-name
5201 /// template-id
5202 ///
5203 /// Note, any additional constructs added here may need corresponding changes
5204 /// in isConstructorDeclarator.
5205 void Parser::ParseDirectDeclarator(Declarator &D) {
5206  DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec());
5207 
5208  if (getLangOpts().CPlusPlus && D.mayHaveIdentifier()) {
5209  // Don't parse FOO:BAR as if it were a typo for FOO::BAR inside a class, in
5210  // this context it is a bitfield. Also in range-based for statement colon
5211  // may delimit for-range-declaration.
5215  getLangOpts().CPlusPlus11));
5216 
5217  // ParseDeclaratorInternal might already have parsed the scope.
5218  if (D.getCXXScopeSpec().isEmpty()) {
5219  bool EnteringContext = D.getContext() == Declarator::FileContext ||
5221  ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec(), nullptr,
5222  EnteringContext);
5223  }
5224 
5225  if (D.getCXXScopeSpec().isValid()) {
5227  D.getCXXScopeSpec()))
5228  // Change the declaration context for name lookup, until this function
5229  // is exited (and the declarator has been parsed).
5230  DeclScopeObj.EnterDeclaratorScope();
5231  }
5232 
5233  // C++0x [dcl.fct]p14:
5234  // There is a syntactic ambiguity when an ellipsis occurs at the end of a
5235  // parameter-declaration-clause without a preceding comma. In this case,
5236  // the ellipsis is parsed as part of the abstract-declarator if the type
5237  // of the parameter either names a template parameter pack that has not
5238  // been expanded or contains auto; otherwise, it is parsed as part of the
5239  // parameter-declaration-clause.
5240  if (Tok.is(tok::ellipsis) && D.getCXXScopeSpec().isEmpty() &&
5244  NextToken().is(tok::r_paren) &&
5245  !D.hasGroupingParens() &&
5246  !Actions.containsUnexpandedParameterPacks(D) &&
5247  D.getDeclSpec().getTypeSpecType() != TST_auto)) {
5248  SourceLocation EllipsisLoc = ConsumeToken();
5249  if (isPtrOperatorToken(Tok.getKind(), getLangOpts(), D.getContext())) {
5250  // The ellipsis was put in the wrong place. Recover, and explain to
5251  // the user what they should have done.
5252  ParseDeclarator(D);
5253  if (EllipsisLoc.isValid())
5254  DiagnoseMisplacedEllipsisInDeclarator(EllipsisLoc, D);
5255  return;
5256  } else
5257  D.setEllipsisLoc(EllipsisLoc);
5258 
5259  // The ellipsis can't be followed by a parenthesized declarator. We
5260  // check for that in ParseParenDeclarator, after we have disambiguated
5261  // the l_paren token.
5262  }
5263 
5264  if (Tok.isOneOf(tok::identifier, tok::kw_operator, tok::annot_template_id,
5265  tok::tilde)) {
5266  // We found something that indicates the start of an unqualified-id.
5267  // Parse that unqualified-id.
5268  bool AllowConstructorName;
5269  if (D.getDeclSpec().hasTypeSpecifier())
5270  AllowConstructorName = false;
5271  else if (D.getCXXScopeSpec().isSet())
5272  AllowConstructorName =
5275  else
5276  AllowConstructorName = (D.getContext() == Declarator::MemberContext);
5277 
5278  SourceLocation TemplateKWLoc;
5279  bool HadScope = D.getCXXScopeSpec().isValid();
5281  /*EnteringContext=*/true,
5282  /*AllowDestructorName=*/true, AllowConstructorName,
5283  nullptr, TemplateKWLoc, D.getName()) ||
5284  // Once we're past the identifier, if the scope was bad, mark the
5285  // whole declarator bad.
5286  D.getCXXScopeSpec().isInvalid()) {
5287  D.SetIdentifier(nullptr, Tok.getLocation());
5288  D.setInvalidType(true);
5289  } else {
5290  // ParseUnqualifiedId might have parsed a scope specifier during error
5291  // recovery. If it did so, enter that scope.
5292  if (!HadScope && D.getCXXScopeSpec().isValid() &&
5294  D.getCXXScopeSpec()))
5295  DeclScopeObj.EnterDeclaratorScope();
5296 
5297  // Parsed the unqualified-id; update range information and move along.
5298  if (D.getSourceRange().getBegin().isInvalid())
5301  }
5302  goto PastIdentifier;
5303  }
5304 
5305  if (D.getCXXScopeSpec().isNotEmpty()) {
5306  // We have a scope specifier but no following unqualified-id.
5308  diag::err_expected_unqualified_id)
5309  << /*C++*/1;
5310  D.SetIdentifier(nullptr, Tok.getLocation());
5311  goto PastIdentifier;
5312  }
5313  } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
5314  assert(!getLangOpts().CPlusPlus &&
5315  "There's a C++-specific check for tok::identifier above");
5316  assert(Tok.getIdentifierInfo() && "Not an identifier?");
5318  D.SetRangeEnd(Tok.getLocation());
5319  ConsumeToken();
5320  goto PastIdentifier;
5321  } else if (Tok.is(tok::identifier) && D.diagnoseIdentifier()) {
5322  // A virt-specifier isn't treated as an identifier if it appears after a
5323  // trailing-return-type.
5325  !isCXX11VirtSpecifier(Tok)) {
5326  Diag(Tok.getLocation(), diag::err_unexpected_unqualified_id)
5328  D.SetIdentifier(nullptr, Tok.getLocation());
5329  ConsumeToken();
5330  goto PastIdentifier;
5331  }
5332  }
5333 
5334  if (Tok.is(tok::l_paren)) {
5335  // direct-declarator: '(' declarator ')'
5336  // direct-declarator: '(' attributes declarator ')'
5337  // Example: 'char (*X)' or 'int (*XX)(void)'
5338  ParseParenDeclarator(D);
5339 
5340  // If the declarator was parenthesized, we entered the declarator
5341  // scope when parsing the parenthesized declarator, then exited
5342  // the scope already. Re-enter the scope, if we need to.
5343  if (D.getCXXScopeSpec().isSet()) {
5344  // If there was an error parsing parenthesized declarator, declarator
5345  // scope may have been entered before. Don't do it again.
5346  if (!D.isInvalidType() &&
5348  D.getCXXScopeSpec()))
5349  // Change the declaration context for name lookup, until this function
5350  // is exited (and the declarator has been parsed).
5351  DeclScopeObj.EnterDeclaratorScope();
5352  }
5353  } else if (D.mayOmitIdentifier()) {
5354  // This could be something simple like "int" (in which case the declarator
5355  // portion is empty), if an abstract-declarator is allowed.
5356  D.SetIdentifier(nullptr, Tok.getLocation());
5357 
5358  // The grammar for abstract-pack-declarator does not allow grouping parens.
5359  // FIXME: Revisit this once core issue 1488 is resolved.
5360  if (D.hasEllipsis() && D.hasGroupingParens())
5362  diag::ext_abstract_pack_declarator_parens);
5363  } else {
5364  if (Tok.getKind() == tok::annot_pragma_parser_crash)
5365  LLVM_BUILTIN_TRAP;
5366  if (Tok.is(tok::l_square))
5367  return ParseMisplacedBracketDeclarator(D);
5370  diag::err_expected_member_name_or_semi)
5371  << (D.getDeclSpec().isEmpty() ? SourceRange()
5372  : D.getDeclSpec().getSourceRange());
5373  } else if (getLangOpts().CPlusPlus) {
5374  if (Tok.isOneOf(tok::period, tok::arrow))
5375  Diag(Tok, diag::err_invalid_operator_on_type) << Tok.is(tok::arrow);
5376  else {
5378  if (Tok.isAtStartOfLine() && Loc.isValid())
5379  Diag(PP.getLocForEndOfToken(Loc), diag::err_expected_unqualified_id)
5380  << getLangOpts().CPlusPlus;
5381  else
5383  diag::err_expected_unqualified_id)
5384  << getLangOpts().CPlusPlus;
5385  }
5386  } else {
5388  diag::err_expected_either)
5389  << tok::identifier << tok::l_paren;
5390  }
5391  D.SetIdentifier(nullptr, Tok.getLocation());
5392  D.setInvalidType(true);
5393  }
5394 
5395  PastIdentifier:
5396  assert(D.isPastIdentifier() &&
5397  "Haven't past the location of the identifier yet?");
5398 
5399  // Don't parse attributes unless we have parsed an unparenthesized name.
5400  if (D.hasName() && !D.getNumTypeObjects())
5401  MaybeParseCXX11Attributes(D);
5402 
5403  while (1) {
5404  if (Tok.is(tok::l_paren)) {
5405  // Enter function-declaration scope, limiting any declarators to the
5406  // function prototype scope, including parameter declarators.
5407  ParseScope PrototypeScope(this,
5411 
5412  // The paren may be part of a C++ direct initializer, eg. "int x(1);".
5413  // In such a case, check if we actually have a function declarator; if it
5414  // is not, the declarator has been fully parsed.
5415  bool IsAmbiguous = false;
5417  // The name of the declarator, if any, is tentatively declared within
5418  // a possible direct initializer.
5419  TentativelyDeclaredIdentifiers.push_back(D.getIdentifier());
5420  bool IsFunctionDecl = isCXXFunctionDeclarator(&IsAmbiguous);
5421  TentativelyDeclaredIdentifiers.pop_back();
5422  if (!IsFunctionDecl)
5423  break;
5424  }
5425  ParsedAttributes attrs(AttrFactory);
5426  BalancedDelimiterTracker T(*this, tok::l_paren);
5427  T.consumeOpen();
5428  ParseFunctionDeclarator(D, attrs, T, IsAmbiguous);
5429  PrototypeScope.Exit();
5430  } else if (Tok.is(tok::l_square)) {
5431  ParseBracketDeclarator(D);
5432  } else {
5433  break;
5434  }
5435  }
5436 }
5437 
5438 /// ParseParenDeclarator - We parsed the declarator D up to a paren. This is
5439 /// only called before the identifier, so these are most likely just grouping
5440 /// parens for precedence. If we find that these are actually function
5441 /// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator.
5442 ///
5443 /// direct-declarator:
5444 /// '(' declarator ')'
5445 /// [GNU] '(' attributes declarator ')'
5446 /// direct-declarator '(' parameter-type-list ')'
5447 /// direct-declarator '(' identifier-list[opt] ')'
5448 /// [GNU] direct-declarator '(' parameter-forward-declarations
5449 /// parameter-type-list[opt] ')'
5450 ///
5451 void Parser::ParseParenDeclarator(Declarator &D) {
5452  BalancedDelimiterTracker T(*this, tok::l_paren);
5453  T.consumeOpen();
5454 
5455  assert(!D.isPastIdentifier() && "Should be called before passing identifier");
5456 
5457  // Eat any attributes before we look at whether this is a grouping or function
5458  // declarator paren. If this is a grouping paren, the attribute applies to
5459  // the type being built up, for example:
5460  // int (__attribute__(()) *x)(long y)
5461  // If this ends up not being a grouping paren, the attribute applies to the
5462  // first argument, for example:
5463  // int (__attribute__(()) int x)
5464  // In either case, we need to eat any attributes to be able to determine what
5465  // sort of paren this is.
5466  //
5467  ParsedAttributes attrs(AttrFactory);
5468  bool RequiresArg = false;
5469  if (Tok.is(tok::kw___attribute)) {
5470  ParseGNUAttributes(attrs);
5471 
5472  // We require that the argument list (if this is a non-grouping paren) be
5473  // present even if the attribute list was empty.
5474  RequiresArg = true;
5475  }
5476 
5477  // Eat any Microsoft extensions.
5478  ParseMicrosoftTypeAttributes(attrs);
5479 
5480  // Eat any Borland extensions.
5481  if (Tok.is(tok::kw___pascal))
5482  ParseBorlandTypeAttributes(attrs);
5483 
5484  // If we haven't past the identifier yet (or where the identifier would be
5485  // stored, if this is an abstract declarator), then this is probably just
5486  // grouping parens. However, if this could be an abstract-declarator, then
5487  // this could also be the start of function arguments (consider 'void()').
5488  bool isGrouping;
5489 
5490  if (!D.mayOmitIdentifier()) {
5491  // If this can't be an abstract-declarator, this *must* be a grouping
5492  // paren, because we haven't seen the identifier yet.
5493  isGrouping = true;
5494  } else if (Tok.is(tok::r_paren) || // 'int()' is a function.
5495  (getLangOpts().CPlusPlus && Tok.is(tok::ellipsis) &&
5496  NextToken().is(tok::r_paren)) || // C++ int(...)
5497  isDeclarationSpecifier() || // 'int(int)' is a function.
5498  isCXX11AttributeSpecifier()) { // 'int([[]]int)' is a function.
5499  // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is
5500  // considered to be a type, not a K&R identifier-list.
5501  isGrouping = false;
5502  } else {
5503  // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'.
5504  isGrouping = true;
5505  }
5506 
5507  // If this is a grouping paren, handle:
5508  // direct-declarator: '(' declarator ')'
5509  // direct-declarator: '(' attributes declarator ')'
5510  if (isGrouping) {
5511  SourceLocation EllipsisLoc = D.getEllipsisLoc();
5513 
5514  bool hadGroupingParens = D.hasGroupingParens();
5515  D.setGroupingParens(true);
5516  ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
5517  // Match the ')'.
5518  T.consumeClose();
5519  D.AddTypeInfo(DeclaratorChunk::getParen(T.getOpenLocation(),
5520  T.getCloseLocation()),
5521  attrs, T.getCloseLocation());
5522 
5523  D.setGroupingParens(hadGroupingParens);
5524 
5525  // An ellipsis cannot be placed outside parentheses.
5526  if (EllipsisLoc.isValid())
5527  DiagnoseMisplacedEllipsisInDeclarator(EllipsisLoc, D);
5528 
5529  return;
5530  }
5531 
5532  // Okay, if this wasn't a grouping paren, it must be the start of a function
5533  // argument list. Recognize that this declarator will never have an
5534  // identifier (and remember where it would have been), then call into
5535  // ParseFunctionDeclarator to handle of argument list.
5536  D.SetIdentifier(nullptr, Tok.getLocation());
5537 
5538  // Enter function-declaration scope, limiting any declarators to the
5539  // function prototype scope, including parameter declarators.
5540  ParseScope PrototypeScope(this,
5544  ParseFunctionDeclarator(D, attrs, T, false, RequiresArg);
5545  PrototypeScope.Exit();
5546 }
5547 
5548 /// ParseFunctionDeclarator - We are after the identifier and have parsed the
5549 /// declarator D up to a paren, which indicates that we are parsing function
5550 /// arguments.
5551 ///
5552 /// If FirstArgAttrs is non-null, then the caller parsed those arguments
5553 /// immediately after the open paren - they should be considered to be the
5554 /// first argument of a parameter.
5555 ///
5556 /// If RequiresArg is true, then the first argument of the function is required
5557 /// to be present and required to not be an identifier list.
5558 ///
5559 /// For C++, after the parameter-list, it also parses the cv-qualifier-seq[opt],
5560 /// (C++11) ref-qualifier[opt], exception-specification[opt],
5561 /// (C++11) attribute-specifier-seq[opt], and (C++11) trailing-return-type[opt].
5562 ///
5563 /// [C++11] exception-specification:
5564 /// dynamic-exception-specification
5565 /// noexcept-specification
5566 ///
5567 void Parser::ParseFunctionDeclarator(Declarator &D,
5568  ParsedAttributes &FirstArgAttrs,
5569  BalancedDelimiterTracker &Tracker,
5570  bool IsAmbiguous,
5571  bool RequiresArg) {
5572  assert(getCurScope()->isFunctionPrototypeScope() &&
5573  "Should call from a Function scope");
5574  // lparen is already consumed!
5575  assert(D.isPastIdentifier() && "Should not call before identifier!");
5576 
5577  // This should be true when the function has typed arguments.
5578  // Otherwise, it is treated as a K&R-style function.
5579  bool HasProto = false;
5580  // Build up an array of information about the parsed arguments.
5582  // Remember where we see an ellipsis, if any.
5583  SourceLocation EllipsisLoc;
5584 
5585  DeclSpec DS(AttrFactory);
5586  bool RefQualifierIsLValueRef = true;
5587  SourceLocation RefQualifierLoc;
5588  SourceLocation ConstQualifierLoc;
5589  SourceLocation VolatileQualifierLoc;
5590  SourceLocation RestrictQualifierLoc;
5592  SourceRange ESpecRange;
5593  SmallVector<ParsedType, 2> DynamicExceptions;
5594  SmallVector<SourceRange, 2> DynamicExceptionRanges;
5595  ExprResult NoexceptExpr;
5596  CachedTokens *ExceptionSpecTokens = nullptr;
5597  ParsedAttributes FnAttrs(AttrFactory);
5598  TypeResult TrailingReturnType;
5599 
5600  /* LocalEndLoc is the end location for the local FunctionTypeLoc.
5601  EndLoc is the end location for the function declarator.
5602  They differ for trailing return types. */
5603  SourceLocation StartLoc, LocalEndLoc, EndLoc;
5604  SourceLocation LParenLoc, RParenLoc;
5605  LParenLoc = Tracker.getOpenLocation();
5606  StartLoc = LParenLoc;
5607 
5608  if (isFunctionDeclaratorIdentifierList()) {
5609  if (RequiresArg)
5610  Diag(Tok, diag::err_argument_required_after_attribute);
5611 
5612  ParseFunctionDeclaratorIdentifierList(D, ParamInfo);
5613 
5614  Tracker.consumeClose();
5615  RParenLoc = Tracker.getCloseLocation();
5616  LocalEndLoc = RParenLoc;
5617  EndLoc = RParenLoc;
5618  } else {
5619  if (Tok.isNot(tok::r_paren))
5620  ParseParameterDeclarationClause(D, FirstArgAttrs, ParamInfo,
5621  EllipsisLoc);
5622  else if (RequiresArg)
5623  Diag(Tok, diag::err_argument_required_after_attribute);
5624 
5625  HasProto = ParamInfo.size() || getLangOpts().CPlusPlus;
5626 
5627  // If we have the closing ')', eat it.
5628  Tracker.consumeClose();
5629  RParenLoc = Tracker.getCloseLocation();
5630  LocalEndLoc = RParenLoc;
5631  EndLoc = RParenLoc;
5632 
5633  if (getLangOpts().CPlusPlus) {
5634  // FIXME: Accept these components in any order, and produce fixits to
5635  // correct the order if the user gets it wrong. Ideally we should deal
5636  // with the pure-specifier in the same way.
5637 
5638  // Parse cv-qualifier-seq[opt].
5639  ParseTypeQualifierListOpt(DS, AR_NoAttributesParsed,
5640  /*AtomicAllowed*/ false);
5641  if (!DS.getSourceRange().getEnd().isInvalid()) {
5642  EndLoc = DS.getSourceRange().getEnd();
5643  ConstQualifierLoc = DS.getConstSpecLoc();
5644  VolatileQualifierLoc = DS.getVolatileSpecLoc();
5645  RestrictQualifierLoc = DS.getRestrictSpecLoc();
5646  }
5647 
5648  // Parse ref-qualifier[opt].
5649  if (ParseRefQualifier(RefQualifierIsLValueRef, RefQualifierLoc))
5650  EndLoc = RefQualifierLoc;
5651 
5652  // C++11 [expr.prim.general]p3:
5653  // If a declaration declares a member function or member function
5654  // template of a class X, the expression this is a prvalue of type
5655  // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
5656  // and the end of the function-definition, member-declarator, or
5657  // declarator.
5658  // FIXME: currently, "static" case isn't handled correctly.
5659  bool IsCXX11MemberFunction =
5660  getLangOpts().CPlusPlus11 &&
5665  D.getCXXScopeSpec().isValid() &&
5666  Actions.CurContext->isRecord());
5667  Sema::CXXThisScopeRAII ThisScope(Actions,
5668  dyn_cast<CXXRecordDecl>(Actions.CurContext),
5669  DS.getTypeQualifiers() |
5671  !getLangOpts().CPlusPlus14
5672  ? Qualifiers::Const : 0),
5673  IsCXX11MemberFunction);
5674 
5675  // Parse exception-specification[opt].
5676  bool Delayed = D.isFirstDeclarationOfMember() &&
5678  if (Delayed && Actions.isLibstdcxxEagerExceptionSpecHack(D) &&
5679  GetLookAheadToken(0).is(tok::kw_noexcept) &&
5680  GetLookAheadToken(1).is(tok::l_paren) &&
5681  GetLookAheadToken(2).is(tok::kw_noexcept) &&
5682  GetLookAheadToken(3).is(tok::l_paren) &&
5683  GetLookAheadToken(4).is(tok::identifier) &&
5684  GetLookAheadToken(4).getIdentifierInfo()->isStr("swap")) {
5685  // HACK: We've got an exception-specification
5686  // noexcept(noexcept(swap(...)))
5687  // or
5688  // noexcept(noexcept(swap(...)) && noexcept(swap(...)))
5689  // on a 'swap' member function. This is a libstdc++ bug; the lookup
5690  // for 'swap' will only find the function we're currently declaring,
5691  // whereas it expects to find a non-member swap through ADL. Turn off
5692  // delayed parsing to give it a chance to find what it expects.
5693  Delayed = false;
5694  }
5695  ESpecType = tryParseExceptionSpecification(Delayed,
5696  ESpecRange,
5697  DynamicExceptions,
5698  DynamicExceptionRanges,
5699  NoexceptExpr,
5700  ExceptionSpecTokens);
5701  if (ESpecType != EST_None)
5702  EndLoc = ESpecRange.getEnd();
5703 
5704  // Parse attribute-specifier-seq[opt]. Per DR 979 and DR 1297, this goes
5705  // after the exception-specification.
5706  MaybeParseCXX11Attributes(FnAttrs);
5707 
5708  // Parse trailing-return-type[opt].
5709  LocalEndLoc = EndLoc;
5710  if (getLangOpts().CPlusPlus11 && Tok.is(tok::arrow)) {
5711  Diag(Tok, diag::warn_cxx98_compat_trailing_return_type);
5712  if (D.getDeclSpec().getTypeSpecType() == TST_auto)
5713  StartLoc = D.getDeclSpec().getTypeSpecTypeLoc();
5714  LocalEndLoc = Tok.getLocation();
5715  SourceRange Range;
5716  TrailingReturnType = ParseTrailingReturnType(Range);
5717  EndLoc = Range.getEnd();
5718  }
5719  }
5720  }
5721 
5722  // Remember that we parsed a function type, and remember the attributes.
5724  IsAmbiguous,
5725  LParenLoc,
5726  ParamInfo.data(), ParamInfo.size(),
5727  EllipsisLoc, RParenLoc,
5728  DS.getTypeQualifiers(),
5729  RefQualifierIsLValueRef,
5730  RefQualifierLoc, ConstQualifierLoc,
5731  VolatileQualifierLoc,
5732  RestrictQualifierLoc,
5733  /*MutableLoc=*/SourceLocation(),
5734  ESpecType, ESpecRange,
5735  DynamicExceptions.data(),
5736  DynamicExceptionRanges.data(),
5737  DynamicExceptions.size(),
5738  NoexceptExpr.isUsable() ?
5739  NoexceptExpr.get() : nullptr,
5740  ExceptionSpecTokens,
5741  StartLoc, LocalEndLoc, D,
5742  TrailingReturnType),
5743  FnAttrs, EndLoc);
5744 }
5745 
5746 /// ParseRefQualifier - Parses a member function ref-qualifier. Returns
5747 /// true if a ref-qualifier is found.
5748 bool Parser::ParseRefQualifier(bool &RefQualifierIsLValueRef,
5749  SourceLocation &RefQualifierLoc) {
5750  if (Tok.isOneOf(tok::amp, tok::ampamp)) {
5751  Diag(Tok, getLangOpts().CPlusPlus11 ?
5752  diag::warn_cxx98_compat_ref_qualifier :
5753  diag::ext_ref_qualifier);
5754 
5755  RefQualifierIsLValueRef = Tok.is(tok::amp);
5756  RefQualifierLoc = ConsumeToken();
5757  return true;
5758  }
5759  return false;
5760 }
5761 
5762 /// isFunctionDeclaratorIdentifierList - This parameter list may have an
5763 /// identifier list form for a K&R-style function: void foo(a,b,c)
5764 ///
5765 /// Note that identifier-lists are only allowed for normal declarators, not for
5766 /// abstract-declarators.
5767 bool Parser::isFunctionDeclaratorIdentifierList() {
5768  return !getLangOpts().CPlusPlus
5769  && Tok.is(tok::identifier)
5770  && !TryAltiVecVectorToken()
5771  // K&R identifier lists can't have typedefs as identifiers, per C99
5772  // 6.7.5.3p11.
5773  && (TryAnnotateTypeOrScopeToken() || !Tok.is(tok::annot_typename))
5774  // Identifier lists follow a really simple grammar: the identifiers can
5775  // be followed *only* by a ", identifier" or ")". However, K&R
5776  // identifier lists are really rare in the brave new modern world, and
5777  // it is very common for someone to typo a type in a non-K&R style
5778  // list. If we are presented with something like: "void foo(intptr x,
5779  // float y)", we don't want to start parsing the function declarator as
5780  // though it is a K&R style declarator just because intptr is an
5781  // invalid type.
5782  //
5783  // To handle this, we check to see if the token after the first
5784  // identifier is a "," or ")". Only then do we parse it as an
5785  // identifier list.
5786  && (NextToken().is(tok::comma) || NextToken().is(tok::r_paren));
5787 }
5788 
5789 /// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator
5790 /// we found a K&R-style identifier list instead of a typed parameter list.
5791 ///
5792 /// After returning, ParamInfo will hold the parsed parameters.
5793 ///
5794 /// identifier-list: [C99 6.7.5]
5795 /// identifier
5796 /// identifier-list ',' identifier
5797 ///
5798 void Parser::ParseFunctionDeclaratorIdentifierList(
5799  Declarator &D,
5801  // If there was no identifier specified for the declarator, either we are in
5802  // an abstract-declarator, or we are in a parameter declarator which was found
5803  // to be abstract. In abstract-declarators, identifier lists are not valid:
5804  // diagnose this.
5805  if (!D.getIdentifier())
5806  Diag(Tok, diag::ext_ident_list_in_param);
5807 
5808  // Maintain an efficient lookup of params we have seen so far.
5809  llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
5810 
5811  do {
5812  // If this isn't an identifier, report the error and skip until ')'.
5813  if (Tok.isNot(tok::identifier)) {
5814  Diag(Tok, diag::err_expected) << tok::identifier;
5815  SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch);
5816  // Forget we parsed anything.
5817  ParamInfo.clear();
5818  return;
5819  }
5820 
5821  IdentifierInfo *ParmII = Tok.getIdentifierInfo();
5822 
5823  // Reject 'typedef int y; int test(x, y)', but continue parsing.
5824  if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope()))
5825  Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;
5826 
5827  // Verify that the argument identifier has not already been mentioned.
5828  if (!ParamsSoFar.insert(ParmII).second) {
5829  Diag(Tok, diag::err_param_redefinition) << ParmII;
5830  } else {
5831  // Remember this identifier in ParamInfo.
5832  ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
5833  Tok.getLocation(),
5834  nullptr));
5835  }
5836 
5837  // Eat the identifier.
5838  ConsumeToken();
5839  // The list continues if we see a comma.
5840  } while (TryConsumeToken(tok::comma));
5841 }
5842 
5843 /// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list
5844 /// after the opening parenthesis. This function will not parse a K&R-style
5845 /// identifier list.
5846 ///
5847 /// D is the declarator being parsed. If FirstArgAttrs is non-null, then the
5848 /// caller parsed those arguments immediately after the open paren - they should
5849 /// be considered to be part of the first parameter.
5850 ///
5851 /// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will
5852 /// be the location of the ellipsis, if any was parsed.
5853 ///
5854 /// parameter-type-list: [C99 6.7.5]
5855 /// parameter-list
5856 /// parameter-list ',' '...'
5857 /// [C++] parameter-list '...'
5858 ///
5859 /// parameter-list: [C99 6.7.5]
5860 /// parameter-declaration
5861 /// parameter-list ',' parameter-declaration
5862 ///
5863 /// parameter-declaration: [C99 6.7.5]
5864 /// declaration-specifiers declarator
5865 /// [C++] declaration-specifiers declarator '=' assignment-expression
5866 /// [C++11] initializer-clause
5867 /// [GNU] declaration-specifiers declarator attributes
5868 /// declaration-specifiers abstract-declarator[opt]
5869 /// [C++] declaration-specifiers abstract-declarator[opt]
5870 /// '=' assignment-expression
5871 /// [GNU] declaration-specifiers abstract-declarator[opt] attributes
5872 /// [C++11] attribute-specifier-seq parameter-declaration
5873 ///
5874 void Parser::ParseParameterDeclarationClause(
5875  Declarator &D,
5876  ParsedAttributes &FirstArgAttrs,
5878  SourceLocation &EllipsisLoc) {
5879  do {
5880  // FIXME: Issue a diagnostic if we parsed an attribute-specifier-seq
5881  // before deciding this was a parameter-declaration-clause.
5882  if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
5883  break;
5884 
5885  // Parse the declaration-specifiers.
5886  // Just use the ParsingDeclaration "scope" of the declarator.
5887  DeclSpec DS(AttrFactory);
5888 
5889  // Parse any C++11 attributes.
5890  MaybeParseCXX11Attributes(DS.getAttributes());
5891 
5892  // Skip any Microsoft attributes before a param.
5893  MaybeParseMicrosoftAttributes(DS.getAttributes());
5894 
5895  SourceLocation DSStart = Tok.getLocation();
5896 
5897  // If the caller parsed attributes for the first argument, add them now.
5898  // Take them so that we only apply the attributes to the first parameter.
5899  // FIXME: If we can leave the attributes in the token stream somehow, we can
5900  // get rid of a parameter (FirstArgAttrs) and this statement. It might be
5901  // too much hassle.
5902  DS.takeAttributesFrom(FirstArgAttrs);
5903 
5904  ParseDeclarationSpecifiers(DS);
5905 
5906 
5907  // Parse the declarator. This is "PrototypeContext" or
5908  // "LambdaExprParameterContext", because we must accept either
5909  // 'declarator' or 'abstract-declarator' here.
5910  Declarator ParmDeclarator(DS,
5914  ParseDeclarator(ParmDeclarator);
5915 
5916  // Parse GNU attributes, if present.
5917  MaybeParseGNUAttributes(ParmDeclarator);
5918 
5919  // Remember this parsed parameter in ParamInfo.
5920  IdentifierInfo *ParmII = ParmDeclarator.getIdentifier();
5921 
5922  // DefArgToks is used when the parsing of default arguments needs
5923  // to be delayed.
5924  CachedTokens *DefArgToks = nullptr;
5925 
5926  // If no parameter was specified, verify that *something* was specified,
5927  // otherwise we have a missing type and identifier.
5928  if (DS.isEmpty() && ParmDeclarator.getIdentifier() == nullptr &&
5929  ParmDeclarator.getNumTypeObjects() == 0) {
5930  // Completely missing, emit error.
5931  Diag(DSStart, diag::err_missing_param);
5932  } else {
5933  // Otherwise, we have something. Add it and let semantic analysis try
5934  // to grok it and add the result to the ParamInfo we are building.
5935 
5936  // Last chance to recover from a misplaced ellipsis in an attempted
5937  // parameter pack declaration.
5938  if (Tok.is(tok::ellipsis) &&
5939  (NextToken().isNot(tok::r_paren) ||
5940  (!ParmDeclarator.getEllipsisLoc().isValid() &&
5941  !Actions.isUnexpandedParameterPackPermitted())) &&
5942  Actions.containsUnexpandedParameterPacks(ParmDeclarator))
5943  DiagnoseMisplacedEllipsisInDeclarator(ConsumeToken(), ParmDeclarator);
5944 
5945  // Inform the actions module about the parameter declarator, so it gets
5946  // added to the current scope.
5947  Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDeclarator);
5948  // Parse the default argument, if any. We parse the default
5949  // arguments in all dialects; the semantic analysis in
5950  // ActOnParamDefaultArgument will reject the default argument in
5951  // C.
5952  if (Tok.is(tok::equal)) {
5953  SourceLocation EqualLoc = Tok.getLocation();
5954 
5955  // Parse the default argument
5957  // If we're inside a class definition, cache the tokens
5958  // corresponding to the default argument. We'll actually parse
5959  // them when we see the end of the class definition.
5960  // FIXME: Can we use a smart pointer for Toks?
5961  DefArgToks = new CachedTokens;
5962 
5963  SourceLocation ArgStartLoc = NextToken().getLocation();
5964  if (!ConsumeAndStoreInitializer(*DefArgToks, CIK_DefaultArgument)) {
5965  delete DefArgToks;
5966  DefArgToks = nullptr;
5967  Actions.ActOnParamDefaultArgumentError(Param, EqualLoc);
5968  } else {
5969  Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc,
5970  ArgStartLoc);
5971  }
5972  } else {
5973  // Consume the '='.
5974  ConsumeToken();
5975 
5976  // The argument isn't actually potentially evaluated unless it is
5977  // used.
5978  EnterExpressionEvaluationContext Eval(Actions,
5980  Param);
5981 
5982  ExprResult DefArgResult;
5983  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
5984  Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
5985  DefArgResult = ParseBraceInitializer();
5986  } else
5987  DefArgResult = ParseAssignmentExpression();
5988  DefArgResult = Actions.CorrectDelayedTyposInExpr(DefArgResult);
5989  if (DefArgResult.isInvalid()) {
5990  Actions.ActOnParamDefaultArgumentError(Param, EqualLoc);
5991  SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch);
5992  } else {
5993  // Inform the actions module about the default argument
5994  Actions.ActOnParamDefaultArgument(Param, EqualLoc,
5995  DefArgResult.get());
5996  }
5997  }
5998  }
5999 
6000  ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
6001  ParmDeclarator.getIdentifierLoc(),
6002  Param, DefArgToks));
6003  }
6004 
6005  if (TryConsumeToken(tok::ellipsis, EllipsisLoc)) {
6006  if (!getLangOpts().CPlusPlus) {
6007  // We have ellipsis without a preceding ',', which is ill-formed
6008  // in C. Complain and provide the fix.
6009  Diag(EllipsisLoc, diag::err_missing_comma_before_ellipsis)
6010  << FixItHint::CreateInsertion(EllipsisLoc, ", ");
6011  } else if (ParmDeclarator.getEllipsisLoc().isValid() ||
6012  Actions.containsUnexpandedParameterPacks(ParmDeclarator)) {
6013  // It looks like this was supposed to be a parameter pack. Warn and
6014  // point out where the ellipsis should have gone.
6015  SourceLocation ParmEllipsis = ParmDeclarator.getEllipsisLoc();
6016  Diag(EllipsisLoc, diag::warn_misplaced_ellipsis_vararg)
6017  << ParmEllipsis.isValid() << ParmEllipsis;
6018  if (ParmEllipsis.isValid()) {
6019  Diag(ParmEllipsis,
6020  diag::note_misplaced_ellipsis_vararg_existing_ellipsis);
6021  } else {
6022  Diag(ParmDeclarator.getIdentifierLoc(),
6023  diag::note_misplaced_ellipsis_vararg_add_ellipsis)
6024  << FixItHint::CreateInsertion(ParmDeclarator.getIdentifierLoc(),
6025  "...")
6026  << !ParmDeclarator.hasName();
6027  }
6028  Diag(EllipsisLoc, diag::note_misplaced_ellipsis_vararg_add_comma)
6029  << FixItHint::CreateInsertion(EllipsisLoc, ", ");
6030  }
6031 
6032  // We can't have any more parameters after an ellipsis.
6033  break;
6034  }
6035 
6036  // If the next token is a comma, consume it and keep reading arguments.
6037  } while (TryConsumeToken(tok::comma));
6038 }
6039 
6040 /// [C90] direct-declarator '[' constant-expression[opt] ']'
6041 /// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
6042 /// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
6043 /// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']'
6044 /// [C99] direct-declarator '[' type-qual-list[opt] '*' ']'
6045 /// [C++11] direct-declarator '[' constant-expression[opt] ']'
6046 /// attribute-specifier-seq[opt]
6047 void Parser::ParseBracketDeclarator(Declarator &D) {
6048  if (CheckProhibitedCXX11Attribute())
6049  return;
6050 
6051  BalancedDelimiterTracker T(*this, tok::l_square);
6052  T.consumeOpen();
6053 
6054  // C array syntax has many features, but by-far the most common is [] and [4].
6055  // This code does a fast path to handle some of the most obvious cases.
6056  if (Tok.getKind() == tok::r_square) {
6057  T.consumeClose();
6058  ParsedAttributes attrs(AttrFactory);
6059  MaybeParseCXX11Attributes(attrs);
6060 
6061  // Remember that we parsed the empty array type.
6062  D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, nullptr,
6063  T.getOpenLocation(),
6064  T.getCloseLocation()),
6065  attrs, T.getCloseLocation());
6066  return;
6067  } else if (Tok.getKind() == tok::numeric_constant &&
6068  GetLookAheadToken(1).is(tok::r_square)) {
6069  // [4] is very common. Parse the numeric constant expression.
6070  ExprResult ExprRes(Actions.ActOnNumericConstant(Tok, getCurScope()));
6071  ConsumeToken();
6072 
6073  T.consumeClose();
6074  ParsedAttributes attrs(AttrFactory);
6075  MaybeParseCXX11Attributes(attrs);
6076 
6077  // Remember that we parsed a array type, and remember its features.
6078  D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false,
6079  ExprRes.get(),
6080  T.getOpenLocation(),
6081  T.getCloseLocation()),
6082  attrs, T.getCloseLocation());
6083  return;
6084  } else if (Tok.getKind() == tok::code_completion) {
6086  return cutOffParsing();
6087  }
6088 
6089  // If valid, this location is the position where we read the 'static' keyword.
6090  SourceLocation StaticLoc;
6091  TryConsumeToken(tok::kw_static, StaticLoc);
6092 
6093  // If there is a type-qualifier-list, read it now.
6094  // Type qualifiers in an array subscript are a C99 feature.
6095  DeclSpec DS(AttrFactory);
6096  ParseTypeQualifierListOpt(DS, AR_CXX11AttributesParsed);
6097 
6098  // If we haven't already read 'static', check to see if there is one after the
6099  // type-qualifier-list.
6100  if (!StaticLoc.isValid())
6101  TryConsumeToken(tok::kw_static, StaticLoc);
6102 
6103  // Handle "direct-declarator [ type-qual-list[opt] * ]".
6104  bool isStar = false;
6105  ExprResult NumElements;
6106 
6107  // Handle the case where we have '[*]' as the array size. However, a leading
6108  // star could be the start of an expression, for example 'X[*p + 4]'. Verify
6109  // the token after the star is a ']'. Since stars in arrays are
6110  // infrequent, use of lookahead is not costly here.
6111  if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
6112  ConsumeToken(); // Eat the '*'.
6113 
6114  if (StaticLoc.isValid()) {
6115  Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);
6116  StaticLoc = SourceLocation(); // Drop the static.
6117  }
6118  isStar = true;
6119  } else if (Tok.isNot(tok::r_square)) {
6120  // Note, in C89, this production uses the constant-expr production instead
6121  // of assignment-expr. The only difference is that assignment-expr allows
6122  // things like '=' and '*='. Sema rejects these in C89 mode because they
6123  // are not i-c-e's, so we don't need to distinguish between the two here.
6124 
6125  // Parse the constant-expression or assignment-expression now (depending
6126  // on dialect).
6127  if (getLangOpts().CPlusPlus) {
6128  NumElements = ParseConstantExpression();
6129  } else {
6130  EnterExpressionEvaluationContext Unevaluated(Actions,
6132  NumElements =
6134  }
6135  } else {
6136  if (StaticLoc.isValid()) {
6137  Diag(StaticLoc, diag::err_unspecified_size_with_static);
6138  StaticLoc = SourceLocation(); // Drop the static.
6139  }
6140  }
6141 
6142  // If there was an error parsing the assignment-expression, recover.
6143  if (NumElements.isInvalid()) {
6144  D.setInvalidType(true);
6145  // If the expression was invalid, skip it.
6146  SkipUntil(tok::r_square, StopAtSemi);
6147  return;
6148  }
6149 
6150  T.consumeClose();
6151 
6152  ParsedAttributes attrs(AttrFactory);
6153  MaybeParseCXX11Attributes(attrs);
6154 
6155  // Remember that we parsed a array type, and remember its features.
6157  StaticLoc.isValid(), isStar,
6158  NumElements.get(),
6159  T.getOpenLocation(),
6160  T.getCloseLocation()),
6161  attrs, T.getCloseLocation());
6162 }
6163 
6164 /// Diagnose brackets before an identifier.
6165 void Parser::ParseMisplacedBracketDeclarator(Declarator &D) {
6166  assert(Tok.is(tok::l_square) && "Missing opening bracket");
6167  assert(!D.mayOmitIdentifier() && "Declarator cannot omit identifier");
6168 
6169  SourceLocation StartBracketLoc = Tok.getLocation();
6170  Declarator TempDeclarator(D.getDeclSpec(), D.getContext());
6171 
6172  while (Tok.is(tok::l_square)) {
6173  ParseBracketDeclarator(TempDeclarator);
6174  }
6175 
6176  // Stuff the location of the start of the brackets into the Declarator.
6177  // The diagnostics from ParseDirectDeclarator will make more sense if
6178  // they use this location instead.
6179  if (Tok.is(tok::semi))
6180  D.getName().EndLocation = StartBracketLoc;
6181 
6182  SourceLocation SuggestParenLoc = Tok.getLocation();
6183 
6184  // Now that the brackets are removed, try parsing the declarator again.
6185  ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
6186 
6187  // Something went wrong parsing the brackets, in which case,
6188  // ParseBracketDeclarator has emitted an error, and we don't need to emit
6189  // one here.
6190  if (TempDeclarator.getNumTypeObjects() == 0)
6191  return;
6192 
6193  // Determine if parens will need to be suggested in the diagnostic.
6194  bool NeedParens = false;
6195  if (D.getNumTypeObjects() != 0) {
6196  switch (D.getTypeObject(D.getNumTypeObjects() - 1).Kind) {
6201  case DeclaratorChunk::Pipe:
6202  NeedParens = true;
6203  break;
6207  break;
6208  }
6209  }
6210 
6211  if (NeedParens) {
6212  // Create a DeclaratorChunk for the inserted parens.
6213  ParsedAttributes attrs(AttrFactory);
6214  SourceLocation EndLoc = PP.getLocForEndOfToken(D.getLocEnd());
6215  D.AddTypeInfo(DeclaratorChunk::getParen(SuggestParenLoc, EndLoc), attrs,
6216  SourceLocation());
6217  }
6218 
6219  // Adding back the bracket info to the end of the Declarator.
6220  for (unsigned i = 0, e = TempDeclarator.getNumTypeObjects(); i < e; ++i) {
6221  const DeclaratorChunk &Chunk = TempDeclarator.getTypeObject(i);
6222  ParsedAttributes attrs(AttrFactory);
6223  attrs.set(Chunk.Common.AttrList);
6224  D.AddTypeInfo(Chunk, attrs, SourceLocation());
6225  }
6226 
6227  // The missing identifier would have been diagnosed in ParseDirectDeclarator.
6228  // If parentheses are required, always suggest them.
6229  if (!D.getIdentifier() && !NeedParens)
6230  return;
6231 
6232  SourceLocation EndBracketLoc = TempDeclarator.getLocEnd();
6233 
6234  // Generate the move bracket error message.
6235  SourceRange BracketRange(StartBracketLoc, EndBracketLoc);
6236  SourceLocation EndLoc = PP.getLocForEndOfToken(D.getLocEnd());
6237 
6238  if (NeedParens) {
6239  Diag(EndLoc, diag::err_brackets_go_after_unqualified_id)
6240  << getLangOpts().CPlusPlus
6241  << FixItHint::CreateInsertion(SuggestParenLoc, "(")
6242  << FixItHint::CreateInsertion(EndLoc, ")")
6244  EndLoc, CharSourceRange(BracketRange, true))
6245  << FixItHint::CreateRemoval(BracketRange);
6246  } else {
6247  Diag(EndLoc, diag::err_brackets_go_after_unqualified_id)
6248  << getLangOpts().CPlusPlus
6250  EndLoc, CharSourceRange(BracketRange, true))
6251  << FixItHint::CreateRemoval(BracketRange);
6252  }
6253 }
6254 
6255 /// [GNU] typeof-specifier:
6256 /// typeof ( expressions )
6257 /// typeof ( type-name )
6258 /// [GNU/C++] typeof unary-expression
6259 ///
6260 void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
6261  assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier");
6262  Token OpTok = Tok;
6263  SourceLocation StartLoc = ConsumeToken();
6264 
6265  const bool hasParens = Tok.is(tok::l_paren);
6266 
6269 
6270  bool isCastExpr;
6271  ParsedType CastTy;
6272  SourceRange CastRange;
6273  ExprResult Operand = Actions.CorrectDelayedTyposInExpr(
6274  ParseExprAfterUnaryExprOrTypeTrait(OpTok, isCastExpr, CastTy, CastRange));
6275  if (hasParens)
6276  DS.setTypeofParensRange(CastRange);
6277 
6278  if (CastRange.getEnd().isInvalid())
6279  // FIXME: Not accurate, the range gets one token more than it should.
6280  DS.SetRangeEnd(Tok.getLocation());
6281  else
6282  DS.SetRangeEnd(CastRange.getEnd());
6283 
6284  if (isCastExpr) {
6285  if (!CastTy) {
6286  DS.SetTypeSpecError();
6287  return;
6288  }
6289 
6290  const char *PrevSpec = nullptr;
6291  unsigned DiagID;
6292  // Check for duplicate type specifiers (e.g. "int typeof(int)").
6293  if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec,
6294  DiagID, CastTy,
6295  Actions.getASTContext().getPrintingPolicy()))
6296  Diag(StartLoc, DiagID) << PrevSpec;
6297  return;
6298  }
6299 
6300  // If we get here, the operand to the typeof was an expresion.
6301  if (Operand.isInvalid()) {
6302  DS.SetTypeSpecError();
6303  return;
6304  }
6305 
6306  // We might need to transform the operand if it is potentially evaluated.
6307  Operand = Actions.HandleExprEvaluationContextForTypeof(Operand.get());
6308  if (Operand.isInvalid()) {
6309  DS.SetTypeSpecError();
6310  return;
6311  }
6312 
6313  const char *PrevSpec = nullptr;
6314  unsigned DiagID;
6315  // Check for duplicate type specifiers (e.g. "int typeof(int)").
6316  if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
6317  DiagID, Operand.get(),
6318  Actions.getASTContext().getPrintingPolicy()))
6319  Diag(StartLoc, DiagID) << PrevSpec;
6320 }
6321 
6322 /// [C11] atomic-specifier:
6323 /// _Atomic ( type-name )
6324 ///
6325 void Parser::ParseAtomicSpecifier(DeclSpec &DS) {
6326  assert(Tok.is(tok::kw__Atomic) && NextToken().is(tok::l_paren) &&
6327  "Not an atomic specifier");
6328 
6329  SourceLocation StartLoc = ConsumeToken();
6330  BalancedDelimiterTracker T(*this, tok::l_paren);
6331  if (T.consumeOpen())
6332  return;
6333 
6335  if (Result.isInvalid()) {
6336  SkipUntil(tok::r_paren, StopAtSemi);
6337  return;
6338  }
6339 
6340  // Match the ')'
6341  T.consumeClose();
6342 
6343  if (T.getCloseLocation().isInvalid())
6344  return;
6345 
6346  DS.setTypeofParensRange(T.getRange());
6347  DS.SetRangeEnd(T.getCloseLocation());
6348 
6349  const char *PrevSpec = nullptr;
6350  unsigned DiagID;
6351  if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec,
6352  DiagID, Result.get(),
6353  Actions.getASTContext().getPrintingPolicy()))
6354  Diag(StartLoc, DiagID) << PrevSpec;
6355 }
6356 
6357 /// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be called
6358 /// from TryAltiVecVectorToken.
6359 bool Parser::TryAltiVecVectorTokenOutOfLine() {
6360  Token Next = NextToken();
6361  switch (Next.getKind()) {
6362  default: return false;
6363  case tok::kw_short:
6364  case tok::kw_long:
6365  case tok::kw_signed:
6366  case tok::kw_unsigned:
6367  case tok::kw_void:
6368  case tok::kw_char:
6369  case tok::kw_int:
6370  case tok::kw_float:
6371  case tok::kw_double:
6372  case tok::kw_bool:
6373  case tok::kw___bool:
6374  case tok::kw___pixel:
6375  Tok.setKind(tok::kw___vector);
6376  return true;
6377  case tok::identifier:
6378  if (Next.getIdentifierInfo() == Ident_pixel) {
6379  Tok.setKind(tok::kw___vector);
6380  return true;
6381  }
6382  if (Next.getIdentifierInfo() == Ident_bool) {
6383  Tok.setKind(tok::kw___vector);
6384  return true;
6385  }
6386  return false;
6387  }
6388 }
6389 
6390 bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
6391  const char *&PrevSpec, unsigned &DiagID,
6392  bool &isInvalid) {
6393  const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
6394  if (Tok.getIdentifierInfo() == Ident_vector) {
6395  Token Next = NextToken();
6396  switch (Next.getKind()) {
6397  case tok::kw_short:
6398  case tok::kw_long:
6399  case tok::kw_signed:
6400  case tok::kw_unsigned:
6401  case tok::kw_void:
6402  case tok::kw_char:
6403  case tok::kw_int:
6404  case tok::kw_float:
6405  case tok::kw_double:
6406  case tok::kw_bool:
6407  case tok::kw___bool:
6408  case tok::kw___pixel:
6409  isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
6410  return true;
6411  case tok::identifier:
6412  if (Next.getIdentifierInfo() == Ident_pixel) {
6413  isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID,Policy);
6414  return true;
6415  }
6416  if (Next.getIdentifierInfo() == Ident_bool) {
6417  isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID,Policy);
6418  return true;
6419  }
6420  break;
6421  default:
6422  break;
6423  }
6424  } else if ((Tok.getIdentifierInfo() == Ident_pixel) &&
6425  DS.isTypeAltiVecVector()) {
6426  isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID, Policy);
6427  return true;
6428  } else if ((Tok.getIdentifierInfo() == Ident_bool) &&
6429  DS.isTypeAltiVecVector()) {
6430  isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID, Policy);
6431  return true;
6432  }
6433  return false;
6434 }
void ClearFunctionSpecs()
Definition: DeclSpec.h:576
MutableArrayRef< TemplateParameterList * > MultiTemplateParamsArg
Definition: Ownership.h:266
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:210
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
Definition: Token.h:265
SourceLocation getThreadStorageClassSpecLoc() const
Definition: DeclSpec.h:457
SourceLocation getCloseLocation() const
Defines the clang::ASTContext interface.
static bool isAttributeLateParsed(const IdentifierInfo &II)
isAttributeLateParsed - Return true if the attribute has arguments that require late parsing...
Definition: ParseDecl.cpp:75
SourceLocation getEnd() const
AttributeList * addNewPropertyAttr(IdentifierInfo *attrName, SourceRange attrRange, IdentifierInfo *scopeName, SourceLocation scopeLoc, IdentifierInfo *getterId, IdentifierInfo *setterId, AttributeList::Syntax syntaxUsed)
Add microsoft __delspec(property) attribute.
IdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:981
DeclaratorChunk::FunctionTypeInfo & getFunctionTypeInfo()
getFunctionTypeInfo - Retrieves the function type info object (looking through parentheses).
Definition: DeclSpec.h:2097
TypeResult ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK, const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation TagLoc, SourceLocation NameLoc)
static LLVM_READONLY bool isDigit(unsigned char c)
Return true if this character is an ASCII digit: [0-9].
Definition: CharInfo.h:94
no exception specification
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
Definition: ParseExpr.cpp:120
SourceLocation getRestrictSpecLoc() const
Definition: DeclSpec.h:542
This is a scope that corresponds to the parameters within a function prototype.
Definition: Scope.h:80
bool isInvalid() const
Definition: Ownership.h:160
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
SourceLocation getConstSpecLoc() const
Definition: DeclSpec.h:541
SourceLocation getExplicitSpecLoc() const
Definition: DeclSpec.h:571
TSW getTypeSpecWidth() const
Definition: DeclSpec.h:476
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1087
static const TSS TSS_unsigned
Definition: DeclSpec.h:268
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:958
Code completion occurs within a class, struct, or union.
Definition: Sema.h:9181
TheContext getContext() const
Definition: DeclSpec.h:1750
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:2705
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
const LangOptions & getLangOpts() const
Definition: Parse/Parser.h:251
static const TST TST_wchar
Definition: DeclSpec.h:275
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
Definition: SemaExpr.cpp:6107
Decl * getRepAsDecl() const
Definition: DeclSpec.h:491
const LangOptions & getLangOpts() const
Definition: Sema.h:1062
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
Definition: Preprocessor.h:934
static const TST TST_typeofExpr
Definition: DeclSpec.h:295
static const TST TST_char16
Definition: DeclSpec.h:276
static bool isPtrOperatorToken(tok::TokenKind Kind, const LangOptions &Lang, unsigned TheContext)
Definition: ParseDecl.cpp:4926
RAII object used to inform the actions that we're currently parsing a declaration.
bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:907
Is the identifier known as a __declspec-style attribute?
A RAII object used to temporarily suppress access-like checking.
Defines the C++ template declaration subclasses.
bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS, bool AllowBuiltinCreation=false, bool EnteringContext=false)
Performs name lookup for a name that was parsed in the source code, and may contain a C++ scope speci...
IdentifierInfo * Ident
Definition: AttributeList.h:74
SCS getStorageClassSpec() const
Definition: DeclSpec.h:447
const char * getName() const
Definition: Token.h:165
PtrTy get() const
Definition: Ownership.h:164
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, unsigned TypeQuals, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation ConstQualifierLoc, SourceLocation VolatileQualifierLoc, SourceLocation RestrictQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult())
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
Definition: DeclSpec.cpp:152
The base class of the type hierarchy.
Definition: Type.h:1281
bool TryAnnotateCXXScopeToken(bool EnteringContext=false)
TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only annotates C++ scope specifiers and ...
This indicates that the scope corresponds to a function, which means that labels are set here...
Definition: Scope.h:46
std::unique_ptr< llvm::MemoryBuffer > Buffer
One instance of this struct is used for each type in a declarator that is parsed. ...
Definition: DeclSpec.h:1101
Declaration of a variable template.
static FixItHint CreateInsertionFromRange(SourceLocation InsertionLoc, CharSourceRange FromRange, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code from FromRange at a specific location...
Definition: Diagnostic.h:91
static const char * getSpecifierName(DeclSpec::TST T, const PrintingPolicy &Policy)
Turn a type-specifier-type into a string like "_Bool" or "union".
Definition: DeclSpec.cpp:447
SourceLocation getInlineSpecLoc() const
Definition: DeclSpec.h:563
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:93
TemplateNameKind Kind
The kind of template that Template refers to.
void ActOnExitFunctionContext()
Definition: SemaDecl.cpp:1214
Wrapper for void* pointer.
Definition: Ownership.h:46
bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:757
void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc)
Set the name of this declarator to be the given identifier.
Definition: DeclSpec.h:1981
static IdentifierLoc * create(ASTContext &Ctx, SourceLocation Loc, IdentifierInfo *Ident)
void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS, bool AllowNonIdentifiers, bool AllowNestedNameSpecifiers)
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group, bool TypeMayContainAuto=true)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
Definition: SemaDecl.cpp:10700
RAII object that enters a new expression evaluation context.
Definition: Sema.h:9606
void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record)
void EnterToken(const Token &Tok)
Enters a token in the token stream to be lexed next.
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1624
bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:847
void setTypeofParensRange(SourceRange range)
Definition: DeclSpec.h:518
static const TST TST_interface
Definition: DeclSpec.h:291
RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...
Definition: Sema.h:4695
static const TST TST_char
Definition: DeclSpec.h:274
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
Code completion occurs within an Objective-C implementation or category implementation.
Definition: Sema.h:9187
RAII object that makes sure paren/bracket/brace count is correct after declaration/statement parsing...
Decl * ActOnParamDeclarator(Scope *S, Declarator &D)
ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() to introduce parameters into fun...
Definition: SemaDecl.cpp:10795
friend class ObjCDeclContextSwitch
Definition: Parse/Parser.h:61
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1377
ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed...
StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const
Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch ...
Definition: Parse/Parser.h:885
void ActOnUninitializedDecl(Decl *dcl, bool TypeMayContainAuto)
Definition: SemaDecl.cpp:9988
Information about a template-id annotation token.
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)
void CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc, ArrayRef< Expr * > Args)
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3253
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parse/Parser.h:558
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parse/Parser.h:300
__ptr16, alignas(...), etc.
One of these records is kept for each identifier that is lexed.
void set(AttributeList *newList)
static const TST TST_decimal32
Definition: DeclSpec.h:285
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
AttributeList * getList() const
static bool attributeHasIdentifierArg(const IdentifierInfo &II)
Determine whether the given attribute has an identifier argument.
Definition: ParseDecl.cpp:206
bool isTypeSpecPipe() const
Definition: DeclSpec.h:485
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
Definition: DeclSpec.h:1987
void ActOnTagStartDefinition(Scope *S, Decl *TagDecl)
ActOnTagStartDefinition - Invoked when we have entered the scope of a tag's definition (e...
Definition: SemaDecl.cpp:13117
const CXXScopeSpec & getCXXScopeSpec() const
getCXXScopeSpec - Return the C++ scope specifier (global scope or nested-name-specifier) that is part...
Definition: DeclSpec.h:1744
static const TST TST_class
Definition: DeclSpec.h:292
bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS)
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
Definition: SemaDecl.cpp:54
void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDecl, ArrayRef< Decl * > Elements, Scope *S, AttributeList *Attr)
Definition: SemaDecl.cpp:14778
AttributeList * addNewTypeAttr(IdentifierInfo *attrName, SourceRange attrRange, IdentifierInfo *scopeName, SourceLocation scopeLoc, ParsedType typeArg, AttributeList::Syntax syntaxUsed)
Add an attribute with a single type argument.
bool isEmpty() const
isEmpty - Return true if this declaration specifier is completely empty: no tokens were parsed in the...
Definition: DeclSpec.h:603
static const TST TST_double
Definition: DeclSpec.h:282
Code completion occurs following one or more template headers within a class.
Definition: Sema.h:9196
bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:832
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:28
ParsedType ActOnObjCInstanceType(SourceLocation Loc)
The parser has parsed the context-sensitive type 'instancetype' in an Objective-C message declaration...
Definition: SemaType.cpp:5241
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, SourceLocation IILoc)
Determine whether the body of an anonymous enumeration should be skipped.
Definition: SemaDecl.cpp:14482
static const TST TST_enum
Definition: DeclSpec.h:288
void setKind(tok::TokenKind K)
Definition: Token.h:90
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ...
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:509
Decl * ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant, SourceLocation IdLoc, IdentifierInfo *Id, AttributeList *Attrs, SourceLocation EqualLoc, Expr *Val)
Definition: SemaDecl.cpp:14508
void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs)
ActOnFinishDelayedAttribute - Invoked when we have finished parsing an attribute for which parsing is...
Definition: SemaDecl.cpp:11718
void ClearStorageClassSpecs()
Definition: DeclSpec.h:461
static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc, SourceLocation ConstQualLoc, SourceLocation VolatileQualLoc, SourceLocation RestrictQualLoc, SourceLocation AtomicQualLoc, SourceLocation UnalignedQualLoc)
Return a DeclaratorChunk for a pointer.
Definition: DeclSpec.h:1477
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
bool mayBeFollowedByCXXDirectInit() const
mayBeFollowedByCXXDirectInit - Return true if the declarator can be followed by a C++ direct initiali...
Definition: DeclSpec.h:1911
Decl * ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, AttributeList *Attr, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, SkipBodyInfo *SkipBody=nullptr)
This is invoked when we see 'struct foo' or 'struct {'.
Definition: SemaDecl.cpp:12260
bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:742
Code completion occurs at top-level or namespace context.
Definition: Sema.h:9179
The controlling scope in a if/switch/while/for statement.
Definition: Scope.h:61
const TargetInfo & getTargetInfo() const
Definition: Parse/Parser.h:252
void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart, IdentifierInfo *ClassName, SmallVectorImpl< Decl * > &Decls)
Called whenever @defs(ClassName) is encountered in the source.
This is a scope that corresponds to a block/closure object.
Definition: Scope.h:70
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
Definition: Sema.h:829
void addAttributes(AttributeList *AL)
Concatenates two attribute lists.
Definition: DeclSpec.h:743
Represents the results of name lookup.
Definition: Sema/Lookup.h:30
bool hasGroupingParens() const
Definition: DeclSpec.h:2227
void setExtension(bool Val=true)
Definition: DeclSpec.h:2212
This scope corresponds to an enum.
Definition: Scope.h:117
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:2004
static StringRef normalizeAttrName(StringRef Name)
Normalizes an attribute name by dropping prefixed and suffixed __.
Definition: ParseDecl.cpp:199
void SetRangeBegin(SourceLocation Loc)
SetRangeBegin - Set the start of the source range to Loc, unless it's invalid.
Definition: DeclSpec.h:1767
Code completion occurs following one or more template headers.
Definition: Sema.h:9193
void CodeCompleteBracketDeclarator(Scope *S)
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
Definition: SemaDecl.cpp:9951
bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:820
bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS)
Determine whether the identifier II is a typo for the name of the class type currently being defined...
tok::TokenKind getTokenID() const
If this is a source-language token (e.g.
bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:877
SourceLocation getEndLoc() const
Definition: DeclSpec.h:73
Represents information about a change in availability for an entity, which is part of the encoding of...
Definition: AttributeList.h:35
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
int hasAttribute(AttrSyntax Syntax, const IdentifierInfo *Scope, const IdentifierInfo *Attr, const TargetInfo &Target, const LangOptions &LangOpts)
Return the version number associated with the attribute if we recognize and implement the attribute s...
Definition: Attributes.cpp:6
bool SetTypePipe(bool isPipe, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:726
bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:862
AvailabilityChange Changes[NumAvailabilitySlots]
Definition: AttributeList.h:56
tok::TokenKind getKind() const
Definition: Token.h:89
Decl * ActOnTemplateDeclarator(Scope *S, MultiTemplateParamsArg TemplateParameterLists, Declarator &D)
ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope=nullptr)
Definition: SemaExpr.cpp:3243
bool isFunctionDeclaratorAFunctionDeclaration() const
Return true if a function declarator at this position would be a function declaration.
Definition: DeclSpec.h:2157
static bool VersionNumberSeparator(const char Separator)
Definition: ParseDecl.cpp:712
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:502
void setInvalid(bool b=true) const
detail::InMemoryDirectory::const_iterator I
VersionTuple Version
The version number at which the change occurred.
Definition: AttributeList.h:40
bool isInvalid() const
void DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool AllowClassTemplates=false)
Definition: SemaDecl.cpp:599
static const TST TST_float
Definition: DeclSpec.h:281
Code completion occurs within a sequence of declaration specifiers within a function, method, or block.
Definition: Sema.h:9219
void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an initializer for the declaratio...
Provides definitions for the various language-specific address spaces.
void * getAnnotationValue() const
Definition: Token.h:223
static const TSW TSW_long
Definition: DeclSpec.h:255
bool isFunctionDeclarator(unsigned &idx) const
isFunctionDeclarator - This method returns true if the declarator is a function declarator (looking t...
Definition: DeclSpec.h:2066
TemplateParameterList * ActOnTemplateParameterList(unsigned Depth, SourceLocation ExportLoc, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< Decl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
ActOnTemplateParameterList - Builds a TemplateParameterList, optionally constrained by RequiresClause...
TST getTypeSpecType() const
Definition: DeclSpec.h:479
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit, bool TypeMayContainAuto)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
Definition: SemaDecl.cpp:9517
Kind getKind() const
void ClearConstexprSpec()
Definition: DeclSpec.h:712
const void * getEofData() const
Definition: Token.h:189
SourceLocation getModulePrivateSpecLoc() const
Definition: DeclSpec.h:704
A class for parsing a declarator.
TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S)
isTagName() - This method is called for error recovery purposes only to determine if the specified na...
Definition: SemaDecl.cpp:550
void SetRangeStart(SourceLocation Loc)
Definition: DeclSpec.h:607
NameClassificationKind getKind() const
Definition: Sema.h:1607
SourceLocation getFriendSpecLoc() const
Definition: DeclSpec.h:701
unsigned NumParams
NumParams - This is the number of formal parameters specified by the declarator.
Definition: DeclSpec.h:1247
Stop at code completion.
Definition: Parse/Parser.h:868
ASTContext * Context
TypeResult ParseTypeName(SourceRange *Range=nullptr, Declarator::TheContext Context=Declarator::TypeNameContext, AccessSpecifier AS=AS_none, Decl **OwnedType=nullptr, ParsedAttributes *Attrs=nullptr)
ParseTypeName type-name: [C99 6.7.6] specifier-qualifier-list abstract-declarator[opt].
Definition: ParseDecl.cpp:44
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1616
bool mayOmitIdentifier() const
mayOmitIdentifier - Return true if the identifier is either optional or not allowed.
Definition: DeclSpec.h:1808
void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param)
This is used to implement the constant expression evaluation part of the attribute enable_if extensio...
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:540
SourceRange getAnnotationRange() const
SourceRange of the group of tokens that this annotation token represents.
Definition: Token.h:157
bool containsUnexpandedParameterPacks(Declarator &D)
Determine whether the given declarator contains any unexpanded parameter packs.
StringRef getName() const
Return the actual identifier string.
Decl * ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, RecordDecl *&AnonRecord)
ParsedFreeStandingDeclSpec - This method is invoked when a declspec with no declarator (e...
Definition: SemaDecl.cpp:3714
Represents a character-granular source range.
SourceLocation getAtomicSpecLoc() const
Definition: DeclSpec.h:544
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type...
Definition: SemaDecl.cpp:249
void SkipMalformedDecl()
SkipMalformedDecl - Read tokens until we get to some likely good stopping point for skipping past a s...
Definition: ParseDecl.cpp:1648
static DeclaratorChunk getPipe(unsigned TypeQuals, SourceLocation Loc)
Return a DeclaratorChunk for a block.
Definition: DeclSpec.h:1564
TypeResult ActOnTypeName(Scope *S, Declarator &D)
Definition: SemaType.cpp:5212
void setEofData(const void *D)
Definition: Token.h:193
static bool isPipeDeclerator(const Declarator &D)
Definition: ParseDecl.cpp:4953
void setAsmLabel(Expr *E)
Definition: DeclSpec.h:2209
SourceLocation getVolatileSpecLoc() const
Definition: DeclSpec.h:543
TypeInfoCommon Common
Definition: DeclSpec.h:1443
enum clang::DeclaratorChunk::@185 Kind
static const TST TST_decimal64
Definition: DeclSpec.h:286
bool isPastIdentifier() const
isPastIdentifier - Return true if we have parsed beyond the point where the
Definition: DeclSpec.h:1963
Decl * ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth)
ActOnField - Each field of a C struct/union is passed into this in order to create a FieldDecl object...
Definition: SemaDecl.cpp:13334
void UpdateTypeRep(ParsedType Rep)
Definition: DeclSpec.h:668
SourceLocation KeywordLoc
The location of the keyword indicating the kind of change.
Definition: AttributeList.h:37
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:123
bool isConstexprSpecified() const
Definition: DeclSpec.h:706
A class for parsing a field declarator.
bool isNot(tok::TokenKind K) const
Definition: Token.h:95
bool hasTypeSpecifier() const
Return true if any type-specifier has been found.
Definition: DeclSpec.h:590
SourceLocation Loc
Loc - The place where this type was defined.
Definition: DeclSpec.h:1107
static SourceLocation getMissingDeclaratorIdLoc(Declarator &D, SourceLocation Loc)
Definition: ParseDecl.cpp:5155
static const TST TST_int
Definition: DeclSpec.h:278
void setEllipsisLoc(SourceLocation EL)
Definition: DeclSpec.h:2235
bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:602
static const TST TST_half
Definition: DeclSpec.h:280
class LLVM_ALIGNAS(8) TemplateSpecializationType unsigned NumArgs
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4154
Wraps an identifier and optional source location for the identifier.
Definition: AttributeList.h:72
void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl)
ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an initializer for the declaration ...
The result type of a method or function.
SourceLocation getStorageClassSpecLoc() const
Definition: DeclSpec.h:456
SourceRange VersionRange
The source range covering the version number.
Definition: AttributeList.h:43
SourceLocation getAnnotationEndLoc() const
Definition: Token.h:137
static const TSW TSW_short
Definition: DeclSpec.h:254
bool isVirtualSpecified() const
Definition: DeclSpec.h:567
void CodeCompleteInitializer(Scope *S, Decl *D)
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:553
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
bool SetTypeSpecWidth(TSW W, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec, but return true and ignore the request if ...
Definition: DeclSpec.cpp:577
NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc, const Token &NextToken, bool IsAddressOfOperand, std::unique_ptr< CorrectionCandidateCallback > CCC=nullptr)
Perform name lookup on the given name, classifying it based on the results of name lookup and the fol...
Definition: SemaDecl.cpp:775
This is a scope that corresponds to the parameters within a function prototype for a function declara...
Definition: Scope.h:86
void CodeCompleteTypeQualifiers(DeclSpec &DS)
static const TST TST_char32
Definition: DeclSpec.h:277
A class for parsing a DeclSpec.
static DeclaratorChunk getParen(SourceLocation LParenLoc, SourceLocation RParenLoc)
Return a DeclaratorChunk for a paren.
Definition: DeclSpec.h:1588
bool SetConceptSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:921
Kind
Stop skipping at semicolon.
Definition: Parse/Parser.h:865
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:146
static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc, bool lvalue)
Return a DeclaratorChunk for a reference.
Definition: DeclSpec.h:1497
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
Encodes a location in the source.
void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record)
static const TST TST_auto_type
Definition: DeclSpec.h:300
const char * getNameStart() const
Return the beginning of the actual null-terminated string for this identifier.
void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl, SourceRange BraceRange)
ActOnTagFinishDefinition - Invoked once we have finished parsing the definition of a tag (enumeration...
Definition: SemaDecl.cpp:13178
SourceLocation getEndLoc() const
Definition: Token.h:150
UnqualifiedId & getName()
Retrieve the name specified by this declarator.
Definition: DeclSpec.h:1748
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
Definition: SemaDecl.cpp:10491
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getPipeLoc() const
Definition: DeclSpec.h:546
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2727
void ExitScope()
ExitScope - Pop a scope off the scope stack.
This is a scope that corresponds to the Objective-C @catch statement.
Definition: Scope.h:90
ASTContext & getASTContext() const
Definition: Sema.h:1069
static const TST TST_union
Definition: DeclSpec.h:289
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec and return false if there was no error...
Definition: DeclSpec.cpp:502
Scope * getCurScope() const
Definition: Parse/Parser.h:258
static const TSS TSS_signed
Definition: DeclSpec.h:267
bool isObjCAtKeyword(tok::ObjCKeywordKind objcKey) const
Return true if we have an ObjC keyword identifier.
Definition: Lexer.cpp:36
void setIdentifierInfo(IdentifierInfo *II)
Definition: Token.h:185
ExtensionRAIIObject - This saves the state of extension warnings when constructed and disables them...
void setGroupingParens(bool flag)
Definition: DeclSpec.h:2226
void EnterScope(unsigned ScopeFlags)
EnterScope - Start a new scope.
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
SourceLocation getConstexprSpecLoc() const
Definition: DeclSpec.h:707
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
SourceLocation StrictLoc
Definition: AttributeList.h:57
SourceLocation getVirtualSpecLoc() const
Definition: DeclSpec.h:568
SourceLocation getUnalignedSpecLoc() const
Definition: DeclSpec.h:545
static const TST TST_typeofType
Definition: DeclSpec.h:294
SourceLocation getBegin() const
bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D)
Determine if we're in a case where we need to (incorrectly) eagerly parse an exception specification ...
bool hasAttributes() const
Definition: DeclSpec.h:747
bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const LangOptions &Lang)
Definition: DeclSpec.cpp:780
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {...
Definition: Token.h:94
bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:713
static DeclaratorChunk getArray(unsigned TypeQuals, bool isStatic, bool isStar, Expr *NumElts, SourceLocation LBLoc, SourceLocation RBLoc)
Return a DeclaratorChunk for an array.
Definition: DeclSpec.h:1509
bool ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, ParsedType ObjectType, SourceLocation &TemplateKWLoc, UnqualifiedId &Result)
Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, AttributeList *AttrList)
Definition: SemaDecl.cpp:13854
ExprResult HandleExprEvaluationContextForTypeof(Expr *E)
Definition: SemaExpr.cpp:12906
bool containsPlaceholderType() const
Definition: DeclSpec.h:520
SourceLocation getOpenLocation() const
The scope of a struct/union/class definition.
Definition: Scope.h:64
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1760
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
void ActOnReenterFunctionContext(Scope *S, Decl *D)
Push the parameters of D, which must be a function, into scope.
Definition: SemaDecl.cpp:1190
ParserCompletionContext
Describes the context in which code completion occurs.
Definition: Sema.h:9177
bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:895
static bool isInvalid(LocType Loc, bool *Invalid)
TSCS getThreadStorageClassSpec() const
Definition: DeclSpec.h:448
SmallVector< Token, 4 > CachedTokens
A set of tokens that has been cached for later parsing.
Definition: DeclSpec.h:1095
static const TST TST_auto
Definition: DeclSpec.h:299
bool isFriendSpecified() const
Definition: DeclSpec.h:700
static const TST TST_void
Definition: DeclSpec.h:273
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero)...
Definition: VersionTuple.h:69
SourceRange getSourceRange(const SourceRange &Range)
Returns the SourceRange of a SourceRange.
Definition: FixIt.h:34
CXXScopeSpec SS
The nested-name-specifier that precedes the template name.
static const TST TST_int128
Definition: DeclSpec.h:279
void CodeCompleteTag(Scope *S, unsigned TagSpec)
void ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc, Expr *defarg)
ActOnParamDefaultArgument - Check whether the default argument provided for a function parameter is w...
bool hasTagDefinition() const
Definition: DeclSpec.cpp:354
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:104
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:76
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclSpec.h:504
EnumDecl - Represents an enum.
Definition: Decl.h:3013
bool hasName() const
hasName - Whether this declarator has a name, which might be an identifier (accessible via getIdentif...
Definition: DeclSpec.h:1968
The name refers to a template whose specialization produces a type.
Definition: TemplateKinds.h:30
static const TST TST_unspecified
Definition: DeclSpec.h:272
bool isFirstDeclarator() const
Definition: DeclSpec.h:2229
Syntax
The style used to specify an attribute.
Definition: AttributeList.h:97
bool isCurrentClassName(const IdentifierInfo &II, Scope *S, const CXXScopeSpec *SS=nullptr)
isCurrentClassName - Determine whether the identifier II is the name of the class type currently bein...
ExprResult ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, bool IsType, void *TyOrEx, SourceRange ArgRange)
ActOnUnaryExprOrTypeTraitExpr - Handle sizeof(type) and sizeof expr and the same for alignof and __al...
Definition: SemaExpr.cpp:4039
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:191
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:96
IdentifierInfo * getName() const
static const TST TST_decimal128
Definition: DeclSpec.h:287
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
Definition: Sema.h:1912
void takeAttributesFrom(ParsedAttributes &attrs)
Definition: DeclSpec.h:752
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
static const TSCS TSCS___thread
Definition: DeclSpec.h:247
void RestoreNestedNameSpecifierAnnotation(void *Annotation, SourceRange AnnotationRange, CXXScopeSpec &SS)
Given an annotation pointer for a nested-name-specifier, restore the nested-name-specifier structure...
bool mayHaveIdentifier() const
mayHaveIdentifier - Return true if the identifier is either optional or required. ...
Definition: DeclSpec.h:1843
bool isKnownToGCC() const
void setNext(AttributeList *N)
unsigned getMaxArgs() const
bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:563
static const TST TST_typename
Definition: DeclSpec.h:293
void * getAsOpaquePtr() const
Definition: Ownership.h:85
void SetRangeEnd(SourceLocation Loc)
SetRangeEnd - Set the end of the source range to Loc, unless it's invalid.
Definition: DeclSpec.h:1772
DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, ArrayRef< Decl * > Group)
Definition: SemaDecl.cpp:10669
DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy Template, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, AttributeList *Attr)
ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)
Parse an expr that doesn't include (top-level) commas.
Definition: ParseExpr.cpp:157
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
void ActOnCXXForRangeDecl(Decl *D)
Definition: SemaDecl.cpp:10222
SourceLocation getLoc() const
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:78
bool isInlineSpecified() const
Definition: DeclSpec.h:560
bool isInvalid() const
A template-id, e.g., f<int>.
Definition: DeclSpec.h:907
SmallVector< TemplateParameterList *, 4 > TemplateParameterLists
Definition: Parse/Parser.h:270
CXXScopeSpec & getTypeSpecScope()
Definition: DeclSpec.h:499
AttributeList * addNew(IdentifierInfo *attrName, SourceRange attrRange, IdentifierInfo *scopeName, SourceLocation scopeLoc, ArgsUnion *args, unsigned numArgs, AttributeList::Syntax syntax, SourceLocation ellipsisLoc=SourceLocation())
Add attribute with expression arguments.
bool isUnexpandedParameterPackPermitted()
Determine whether an unexpanded parameter pack might be permitted in this location.
bool isUsable() const
Definition: Ownership.h:161
This is a scope that can contain a declaration.
Definition: Scope.h:58
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:1972
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:691
static ParsedType getTypeAnnotation(Token &Tok)
getTypeAnnotation - Read a parsed type out of an annotation token.
Definition: Parse/Parser.h:563
bool isCXX11Attribute() const
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:12171
void setInvalidType(bool Val=true)
Definition: DeclSpec.h:2221
ExprResult ParseConstantExpression(TypeCastState isTypeCast=NotTypeCast)
Definition: ParseExpr.cpp:197
void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc)
ActOnParamDefaultArgumentError - Parsing or semantic analysis of the default argument for the paramet...
static DeclaratorChunk getBlockPointer(unsigned TypeQuals, SourceLocation Loc)
Return a DeclaratorChunk for a block.
Definition: DeclSpec.h:1553
static bool attributeParsedArgsUnevaluated(const IdentifierInfo &II)
Determine whether the given attribute requires parsing its arguments in an unevaluated context or not...
Definition: ParseDecl.cpp:225
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
bool isExplicitSpecified() const
Definition: DeclSpec.h:570
SourceLocation getIdentifierLoc() const
Definition: DeclSpec.h:1978
static bool isValidAfterIdentifierInDeclarator(const Token &T)
isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the specified token is valid after t...
Definition: ParseDecl.cpp:2232
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
Definition: Parse/Parser.h:292
static const TSCS TSCS_thread_local
Definition: DeclSpec.h:248
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
Definition: Sema.h:814
void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc, SourceLocation ArgLoc)
ActOnParamUnparsedDefaultArgument - We've seen a default argument for a function parameter, but we can't parse it yet because we're inside a class definition.
void ClearTypeSpecType()
Definition: DeclSpec.h:469
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult{return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
static const TST TST_float128
Definition: DeclSpec.h:283
bool TryAnnotateTypeOrScopeToken(bool EnteringContext=false, bool NeedType=false)
TryAnnotateTypeOrScopeToken - If the current token position is on a typename (possibly qualified in C...
static const TST TST_bool
Definition: DeclSpec.h:284
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:311
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:115
void revertTokenIDToIdentifier()
Revert TokenID to tok::identifier; used for GNU libstdc++ 4.2 compatibility.
bool diagnoseIdentifier() const
diagnoseIdentifier - Return true if the identifier is prohibited and should be diagnosed (because it ...
Definition: DeclSpec.h:1877
bool isTypeSpecOwned() const
Definition: DeclSpec.h:483
void Finish(Sema &S, const PrintingPolicy &Policy)
Finish - This does final analysis of the declspec, issuing diagnostics for things like "_Imaginary" (...
Definition: DeclSpec.cpp:953
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1466
Defines the clang::TargetInfo interface.
void ExtendWithDeclSpec(const DeclSpec &DS)
ExtendWithDeclSpec - Extend the declarator source range to include the given declspec, unless its location is invalid.
Definition: DeclSpec.h:1779
ExprResult ExprError()
Definition: Ownership.h:268
static const TSW TSW_longlong
Definition: DeclSpec.h:256
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:810
bool isRecord() const
Definition: DeclBase.h:1287
bool isTypeAltiVecVector() const
Definition: DeclSpec.h:480
unsigned getParsedSpecifiers() const
Return a bitmask of which flavors of specifiers this DeclSpec includes.
Definition: DeclSpec.cpp:363
bool hasEllipsis() const
Definition: DeclSpec.h:2233
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:196
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
unsigned getLength() const
Definition: Token.h:126
static bool attributeIsTypeArgAttr(const IdentifierInfo &II)
Determine whether the given attribute parses a type argument.
Definition: ParseDecl.cpp:215
static const TST TST_atomic
Definition: DeclSpec.h:302
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
Definition: Sema.h:799
bool isDeclspecAttribute() const
static const TST TST_struct
Definition: DeclSpec.h:290
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:52
ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed...
Definition: DeclSpec.h:1179
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
Definition: DeclSpec.h:2008
void setLocation(SourceLocation L)
Definition: Token.h:131
AttributeList * getNext() const
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:299
bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:592
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
bool isInvalidType() const
Definition: DeclSpec.h:2222
bool SetTypeSpecError()
Definition: DeclSpec.cpp:772
SourceLocation EndLocation
The location of the last token that describes this unqualified-id.
Definition: DeclSpec.h:961
static const TSCS TSCS__Thread_local
Definition: DeclSpec.h:249
ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II, SourceLocation NameLoc, bool IsTemplateTypeArg)
Attempt to behave like MSVC in situations where lookup of an unqualified type name has failed in a de...
Definition: SemaDecl.cpp:497
bool isFirstDeclarationOfMember()
Returns true if this declares a real member and not a friend.
Definition: DeclSpec.h:2250
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclSpec.h:1762
void SetRangeEnd(SourceLocation Loc)
Definition: DeclSpec.h:608
ParsedAttributes - A collection of parsed attributes.
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
Definition: Token.h:117
ParamInfo * Params
Params - This is a pointer to a new[]'d array of ParamInfo objects that describe the parameters speci...
Definition: DeclSpec.h:1286
Attr - This represents one attribute.
Definition: Attr.h:45
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:749
void startToken()
Reset all flags to cleared.
Definition: Token.h:168
AttributeList * addNewTypeTagForDatatype(IdentifierInfo *attrName, SourceRange attrRange, IdentifierInfo *scopeName, SourceLocation scopeLoc, IdentifierLoc *argumentKind, ParsedType matchingCType, bool layoutCompatible, bool mustBeNull, AttributeList::Syntax syntax)
Add type_tag_for_datatype attribute.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1729
Decl * ActOnDeclarator(Scope *S, Declarator &D)
Definition: SemaDecl.cpp:4788
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:94
static DeclaratorChunk getMemberPointer(const CXXScopeSpec &SS, unsigned TypeQuals, SourceLocation Loc)
Definition: DeclSpec.h:1574
bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:806
Stop skipping at specified token, but don't skip the token itself.
Definition: Parse/Parser.h:867
SourceLocation getEllipsisLoc() const
Definition: DeclSpec.h:2234
unsigned ActOnReenterTemplateScope(Scope *S, Decl *Template)
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:176