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