contrib/llvm/tools/clang/lib/Parse/ParseDecl.cpp

   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
  33 using namespace clang;
  34
  35 //===----------------------------------------------------------------------===//
  36 // C99 6.7: Declarations.
  37 //===----------------------------------------------------------------------===//
  38
  39 /// ParseTypeName
  40 ///       type-name: [C99 6.7.6]
  41 ///         specifier-qualifier-list abstract-declarator[opt]
  42 ///
  43 /// Called type-id in C++.
  44 TypeResult 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.
  75 static bool isAttributeLateParsed(const IdentifierInfo &II) {
  76 #define CLANG_ATTR_LATE_PARSED_LIST
  77     return llvm::StringSwitch<bool>(II.getName())
  78 #include "clang/Parse/AttrParserStringSwitches.inc"
  79         .Default(false);
  80 #undef CLANG_ATTR_LATE_PARSED_LIST
  81 }
  82
  83 /// ParseGNUAttributes - Parse a non-empty attributes list.
  84 ///
  85 /// [GNU] attributes:
  86 ///         attribute
  87 ///         attributes attribute
  88 ///
  89 /// [GNU]  attribute:
  90 ///          '__attribute__' '(' '(' attribute-list ')' ')'
  91 ///
  92 /// [GNU]  attribute-list:
  93 ///          attrib
  94 ///          attribute_list ',' attrib
  95 ///
  96 /// [GNU]  attrib:
  97 ///          empty
  98 ///          attrib-name
  99 ///          attrib-name '(' identifier ')'
 100 ///          attrib-name '(' identifier ',' nonempty-expr-list ')'
 101 ///          attrib-name '(' argument-expression-list [C99 6.5.2] ')'
 102 ///
 103 /// [GNU]  attrib-name:
 104 ///          identifier
 105 ///          typespec
 106 ///          typequal
 107 ///          storageclass
 108 ///
 109 /// Whether an attribute takes an 'identifier' is determined by the
 110 /// attrib-name. GCC's behavior here is not worth imitating:
 111 ///
 112 ///  * In C mode, if the attribute argument list starts with an identifier
 113 ///    followed by a ',' or an ')', and the identifier doesn't resolve to
 114 ///    a type, it is parsed as an identifier. If the attribute actually
 115 ///    wanted an expression, it's out of luck (but it turns out that no
 116 ///    attributes work that way, because C constant expressions are very
 117 ///    limited).
 118 ///  * In C++ mode, if the attribute argument list starts with an identifier,
 119 ///    and the attribute *wants* an identifier, it is parsed as an identifier.
 120 ///    At block scope, any additional tokens between the identifier and the
 121 ///    ',' or ')' are ignored, otherwise they produce a parse error.
 122 ///
 123 /// We follow the C++ model, but don't allow junk after the identifier.
 124 void Parser::ParseGNUAttributes(ParsedAttributes &attrs,
 125                                 SourceLocation *endLoc,
 126                                 LateParsedAttrList *LateAttrs,
 127                                 Declarator *D) {
 128   assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!");
 129
 130   while (Tok.is(tok::kw___attribute)) {
 131     ConsumeToken();
 132     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
 133                          "attribute")) {
 134       SkipUntil(tok::r_paren, StopAtSemi); // skip until ) or ;
 135       return;
 136     }
 137     if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
 138       SkipUntil(tok::r_paren, StopAtSemi); // skip until ) or ;
 139       return;
 140     }
 141     // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") ))
 142     while (true) {
 143       // Allow empty/non-empty attributes. ((__vector_size__(16),,,,))
 144       if (TryConsumeToken(tok::comma))
 145         continue;
 146
 147       // Expect an identifier or declaration specifier (const, int, etc.)
 148       if (Tok.isAnnotation())
 149         break;
 150       IdentifierInfo *AttrName = Tok.getIdentifierInfo();
 151       if (!AttrName)
 152         break;
 153
 154       SourceLocation AttrNameLoc = ConsumeToken();
 155
 156       if (Tok.isNot(tok::l_paren)) {
 157         attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
 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 __.
 199 static StringRef normalizeAttrName(StringRef Name) {
 200   if (Name.size() >= 4 && Name.startswith("__") && Name.endswith("__"))
 201     Name = Name.drop_front(2).drop_back(2);
 202   return Name;
 203 }
 204
 205 /// \brief Determine whether the given attribute has an identifier argument.
 206 static 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.
 215 static bool attributeIsTypeArgAttr(const IdentifierInfo &II) {
 216 #define CLANG_ATTR_TYPE_ARG_LIST
 217   return llvm::StringSwitch<bool>(normalizeAttrName(II.getName()))
 218 #include "clang/Parse/AttrParserStringSwitches.inc"
 219            .Default(false);
 220 #undef CLANG_ATTR_TYPE_ARG_LIST
 221 }
 222
 223 /// \brief Determine whether the given attribute requires parsing its arguments
 224 /// in an unevaluated context or not.
 225 static 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
 233 IdentifierLoc *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
 242 void Parser::ParseAttributeWithTypeArg(IdentifierInfo &AttrName,
 243                                        SourceLocation AttrNameLoc,
 244                                        ParsedAttributes &Attrs,
 245                                        SourceLocation *EndLoc,
 246                                        IdentifierInfo *ScopeName,
 247                                        SourceLocation ScopeLoc,
 248                                        AttributeList::Syntax Syntax) {
 249   BalancedDelimiterTracker Parens(*this, tok::l_paren);
 250   Parens.consumeOpen();
 251
 252   TypeResult T;
 253   if (Tok.isNot(tok::r_paren))
 254     T = ParseTypeName();
 255
 256   if (Parens.consumeClose())
 257     return;
 258
 259   if (T.isInvalid())
 260     return;
 261
 262   if (T.isUsable())
 263     Attrs.addNewTypeAttr(&AttrName,
 264                          SourceRange(AttrNameLoc, Parens.getCloseLocation()),
 265                          ScopeName, ScopeLoc, T.get(), Syntax);
 266   else
 267     Attrs.addNew(&AttrName, SourceRange(AttrNameLoc, Parens.getCloseLocation()),
 268                  ScopeName, ScopeLoc, nullptr, 0, Syntax);
 269 }
 270
 271 unsigned Parser::ParseAttributeArgsCommon(
 272     IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
 273     ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName,
 274     SourceLocation ScopeLoc, AttributeList::Syntax Syntax) {
 275   // Ignore the left paren location for now.
 276   ConsumeParen();
 277
 278   ArgsVector ArgExprs;
 279   if (Tok.is(tok::identifier)) {
 280     // If this attribute wants an 'identifier' argument, make it so.
 281     bool IsIdentifierArg = attributeHasIdentifierArg(*AttrName);
 282     AttributeList::Kind AttrKind =
 283         AttributeList::getKind(AttrName, ScopeName, Syntax);
 284
 285     // If we don't know how to parse this attribute, but this is the only
 286     // token in this argument, assume it's meant to be an identifier.
 287     if (AttrKind == AttributeList::UnknownAttribute ||
 288         AttrKind == AttributeList::IgnoredAttribute) {
 289       const Token &Next = NextToken();
 290       IsIdentifierArg = Next.isOneOf(tok::r_paren, tok::comma);
 291     }
 292
 293     if (IsIdentifierArg)
 294       ArgExprs.push_back(ParseIdentifierLoc());
 295   }
 296
 297   if (!ArgExprs.empty() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren)) {
 298     // Eat the comma.
 299     if (!ArgExprs.empty())
 300       ConsumeToken();
 301
 302     // Parse the non-empty comma-separated list of expressions.
 303     do {
 304       std::unique_ptr<EnterExpressionEvaluationContext> Unevaluated;
 305       if (attributeParsedArgsUnevaluated(*AttrName))
 306         Unevaluated.reset(
 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.
 335 void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName,
 336                                    SourceLocation AttrNameLoc,
 337                                    ParsedAttributes &Attrs,
 338                                    SourceLocation *EndLoc,
 339                                    IdentifierInfo *ScopeName,
 340                                    SourceLocation ScopeLoc,
 341                                    AttributeList::Syntax Syntax,
 342                                    Declarator *D) {
 343
 344   assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
 345
 346   AttributeList::Kind AttrKind =
 347       AttributeList::getKind(AttrName, ScopeName, Syntax);
 348
 349   if (AttrKind == AttributeList::AT_Availability) {
 350     ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
 351                                ScopeLoc, Syntax);
 352     return;
 353   } else if (AttrKind == AttributeList::AT_ObjCBridgeRelated) {
 354     ParseObjCBridgeRelatedAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
 355                                     ScopeName, ScopeLoc, Syntax);
 356     return;
 357   } else if (AttrKind == AttributeList::AT_TypeTagForDatatype) {
 358     ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
 359                                      ScopeName, ScopeLoc, Syntax);
 360     return;
 361   } else if (attributeIsTypeArgAttr(*AttrName)) {
 362     ParseAttributeWithTypeArg(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
 363                               ScopeLoc, Syntax);
 364     return;
 365   }
 366
 367   // These may refer to the function arguments, but need to be parsed early to
 368   // participate in determining whether it's a redeclaration.
 369   std::unique_ptr<ParseScope> PrototypeScope;
 370   if (normalizeAttrName(AttrName->getName()) == "enable_if" &&
 371       D && D->isFunctionDeclarator()) {
 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
 386 bool Parser::ParseMicrosoftDeclSpecArgs(IdentifierInfo *AttrName,
 387                                         SourceLocation AttrNameLoc,
 388                                         ParsedAttributes &Attrs) {
 389   // If the attribute isn't known, we will not attempt to parse any
 390   // arguments.
 391   if (!hasAttribute(AttrSyntax::Declspec, nullptr, AttrName,
 392                     getTargetInfo(), getLangOpts())) {
 393     // Eat the left paren, then skip to the ending right paren.
 394     ConsumeParen();
 395     SkipUntil(tok::r_paren);
 396     return false;
 397   }
 398
 399   SourceLocation OpenParenLoc = Tok.getLocation();
 400
 401   if (AttrName->getName() == "property") {
 402     // The property declspec is more complex in that it can take one or two
 403     // assignment expressions as a parameter, but the lhs of the assignment
 404     // must be named get or put.
 405
 406     BalancedDelimiterTracker T(*this, tok::l_paren);
 407     T.expectAndConsume(diag::err_expected_lparen_after,
 408                        AttrName->getNameStart(), tok::r_paren);
 409
 410     enum AccessorKind {
 411       AK_Invalid = -1,
 412       AK_Put = 0,
 413       AK_Get = 1 // indices into AccessorNames
 414     };
 415     IdentifierInfo *AccessorNames[] = {nullptr, nullptr};
 416     bool HasInvalidAccessor = false;
 417
 418     // Parse the accessor specifications.
 419     while (true) {
 420       // Stop if this doesn't look like an accessor spec.
 421       if (!Tok.is(tok::identifier)) {
 422         // If the user wrote a completely empty list, use a special diagnostic.
 423         if (Tok.is(tok::r_paren) && !HasInvalidAccessor &&
 424             AccessorNames[AK_Put] == nullptr &&
 425             AccessorNames[AK_Get] == nullptr) {
 426           Diag(AttrNameLoc, diag::err_ms_property_no_getter_or_putter);
 427           break;
 428         }
 429
 430         Diag(Tok.getLocation(), diag::err_ms_property_unknown_accessor);
 431         break;
 432       }
 433
 434       AccessorKind Kind;
 435       SourceLocation KindLoc = Tok.getLocation();
 436       StringRef KindStr = Tok.getIdentifierInfo()->getName();
 437       if (KindStr == "get") {
 438         Kind = AK_Get;
 439       } else if (KindStr == "put") {
 440         Kind = AK_Put;
 441
 442         // Recover from the common mistake of using 'set' instead of 'put'.
 443       } else if (KindStr == "set") {
 444         Diag(KindLoc, diag::err_ms_property_has_set_accessor)
 445             << FixItHint::CreateReplacement(KindLoc, "put");
 446         Kind = AK_Put;
 447
 448         // Handle the mistake of forgetting the accessor kind by skipping
 449         // this accessor.
 450       } else if (NextToken().is(tok::comma) || NextToken().is(tok::r_paren)) {
 451         Diag(KindLoc, diag::err_ms_property_missing_accessor_kind);
 452         ConsumeToken();
 453         HasInvalidAccessor = true;
 454         goto next_property_accessor;
 455
 456         // Otherwise, complain about the unknown accessor kind.
 457       } else {
 458         Diag(KindLoc, diag::err_ms_property_unknown_accessor);
 459         HasInvalidAccessor = true;
 460         Kind = AK_Invalid;
 461
 462         // Try to keep parsing unless it doesn't look like an accessor spec.
 463         if (!NextToken().is(tok::equal))
 464           break;
 465       }
 466
 467       // Consume the identifier.
 468       ConsumeToken();
 469
 470       // Consume the '='.
 471       if (!TryConsumeToken(tok::equal)) {
 472         Diag(Tok.getLocation(), diag::err_ms_property_expected_equal)
 473             << KindStr;
 474         break;
 475       }
 476
 477       // Expect the method name.
 478       if (!Tok.is(tok::identifier)) {
 479         Diag(Tok.getLocation(), diag::err_ms_property_expected_accessor_name);
 480         break;
 481       }
 482
 483       if (Kind == AK_Invalid) {
 484         // Just drop invalid accessors.
 485       } else if (AccessorNames[Kind] != nullptr) {
 486         // Complain about the repeated accessor, ignore it, and keep parsing.
 487         Diag(KindLoc, diag::err_ms_property_duplicate_accessor) << KindStr;
 488       } else {
 489         AccessorNames[Kind] = Tok.getIdentifierInfo();
 490       }
 491       ConsumeToken();
 492
 493     next_property_accessor:
 494       // Keep processing accessors until we run out.
 495       if (TryConsumeToken(tok::comma))
 496         continue;
 497
 498       // If we run into the ')', stop without consuming it.
 499       if (Tok.is(tok::r_paren))
 500         break;
 501
 502       Diag(Tok.getLocation(), diag::err_ms_property_expected_comma_or_rparen);
 503       break;
 504     }
 505
 506     // Only add the property attribute if it was well-formed.
 507     if (!HasInvalidAccessor)
 508       Attrs.addNewPropertyAttr(AttrName, AttrNameLoc, nullptr, SourceLocation(),
 509                                AccessorNames[AK_Get], AccessorNames[AK_Put],
 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
 535 void Parser::ParseMicrosoftDeclSpecs(ParsedAttributes &Attrs,
 536                                      SourceLocation *End) {
 537   assert(getLangOpts().DeclSpecKeyword && "__declspec keyword is not enabled");
 538   assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
 539
 540   while (Tok.is(tok::kw___declspec)) {
 541     ConsumeToken();
 542     BalancedDelimiterTracker T(*this, tok::l_paren);
 543     if (T.expectAndConsume(diag::err_expected_lparen_after, "__declspec",
 544                            tok::r_paren))
 545       return;
 546
 547     // An empty declspec is perfectly legal and should not warn.  Additionally,
 548     // you can specify multiple attributes per declspec.
 549     while (Tok.isNot(tok::r_paren)) {
 550       // Attribute not present.
 551       if (TryConsumeToken(tok::comma))
 552         continue;
 553
 554       // We expect either a well-known identifier or a generic string.  Anything
 555       // else is a malformed declspec.
 556       bool IsString = Tok.getKind() == tok::string_literal;
 557       if (!IsString && Tok.getKind() != tok::identifier &&
 558           Tok.getKind() != tok::kw_restrict) {
 559         Diag(Tok, diag::err_ms_declspec_type);
 560         T.skipToEnd();
 561         return;
 562       }
 563
 564       IdentifierInfo *AttrName;
 565       SourceLocation AttrNameLoc;
 566       if (IsString) {
 567         SmallString<8> StrBuffer;
 568         bool Invalid = false;
 569         StringRef Str = PP.getSpelling(Tok, StrBuffer, &Invalid);
 570         if (Invalid) {
 571           T.skipToEnd();
 572           return;
 573         }
 574         AttrName = PP.getIdentifierInfo(Str);
 575         AttrNameLoc = ConsumeStringToken();
 576       } else {
 577         AttrName = Tok.getIdentifierInfo();
 578         AttrNameLoc = ConsumeToken();
 579       }
 580
 581       bool AttrHandled = false;
 582
 583       // Parse attribute arguments.
 584       if (Tok.is(tok::l_paren))
 585         AttrHandled = ParseMicrosoftDeclSpecArgs(AttrName, AttrNameLoc, Attrs);
 586       else if (AttrName->getName() == "property")
 587         // The property attribute must have an argument list.
 588         Diag(Tok.getLocation(), diag::err_expected_lparen_after)
 589             << AttrName->getName();
 590
 591       if (!AttrHandled)
 592         Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
 593                      AttributeList::AS_Declspec);
 594     }
 595     T.consumeClose();
 596     if (End)
 597       *End = T.getCloseLocation();
 598   }
 599 }
 600
 601 void Parser::ParseMicrosoftTypeAttributes(ParsedAttributes &attrs) {
 602   // Treat these like attributes
 603   while (true) {
 604     switch (Tok.getKind()) {
 605     case tok::kw___fastcall:
 606     case tok::kw___stdcall:
 607     case tok::kw___thiscall:
 608     case tok::kw___cdecl:
 609     case tok::kw___vectorcall:
 610     case tok::kw___ptr64:
 611     case tok::kw___w64:
 612     case tok::kw___ptr32:
 613     case tok::kw___sptr:
 614     case tok::kw___uptr: {
 615       IdentifierInfo *AttrName = Tok.getIdentifierInfo();
 616       SourceLocation AttrNameLoc = ConsumeToken();
 617       attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
 618                    AttributeList::AS_Keyword);
 619       break;
 620     }
 621     default:
 622       return;
 623     }
 624   }
 625 }
 626
 627 void Parser::DiagnoseAndSkipExtendedMicrosoftTypeAttributes() {
 628   SourceLocation StartLoc = Tok.getLocation();
 629   SourceLocation EndLoc = SkipExtendedMicrosoftTypeAttributes();
 630
 631   if (EndLoc.isValid()) {
 632     SourceRange Range(StartLoc, EndLoc);
 633     Diag(StartLoc, diag::warn_microsoft_qualifiers_ignored) << Range;
 634   }
 635 }
 636
 637 SourceLocation Parser::SkipExtendedMicrosoftTypeAttributes() {
 638   SourceLocation EndLoc;
 639
 640   while (true) {
 641     switch (Tok.getKind()) {
 642     case tok::kw_const:
 643     case tok::kw_volatile:
 644     case tok::kw___fastcall:
 645     case tok::kw___stdcall:
 646     case tok::kw___thiscall:
 647     case tok::kw___cdecl:
 648     case tok::kw___vectorcall:
 649     case tok::kw___ptr32:
 650     case tok::kw___ptr64:
 651     case tok::kw___w64:
 652     case tok::kw___unaligned:
 653     case tok::kw___sptr:
 654     case tok::kw___uptr:
 655       EndLoc = ConsumeToken();
 656       break;
 657     default:
 658       return EndLoc;
 659     }
 660   }
 661 }
 662
 663 void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) {
 664   // Treat these like attributes
 665   while (Tok.is(tok::kw___pascal)) {
 666     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
 667     SourceLocation AttrNameLoc = ConsumeToken();
 668     attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
 669                  AttributeList::AS_Keyword);
 670   }
 671 }
 672
 673 void Parser::ParseOpenCLKernelAttributes(ParsedAttributes &attrs) {
 674   // Treat these like attributes
 675   while (Tok.is(tok::kw___kernel)) {
 676     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
 677     SourceLocation AttrNameLoc = ConsumeToken();
 678     attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
 679                  AttributeList::AS_Keyword);
 680   }
 681 }
 682
 683 void Parser::ParseOpenCLQualifiers(ParsedAttributes &Attrs) {
 684   IdentifierInfo *AttrName = Tok.getIdentifierInfo();
 685   SourceLocation AttrNameLoc = Tok.getLocation();
 686   Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
 687                AttributeList::AS_Keyword);
 688 }
 689
 690 void Parser::ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs) {
 691   // Treat these like attributes, even though they're type specifiers.
 692   while (true) {
 693     switch (Tok.getKind()) {
 694     case tok::kw__Nonnull:
 695     case tok::kw__Nullable:
 696     case tok::kw__Null_unspecified: {
 697       IdentifierInfo *AttrName = Tok.getIdentifierInfo();
 698       SourceLocation AttrNameLoc = ConsumeToken();
 699       if (!getLangOpts().ObjC1)
 700         Diag(AttrNameLoc, diag::ext_nullability)
 701           << AttrName;
 702       attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
 703                    AttributeList::AS_Keyword);
 704       break;
 705     }
 706     default:
 707       return;
 708     }
 709   }
 710 }
 711
 712 static bool VersionNumberSeparator(const char Separator) {
 713   return (Separator == '.' || Separator == '_');
 714 }
 715
 716 /// \brief Parse a version number.
 717 ///
 718 /// version:
 719 ///   simple-integer
 720 ///   simple-integer ',' simple-integer
 721 ///   simple-integer ',' simple-integer ',' simple-integer
 722 VersionTuple Parser::ParseVersionTuple(SourceRange &Range) {
 723   Range = SourceRange(Tok.getLocation(), Tok.getEndLoc());
 724
 725   if (!Tok.is(tok::numeric_constant)) {
 726     Diag(Tok, diag::err_expected_version);
 727     SkipUntil(tok::comma, tok::r_paren,
 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>
 858 void Parser::ParseAvailabilityAttribute(IdentifierInfo &Availability,
 859                                         SourceLocation AvailabilityLoc,
 860                                         ParsedAttributes &attrs,
 861                                         SourceLocation *endLoc,
 862                                         IdentifierInfo *ScopeName,
 863                                         SourceLocation ScopeLoc,
 864                                         AttributeList::Syntax Syntax) {
 865   enum { Introduced, Deprecated, Obsoleted, Unknown };
 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 ///
1071 void Parser::ParseObjCBridgeRelatedAttribute(IdentifierInfo &ObjCBridgeRelated,
1072                                 SourceLocation ObjCBridgeRelatedLoc,
1073                                 ParsedAttributes &attrs,
1074                                 SourceLocation *endLoc,
1075                                 IdentifierInfo *ScopeName,
1076                                 SourceLocation ScopeLoc,
1077                                 AttributeList::Syntax Syntax) {
1078   // Opening '('.
1079   BalancedDelimiterTracker T(*this, tok::l_paren);
1080   if (T.consumeOpen()) {
1081     Diag(Tok, diag::err_expected) << tok::l_paren;
1082     return;
1083   }
1084
1085   // Parse the related class name.
1086   if (Tok.isNot(tok::identifier)) {
1087     Diag(Tok, diag::err_objcbridge_related_expected_related_class);
1088     SkipUntil(tok::r_paren, StopAtSemi);
1089     return;
1090   }
1091   IdentifierLoc *RelatedClass = ParseIdentifierLoc();
1092   if (ExpectAndConsume(tok::comma)) {
1093     SkipUntil(tok::r_paren, StopAtSemi);
1094     return;
1095   }
1096
1097   // Parse optional class method name.
1098   IdentifierLoc *ClassMethod = nullptr;
1099   if (Tok.is(tok::identifier)) {
1100     ClassMethod = ParseIdentifierLoc();
1101     if (!TryConsumeToken(tok::colon)) {
1102       Diag(Tok, diag::err_objcbridge_related_selector_name);
1103       SkipUntil(tok::r_paren, StopAtSemi);
1104       return;
1105     }
1106   }
1107   if (!TryConsumeToken(tok::comma)) {
1108     if (Tok.is(tok::colon))
1109       Diag(Tok, diag::err_objcbridge_related_selector_name);
1110     else
1111       Diag(Tok, diag::err_expected) << tok::comma;
1112     SkipUntil(tok::r_paren, StopAtSemi);
1113     return;
1114   }
1115
1116   // Parse optional instance method name.
1117   IdentifierLoc *InstanceMethod = nullptr;
1118   if (Tok.is(tok::identifier))
1119     InstanceMethod = ParseIdentifierLoc();
1120   else if (Tok.isNot(tok::r_paren)) {
1121     Diag(Tok, diag::err_expected) << tok::r_paren;
1122     SkipUntil(tok::r_paren, StopAtSemi);
1123     return;
1124   }
1125
1126   // Closing ')'.
1127   if (T.consumeClose())
1128     return;
1129
1130   if (endLoc)
1131     *endLoc = T.getCloseLocation();
1132
1133   // Record this attribute
1134   attrs.addNew(&ObjCBridgeRelated,
1135                SourceRange(ObjCBridgeRelatedLoc, T.getCloseLocation()),
1136                ScopeName, ScopeLoc,
1137                RelatedClass,
1138                ClassMethod,
1139                InstanceMethod,
1140                Syntax);
1141 }
1142
1143 // Late Parsed Attributes:
1144 // See other examples of late parsing in lib/Parse/ParseCXXInlineMethods
1145
1146 void Parser::LateParsedDeclaration::ParseLexedAttributes() {}
1147
1148 void Parser::LateParsedClass::ParseLexedAttributes() {
1149   Self->ParseLexedAttributes(*Class);
1150 }
1151
1152 void Parser::LateParsedAttribute::ParseLexedAttributes() {
1153   Self->ParseLexedAttribute(*this, true, false);
1154 }
1155
1156 /// Wrapper class which calls ParseLexedAttribute, after setting up the
1157 /// scope appropriately.
1158 void Parser::ParseLexedAttributes(ParsingClass &Class) {
1159   // Deal with templates
1160   // FIXME: Test cases to make sure this does the right thing for templates.
1161   bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope;
1162   ParseScope ClassTemplateScope(this, Scope::TemplateParamScope,
1163                                 HasTemplateScope);
1164   if (HasTemplateScope)
1165     Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate);
1166
1167   // Set or update the scope flags.
1168   bool AlreadyHasClassScope = Class.TopLevelClass;
1169   unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope;
1170   ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope);
1171   ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope);
1172
1173   // Enter the scope of nested classes
1174   if (!AlreadyHasClassScope)
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.
1189 void Parser::ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D,
1190                                      bool EnterScope, bool OnDefinition) {
1191   assert(LAs.parseSoon() &&
1192          "Attribute list should be marked for immediate parsing.");
1193   for (unsigned i = 0, ni = LAs.size(); i < ni; ++i) {
1194     if (D)
1195       LAs[i]->addDecl(D);
1196     ParseLexedAttribute(*LAs[i], EnterScope, OnDefinition);
1197     delete LAs[i];
1198   }
1199   LAs.clear();
1200 }
1201
1202 /// \brief Finish parsing an attribute for which parsing was delayed.
1203 /// This will be called at the end of parsing a class declaration
1204 /// for each LateParsedAttribute. We consume the saved tokens and
1205 /// create an attribute with the arguments filled in. We add this
1206 /// to the Attribute list for the decl.
1207 void Parser::ParseLexedAttribute(LateParsedAttribute &LA,
1208                                  bool EnterScope, bool OnDefinition) {
1209   // Create a fake EOF so that attribute parsing won't go off the end of the
1210   // attribute.
1211   Token AttrEnd;
1212   AttrEnd.startToken();
1213   AttrEnd.setKind(tok::eof);
1214   AttrEnd.setLocation(Tok.getLocation());
1215   AttrEnd.setEofData(LA.Toks.data());
1216   LA.Toks.push_back(AttrEnd);
1217
1218   // Append the current token at the end of the new token stream so that it
1219   // doesn't get lost.
1220   LA.Toks.push_back(Tok);
1221   PP.EnterTokenStream(LA.Toks, true);
1222   // Consume the previously pushed token.
1223   ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
1224
1225   ParsedAttributes Attrs(AttrFactory);
1226   SourceLocation endLoc;
1227
1228   if (LA.Decls.size() > 0) {
1229     Decl *D = LA.Decls[0];
1230     NamedDecl *ND  = dyn_cast<NamedDecl>(D);
1231     RecordDecl *RD = dyn_cast_or_null<RecordDecl>(D->getDeclContext());
1232
1233     // Allow 'this' within late-parsed attributes.
1234     Sema::CXXThisScopeRAII ThisScope(Actions, RD, /*TypeQuals=*/0,
1235                                      ND && ND->isCXXInstanceMember());
1236
1237     if (LA.Decls.size() == 1) {
1238       // If the Decl is templatized, add template parameters to scope.
1239       bool HasTemplateScope = EnterScope && D->isTemplateDecl();
1240       ParseScope TempScope(this, Scope::TemplateParamScope, HasTemplateScope);
1241       if (HasTemplateScope)
1242         Actions.ActOnReenterTemplateScope(Actions.CurScope, D);
1243
1244       // If the Decl is on a function, add function parameters to the scope.
1245       bool HasFunScope = EnterScope && D->isFunctionOrFunctionTemplate();
1246       ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope, HasFunScope);
1247       if (HasFunScope)
1248         Actions.ActOnReenterFunctionContext(Actions.CurScope, D);
1249
1250       ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc,
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
1290 void Parser::ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName,
1291                                               SourceLocation AttrNameLoc,
1292                                               ParsedAttributes &Attrs,
1293                                               SourceLocation *EndLoc,
1294                                               IdentifierInfo *ScopeName,
1295                                               SourceLocation ScopeLoc,
1296                                               AttributeList::Syntax Syntax) {
1297   assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('");
1298
1299   BalancedDelimiterTracker T(*this, tok::l_paren);
1300   T.consumeOpen();
1301
1302   if (Tok.isNot(tok::identifier)) {
1303     Diag(Tok, diag::err_expected) << tok::identifier;
1304     T.skipToEnd();
1305     return;
1306   }
1307   IdentifierLoc *ArgumentKind = ParseIdentifierLoc();
1308
1309   if (ExpectAndConsume(tok::comma)) {
1310     T.skipToEnd();
1311     return;
1312   }
1313
1314   SourceRange MatchingCTypeRange;
1315   TypeResult MatchingCType = ParseTypeName(&MatchingCTypeRange);
1316   if (MatchingCType.isInvalid()) {
1317     T.skipToEnd();
1318     return;
1319   }
1320
1321   bool LayoutCompatible = false;
1322   bool MustBeNull = false;
1323   while (TryConsumeToken(tok::comma)) {
1324     if (Tok.isNot(tok::identifier)) {
1325       Diag(Tok, diag::err_expected) << tok::identifier;
1326       T.skipToEnd();
1327       return;
1328     }
1329     IdentifierInfo *Flag = Tok.getIdentifierInfo();
1330     if (Flag->isStr("layout_compatible"))
1331       LayoutCompatible = true;
1332     else if (Flag->isStr("must_be_null"))
1333       MustBeNull = true;
1334     else {
1335       Diag(Tok, diag::err_type_safety_unknown_flag) << Flag;
1336       T.skipToEnd();
1337       return;
1338     }
1339     ConsumeToken(); // consume flag
1340   }
1341
1342   if (!T.consumeClose()) {
1343     Attrs.addNewTypeTagForDatatype(&AttrName, AttrNameLoc, ScopeName, ScopeLoc,
1344                                    ArgumentKind, MatchingCType.get(),
1345                                    LayoutCompatible, MustBeNull, Syntax);
1346   }
1347
1348   if (EndLoc)
1349     *EndLoc = T.getCloseLocation();
1350 }
1351
1352 /// DiagnoseProhibitedCXX11Attribute - We have found the opening square brackets
1353 /// of a C++11 attribute-specifier in a location where an attribute is not
1354 /// permitted. By C++11 [dcl.attr.grammar]p6, this is ill-formed. Diagnose this
1355 /// situation.
1356 ///
1357 /// \return \c true if we skipped an attribute-like chunk of tokens, \c false if
1358 /// this doesn't appear to actually be an attribute-specifier, and the caller
1359 /// should try to parse it.
1360 bool Parser::DiagnoseProhibitedCXX11Attribute() {
1361   assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square));
1362
1363   switch (isCXX11AttributeSpecifier(/*Disambiguate*/true)) {
1364   case CAK_NotAttributeSpecifier:
1365     // No diagnostic: we're in Obj-C++11 and this is not actually an attribute.
1366     return false;
1367
1368   case CAK_InvalidAttributeSpecifier:
1369     Diag(Tok.getLocation(), diag::err_l_square_l_square_not_attribute);
1370     return false;
1371
1372   case CAK_AttributeSpecifier:
1373     // Parse and discard the attributes.
1374     SourceLocation BeginLoc = ConsumeBracket();
1375     ConsumeBracket();
1376     SkipUntil(tok::r_square);
1377     assert(Tok.is(tok::r_square) && "isCXX11AttributeSpecifier lied");
1378     SourceLocation EndLoc = ConsumeBracket();
1379     Diag(BeginLoc, diag::err_attributes_not_allowed)
1380       << SourceRange(BeginLoc, EndLoc);
1381     return true;
1382   }
1383   llvm_unreachable("All cases handled above.");
1384 }
1385
1386 /// \brief We have found the opening square brackets of a C++11
1387 /// attribute-specifier in a location where an attribute is not permitted, but
1388 /// we know where the attributes ought to be written. Parse them anyway, and
1389 /// provide a fixit moving them to the right place.
1390 void Parser::DiagnoseMisplacedCXX11Attribute(ParsedAttributesWithRange &Attrs,
1391                                              SourceLocation CorrectLocation) {
1392   assert((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) ||
1393          Tok.is(tok::kw_alignas));
1394
1395   // Consume the attributes.
1396   SourceLocation Loc = Tok.getLocation();
1397   ParseCXX11Attributes(Attrs);
1398   CharSourceRange AttrRange(SourceRange(Loc, Attrs.Range.getEnd()), true);
1399
1400   Diag(Loc, diag::err_attributes_not_allowed)
1401     << FixItHint::CreateInsertionFromRange(CorrectLocation, AttrRange)
1402     << FixItHint::CreateRemoval(AttrRange);
1403 }
1404
1405 void Parser::DiagnoseProhibitedAttributes(ParsedAttributesWithRange &attrs) {
1406   Diag(attrs.Range.getBegin(), diag::err_attributes_not_allowed)
1407     << attrs.Range;
1408 }
1409
1410 void Parser::ProhibitCXX11Attributes(ParsedAttributesWithRange &attrs) {
1411   AttributeList *AttrList = attrs.getList();
1412   while (AttrList) {
1413     if (AttrList->isCXX11Attribute()) {
1414       Diag(AttrList->getLoc(), diag::err_attribute_not_type_attr)
1415         << AttrList->getName();
1416       AttrList->setInvalid();
1417     }
1418     AttrList = AttrList->getNext();
1419   }
1420 }
1421
1422 // As an exception to the rule, __declspec(align(...)) before the
1423 // class-key affects the type instead of the variable.
1424 void Parser::handleDeclspecAlignBeforeClassKey(ParsedAttributesWithRange &Attrs,
1425                                                DeclSpec &DS,
1426                                                Sema::TagUseKind TUK) {
1427   if (TUK == Sema::TUK_Reference)
1428     return;
1429
1430   ParsedAttributes &PA = DS.getAttributes();
1431   AttributeList *AL = PA.getList();
1432   AttributeList *Prev = nullptr;
1433   while (AL) {
1434     AttributeList *Next = AL->getNext();
1435
1436     // We only consider attributes using the appropriate '__declspec' spelling.
1437     // This behavior doesn't extend to any other spellings.
1438     if (AL->getKind() == AttributeList::AT_Aligned &&
1439         AL->isDeclspecAttribute()) {
1440       // Stitch the attribute into the tag's attribute list.
1441       AL->setNext(nullptr);
1442       Attrs.add(AL);
1443
1444       // Remove the attribute from the variable's attribute list.
1445       if (Prev) {
1446         // Set the last variable attribute's next attribute to be the attribute
1447         // after the current one.
1448         Prev->setNext(Next);
1449       } else {
1450         // Removing the head of the list requires us to reset the head to the
1451         // next attribute.
1452         PA.set(Next);
1453       }
1454     } else {
1455       Prev = AL;
1456     }
1457
1458     AL = Next;
1459   }
1460 }
1461
1462 /// ParseDeclaration - Parse a full 'declaration', which consists of
1463 /// declaration-specifiers, some number of declarators, and a semicolon.
1464 /// 'Context' should be a Declarator::TheContext value.  This returns the
1465 /// location of the semicolon in DeclEnd.
1466 ///
1467 ///       declaration: [C99 6.7]
1468 ///         block-declaration ->
1469 ///           simple-declaration
1470 ///           others                   [FIXME]
1471 /// [C++]   template-declaration
1472 /// [C++]   namespace-definition
1473 /// [C++]   using-directive
1474 /// [C++]   using-declaration
1475 /// [C++11/C11] static_assert-declaration
1476 ///         others... [FIXME]
1477 ///
1478 Parser::DeclGroupPtrTy Parser::ParseDeclaration(unsigned Context,
1479                                                 SourceLocation &DeclEnd,
1480                                           ParsedAttributesWithRange &attrs) {
1481   ParenBraceBracketBalancer BalancerRAIIObj(*this);
1482   // Must temporarily exit the objective-c container scope for
1483   // parsing c none objective-c decls.
1484   ObjCDeclContextSwitch ObjCDC(*this);
1485
1486   Decl *SingleDecl = nullptr;
1487   Decl *OwnedType = nullptr;
1488   switch (Tok.getKind()) {
1489   case tok::kw_template:
1490   case tok::kw_export:
1491     ProhibitAttributes(attrs);
1492     SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd);
1493     break;
1494   case tok::kw_inline:
1495     // Could be the start of an inline namespace. Allowed as an ext in C++03.
1496     if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_namespace)) {
1497       ProhibitAttributes(attrs);
1498       SourceLocation InlineLoc = ConsumeToken();
1499       return ParseNamespace(Context, DeclEnd, InlineLoc);
1500     }
1501     return ParseSimpleDeclaration(Context, DeclEnd, attrs,
1502                                   true);
1503   case tok::kw_namespace:
1504     ProhibitAttributes(attrs);
1505     return ParseNamespace(Context, DeclEnd);
1506   case tok::kw_using:
1507     SingleDecl = ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(),
1508                                                   DeclEnd, attrs, &OwnedType);
1509     break;
1510   case tok::kw_static_assert:
1511   case tok::kw__Static_assert:
1512     ProhibitAttributes(attrs);
1513     SingleDecl = ParseStaticAssertDeclaration(DeclEnd);
1514     break;
1515   default:
1516     return ParseSimpleDeclaration(Context, DeclEnd, attrs, true);
1517   }
1518
1519   // This routine returns a DeclGroup, if the thing we parsed only contains a
1520   // single decl, convert it now. Alias declarations can also declare a type;
1521   // include that too if it is present.
1522   return Actions.ConvertDeclToDeclGroup(SingleDecl, OwnedType);
1523 }
1524
1525 ///       simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
1526 ///         declaration-specifiers init-declarator-list[opt] ';'
1527 /// [C++11] attribute-specifier-seq decl-specifier-seq[opt]
1528 ///             init-declarator-list ';'
1529 ///[C90/C++]init-declarator-list ';'                             [TODO]
1530 /// [OMP]   threadprivate-directive                              [TODO]
1531 ///
1532 ///       for-range-declaration: [C++11 6.5p1: stmt.ranged]
1533 ///         attribute-specifier-seq[opt] type-specifier-seq declarator
1534 ///
1535 /// If RequireSemi is false, this does not check for a ';' at the end of the
1536 /// declaration.  If it is true, it checks for and eats it.
1537 ///
1538 /// If FRI is non-null, we might be parsing a for-range-declaration instead
1539 /// of a simple-declaration. If we find that we are, we also parse the
1540 /// for-range-initializer, and place it here.
1541 Parser::DeclGroupPtrTy
1542 Parser::ParseSimpleDeclaration(unsigned Context,
1543                                SourceLocation &DeclEnd,
1544                                ParsedAttributesWithRange &Attrs,
1545                                bool RequireSemi, ForRangeInit *FRI) {
1546   // Parse the common declaration-specifiers piece.
1547   ParsingDeclSpec DS(*this);
1548
1549   DeclSpecContext DSContext = getDeclSpecContextFromDeclaratorContext(Context);
1550   ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none, DSContext);
1551
1552   // If we had a free-standing type definition with a missing semicolon, we
1553   // may get this far before the problem becomes obvious.
1554   if (DS.hasTagDefinition() &&
1555       DiagnoseMissingSemiAfterTagDefinition(DS, AS_none, DSContext))
1556     return nullptr;
1557
1558   // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
1559   // declaration-specifiers init-declarator-list[opt] ';'
1560   if (Tok.is(tok::semi)) {
1561     ProhibitAttributes(Attrs);
1562     DeclEnd = Tok.getLocation();
1563     if (RequireSemi) ConsumeToken();
1564     RecordDecl *AnonRecord = nullptr;
1565     Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
1566                                                        DS, AnonRecord);
1567     DS.complete(TheDecl);
1568     if (AnonRecord) {
1569       Decl* decls[] = {AnonRecord, TheDecl};
1570       return Actions.BuildDeclaratorGroup(decls, /*TypeMayContainAuto=*/false);
1571     }
1572     return Actions.ConvertDeclToDeclGroup(TheDecl);
1573   }
1574
1575   DS.takeAttributesFrom(Attrs);
1576   return ParseDeclGroup(DS, Context, &DeclEnd, FRI);
1577 }
1578
1579 /// Returns true if this might be the start of a declarator, or a common typo
1580 /// for a declarator.
1581 bool Parser::MightBeDeclarator(unsigned Context) {
1582   switch (Tok.getKind()) {
1583   case tok::annot_cxxscope:
1584   case tok::annot_template_id:
1585   case tok::caret:
1586   case tok::code_completion:
1587   case tok::coloncolon:
1588   case tok::ellipsis:
1589   case tok::kw___attribute:
1590   case tok::kw_operator:
1591   case tok::l_paren:
1592   case tok::star:
1593     return true;
1594
1595   case tok::amp:
1596   case tok::ampamp:
1597     return getLangOpts().CPlusPlus;
1598
1599   case tok::l_square: // Might be an attribute on an unnamed bit-field.
1600     return Context == Declarator::MemberContext && getLangOpts().CPlusPlus11 &&
1601            NextToken().is(tok::l_square);
1602
1603   case tok::colon: // Might be a typo for '::' or an unnamed bit-field.
1604     return Context == Declarator::MemberContext || getLangOpts().CPlusPlus;
1605
1606   case tok::identifier:
1607     switch (NextToken().getKind()) {
1608     case tok::code_completion:
1609     case tok::coloncolon:
1610     case tok::comma:
1611     case tok::equal:
1612     case tok::equalequal: // Might be a typo for '='.
1613     case tok::kw_alignas:
1614     case tok::kw_asm:
1615     case tok::kw___attribute:
1616     case tok::l_brace:
1617     case tok::l_paren:
1618     case tok::l_square:
1619     case tok::less:
1620     case tok::r_brace:
1621     case tok::r_paren:
1622     case tok::r_square:
1623     case tok::semi:
1624       return true;
1625
1626     case tok::colon:
1627       // At namespace scope, 'identifier:' is probably a typo for 'identifier::'
1628       // and in block scope it's probably a label. Inside a class definition,
1629       // this is a bit-field.
1630       return Context == Declarator::MemberContext ||
1631              (getLangOpts().CPlusPlus && Context == Declarator::FileContext);
1632
1633     case tok::identifier: // Possible virt-specifier.
1634       return getLangOpts().CPlusPlus11 && isCXX11VirtSpecifier(NextToken());
1635
1636     default:
1637       return false;
1638     }
1639
1640   default:
1641     return false;
1642   }
1643 }
1644
1645 /// Skip until we reach something which seems like a sensible place to pick
1646 /// up parsing after a malformed declaration. This will sometimes stop sooner
1647 /// than SkipUntil(tok::r_brace) would, but will never stop later.
1648 void 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.
1729 Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS,
1730                                               unsigned Context,
1731                                               SourceLocation *DeclEnd,
1732                                               ForRangeInit *FRI) {
1733   // Parse the first declarator.
1734   ParsingDeclarator D(*this, DS, static_cast<Declarator::TheContext>(Context));
1735   ParseDeclarator(D);
1736
1737   // Bail out if the first declarator didn't seem well-formed.
1738   if (!D.hasName() && !D.mayOmitIdentifier()) {
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.
1915 bool Parser::ParseAsmAttributesAfterDeclarator(Declarator &D) {
1916   // If a simple-asm-expr is present, parse it.
1917   if (Tok.is(tok::kw_asm)) {
1918     SourceLocation Loc;
1919     ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1920     if (AsmLabel.isInvalid()) {
1921       SkipUntil(tok::semi, StopBeforeMatch);
1922       return true;
1923     }
1924
1925     D.setAsmLabel(AsmLabel.get());
1926     D.SetRangeEnd(Loc);
1927   }
1928
1929   MaybeParseGNUAttributes(D);
1930   return false;
1931 }
1932
1933 /// \brief Parse 'declaration' after parsing 'declaration-specifiers
1934 /// declarator'. This method parses the remainder of the declaration
1935 /// (including any attributes or initializer, among other things) and
1936 /// finalizes the declaration.
1937 ///
1938 ///       init-declarator: [C99 6.7]
1939 ///         declarator
1940 ///         declarator '=' initializer
1941 /// [GNU]   declarator simple-asm-expr[opt] attributes[opt]
1942 /// [GNU]   declarator simple-asm-expr[opt] attributes[opt] '=' initializer
1943 /// [C++]   declarator initializer[opt]
1944 ///
1945 /// [C++] initializer:
1946 /// [C++]   '=' initializer-clause
1947 /// [C++]   '(' expression-list ')'
1948 /// [C++0x] '=' 'default'                                                [TODO]
1949 /// [C++0x] '=' 'delete'
1950 /// [C++0x] braced-init-list
1951 ///
1952 /// According to the standard grammar, =default and =delete are function
1953 /// definitions, but that definitely doesn't fit with the parser here.
1954 ///
1955 Decl *Parser::ParseDeclarationAfterDeclarator(
1956     Declarator &D, const ParsedTemplateInfo &TemplateInfo) {
1957   if (ParseAsmAttributesAfterDeclarator(D))
1958     return nullptr;
1959
1960   return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo);
1961 }
1962
1963 Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(
1964     Declarator &D, const ParsedTemplateInfo &TemplateInfo, ForRangeInit *FRI) {
1965   // Inform the current actions module that we just parsed this declarator.
1966   Decl *ThisDecl = nullptr;
1967   switch (TemplateInfo.Kind) {
1968   case ParsedTemplateInfo::NonTemplate:
1969     ThisDecl = Actions.ActOnDeclarator(getCurScope(), D);
1970     break;
1971
1972   case ParsedTemplateInfo::Template:
1973   case ParsedTemplateInfo::ExplicitSpecialization: {
1974     ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(),
1975                                                *TemplateInfo.TemplateParams,
1976                                                D);
1977     if (VarTemplateDecl *VT = dyn_cast_or_null<VarTemplateDecl>(ThisDecl))
1978       // Re-direct this decl to refer to the templated decl so that we can
1979       // initialize it.
1980       ThisDecl = VT->getTemplatedDecl();
1981     break;
1982   }
1983   case ParsedTemplateInfo::ExplicitInstantiation: {
1984     if (Tok.is(tok::semi)) {
1985       DeclResult ThisRes = Actions.ActOnExplicitInstantiation(
1986           getCurScope(), TemplateInfo.ExternLoc, TemplateInfo.TemplateLoc, D);
1987       if (ThisRes.isInvalid()) {
1988         SkipUntil(tok::semi, StopBeforeMatch);
1989         return nullptr;
1990       }
1991       ThisDecl = ThisRes.get();
1992     } else {
1993       // FIXME: This check should be for a variable template instantiation only.
1994
1995       // Check that this is a valid instantiation
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 ///
2168 void Parser::ParseSpecifierQualifierList(DeclSpec &DS, AccessSpecifier AS,
2169                                          DeclSpecContext DSC) {
2170   /// specifier-qualifier-list is a subset of declaration-specifiers.  Just
2171   /// parse declaration-specifiers and complain about extra stuff.
2172   /// TODO: diagnose attribute-specifiers and alignment-specifiers.
2173   ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC);
2174
2175   // Validate declspec for type-name.
2176   unsigned Specs = DS.getParsedSpecifiers();
2177   if (isTypeSpecifier(DSC) && !DS.hasTypeSpecifier()) {
2178     Diag(Tok, diag::err_expected_type);
2179     DS.SetTypeSpecError();
2180   } else if (Specs == DeclSpec::PQ_None && !DS.hasAttributes()) {
2181     Diag(Tok, diag::err_typename_requires_specqual);
2182     if (!DS.hasTypeSpecifier())
2183       DS.SetTypeSpecError();
2184   }
2185
2186   // Issue diagnostic and remove storage class if present.
2187   if (Specs & DeclSpec::PQ_StorageClassSpecifier) {
2188     if (DS.getStorageClassSpecLoc().isValid())
2189       Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass);
2190     else
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 ///
2232 static 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 ///
2247 bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
2248                               const ParsedTemplateInfo &TemplateInfo,
2249                               AccessSpecifier AS, DeclSpecContext DSC,
2250                               ParsedAttributesWithRange &Attrs) {
2251   assert(Tok.is(tok::identifier) && "should have identifier");
2252
2253   SourceLocation Loc = Tok.getLocation();
2254   // If we see an identifier that is not a type name, we normally would
2255   // parse it as the identifer being declared.  However, when a typename
2256   // is typo'd or the definition is not included, this will incorrectly
2257   // parse the typename as the identifier name and fall over misparsing
2258   // later parts of the diagnostic.
2259   //
2260   // As such, we try to do some look-ahead in cases where this would
2261   // otherwise be an "implicit-int" case to see if this is invalid.  For
2262   // example: "static foo_t x = 4;"  In this case, if we parsed foo_t as
2263   // an identifier with implicit int, we'd get a parse error because the
2264   // next token is obviously invalid for a type.  Parse these as a case
2265   // with an invalid type specifier.
2266   assert(!DS.hasTypeSpecifier() && "Type specifier checked above");
2267
2268   // Since we know that this either implicit int (which is rare) or an
2269   // error, do lookahead to try to do better recovery. This never applies
2270   // within a type specifier. Outside of C++, we allow this even if the
2271   // language doesn't "officially" support implicit int -- we support
2272   // implicit int as an extension in C99 and C11.
2273   if (!isTypeSpecifier(DSC) && !getLangOpts().CPlusPlus &&
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.
2459 Parser::DeclSpecContext
2460 Parser::getDeclSpecContextFromDeclaratorContext(unsigned Context) {
2461   if (Context == Declarator::MemberContext)
2462     return DSC_class;
2463   if (Context == Declarator::FileContext)
2464     return DSC_top_level;
2465   if (Context == Declarator::TemplateTypeArgContext)
2466     return DSC_template_type_arg;
2467   if (Context == Declarator::TrailingReturnContext)
2468     return DSC_trailing;
2469   if (Context == Declarator::AliasDeclContext ||
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]
2484 ExprResult 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] ')'
2510 void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs,
2511                                      SourceLocation *EndLoc) {
2512   assert(Tok.isOneOf(tok::kw_alignas, tok::kw__Alignas) &&
2513          "Not an alignment-specifier!");
2514
2515   IdentifierInfo *KWName = Tok.getIdentifierInfo();
2516   SourceLocation KWLoc = ConsumeToken();
2517
2518   BalancedDelimiterTracker T(*this, tok::l_paren);
2519   if (T.expectAndConsume())
2520     return;
2521
2522   SourceLocation EllipsisLoc;
2523   ExprResult ArgExpr = ParseAlignArgument(T.getOpenLocation(), EllipsisLoc);
2524   if (ArgExpr.isInvalid()) {
2525     T.skipToEnd();
2526     return;
2527   }
2528
2529   T.consumeClose();
2530   if (EndLoc)
2531     *EndLoc = T.getCloseLocation();
2532
2533   ArgsVector ArgExprs;
2534   ArgExprs.push_back(ArgExpr.get());
2535   Attrs.addNew(KWName, KWLoc, nullptr, KWLoc, ArgExprs.data(), 1,
2536                AttributeList::AS_Keyword, EllipsisLoc);
2537 }
2538
2539 /// Determine whether we're looking at something that might be a declarator
2540 /// in a simple-declaration. If it can't possibly be a declarator, maybe
2541 /// diagnose a missing semicolon after a prior tag definition in the decl
2542 /// specifier.
2543 ///
2544 /// \return \c true if an error occurred and this can't be any kind of
2545 /// declaration.
2546 bool
2547 Parser::DiagnoseMissingSemiAfterTagDefinition(DeclSpec &DS, AccessSpecifier AS,
2548                                               DeclSpecContext DSContext,
2549                                               LateParsedAttrList *LateAttrs) {
2550   assert(DS.hasTagDefinition() && "shouldn't call this");
2551
2552   bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level);
2553
2554   if (getLangOpts().CPlusPlus &&
2555       Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_decltype,
2556                   tok::annot_template_id) &&
2557       TryAnnotateCXXScopeToken(EnteringContext)) {
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]
2673 void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
2674                                         const ParsedTemplateInfo &TemplateInfo,
2675                                         AccessSpecifier AS,
2676                                         DeclSpecContext DSContext,
2677                                         LateParsedAttrList *LateAttrs) {
2678   if (DS.getSourceRange().isInvalid()) {
2679     // Start the range at the current token but make the end of the range
2680     // invalid.  This will make the entire range invalid unless we successfully
2681     // consume a token.
2682     DS.SetRangeStart(Tok.getLocation());
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 ///
3585 void Parser::ParseStructDeclaration(
3586     ParsingDeclSpec &DS,
3587     llvm::function_ref<void(ParsingFieldDeclarator &)> FieldsCallback) {
3588
3589   if (Tok.is(tok::kw___extension__)) {
3590     // __extension__ silences extension warnings in the subexpression.
3591     ExtensionRAIIObject O(Diags);  // Use RAII to do this.
3592     ConsumeToken();
3593     return ParseStructDeclaration(DS, FieldsCallback);
3594   }
3595
3596   // Parse the common specifier-qualifiers-list piece.
3597   ParseSpecifierQualifierList(DS);
3598
3599   // If there are no declarators, this is a free-standing declaration
3600   // specifier. Let the actions module cope with it.
3601   if (Tok.is(tok::semi)) {
3602     RecordDecl *AnonRecord = nullptr;
3603     Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
3604                                                        DS, AnonRecord);
3605     assert(!AnonRecord && "Did not expect anonymous struct or union here");
3606     DS.complete(TheDecl);
3607     return;
3608   }
3609
3610   // Read struct-declarators until we find the semicolon.
3611   bool FirstDeclarator = true;
3612   SourceLocation CommaLoc;
3613   while (1) {
3614     ParsingFieldDeclarator DeclaratorInfo(*this, DS);
3615     DeclaratorInfo.D.setCommaLoc(CommaLoc);
3616
3617     // Attributes are only allowed here on successive declarators.
3618     if (!FirstDeclarator)
3619       MaybeParseGNUAttributes(DeclaratorInfo.D);
3620
3621     /// struct-declarator: declarator
3622     /// struct-declarator: declarator[opt] ':' constant-expression
3623     if (Tok.isNot(tok::colon)) {
3624       // Don't parse FOO:BAR as if it were a typo for FOO::BAR.
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 ///
3663 void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
3664                                   unsigned TagType, Decl *TagDecl) {
3665   PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc,
3666                                       "parsing struct/union body");
3667   assert(!getLangOpts().CPlusPlus && "C++ declarations not supported");
3668
3669   BalancedDelimiterTracker T(*this, tok::l_brace);
3670   if (T.consumeOpen())
3671     return;
3672
3673   ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
3674   Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
3675
3676   SmallVector<Decl *, 32> FieldDecls;
3677
3678   // While we still have something to read, read the declarations in the struct.
3679   while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) &&
3680          Tok.isNot(tok::eof)) {
3681     // Each iteration of this loop reads one struct-declaration.
3682
3683     // Check for extraneous top-level semicolon.
3684     if (Tok.is(tok::semi)) {
3685       ConsumeExtraSemi(InsideStruct, TagType);
3686       continue;
3687     }
3688
3689     // Parse _Static_assert declaration.
3690     if (Tok.is(tok::kw__Static_assert)) {
3691       SourceLocation DeclEnd;
3692       ParseStaticAssertDeclaration(DeclEnd);
3693       continue;
3694     }
3695
3696     if (Tok.is(tok::annot_pragma_pack)) {
3697       HandlePragmaPack();
3698       continue;
3699     }
3700
3701     if (Tok.is(tok::annot_pragma_align)) {
3702       HandlePragmaAlign();
3703       continue;
3704     }
3705
3706     if (Tok.is(tok::annot_pragma_openmp)) {
3707       // Result can be ignored, because it must be always empty.
3708       AccessSpecifier AS = AS_none;
3709       ParsedAttributesWithRange Attrs(AttrFactory);
3710       (void)ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs);
3711       continue;
3712     }
3713
3714     if (!Tok.is(tok::at)) {
3715       auto CFieldCallback = [&](ParsingFieldDeclarator &FD) {
3716         // Install the declarator into the current TagDecl.
3717         Decl *Field =
3718             Actions.ActOnField(getCurScope(), TagDecl,
3719                                FD.D.getDeclSpec().getSourceRange().getBegin(),
3720                                FD.D, FD.BitfieldSize);
3721         FieldDecls.push_back(Field);
3722         FD.complete(Field);
3723       };
3724
3725       // Parse all the comma separated declarators.
3726       ParsingDeclSpec DS(*this);
3727       ParseStructDeclaration(DS, CFieldCallback);
3728     } else { // Handle @defs
3729       ConsumeToken();
3730       if (!Tok.isObjCAtKeyword(tok::objc_defs)) {
3731         Diag(Tok, diag::err_unexpected_at);
3732         SkipUntil(tok::semi);
3733         continue;
3734       }
3735       ConsumeToken();
3736       ExpectAndConsume(tok::l_paren);
3737       if (!Tok.is(tok::identifier)) {
3738         Diag(Tok, diag::err_expected) << tok::identifier;
3739         SkipUntil(tok::semi);
3740         continue;
3741       }
3742       SmallVector<Decl *, 16> Fields;
3743       Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(),
3744                         Tok.getIdentifierInfo(), Fields);
3745       FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end());
3746       ConsumeToken();
3747       ExpectAndConsume(tok::r_paren);
3748     }
3749
3750     if (TryConsumeToken(tok::semi))
3751       continue;
3752
3753     if (Tok.is(tok::r_brace)) {
3754       ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list);
3755       break;
3756     }
3757
3758     ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list);
3759     // Skip to end of block or statement to avoid ext-warning on extra ';'.
3760     SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
3761     // If we stopped at a ';', eat it.
3762     TryConsumeToken(tok::semi);
3763   }
3764
3765   T.consumeClose();
3766
3767   ParsedAttributes attrs(AttrFactory);
3768   // If attributes exist after struct contents, parse them.
3769   MaybeParseGNUAttributes(attrs);
3770
3771   Actions.ActOnFields(getCurScope(),
3772                       RecordLoc, TagDecl, FieldDecls,
3773                       T.getOpenLocation(), T.getCloseLocation(),
3774                       attrs.getList());
3775   StructScope.Exit();
3776   Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl, T.getRange());
3777 }
3778
3779 /// ParseEnumSpecifier
3780 ///       enum-specifier: [C99 6.7.2.2]
3781 ///         'enum' identifier[opt] '{' enumerator-list '}'
3782 ///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
3783 /// [GNU]   'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
3784 ///                                                 '}' attributes[opt]
3785 /// [MS]    'enum' __declspec[opt] identifier[opt] '{' enumerator-list ',' [opt]
3786 ///                                                 '}'
3787 ///         'enum' identifier
3788 /// [GNU]   'enum' attributes[opt] identifier
3789 ///
3790 /// [C++11] enum-head '{' enumerator-list[opt] '}'
3791 /// [C++11] enum-head '{' enumerator-list ','  '}'
3792 ///
3793 ///       enum-head: [C++11]
3794 ///         enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]
3795 ///         enum-key attribute-specifier-seq[opt] nested-name-specifier
3796 ///             identifier enum-base[opt]
3797 ///
3798 ///       enum-key: [C++11]
3799 ///         'enum'
3800 ///         'enum' 'class'
3801 ///         'enum' 'struct'
3802 ///
3803 ///       enum-base: [C++11]
3804 ///         ':' type-specifier-seq
3805 ///
3806 /// [C++] elaborated-type-specifier:
3807 /// [C++]   'enum' '::'[opt] nested-name-specifier[opt] identifier
3808 ///
3809 void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
3810                                 const ParsedTemplateInfo &TemplateInfo,
3811                                 AccessSpecifier AS, DeclSpecContext DSC) {
3812   // Parse the tag portion of this.
3813   if (Tok.is(tok::code_completion)) {
3814     // Code completion for an enum name.
3815     Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum);
3816     return cutOffParsing();
3817   }
3818
3819   // If attributes exist after tag, parse them.
3820   ParsedAttributesWithRange attrs(AttrFactory);
3821   MaybeParseGNUAttributes(attrs);
3822   MaybeParseCXX11Attributes(attrs);
3823   MaybeParseMicrosoftDeclSpecs(attrs);
3824
3825   SourceLocation ScopedEnumKWLoc;
3826   bool IsScopedUsingClassTag = false;
3827
3828   // In C++11, recognize 'enum class' and 'enum struct'.
3829   if (Tok.isOneOf(tok::kw_class, tok::kw_struct)) {
3830     Diag(Tok, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_scoped_enum
3831                                         : diag::ext_scoped_enum);
3832     IsScopedUsingClassTag = Tok.is(tok::kw_class);
3833     ScopedEnumKWLoc = ConsumeToken();
3834
3835     // Attributes are not allowed between these keywords.  Diagnose,
3836     // but then just treat them like they appeared in the right place.
3837     ProhibitAttributes(attrs);
3838
3839     // They are allowed afterwards, though.
3840     MaybeParseGNUAttributes(attrs);
3841     MaybeParseCXX11Attributes(attrs);
3842     MaybeParseMicrosoftDeclSpecs(attrs);
3843   }
3844
3845   // C++11 [temp.explicit]p12:
3846   //   The usual access controls do not apply to names used to specify
3847   //   explicit instantiations.
3848   // We extend this to also cover explicit specializations.  Note that
3849   // we don't suppress if this turns out to be an elaborated type
3850   // specifier.
3851   bool shouldDelayDiagsInTag =
3852     (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
3853      TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
3854   SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag);
3855
3856   // Enum definitions should not be parsed in a trailing-return-type.
3857   bool AllowDeclaration = DSC != DSC_trailing;
3858
3859   bool AllowFixedUnderlyingType = AllowDeclaration &&
3860     (getLangOpts().CPlusPlus11 || getLangOpts().MicrosoftExt ||
3861      getLangOpts().ObjC2);
3862
3863   CXXScopeSpec &SS = DS.getTypeSpecScope();
3864   if (getLangOpts().CPlusPlus) {
3865     // "enum foo : bar;" is not a potential typo for "enum foo::bar;"
3866     // if a fixed underlying type is allowed.
3867     ColonProtectionRAIIObject X(*this, AllowFixedUnderlyingType);
3868
3869     CXXScopeSpec Spec;
3870     if (ParseOptionalCXXScopeSpecifier(Spec, nullptr,
3871                                        /*EnteringContext=*/true))
3872       return;
3873
3874     if (Spec.isSet() && Tok.isNot(tok::identifier)) {
3875       Diag(Tok, diag::err_expected) << tok::identifier;
3876       if (Tok.isNot(tok::l_brace)) {
3877         // Has no name and is not a definition.
3878         // Skip the rest of this declarator, up until the comma or semicolon.
3879         SkipUntil(tok::comma, StopAtSemi);
3880         return;
3881       }
3882     }
3883
3884     SS = Spec;
3885   }
3886
3887   // Must have either 'enum name' or 'enum {...}'.
3888   if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) &&
3889       !(AllowFixedUnderlyingType && Tok.is(tok::colon))) {
3890     Diag(Tok, diag::err_expected_either) << tok::identifier << tok::l_brace;
3891
3892     // Skip the rest of this declarator, up until the comma or semicolon.
3893     SkipUntil(tok::comma, StopAtSemi);
3894     return;
3895   }
3896
3897   // If an identifier is present, consume and remember it.
3898   IdentifierInfo *Name = nullptr;
3899   SourceLocation NameLoc;
3900   if (Tok.is(tok::identifier)) {
3901     Name = Tok.getIdentifierInfo();
3902     NameLoc = ConsumeToken();
3903   }
3904
3905   if (!Name && ScopedEnumKWLoc.isValid()) {
3906     // C++0x 7.2p2: The optional identifier shall not be omitted in the
3907     // declaration of a scoped enumeration.
3908     Diag(Tok, diag::err_scoped_enum_missing_identifier);
3909     ScopedEnumKWLoc = SourceLocation();
3910     IsScopedUsingClassTag = false;
3911   }
3912
3913   // Okay, end the suppression area.  We'll decide whether to emit the
3914   // diagnostics in a second.
3915   if (shouldDelayDiagsInTag)
3916     diagsFromTag.done();
3917
3918   TypeResult BaseType;
3919
3920   // Parse the fixed underlying type.
3921   bool CanBeBitfield = getCurScope()->getFlags() & Scope::ClassScope;
3922   if (AllowFixedUnderlyingType && Tok.is(tok::colon)) {
3923     bool PossibleBitfield = false;
3924     if (CanBeBitfield) {
3925       // If we're in class scope, this can either be an enum declaration with
3926       // an underlying type, or a declaration of a bitfield member. We try to
3927       // use a simple disambiguation scheme first to catch the common cases
3928       // (integer literal, sizeof); if it's still ambiguous, we then consider
3929       // anything that's a simple-type-specifier followed by '(' as an
3930       // expression. This suffices because function types are not valid
3931       // underlying types anyway.
3932       EnterExpressionEvaluationContext Unevaluated(Actions,
3933                                                    Sema::ConstantEvaluated);
3934       TPResult TPR = isExpressionOrTypeSpecifierSimple(NextToken().getKind());
3935       // If the next token starts an expression, we know we're parsing a
3936       // bit-field. This is the common case.
3937       if (TPR == TPResult::True)
3938         PossibleBitfield = true;
3939       // If the next token starts a type-specifier-seq, it may be either a
3940       // a fixed underlying type or the start of a function-style cast in C++;
3941       // lookahead one more token to see if it's obvious that we have a
3942       // fixed underlying type.
3943       else if (TPR == TPResult::False &&
3944                GetLookAheadToken(2).getKind() == tok::semi) {
3945         // Consume the ':'.
3946         ConsumeToken();
3947       } else {
3948         // We have the start of a type-specifier-seq, so we have to perform
3949         // tentative parsing to determine whether we have an expression or a
3950         // type.
3951         TentativeParsingAction TPA(*this);
3952
3953         // Consume the ':'.
3954         ConsumeToken();
3955
3956         // If we see a type specifier followed by an open-brace, we have an
3957         // ambiguity between an underlying type and a C++11 braced
3958         // function-style cast. Resolve this by always treating it as an
3959         // underlying type.
3960         // FIXME: The standard is not entirely clear on how to disambiguate in
3961         // this case.
3962         if ((getLangOpts().CPlusPlus &&
3963              isCXXDeclarationSpecifier(TPResult::True) != TPResult::True) ||
3964             (!getLangOpts().CPlusPlus && !isDeclarationSpecifier(true))) {
3965           // We'll parse this as a bitfield later.
3966           PossibleBitfield = true;
3967           TPA.Revert();
3968         } else {
3969           // We have a type-specifier-seq.
3970           TPA.Commit();
3971         }
3972       }
3973     } else {
3974       // Consume the ':'.
3975       ConsumeToken();
3976     }
3977
3978     if (!PossibleBitfield) {
3979       SourceRange Range;
3980       BaseType = ParseTypeName(&Range);
3981
3982       if (getLangOpts().CPlusPlus11) {
3983         Diag(StartLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type);
3984       } else if (!getLangOpts().ObjC2) {
3985         if (getLangOpts().CPlusPlus)
3986           Diag(StartLoc, diag::ext_cxx11_enum_fixed_underlying_type) << Range;
3987         else
3988           Diag(StartLoc, diag::ext_c_enum_fixed_underlying_type) << Range;
3989       }
3990     }
3991   }
3992
3993   // There are four options here.  If we have 'friend enum foo;' then this is a
3994   // friend declaration, and cannot have an accompanying definition. If we have
3995   // 'enum foo;', then this is a forward declaration.  If we have
3996   // 'enum foo {...' then this is a definition. Otherwise we have something
3997   // like 'enum foo xyz', a reference.
3998   //
3999   // This is needed to handle stuff like this right (C99 6.7.2.3p11):
4000   // enum foo {..};  void bar() { enum foo; }    <- new foo in bar.
4001   // enum foo {..};  void bar() { enum foo x; }  <- use of old foo.
4002   //
4003   Sema::TagUseKind TUK;
4004   if (!AllowDeclaration) {
4005     TUK = Sema::TUK_Reference;
4006   } else if (Tok.is(tok::l_brace)) {
4007     if (DS.isFriendSpecified()) {
4008       Diag(Tok.getLocation(), diag::err_friend_decl_defines_type)
4009         << SourceRange(DS.getFriendSpecLoc());
4010       ConsumeBrace();
4011       SkipUntil(tok::r_brace, StopAtSemi);
4012       TUK = Sema::TUK_Friend;
4013     } else {
4014       TUK = Sema::TUK_Definition;
4015     }
4016   } else if (!isTypeSpecifier(DSC) &&
4017              (Tok.is(tok::semi) ||
4018               (Tok.isAtStartOfLine() &&
4019                !isValidAfterTypeSpecifier(CanBeBitfield)))) {
4020     TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration;
4021     if (Tok.isNot(tok::semi)) {
4022       // A semicolon was missing after this declaration. Diagnose and recover.
4023       ExpectAndConsume(tok::semi, diag::err_expected_after, "enum");
4024       PP.EnterToken(Tok);
4025       Tok.setKind(tok::semi);
4026     }
4027   } else {
4028     TUK = Sema::TUK_Reference;
4029   }
4030
4031   // If this is an elaborated type specifier, and we delayed
4032   // diagnostics before, just merge them into the current pool.
4033   if (TUK == Sema::TUK_Reference && shouldDelayDiagsInTag) {
4034     diagsFromTag.redelay();
4035   }
4036
4037   MultiTemplateParamsArg TParams;
4038   if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
4039       TUK != Sema::TUK_Reference) {
4040     if (!getLangOpts().CPlusPlus11 || !SS.isSet()) {
4041       // Skip the rest of this declarator, up until the comma or semicolon.
4042       Diag(Tok, diag::err_enum_template);
4043       SkipUntil(tok::comma, StopAtSemi);
4044       return;
4045     }
4046
4047     if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) {
4048       // Enumerations can't be explicitly instantiated.
4049       DS.SetTypeSpecError();
4050       Diag(StartLoc, diag::err_explicit_instantiation_enum);
4051       return;
4052     }
4053
4054     assert(TemplateInfo.TemplateParams && "no template parameters");
4055     TParams = MultiTemplateParamsArg(TemplateInfo.TemplateParams->data(),
4056                                      TemplateInfo.TemplateParams->size());
4057   }
4058
4059   if (TUK == Sema::TUK_Reference)
4060     ProhibitAttributes(attrs);
4061
4062   if (!Name && TUK != Sema::TUK_Definition) {
4063     Diag(Tok, diag::err_enumerator_unnamed_no_def);
4064
4065     // Skip the rest of this declarator, up until the comma or semicolon.
4066     SkipUntil(tok::comma, StopAtSemi);
4067     return;
4068   }
4069
4070   handleDeclspecAlignBeforeClassKey(attrs, DS, TUK);
4071
4072   Sema::SkipBodyInfo SkipBody;
4073   if (!Name && TUK == Sema::TUK_Definition && Tok.is(tok::l_brace) &&
4074       NextToken().is(tok::identifier))
4075     SkipBody = Actions.shouldSkipAnonEnumBody(getCurScope(),
4076                                               NextToken().getIdentifierInfo(),
4077                                               NextToken().getLocation());
4078
4079   bool Owned = false;
4080   bool IsDependent = false;
4081   const char *PrevSpec = nullptr;
4082   unsigned DiagID;
4083   Decl *TagDecl = Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK,
4084                                    StartLoc, SS, Name, NameLoc, attrs.getList(),
4085                                    AS, DS.getModulePrivateSpecLoc(), TParams,
4086                                    Owned, IsDependent, ScopedEnumKWLoc,
4087                                    IsScopedUsingClassTag, BaseType,
4088                                    DSC == DSC_type_specifier, &SkipBody);
4089
4090   if (SkipBody.ShouldSkip) {
4091     assert(TUK == Sema::TUK_Definition && "can only skip a definition");
4092
4093     BalancedDelimiterTracker T(*this, tok::l_brace);
4094     T.consumeOpen();
4095     T.skipToEnd();
4096
4097     if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
4098                            NameLoc.isValid() ? NameLoc : StartLoc,
4099                            PrevSpec, DiagID, TagDecl, Owned,
4100                            Actions.getASTContext().getPrintingPolicy()))
4101       Diag(StartLoc, DiagID) << PrevSpec;
4102     return;
4103   }
4104
4105   if (IsDependent) {
4106     // This enum has a dependent nested-name-specifier. Handle it as a
4107     // dependent tag.
4108     if (!Name) {
4109       DS.SetTypeSpecError();
4110       Diag(Tok, diag::err_expected_type_name_after_typename);
4111       return;
4112     }
4113
4114     TypeResult Type = Actions.ActOnDependentTag(
4115         getCurScope(), DeclSpec::TST_enum, TUK, SS, Name, StartLoc, NameLoc);
4116     if (Type.isInvalid()) {
4117       DS.SetTypeSpecError();
4118       return;
4119     }
4120
4121     if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
4122                            NameLoc.isValid() ? NameLoc : StartLoc,
4123                            PrevSpec, DiagID, Type.get(),
4124                            Actions.getASTContext().getPrintingPolicy()))
4125       Diag(StartLoc, DiagID) << PrevSpec;
4126
4127     return;
4128   }
4129
4130   if (!TagDecl) {
4131     // The action failed to produce an enumeration tag. If this is a
4132     // definition, consume the entire definition.
4133     if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference) {
4134       ConsumeBrace();
4135       SkipUntil(tok::r_brace, StopAtSemi);
4136     }
4137
4138     DS.SetTypeSpecError();
4139     return;
4140   }
4141
4142   if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference)
4143     ParseEnumBody(StartLoc, TagDecl);
4144
4145   if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
4146                          NameLoc.isValid() ? NameLoc : StartLoc,
4147                          PrevSpec, DiagID, TagDecl, Owned,
4148                          Actions.getASTContext().getPrintingPolicy()))
4149     Diag(StartLoc, DiagID) << PrevSpec;
4150 }
4151
4152 /// ParseEnumBody - Parse a {} enclosed enumerator-list.
4153 ///       enumerator-list:
4154 ///         enumerator
4155 ///         enumerator-list ',' enumerator
4156 ///       enumerator:
4157 ///         enumeration-constant attributes[opt]
4158 ///         enumeration-constant attributes[opt] '=' constant-expression
4159 ///       enumeration-constant:
4160 ///         identifier
4161 ///
4162 void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) {
4163   // Enter the scope of the enum body and start the definition.
4164   ParseScope EnumScope(this, Scope::DeclScope | Scope::EnumScope);
4165   Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl);
4166
4167   BalancedDelimiterTracker T(*this, tok::l_brace);
4168   T.consumeOpen();
4169
4170   // C does not allow an empty enumerator-list, C++ does [dcl.enum].
4171   if (Tok.is(tok::r_brace) && !getLangOpts().CPlusPlus)
4172     Diag(Tok, diag::error_empty_enum);
4173
4174   SmallVector<Decl *, 32> EnumConstantDecls;
4175   SmallVector<SuppressAccessChecks, 32> EnumAvailabilityDiags;
4176
4177   Decl *LastEnumConstDecl = nullptr;
4178
4179   // Parse the enumerator-list.
4180   while (Tok.isNot(tok::r_brace)) {
4181     // Parse enumerator. If failed, try skipping till the start of the next
4182     // enumerator definition.
4183     if (Tok.isNot(tok::identifier)) {
4184       Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
4185       if (SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch) &&
4186           TryConsumeToken(tok::comma))
4187         continue;
4188       break;
4189     }
4190     IdentifierInfo *Ident = Tok.getIdentifierInfo();
4191     SourceLocation IdentLoc = ConsumeToken();
4192
4193     // If attributes exist after the enumerator, parse them.
4194     ParsedAttributesWithRange attrs(AttrFactory);
4195     MaybeParseGNUAttributes(attrs);
4196     ProhibitAttributes(attrs); // GNU-style attributes are prohibited.
4197     if (getLangOpts().CPlusPlus11 && isCXX11AttributeSpecifier()) {
4198       if (!getLangOpts().CPlusPlus1z)
4199         Diag(Tok.getLocation(), diag::warn_cxx14_compat_attribute)
4200             << 1 /*enumerator*/;
4201       ParseCXX11Attributes(attrs);
4202     }
4203
4204     SourceLocation EqualLoc;
4205     ExprResult AssignedVal;
4206     EnumAvailabilityDiags.emplace_back(*this);
4207
4208     if (TryConsumeToken(tok::equal, EqualLoc)) {
4209       AssignedVal = ParseConstantExpression();
4210       if (AssignedVal.isInvalid())
4211         SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch);
4212     }
4213
4214     // Install the enumerator constant into EnumDecl.
4215     Decl *EnumConstDecl = Actions.ActOnEnumConstant(getCurScope(), EnumDecl,
4216                                                     LastEnumConstDecl,
4217                                                     IdentLoc, Ident,
4218                                                     attrs.getList(), EqualLoc,
4219                                                     AssignedVal.get());
4220     EnumAvailabilityDiags.back().done();
4221
4222     EnumConstantDecls.push_back(EnumConstDecl);
4223     LastEnumConstDecl = EnumConstDecl;
4224
4225     if (Tok.is(tok::identifier)) {
4226       // We're missing a comma between enumerators.
4227       SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation);
4228       Diag(Loc, diag::err_enumerator_list_missing_comma)
4229         << FixItHint::CreateInsertion(Loc, ", ");
4230       continue;
4231     }
4232
4233     // Emumerator definition must be finished, only comma or r_brace are
4234     // allowed here.
4235     SourceLocation CommaLoc;
4236     if (Tok.isNot(tok::r_brace) && !TryConsumeToken(tok::comma, CommaLoc)) {
4237       if (EqualLoc.isValid())
4238         Diag(Tok.getLocation(), diag::err_expected_either) << tok::r_brace
4239                                                            << tok::comma;
4240       else
4241         Diag(Tok.getLocation(), diag::err_expected_end_of_enumerator);
4242       if (SkipUntil(tok::comma, tok::r_brace, StopBeforeMatch)) {
4243         if (TryConsumeToken(tok::comma, CommaLoc))
4244           continue;
4245       } else {
4246         break;
4247       }
4248     }
4249
4250     // If comma is followed by r_brace, emit appropriate warning.
4251     if (Tok.is(tok::r_brace) && CommaLoc.isValid()) {
4252       if (!getLangOpts().C99 && !getLangOpts().CPlusPlus11)
4253         Diag(CommaLoc, getLangOpts().CPlusPlus ?
4254                diag::ext_enumerator_list_comma_cxx :
4255                diag::ext_enumerator_list_comma_c)
4256           << FixItHint::CreateRemoval(CommaLoc);
4257       else if (getLangOpts().CPlusPlus11)
4258         Diag(CommaLoc, diag::warn_cxx98_compat_enumerator_list_comma)
4259           << FixItHint::CreateRemoval(CommaLoc);
4260       break;
4261     }
4262   }
4263
4264   // Eat the }.
4265   T.consumeClose();
4266
4267   // If attributes exist after the identifier list, parse them.
4268   ParsedAttributes attrs(AttrFactory);
4269   MaybeParseGNUAttributes(attrs);
4270
4271   Actions.ActOnEnumBody(StartLoc, T.getRange(),
4272                         EnumDecl, EnumConstantDecls,
4273                         getCurScope(),
4274                         attrs.getList());
4275
4276   // Now handle enum constant availability diagnostics.
4277   assert(EnumConstantDecls.size() == EnumAvailabilityDiags.size());
4278   for (size_t i = 0, e = EnumConstantDecls.size(); i != e; ++i) {
4279     ParsingDeclRAIIObject PD(*this, ParsingDeclRAIIObject::NoParent);
4280     EnumAvailabilityDiags[i].redelay();
4281     PD.complete(EnumConstantDecls[i]);
4282   }
4283
4284   EnumScope.Exit();
4285   Actions.ActOnTagFinishDefinition(getCurScope(), EnumDecl, T.getRange());
4286
4287   // The next token must be valid after an enum definition. If not, a ';'
4288   // was probably forgotten.
4289   bool CanBeBitfield = getCurScope()->getFlags() & Scope::ClassScope;
4290   if (!isValidAfterTypeSpecifier(CanBeBitfield)) {
4291     ExpectAndConsume(tok::semi, diag::err_expected_after, "enum");
4292     // Push this token back into the preprocessor and change our current token
4293     // to ';' so that the rest of the code recovers as though there were an
4294     // ';' after the definition.
4295     PP.EnterToken(Tok);
4296     Tok.setKind(tok::semi);
4297   }
4298 }
4299
4300 /// isKnownToBeTypeSpecifier - Return true if we know that the specified token
4301 /// is definitely a type-specifier.  Return false if it isn't part of a type
4302 /// specifier or if we're not sure.
4303 bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const {
4304   switch (Tok.getKind()) {
4305   default: return false;
4306     // type-specifiers
4307   case tok::kw_short:
4308   case tok::kw_long:
4309   case tok::kw___int64:
4310   case tok::kw___int128:
4311   case tok::kw_signed:
4312   case tok::kw_unsigned:
4313   case tok::kw__Complex:
4314   case tok::kw__Imaginary:
4315   case tok::kw_void:
4316   case tok::kw_char:
4317   case tok::kw_wchar_t:
4318   case tok::kw_char16_t:
4319   case tok::kw_char32_t:
4320   case tok::kw_int:
4321   case tok::kw_half:
4322   case tok::kw_float:
4323   case tok::kw_double:
4324   case tok::kw___float128:
4325   case tok::kw_bool:
4326   case tok::kw__Bool:
4327   case tok::kw__Decimal32:
4328   case tok::kw__Decimal64:
4329   case tok::kw__Decimal128:
4330   case tok::kw___vector:
4331 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
4332 #include "clang/Basic/OpenCLImageTypes.def"
4333
4334     // struct-or-union-specifier (C99) or class-specifier (C++)
4335   case tok::kw_class:
4336   case tok::kw_struct:
4337   case tok::kw___interface:
4338   case tok::kw_union:
4339     // enum-specifier
4340   case tok::kw_enum:
4341
4342     // typedef-name
4343   case tok::annot_typename:
4344     return true;
4345   }
4346 }
4347
4348 /// isTypeSpecifierQualifier - Return true if the current token could be the
4349 /// start of a specifier-qualifier-list.
4350 bool Parser::isTypeSpecifierQualifier() {
4351   switch (Tok.getKind()) {
4352   default: return false;
4353
4354   case tok::identifier:   // foo::bar
4355     if (TryAltiVecVectorToken())
4356       return true;
4357     // Fall through.
4358   case tok::kw_typename:  // typename T::type
4359     // Annotate typenames and C++ scope specifiers.  If we get one, just
4360     // recurse to handle whatever we get.
4361     if (TryAnnotateTypeOrScopeToken())
4362       return true;
4363     if (Tok.is(tok::identifier))
4364       return false;
4365     return isTypeSpecifierQualifier();
4366
4367   case tok::coloncolon:   // ::foo::bar
4368     if (NextToken().is(tok::kw_new) ||    // ::new
4369         NextToken().is(tok::kw_delete))   // ::delete
4370       return false;
4371
4372     if (TryAnnotateTypeOrScopeToken())
4373       return true;
4374     return isTypeSpecifierQualifier();
4375
4376     // GNU attributes support.
4377   case tok::kw___attribute:
4378     // GNU typeof support.
4379   case tok::kw_typeof:
4380
4381     // type-specifiers
4382   case tok::kw_short:
4383   case tok::kw_long:
4384   case tok::kw___int64:
4385   case tok::kw___int128:
4386   case tok::kw_signed:
4387   case tok::kw_unsigned:
4388   case tok::kw__Complex:
4389   case tok::kw__Imaginary:
4390   case tok::kw_void:
4391   case tok::kw_char:
4392   case tok::kw_wchar_t:
4393   case tok::kw_char16_t:
4394   case tok::kw_char32_t:
4395   case tok::kw_int:
4396   case tok::kw_half:
4397   case tok::kw_float:
4398   case tok::kw_double:
4399   case tok::kw___float128:
4400   case tok::kw_bool:
4401   case tok::kw__Bool:
4402   case tok::kw__Decimal32:
4403   case tok::kw__Decimal64:
4404   case tok::kw__Decimal128:
4405   case tok::kw___vector:
4406 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
4407 #include "clang/Basic/OpenCLImageTypes.def"
4408
4409     // struct-or-union-specifier (C99) or class-specifier (C++)
4410   case tok::kw_class:
4411   case tok::kw_struct:
4412   case tok::kw___interface:
4413   case tok::kw_union:
4414     // enum-specifier
4415   case tok::kw_enum:
4416
4417     // type-qualifier
4418   case tok::kw_const:
4419   case tok::kw_volatile:
4420   case tok::kw_restrict:
4421
4422     // Debugger support.
4423   case tok::kw___unknown_anytype:
4424
4425     // typedef-name
4426   case tok::annot_typename:
4427     return true;
4428
4429     // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
4430   case tok::less:
4431     return getLangOpts().ObjC1;
4432
4433   case tok::kw___cdecl:
4434   case tok::kw___stdcall:
4435   case tok::kw___fastcall:
4436   case tok::kw___thiscall:
4437   case tok::kw___vectorcall:
4438   case tok::kw___w64:
4439   case tok::kw___ptr64:
4440   case tok::kw___ptr32:
4441   case tok::kw___pascal:
4442   case tok::kw___unaligned:
4443
4444   case tok::kw__Nonnull:
4445   case tok::kw__Nullable:
4446   case tok::kw__Null_unspecified:
4447
4448   case tok::kw___kindof:
4449
4450   case tok::kw___private:
4451   case tok::kw___local:
4452   case tok::kw___global:
4453   case tok::kw___constant:
4454   case tok::kw___generic:
4455   case tok::kw___read_only:
4456   case tok::kw___read_write:
4457   case tok::kw___write_only:
4458
4459     return true;
4460
4461   // C11 _Atomic
4462   case tok::kw__Atomic:
4463     return true;
4464   }
4465 }
4466
4467 /// isDeclarationSpecifier() - Return true if the current token is part of a
4468 /// declaration specifier.
4469 ///
4470 /// \param DisambiguatingWithExpression True to indicate that the purpose of
4471 /// this check is to disambiguate between an expression and a declaration.
4472 bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
4473   switch (Tok.getKind()) {
4474   default: return false;
4475
4476   case tok::kw_pipe:
4477     return getLangOpts().OpenCL && (getLangOpts().OpenCLVersion >= 200);
4478
4479   case tok::identifier:   // foo::bar
4480     // Unfortunate hack to support "Class.factoryMethod" notation.
4481     if (getLangOpts().ObjC1 && NextToken().is(tok::period))
4482       return false;
4483     if (TryAltiVecVectorToken())
4484       return true;
4485     // Fall through.
4486   case tok::kw_decltype: // decltype(T())::type
4487   case tok::kw_typename: // typename T::type
4488     // Annotate typenames and C++ scope specifiers.  If we get one, just
4489     // recurse to handle whatever we get.
4490     if (TryAnnotateTypeOrScopeToken())
4491       return true;
4492     if (Tok.is(tok::identifier))
4493       return false;
4494
4495     // If we're in Objective-C and we have an Objective-C class type followed
4496     // by an identifier and then either ':' or ']', in a place where an
4497     // expression is permitted, then this is probably a class message send
4498     // missing the initial '['. In this case, we won't consider this to be
4499     // the start of a declaration.
4500     if (DisambiguatingWithExpression &&
4501         isStartOfObjCClassMessageMissingOpenBracket())
4502       return false;
4503
4504     return isDeclarationSpecifier();
4505
4506   case tok::coloncolon:   // ::foo::bar
4507     if (NextToken().is(tok::kw_new) ||    // ::new
4508         NextToken().is(tok::kw_delete))   // ::delete
4509       return false;
4510
4511     // Annotate typenames and C++ scope specifiers.  If we get one, just
4512     // recurse to handle whatever we get.
4513     if (TryAnnotateTypeOrScopeToken())
4514       return true;
4515     return isDeclarationSpecifier();
4516
4517     // storage-class-specifier
4518   case tok::kw_typedef:
4519   case tok::kw_extern:
4520   case tok::kw___private_extern__:
4521   case tok::kw_static:
4522   case tok::kw_auto:
4523   case tok::kw___auto_type:
4524   case tok::kw_register:
4525   case tok::kw___thread:
4526   case tok::kw_thread_local:
4527   case tok::kw__Thread_local:
4528
4529     // Modules
4530   case tok::kw___module_private__:
4531
4532     // Debugger support
4533   case tok::kw___unknown_anytype:
4534
4535     // type-specifiers
4536   case tok::kw_short:
4537   case tok::kw_long:
4538   case tok::kw___int64:
4539   case tok::kw___int128:
4540   case tok::kw_signed:
4541   case tok::kw_unsigned:
4542   case tok::kw__Complex:
4543   case tok::kw__Imaginary:
4544   case tok::kw_void:
4545   case tok::kw_char:
4546   case tok::kw_wchar_t:
4547   case tok::kw_char16_t:
4548   case tok::kw_char32_t:
4549
4550   case tok::kw_int:
4551   case tok::kw_half:
4552   case tok::kw_float:
4553   case tok::kw_double:
4554   case tok::kw___float128:
4555   case tok::kw_bool:
4556   case tok::kw__Bool:
4557   case tok::kw__Decimal32:
4558   case tok::kw__Decimal64:
4559   case tok::kw__Decimal128:
4560   case tok::kw___vector:
4561
4562     // struct-or-union-specifier (C99) or class-specifier (C++)
4563   case tok::kw_class:
4564   case tok::kw_struct:
4565   case tok::kw_union:
4566   case tok::kw___interface:
4567     // enum-specifier
4568   case tok::kw_enum:
4569
4570     // type-qualifier
4571   case tok::kw_const:
4572   case tok::kw_volatile:
4573   case tok::kw_restrict:
4574
4575     // function-specifier
4576   case tok::kw_inline:
4577   case tok::kw_virtual:
4578   case tok::kw_explicit:
4579   case tok::kw__Noreturn:
4580
4581     // alignment-specifier
4582   case tok::kw__Alignas:
4583
4584     // friend keyword.
4585   case tok::kw_friend:
4586
4587     // static_assert-declaration
4588   case tok::kw__Static_assert:
4589
4590     // GNU typeof support.
4591   case tok::kw_typeof:
4592
4593     // GNU attributes.
4594   case tok::kw___attribute:
4595
4596     // C++11 decltype and constexpr.
4597   case tok::annot_decltype:
4598   case tok::kw_constexpr:
4599
4600     // C++ Concepts TS - concept
4601   case tok::kw_concept:
4602
4603     // C11 _Atomic
4604   case tok::kw__Atomic:
4605     return true;
4606
4607     // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
4608   case tok::less:
4609     return getLangOpts().ObjC1;
4610
4611     // typedef-name
4612   case tok::annot_typename:
4613     return !DisambiguatingWithExpression ||
4614            !isStartOfObjCClassMessageMissingOpenBracket();
4615
4616   case tok::kw___declspec:
4617   case tok::kw___cdecl:
4618   case tok::kw___stdcall:
4619   case tok::kw___fastcall:
4620   case tok::kw___thiscall:
4621   case tok::kw___vectorcall:
4622   case tok::kw___w64:
4623   case tok::kw___sptr:
4624   case tok::kw___uptr:
4625   case tok::kw___ptr64:
4626   case tok::kw___ptr32:
4627   case tok::kw___forceinline:
4628   case tok::kw___pascal:
4629   case tok::kw___unaligned:
4630
4631   case tok::kw__Nonnull:
4632   case tok::kw__Nullable:
4633   case tok::kw__Null_unspecified:
4634
4635   case tok::kw___kindof:
4636
4637   case tok::kw___private:
4638   case tok::kw___local:
4639   case tok::kw___global:
4640   case tok::kw___constant:
4641   case tok::kw___generic:
4642   case tok::kw___read_only:
4643   case tok::kw___read_write:
4644   case tok::kw___write_only:
4645 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
4646 #include "clang/Basic/OpenCLImageTypes.def"
4647
4648     return true;
4649   }
4650 }
4651
4652 bool Parser::isConstructorDeclarator(bool IsUnqualified) {
4653   TentativeParsingAction TPA(*this);
4654
4655   // Parse the C++ scope specifier.
4656   CXXScopeSpec SS;
4657   if (ParseOptionalCXXScopeSpecifier(SS, nullptr,
4658                                      /*EnteringContext=*/true)) {
4659     TPA.Revert();
4660     return false;
4661   }
4662
4663   // Parse the constructor name.
4664   if (Tok.isOneOf(tok::identifier, tok::annot_template_id)) {
4665     // We already know that we have a constructor name; just consume
4666     // the token.
4667     ConsumeToken();
4668   } else {
4669     TPA.Revert();
4670     return false;
4671   }
4672
4673   // Current class name must be followed by a left parenthesis.
4674   if (Tok.isNot(tok::l_paren)) {
4675     TPA.Revert();
4676     return false;
4677   }
4678   ConsumeParen();
4679
4680   // A right parenthesis, or ellipsis followed by a right parenthesis signals
4681   // that we have a constructor.
4682   if (Tok.is(tok::r_paren) ||
4683       (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren))) {
4684     TPA.Revert();
4685     return true;
4686   }
4687
4688   // A C++11 attribute here signals that we have a constructor, and is an
4689   // attribute on the first constructor parameter.
4690   if (getLangOpts().CPlusPlus11 &&
4691       isCXX11AttributeSpecifier(/*Disambiguate*/ false,
4692                                 /*OuterMightBeMessageSend*/ true)) {
4693     TPA.Revert();
4694     return true;
4695   }
4696
4697   // If we need to, enter the specified scope.
4698   DeclaratorScopeObj DeclScopeObj(*this, SS);
4699   if (SS.isSet() && Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
4700     DeclScopeObj.EnterDeclaratorScope();
4701
4702   // Optionally skip Microsoft attributes.
4703   ParsedAttributes Attrs(AttrFactory);
4704   MaybeParseMicrosoftAttributes(Attrs);
4705
4706   // Check whether the next token(s) are part of a declaration
4707   // specifier, in which case we have the start of a parameter and,
4708   // therefore, we know that this is a constructor.
4709   bool IsConstructor = false;
4710   if (isDeclarationSpecifier())
4711     IsConstructor = true;
4712   else if (Tok.is(tok::identifier) ||
4713            (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier))) {
4714     // We've seen "C ( X" or "C ( X::Y", but "X" / "X::Y" is not a type.
4715     // This might be a parenthesized member name, but is more likely to
4716     // be a constructor declaration with an invalid argument type. Keep
4717     // looking.
4718     if (Tok.is(tok::annot_cxxscope))
4719       ConsumeToken();
4720     ConsumeToken();
4721
4722     // If this is not a constructor, we must be parsing a declarator,
4723     // which must have one of the following syntactic forms (see the
4724     // grammar extract at the start of ParseDirectDeclarator):
4725     switch (Tok.getKind()) {
4726     case tok::l_paren:
4727       // C(X   (   int));
4728     case tok::l_square:
4729       // C(X   [   5]);
4730       // C(X   [   [attribute]]);
4731     case tok::coloncolon:
4732       // C(X   ::   Y);
4733       // C(X   ::   *p);
4734       // Assume this isn't a constructor, rather than assuming it's a
4735       // constructor with an unnamed parameter of an ill-formed type.
4736       break;
4737
4738     case tok::r_paren:
4739       // C(X   )
4740       if (NextToken().is(tok::colon) || NextToken().is(tok::kw_try)) {
4741         // Assume these were meant to be constructors:
4742         //   C(X)   :    (the name of a bit-field cannot be parenthesized).
4743         //   C(X)   try  (this is otherwise ill-formed).
4744         IsConstructor = true;
4745       }
4746       if (NextToken().is(tok::semi) || NextToken().is(tok::l_brace)) {
4747         // If we have a constructor name within the class definition,
4748         // assume these were meant to be constructors:
4749         //   C(X)   {
4750         //   C(X)   ;
4751         // ... because otherwise we would be declaring a non-static data
4752         // member that is ill-formed because it's of the same type as its
4753         // surrounding class.
4754         //
4755         // FIXME: We can actually do this whether or not the name is qualified,
4756         // because if it is qualified in this context it must be being used as
4757         // a constructor name. However, we do not implement that rule correctly
4758         // currently, so we're somewhat conservative here.
4759         IsConstructor = IsUnqualified;
4760       }
4761       break;
4762
4763     default:
4764       IsConstructor = true;
4765       break;
4766     }
4767   }
4768
4769   TPA.Revert();
4770   return IsConstructor;
4771 }
4772
4773 /// ParseTypeQualifierListOpt
4774 ///          type-qualifier-list: [C99 6.7.5]
4775 ///            type-qualifier
4776 /// [vendor]   attributes
4777 ///              [ only if AttrReqs & AR_VendorAttributesParsed ]
4778 ///            type-qualifier-list type-qualifier
4779 /// [vendor]   type-qualifier-list attributes
4780 ///              [ only if AttrReqs & AR_VendorAttributesParsed ]
4781 /// [C++0x]    attribute-specifier[opt] is allowed before cv-qualifier-seq
4782 ///              [ only if AttReqs & AR_CXX11AttributesParsed ]
4783 /// Note: vendor can be GNU, MS, etc and can be explicitly controlled via
4784 /// AttrRequirements bitmask values.
4785 void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, unsigned AttrReqs,
4786                                        bool AtomicAllowed,
4787                                        bool IdentifierRequired) {
4788   if (getLangOpts().CPlusPlus11 && (AttrReqs & AR_CXX11AttributesParsed) &&
4789       isCXX11AttributeSpecifier()) {
4790     ParsedAttributesWithRange attrs(AttrFactory);
4791     ParseCXX11Attributes(attrs);
4792     DS.takeAttributesFrom(attrs);
4793   }
4794
4795   SourceLocation EndLoc;
4796
4797   while (1) {
4798     bool isInvalid = false;
4799     const char *PrevSpec = nullptr;
4800     unsigned DiagID = 0;
4801     SourceLocation Loc = Tok.getLocation();
4802
4803     switch (Tok.getKind()) {
4804     case tok::code_completion:
4805       Actions.CodeCompleteTypeQualifiers(DS);
4806       return cutOffParsing();
4807
4808     case tok::kw_const:
4809       isInvalid = DS.SetTypeQual(DeclSpec::TQ_const   , Loc, PrevSpec, DiagID,
4810                                  getLangOpts());
4811       break;
4812     case tok::kw_volatile:
4813       isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID,
4814                                  getLangOpts());
4815       break;
4816     case tok::kw_restrict:
4817       isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID,
4818                                  getLangOpts());
4819       break;
4820     case tok::kw__Atomic:
4821       if (!AtomicAllowed)
4822         goto DoneWithTypeQuals;
4823       isInvalid = DS.SetTypeQual(DeclSpec::TQ_atomic, Loc, PrevSpec, DiagID,
4824                                  getLangOpts());
4825       break;
4826
4827     // OpenCL qualifiers:
4828     case tok::kw___private:
4829     case tok::kw___global:
4830     case tok::kw___local:
4831     case tok::kw___constant:
4832     case tok::kw___generic:
4833     case tok::kw___read_only:
4834     case tok::kw___write_only:
4835     case tok::kw___read_write:
4836       ParseOpenCLQualifiers(DS.getAttributes());
4837       break;
4838
4839     case tok::kw___unaligned:
4840       isInvalid = DS.SetTypeQual(DeclSpec::TQ_unaligned, Loc, PrevSpec, DiagID,
4841                                  getLangOpts());
4842       break;
4843     case tok::kw___uptr:
4844       // GNU libc headers in C mode use '__uptr' as an identifer which conflicts
4845       // with the MS modifier keyword.
4846       if ((AttrReqs & AR_DeclspecAttributesParsed) && !getLangOpts().CPlusPlus &&
4847           IdentifierRequired && DS.isEmpty() && NextToken().is(tok::semi)) {
4848         if (TryKeywordIdentFallback(false))
4849           continue;
4850       }
4851     case tok::kw___sptr:
4852     case tok::kw___w64:
4853     case tok::kw___ptr64:
4854     case tok::kw___ptr32:
4855     case tok::kw___cdecl:
4856     case tok::kw___stdcall:
4857     case tok::kw___fastcall:
4858     case tok::kw___thiscall:
4859     case tok::kw___vectorcall:
4860       if (AttrReqs & AR_DeclspecAttributesParsed) {
4861         ParseMicrosoftTypeAttributes(DS.getAttributes());
4862         continue;
4863       }
4864       goto DoneWithTypeQuals;
4865     case tok::kw___pascal:
4866       if (AttrReqs & AR_VendorAttributesParsed) {
4867         ParseBorlandTypeAttributes(DS.getAttributes());
4868         continue;
4869       }
4870       goto DoneWithTypeQuals;
4871
4872     // Nullability type specifiers.
4873     case tok::kw__Nonnull:
4874     case tok::kw__Nullable:
4875     case tok::kw__Null_unspecified:
4876       ParseNullabilityTypeSpecifiers(DS.getAttributes());
4877       continue;
4878
4879     // Objective-C 'kindof' types.
4880     case tok::kw___kindof:
4881       DS.getAttributes().addNew(Tok.getIdentifierInfo(), Loc, nullptr, Loc,
4882                                 nullptr, 0, AttributeList::AS_Keyword);
4883       (void)ConsumeToken();
4884       continue;
4885
4886     case tok::kw___attribute:
4887       if (AttrReqs & AR_GNUAttributesParsedAndRejected)
4888         // When GNU attributes are expressly forbidden, diagnose their usage.
4889         Diag(Tok, diag::err_attributes_not_allowed);
4890
4891       // Parse the attributes even if they are rejected to ensure that error
4892       // recovery is graceful.
4893       if (AttrReqs & AR_GNUAttributesParsed ||
4894           AttrReqs & AR_GNUAttributesParsedAndRejected) {
4895         ParseGNUAttributes(DS.getAttributes());
4896         continue; // do *not* consume the next token!
4897       }
4898       // otherwise, FALL THROUGH!
4899     default:
4900       DoneWithTypeQuals:
4901       // If this is not a type-qualifier token, we're done reading type
4902       // qualifiers.  First verify that DeclSpec's are consistent.
4903       DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
4904       if (EndLoc.isValid())
4905         DS.SetRangeEnd(EndLoc);
4906       return;
4907     }
4908
4909     // If the specifier combination wasn't legal, issue a diagnostic.
4910     if (isInvalid) {
4911       assert(PrevSpec && "Method did not return previous specifier!");
4912       Diag(Tok, DiagID) << PrevSpec;
4913     }
4914     EndLoc = ConsumeToken();
4915   }
4916 }
4917
4918 /// ParseDeclarator - Parse and verify a newly-initialized declarator.
4919 ///
4920 void Parser::ParseDeclarator(Declarator &D) {
4921   /// This implements the 'declarator' production in the C grammar, then checks
4922   /// for well-formedness and issues diagnostics.
4923   ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
4924 }
4925
4926 static bool isPtrOperatorToken(tok::TokenKind Kind, const LangOptions &Lang,
4927                                unsigned TheContext) {
4928   if (Kind == tok::star || Kind == tok::caret)
4929     return true;
4930
4931   if ((Kind == tok::kw_pipe) && Lang.OpenCL && (Lang.OpenCLVersion >= 200))
4932     return true;
4933
4934   if (!Lang.CPlusPlus)
4935     return false;
4936
4937   if (Kind == tok::amp)
4938     return true;
4939
4940   // We parse rvalue refs in C++03, because otherwise the errors are scary.
4941   // But we must not parse them in conversion-type-ids and new-type-ids, since
4942   // those can be legitimately followed by a && operator.
4943   // (The same thing can in theory happen after a trailing-return-type, but
4944   // since those are a C++11 feature, there is no rejects-valid issue there.)
4945   if (Kind == tok::ampamp)
4946     return Lang.CPlusPlus11 || (TheContext != Declarator::ConversionIdContext &&
4947                                 TheContext != Declarator::CXXNewContext);
4948
4949   return false;
4950 }
4951
4952 // Indicates whether the given declarator is a pipe declarator.
4953 static bool isPipeDeclerator(const Declarator &D) {
4954   const unsigned NumTypes = D.getNumTypeObjects();
4955
4956   for (unsigned Idx = 0; Idx != NumTypes; ++Idx)
4957     if (DeclaratorChunk::Pipe == D.getTypeObject(Idx).Kind)
4958       return true;
4959
4960   return false;
4961 }
4962
4963 /// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator
4964 /// is parsed by the function passed to it. Pass null, and the direct-declarator
4965 /// isn't parsed at all, making this function effectively parse the C++
4966 /// ptr-operator production.
4967 ///
4968 /// If the grammar of this construct is extended, matching changes must also be
4969 /// made to TryParseDeclarator and MightBeDeclarator, and possibly to
4970 /// isConstructorDeclarator.
4971 ///
4972 ///       declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
4973 /// [C]     pointer[opt] direct-declarator
4974 /// [C++]   direct-declarator
4975 /// [C++]   ptr-operator declarator
4976 ///
4977 ///       pointer: [C99 6.7.5]
4978 ///         '*' type-qualifier-list[opt]
4979 ///         '*' type-qualifier-list[opt] pointer
4980 ///
4981 ///       ptr-operator:
4982 ///         '*' cv-qualifier-seq[opt]
4983 ///         '&'
4984 /// [C++0x] '&&'
4985 /// [GNU]   '&' restrict[opt] attributes[opt]
4986 /// [GNU?]  '&&' restrict[opt] attributes[opt]
4987 ///         '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
4988 void Parser::ParseDeclaratorInternal(Declarator &D,
4989                                      DirectDeclParseFunction DirectDeclParser) {
4990   if (Diags.hasAllExtensionsSilenced())
4991     D.setExtension();
4992
4993   // C++ member pointers start with a '::' or a nested-name.
4994   // Member pointers get special handling, since there's no place for the
4995   // scope spec in the generic path below.
4996   if (getLangOpts().CPlusPlus &&
4997       (Tok.is(tok::coloncolon) || Tok.is(tok::kw_decltype) ||
4998        (Tok.is(tok::identifier) &&
4999         (NextToken().is(tok::coloncolon) || NextToken().is(tok::less))) ||
5000        Tok.is(tok::annot_cxxscope))) {
5001     bool EnteringContext = D.getContext() == Declarator::FileContext ||
5002                            D.getContext() == Declarator::MemberContext;
5003     CXXScopeSpec SS;
5004     ParseOptionalCXXScopeSpecifier(SS, nullptr, EnteringContext);
5005
5006     if (SS.isNotEmpty()) {
5007       if (Tok.isNot(tok::star)) {
5008         // The scope spec really belongs to the direct-declarator.
5009         if (D.mayHaveIdentifier())
5010           D.getCXXScopeSpec() = SS;
5011         else
5012           AnnotateScopeToken(SS, true);
5013
5014         if (DirectDeclParser)
5015           (this->*DirectDeclParser)(D);
5016         return;
5017       }
5018
5019       SourceLocation Loc = ConsumeToken();
5020       D.SetRangeEnd(Loc);
5021       DeclSpec DS(AttrFactory);
5022       ParseTypeQualifierListOpt(DS);
5023       D.ExtendWithDeclSpec(DS);
5024
5025       // Recurse to parse whatever is left.
5026       ParseDeclaratorInternal(D, DirectDeclParser);
5027
5028       // Sema will have to catch (syntactically invalid) pointers into global
5029       // scope. It has to catch pointers into namespace scope anyway.
5030       D.AddTypeInfo(DeclaratorChunk::getMemberPointer(SS,DS.getTypeQualifiers(),
5031                                                       DS.getLocEnd()),
5032                     DS.getAttributes(),
5033                     /* Don't replace range end. */SourceLocation());
5034       return;
5035     }
5036   }
5037
5038   tok::TokenKind Kind = Tok.getKind();
5039
5040   if (D.getDeclSpec().isTypeSpecPipe() && !isPipeDeclerator(D)) {
5041     DeclSpec DS(AttrFactory);
5042     ParseTypeQualifierListOpt(DS);
5043
5044     D.AddTypeInfo(
5045         DeclaratorChunk::getPipe(DS.getTypeQualifiers(), DS.getPipeLoc()),
5046         DS.getAttributes(), SourceLocation());
5047   }
5048
5049   // Not a pointer, C++ reference, or block.
5050   if (!isPtrOperatorToken(Kind, getLangOpts(), D.getContext())) {
5051     if (DirectDeclParser)
5052       (this->*DirectDeclParser)(D);
5053     return;
5054   }
5055
5056   // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference,
5057   // '&&' -> rvalue reference
5058   SourceLocation Loc = ConsumeToken();  // Eat the *, ^, & or &&.
5059   D.SetRangeEnd(Loc);
5060
5061   if (Kind == tok::star || Kind == tok::caret) {
5062     // Is a pointer.
5063     DeclSpec DS(AttrFactory);
5064
5065     // GNU attributes are not allowed here in a new-type-id, but Declspec and
5066     // C++11 attributes are allowed.
5067     unsigned Reqs = AR_CXX11AttributesParsed | AR_DeclspecAttributesParsed |
5068                             ((D.getContext() != Declarator::CXXNewContext)
5069                                  ? AR_GNUAttributesParsed
5070                                  : AR_GNUAttributesParsedAndRejected);
5071     ParseTypeQualifierListOpt(DS, Reqs, true, !D.mayOmitIdentifier());
5072     D.ExtendWithDeclSpec(DS);
5073
5074     // Recursively parse the declarator.
5075     ParseDeclaratorInternal(D, DirectDeclParser);
5076     if (Kind == tok::star)
5077       // Remember that we parsed a pointer type, and remember the type-quals.
5078       D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc,
5079                                                 DS.getConstSpecLoc(),
5080                                                 DS.getVolatileSpecLoc(),
5081                                                 DS.getRestrictSpecLoc(),
5082                                                 DS.getAtomicSpecLoc(),
5083                                                 DS.getUnalignedSpecLoc()),
5084                     DS.getAttributes(),
5085                     SourceLocation());
5086     else
5087       // Remember that we parsed a Block type, and remember the type-quals.
5088       D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(),
5089                                                      Loc),
5090                     DS.getAttributes(),
5091                     SourceLocation());
5092   } else {
5093     // Is a reference
5094     DeclSpec DS(AttrFactory);
5095
5096     // Complain about rvalue references in C++03, but then go on and build
5097     // the declarator.
5098     if (Kind == tok::ampamp)
5099       Diag(Loc, getLangOpts().CPlusPlus11 ?
5100            diag::warn_cxx98_compat_rvalue_reference :
5101            diag::ext_rvalue_reference);
5102
5103     // GNU-style and C++11 attributes are allowed here, as is restrict.
5104     ParseTypeQualifierListOpt(DS);
5105     D.ExtendWithDeclSpec(DS);
5106
5107     // C++ 8.3.2p1: cv-qualified references are ill-formed except when the
5108     // cv-qualifiers are introduced through the use of a typedef or of a
5109     // template type argument, in which case the cv-qualifiers are ignored.
5110     if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
5111       if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
5112         Diag(DS.getConstSpecLoc(),
5113              diag::err_invalid_reference_qualifier_application) << "const";
5114       if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
5115         Diag(DS.getVolatileSpecLoc(),
5116              diag::err_invalid_reference_qualifier_application) << "volatile";
5117       // 'restrict' is permitted as an extension.
5118       if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
5119         Diag(DS.getAtomicSpecLoc(),
5120              diag::err_invalid_reference_qualifier_application) << "_Atomic";
5121     }
5122
5123     // Recursively parse the declarator.
5124     ParseDeclaratorInternal(D, DirectDeclParser);
5125
5126     if (D.getNumTypeObjects() > 0) {
5127       // C++ [dcl.ref]p4: There shall be no references to references.
5128       DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1);
5129       if (InnerChunk.Kind == DeclaratorChunk::Reference) {
5130         if (const IdentifierInfo *II = D.getIdentifier())
5131           Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
5132            << II;
5133         else
5134           Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
5135             << "type name";
5136
5137         // Once we've complained about the reference-to-reference, we
5138         // can go ahead and build the (technically ill-formed)
5139         // declarator: reference collapsing will take care of it.
5140       }
5141     }
5142
5143     // Remember that we parsed a reference type.
5144     D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc,
5145                                                 Kind == tok::amp),
5146                   DS.getAttributes(),
5147                   SourceLocation());
5148   }
5149 }
5150
5151 // When correcting from misplaced brackets before the identifier, the location
5152 // is saved inside the declarator so that other diagnostic messages can use
5153 // them.  This extracts and returns that location, or returns the provided
5154 // location if a stored location does not exist.
5155 static SourceLocation getMissingDeclaratorIdLoc(Declarator &D,
5156                                                 SourceLocation Loc) {
5157   if (D.getName().StartLocation.isInvalid() &&
5158       D.getName().EndLocation.isValid())
5159     return D.getName().EndLocation;
5160
5161   return Loc;
5162 }
5163
5164 /// ParseDirectDeclarator
5165 ///       direct-declarator: [C99 6.7.5]
5166 /// [C99]   identifier
5167 ///         '(' declarator ')'
5168 /// [GNU]   '(' attributes declarator ')'
5169 /// [C90]   direct-declarator '[' constant-expression[opt] ']'
5170 /// [C99]   direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
5171 /// [C99]   direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
5172 /// [C99]   direct-declarator '[' type-qual-list 'static' assignment-expr ']'
5173 /// [C99]   direct-declarator '[' type-qual-list[opt] '*' ']'
5174 /// [C++11] direct-declarator '[' constant-expression[opt] ']'
5175 ///                    attribute-specifier-seq[opt]
5176 ///         direct-declarator '(' parameter-type-list ')'
5177 ///         direct-declarator '(' identifier-list[opt] ')'
5178 /// [GNU]   direct-declarator '(' parameter-forward-declarations
5179 ///                    parameter-type-list[opt] ')'
5180 /// [C++]   direct-declarator '(' parameter-declaration-clause ')'
5181 ///                    cv-qualifier-seq[opt] exception-specification[opt]
5182 /// [C++11] direct-declarator '(' parameter-declaration-clause ')'
5183 ///                    attribute-specifier-seq[opt] cv-qualifier-seq[opt]
5184 ///                    ref-qualifier[opt] exception-specification[opt]
5185 /// [C++]   declarator-id
5186 /// [C++11] declarator-id attribute-specifier-seq[opt]
5187 ///
5188 ///       declarator-id: [C++ 8]
5189 ///         '...'[opt] id-expression
5190 ///         '::'[opt] nested-name-specifier[opt] type-name
5191 ///
5192 ///       id-expression: [C++ 5.1]
5193 ///         unqualified-id
5194 ///         qualified-id
5195 ///
5196 ///       unqualified-id: [C++ 5.1]
5197 ///         identifier
5198 ///         operator-function-id
5199 ///         conversion-function-id
5200 ///          '~' class-name
5201 ///         template-id
5202 ///
5203 /// Note, any additional constructs added here may need corresponding changes
5204 /// in isConstructorDeclarator.
5205 void Parser::ParseDirectDeclarator(Declarator &D) {
5206   DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec());
5207
5208   if (getLangOpts().CPlusPlus && D.mayHaveIdentifier()) {
5209     // Don't parse FOO:BAR as if it were a typo for FOO::BAR inside a class, in
5210     // this context it is a bitfield. Also in range-based for statement colon
5211     // may delimit for-range-declaration.
5212     ColonProtectionRAIIObject X(*this,
5213                                 D.getContext() == Declarator::MemberContext ||
5214                                     (D.getContext() == Declarator::ForContext &&
5215                                      getLangOpts().CPlusPlus11));
5216
5217     // ParseDeclaratorInternal might already have parsed the scope.
5218     if (D.getCXXScopeSpec().isEmpty()) {
5219       bool EnteringContext = D.getContext() == Declarator::FileContext ||
5220                              D.getContext() == Declarator::MemberContext;
5221       ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec(), nullptr,
5222                                      EnteringContext);
5223     }
5224
5225     if (D.getCXXScopeSpec().isValid()) {
5226       if (Actions.ShouldEnterDeclaratorScope(getCurScope(),
5227                                              D.getCXXScopeSpec()))
5228         // Change the declaration context for name lookup, until this function
5229         // is exited (and the declarator has been parsed).
5230         DeclScopeObj.EnterDeclaratorScope();
5231     }
5232
5233     // C++0x [dcl.fct]p14:
5234     //   There is a syntactic ambiguity when an ellipsis occurs at the end of a
5235     //   parameter-declaration-clause without a preceding comma. In this case,
5236     //   the ellipsis is parsed as part of the abstract-declarator if the type
5237     //   of the parameter either names a template parameter pack that has not
5238     //   been expanded or contains auto; otherwise, it is parsed as part of the
5239     //   parameter-declaration-clause.
5240     if (Tok.is(tok::ellipsis) && D.getCXXScopeSpec().isEmpty() &&
5241         !((D.getContext() == Declarator::PrototypeContext ||
5242            D.getContext() == Declarator::LambdaExprParameterContext ||
5243            D.getContext() == Declarator::BlockLiteralContext) &&
5244           NextToken().is(tok::r_paren) &&
5245           !D.hasGroupingParens() &&
5246           !Actions.containsUnexpandedParameterPacks(D) &&
5247           D.getDeclSpec().getTypeSpecType() != TST_auto)) {
5248       SourceLocation EllipsisLoc = ConsumeToken();
5249       if (isPtrOperatorToken(Tok.getKind(), getLangOpts(), D.getContext())) {
5250         // The ellipsis was put in the wrong place. Recover, and explain to
5251         // the user what they should have done.
5252         ParseDeclarator(D);
5253         if (EllipsisLoc.isValid())
5254           DiagnoseMisplacedEllipsisInDeclarator(EllipsisLoc, D);
5255         return;
5256       } else
5257         D.setEllipsisLoc(EllipsisLoc);
5258
5259       // The ellipsis can't be followed by a parenthesized declarator. We
5260       // check for that in ParseParenDeclarator, after we have disambiguated
5261       // the l_paren token.
5262     }
5263
5264     if (Tok.isOneOf(tok::identifier, tok::kw_operator, tok::annot_template_id,
5265                     tok::tilde)) {
5266       // We found something that indicates the start of an unqualified-id.
5267       // Parse that unqualified-id.
5268       bool AllowConstructorName;
5269       if (D.getDeclSpec().hasTypeSpecifier())
5270         AllowConstructorName = false;
5271       else if (D.getCXXScopeSpec().isSet())
5272         AllowConstructorName =
5273           (D.getContext() == Declarator::FileContext ||
5274            D.getContext() == Declarator::MemberContext);
5275       else
5276         AllowConstructorName = (D.getContext() == Declarator::MemberContext);
5277
5278       SourceLocation TemplateKWLoc;
5279       bool HadScope = D.getCXXScopeSpec().isValid();
5280       if (ParseUnqualifiedId(D.getCXXScopeSpec(),
5281                              /*EnteringContext=*/true,
5282                              /*AllowDestructorName=*/true, AllowConstructorName,
5283                              nullptr, TemplateKWLoc, D.getName()) ||
5284           // Once we're past the identifier, if the scope was bad, mark the
5285           // whole declarator bad.
5286           D.getCXXScopeSpec().isInvalid()) {
5287         D.SetIdentifier(nullptr, Tok.getLocation());
5288         D.setInvalidType(true);
5289       } else {
5290         // ParseUnqualifiedId might have parsed a scope specifier during error
5291         // recovery. If it did so, enter that scope.
5292         if (!HadScope && D.getCXXScopeSpec().isValid() &&
5293             Actions.ShouldEnterDeclaratorScope(getCurScope(),
5294                                                D.getCXXScopeSpec()))
5295           DeclScopeObj.EnterDeclaratorScope();
5296
5297         // Parsed the unqualified-id; update range information and move along.
5298         if (D.getSourceRange().getBegin().isInvalid())
5299           D.SetRangeBegin(D.getName().getSourceRange().getBegin());
5300         D.SetRangeEnd(D.getName().getSourceRange().getEnd());
5301       }
5302       goto PastIdentifier;
5303     }
5304
5305     if (D.getCXXScopeSpec().isNotEmpty()) {
5306       // We have a scope specifier but no following unqualified-id.
5307       Diag(PP.getLocForEndOfToken(D.getCXXScopeSpec().getEndLoc()),
5308            diag::err_expected_unqualified_id)
5309           << /*C++*/1;
5310       D.SetIdentifier(nullptr, Tok.getLocation());
5311       goto PastIdentifier;
5312     }
5313   } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
5314     assert(!getLangOpts().CPlusPlus &&
5315            "There's a C++-specific check for tok::identifier above");
5316     assert(Tok.getIdentifierInfo() && "Not an identifier?");
5317     D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
5318     D.SetRangeEnd(Tok.getLocation());
5319     ConsumeToken();
5320     goto PastIdentifier;
5321   } else if (Tok.is(tok::identifier) && D.diagnoseIdentifier()) {
5322     // A virt-specifier isn't treated as an identifier if it appears after a
5323     // trailing-return-type.
5324     if (D.getContext() != Declarator::TrailingReturnContext ||
5325         !isCXX11VirtSpecifier(Tok)) {
5326       Diag(Tok.getLocation(), diag::err_unexpected_unqualified_id)
5327         << FixItHint::CreateRemoval(Tok.getLocation());
5328       D.SetIdentifier(nullptr, Tok.getLocation());
5329       ConsumeToken();
5330       goto PastIdentifier;
5331     }
5332   }
5333
5334   if (Tok.is(tok::l_paren)) {
5335     // direct-declarator: '(' declarator ')'
5336     // direct-declarator: '(' attributes declarator ')'
5337     // Example: 'char (*X)'   or 'int (*XX)(void)'
5338     ParseParenDeclarator(D);
5339
5340     // If the declarator was parenthesized, we entered the declarator
5341     // scope when parsing the parenthesized declarator, then exited
5342     // the scope already. Re-enter the scope, if we need to.
5343     if (D.getCXXScopeSpec().isSet()) {
5344       // If there was an error parsing parenthesized declarator, declarator
5345       // scope may have been entered before. Don't do it again.
5346       if (!D.isInvalidType() &&
5347           Actions.ShouldEnterDeclaratorScope(getCurScope(),
5348                                              D.getCXXScopeSpec()))
5349         // Change the declaration context for name lookup, until this function
5350         // is exited (and the declarator has been parsed).
5351         DeclScopeObj.EnterDeclaratorScope();
5352     }
5353   } else if (D.mayOmitIdentifier()) {
5354     // This could be something simple like "int" (in which case the declarator
5355     // portion is empty), if an abstract-declarator is allowed.
5356     D.SetIdentifier(nullptr, Tok.getLocation());
5357
5358     // The grammar for abstract-pack-declarator does not allow grouping parens.
5359     // FIXME: Revisit this once core issue 1488 is resolved.
5360     if (D.hasEllipsis() && D.hasGroupingParens())
5361       Diag(PP.getLocForEndOfToken(D.getEllipsisLoc()),
5362            diag::ext_abstract_pack_declarator_parens);
5363   } else {
5364     if (Tok.getKind() == tok::annot_pragma_parser_crash)
5365       LLVM_BUILTIN_TRAP;
5366     if (Tok.is(tok::l_square))
5367       return ParseMisplacedBracketDeclarator(D);
5368     if (D.getContext() == Declarator::MemberContext) {
5369       Diag(getMissingDeclaratorIdLoc(D, Tok.getLocation()),
5370            diag::err_expected_member_name_or_semi)
5371           << (D.getDeclSpec().isEmpty() ? SourceRange()
5372                                         : D.getDeclSpec().getSourceRange());
5373     } else if (getLangOpts().CPlusPlus) {
5374       if (Tok.isOneOf(tok::period, tok::arrow))
5375         Diag(Tok, diag::err_invalid_operator_on_type) << Tok.is(tok::arrow);
5376       else {
5377         SourceLocation Loc = D.getCXXScopeSpec().getEndLoc();
5378         if (Tok.isAtStartOfLine() && Loc.isValid())
5379           Diag(PP.getLocForEndOfToken(Loc), diag::err_expected_unqualified_id)
5380               << getLangOpts().CPlusPlus;
5381         else
5382           Diag(getMissingDeclaratorIdLoc(D, Tok.getLocation()),
5383                diag::err_expected_unqualified_id)
5384               << getLangOpts().CPlusPlus;
5385       }
5386     } else {
5387       Diag(getMissingDeclaratorIdLoc(D, Tok.getLocation()),
5388            diag::err_expected_either)
5389           << tok::identifier << tok::l_paren;
5390     }
5391     D.SetIdentifier(nullptr, Tok.getLocation());
5392     D.setInvalidType(true);
5393   }
5394
5395  PastIdentifier:
5396   assert(D.isPastIdentifier() &&
5397          "Haven't past the location of the identifier yet?");
5398
5399   // Don't parse attributes unless we have parsed an unparenthesized name.
5400   if (D.hasName() && !D.getNumTypeObjects())
5401     MaybeParseCXX11Attributes(D);
5402
5403   while (1) {
5404     if (Tok.is(tok::l_paren)) {
5405       // Enter function-declaration scope, limiting any declarators to the
5406       // function prototype scope, including parameter declarators.
5407       ParseScope PrototypeScope(this,
5408                                 Scope::FunctionPrototypeScope|Scope::DeclScope|
5409                                 (D.isFunctionDeclaratorAFunctionDeclaration()
5410                                    ? Scope::FunctionDeclarationScope : 0));
5411
5412       // The paren may be part of a C++ direct initializer, eg. "int x(1);".
5413       // In such a case, check if we actually have a function declarator; if it
5414       // is not, the declarator has been fully parsed.
5415       bool IsAmbiguous = false;
5416       if (getLangOpts().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) {
5417         // The name of the declarator, if any, is tentatively declared within
5418         // a possible direct initializer.
5419         TentativelyDeclaredIdentifiers.push_back(D.getIdentifier());
5420         bool IsFunctionDecl = isCXXFunctionDeclarator(&IsAmbiguous);
5421         TentativelyDeclaredIdentifiers.pop_back();
5422         if (!IsFunctionDecl)
5423           break;
5424       }
5425       ParsedAttributes attrs(AttrFactory);
5426       BalancedDelimiterTracker T(*this, tok::l_paren);
5427       T.consumeOpen();
5428       ParseFunctionDeclarator(D, attrs, T, IsAmbiguous);
5429       PrototypeScope.Exit();
5430     } else if (Tok.is(tok::l_square)) {
5431       ParseBracketDeclarator(D);
5432     } else {
5433       break;
5434     }
5435   }
5436 }
5437
5438 /// ParseParenDeclarator - We parsed the declarator D up to a paren.  This is
5439 /// only called before the identifier, so these are most likely just grouping
5440 /// parens for precedence.  If we find that these are actually function
5441 /// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator.
5442 ///
5443 ///       direct-declarator:
5444 ///         '(' declarator ')'
5445 /// [GNU]   '(' attributes declarator ')'
5446 ///         direct-declarator '(' parameter-type-list ')'
5447 ///         direct-declarator '(' identifier-list[opt] ')'
5448 /// [GNU]   direct-declarator '(' parameter-forward-declarations
5449 ///                    parameter-type-list[opt] ')'
5450 ///
5451 void Parser::ParseParenDeclarator(Declarator &D) {
5452   BalancedDelimiterTracker T(*this, tok::l_paren);
5453   T.consumeOpen();
5454
5455   assert(!D.isPastIdentifier() && "Should be called before passing identifier");
5456
5457   // Eat any attributes before we look at whether this is a grouping or function
5458   // declarator paren.  If this is a grouping paren, the attribute applies to
5459   // the type being built up, for example:
5460   //     int (__attribute__(()) *x)(long y)
5461   // If this ends up not being a grouping paren, the attribute applies to the
5462   // first argument, for example:
5463   //     int (__attribute__(()) int x)
5464   // In either case, we need to eat any attributes to be able to determine what
5465   // sort of paren this is.
5466   //
5467   ParsedAttributes attrs(AttrFactory);
5468   bool RequiresArg = false;
5469   if (Tok.is(tok::kw___attribute)) {
5470     ParseGNUAttributes(attrs);
5471
5472     // We require that the argument list (if this is a non-grouping paren) be
5473     // present even if the attribute list was empty.
5474     RequiresArg = true;
5475   }
5476
5477   // Eat any Microsoft extensions.
5478   ParseMicrosoftTypeAttributes(attrs);
5479
5480   // Eat any Borland extensions.
5481   if  (Tok.is(tok::kw___pascal))
5482     ParseBorlandTypeAttributes(attrs);
5483
5484   // If we haven't past the identifier yet (or where the identifier would be
5485   // stored, if this is an abstract declarator), then this is probably just
5486   // grouping parens. However, if this could be an abstract-declarator, then
5487   // this could also be the start of function arguments (consider 'void()').
5488   bool isGrouping;
5489
5490   if (!D.mayOmitIdentifier()) {
5491     // If this can't be an abstract-declarator, this *must* be a grouping
5492     // paren, because we haven't seen the identifier yet.
5493     isGrouping = true;
5494   } else if (Tok.is(tok::r_paren) ||           // 'int()' is a function.
5495              (getLangOpts().CPlusPlus && Tok.is(tok::ellipsis) &&
5496               NextToken().is(tok::r_paren)) || // C++ int(...)
5497              isDeclarationSpecifier() ||       // 'int(int)' is a function.
5498              isCXX11AttributeSpecifier()) {    // 'int([[]]int)' is a function.
5499     // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is
5500     // considered to be a type, not a K&R identifier-list.
5501     isGrouping = false;
5502   } else {
5503     // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'.
5504     isGrouping = true;
5505   }
5506
5507   // If this is a grouping paren, handle:
5508   // direct-declarator: '(' declarator ')'
5509   // direct-declarator: '(' attributes declarator ')'
5510   if (isGrouping) {
5511     SourceLocation EllipsisLoc = D.getEllipsisLoc();
5512     D.setEllipsisLoc(SourceLocation());
5513
5514     bool hadGroupingParens = D.hasGroupingParens();
5515     D.setGroupingParens(true);
5516     ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
5517     // Match the ')'.
5518     T.consumeClose();
5519     D.AddTypeInfo(DeclaratorChunk::getParen(T.getOpenLocation(),
5520                                             T.getCloseLocation()),
5521                   attrs, T.getCloseLocation());
5522
5523     D.setGroupingParens(hadGroupingParens);
5524
5525     // An ellipsis cannot be placed outside parentheses.
5526     if (EllipsisLoc.isValid())
5527       DiagnoseMisplacedEllipsisInDeclarator(EllipsisLoc, D);
5528
5529     return;
5530   }
5531
5532   // Okay, if this wasn't a grouping paren, it must be the start of a function
5533   // argument list.  Recognize that this declarator will never have an
5534   // identifier (and remember where it would have been), then call into
5535   // ParseFunctionDeclarator to handle of argument list.
5536   D.SetIdentifier(nullptr, Tok.getLocation());
5537
5538   // Enter function-declaration scope, limiting any declarators to the
5539   // function prototype scope, including parameter declarators.
5540   ParseScope PrototypeScope(this,
5541                             Scope::FunctionPrototypeScope | Scope::DeclScope |
5542                             (D.isFunctionDeclaratorAFunctionDeclaration()
5543                                ? Scope::FunctionDeclarationScope : 0));
5544   ParseFunctionDeclarator(D, attrs, T, false, RequiresArg);
5545   PrototypeScope.Exit();
5546 }
5547
5548 /// ParseFunctionDeclarator - We are after the identifier and have parsed the
5549 /// declarator D up to a paren, which indicates that we are parsing function
5550 /// arguments.
5551 ///
5552 /// If FirstArgAttrs is non-null, then the caller parsed those arguments
5553 /// immediately after the open paren - they should be considered to be the
5554 /// first argument of a parameter.
5555 ///
5556 /// If RequiresArg is true, then the first argument of the function is required
5557 /// to be present and required to not be an identifier list.
5558 ///
5559 /// For C++, after the parameter-list, it also parses the cv-qualifier-seq[opt],
5560 /// (C++11) ref-qualifier[opt], exception-specification[opt],
5561 /// (C++11) attribute-specifier-seq[opt], and (C++11) trailing-return-type[opt].
5562 ///
5563 /// [C++11] exception-specification:
5564 ///           dynamic-exception-specification
5565 ///           noexcept-specification
5566 ///
5567 void Parser::ParseFunctionDeclarator(Declarator &D,
5568                                      ParsedAttributes &FirstArgAttrs,
5569                                      BalancedDelimiterTracker &Tracker,
5570                                      bool IsAmbiguous,
5571                                      bool RequiresArg) {
5572   assert(getCurScope()->isFunctionPrototypeScope() &&
5573          "Should call from a Function scope");
5574   // lparen is already consumed!
5575   assert(D.isPastIdentifier() && "Should not call before identifier!");
5576
5577   // This should be true when the function has typed arguments.
5578   // Otherwise, it is treated as a K&R-style function.
5579   bool HasProto = false;
5580   // Build up an array of information about the parsed arguments.
5581   SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
5582   // Remember where we see an ellipsis, if any.
5583   SourceLocation EllipsisLoc;
5584
5585   DeclSpec DS(AttrFactory);
5586   bool RefQualifierIsLValueRef = true;
5587   SourceLocation RefQualifierLoc;
5588   SourceLocation ConstQualifierLoc;
5589   SourceLocation VolatileQualifierLoc;
5590   SourceLocation RestrictQualifierLoc;
5591   ExceptionSpecificationType ESpecType = EST_None;
5592   SourceRange ESpecRange;
5593   SmallVector<ParsedType, 2> DynamicExceptions;
5594   SmallVector<SourceRange, 2> DynamicExceptionRanges;
5595   ExprResult NoexceptExpr;
5596   CachedTokens *ExceptionSpecTokens = nullptr;
5597   ParsedAttributes FnAttrs(AttrFactory);
5598   TypeResult TrailingReturnType;
5599
5600   /* LocalEndLoc is the end location for the local FunctionTypeLoc.
5601      EndLoc is the end location for the function declarator.
5602      They differ for trailing return types. */
5603   SourceLocation StartLoc, LocalEndLoc, EndLoc;
5604   SourceLocation LParenLoc, RParenLoc;
5605   LParenLoc = Tracker.getOpenLocation();
5606   StartLoc = LParenLoc;
5607
5608   if (isFunctionDeclaratorIdentifierList()) {
5609     if (RequiresArg)
5610       Diag(Tok, diag::err_argument_required_after_attribute);
5611
5612     ParseFunctionDeclaratorIdentifierList(D, ParamInfo);
5613
5614     Tracker.consumeClose();
5615     RParenLoc = Tracker.getCloseLocation();
5616     LocalEndLoc = RParenLoc;
5617     EndLoc = RParenLoc;
5618   } else {
5619     if (Tok.isNot(tok::r_paren))
5620       ParseParameterDeclarationClause(D, FirstArgAttrs, ParamInfo,
5621                                       EllipsisLoc);
5622     else if (RequiresArg)
5623       Diag(Tok, diag::err_argument_required_after_attribute);
5624
5625     HasProto = ParamInfo.size() || getLangOpts().CPlusPlus;
5626
5627     // If we have the closing ')', eat it.
5628     Tracker.consumeClose();
5629     RParenLoc = Tracker.getCloseLocation();
5630     LocalEndLoc = RParenLoc;
5631     EndLoc = RParenLoc;
5632
5633     if (getLangOpts().CPlusPlus) {
5634       // FIXME: Accept these components in any order, and produce fixits to
5635       // correct the order if the user gets it wrong. Ideally we should deal
5636       // with the pure-specifier in the same way.
5637
5638       // Parse cv-qualifier-seq[opt].
5639       ParseTypeQualifierListOpt(DS, AR_NoAttributesParsed,
5640                                 /*AtomicAllowed*/ false);
5641       if (!DS.getSourceRange().getEnd().isInvalid()) {
5642         EndLoc = DS.getSourceRange().getEnd();
5643         ConstQualifierLoc = DS.getConstSpecLoc();
5644         VolatileQualifierLoc = DS.getVolatileSpecLoc();
5645         RestrictQualifierLoc = DS.getRestrictSpecLoc();
5646       }
5647
5648       // Parse ref-qualifier[opt].
5649       if (ParseRefQualifier(RefQualifierIsLValueRef, RefQualifierLoc))
5650         EndLoc = RefQualifierLoc;
5651
5652       // C++11 [expr.prim.general]p3:
5653       //   If a declaration declares a member function or member function
5654       //   template of a class X, the expression this is a prvalue of type
5655       //   "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
5656       //   and the end of the function-definition, member-declarator, or
5657       //   declarator.
5658       // FIXME: currently, "static" case isn't handled correctly.
5659       bool IsCXX11MemberFunction =
5660         getLangOpts().CPlusPlus11 &&
5661         D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
5662         (D.getContext() == Declarator::MemberContext
5663          ? !D.getDeclSpec().isFriendSpecified()
5664          : D.getContext() == Declarator::FileContext &&
5665            D.getCXXScopeSpec().isValid() &&
5666            Actions.CurContext->isRecord());
5667       Sema::CXXThisScopeRAII ThisScope(Actions,
5668                                dyn_cast<CXXRecordDecl>(Actions.CurContext),
5669                                DS.getTypeQualifiers() |
5670                                (D.getDeclSpec().isConstexprSpecified() &&
5671                                 !getLangOpts().CPlusPlus14
5672                                   ? Qualifiers::Const : 0),
5673                                IsCXX11MemberFunction);
5674
5675       // Parse exception-specification[opt].
5676       bool Delayed = D.isFirstDeclarationOfMember() &&
5677                      D.isFunctionDeclaratorAFunctionDeclaration();
5678       if (Delayed && Actions.isLibstdcxxEagerExceptionSpecHack(D) &&
5679           GetLookAheadToken(0).is(tok::kw_noexcept) &&
5680           GetLookAheadToken(1).is(tok::l_paren) &&
5681           GetLookAheadToken(2).is(tok::kw_noexcept) &&
5682           GetLookAheadToken(3).is(tok::l_paren) &&
5683           GetLookAheadToken(4).is(tok::identifier) &&
5684           GetLookAheadToken(4).getIdentifierInfo()->isStr("swap")) {
5685         // HACK: We've got an exception-specification
5686         //   noexcept(noexcept(swap(...)))
5687         // or
5688         //   noexcept(noexcept(swap(...)) && noexcept(swap(...)))
5689         // on a 'swap' member function. This is a libstdc++ bug; the lookup
5690         // for 'swap' will only find the function we're currently declaring,
5691         // whereas it expects to find a non-member swap through ADL. Turn off
5692         // delayed parsing to give it a chance to find what it expects.
5693         Delayed = false;
5694       }
5695       ESpecType = tryParseExceptionSpecification(Delayed,
5696                                                  ESpecRange,
5697                                                  DynamicExceptions,
5698                                                  DynamicExceptionRanges,
5699                                                  NoexceptExpr,
5700                                                  ExceptionSpecTokens);
5701       if (ESpecType != EST_None)
5702         EndLoc = ESpecRange.getEnd();
5703
5704       // Parse attribute-specifier-seq[opt]. Per DR 979 and DR 1297, this goes
5705       // after the exception-specification.
5706       MaybeParseCXX11Attributes(FnAttrs);
5707
5708       // Parse trailing-return-type[opt].
5709       LocalEndLoc = EndLoc;
5710       if (getLangOpts().CPlusPlus11 && Tok.is(tok::arrow)) {
5711         Diag(Tok, diag::warn_cxx98_compat_trailing_return_type);
5712         if (D.getDeclSpec().getTypeSpecType() == TST_auto)
5713           StartLoc = D.getDeclSpec().getTypeSpecTypeLoc();
5714         LocalEndLoc = Tok.getLocation();
5715         SourceRange Range;
5716         TrailingReturnType = ParseTrailingReturnType(Range);
5717         EndLoc = Range.getEnd();
5718       }
5719     }
5720   }
5721
5722   // Remember that we parsed a function type, and remember the attributes.
5723   D.AddTypeInfo(DeclaratorChunk::getFunction(HasProto,
5724                                              IsAmbiguous,
5725                                              LParenLoc,
5726                                              ParamInfo.data(), ParamInfo.size(),
5727                                              EllipsisLoc, RParenLoc,
5728                                              DS.getTypeQualifiers(),
5729                                              RefQualifierIsLValueRef,
5730                                              RefQualifierLoc, ConstQualifierLoc,
5731                                              VolatileQualifierLoc,
5732                                              RestrictQualifierLoc,
5733                                              /*MutableLoc=*/SourceLocation(),
5734                                              ESpecType, ESpecRange,
5735                                              DynamicExceptions.data(),
5736                                              DynamicExceptionRanges.data(),
5737                                              DynamicExceptions.size(),
5738                                              NoexceptExpr.isUsable() ?
5739                                                NoexceptExpr.get() : nullptr,
5740                                              ExceptionSpecTokens,
5741                                              StartLoc, LocalEndLoc, D,
5742                                              TrailingReturnType),
5743                 FnAttrs, EndLoc);
5744 }
5745
5746 /// ParseRefQualifier - Parses a member function ref-qualifier. Returns
5747 /// true if a ref-qualifier is found.
5748 bool Parser::ParseRefQualifier(bool &RefQualifierIsLValueRef,
5749                                SourceLocation &RefQualifierLoc) {
5750   if (Tok.isOneOf(tok::amp, tok::ampamp)) {
5751     Diag(Tok, getLangOpts().CPlusPlus11 ?
5752          diag::warn_cxx98_compat_ref_qualifier :
5753          diag::ext_ref_qualifier);
5754
5755     RefQualifierIsLValueRef = Tok.is(tok::amp);
5756     RefQualifierLoc = ConsumeToken();
5757     return true;
5758   }
5759   return false;
5760 }
5761
5762 /// isFunctionDeclaratorIdentifierList - This parameter list may have an
5763 /// identifier list form for a K&R-style function:  void foo(a,b,c)
5764 ///
5765 /// Note that identifier-lists are only allowed for normal declarators, not for
5766 /// abstract-declarators.
5767 bool Parser::isFunctionDeclaratorIdentifierList() {
5768   return !getLangOpts().CPlusPlus
5769          && Tok.is(tok::identifier)
5770          && !TryAltiVecVectorToken()
5771          // K&R identifier lists can't have typedefs as identifiers, per C99
5772          // 6.7.5.3p11.
5773          && (TryAnnotateTypeOrScopeToken() || !Tok.is(tok::annot_typename))
5774          // Identifier lists follow a really simple grammar: the identifiers can
5775          // be followed *only* by a ", identifier" or ")".  However, K&R
5776          // identifier lists are really rare in the brave new modern world, and
5777          // it is very common for someone to typo a type in a non-K&R style
5778          // list.  If we are presented with something like: "void foo(intptr x,
5779          // float y)", we don't want to start parsing the function declarator as
5780          // though it is a K&R style declarator just because intptr is an
5781          // invalid type.
5782          //
5783          // To handle this, we check to see if the token after the first
5784          // identifier is a "," or ")".  Only then do we parse it as an
5785          // identifier list.
5786          && (NextToken().is(tok::comma) || NextToken().is(tok::r_paren));
5787 }
5788
5789 /// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator
5790 /// we found a K&R-style identifier list instead of a typed parameter list.
5791 ///
5792 /// After returning, ParamInfo will hold the parsed parameters.
5793 ///
5794 ///       identifier-list: [C99 6.7.5]
5795 ///         identifier
5796 ///         identifier-list ',' identifier
5797 ///
5798 void Parser::ParseFunctionDeclaratorIdentifierList(
5799        Declarator &D,
5800        SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo) {
5801   // If there was no identifier specified for the declarator, either we are in
5802   // an abstract-declarator, or we are in a parameter declarator which was found
5803   // to be abstract.  In abstract-declarators, identifier lists are not valid:
5804   // diagnose this.
5805   if (!D.getIdentifier())
5806     Diag(Tok, diag::ext_ident_list_in_param);
5807
5808   // Maintain an efficient lookup of params we have seen so far.
5809   llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
5810
5811   do {
5812     // If this isn't an identifier, report the error and skip until ')'.
5813     if (Tok.isNot(tok::identifier)) {
5814       Diag(Tok, diag::err_expected) << tok::identifier;
5815       SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch);
5816       // Forget we parsed anything.
5817       ParamInfo.clear();
5818       return;
5819     }
5820
5821     IdentifierInfo *ParmII = Tok.getIdentifierInfo();
5822
5823     // Reject 'typedef int y; int test(x, y)', but continue parsing.
5824     if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope()))
5825       Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;
5826
5827     // Verify that the argument identifier has not already been mentioned.
5828     if (!ParamsSoFar.insert(ParmII).second) {
5829       Diag(Tok, diag::err_param_redefinition) << ParmII;
5830     } else {
5831       // Remember this identifier in ParamInfo.
5832       ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
5833                                                      Tok.getLocation(),
5834                                                      nullptr));
5835     }
5836
5837     // Eat the identifier.
5838     ConsumeToken();
5839     // The list continues if we see a comma.
5840   } while (TryConsumeToken(tok::comma));
5841 }
5842
5843 /// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list
5844 /// after the opening parenthesis. This function will not parse a K&R-style
5845 /// identifier list.
5846 ///
5847 /// D is the declarator being parsed.  If FirstArgAttrs is non-null, then the
5848 /// caller parsed those arguments immediately after the open paren - they should
5849 /// be considered to be part of the first parameter.
5850 ///
5851 /// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will
5852 /// be the location of the ellipsis, if any was parsed.
5853 ///
5854 ///       parameter-type-list: [C99 6.7.5]
5855 ///         parameter-list
5856 ///         parameter-list ',' '...'
5857 /// [C++]   parameter-list '...'
5858 ///
5859 ///       parameter-list: [C99 6.7.5]
5860 ///         parameter-declaration
5861 ///         parameter-list ',' parameter-declaration
5862 ///
5863 ///       parameter-declaration: [C99 6.7.5]
5864 ///         declaration-specifiers declarator
5865 /// [C++]   declaration-specifiers declarator '=' assignment-expression
5866 /// [C++11]                                       initializer-clause
5867 /// [GNU]   declaration-specifiers declarator attributes
5868 ///         declaration-specifiers abstract-declarator[opt]
5869 /// [C++]   declaration-specifiers abstract-declarator[opt]
5870 ///           '=' assignment-expression
5871 /// [GNU]   declaration-specifiers abstract-declarator[opt] attributes
5872 /// [C++11] attribute-specifier-seq parameter-declaration
5873 ///
5874 void Parser::ParseParameterDeclarationClause(
5875        Declarator &D,
5876        ParsedAttributes &FirstArgAttrs,
5877        SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
5878        SourceLocation &EllipsisLoc) {
5879   do {
5880     // FIXME: Issue a diagnostic if we parsed an attribute-specifier-seq
5881     // before deciding this was a parameter-declaration-clause.
5882     if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
5883       break;
5884
5885     // Parse the declaration-specifiers.
5886     // Just use the ParsingDeclaration "scope" of the declarator.
5887     DeclSpec DS(AttrFactory);
5888
5889     // Parse any C++11 attributes.
5890     MaybeParseCXX11Attributes(DS.getAttributes());
5891
5892     // Skip any Microsoft attributes before a param.
5893     MaybeParseMicrosoftAttributes(DS.getAttributes());
5894
5895     SourceLocation DSStart = Tok.getLocation();
5896
5897     // If the caller parsed attributes for the first argument, add them now.
5898     // Take them so that we only apply the attributes to the first parameter.
5899     // FIXME: If we can leave the attributes in the token stream somehow, we can
5900     // get rid of a parameter (FirstArgAttrs) and this statement. It might be
5901     // too much hassle.
5902     DS.takeAttributesFrom(FirstArgAttrs);
5903
5904     ParseDeclarationSpecifiers(DS);
5905
5906
5907     // Parse the declarator.  This is "PrototypeContext" or
5908     // "LambdaExprParameterContext", because we must accept either
5909     // 'declarator' or 'abstract-declarator' here.
5910     Declarator ParmDeclarator(DS,
5911               D.getContext() == Declarator::LambdaExprContext ?
5912                                   Declarator::LambdaExprParameterContext :
5913                                                 Declarator::PrototypeContext);
5914     ParseDeclarator(ParmDeclarator);
5915
5916     // Parse GNU attributes, if present.
5917     MaybeParseGNUAttributes(ParmDeclarator);
5918
5919     // Remember this parsed parameter in ParamInfo.
5920     IdentifierInfo *ParmII = ParmDeclarator.getIdentifier();
5921
5922     // DefArgToks is used when the parsing of default arguments needs
5923     // to be delayed.
5924     CachedTokens *DefArgToks = nullptr;
5925
5926     // If no parameter was specified, verify that *something* was specified,
5927     // otherwise we have a missing type and identifier.
5928     if (DS.isEmpty() && ParmDeclarator.getIdentifier() == nullptr &&
5929         ParmDeclarator.getNumTypeObjects() == 0) {
5930       // Completely missing, emit error.
5931       Diag(DSStart, diag::err_missing_param);
5932     } else {
5933       // Otherwise, we have something.  Add it and let semantic analysis try
5934       // to grok it and add the result to the ParamInfo we are building.
5935
5936       // Last chance to recover from a misplaced ellipsis in an attempted
5937       // parameter pack declaration.
5938       if (Tok.is(tok::ellipsis) &&
5939           (NextToken().isNot(tok::r_paren) ||
5940            (!ParmDeclarator.getEllipsisLoc().isValid() &&
5941             !Actions.isUnexpandedParameterPackPermitted())) &&
5942           Actions.containsUnexpandedParameterPacks(ParmDeclarator))
5943         DiagnoseMisplacedEllipsisInDeclarator(ConsumeToken(), ParmDeclarator);
5944
5945       // Inform the actions module about the parameter declarator, so it gets
5946       // added to the current scope.
5947       Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDeclarator);
5948       // Parse the default argument, if any. We parse the default
5949       // arguments in all dialects; the semantic analysis in
5950       // ActOnParamDefaultArgument will reject the default argument in
5951       // C.
5952       if (Tok.is(tok::equal)) {
5953         SourceLocation EqualLoc = Tok.getLocation();
5954
5955         // Parse the default argument
5956         if (D.getContext() == Declarator::MemberContext) {
5957           // If we're inside a class definition, cache the tokens
5958           // corresponding to the default argument. We'll actually parse
5959           // them when we see the end of the class definition.
5960           // FIXME: Can we use a smart pointer for Toks?
5961           DefArgToks = new CachedTokens;
5962
5963           SourceLocation ArgStartLoc = NextToken().getLocation();
5964           if (!ConsumeAndStoreInitializer(*DefArgToks, CIK_DefaultArgument)) {
5965             delete DefArgToks;
5966             DefArgToks = nullptr;
5967             Actions.ActOnParamDefaultArgumentError(Param, EqualLoc);
5968           } else {
5969             Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc,
5970                                                       ArgStartLoc);
5971           }
5972         } else {
5973           // Consume the '='.
5974           ConsumeToken();
5975
5976           // The argument isn't actually potentially evaluated unless it is
5977           // used.
5978           EnterExpressionEvaluationContext Eval(Actions,
5979                                               Sema::PotentiallyEvaluatedIfUsed,
5980                                                 Param);
5981
5982           ExprResult DefArgResult;
5983           if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
5984             Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
5985             DefArgResult = ParseBraceInitializer();
5986           } else
5987             DefArgResult = ParseAssignmentExpression();
5988           DefArgResult = Actions.CorrectDelayedTyposInExpr(DefArgResult);
5989           if (DefArgResult.isInvalid()) {
5990             Actions.ActOnParamDefaultArgumentError(Param, EqualLoc);
5991             SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch);
5992           } else {
5993             // Inform the actions module about the default argument
5994             Actions.ActOnParamDefaultArgument(Param, EqualLoc,
5995                                               DefArgResult.get());
5996           }
5997         }
5998       }
5999
6000       ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
6001                                           ParmDeclarator.getIdentifierLoc(),
6002                                           Param, DefArgToks));
6003     }
6004
6005     if (TryConsumeToken(tok::ellipsis, EllipsisLoc)) {
6006       if (!getLangOpts().CPlusPlus) {
6007         // We have ellipsis without a preceding ',', which is ill-formed
6008         // in C. Complain and provide the fix.
6009         Diag(EllipsisLoc, diag::err_missing_comma_before_ellipsis)
6010             << FixItHint::CreateInsertion(EllipsisLoc, ", ");
6011       } else if (ParmDeclarator.getEllipsisLoc().isValid() ||
6012                  Actions.containsUnexpandedParameterPacks(ParmDeclarator)) {
6013         // It looks like this was supposed to be a parameter pack. Warn and
6014         // point out where the ellipsis should have gone.
6015         SourceLocation ParmEllipsis = ParmDeclarator.getEllipsisLoc();
6016         Diag(EllipsisLoc, diag::warn_misplaced_ellipsis_vararg)
6017           << ParmEllipsis.isValid() << ParmEllipsis;
6018         if (ParmEllipsis.isValid()) {
6019           Diag(ParmEllipsis,
6020                diag::note_misplaced_ellipsis_vararg_existing_ellipsis);
6021         } else {
6022           Diag(ParmDeclarator.getIdentifierLoc(),
6023                diag::note_misplaced_ellipsis_vararg_add_ellipsis)
6024             << FixItHint::CreateInsertion(ParmDeclarator.getIdentifierLoc(),
6025                                           "...")
6026             << !ParmDeclarator.hasName();
6027         }
6028         Diag(EllipsisLoc, diag::note_misplaced_ellipsis_vararg_add_comma)
6029           << FixItHint::CreateInsertion(EllipsisLoc, ", ");
6030       }
6031
6032       // We can't have any more parameters after an ellipsis.
6033       break;
6034     }
6035
6036     // If the next token is a comma, consume it and keep reading arguments.
6037   } while (TryConsumeToken(tok::comma));
6038 }
6039
6040 /// [C90]   direct-declarator '[' constant-expression[opt] ']'
6041 /// [C99]   direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
6042 /// [C99]   direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
6043 /// [C99]   direct-declarator '[' type-qual-list 'static' assignment-expr ']'
6044 /// [C99]   direct-declarator '[' type-qual-list[opt] '*' ']'
6045 /// [C++11] direct-declarator '[' constant-expression[opt] ']'
6046 ///                           attribute-specifier-seq[opt]
6047 void Parser::ParseBracketDeclarator(Declarator &D) {
6048   if (CheckProhibitedCXX11Attribute())
6049     return;
6050
6051   BalancedDelimiterTracker T(*this, tok::l_square);
6052   T.consumeOpen();
6053
6054   // C array syntax has many features, but by-far the most common is [] and [4].
6055   // This code does a fast path to handle some of the most obvious cases.
6056   if (Tok.getKind() == tok::r_square) {
6057     T.consumeClose();
6058     ParsedAttributes attrs(AttrFactory);
6059     MaybeParseCXX11Attributes(attrs);
6060
6061     // Remember that we parsed the empty array type.
6062     D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, nullptr,
6063                                             T.getOpenLocation(),
6064                                             T.getCloseLocation()),
6065                   attrs, T.getCloseLocation());
6066     return;
6067   } else if (Tok.getKind() == tok::numeric_constant &&
6068              GetLookAheadToken(1).is(tok::r_square)) {
6069     // [4] is very common.  Parse the numeric constant expression.
6070     ExprResult ExprRes(Actions.ActOnNumericConstant(Tok, getCurScope()));
6071     ConsumeToken();
6072
6073     T.consumeClose();
6074     ParsedAttributes attrs(AttrFactory);
6075     MaybeParseCXX11Attributes(attrs);
6076
6077     // Remember that we parsed a array type, and remember its features.
6078     D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false,
6079                                             ExprRes.get(),
6080                                             T.getOpenLocation(),
6081                                             T.getCloseLocation()),
6082                   attrs, T.getCloseLocation());
6083     return;
6084   } else if (Tok.getKind() == tok::code_completion) {
6085     Actions.CodeCompleteBracketDeclarator(getCurScope());
6086     return cutOffParsing();
6087   }
6088
6089   // If valid, this location is the position where we read the 'static' keyword.
6090   SourceLocation StaticLoc;
6091   TryConsumeToken(tok::kw_static, StaticLoc);
6092
6093   // If there is a type-qualifier-list, read it now.
6094   // Type qualifiers in an array subscript are a C99 feature.
6095   DeclSpec DS(AttrFactory);
6096   ParseTypeQualifierListOpt(DS, AR_CXX11AttributesParsed);
6097
6098   // If we haven't already read 'static', check to see if there is one after the
6099   // type-qualifier-list.
6100   if (!StaticLoc.isValid())
6101     TryConsumeToken(tok::kw_static, StaticLoc);
6102
6103   // Handle "direct-declarator [ type-qual-list[opt] * ]".
6104   bool isStar = false;
6105   ExprResult NumElements;
6106
6107   // Handle the case where we have '[*]' as the array size.  However, a leading
6108   // star could be the start of an expression, for example 'X[*p + 4]'.  Verify
6109   // the token after the star is a ']'.  Since stars in arrays are
6110   // infrequent, use of lookahead is not costly here.
6111   if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
6112     ConsumeToken();  // Eat the '*'.
6113
6114     if (StaticLoc.isValid()) {
6115       Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);
6116       StaticLoc = SourceLocation();  // Drop the static.
6117     }
6118     isStar = true;
6119   } else if (Tok.isNot(tok::r_square)) {
6120     // Note, in C89, this production uses the constant-expr production instead
6121     // of assignment-expr.  The only difference is that assignment-expr allows
6122     // things like '=' and '*='.  Sema rejects these in C89 mode because they
6123     // are not i-c-e's, so we don't need to distinguish between the two here.
6124
6125     // Parse the constant-expression or assignment-expression now (depending
6126     // on dialect).
6127     if (getLangOpts().CPlusPlus) {
6128       NumElements = ParseConstantExpression();
6129     } else {
6130       EnterExpressionEvaluationContext Unevaluated(Actions,
6131                                                    Sema::ConstantEvaluated);
6132       NumElements =
6133           Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
6134     }
6135   } else {
6136     if (StaticLoc.isValid()) {
6137       Diag(StaticLoc, diag::err_unspecified_size_with_static);
6138       StaticLoc = SourceLocation();  // Drop the static.
6139     }
6140   }
6141
6142   // If there was an error parsing the assignment-expression, recover.
6143   if (NumElements.isInvalid()) {
6144     D.setInvalidType(true);
6145     // If the expression was invalid, skip it.
6146     SkipUntil(tok::r_square, StopAtSemi);
6147     return;
6148   }
6149
6150   T.consumeClose();
6151
6152   ParsedAttributes attrs(AttrFactory);
6153   MaybeParseCXX11Attributes(attrs);
6154
6155   // Remember that we parsed a array type, and remember its features.
6156   D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(),
6157                                           StaticLoc.isValid(), isStar,
6158                                           NumElements.get(),
6159                                           T.getOpenLocation(),
6160                                           T.getCloseLocation()),
6161                 attrs, T.getCloseLocation());
6162 }
6163
6164 /// Diagnose brackets before an identifier.
6165 void Parser::ParseMisplacedBracketDeclarator(Declarator &D) {
6166   assert(Tok.is(tok::l_square) && "Missing opening bracket");
6167   assert(!D.mayOmitIdentifier() && "Declarator cannot omit identifier");
6168
6169   SourceLocation StartBracketLoc = Tok.getLocation();
6170   Declarator TempDeclarator(D.getDeclSpec(), D.getContext());
6171
6172   while (Tok.is(tok::l_square)) {
6173     ParseBracketDeclarator(TempDeclarator);
6174   }
6175
6176   // Stuff the location of the start of the brackets into the Declarator.
6177   // The diagnostics from ParseDirectDeclarator will make more sense if
6178   // they use this location instead.
6179   if (Tok.is(tok::semi))
6180     D.getName().EndLocation = StartBracketLoc;
6181
6182   SourceLocation SuggestParenLoc = Tok.getLocation();
6183
6184   // Now that the brackets are removed, try parsing the declarator again.
6185   ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
6186
6187   // Something went wrong parsing the brackets, in which case,
6188   // ParseBracketDeclarator has emitted an error, and we don't need to emit
6189   // one here.
6190   if (TempDeclarator.getNumTypeObjects() == 0)
6191     return;
6192
6193   // Determine if parens will need to be suggested in the diagnostic.
6194   bool NeedParens = false;
6195   if (D.getNumTypeObjects() != 0) {
6196     switch (D.getTypeObject(D.getNumTypeObjects() - 1).Kind) {
6197     case DeclaratorChunk::Pointer:
6198     case DeclaratorChunk::Reference:
6199     case DeclaratorChunk::BlockPointer:
6200     case DeclaratorChunk::MemberPointer:
6201     case DeclaratorChunk::Pipe:
6202       NeedParens = true;
6203       break;
6204     case DeclaratorChunk::Array:
6205     case DeclaratorChunk::Function:
6206     case DeclaratorChunk::Paren:
6207       break;
6208     }
6209   }
6210
6211   if (NeedParens) {
6212     // Create a DeclaratorChunk for the inserted parens.
6213     ParsedAttributes attrs(AttrFactory);
6214     SourceLocation EndLoc = PP.getLocForEndOfToken(D.getLocEnd());
6215     D.AddTypeInfo(DeclaratorChunk::getParen(SuggestParenLoc, EndLoc), attrs,
6216                   SourceLocation());
6217   }
6218
6219   // Adding back the bracket info to the end of the Declarator.
6220   for (unsigned i = 0, e = TempDeclarator.getNumTypeObjects(); i < e; ++i) {
6221     const DeclaratorChunk &Chunk = TempDeclarator.getTypeObject(i);
6222     ParsedAttributes attrs(AttrFactory);
6223     attrs.set(Chunk.Common.AttrList);
6224     D.AddTypeInfo(Chunk, attrs, SourceLocation());
6225   }
6226
6227   // The missing identifier would have been diagnosed in ParseDirectDeclarator.
6228   // If parentheses are required, always suggest them.
6229   if (!D.getIdentifier() && !NeedParens)
6230     return;
6231
6232   SourceLocation EndBracketLoc = TempDeclarator.getLocEnd();
6233
6234   // Generate the move bracket error message.
6235   SourceRange BracketRange(StartBracketLoc, EndBracketLoc);
6236   SourceLocation EndLoc = PP.getLocForEndOfToken(D.getLocEnd());
6237
6238   if (NeedParens) {
6239     Diag(EndLoc, diag::err_brackets_go_after_unqualified_id)
6240         << getLangOpts().CPlusPlus
6241         << FixItHint::CreateInsertion(SuggestParenLoc, "(")
6242         << FixItHint::CreateInsertion(EndLoc, ")")
6243         << FixItHint::CreateInsertionFromRange(
6244                EndLoc, CharSourceRange(BracketRange, true))
6245         << FixItHint::CreateRemoval(BracketRange);
6246   } else {
6247     Diag(EndLoc, diag::err_brackets_go_after_unqualified_id)
6248         << getLangOpts().CPlusPlus
6249         << FixItHint::CreateInsertionFromRange(
6250                EndLoc, CharSourceRange(BracketRange, true))
6251         << FixItHint::CreateRemoval(BracketRange);
6252   }
6253 }
6254
6255 /// [GNU]   typeof-specifier:
6256 ///           typeof ( expressions )
6257 ///           typeof ( type-name )
6258 /// [GNU/C++] typeof unary-expression
6259 ///
6260 void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
6261   assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier");
6262   Token OpTok = Tok;
6263   SourceLocation StartLoc = ConsumeToken();
6264
6265   const bool hasParens = Tok.is(tok::l_paren);
6266
6267   EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated,
6268                                                Sema::ReuseLambdaContextDecl);
6269
6270   bool isCastExpr;
6271   ParsedType CastTy;
6272   SourceRange CastRange;
6273   ExprResult Operand = Actions.CorrectDelayedTyposInExpr(
6274       ParseExprAfterUnaryExprOrTypeTrait(OpTok, isCastExpr, CastTy, CastRange));
6275   if (hasParens)
6276     DS.setTypeofParensRange(CastRange);
6277
6278   if (CastRange.getEnd().isInvalid())
6279     // FIXME: Not accurate, the range gets one token more than it should.
6280     DS.SetRangeEnd(Tok.getLocation());
6281   else
6282     DS.SetRangeEnd(CastRange.getEnd());
6283
6284   if (isCastExpr) {
6285     if (!CastTy) {
6286       DS.SetTypeSpecError();
6287       return;
6288     }
6289
6290     const char *PrevSpec = nullptr;
6291     unsigned DiagID;
6292     // Check for duplicate type specifiers (e.g. "int typeof(int)").
6293     if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec,
6294                            DiagID, CastTy,
6295                            Actions.getASTContext().getPrintingPolicy()))
6296       Diag(StartLoc, DiagID) << PrevSpec;
6297     return;
6298   }
6299
6300   // If we get here, the operand to the typeof was an expresion.
6301   if (Operand.isInvalid()) {
6302     DS.SetTypeSpecError();
6303     return;
6304   }
6305
6306   // We might need to transform the operand if it is potentially evaluated.
6307   Operand = Actions.HandleExprEvaluationContextForTypeof(Operand.get());
6308   if (Operand.isInvalid()) {
6309     DS.SetTypeSpecError();
6310     return;
6311   }
6312
6313   const char *PrevSpec = nullptr;
6314   unsigned DiagID;
6315   // Check for duplicate type specifiers (e.g. "int typeof(int)").
6316   if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
6317                          DiagID, Operand.get(),
6318                          Actions.getASTContext().getPrintingPolicy()))
6319     Diag(StartLoc, DiagID) << PrevSpec;
6320 }
6321
6322 /// [C11]   atomic-specifier:
6323 ///           _Atomic ( type-name )
6324 ///
6325 void Parser::ParseAtomicSpecifier(DeclSpec &DS) {
6326   assert(Tok.is(tok::kw__Atomic) && NextToken().is(tok::l_paren) &&
6327          "Not an atomic specifier");
6328
6329   SourceLocation StartLoc = ConsumeToken();
6330   BalancedDelimiterTracker T(*this, tok::l_paren);
6331   if (T.consumeOpen())
6332     return;
6333
6334   TypeResult Result = ParseTypeName();
6335   if (Result.isInvalid()) {
6336     SkipUntil(tok::r_paren, StopAtSemi);
6337     return;
6338   }
6339
6340   // Match the ')'
6341   T.consumeClose();
6342
6343   if (T.getCloseLocation().isInvalid())
6344     return;
6345
6346   DS.setTypeofParensRange(T.getRange());
6347   DS.SetRangeEnd(T.getCloseLocation());
6348
6349   const char *PrevSpec = nullptr;
6350   unsigned DiagID;
6351   if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec,
6352                          DiagID, Result.get(),
6353                          Actions.getASTContext().getPrintingPolicy()))
6354     Diag(StartLoc, DiagID) << PrevSpec;
6355 }
6356
6357 /// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be called
6358 /// from TryAltiVecVectorToken.
6359 bool Parser::TryAltiVecVectorTokenOutOfLine() {
6360   Token Next = NextToken();
6361   switch (Next.getKind()) {
6362   default: return false;
6363   case tok::kw_short:
6364   case tok::kw_long:
6365   case tok::kw_signed:
6366   case tok::kw_unsigned:
6367   case tok::kw_void:
6368   case tok::kw_char:
6369   case tok::kw_int:
6370   case tok::kw_float:
6371   case tok::kw_double:
6372   case tok::kw_bool:
6373   case tok::kw___bool:
6374   case tok::kw___pixel:
6375     Tok.setKind(tok::kw___vector);
6376     return true;
6377   case tok::identifier:
6378     if (Next.getIdentifierInfo() == Ident_pixel) {
6379       Tok.setKind(tok::kw___vector);
6380       return true;
6381     }
6382     if (Next.getIdentifierInfo() == Ident_bool) {
6383       Tok.setKind(tok::kw___vector);
6384       return true;
6385     }
6386     return false;
6387   }
6388 }
6389
6390 bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
6391                                       const char *&PrevSpec, unsigned &DiagID,
6392                                       bool &isInvalid) {
6393   const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
6394   if (Tok.getIdentifierInfo() == Ident_vector) {
6395     Token Next = NextToken();
6396     switch (Next.getKind()) {
6397     case tok::kw_short:
6398     case tok::kw_long:
6399     case tok::kw_signed:
6400     case tok::kw_unsigned:
6401     case tok::kw_void:
6402     case tok::kw_char:
6403     case tok::kw_int:
6404     case tok::kw_float:
6405     case tok::kw_double:
6406     case tok::kw_bool:
6407     case tok::kw___bool:
6408     case tok::kw___pixel:
6409       isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
6410       return true;
6411     case tok::identifier:
6412       if (Next.getIdentifierInfo() == Ident_pixel) {
6413         isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID,Policy);
6414         return true;
6415       }
6416       if (Next.getIdentifierInfo() == Ident_bool) {
6417         isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID,Policy);
6418         return true;
6419       }
6420       break;
6421     default:
6422       break;
6423     }
6424   } else if ((Tok.getIdentifierInfo() == Ident_pixel) &&
6425              DS.isTypeAltiVecVector()) {
6426     isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID, Policy);
6427     return true;
6428   } else if ((Tok.getIdentifierInfo() == Ident_bool) &&
6429              DS.isTypeAltiVecVector()) {
6430     isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID, Policy);
6431     return true;
6432   }
6433   return false;
6434 }