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