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