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