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/Basic/AddressSpaces.h" 17 #include "clang/Basic/CharInfo.h" 18 #include "clang/Basic/OpenCL.h" 19 #include "clang/Parse/ParseDiagnostic.h" 20 #include "clang/Sema/Lookup.h" 21 #include "clang/Sema/ParsedTemplate.h" 22 #include "clang/Sema/PrettyDeclStackTrace.h" 23 #include "clang/Sema/Scope.h" 24 #include "llvm/ADT/SmallSet.h" 25 #include "llvm/ADT/SmallString.h" 26 #include "llvm/ADT/StringSwitch.h" 27 using namespace clang; 28 29 //===----------------------------------------------------------------------===// 30 // C99 6.7: Declarations. 31 //===----------------------------------------------------------------------===// 32 33 /// ParseTypeName 34 /// type-name: [C99 6.7.6] 35 /// specifier-qualifier-list abstract-declarator[opt] 36 /// 37 /// Called type-id in C++. 38 TypeResult Parser::ParseTypeName(SourceRange *Range, 39 Declarator::TheContext Context, 40 AccessSpecifier AS, 41 Decl **OwnedType, 42 ParsedAttributes *Attrs) { 43 DeclSpecContext DSC = getDeclSpecContextFromDeclaratorContext(Context); 44 if (DSC == DSC_normal) 45 DSC = DSC_type_specifier; 46 47 // Parse the common declaration-specifiers piece. 48 DeclSpec DS(AttrFactory); 49 if (Attrs) 50 DS.addAttributes(Attrs->getList()); 51 ParseSpecifierQualifierList(DS, AS, DSC); 52 if (OwnedType) 53 *OwnedType = DS.isTypeSpecOwned() ? DS.getRepAsDecl() : 0; 54 55 // Parse the abstract-declarator, if present. 56 Declarator DeclaratorInfo(DS, Context); 57 ParseDeclarator(DeclaratorInfo); 58 if (Range) 59 *Range = DeclaratorInfo.getSourceRange(); 60 61 if (DeclaratorInfo.isInvalidType()) 62 return true; 63 64 return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 65 } 66 67 68 /// isAttributeLateParsed - Return true if the attribute has arguments that 69 /// require late parsing. 70 static bool isAttributeLateParsed(const IdentifierInfo &II) { 71 return llvm::StringSwitch<bool>(II.getName()) 72 #include "clang/Parse/AttrLateParsed.inc" 73 .Default(false); 74 } 75 76 /// ParseGNUAttributes - Parse a non-empty attributes list. 77 /// 78 /// [GNU] attributes: 79 /// attribute 80 /// attributes attribute 81 /// 82 /// [GNU] attribute: 83 /// '__attribute__' '(' '(' attribute-list ')' ')' 84 /// 85 /// [GNU] attribute-list: 86 /// attrib 87 /// attribute_list ',' attrib 88 /// 89 /// [GNU] attrib: 90 /// empty 91 /// attrib-name 92 /// attrib-name '(' identifier ')' 93 /// attrib-name '(' identifier ',' nonempty-expr-list ')' 94 /// attrib-name '(' argument-expression-list [C99 6.5.2] ')' 95 /// 96 /// [GNU] attrib-name: 97 /// identifier 98 /// typespec 99 /// typequal 100 /// storageclass 101 /// 102 /// FIXME: The GCC grammar/code for this construct implies we need two 103 /// token lookahead. Comment from gcc: "If they start with an identifier 104 /// which is followed by a comma or close parenthesis, then the arguments 105 /// start with that identifier; otherwise they are an expression list." 106 /// 107 /// GCC does not require the ',' between attribs in an attribute-list. 108 /// 109 /// At the moment, I am not doing 2 token lookahead. I am also unaware of 110 /// any attributes that don't work (based on my limited testing). Most 111 /// attributes are very simple in practice. Until we find a bug, I don't see 112 /// a pressing need to implement the 2 token lookahead. 113 114 void Parser::ParseGNUAttributes(ParsedAttributes &attrs, 115 SourceLocation *endLoc, 116 LateParsedAttrList *LateAttrs) { 117 assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!"); 118 119 while (Tok.is(tok::kw___attribute)) { 120 ConsumeToken(); 121 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, 122 "attribute")) { 123 SkipUntil(tok::r_paren, true); // skip until ) or ; 124 return; 125 } 126 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) { 127 SkipUntil(tok::r_paren, true); // skip until ) or ; 128 return; 129 } 130 // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") )) 131 while (Tok.is(tok::identifier) || isDeclarationSpecifier() || 132 Tok.is(tok::comma)) { 133 if (Tok.is(tok::comma)) { 134 // allows for empty/non-empty attributes. ((__vector_size__(16),,,,)) 135 ConsumeToken(); 136 continue; 137 } 138 // we have an identifier or declaration specifier (const, int, etc.) 139 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 140 SourceLocation AttrNameLoc = ConsumeToken(); 141 142 if (Tok.is(tok::l_paren)) { 143 // handle "parameterized" attributes 144 if (LateAttrs && isAttributeLateParsed(*AttrName)) { 145 LateParsedAttribute *LA = 146 new LateParsedAttribute(this, *AttrName, AttrNameLoc); 147 LateAttrs->push_back(LA); 148 149 // Attributes in a class are parsed at the end of the class, along 150 // with other late-parsed declarations. 151 if (!ClassStack.empty() && !LateAttrs->parseSoon()) 152 getCurrentClass().LateParsedDeclarations.push_back(LA); 153 154 // consume everything up to and including the matching right parens 155 ConsumeAndStoreUntil(tok::r_paren, LA->Toks, true, false); 156 157 Token Eof; 158 Eof.startToken(); 159 Eof.setLocation(Tok.getLocation()); 160 LA->Toks.push_back(Eof); 161 } else { 162 ParseGNUAttributeArgs(AttrName, AttrNameLoc, attrs, endLoc, 163 0, SourceLocation(), AttributeList::AS_GNU); 164 } 165 } else { 166 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 167 0, SourceLocation(), 0, 0, AttributeList::AS_GNU); 168 } 169 } 170 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) 171 SkipUntil(tok::r_paren, false); 172 SourceLocation Loc = Tok.getLocation(); 173 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) { 174 SkipUntil(tok::r_paren, false); 175 } 176 if (endLoc) 177 *endLoc = Loc; 178 } 179 } 180 181 182 /// Parse the arguments to a parameterized GNU attribute or 183 /// a C++11 attribute in "gnu" namespace. 184 void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName, 185 SourceLocation AttrNameLoc, 186 ParsedAttributes &Attrs, 187 SourceLocation *EndLoc, 188 IdentifierInfo *ScopeName, 189 SourceLocation ScopeLoc, 190 AttributeList::Syntax Syntax) { 191 192 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('"); 193 194 // Availability attributes have their own grammar. 195 if (AttrName->isStr("availability")) { 196 ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc); 197 return; 198 } 199 // Thread safety attributes fit into the FIXME case above, so we 200 // just parse the arguments as a list of expressions 201 if (IsThreadSafetyAttribute(AttrName->getName())) { 202 ParseThreadSafetyAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc); 203 return; 204 } 205 // Type safety attributes have their own grammar. 206 if (AttrName->isStr("type_tag_for_datatype")) { 207 ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc); 208 return; 209 } 210 211 ConsumeParen(); // ignore the left paren loc for now 212 213 IdentifierInfo *ParmName = 0; 214 SourceLocation ParmLoc; 215 bool BuiltinType = false; 216 217 TypeResult T; 218 SourceRange TypeRange; 219 bool TypeParsed = false; 220 221 switch (Tok.getKind()) { 222 case tok::kw_char: 223 case tok::kw_wchar_t: 224 case tok::kw_char16_t: 225 case tok::kw_char32_t: 226 case tok::kw_bool: 227 case tok::kw_short: 228 case tok::kw_int: 229 case tok::kw_long: 230 case tok::kw___int64: 231 case tok::kw___int128: 232 case tok::kw_signed: 233 case tok::kw_unsigned: 234 case tok::kw_float: 235 case tok::kw_double: 236 case tok::kw_void: 237 case tok::kw_typeof: 238 // __attribute__(( vec_type_hint(char) )) 239 BuiltinType = true; 240 T = ParseTypeName(&TypeRange); 241 TypeParsed = true; 242 break; 243 244 case tok::identifier: 245 if (AttrName->isStr("vec_type_hint")) { 246 T = ParseTypeName(&TypeRange); 247 TypeParsed = true; 248 break; 249 } 250 ParmName = Tok.getIdentifierInfo(); 251 ParmLoc = ConsumeToken(); 252 break; 253 254 default: 255 break; 256 } 257 258 ExprVector ArgExprs; 259 bool isInvalid = false; 260 bool isParmType = false; 261 262 if (!BuiltinType && !AttrName->isStr("vec_type_hint") && 263 (ParmLoc.isValid() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren))) { 264 // Eat the comma. 265 if (ParmLoc.isValid()) 266 ConsumeToken(); 267 268 // Parse the non-empty comma-separated list of expressions. 269 while (1) { 270 ExprResult ArgExpr(ParseAssignmentExpression()); 271 if (ArgExpr.isInvalid()) { 272 SkipUntil(tok::r_paren); 273 return; 274 } 275 ArgExprs.push_back(ArgExpr.release()); 276 if (Tok.isNot(tok::comma)) 277 break; 278 ConsumeToken(); // Eat the comma, move to the next argument 279 } 280 } 281 else if (Tok.is(tok::less) && AttrName->isStr("iboutletcollection")) { 282 if (!ExpectAndConsume(tok::less, diag::err_expected_less_after, "<", 283 tok::greater)) { 284 while (Tok.is(tok::identifier)) { 285 ConsumeToken(); 286 if (Tok.is(tok::greater)) 287 break; 288 if (Tok.is(tok::comma)) { 289 ConsumeToken(); 290 continue; 291 } 292 } 293 if (Tok.isNot(tok::greater)) 294 Diag(Tok, diag::err_iboutletcollection_with_protocol); 295 SkipUntil(tok::r_paren, false, true); // skip until ')' 296 } 297 } else if (AttrName->isStr("vec_type_hint")) { 298 if (T.get() && !T.isInvalid()) 299 isParmType = true; 300 else { 301 if (Tok.is(tok::identifier)) 302 ConsumeToken(); 303 if (TypeParsed) 304 isInvalid = true; 305 } 306 } 307 308 SourceLocation RParen = Tok.getLocation(); 309 if (!ExpectAndConsume(tok::r_paren, diag::err_expected_rparen) && 310 !isInvalid) { 311 SourceLocation AttrLoc = ScopeLoc.isValid() ? ScopeLoc : AttrNameLoc; 312 if (isParmType) { 313 Attrs.addNewTypeAttr(AttrName, SourceRange(AttrLoc, RParen), ScopeName, 314 ScopeLoc, ParmName, ParmLoc, T.get(), Syntax); 315 } else { 316 AttributeList *attr = Attrs.addNew( 317 AttrName, SourceRange(AttrLoc, RParen), ScopeName, ScopeLoc, ParmName, 318 ParmLoc, ArgExprs.data(), ArgExprs.size(), Syntax); 319 if (BuiltinType && 320 attr->getKind() == AttributeList::AT_IBOutletCollection) 321 Diag(Tok, diag::err_iboutletcollection_builtintype); 322 } 323 } 324 } 325 326 /// \brief Parses a single argument for a declspec, including the 327 /// surrounding parens. 328 void Parser::ParseMicrosoftDeclSpecWithSingleArg(IdentifierInfo *AttrName, 329 SourceLocation AttrNameLoc, 330 ParsedAttributes &Attrs) 331 { 332 BalancedDelimiterTracker T(*this, tok::l_paren); 333 if (T.expectAndConsume(diag::err_expected_lparen_after, 334 AttrName->getNameStart(), tok::r_paren)) 335 return; 336 337 ExprResult ArgExpr(ParseConstantExpression()); 338 if (ArgExpr.isInvalid()) { 339 T.skipToEnd(); 340 return; 341 } 342 Expr *ExprList = ArgExpr.take(); 343 Attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(), 344 &ExprList, 1, AttributeList::AS_Declspec); 345 346 T.consumeClose(); 347 } 348 349 /// \brief Determines whether a declspec is a "simple" one requiring no 350 /// arguments. 351 bool Parser::IsSimpleMicrosoftDeclSpec(IdentifierInfo *Ident) { 352 return llvm::StringSwitch<bool>(Ident->getName()) 353 .Case("dllimport", true) 354 .Case("dllexport", true) 355 .Case("noreturn", true) 356 .Case("nothrow", true) 357 .Case("noinline", true) 358 .Case("naked", true) 359 .Case("appdomain", true) 360 .Case("process", true) 361 .Case("jitintrinsic", true) 362 .Case("noalias", true) 363 .Case("restrict", true) 364 .Case("novtable", true) 365 .Case("selectany", true) 366 .Case("thread", true) 367 .Default(false); 368 } 369 370 /// \brief Attempts to parse a declspec which is not simple (one that takes 371 /// parameters). Will return false if we properly handled the declspec, or 372 /// true if it is an unknown declspec. 373 void Parser::ParseComplexMicrosoftDeclSpec(IdentifierInfo *Ident, 374 SourceLocation Loc, 375 ParsedAttributes &Attrs) { 376 // Try to handle the easy case first -- these declspecs all take a single 377 // parameter as their argument. 378 if (llvm::StringSwitch<bool>(Ident->getName()) 379 .Case("uuid", true) 380 .Case("align", true) 381 .Case("allocate", true) 382 .Default(false)) { 383 ParseMicrosoftDeclSpecWithSingleArg(Ident, Loc, Attrs); 384 } else if (Ident->getName() == "deprecated") { 385 // The deprecated declspec has an optional single argument, so we will 386 // check for a l-paren to decide whether we should parse an argument or 387 // not. 388 if (Tok.getKind() == tok::l_paren) 389 ParseMicrosoftDeclSpecWithSingleArg(Ident, Loc, Attrs); 390 else 391 Attrs.addNew(Ident, Loc, 0, Loc, 0, SourceLocation(), 0, 0, 392 AttributeList::AS_Declspec); 393 } else if (Ident->getName() == "property") { 394 // The property declspec is more complex in that it can take one or two 395 // assignment expressions as a parameter, but the lhs of the assignment 396 // must be named get or put. 397 // 398 // For right now, we will just skip to the closing right paren of the 399 // property expression. 400 // 401 // FIXME: we should deal with __declspec(property) at some point because it 402 // is used in the platform SDK headers for the Parallel Patterns Library 403 // and ATL. 404 BalancedDelimiterTracker T(*this, tok::l_paren); 405 if (T.expectAndConsume(diag::err_expected_lparen_after, 406 Ident->getNameStart(), tok::r_paren)) 407 return; 408 T.skipToEnd(); 409 } else { 410 // We don't recognize this as a valid declspec, but instead of creating the 411 // attribute and allowing sema to warn about it, we will warn here instead. 412 // This is because some attributes have multiple spellings, but we need to 413 // disallow that for declspecs (such as align vs aligned). If we made the 414 // attribute, we'd have to split the valid declspec spelling logic into 415 // both locations. 416 Diag(Loc, diag::warn_ms_declspec_unknown) << Ident; 417 418 // If there's an open paren, we should eat the open and close parens under 419 // the assumption that this unknown declspec has parameters. 420 BalancedDelimiterTracker T(*this, tok::l_paren); 421 if (!T.consumeOpen()) 422 T.skipToEnd(); 423 } 424 } 425 426 /// [MS] decl-specifier: 427 /// __declspec ( extended-decl-modifier-seq ) 428 /// 429 /// [MS] extended-decl-modifier-seq: 430 /// extended-decl-modifier[opt] 431 /// extended-decl-modifier extended-decl-modifier-seq 432 void Parser::ParseMicrosoftDeclSpec(ParsedAttributes &Attrs) { 433 assert(Tok.is(tok::kw___declspec) && "Not a declspec!"); 434 435 ConsumeToken(); 436 BalancedDelimiterTracker T(*this, tok::l_paren); 437 if (T.expectAndConsume(diag::err_expected_lparen_after, "__declspec", 438 tok::r_paren)) 439 return; 440 441 // An empty declspec is perfectly legal and should not warn. Additionally, 442 // you can specify multiple attributes per declspec. 443 while (Tok.getKind() != tok::r_paren) { 444 // We expect either a well-known identifier or a generic string. Anything 445 // else is a malformed declspec. 446 bool IsString = Tok.getKind() == tok::string_literal ? true : false; 447 if (!IsString && Tok.getKind() != tok::identifier && 448 Tok.getKind() != tok::kw_restrict) { 449 Diag(Tok, diag::err_ms_declspec_type); 450 T.skipToEnd(); 451 return; 452 } 453 454 IdentifierInfo *AttrName; 455 SourceLocation AttrNameLoc; 456 if (IsString) { 457 SmallString<8> StrBuffer; 458 bool Invalid = false; 459 StringRef Str = PP.getSpelling(Tok, StrBuffer, &Invalid); 460 if (Invalid) { 461 T.skipToEnd(); 462 return; 463 } 464 AttrName = PP.getIdentifierInfo(Str); 465 AttrNameLoc = ConsumeStringToken(); 466 } else { 467 AttrName = Tok.getIdentifierInfo(); 468 AttrNameLoc = ConsumeToken(); 469 } 470 471 if (IsString || IsSimpleMicrosoftDeclSpec(AttrName)) 472 // If we have a generic string, we will allow it because there is no 473 // documented list of allowable string declspecs, but we know they exist 474 // (for instance, SAL declspecs in older versions of MSVC). 475 // 476 // Alternatively, if the identifier is a simple one, then it requires no 477 // arguments and can be turned into an attribute directly. 478 Attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(), 479 0, 0, AttributeList::AS_Declspec); 480 else 481 ParseComplexMicrosoftDeclSpec(AttrName, AttrNameLoc, Attrs); 482 } 483 T.consumeClose(); 484 } 485 486 void Parser::ParseMicrosoftTypeAttributes(ParsedAttributes &attrs) { 487 // Treat these like attributes 488 while (Tok.is(tok::kw___fastcall) || Tok.is(tok::kw___stdcall) || 489 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___cdecl) || 490 Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64) || 491 Tok.is(tok::kw___ptr32) || Tok.is(tok::kw___unaligned)) { 492 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 493 SourceLocation AttrNameLoc = ConsumeToken(); 494 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, 495 SourceLocation(), 0, 0, AttributeList::AS_Keyword); 496 } 497 } 498 499 void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) { 500 // Treat these like attributes 501 while (Tok.is(tok::kw___pascal)) { 502 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 503 SourceLocation AttrNameLoc = ConsumeToken(); 504 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, 505 SourceLocation(), 0, 0, AttributeList::AS_Keyword); 506 } 507 } 508 509 void Parser::ParseOpenCLAttributes(ParsedAttributes &attrs) { 510 // Treat these like attributes 511 while (Tok.is(tok::kw___kernel)) { 512 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 513 SourceLocation AttrNameLoc = ConsumeToken(); 514 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, 515 SourceLocation(), 0, 0, AttributeList::AS_Keyword); 516 } 517 } 518 519 void Parser::ParseOpenCLQualifiers(DeclSpec &DS) { 520 // FIXME: The mapping from attribute spelling to semantics should be 521 // performed in Sema, not here. 522 SourceLocation Loc = Tok.getLocation(); 523 switch(Tok.getKind()) { 524 // OpenCL qualifiers: 525 case tok::kw___private: 526 case tok::kw_private: 527 DS.getAttributes().addNewInteger( 528 Actions.getASTContext(), 529 PP.getIdentifierInfo("address_space"), Loc, 0); 530 break; 531 532 case tok::kw___global: 533 DS.getAttributes().addNewInteger( 534 Actions.getASTContext(), 535 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_global); 536 break; 537 538 case tok::kw___local: 539 DS.getAttributes().addNewInteger( 540 Actions.getASTContext(), 541 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_local); 542 break; 543 544 case tok::kw___constant: 545 DS.getAttributes().addNewInteger( 546 Actions.getASTContext(), 547 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_constant); 548 break; 549 550 case tok::kw___read_only: 551 DS.getAttributes().addNewInteger( 552 Actions.getASTContext(), 553 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_only); 554 break; 555 556 case tok::kw___write_only: 557 DS.getAttributes().addNewInteger( 558 Actions.getASTContext(), 559 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_write_only); 560 break; 561 562 case tok::kw___read_write: 563 DS.getAttributes().addNewInteger( 564 Actions.getASTContext(), 565 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_write); 566 break; 567 default: break; 568 } 569 } 570 571 /// \brief Parse a version number. 572 /// 573 /// version: 574 /// simple-integer 575 /// simple-integer ',' simple-integer 576 /// simple-integer ',' simple-integer ',' simple-integer 577 VersionTuple Parser::ParseVersionTuple(SourceRange &Range) { 578 Range = Tok.getLocation(); 579 580 if (!Tok.is(tok::numeric_constant)) { 581 Diag(Tok, diag::err_expected_version); 582 SkipUntil(tok::comma, tok::r_paren, true, true, true); 583 return VersionTuple(); 584 } 585 586 // Parse the major (and possibly minor and subminor) versions, which 587 // are stored in the numeric constant. We utilize a quirk of the 588 // lexer, which is that it handles something like 1.2.3 as a single 589 // numeric constant, rather than two separate tokens. 590 SmallString<512> Buffer; 591 Buffer.resize(Tok.getLength()+1); 592 const char *ThisTokBegin = &Buffer[0]; 593 594 // Get the spelling of the token, which eliminates trigraphs, etc. 595 bool Invalid = false; 596 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid); 597 if (Invalid) 598 return VersionTuple(); 599 600 // Parse the major version. 601 unsigned AfterMajor = 0; 602 unsigned Major = 0; 603 while (AfterMajor < ActualLength && isDigit(ThisTokBegin[AfterMajor])) { 604 Major = Major * 10 + ThisTokBegin[AfterMajor] - '0'; 605 ++AfterMajor; 606 } 607 608 if (AfterMajor == 0) { 609 Diag(Tok, diag::err_expected_version); 610 SkipUntil(tok::comma, tok::r_paren, true, true, true); 611 return VersionTuple(); 612 } 613 614 if (AfterMajor == ActualLength) { 615 ConsumeToken(); 616 617 // We only had a single version component. 618 if (Major == 0) { 619 Diag(Tok, diag::err_zero_version); 620 return VersionTuple(); 621 } 622 623 return VersionTuple(Major); 624 } 625 626 if (ThisTokBegin[AfterMajor] != '.' || (AfterMajor + 1 == ActualLength)) { 627 Diag(Tok, diag::err_expected_version); 628 SkipUntil(tok::comma, tok::r_paren, true, true, true); 629 return VersionTuple(); 630 } 631 632 // Parse the minor version. 633 unsigned AfterMinor = AfterMajor + 1; 634 unsigned Minor = 0; 635 while (AfterMinor < ActualLength && isDigit(ThisTokBegin[AfterMinor])) { 636 Minor = Minor * 10 + ThisTokBegin[AfterMinor] - '0'; 637 ++AfterMinor; 638 } 639 640 if (AfterMinor == ActualLength) { 641 ConsumeToken(); 642 643 // We had major.minor. 644 if (Major == 0 && Minor == 0) { 645 Diag(Tok, diag::err_zero_version); 646 return VersionTuple(); 647 } 648 649 return VersionTuple(Major, Minor); 650 } 651 652 // If what follows is not a '.', we have a problem. 653 if (ThisTokBegin[AfterMinor] != '.') { 654 Diag(Tok, diag::err_expected_version); 655 SkipUntil(tok::comma, tok::r_paren, true, true, true); 656 return VersionTuple(); 657 } 658 659 // Parse the subminor version. 660 unsigned AfterSubminor = AfterMinor + 1; 661 unsigned Subminor = 0; 662 while (AfterSubminor < ActualLength && isDigit(ThisTokBegin[AfterSubminor])) { 663 Subminor = Subminor * 10 + ThisTokBegin[AfterSubminor] - '0'; 664 ++AfterSubminor; 665 } 666 667 if (AfterSubminor != ActualLength) { 668 Diag(Tok, diag::err_expected_version); 669 SkipUntil(tok::comma, tok::r_paren, true, true, true); 670 return VersionTuple(); 671 } 672 ConsumeToken(); 673 return VersionTuple(Major, Minor, Subminor); 674 } 675 676 /// \brief Parse the contents of the "availability" attribute. 677 /// 678 /// availability-attribute: 679 /// 'availability' '(' platform ',' version-arg-list, opt-message')' 680 /// 681 /// platform: 682 /// identifier 683 /// 684 /// version-arg-list: 685 /// version-arg 686 /// version-arg ',' version-arg-list 687 /// 688 /// version-arg: 689 /// 'introduced' '=' version 690 /// 'deprecated' '=' version 691 /// 'obsoleted' = version 692 /// 'unavailable' 693 /// opt-message: 694 /// 'message' '=' <string> 695 void Parser::ParseAvailabilityAttribute(IdentifierInfo &Availability, 696 SourceLocation AvailabilityLoc, 697 ParsedAttributes &attrs, 698 SourceLocation *endLoc) { 699 SourceLocation PlatformLoc; 700 IdentifierInfo *Platform = 0; 701 702 enum { Introduced, Deprecated, Obsoleted, Unknown }; 703 AvailabilityChange Changes[Unknown]; 704 ExprResult MessageExpr; 705 706 // Opening '('. 707 BalancedDelimiterTracker T(*this, tok::l_paren); 708 if (T.consumeOpen()) { 709 Diag(Tok, diag::err_expected_lparen); 710 return; 711 } 712 713 // Parse the platform name, 714 if (Tok.isNot(tok::identifier)) { 715 Diag(Tok, diag::err_availability_expected_platform); 716 SkipUntil(tok::r_paren); 717 return; 718 } 719 Platform = Tok.getIdentifierInfo(); 720 PlatformLoc = ConsumeToken(); 721 722 // Parse the ',' following the platform name. 723 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", tok::r_paren)) 724 return; 725 726 // If we haven't grabbed the pointers for the identifiers 727 // "introduced", "deprecated", and "obsoleted", do so now. 728 if (!Ident_introduced) { 729 Ident_introduced = PP.getIdentifierInfo("introduced"); 730 Ident_deprecated = PP.getIdentifierInfo("deprecated"); 731 Ident_obsoleted = PP.getIdentifierInfo("obsoleted"); 732 Ident_unavailable = PP.getIdentifierInfo("unavailable"); 733 Ident_message = PP.getIdentifierInfo("message"); 734 } 735 736 // Parse the set of introductions/deprecations/removals. 737 SourceLocation UnavailableLoc; 738 do { 739 if (Tok.isNot(tok::identifier)) { 740 Diag(Tok, diag::err_availability_expected_change); 741 SkipUntil(tok::r_paren); 742 return; 743 } 744 IdentifierInfo *Keyword = Tok.getIdentifierInfo(); 745 SourceLocation KeywordLoc = ConsumeToken(); 746 747 if (Keyword == Ident_unavailable) { 748 if (UnavailableLoc.isValid()) { 749 Diag(KeywordLoc, diag::err_availability_redundant) 750 << Keyword << SourceRange(UnavailableLoc); 751 } 752 UnavailableLoc = KeywordLoc; 753 754 if (Tok.isNot(tok::comma)) 755 break; 756 757 ConsumeToken(); 758 continue; 759 } 760 761 if (Tok.isNot(tok::equal)) { 762 Diag(Tok, diag::err_expected_equal_after) 763 << Keyword; 764 SkipUntil(tok::r_paren); 765 return; 766 } 767 ConsumeToken(); 768 if (Keyword == Ident_message) { 769 if (!isTokenStringLiteral()) { 770 Diag(Tok, diag::err_expected_string_literal) 771 << /*Source='availability attribute'*/2; 772 SkipUntil(tok::r_paren); 773 return; 774 } 775 MessageExpr = ParseStringLiteralExpression(); 776 break; 777 } 778 779 SourceRange VersionRange; 780 VersionTuple Version = ParseVersionTuple(VersionRange); 781 782 if (Version.empty()) { 783 SkipUntil(tok::r_paren); 784 return; 785 } 786 787 unsigned Index; 788 if (Keyword == Ident_introduced) 789 Index = Introduced; 790 else if (Keyword == Ident_deprecated) 791 Index = Deprecated; 792 else if (Keyword == Ident_obsoleted) 793 Index = Obsoleted; 794 else 795 Index = Unknown; 796 797 if (Index < Unknown) { 798 if (!Changes[Index].KeywordLoc.isInvalid()) { 799 Diag(KeywordLoc, diag::err_availability_redundant) 800 << Keyword 801 << SourceRange(Changes[Index].KeywordLoc, 802 Changes[Index].VersionRange.getEnd()); 803 } 804 805 Changes[Index].KeywordLoc = KeywordLoc; 806 Changes[Index].Version = Version; 807 Changes[Index].VersionRange = VersionRange; 808 } else { 809 Diag(KeywordLoc, diag::err_availability_unknown_change) 810 << Keyword << VersionRange; 811 } 812 813 if (Tok.isNot(tok::comma)) 814 break; 815 816 ConsumeToken(); 817 } while (true); 818 819 // Closing ')'. 820 if (T.consumeClose()) 821 return; 822 823 if (endLoc) 824 *endLoc = T.getCloseLocation(); 825 826 // The 'unavailable' availability cannot be combined with any other 827 // availability changes. Make sure that hasn't happened. 828 if (UnavailableLoc.isValid()) { 829 bool Complained = false; 830 for (unsigned Index = Introduced; Index != Unknown; ++Index) { 831 if (Changes[Index].KeywordLoc.isValid()) { 832 if (!Complained) { 833 Diag(UnavailableLoc, diag::warn_availability_and_unavailable) 834 << SourceRange(Changes[Index].KeywordLoc, 835 Changes[Index].VersionRange.getEnd()); 836 Complained = true; 837 } 838 839 // Clear out the availability. 840 Changes[Index] = AvailabilityChange(); 841 } 842 } 843 } 844 845 // Record this attribute 846 attrs.addNew(&Availability, 847 SourceRange(AvailabilityLoc, T.getCloseLocation()), 848 0, AvailabilityLoc, 849 Platform, PlatformLoc, 850 Changes[Introduced], 851 Changes[Deprecated], 852 Changes[Obsoleted], 853 UnavailableLoc, MessageExpr.take(), 854 AttributeList::AS_GNU); 855 } 856 857 858 // Late Parsed Attributes: 859 // See other examples of late parsing in lib/Parse/ParseCXXInlineMethods 860 861 void Parser::LateParsedDeclaration::ParseLexedAttributes() {} 862 863 void Parser::LateParsedClass::ParseLexedAttributes() { 864 Self->ParseLexedAttributes(*Class); 865 } 866 867 void Parser::LateParsedAttribute::ParseLexedAttributes() { 868 Self->ParseLexedAttribute(*this, true, false); 869 } 870 871 /// Wrapper class which calls ParseLexedAttribute, after setting up the 872 /// scope appropriately. 873 void Parser::ParseLexedAttributes(ParsingClass &Class) { 874 // Deal with templates 875 // FIXME: Test cases to make sure this does the right thing for templates. 876 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope; 877 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, 878 HasTemplateScope); 879 if (HasTemplateScope) 880 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate); 881 882 // Set or update the scope flags. 883 bool AlreadyHasClassScope = Class.TopLevelClass; 884 unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope; 885 ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope); 886 ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope); 887 888 // Enter the scope of nested classes 889 if (!AlreadyHasClassScope) 890 Actions.ActOnStartDelayedMemberDeclarations(getCurScope(), 891 Class.TagOrTemplate); 892 if (!Class.LateParsedDeclarations.empty()) { 893 for (unsigned i = 0, ni = Class.LateParsedDeclarations.size(); i < ni; ++i){ 894 Class.LateParsedDeclarations[i]->ParseLexedAttributes(); 895 } 896 } 897 898 if (!AlreadyHasClassScope) 899 Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(), 900 Class.TagOrTemplate); 901 } 902 903 904 /// \brief Parse all attributes in LAs, and attach them to Decl D. 905 void Parser::ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D, 906 bool EnterScope, bool OnDefinition) { 907 assert(LAs.parseSoon() && 908 "Attribute list should be marked for immediate parsing."); 909 for (unsigned i = 0, ni = LAs.size(); i < ni; ++i) { 910 if (D) 911 LAs[i]->addDecl(D); 912 ParseLexedAttribute(*LAs[i], EnterScope, OnDefinition); 913 delete LAs[i]; 914 } 915 LAs.clear(); 916 } 917 918 919 /// \brief Finish parsing an attribute for which parsing was delayed. 920 /// This will be called at the end of parsing a class declaration 921 /// for each LateParsedAttribute. We consume the saved tokens and 922 /// create an attribute with the arguments filled in. We add this 923 /// to the Attribute list for the decl. 924 void Parser::ParseLexedAttribute(LateParsedAttribute &LA, 925 bool EnterScope, bool OnDefinition) { 926 // Save the current token position. 927 SourceLocation OrigLoc = Tok.getLocation(); 928 929 // Append the current token at the end of the new token stream so that it 930 // doesn't get lost. 931 LA.Toks.push_back(Tok); 932 PP.EnterTokenStream(LA.Toks.data(), LA.Toks.size(), true, false); 933 // Consume the previously pushed token. 934 ConsumeAnyToken(); 935 936 if (OnDefinition && !IsThreadSafetyAttribute(LA.AttrName.getName())) { 937 // FIXME: Do not warn on C++11 attributes, once we start supporting 938 // them here. 939 Diag(Tok, diag::warn_attribute_on_function_definition) 940 << LA.AttrName.getName(); 941 } 942 943 ParsedAttributes Attrs(AttrFactory); 944 SourceLocation endLoc; 945 946 if (LA.Decls.size() > 0) { 947 Decl *D = LA.Decls[0]; 948 NamedDecl *ND = dyn_cast<NamedDecl>(D); 949 RecordDecl *RD = dyn_cast_or_null<RecordDecl>(D->getDeclContext()); 950 951 // Allow 'this' within late-parsed attributes. 952 Sema::CXXThisScopeRAII ThisScope(Actions, RD, 953 /*TypeQuals=*/0, 954 ND && RD && ND->isCXXInstanceMember()); 955 956 if (LA.Decls.size() == 1) { 957 // If the Decl is templatized, add template parameters to scope. 958 bool HasTemplateScope = EnterScope && D->isTemplateDecl(); 959 ParseScope TempScope(this, Scope::TemplateParamScope, HasTemplateScope); 960 if (HasTemplateScope) 961 Actions.ActOnReenterTemplateScope(Actions.CurScope, D); 962 963 // If the Decl is on a function, add function parameters to the scope. 964 bool HasFunScope = EnterScope && D->isFunctionOrFunctionTemplate(); 965 ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope, HasFunScope); 966 if (HasFunScope) 967 Actions.ActOnReenterFunctionContext(Actions.CurScope, D); 968 969 ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc, 970 0, SourceLocation(), AttributeList::AS_GNU); 971 972 if (HasFunScope) { 973 Actions.ActOnExitFunctionContext(); 974 FnScope.Exit(); // Pop scope, and remove Decls from IdResolver 975 } 976 if (HasTemplateScope) { 977 TempScope.Exit(); 978 } 979 } else { 980 // If there are multiple decls, then the decl cannot be within the 981 // function scope. 982 ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc, 983 0, SourceLocation(), AttributeList::AS_GNU); 984 } 985 } else { 986 Diag(Tok, diag::warn_attribute_no_decl) << LA.AttrName.getName(); 987 } 988 989 for (unsigned i = 0, ni = LA.Decls.size(); i < ni; ++i) { 990 Actions.ActOnFinishDelayedAttribute(getCurScope(), LA.Decls[i], Attrs); 991 } 992 993 if (Tok.getLocation() != OrigLoc) { 994 // Due to a parsing error, we either went over the cached tokens or 995 // there are still cached tokens left, so we skip the leftover tokens. 996 // Since this is an uncommon situation that should be avoided, use the 997 // expensive isBeforeInTranslationUnit call. 998 if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(), 999 OrigLoc)) 1000 while (Tok.getLocation() != OrigLoc && Tok.isNot(tok::eof)) 1001 ConsumeAnyToken(); 1002 } 1003 } 1004 1005 /// \brief Wrapper around a case statement checking if AttrName is 1006 /// one of the thread safety attributes 1007 bool Parser::IsThreadSafetyAttribute(StringRef AttrName) { 1008 return llvm::StringSwitch<bool>(AttrName) 1009 .Case("guarded_by", true) 1010 .Case("guarded_var", true) 1011 .Case("pt_guarded_by", true) 1012 .Case("pt_guarded_var", true) 1013 .Case("lockable", true) 1014 .Case("scoped_lockable", true) 1015 .Case("no_thread_safety_analysis", true) 1016 .Case("acquired_after", true) 1017 .Case("acquired_before", true) 1018 .Case("exclusive_lock_function", true) 1019 .Case("shared_lock_function", true) 1020 .Case("exclusive_trylock_function", true) 1021 .Case("shared_trylock_function", true) 1022 .Case("unlock_function", true) 1023 .Case("lock_returned", true) 1024 .Case("locks_excluded", true) 1025 .Case("exclusive_locks_required", true) 1026 .Case("shared_locks_required", true) 1027 .Default(false); 1028 } 1029 1030 /// \brief Parse the contents of thread safety attributes. These 1031 /// should always be parsed as an expression list. 1032 /// 1033 /// We need to special case the parsing due to the fact that if the first token 1034 /// of the first argument is an identifier, the main parse loop will store 1035 /// that token as a "parameter" and the rest of 1036 /// the arguments will be added to a list of "arguments". However, 1037 /// subsequent tokens in the first argument are lost. We instead parse each 1038 /// argument as an expression and add all arguments to the list of "arguments". 1039 /// In future, we will take advantage of this special case to also 1040 /// deal with some argument scoping issues here (for example, referring to a 1041 /// function parameter in the attribute on that function). 1042 void Parser::ParseThreadSafetyAttribute(IdentifierInfo &AttrName, 1043 SourceLocation AttrNameLoc, 1044 ParsedAttributes &Attrs, 1045 SourceLocation *EndLoc) { 1046 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('"); 1047 1048 BalancedDelimiterTracker T(*this, tok::l_paren); 1049 T.consumeOpen(); 1050 1051 ExprVector ArgExprs; 1052 bool ArgExprsOk = true; 1053 1054 // now parse the list of expressions 1055 while (Tok.isNot(tok::r_paren)) { 1056 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated); 1057 ExprResult ArgExpr(ParseAssignmentExpression()); 1058 if (ArgExpr.isInvalid()) { 1059 ArgExprsOk = false; 1060 T.consumeClose(); 1061 break; 1062 } else { 1063 ArgExprs.push_back(ArgExpr.release()); 1064 } 1065 if (Tok.isNot(tok::comma)) 1066 break; 1067 ConsumeToken(); // Eat the comma, move to the next argument 1068 } 1069 // Match the ')'. 1070 if (ArgExprsOk && !T.consumeClose()) { 1071 Attrs.addNew(&AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(), 1072 ArgExprs.data(), ArgExprs.size(), AttributeList::AS_GNU); 1073 } 1074 if (EndLoc) 1075 *EndLoc = T.getCloseLocation(); 1076 } 1077 1078 void Parser::ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName, 1079 SourceLocation AttrNameLoc, 1080 ParsedAttributes &Attrs, 1081 SourceLocation *EndLoc) { 1082 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('"); 1083 1084 BalancedDelimiterTracker T(*this, tok::l_paren); 1085 T.consumeOpen(); 1086 1087 if (Tok.isNot(tok::identifier)) { 1088 Diag(Tok, diag::err_expected_ident); 1089 T.skipToEnd(); 1090 return; 1091 } 1092 IdentifierInfo *ArgumentKind = Tok.getIdentifierInfo(); 1093 SourceLocation ArgumentKindLoc = ConsumeToken(); 1094 1095 if (Tok.isNot(tok::comma)) { 1096 Diag(Tok, diag::err_expected_comma); 1097 T.skipToEnd(); 1098 return; 1099 } 1100 ConsumeToken(); 1101 1102 SourceRange MatchingCTypeRange; 1103 TypeResult MatchingCType = ParseTypeName(&MatchingCTypeRange); 1104 if (MatchingCType.isInvalid()) { 1105 T.skipToEnd(); 1106 return; 1107 } 1108 1109 bool LayoutCompatible = false; 1110 bool MustBeNull = false; 1111 while (Tok.is(tok::comma)) { 1112 ConsumeToken(); 1113 if (Tok.isNot(tok::identifier)) { 1114 Diag(Tok, diag::err_expected_ident); 1115 T.skipToEnd(); 1116 return; 1117 } 1118 IdentifierInfo *Flag = Tok.getIdentifierInfo(); 1119 if (Flag->isStr("layout_compatible")) 1120 LayoutCompatible = true; 1121 else if (Flag->isStr("must_be_null")) 1122 MustBeNull = true; 1123 else { 1124 Diag(Tok, diag::err_type_safety_unknown_flag) << Flag; 1125 T.skipToEnd(); 1126 return; 1127 } 1128 ConsumeToken(); // consume flag 1129 } 1130 1131 if (!T.consumeClose()) { 1132 Attrs.addNewTypeTagForDatatype(&AttrName, AttrNameLoc, 0, AttrNameLoc, 1133 ArgumentKind, ArgumentKindLoc, 1134 MatchingCType.release(), LayoutCompatible, 1135 MustBeNull, AttributeList::AS_GNU); 1136 } 1137 1138 if (EndLoc) 1139 *EndLoc = T.getCloseLocation(); 1140 } 1141 1142 /// DiagnoseProhibitedCXX11Attribute - We have found the opening square brackets 1143 /// of a C++11 attribute-specifier in a location where an attribute is not 1144 /// permitted. By C++11 [dcl.attr.grammar]p6, this is ill-formed. Diagnose this 1145 /// situation. 1146 /// 1147 /// \return \c true if we skipped an attribute-like chunk of tokens, \c false if 1148 /// this doesn't appear to actually be an attribute-specifier, and the caller 1149 /// should try to parse it. 1150 bool Parser::DiagnoseProhibitedCXX11Attribute() { 1151 assert(Tok.is(tok::l_square) && NextToken().is(tok::l_square)); 1152 1153 switch (isCXX11AttributeSpecifier(/*Disambiguate*/true)) { 1154 case CAK_NotAttributeSpecifier: 1155 // No diagnostic: we're in Obj-C++11 and this is not actually an attribute. 1156 return false; 1157 1158 case CAK_InvalidAttributeSpecifier: 1159 Diag(Tok.getLocation(), diag::err_l_square_l_square_not_attribute); 1160 return false; 1161 1162 case CAK_AttributeSpecifier: 1163 // Parse and discard the attributes. 1164 SourceLocation BeginLoc = ConsumeBracket(); 1165 ConsumeBracket(); 1166 SkipUntil(tok::r_square, /*StopAtSemi*/ false); 1167 assert(Tok.is(tok::r_square) && "isCXX11AttributeSpecifier lied"); 1168 SourceLocation EndLoc = ConsumeBracket(); 1169 Diag(BeginLoc, diag::err_attributes_not_allowed) 1170 << SourceRange(BeginLoc, EndLoc); 1171 return true; 1172 } 1173 llvm_unreachable("All cases handled above."); 1174 } 1175 1176 /// \brief We have found the opening square brackets of a C++11 1177 /// attribute-specifier in a location where an attribute is not permitted, but 1178 /// we know where the attributes ought to be written. Parse them anyway, and 1179 /// provide a fixit moving them to the right place. 1180 void Parser::DiagnoseMisplacedCXX11Attribute(ParsedAttributesWithRange &Attrs, 1181 SourceLocation CorrectLocation) { 1182 assert((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) || 1183 Tok.is(tok::kw_alignas)); 1184 1185 // Consume the attributes. 1186 SourceLocation Loc = Tok.getLocation(); 1187 ParseCXX11Attributes(Attrs); 1188 CharSourceRange AttrRange(SourceRange(Loc, Attrs.Range.getEnd()), true); 1189 1190 Diag(Loc, diag::err_attributes_not_allowed) 1191 << FixItHint::CreateInsertionFromRange(CorrectLocation, AttrRange) 1192 << FixItHint::CreateRemoval(AttrRange); 1193 } 1194 1195 void Parser::DiagnoseProhibitedAttributes(ParsedAttributesWithRange &attrs) { 1196 Diag(attrs.Range.getBegin(), diag::err_attributes_not_allowed) 1197 << attrs.Range; 1198 } 1199 1200 void Parser::ProhibitCXX11Attributes(ParsedAttributesWithRange &attrs) { 1201 AttributeList *AttrList = attrs.getList(); 1202 while (AttrList) { 1203 if (AttrList->isCXX11Attribute()) { 1204 Diag(AttrList->getLoc(), diag::err_attribute_not_type_attr) 1205 << AttrList->getName(); 1206 AttrList->setInvalid(); 1207 } 1208 AttrList = AttrList->getNext(); 1209 } 1210 } 1211 1212 /// ParseDeclaration - Parse a full 'declaration', which consists of 1213 /// declaration-specifiers, some number of declarators, and a semicolon. 1214 /// 'Context' should be a Declarator::TheContext value. This returns the 1215 /// location of the semicolon in DeclEnd. 1216 /// 1217 /// declaration: [C99 6.7] 1218 /// block-declaration -> 1219 /// simple-declaration 1220 /// others [FIXME] 1221 /// [C++] template-declaration 1222 /// [C++] namespace-definition 1223 /// [C++] using-directive 1224 /// [C++] using-declaration 1225 /// [C++11/C11] static_assert-declaration 1226 /// others... [FIXME] 1227 /// 1228 Parser::DeclGroupPtrTy Parser::ParseDeclaration(StmtVector &Stmts, 1229 unsigned Context, 1230 SourceLocation &DeclEnd, 1231 ParsedAttributesWithRange &attrs) { 1232 ParenBraceBracketBalancer BalancerRAIIObj(*this); 1233 // Must temporarily exit the objective-c container scope for 1234 // parsing c none objective-c decls. 1235 ObjCDeclContextSwitch ObjCDC(*this); 1236 1237 Decl *SingleDecl = 0; 1238 Decl *OwnedType = 0; 1239 switch (Tok.getKind()) { 1240 case tok::kw_template: 1241 case tok::kw_export: 1242 ProhibitAttributes(attrs); 1243 SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd); 1244 break; 1245 case tok::kw_inline: 1246 // Could be the start of an inline namespace. Allowed as an ext in C++03. 1247 if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_namespace)) { 1248 ProhibitAttributes(attrs); 1249 SourceLocation InlineLoc = ConsumeToken(); 1250 SingleDecl = ParseNamespace(Context, DeclEnd, InlineLoc); 1251 break; 1252 } 1253 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs, 1254 true); 1255 case tok::kw_namespace: 1256 ProhibitAttributes(attrs); 1257 SingleDecl = ParseNamespace(Context, DeclEnd); 1258 break; 1259 case tok::kw_using: 1260 SingleDecl = ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(), 1261 DeclEnd, attrs, &OwnedType); 1262 break; 1263 case tok::kw_static_assert: 1264 case tok::kw__Static_assert: 1265 ProhibitAttributes(attrs); 1266 SingleDecl = ParseStaticAssertDeclaration(DeclEnd); 1267 break; 1268 default: 1269 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs, true); 1270 } 1271 1272 // This routine returns a DeclGroup, if the thing we parsed only contains a 1273 // single decl, convert it now. Alias declarations can also declare a type; 1274 // include that too if it is present. 1275 return Actions.ConvertDeclToDeclGroup(SingleDecl, OwnedType); 1276 } 1277 1278 /// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl] 1279 /// declaration-specifiers init-declarator-list[opt] ';' 1280 /// [C++11] attribute-specifier-seq decl-specifier-seq[opt] 1281 /// init-declarator-list ';' 1282 ///[C90/C++]init-declarator-list ';' [TODO] 1283 /// [OMP] threadprivate-directive [TODO] 1284 /// 1285 /// for-range-declaration: [C++11 6.5p1: stmt.ranged] 1286 /// attribute-specifier-seq[opt] type-specifier-seq declarator 1287 /// 1288 /// If RequireSemi is false, this does not check for a ';' at the end of the 1289 /// declaration. If it is true, it checks for and eats it. 1290 /// 1291 /// If FRI is non-null, we might be parsing a for-range-declaration instead 1292 /// of a simple-declaration. If we find that we are, we also parse the 1293 /// for-range-initializer, and place it here. 1294 Parser::DeclGroupPtrTy 1295 Parser::ParseSimpleDeclaration(StmtVector &Stmts, unsigned Context, 1296 SourceLocation &DeclEnd, 1297 ParsedAttributesWithRange &Attrs, 1298 bool RequireSemi, ForRangeInit *FRI) { 1299 // Parse the common declaration-specifiers piece. 1300 ParsingDeclSpec DS(*this); 1301 1302 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none, 1303 getDeclSpecContextFromDeclaratorContext(Context)); 1304 1305 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };" 1306 // declaration-specifiers init-declarator-list[opt] ';' 1307 if (Tok.is(tok::semi)) { 1308 ProhibitAttributes(Attrs); 1309 DeclEnd = Tok.getLocation(); 1310 if (RequireSemi) ConsumeToken(); 1311 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, 1312 DS); 1313 DS.complete(TheDecl); 1314 return Actions.ConvertDeclToDeclGroup(TheDecl); 1315 } 1316 1317 DS.takeAttributesFrom(Attrs); 1318 return ParseDeclGroup(DS, Context, /*FunctionDefs=*/ false, &DeclEnd, FRI); 1319 } 1320 1321 /// Returns true if this might be the start of a declarator, or a common typo 1322 /// for a declarator. 1323 bool Parser::MightBeDeclarator(unsigned Context) { 1324 switch (Tok.getKind()) { 1325 case tok::annot_cxxscope: 1326 case tok::annot_template_id: 1327 case tok::caret: 1328 case tok::code_completion: 1329 case tok::coloncolon: 1330 case tok::ellipsis: 1331 case tok::kw___attribute: 1332 case tok::kw_operator: 1333 case tok::l_paren: 1334 case tok::star: 1335 return true; 1336 1337 case tok::amp: 1338 case tok::ampamp: 1339 return getLangOpts().CPlusPlus; 1340 1341 case tok::l_square: // Might be an attribute on an unnamed bit-field. 1342 return Context == Declarator::MemberContext && getLangOpts().CPlusPlus11 && 1343 NextToken().is(tok::l_square); 1344 1345 case tok::colon: // Might be a typo for '::' or an unnamed bit-field. 1346 return Context == Declarator::MemberContext || getLangOpts().CPlusPlus; 1347 1348 case tok::identifier: 1349 switch (NextToken().getKind()) { 1350 case tok::code_completion: 1351 case tok::coloncolon: 1352 case tok::comma: 1353 case tok::equal: 1354 case tok::equalequal: // Might be a typo for '='. 1355 case tok::kw_alignas: 1356 case tok::kw_asm: 1357 case tok::kw___attribute: 1358 case tok::l_brace: 1359 case tok::l_paren: 1360 case tok::l_square: 1361 case tok::less: 1362 case tok::r_brace: 1363 case tok::r_paren: 1364 case tok::r_square: 1365 case tok::semi: 1366 return true; 1367 1368 case tok::colon: 1369 // At namespace scope, 'identifier:' is probably a typo for 'identifier::' 1370 // and in block scope it's probably a label. Inside a class definition, 1371 // this is a bit-field. 1372 return Context == Declarator::MemberContext || 1373 (getLangOpts().CPlusPlus && Context == Declarator::FileContext); 1374 1375 case tok::identifier: // Possible virt-specifier. 1376 return getLangOpts().CPlusPlus11 && isCXX11VirtSpecifier(NextToken()); 1377 1378 default: 1379 return false; 1380 } 1381 1382 default: 1383 return false; 1384 } 1385 } 1386 1387 /// Skip until we reach something which seems like a sensible place to pick 1388 /// up parsing after a malformed declaration. This will sometimes stop sooner 1389 /// than SkipUntil(tok::r_brace) would, but will never stop later. 1390 void Parser::SkipMalformedDecl() { 1391 while (true) { 1392 switch (Tok.getKind()) { 1393 case tok::l_brace: 1394 // Skip until matching }, then stop. We've probably skipped over 1395 // a malformed class or function definition or similar. 1396 ConsumeBrace(); 1397 SkipUntil(tok::r_brace, /*StopAtSemi*/false); 1398 if (Tok.is(tok::comma) || Tok.is(tok::l_brace) || Tok.is(tok::kw_try)) { 1399 // This declaration isn't over yet. Keep skipping. 1400 continue; 1401 } 1402 if (Tok.is(tok::semi)) 1403 ConsumeToken(); 1404 return; 1405 1406 case tok::l_square: 1407 ConsumeBracket(); 1408 SkipUntil(tok::r_square, /*StopAtSemi*/false); 1409 continue; 1410 1411 case tok::l_paren: 1412 ConsumeParen(); 1413 SkipUntil(tok::r_paren, /*StopAtSemi*/false); 1414 continue; 1415 1416 case tok::r_brace: 1417 return; 1418 1419 case tok::semi: 1420 ConsumeToken(); 1421 return; 1422 1423 case tok::kw_inline: 1424 // 'inline namespace' at the start of a line is almost certainly 1425 // a good place to pick back up parsing, except in an Objective-C 1426 // @interface context. 1427 if (Tok.isAtStartOfLine() && NextToken().is(tok::kw_namespace) && 1428 (!ParsingInObjCContainer || CurParsedObjCImpl)) 1429 return; 1430 break; 1431 1432 case tok::kw_namespace: 1433 // 'namespace' at the start of a line is almost certainly a good 1434 // place to pick back up parsing, except in an Objective-C 1435 // @interface context. 1436 if (Tok.isAtStartOfLine() && 1437 (!ParsingInObjCContainer || CurParsedObjCImpl)) 1438 return; 1439 break; 1440 1441 case tok::at: 1442 // @end is very much like } in Objective-C contexts. 1443 if (NextToken().isObjCAtKeyword(tok::objc_end) && 1444 ParsingInObjCContainer) 1445 return; 1446 break; 1447 1448 case tok::minus: 1449 case tok::plus: 1450 // - and + probably start new method declarations in Objective-C contexts. 1451 if (Tok.isAtStartOfLine() && ParsingInObjCContainer) 1452 return; 1453 break; 1454 1455 case tok::eof: 1456 return; 1457 1458 default: 1459 break; 1460 } 1461 1462 ConsumeAnyToken(); 1463 } 1464 } 1465 1466 /// ParseDeclGroup - Having concluded that this is either a function 1467 /// definition or a group of object declarations, actually parse the 1468 /// result. 1469 Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS, 1470 unsigned Context, 1471 bool AllowFunctionDefinitions, 1472 SourceLocation *DeclEnd, 1473 ForRangeInit *FRI) { 1474 // Parse the first declarator. 1475 ParsingDeclarator D(*this, DS, static_cast<Declarator::TheContext>(Context)); 1476 ParseDeclarator(D); 1477 1478 // Bail out if the first declarator didn't seem well-formed. 1479 if (!D.hasName() && !D.mayOmitIdentifier()) { 1480 SkipMalformedDecl(); 1481 return DeclGroupPtrTy(); 1482 } 1483 1484 // Save late-parsed attributes for now; they need to be parsed in the 1485 // appropriate function scope after the function Decl has been constructed. 1486 // These will be parsed in ParseFunctionDefinition or ParseLexedAttrList. 1487 LateParsedAttrList LateParsedAttrs(true); 1488 if (D.isFunctionDeclarator()) 1489 MaybeParseGNUAttributes(D, &LateParsedAttrs); 1490 1491 // Check to see if we have a function *definition* which must have a body. 1492 if (AllowFunctionDefinitions && D.isFunctionDeclarator() && 1493 // Look at the next token to make sure that this isn't a function 1494 // declaration. We have to check this because __attribute__ might be the 1495 // start of a function definition in GCC-extended K&R C. 1496 !isDeclarationAfterDeclarator()) { 1497 1498 if (isStartOfFunctionDefinition(D)) { 1499 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) { 1500 Diag(Tok, diag::err_function_declared_typedef); 1501 1502 // Recover by treating the 'typedef' as spurious. 1503 DS.ClearStorageClassSpecs(); 1504 } 1505 1506 Decl *TheDecl = 1507 ParseFunctionDefinition(D, ParsedTemplateInfo(), &LateParsedAttrs); 1508 return Actions.ConvertDeclToDeclGroup(TheDecl); 1509 } 1510 1511 if (isDeclarationSpecifier()) { 1512 // If there is an invalid declaration specifier right after the function 1513 // prototype, then we must be in a missing semicolon case where this isn't 1514 // actually a body. Just fall through into the code that handles it as a 1515 // prototype, and let the top-level code handle the erroneous declspec 1516 // where it would otherwise expect a comma or semicolon. 1517 } else { 1518 Diag(Tok, diag::err_expected_fn_body); 1519 SkipUntil(tok::semi); 1520 return DeclGroupPtrTy(); 1521 } 1522 } 1523 1524 if (ParseAsmAttributesAfterDeclarator(D)) 1525 return DeclGroupPtrTy(); 1526 1527 // C++0x [stmt.iter]p1: Check if we have a for-range-declarator. If so, we 1528 // must parse and analyze the for-range-initializer before the declaration is 1529 // analyzed. 1530 if (FRI && Tok.is(tok::colon)) { 1531 FRI->ColonLoc = ConsumeToken(); 1532 if (Tok.is(tok::l_brace)) 1533 FRI->RangeExpr = ParseBraceInitializer(); 1534 else 1535 FRI->RangeExpr = ParseExpression(); 1536 Decl *ThisDecl = Actions.ActOnDeclarator(getCurScope(), D); 1537 Actions.ActOnCXXForRangeDecl(ThisDecl); 1538 Actions.FinalizeDeclaration(ThisDecl); 1539 D.complete(ThisDecl); 1540 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, &ThisDecl, 1); 1541 } 1542 1543 SmallVector<Decl *, 8> DeclsInGroup; 1544 Decl *FirstDecl = ParseDeclarationAfterDeclaratorAndAttributes(D); 1545 if (LateParsedAttrs.size() > 0) 1546 ParseLexedAttributeList(LateParsedAttrs, FirstDecl, true, false); 1547 D.complete(FirstDecl); 1548 if (FirstDecl) 1549 DeclsInGroup.push_back(FirstDecl); 1550 1551 bool ExpectSemi = Context != Declarator::ForContext; 1552 1553 // If we don't have a comma, it is either the end of the list (a ';') or an 1554 // error, bail out. 1555 while (Tok.is(tok::comma)) { 1556 SourceLocation CommaLoc = ConsumeToken(); 1557 1558 if (Tok.isAtStartOfLine() && ExpectSemi && !MightBeDeclarator(Context)) { 1559 // This comma was followed by a line-break and something which can't be 1560 // the start of a declarator. The comma was probably a typo for a 1561 // semicolon. 1562 Diag(CommaLoc, diag::err_expected_semi_declaration) 1563 << FixItHint::CreateReplacement(CommaLoc, ";"); 1564 ExpectSemi = false; 1565 break; 1566 } 1567 1568 // Parse the next declarator. 1569 D.clear(); 1570 D.setCommaLoc(CommaLoc); 1571 1572 // Accept attributes in an init-declarator. In the first declarator in a 1573 // declaration, these would be part of the declspec. In subsequent 1574 // declarators, they become part of the declarator itself, so that they 1575 // don't apply to declarators after *this* one. Examples: 1576 // short __attribute__((common)) var; -> declspec 1577 // short var __attribute__((common)); -> declarator 1578 // short x, __attribute__((common)) var; -> declarator 1579 MaybeParseGNUAttributes(D); 1580 1581 ParseDeclarator(D); 1582 if (!D.isInvalidType()) { 1583 Decl *ThisDecl = ParseDeclarationAfterDeclarator(D); 1584 D.complete(ThisDecl); 1585 if (ThisDecl) 1586 DeclsInGroup.push_back(ThisDecl); 1587 } 1588 } 1589 1590 if (DeclEnd) 1591 *DeclEnd = Tok.getLocation(); 1592 1593 if (ExpectSemi && 1594 ExpectAndConsumeSemi(Context == Declarator::FileContext 1595 ? diag::err_invalid_token_after_toplevel_declarator 1596 : diag::err_expected_semi_declaration)) { 1597 // Okay, there was no semicolon and one was expected. If we see a 1598 // declaration specifier, just assume it was missing and continue parsing. 1599 // Otherwise things are very confused and we skip to recover. 1600 if (!isDeclarationSpecifier()) { 1601 SkipUntil(tok::r_brace, true, true); 1602 if (Tok.is(tok::semi)) 1603 ConsumeToken(); 1604 } 1605 } 1606 1607 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, 1608 DeclsInGroup.data(), 1609 DeclsInGroup.size()); 1610 } 1611 1612 /// Parse an optional simple-asm-expr and attributes, and attach them to a 1613 /// declarator. Returns true on an error. 1614 bool Parser::ParseAsmAttributesAfterDeclarator(Declarator &D) { 1615 // If a simple-asm-expr is present, parse it. 1616 if (Tok.is(tok::kw_asm)) { 1617 SourceLocation Loc; 1618 ExprResult AsmLabel(ParseSimpleAsm(&Loc)); 1619 if (AsmLabel.isInvalid()) { 1620 SkipUntil(tok::semi, true, true); 1621 return true; 1622 } 1623 1624 D.setAsmLabel(AsmLabel.release()); 1625 D.SetRangeEnd(Loc); 1626 } 1627 1628 MaybeParseGNUAttributes(D); 1629 return false; 1630 } 1631 1632 /// \brief Parse 'declaration' after parsing 'declaration-specifiers 1633 /// declarator'. This method parses the remainder of the declaration 1634 /// (including any attributes or initializer, among other things) and 1635 /// finalizes the declaration. 1636 /// 1637 /// init-declarator: [C99 6.7] 1638 /// declarator 1639 /// declarator '=' initializer 1640 /// [GNU] declarator simple-asm-expr[opt] attributes[opt] 1641 /// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer 1642 /// [C++] declarator initializer[opt] 1643 /// 1644 /// [C++] initializer: 1645 /// [C++] '=' initializer-clause 1646 /// [C++] '(' expression-list ')' 1647 /// [C++0x] '=' 'default' [TODO] 1648 /// [C++0x] '=' 'delete' 1649 /// [C++0x] braced-init-list 1650 /// 1651 /// According to the standard grammar, =default and =delete are function 1652 /// definitions, but that definitely doesn't fit with the parser here. 1653 /// 1654 Decl *Parser::ParseDeclarationAfterDeclarator(Declarator &D, 1655 const ParsedTemplateInfo &TemplateInfo) { 1656 if (ParseAsmAttributesAfterDeclarator(D)) 1657 return 0; 1658 1659 return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo); 1660 } 1661 1662 Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(Declarator &D, 1663 const ParsedTemplateInfo &TemplateInfo) { 1664 // Inform the current actions module that we just parsed this declarator. 1665 Decl *ThisDecl = 0; 1666 switch (TemplateInfo.Kind) { 1667 case ParsedTemplateInfo::NonTemplate: 1668 ThisDecl = Actions.ActOnDeclarator(getCurScope(), D); 1669 break; 1670 1671 case ParsedTemplateInfo::Template: 1672 case ParsedTemplateInfo::ExplicitSpecialization: 1673 ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(), 1674 *TemplateInfo.TemplateParams, 1675 D); 1676 break; 1677 1678 case ParsedTemplateInfo::ExplicitInstantiation: { 1679 DeclResult ThisRes 1680 = Actions.ActOnExplicitInstantiation(getCurScope(), 1681 TemplateInfo.ExternLoc, 1682 TemplateInfo.TemplateLoc, 1683 D); 1684 if (ThisRes.isInvalid()) { 1685 SkipUntil(tok::semi, true, true); 1686 return 0; 1687 } 1688 1689 ThisDecl = ThisRes.get(); 1690 break; 1691 } 1692 } 1693 1694 bool TypeContainsAuto = 1695 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto; 1696 1697 // Parse declarator '=' initializer. 1698 // If a '==' or '+=' is found, suggest a fixit to '='. 1699 if (isTokenEqualOrEqualTypo()) { 1700 ConsumeToken(); 1701 if (Tok.is(tok::kw_delete)) { 1702 if (D.isFunctionDeclarator()) 1703 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration) 1704 << 1 /* delete */; 1705 else 1706 Diag(ConsumeToken(), diag::err_deleted_non_function); 1707 } else if (Tok.is(tok::kw_default)) { 1708 if (D.isFunctionDeclarator()) 1709 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration) 1710 << 0 /* default */; 1711 else 1712 Diag(ConsumeToken(), diag::err_default_special_members); 1713 } else { 1714 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) { 1715 EnterScope(0); 1716 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl); 1717 } 1718 1719 if (Tok.is(tok::code_completion)) { 1720 Actions.CodeCompleteInitializer(getCurScope(), ThisDecl); 1721 Actions.FinalizeDeclaration(ThisDecl); 1722 cutOffParsing(); 1723 return 0; 1724 } 1725 1726 ExprResult Init(ParseInitializer()); 1727 1728 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) { 1729 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl); 1730 ExitScope(); 1731 } 1732 1733 if (Init.isInvalid()) { 1734 SkipUntil(tok::comma, true, true); 1735 Actions.ActOnInitializerError(ThisDecl); 1736 } else 1737 Actions.AddInitializerToDecl(ThisDecl, Init.take(), 1738 /*DirectInit=*/false, TypeContainsAuto); 1739 } 1740 } else if (Tok.is(tok::l_paren)) { 1741 // Parse C++ direct initializer: '(' expression-list ')' 1742 BalancedDelimiterTracker T(*this, tok::l_paren); 1743 T.consumeOpen(); 1744 1745 ExprVector Exprs; 1746 CommaLocsTy CommaLocs; 1747 1748 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) { 1749 EnterScope(0); 1750 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl); 1751 } 1752 1753 if (ParseExpressionList(Exprs, CommaLocs)) { 1754 Actions.ActOnInitializerError(ThisDecl); 1755 SkipUntil(tok::r_paren); 1756 1757 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) { 1758 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl); 1759 ExitScope(); 1760 } 1761 } else { 1762 // Match the ')'. 1763 T.consumeClose(); 1764 1765 assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() && 1766 "Unexpected number of commas!"); 1767 1768 if (getLangOpts().CPlusPlus && D.getCXXScopeSpec().isSet()) { 1769 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl); 1770 ExitScope(); 1771 } 1772 1773 ExprResult Initializer = Actions.ActOnParenListExpr(T.getOpenLocation(), 1774 T.getCloseLocation(), 1775 Exprs); 1776 Actions.AddInitializerToDecl(ThisDecl, Initializer.take(), 1777 /*DirectInit=*/true, TypeContainsAuto); 1778 } 1779 } else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace) && 1780 (!CurParsedObjCImpl || !D.isFunctionDeclarator())) { 1781 // Parse C++0x braced-init-list. 1782 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists); 1783 1784 if (D.getCXXScopeSpec().isSet()) { 1785 EnterScope(0); 1786 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl); 1787 } 1788 1789 ExprResult Init(ParseBraceInitializer()); 1790 1791 if (D.getCXXScopeSpec().isSet()) { 1792 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl); 1793 ExitScope(); 1794 } 1795 1796 if (Init.isInvalid()) { 1797 Actions.ActOnInitializerError(ThisDecl); 1798 } else 1799 Actions.AddInitializerToDecl(ThisDecl, Init.take(), 1800 /*DirectInit=*/true, TypeContainsAuto); 1801 1802 } else { 1803 Actions.ActOnUninitializedDecl(ThisDecl, TypeContainsAuto); 1804 } 1805 1806 Actions.FinalizeDeclaration(ThisDecl); 1807 1808 return ThisDecl; 1809 } 1810 1811 /// ParseSpecifierQualifierList 1812 /// specifier-qualifier-list: 1813 /// type-specifier specifier-qualifier-list[opt] 1814 /// type-qualifier specifier-qualifier-list[opt] 1815 /// [GNU] attributes specifier-qualifier-list[opt] 1816 /// 1817 void Parser::ParseSpecifierQualifierList(DeclSpec &DS, AccessSpecifier AS, 1818 DeclSpecContext DSC) { 1819 /// specifier-qualifier-list is a subset of declaration-specifiers. Just 1820 /// parse declaration-specifiers and complain about extra stuff. 1821 /// TODO: diagnose attribute-specifiers and alignment-specifiers. 1822 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC); 1823 1824 // Validate declspec for type-name. 1825 unsigned Specs = DS.getParsedSpecifiers(); 1826 if ((DSC == DSC_type_specifier || DSC == DSC_trailing) && 1827 !DS.hasTypeSpecifier()) { 1828 Diag(Tok, diag::err_expected_type); 1829 DS.SetTypeSpecError(); 1830 } else if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers() && 1831 !DS.hasAttributes()) { 1832 Diag(Tok, diag::err_typename_requires_specqual); 1833 if (!DS.hasTypeSpecifier()) 1834 DS.SetTypeSpecError(); 1835 } 1836 1837 // Issue diagnostic and remove storage class if present. 1838 if (Specs & DeclSpec::PQ_StorageClassSpecifier) { 1839 if (DS.getStorageClassSpecLoc().isValid()) 1840 Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass); 1841 else 1842 Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass); 1843 DS.ClearStorageClassSpecs(); 1844 } 1845 1846 // Issue diagnostic and remove function specfier if present. 1847 if (Specs & DeclSpec::PQ_FunctionSpecifier) { 1848 if (DS.isInlineSpecified()) 1849 Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec); 1850 if (DS.isVirtualSpecified()) 1851 Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec); 1852 if (DS.isExplicitSpecified()) 1853 Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec); 1854 DS.ClearFunctionSpecs(); 1855 } 1856 1857 // Issue diagnostic and remove constexpr specfier if present. 1858 if (DS.isConstexprSpecified()) { 1859 Diag(DS.getConstexprSpecLoc(), diag::err_typename_invalid_constexpr); 1860 DS.ClearConstexprSpec(); 1861 } 1862 } 1863 1864 /// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the 1865 /// specified token is valid after the identifier in a declarator which 1866 /// immediately follows the declspec. For example, these things are valid: 1867 /// 1868 /// int x [ 4]; // direct-declarator 1869 /// int x ( int y); // direct-declarator 1870 /// int(int x ) // direct-declarator 1871 /// int x ; // simple-declaration 1872 /// int x = 17; // init-declarator-list 1873 /// int x , y; // init-declarator-list 1874 /// int x __asm__ ("foo"); // init-declarator-list 1875 /// int x : 4; // struct-declarator 1876 /// int x { 5}; // C++'0x unified initializers 1877 /// 1878 /// This is not, because 'x' does not immediately follow the declspec (though 1879 /// ')' happens to be valid anyway). 1880 /// int (x) 1881 /// 1882 static bool isValidAfterIdentifierInDeclarator(const Token &T) { 1883 return T.is(tok::l_square) || T.is(tok::l_paren) || T.is(tok::r_paren) || 1884 T.is(tok::semi) || T.is(tok::comma) || T.is(tok::equal) || 1885 T.is(tok::kw_asm) || T.is(tok::l_brace) || T.is(tok::colon); 1886 } 1887 1888 1889 /// ParseImplicitInt - This method is called when we have an non-typename 1890 /// identifier in a declspec (which normally terminates the decl spec) when 1891 /// the declspec has no type specifier. In this case, the declspec is either 1892 /// malformed or is "implicit int" (in K&R and C89). 1893 /// 1894 /// This method handles diagnosing this prettily and returns false if the 1895 /// declspec is done being processed. If it recovers and thinks there may be 1896 /// other pieces of declspec after it, it returns true. 1897 /// 1898 bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS, 1899 const ParsedTemplateInfo &TemplateInfo, 1900 AccessSpecifier AS, DeclSpecContext DSC, 1901 ParsedAttributesWithRange &Attrs) { 1902 assert(Tok.is(tok::identifier) && "should have identifier"); 1903 1904 SourceLocation Loc = Tok.getLocation(); 1905 // If we see an identifier that is not a type name, we normally would 1906 // parse it as the identifer being declared. However, when a typename 1907 // is typo'd or the definition is not included, this will incorrectly 1908 // parse the typename as the identifier name and fall over misparsing 1909 // later parts of the diagnostic. 1910 // 1911 // As such, we try to do some look-ahead in cases where this would 1912 // otherwise be an "implicit-int" case to see if this is invalid. For 1913 // example: "static foo_t x = 4;" In this case, if we parsed foo_t as 1914 // an identifier with implicit int, we'd get a parse error because the 1915 // next token is obviously invalid for a type. Parse these as a case 1916 // with an invalid type specifier. 1917 assert(!DS.hasTypeSpecifier() && "Type specifier checked above"); 1918 1919 // Since we know that this either implicit int (which is rare) or an 1920 // error, do lookahead to try to do better recovery. This never applies 1921 // within a type specifier. Outside of C++, we allow this even if the 1922 // language doesn't "officially" support implicit int -- we support 1923 // implicit int as an extension in C99 and C11. Allegedly, MS also 1924 // supports implicit int in C++ mode. 1925 if (DSC != DSC_type_specifier && DSC != DSC_trailing && 1926 (!getLangOpts().CPlusPlus || getLangOpts().MicrosoftExt) && 1927 isValidAfterIdentifierInDeclarator(NextToken())) { 1928 // If this token is valid for implicit int, e.g. "static x = 4", then 1929 // we just avoid eating the identifier, so it will be parsed as the 1930 // identifier in the declarator. 1931 return false; 1932 } 1933 1934 if (getLangOpts().CPlusPlus && 1935 DS.getStorageClassSpec() == DeclSpec::SCS_auto) { 1936 // Don't require a type specifier if we have the 'auto' storage class 1937 // specifier in C++98 -- we'll promote it to a type specifier. 1938 return false; 1939 } 1940 1941 // Otherwise, if we don't consume this token, we are going to emit an 1942 // error anyway. Try to recover from various common problems. Check 1943 // to see if this was a reference to a tag name without a tag specified. 1944 // This is a common problem in C (saying 'foo' instead of 'struct foo'). 1945 // 1946 // C++ doesn't need this, and isTagName doesn't take SS. 1947 if (SS == 0) { 1948 const char *TagName = 0, *FixitTagName = 0; 1949 tok::TokenKind TagKind = tok::unknown; 1950 1951 switch (Actions.isTagName(*Tok.getIdentifierInfo(), getCurScope())) { 1952 default: break; 1953 case DeclSpec::TST_enum: 1954 TagName="enum" ; FixitTagName = "enum " ; TagKind=tok::kw_enum ;break; 1955 case DeclSpec::TST_union: 1956 TagName="union" ; FixitTagName = "union " ;TagKind=tok::kw_union ;break; 1957 case DeclSpec::TST_struct: 1958 TagName="struct"; FixitTagName = "struct ";TagKind=tok::kw_struct;break; 1959 case DeclSpec::TST_interface: 1960 TagName="__interface"; FixitTagName = "__interface "; 1961 TagKind=tok::kw___interface;break; 1962 case DeclSpec::TST_class: 1963 TagName="class" ; FixitTagName = "class " ;TagKind=tok::kw_class ;break; 1964 } 1965 1966 if (TagName) { 1967 IdentifierInfo *TokenName = Tok.getIdentifierInfo(); 1968 LookupResult R(Actions, TokenName, SourceLocation(), 1969 Sema::LookupOrdinaryName); 1970 1971 Diag(Loc, diag::err_use_of_tag_name_without_tag) 1972 << TokenName << TagName << getLangOpts().CPlusPlus 1973 << FixItHint::CreateInsertion(Tok.getLocation(), FixitTagName); 1974 1975 if (Actions.LookupParsedName(R, getCurScope(), SS)) { 1976 for (LookupResult::iterator I = R.begin(), IEnd = R.end(); 1977 I != IEnd; ++I) 1978 Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type) 1979 << TokenName << TagName; 1980 } 1981 1982 // Parse this as a tag as if the missing tag were present. 1983 if (TagKind == tok::kw_enum) 1984 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS, DSC_normal); 1985 else 1986 ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS, 1987 /*EnteringContext*/ false, DSC_normal, Attrs); 1988 return true; 1989 } 1990 } 1991 1992 // Determine whether this identifier could plausibly be the name of something 1993 // being declared (with a missing type). 1994 if (DSC != DSC_type_specifier && DSC != DSC_trailing && 1995 (!SS || DSC == DSC_top_level || DSC == DSC_class)) { 1996 // Look ahead to the next token to try to figure out what this declaration 1997 // was supposed to be. 1998 switch (NextToken().getKind()) { 1999 case tok::comma: 2000 case tok::equal: 2001 case tok::kw_asm: 2002 case tok::l_brace: 2003 case tok::l_square: 2004 case tok::semi: 2005 // This looks like a variable declaration. The type is probably missing. 2006 // We're done parsing decl-specifiers. 2007 return false; 2008 2009 case tok::l_paren: { 2010 // static x(4); // 'x' is not a type 2011 // x(int n); // 'x' is not a type 2012 // x (*p)[]; // 'x' is a type 2013 // 2014 // Since we're in an error case (or the rare 'implicit int in C++' MS 2015 // extension), we can afford to perform a tentative parse to determine 2016 // which case we're in. 2017 TentativeParsingAction PA(*this); 2018 ConsumeToken(); 2019 TPResult TPR = TryParseDeclarator(/*mayBeAbstract*/false); 2020 PA.Revert(); 2021 if (TPR == TPResult::False()) 2022 return false; 2023 // The identifier is followed by a parenthesized declarator. 2024 // It's supposed to be a type. 2025 break; 2026 } 2027 2028 default: 2029 // This is probably supposed to be a type. This includes cases like: 2030 // int f(itn); 2031 // struct S { unsinged : 4; }; 2032 break; 2033 } 2034 } 2035 2036 // This is almost certainly an invalid type name. Let the action emit a 2037 // diagnostic and attempt to recover. 2038 ParsedType T; 2039 IdentifierInfo *II = Tok.getIdentifierInfo(); 2040 if (Actions.DiagnoseUnknownTypeName(II, Loc, getCurScope(), SS, T)) { 2041 // The action emitted a diagnostic, so we don't have to. 2042 if (T) { 2043 // The action has suggested that the type T could be used. Set that as 2044 // the type in the declaration specifiers, consume the would-be type 2045 // name token, and we're done. 2046 const char *PrevSpec; 2047 unsigned DiagID; 2048 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T); 2049 DS.SetRangeEnd(Tok.getLocation()); 2050 ConsumeToken(); 2051 // There may be other declaration specifiers after this. 2052 return true; 2053 } else if (II != Tok.getIdentifierInfo()) { 2054 // If no type was suggested, the correction is to a keyword 2055 Tok.setKind(II->getTokenID()); 2056 // There may be other declaration specifiers after this. 2057 return true; 2058 } 2059 2060 // Fall through; the action had no suggestion for us. 2061 } else { 2062 // The action did not emit a diagnostic, so emit one now. 2063 SourceRange R; 2064 if (SS) R = SS->getRange(); 2065 Diag(Loc, diag::err_unknown_typename) << Tok.getIdentifierInfo() << R; 2066 } 2067 2068 // Mark this as an error. 2069 DS.SetTypeSpecError(); 2070 DS.SetRangeEnd(Tok.getLocation()); 2071 ConsumeToken(); 2072 2073 // TODO: Could inject an invalid typedef decl in an enclosing scope to 2074 // avoid rippling error messages on subsequent uses of the same type, 2075 // could be useful if #include was forgotten. 2076 return false; 2077 } 2078 2079 /// \brief Determine the declaration specifier context from the declarator 2080 /// context. 2081 /// 2082 /// \param Context the declarator context, which is one of the 2083 /// Declarator::TheContext enumerator values. 2084 Parser::DeclSpecContext 2085 Parser::getDeclSpecContextFromDeclaratorContext(unsigned Context) { 2086 if (Context == Declarator::MemberContext) 2087 return DSC_class; 2088 if (Context == Declarator::FileContext) 2089 return DSC_top_level; 2090 if (Context == Declarator::TrailingReturnContext) 2091 return DSC_trailing; 2092 return DSC_normal; 2093 } 2094 2095 /// ParseAlignArgument - Parse the argument to an alignment-specifier. 2096 /// 2097 /// FIXME: Simply returns an alignof() expression if the argument is a 2098 /// type. Ideally, the type should be propagated directly into Sema. 2099 /// 2100 /// [C11] type-id 2101 /// [C11] constant-expression 2102 /// [C++0x] type-id ...[opt] 2103 /// [C++0x] assignment-expression ...[opt] 2104 ExprResult Parser::ParseAlignArgument(SourceLocation Start, 2105 SourceLocation &EllipsisLoc) { 2106 ExprResult ER; 2107 if (isTypeIdInParens()) { 2108 SourceLocation TypeLoc = Tok.getLocation(); 2109 ParsedType Ty = ParseTypeName().get(); 2110 SourceRange TypeRange(Start, Tok.getLocation()); 2111 ER = Actions.ActOnUnaryExprOrTypeTraitExpr(TypeLoc, UETT_AlignOf, true, 2112 Ty.getAsOpaquePtr(), TypeRange); 2113 } else 2114 ER = ParseConstantExpression(); 2115 2116 if (getLangOpts().CPlusPlus11 && Tok.is(tok::ellipsis)) 2117 EllipsisLoc = ConsumeToken(); 2118 2119 return ER; 2120 } 2121 2122 /// ParseAlignmentSpecifier - Parse an alignment-specifier, and add the 2123 /// attribute to Attrs. 2124 /// 2125 /// alignment-specifier: 2126 /// [C11] '_Alignas' '(' type-id ')' 2127 /// [C11] '_Alignas' '(' constant-expression ')' 2128 /// [C++11] 'alignas' '(' type-id ...[opt] ')' 2129 /// [C++11] 'alignas' '(' assignment-expression ...[opt] ')' 2130 void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs, 2131 SourceLocation *EndLoc) { 2132 assert((Tok.is(tok::kw_alignas) || Tok.is(tok::kw__Alignas)) && 2133 "Not an alignment-specifier!"); 2134 2135 IdentifierInfo *KWName = Tok.getIdentifierInfo(); 2136 SourceLocation KWLoc = ConsumeToken(); 2137 2138 BalancedDelimiterTracker T(*this, tok::l_paren); 2139 if (T.expectAndConsume(diag::err_expected_lparen)) 2140 return; 2141 2142 SourceLocation EllipsisLoc; 2143 ExprResult ArgExpr = ParseAlignArgument(T.getOpenLocation(), EllipsisLoc); 2144 if (ArgExpr.isInvalid()) { 2145 SkipUntil(tok::r_paren); 2146 return; 2147 } 2148 2149 T.consumeClose(); 2150 if (EndLoc) 2151 *EndLoc = T.getCloseLocation(); 2152 2153 ExprVector ArgExprs; 2154 ArgExprs.push_back(ArgExpr.release()); 2155 Attrs.addNew(KWName, KWLoc, 0, KWLoc, 0, T.getOpenLocation(), 2156 ArgExprs.data(), 1, AttributeList::AS_Keyword, EllipsisLoc); 2157 } 2158 2159 /// ParseDeclarationSpecifiers 2160 /// declaration-specifiers: [C99 6.7] 2161 /// storage-class-specifier declaration-specifiers[opt] 2162 /// type-specifier declaration-specifiers[opt] 2163 /// [C99] function-specifier declaration-specifiers[opt] 2164 /// [C11] alignment-specifier declaration-specifiers[opt] 2165 /// [GNU] attributes declaration-specifiers[opt] 2166 /// [Clang] '__module_private__' declaration-specifiers[opt] 2167 /// 2168 /// storage-class-specifier: [C99 6.7.1] 2169 /// 'typedef' 2170 /// 'extern' 2171 /// 'static' 2172 /// 'auto' 2173 /// 'register' 2174 /// [C++] 'mutable' 2175 /// [GNU] '__thread' 2176 /// function-specifier: [C99 6.7.4] 2177 /// [C99] 'inline' 2178 /// [C++] 'virtual' 2179 /// [C++] 'explicit' 2180 /// [OpenCL] '__kernel' 2181 /// 'friend': [C++ dcl.friend] 2182 /// 'constexpr': [C++0x dcl.constexpr] 2183 2184 /// 2185 void Parser::ParseDeclarationSpecifiers(DeclSpec &DS, 2186 const ParsedTemplateInfo &TemplateInfo, 2187 AccessSpecifier AS, 2188 DeclSpecContext DSContext, 2189 LateParsedAttrList *LateAttrs) { 2190 if (DS.getSourceRange().isInvalid()) { 2191 DS.SetRangeStart(Tok.getLocation()); 2192 DS.SetRangeEnd(Tok.getLocation()); 2193 } 2194 2195 bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level); 2196 bool AttrsLastTime = false; 2197 ParsedAttributesWithRange attrs(AttrFactory); 2198 while (1) { 2199 bool isInvalid = false; 2200 const char *PrevSpec = 0; 2201 unsigned DiagID = 0; 2202 2203 SourceLocation Loc = Tok.getLocation(); 2204 2205 switch (Tok.getKind()) { 2206 default: 2207 DoneWithDeclSpec: 2208 if (!AttrsLastTime) 2209 ProhibitAttributes(attrs); 2210 else { 2211 // Reject C++11 attributes that appertain to decl specifiers as 2212 // we don't support any C++11 attributes that appertain to decl 2213 // specifiers. This also conforms to what g++ 4.8 is doing. 2214 ProhibitCXX11Attributes(attrs); 2215 2216 DS.takeAttributesFrom(attrs); 2217 } 2218 2219 // If this is not a declaration specifier token, we're done reading decl 2220 // specifiers. First verify that DeclSpec's are consistent. 2221 DS.Finish(Diags, PP); 2222 return; 2223 2224 case tok::l_square: 2225 case tok::kw_alignas: 2226 if (!getLangOpts().CPlusPlus11 || !isCXX11AttributeSpecifier()) 2227 goto DoneWithDeclSpec; 2228 2229 ProhibitAttributes(attrs); 2230 // FIXME: It would be good to recover by accepting the attributes, 2231 // but attempting to do that now would cause serious 2232 // madness in terms of diagnostics. 2233 attrs.clear(); 2234 attrs.Range = SourceRange(); 2235 2236 ParseCXX11Attributes(attrs); 2237 AttrsLastTime = true; 2238 continue; 2239 2240 case tok::code_completion: { 2241 Sema::ParserCompletionContext CCC = Sema::PCC_Namespace; 2242 if (DS.hasTypeSpecifier()) { 2243 bool AllowNonIdentifiers 2244 = (getCurScope()->getFlags() & (Scope::ControlScope | 2245 Scope::BlockScope | 2246 Scope::TemplateParamScope | 2247 Scope::FunctionPrototypeScope | 2248 Scope::AtCatchScope)) == 0; 2249 bool AllowNestedNameSpecifiers 2250 = DSContext == DSC_top_level || 2251 (DSContext == DSC_class && DS.isFriendSpecified()); 2252 2253 Actions.CodeCompleteDeclSpec(getCurScope(), DS, 2254 AllowNonIdentifiers, 2255 AllowNestedNameSpecifiers); 2256 return cutOffParsing(); 2257 } 2258 2259 if (getCurScope()->getFnParent() || getCurScope()->getBlockParent()) 2260 CCC = Sema::PCC_LocalDeclarationSpecifiers; 2261 else if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate) 2262 CCC = DSContext == DSC_class? Sema::PCC_MemberTemplate 2263 : Sema::PCC_Template; 2264 else if (DSContext == DSC_class) 2265 CCC = Sema::PCC_Class; 2266 else if (CurParsedObjCImpl) 2267 CCC = Sema::PCC_ObjCImplementation; 2268 2269 Actions.CodeCompleteOrdinaryName(getCurScope(), CCC); 2270 return cutOffParsing(); 2271 } 2272 2273 case tok::coloncolon: // ::foo::bar 2274 // C++ scope specifier. Annotate and loop, or bail out on error. 2275 if (TryAnnotateCXXScopeToken(true)) { 2276 if (!DS.hasTypeSpecifier()) 2277 DS.SetTypeSpecError(); 2278 goto DoneWithDeclSpec; 2279 } 2280 if (Tok.is(tok::coloncolon)) // ::new or ::delete 2281 goto DoneWithDeclSpec; 2282 continue; 2283 2284 case tok::annot_cxxscope: { 2285 if (DS.hasTypeSpecifier() || DS.isTypeAltiVecVector()) 2286 goto DoneWithDeclSpec; 2287 2288 CXXScopeSpec SS; 2289 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(), 2290 Tok.getAnnotationRange(), 2291 SS); 2292 2293 // We are looking for a qualified typename. 2294 Token Next = NextToken(); 2295 if (Next.is(tok::annot_template_id) && 2296 static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue()) 2297 ->Kind == TNK_Type_template) { 2298 // We have a qualified template-id, e.g., N::A<int> 2299 2300 // C++ [class.qual]p2: 2301 // In a lookup in which the constructor is an acceptable lookup 2302 // result and the nested-name-specifier nominates a class C: 2303 // 2304 // - if the name specified after the 2305 // nested-name-specifier, when looked up in C, is the 2306 // injected-class-name of C (Clause 9), or 2307 // 2308 // - if the name specified after the nested-name-specifier 2309 // is the same as the identifier or the 2310 // simple-template-id's template-name in the last 2311 // component of the nested-name-specifier, 2312 // 2313 // the name is instead considered to name the constructor of 2314 // class C. 2315 // 2316 // Thus, if the template-name is actually the constructor 2317 // name, then the code is ill-formed; this interpretation is 2318 // reinforced by the NAD status of core issue 635. 2319 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Next); 2320 if ((DSContext == DSC_top_level || DSContext == DSC_class) && 2321 TemplateId->Name && 2322 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) { 2323 if (isConstructorDeclarator()) { 2324 // The user meant this to be an out-of-line constructor 2325 // definition, but template arguments are not allowed 2326 // there. Just allow this as a constructor; we'll 2327 // complain about it later. 2328 goto DoneWithDeclSpec; 2329 } 2330 2331 // The user meant this to name a type, but it actually names 2332 // a constructor with some extraneous template 2333 // arguments. Complain, then parse it as a type as the user 2334 // intended. 2335 Diag(TemplateId->TemplateNameLoc, 2336 diag::err_out_of_line_template_id_names_constructor) 2337 << TemplateId->Name; 2338 } 2339 2340 DS.getTypeSpecScope() = SS; 2341 ConsumeToken(); // The C++ scope. 2342 assert(Tok.is(tok::annot_template_id) && 2343 "ParseOptionalCXXScopeSpecifier not working"); 2344 AnnotateTemplateIdTokenAsType(); 2345 continue; 2346 } 2347 2348 if (Next.is(tok::annot_typename)) { 2349 DS.getTypeSpecScope() = SS; 2350 ConsumeToken(); // The C++ scope. 2351 if (Tok.getAnnotationValue()) { 2352 ParsedType T = getTypeAnnotation(Tok); 2353 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, 2354 Tok.getAnnotationEndLoc(), 2355 PrevSpec, DiagID, T); 2356 if (isInvalid) 2357 break; 2358 } 2359 else 2360 DS.SetTypeSpecError(); 2361 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 2362 ConsumeToken(); // The typename 2363 } 2364 2365 if (Next.isNot(tok::identifier)) 2366 goto DoneWithDeclSpec; 2367 2368 // If we're in a context where the identifier could be a class name, 2369 // check whether this is a constructor declaration. 2370 if ((DSContext == DSC_top_level || DSContext == DSC_class) && 2371 Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(), 2372 &SS)) { 2373 if (isConstructorDeclarator()) 2374 goto DoneWithDeclSpec; 2375 2376 // As noted in C++ [class.qual]p2 (cited above), when the name 2377 // of the class is qualified in a context where it could name 2378 // a constructor, its a constructor name. However, we've 2379 // looked at the declarator, and the user probably meant this 2380 // to be a type. Complain that it isn't supposed to be treated 2381 // as a type, then proceed to parse it as a type. 2382 Diag(Next.getLocation(), diag::err_out_of_line_type_names_constructor) 2383 << Next.getIdentifierInfo(); 2384 } 2385 2386 ParsedType TypeRep = Actions.getTypeName(*Next.getIdentifierInfo(), 2387 Next.getLocation(), 2388 getCurScope(), &SS, 2389 false, false, ParsedType(), 2390 /*IsCtorOrDtorName=*/false, 2391 /*NonTrivialSourceInfo=*/true); 2392 2393 // If the referenced identifier is not a type, then this declspec is 2394 // erroneous: We already checked about that it has no type specifier, and 2395 // C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the 2396 // typename. 2397 if (TypeRep == 0) { 2398 ConsumeToken(); // Eat the scope spec so the identifier is current. 2399 ParsedAttributesWithRange Attrs(AttrFactory); 2400 if (ParseImplicitInt(DS, &SS, TemplateInfo, AS, DSContext, Attrs)) { 2401 if (!Attrs.empty()) { 2402 AttrsLastTime = true; 2403 attrs.takeAllFrom(Attrs); 2404 } 2405 continue; 2406 } 2407 goto DoneWithDeclSpec; 2408 } 2409 2410 DS.getTypeSpecScope() = SS; 2411 ConsumeToken(); // The C++ scope. 2412 2413 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 2414 DiagID, TypeRep); 2415 if (isInvalid) 2416 break; 2417 2418 DS.SetRangeEnd(Tok.getLocation()); 2419 ConsumeToken(); // The typename. 2420 2421 continue; 2422 } 2423 2424 case tok::annot_typename: { 2425 if (Tok.getAnnotationValue()) { 2426 ParsedType T = getTypeAnnotation(Tok); 2427 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 2428 DiagID, T); 2429 } else 2430 DS.SetTypeSpecError(); 2431 2432 if (isInvalid) 2433 break; 2434 2435 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 2436 ConsumeToken(); // The typename 2437 2438 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 2439 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 2440 // Objective-C interface. 2441 if (Tok.is(tok::less) && getLangOpts().ObjC1) 2442 ParseObjCProtocolQualifiers(DS); 2443 2444 continue; 2445 } 2446 2447 case tok::kw___is_signed: 2448 // GNU libstdc++ 4.4 uses __is_signed as an identifier, but Clang 2449 // typically treats it as a trait. If we see __is_signed as it appears 2450 // in libstdc++, e.g., 2451 // 2452 // static const bool __is_signed; 2453 // 2454 // then treat __is_signed as an identifier rather than as a keyword. 2455 if (DS.getTypeSpecType() == TST_bool && 2456 DS.getTypeQualifiers() == DeclSpec::TQ_const && 2457 DS.getStorageClassSpec() == DeclSpec::SCS_static) { 2458 Tok.getIdentifierInfo()->RevertTokenIDToIdentifier(); 2459 Tok.setKind(tok::identifier); 2460 } 2461 2462 // We're done with the declaration-specifiers. 2463 goto DoneWithDeclSpec; 2464 2465 // typedef-name 2466 case tok::kw_decltype: 2467 case tok::identifier: { 2468 // In C++, check to see if this is a scope specifier like foo::bar::, if 2469 // so handle it as such. This is important for ctor parsing. 2470 if (getLangOpts().CPlusPlus) { 2471 if (TryAnnotateCXXScopeToken(true)) { 2472 if (!DS.hasTypeSpecifier()) 2473 DS.SetTypeSpecError(); 2474 goto DoneWithDeclSpec; 2475 } 2476 if (!Tok.is(tok::identifier)) 2477 continue; 2478 } 2479 2480 // This identifier can only be a typedef name if we haven't already seen 2481 // a type-specifier. Without this check we misparse: 2482 // typedef int X; struct Y { short X; }; as 'short int'. 2483 if (DS.hasTypeSpecifier()) 2484 goto DoneWithDeclSpec; 2485 2486 // Check for need to substitute AltiVec keyword tokens. 2487 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid)) 2488 break; 2489 2490 // [AltiVec] 2.2: [If the 'vector' specifier is used] The syntax does not 2491 // allow the use of a typedef name as a type specifier. 2492 if (DS.isTypeAltiVecVector()) 2493 goto DoneWithDeclSpec; 2494 2495 ParsedType TypeRep = 2496 Actions.getTypeName(*Tok.getIdentifierInfo(), 2497 Tok.getLocation(), getCurScope()); 2498 2499 // If this is not a typedef name, don't parse it as part of the declspec, 2500 // it must be an implicit int or an error. 2501 if (!TypeRep) { 2502 ParsedAttributesWithRange Attrs(AttrFactory); 2503 if (ParseImplicitInt(DS, 0, TemplateInfo, AS, DSContext, Attrs)) { 2504 if (!Attrs.empty()) { 2505 AttrsLastTime = true; 2506 attrs.takeAllFrom(Attrs); 2507 } 2508 continue; 2509 } 2510 goto DoneWithDeclSpec; 2511 } 2512 2513 // If we're in a context where the identifier could be a class name, 2514 // check whether this is a constructor declaration. 2515 if (getLangOpts().CPlusPlus && DSContext == DSC_class && 2516 Actions.isCurrentClassName(*Tok.getIdentifierInfo(), getCurScope()) && 2517 isConstructorDeclarator()) 2518 goto DoneWithDeclSpec; 2519 2520 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 2521 DiagID, TypeRep); 2522 if (isInvalid) 2523 break; 2524 2525 DS.SetRangeEnd(Tok.getLocation()); 2526 ConsumeToken(); // The identifier 2527 2528 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 2529 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 2530 // Objective-C interface. 2531 if (Tok.is(tok::less) && getLangOpts().ObjC1) 2532 ParseObjCProtocolQualifiers(DS); 2533 2534 // Need to support trailing type qualifiers (e.g. "id<p> const"). 2535 // If a type specifier follows, it will be diagnosed elsewhere. 2536 continue; 2537 } 2538 2539 // type-name 2540 case tok::annot_template_id: { 2541 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); 2542 if (TemplateId->Kind != TNK_Type_template) { 2543 // This template-id does not refer to a type name, so we're 2544 // done with the type-specifiers. 2545 goto DoneWithDeclSpec; 2546 } 2547 2548 // If we're in a context where the template-id could be a 2549 // constructor name or specialization, check whether this is a 2550 // constructor declaration. 2551 if (getLangOpts().CPlusPlus && DSContext == DSC_class && 2552 Actions.isCurrentClassName(*TemplateId->Name, getCurScope()) && 2553 isConstructorDeclarator()) 2554 goto DoneWithDeclSpec; 2555 2556 // Turn the template-id annotation token into a type annotation 2557 // token, then try again to parse it as a type-specifier. 2558 AnnotateTemplateIdTokenAsType(); 2559 continue; 2560 } 2561 2562 // GNU attributes support. 2563 case tok::kw___attribute: 2564 ParseGNUAttributes(DS.getAttributes(), 0, LateAttrs); 2565 continue; 2566 2567 // Microsoft declspec support. 2568 case tok::kw___declspec: 2569 ParseMicrosoftDeclSpec(DS.getAttributes()); 2570 continue; 2571 2572 // Microsoft single token adornments. 2573 case tok::kw___forceinline: { 2574 isInvalid = DS.setFunctionSpecInline(Loc); 2575 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 2576 SourceLocation AttrNameLoc = Tok.getLocation(); 2577 // FIXME: This does not work correctly if it is set to be a declspec 2578 // attribute, and a GNU attribute is simply incorrect. 2579 DS.getAttributes().addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, 2580 SourceLocation(), 0, 0, AttributeList::AS_GNU); 2581 break; 2582 } 2583 2584 case tok::kw___ptr64: 2585 case tok::kw___ptr32: 2586 case tok::kw___w64: 2587 case tok::kw___cdecl: 2588 case tok::kw___stdcall: 2589 case tok::kw___fastcall: 2590 case tok::kw___thiscall: 2591 case tok::kw___unaligned: 2592 ParseMicrosoftTypeAttributes(DS.getAttributes()); 2593 continue; 2594 2595 // Borland single token adornments. 2596 case tok::kw___pascal: 2597 ParseBorlandTypeAttributes(DS.getAttributes()); 2598 continue; 2599 2600 // OpenCL single token adornments. 2601 case tok::kw___kernel: 2602 ParseOpenCLAttributes(DS.getAttributes()); 2603 continue; 2604 2605 // storage-class-specifier 2606 case tok::kw_typedef: 2607 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc, 2608 PrevSpec, DiagID); 2609 break; 2610 case tok::kw_extern: 2611 if (DS.isThreadSpecified()) 2612 Diag(Tok, diag::ext_thread_before) << "extern"; 2613 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_extern, Loc, 2614 PrevSpec, DiagID); 2615 break; 2616 case tok::kw___private_extern__: 2617 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_private_extern, 2618 Loc, PrevSpec, DiagID); 2619 break; 2620 case tok::kw_static: 2621 if (DS.isThreadSpecified()) 2622 Diag(Tok, diag::ext_thread_before) << "static"; 2623 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_static, Loc, 2624 PrevSpec, DiagID); 2625 break; 2626 case tok::kw_auto: 2627 if (getLangOpts().CPlusPlus11) { 2628 if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) { 2629 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc, 2630 PrevSpec, DiagID); 2631 if (!isInvalid) 2632 Diag(Tok, diag::ext_auto_storage_class) 2633 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 2634 } else 2635 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec, 2636 DiagID); 2637 } else 2638 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc, 2639 PrevSpec, DiagID); 2640 break; 2641 case tok::kw_register: 2642 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_register, Loc, 2643 PrevSpec, DiagID); 2644 break; 2645 case tok::kw_mutable: 2646 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_mutable, Loc, 2647 PrevSpec, DiagID); 2648 break; 2649 case tok::kw___thread: 2650 isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec, DiagID); 2651 break; 2652 2653 // function-specifier 2654 case tok::kw_inline: 2655 isInvalid = DS.setFunctionSpecInline(Loc); 2656 break; 2657 case tok::kw_virtual: 2658 isInvalid = DS.setFunctionSpecVirtual(Loc); 2659 break; 2660 case tok::kw_explicit: 2661 isInvalid = DS.setFunctionSpecExplicit(Loc); 2662 break; 2663 case tok::kw__Noreturn: 2664 if (!getLangOpts().C11) 2665 Diag(Loc, diag::ext_c11_noreturn); 2666 isInvalid = DS.setFunctionSpecNoreturn(Loc); 2667 break; 2668 2669 // alignment-specifier 2670 case tok::kw__Alignas: 2671 if (!getLangOpts().C11) 2672 Diag(Tok, diag::ext_c11_alignment) << Tok.getName(); 2673 ParseAlignmentSpecifier(DS.getAttributes()); 2674 continue; 2675 2676 // friend 2677 case tok::kw_friend: 2678 if (DSContext == DSC_class) 2679 isInvalid = DS.SetFriendSpec(Loc, PrevSpec, DiagID); 2680 else { 2681 PrevSpec = ""; // not actually used by the diagnostic 2682 DiagID = diag::err_friend_invalid_in_context; 2683 isInvalid = true; 2684 } 2685 break; 2686 2687 // Modules 2688 case tok::kw___module_private__: 2689 isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID); 2690 break; 2691 2692 // constexpr 2693 case tok::kw_constexpr: 2694 isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID); 2695 break; 2696 2697 // type-specifier 2698 case tok::kw_short: 2699 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, 2700 DiagID); 2701 break; 2702 case tok::kw_long: 2703 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long) 2704 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, 2705 DiagID); 2706 else 2707 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, 2708 DiagID); 2709 break; 2710 case tok::kw___int64: 2711 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, 2712 DiagID); 2713 break; 2714 case tok::kw_signed: 2715 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, 2716 DiagID); 2717 break; 2718 case tok::kw_unsigned: 2719 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, 2720 DiagID); 2721 break; 2722 case tok::kw__Complex: 2723 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec, 2724 DiagID); 2725 break; 2726 case tok::kw__Imaginary: 2727 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec, 2728 DiagID); 2729 break; 2730 case tok::kw_void: 2731 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, 2732 DiagID); 2733 break; 2734 case tok::kw_char: 2735 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, 2736 DiagID); 2737 break; 2738 case tok::kw_int: 2739 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, 2740 DiagID); 2741 break; 2742 case tok::kw___int128: 2743 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, 2744 DiagID); 2745 break; 2746 case tok::kw_half: 2747 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, 2748 DiagID); 2749 break; 2750 case tok::kw_float: 2751 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, 2752 DiagID); 2753 break; 2754 case tok::kw_double: 2755 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, 2756 DiagID); 2757 break; 2758 case tok::kw_wchar_t: 2759 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, 2760 DiagID); 2761 break; 2762 case tok::kw_char16_t: 2763 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, 2764 DiagID); 2765 break; 2766 case tok::kw_char32_t: 2767 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, 2768 DiagID); 2769 break; 2770 case tok::kw_bool: 2771 case tok::kw__Bool: 2772 if (Tok.is(tok::kw_bool) && 2773 DS.getTypeSpecType() != DeclSpec::TST_unspecified && 2774 DS.getStorageClassSpec() == DeclSpec::SCS_typedef) { 2775 PrevSpec = ""; // Not used by the diagnostic. 2776 DiagID = diag::err_bool_redeclaration; 2777 // For better error recovery. 2778 Tok.setKind(tok::identifier); 2779 isInvalid = true; 2780 } else { 2781 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, 2782 DiagID); 2783 } 2784 break; 2785 case tok::kw__Decimal32: 2786 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec, 2787 DiagID); 2788 break; 2789 case tok::kw__Decimal64: 2790 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec, 2791 DiagID); 2792 break; 2793 case tok::kw__Decimal128: 2794 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec, 2795 DiagID); 2796 break; 2797 case tok::kw___vector: 2798 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); 2799 break; 2800 case tok::kw___pixel: 2801 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID); 2802 break; 2803 case tok::kw_image1d_t: 2804 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_image1d_t, Loc, 2805 PrevSpec, DiagID); 2806 break; 2807 case tok::kw_image1d_array_t: 2808 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_image1d_array_t, Loc, 2809 PrevSpec, DiagID); 2810 break; 2811 case tok::kw_image1d_buffer_t: 2812 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_image1d_buffer_t, Loc, 2813 PrevSpec, DiagID); 2814 break; 2815 case tok::kw_image2d_t: 2816 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_image2d_t, Loc, 2817 PrevSpec, DiagID); 2818 break; 2819 case tok::kw_image2d_array_t: 2820 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_image2d_array_t, Loc, 2821 PrevSpec, DiagID); 2822 break; 2823 case tok::kw_image3d_t: 2824 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_image3d_t, Loc, 2825 PrevSpec, DiagID); 2826 break; 2827 case tok::kw_sampler_t: 2828 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_sampler_t, Loc, 2829 PrevSpec, DiagID); 2830 break; 2831 case tok::kw_event_t: 2832 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_event_t, Loc, 2833 PrevSpec, DiagID); 2834 break; 2835 case tok::kw___unknown_anytype: 2836 isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc, 2837 PrevSpec, DiagID); 2838 break; 2839 2840 // class-specifier: 2841 case tok::kw_class: 2842 case tok::kw_struct: 2843 case tok::kw___interface: 2844 case tok::kw_union: { 2845 tok::TokenKind Kind = Tok.getKind(); 2846 ConsumeToken(); 2847 2848 // These are attributes following class specifiers. 2849 // To produce better diagnostic, we parse them when 2850 // parsing class specifier. 2851 ParsedAttributesWithRange Attributes(AttrFactory); 2852 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS, 2853 EnteringContext, DSContext, Attributes); 2854 2855 // If there are attributes following class specifier, 2856 // take them over and handle them here. 2857 if (!Attributes.empty()) { 2858 AttrsLastTime = true; 2859 attrs.takeAllFrom(Attributes); 2860 } 2861 continue; 2862 } 2863 2864 // enum-specifier: 2865 case tok::kw_enum: 2866 ConsumeToken(); 2867 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS, DSContext); 2868 continue; 2869 2870 // cv-qualifier: 2871 case tok::kw_const: 2872 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID, 2873 getLangOpts()); 2874 break; 2875 case tok::kw_volatile: 2876 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID, 2877 getLangOpts()); 2878 break; 2879 case tok::kw_restrict: 2880 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID, 2881 getLangOpts()); 2882 break; 2883 2884 // C++ typename-specifier: 2885 case tok::kw_typename: 2886 if (TryAnnotateTypeOrScopeToken()) { 2887 DS.SetTypeSpecError(); 2888 goto DoneWithDeclSpec; 2889 } 2890 if (!Tok.is(tok::kw_typename)) 2891 continue; 2892 break; 2893 2894 // GNU typeof support. 2895 case tok::kw_typeof: 2896 ParseTypeofSpecifier(DS); 2897 continue; 2898 2899 case tok::annot_decltype: 2900 ParseDecltypeSpecifier(DS); 2901 continue; 2902 2903 case tok::kw___underlying_type: 2904 ParseUnderlyingTypeSpecifier(DS); 2905 continue; 2906 2907 case tok::kw__Atomic: 2908 ParseAtomicSpecifier(DS); 2909 continue; 2910 2911 // OpenCL qualifiers: 2912 case tok::kw_private: 2913 if (!getLangOpts().OpenCL) 2914 goto DoneWithDeclSpec; 2915 case tok::kw___private: 2916 case tok::kw___global: 2917 case tok::kw___local: 2918 case tok::kw___constant: 2919 case tok::kw___read_only: 2920 case tok::kw___write_only: 2921 case tok::kw___read_write: 2922 ParseOpenCLQualifiers(DS); 2923 break; 2924 2925 case tok::less: 2926 // GCC ObjC supports types like "<SomeProtocol>" as a synonym for 2927 // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous, 2928 // but we support it. 2929 if (DS.hasTypeSpecifier() || !getLangOpts().ObjC1) 2930 goto DoneWithDeclSpec; 2931 2932 if (!ParseObjCProtocolQualifiers(DS)) 2933 Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id) 2934 << FixItHint::CreateInsertion(Loc, "id") 2935 << SourceRange(Loc, DS.getSourceRange().getEnd()); 2936 2937 // Need to support trailing type qualifiers (e.g. "id<p> const"). 2938 // If a type specifier follows, it will be diagnosed elsewhere. 2939 continue; 2940 } 2941 // If the specifier wasn't legal, issue a diagnostic. 2942 if (isInvalid) { 2943 assert(PrevSpec && "Method did not return previous specifier!"); 2944 assert(DiagID); 2945 2946 if (DiagID == diag::ext_duplicate_declspec) 2947 Diag(Tok, DiagID) 2948 << PrevSpec << FixItHint::CreateRemoval(Tok.getLocation()); 2949 else 2950 Diag(Tok, DiagID) << PrevSpec; 2951 } 2952 2953 DS.SetRangeEnd(Tok.getLocation()); 2954 if (DiagID != diag::err_bool_redeclaration) 2955 ConsumeToken(); 2956 2957 AttrsLastTime = false; 2958 } 2959 } 2960 2961 /// ParseStructDeclaration - Parse a struct declaration without the terminating 2962 /// semicolon. 2963 /// 2964 /// struct-declaration: 2965 /// specifier-qualifier-list struct-declarator-list 2966 /// [GNU] __extension__ struct-declaration 2967 /// [GNU] specifier-qualifier-list 2968 /// struct-declarator-list: 2969 /// struct-declarator 2970 /// struct-declarator-list ',' struct-declarator 2971 /// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator 2972 /// struct-declarator: 2973 /// declarator 2974 /// [GNU] declarator attributes[opt] 2975 /// declarator[opt] ':' constant-expression 2976 /// [GNU] declarator[opt] ':' constant-expression attributes[opt] 2977 /// 2978 void Parser:: 2979 ParseStructDeclaration(ParsingDeclSpec &DS, FieldCallback &Fields) { 2980 2981 if (Tok.is(tok::kw___extension__)) { 2982 // __extension__ silences extension warnings in the subexpression. 2983 ExtensionRAIIObject O(Diags); // Use RAII to do this. 2984 ConsumeToken(); 2985 return ParseStructDeclaration(DS, Fields); 2986 } 2987 2988 // Parse the common specifier-qualifiers-list piece. 2989 ParseSpecifierQualifierList(DS); 2990 2991 // If there are no declarators, this is a free-standing declaration 2992 // specifier. Let the actions module cope with it. 2993 if (Tok.is(tok::semi)) { 2994 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, 2995 DS); 2996 DS.complete(TheDecl); 2997 return; 2998 } 2999 3000 // Read struct-declarators until we find the semicolon. 3001 bool FirstDeclarator = true; 3002 SourceLocation CommaLoc; 3003 while (1) { 3004 ParsingFieldDeclarator DeclaratorInfo(*this, DS); 3005 DeclaratorInfo.D.setCommaLoc(CommaLoc); 3006 3007 // Attributes are only allowed here on successive declarators. 3008 if (!FirstDeclarator) 3009 MaybeParseGNUAttributes(DeclaratorInfo.D); 3010 3011 /// struct-declarator: declarator 3012 /// struct-declarator: declarator[opt] ':' constant-expression 3013 if (Tok.isNot(tok::colon)) { 3014 // Don't parse FOO:BAR as if it were a typo for FOO::BAR. 3015 ColonProtectionRAIIObject X(*this); 3016 ParseDeclarator(DeclaratorInfo.D); 3017 } 3018 3019 if (Tok.is(tok::colon)) { 3020 ConsumeToken(); 3021 ExprResult Res(ParseConstantExpression()); 3022 if (Res.isInvalid()) 3023 SkipUntil(tok::semi, true, true); 3024 else 3025 DeclaratorInfo.BitfieldSize = Res.release(); 3026 } 3027 3028 // If attributes exist after the declarator, parse them. 3029 MaybeParseGNUAttributes(DeclaratorInfo.D); 3030 3031 // We're done with this declarator; invoke the callback. 3032 Fields.invoke(DeclaratorInfo); 3033 3034 // If we don't have a comma, it is either the end of the list (a ';') 3035 // or an error, bail out. 3036 if (Tok.isNot(tok::comma)) 3037 return; 3038 3039 // Consume the comma. 3040 CommaLoc = ConsumeToken(); 3041 3042 FirstDeclarator = false; 3043 } 3044 } 3045 3046 /// ParseStructUnionBody 3047 /// struct-contents: 3048 /// struct-declaration-list 3049 /// [EXT] empty 3050 /// [GNU] "struct-declaration-list" without terminatoring ';' 3051 /// struct-declaration-list: 3052 /// struct-declaration 3053 /// struct-declaration-list struct-declaration 3054 /// [OBC] '@' 'defs' '(' class-name ')' 3055 /// 3056 void Parser::ParseStructUnionBody(SourceLocation RecordLoc, 3057 unsigned TagType, Decl *TagDecl) { 3058 PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc, 3059 "parsing struct/union body"); 3060 3061 BalancedDelimiterTracker T(*this, tok::l_brace); 3062 if (T.consumeOpen()) 3063 return; 3064 3065 ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope); 3066 Actions.ActOnTagStartDefinition(getCurScope(), TagDecl); 3067 3068 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in 3069 // C++. 3070 if (Tok.is(tok::r_brace) && !getLangOpts().CPlusPlus) { 3071 Diag(Tok, diag::ext_empty_struct_union) << (TagType == TST_union); 3072 Diag(Tok, diag::warn_empty_struct_union_compat) << (TagType == TST_union); 3073 } 3074 3075 SmallVector<Decl *, 32> FieldDecls; 3076 3077 // While we still have something to read, read the declarations in the struct. 3078 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 3079 // Each iteration of this loop reads one struct-declaration. 3080 3081 // Check for extraneous top-level semicolon. 3082 if (Tok.is(tok::semi)) { 3083 ConsumeExtraSemi(InsideStruct, TagType); 3084 continue; 3085 } 3086 3087 if (!Tok.is(tok::at)) { 3088 struct CFieldCallback : FieldCallback { 3089 Parser &P; 3090 Decl *TagDecl; 3091 SmallVectorImpl<Decl *> &FieldDecls; 3092 3093 CFieldCallback(Parser &P, Decl *TagDecl, 3094 SmallVectorImpl<Decl *> &FieldDecls) : 3095 P(P), TagDecl(TagDecl), FieldDecls(FieldDecls) {} 3096 3097 void invoke(ParsingFieldDeclarator &FD) { 3098 // Install the declarator into the current TagDecl. 3099 Decl *Field = P.Actions.ActOnField(P.getCurScope(), TagDecl, 3100 FD.D.getDeclSpec().getSourceRange().getBegin(), 3101 FD.D, FD.BitfieldSize); 3102 FieldDecls.push_back(Field); 3103 FD.complete(Field); 3104 } 3105 } Callback(*this, TagDecl, FieldDecls); 3106 3107 // Parse all the comma separated declarators. 3108 ParsingDeclSpec DS(*this); 3109 ParseStructDeclaration(DS, Callback); 3110 } else { // Handle @defs 3111 ConsumeToken(); 3112 if (!Tok.isObjCAtKeyword(tok::objc_defs)) { 3113 Diag(Tok, diag::err_unexpected_at); 3114 SkipUntil(tok::semi, true); 3115 continue; 3116 } 3117 ConsumeToken(); 3118 ExpectAndConsume(tok::l_paren, diag::err_expected_lparen); 3119 if (!Tok.is(tok::identifier)) { 3120 Diag(Tok, diag::err_expected_ident); 3121 SkipUntil(tok::semi, true); 3122 continue; 3123 } 3124 SmallVector<Decl *, 16> Fields; 3125 Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(), 3126 Tok.getIdentifierInfo(), Fields); 3127 FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end()); 3128 ConsumeToken(); 3129 ExpectAndConsume(tok::r_paren, diag::err_expected_rparen); 3130 } 3131 3132 if (Tok.is(tok::semi)) { 3133 ConsumeToken(); 3134 } else if (Tok.is(tok::r_brace)) { 3135 ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list); 3136 break; 3137 } else { 3138 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list); 3139 // Skip to end of block or statement to avoid ext-warning on extra ';'. 3140 SkipUntil(tok::r_brace, true, true); 3141 // If we stopped at a ';', eat it. 3142 if (Tok.is(tok::semi)) ConsumeToken(); 3143 } 3144 } 3145 3146 T.consumeClose(); 3147 3148 ParsedAttributes attrs(AttrFactory); 3149 // If attributes exist after struct contents, parse them. 3150 MaybeParseGNUAttributes(attrs); 3151 3152 Actions.ActOnFields(getCurScope(), 3153 RecordLoc, TagDecl, FieldDecls, 3154 T.getOpenLocation(), T.getCloseLocation(), 3155 attrs.getList()); 3156 StructScope.Exit(); 3157 Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl, 3158 T.getCloseLocation()); 3159 } 3160 3161 /// ParseEnumSpecifier 3162 /// enum-specifier: [C99 6.7.2.2] 3163 /// 'enum' identifier[opt] '{' enumerator-list '}' 3164 ///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}' 3165 /// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt] 3166 /// '}' attributes[opt] 3167 /// [MS] 'enum' __declspec[opt] identifier[opt] '{' enumerator-list ',' [opt] 3168 /// '}' 3169 /// 'enum' identifier 3170 /// [GNU] 'enum' attributes[opt] identifier 3171 /// 3172 /// [C++11] enum-head '{' enumerator-list[opt] '}' 3173 /// [C++11] enum-head '{' enumerator-list ',' '}' 3174 /// 3175 /// enum-head: [C++11] 3176 /// enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt] 3177 /// enum-key attribute-specifier-seq[opt] nested-name-specifier 3178 /// identifier enum-base[opt] 3179 /// 3180 /// enum-key: [C++11] 3181 /// 'enum' 3182 /// 'enum' 'class' 3183 /// 'enum' 'struct' 3184 /// 3185 /// enum-base: [C++11] 3186 /// ':' type-specifier-seq 3187 /// 3188 /// [C++] elaborated-type-specifier: 3189 /// [C++] 'enum' '::'[opt] nested-name-specifier[opt] identifier 3190 /// 3191 void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS, 3192 const ParsedTemplateInfo &TemplateInfo, 3193 AccessSpecifier AS, DeclSpecContext DSC) { 3194 // Parse the tag portion of this. 3195 if (Tok.is(tok::code_completion)) { 3196 // Code completion for an enum name. 3197 Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum); 3198 return cutOffParsing(); 3199 } 3200 3201 // If attributes exist after tag, parse them. 3202 ParsedAttributesWithRange attrs(AttrFactory); 3203 MaybeParseGNUAttributes(attrs); 3204 MaybeParseCXX11Attributes(attrs); 3205 3206 // If declspecs exist after tag, parse them. 3207 while (Tok.is(tok::kw___declspec)) 3208 ParseMicrosoftDeclSpec(attrs); 3209 3210 SourceLocation ScopedEnumKWLoc; 3211 bool IsScopedUsingClassTag = false; 3212 3213 // In C++11, recognize 'enum class' and 'enum struct'. 3214 if (getLangOpts().CPlusPlus11 && 3215 (Tok.is(tok::kw_class) || Tok.is(tok::kw_struct))) { 3216 Diag(Tok, diag::warn_cxx98_compat_scoped_enum); 3217 IsScopedUsingClassTag = Tok.is(tok::kw_class); 3218 ScopedEnumKWLoc = ConsumeToken(); 3219 3220 // Attributes are not allowed between these keywords. Diagnose, 3221 // but then just treat them like they appeared in the right place. 3222 ProhibitAttributes(attrs); 3223 3224 // They are allowed afterwards, though. 3225 MaybeParseGNUAttributes(attrs); 3226 MaybeParseCXX11Attributes(attrs); 3227 while (Tok.is(tok::kw___declspec)) 3228 ParseMicrosoftDeclSpec(attrs); 3229 } 3230 3231 // C++11 [temp.explicit]p12: 3232 // The usual access controls do not apply to names used to specify 3233 // explicit instantiations. 3234 // We extend this to also cover explicit specializations. Note that 3235 // we don't suppress if this turns out to be an elaborated type 3236 // specifier. 3237 bool shouldDelayDiagsInTag = 3238 (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation || 3239 TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization); 3240 SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag); 3241 3242 // Enum definitions should not be parsed in a trailing-return-type. 3243 bool AllowDeclaration = DSC != DSC_trailing; 3244 3245 bool AllowFixedUnderlyingType = AllowDeclaration && 3246 (getLangOpts().CPlusPlus11 || getLangOpts().MicrosoftExt || 3247 getLangOpts().ObjC2); 3248 3249 CXXScopeSpec &SS = DS.getTypeSpecScope(); 3250 if (getLangOpts().CPlusPlus) { 3251 // "enum foo : bar;" is not a potential typo for "enum foo::bar;" 3252 // if a fixed underlying type is allowed. 3253 ColonProtectionRAIIObject X(*this, AllowFixedUnderlyingType); 3254 3255 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), 3256 /*EnteringContext=*/false)) 3257 return; 3258 3259 if (SS.isSet() && Tok.isNot(tok::identifier)) { 3260 Diag(Tok, diag::err_expected_ident); 3261 if (Tok.isNot(tok::l_brace)) { 3262 // Has no name and is not a definition. 3263 // Skip the rest of this declarator, up until the comma or semicolon. 3264 SkipUntil(tok::comma, true); 3265 return; 3266 } 3267 } 3268 } 3269 3270 // Must have either 'enum name' or 'enum {...}'. 3271 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) && 3272 !(AllowFixedUnderlyingType && Tok.is(tok::colon))) { 3273 Diag(Tok, diag::err_expected_ident_lbrace); 3274 3275 // Skip the rest of this declarator, up until the comma or semicolon. 3276 SkipUntil(tok::comma, true); 3277 return; 3278 } 3279 3280 // If an identifier is present, consume and remember it. 3281 IdentifierInfo *Name = 0; 3282 SourceLocation NameLoc; 3283 if (Tok.is(tok::identifier)) { 3284 Name = Tok.getIdentifierInfo(); 3285 NameLoc = ConsumeToken(); 3286 } 3287 3288 if (!Name && ScopedEnumKWLoc.isValid()) { 3289 // C++0x 7.2p2: The optional identifier shall not be omitted in the 3290 // declaration of a scoped enumeration. 3291 Diag(Tok, diag::err_scoped_enum_missing_identifier); 3292 ScopedEnumKWLoc = SourceLocation(); 3293 IsScopedUsingClassTag = false; 3294 } 3295 3296 // Okay, end the suppression area. We'll decide whether to emit the 3297 // diagnostics in a second. 3298 if (shouldDelayDiagsInTag) 3299 diagsFromTag.done(); 3300 3301 TypeResult BaseType; 3302 3303 // Parse the fixed underlying type. 3304 bool CanBeBitfield = getCurScope()->getFlags() & Scope::ClassScope; 3305 if (AllowFixedUnderlyingType && Tok.is(tok::colon)) { 3306 bool PossibleBitfield = false; 3307 if (CanBeBitfield) { 3308 // If we're in class scope, this can either be an enum declaration with 3309 // an underlying type, or a declaration of a bitfield member. We try to 3310 // use a simple disambiguation scheme first to catch the common cases 3311 // (integer literal, sizeof); if it's still ambiguous, we then consider 3312 // anything that's a simple-type-specifier followed by '(' as an 3313 // expression. This suffices because function types are not valid 3314 // underlying types anyway. 3315 EnterExpressionEvaluationContext Unevaluated(Actions, 3316 Sema::ConstantEvaluated); 3317 TPResult TPR = isExpressionOrTypeSpecifierSimple(NextToken().getKind()); 3318 // If the next token starts an expression, we know we're parsing a 3319 // bit-field. This is the common case. 3320 if (TPR == TPResult::True()) 3321 PossibleBitfield = true; 3322 // If the next token starts a type-specifier-seq, it may be either a 3323 // a fixed underlying type or the start of a function-style cast in C++; 3324 // lookahead one more token to see if it's obvious that we have a 3325 // fixed underlying type. 3326 else if (TPR == TPResult::False() && 3327 GetLookAheadToken(2).getKind() == tok::semi) { 3328 // Consume the ':'. 3329 ConsumeToken(); 3330 } else { 3331 // We have the start of a type-specifier-seq, so we have to perform 3332 // tentative parsing to determine whether we have an expression or a 3333 // type. 3334 TentativeParsingAction TPA(*this); 3335 3336 // Consume the ':'. 3337 ConsumeToken(); 3338 3339 // If we see a type specifier followed by an open-brace, we have an 3340 // ambiguity between an underlying type and a C++11 braced 3341 // function-style cast. Resolve this by always treating it as an 3342 // underlying type. 3343 // FIXME: The standard is not entirely clear on how to disambiguate in 3344 // this case. 3345 if ((getLangOpts().CPlusPlus && 3346 isCXXDeclarationSpecifier(TPResult::True()) != TPResult::True()) || 3347 (!getLangOpts().CPlusPlus && !isDeclarationSpecifier(true))) { 3348 // We'll parse this as a bitfield later. 3349 PossibleBitfield = true; 3350 TPA.Revert(); 3351 } else { 3352 // We have a type-specifier-seq. 3353 TPA.Commit(); 3354 } 3355 } 3356 } else { 3357 // Consume the ':'. 3358 ConsumeToken(); 3359 } 3360 3361 if (!PossibleBitfield) { 3362 SourceRange Range; 3363 BaseType = ParseTypeName(&Range); 3364 3365 if (getLangOpts().CPlusPlus11) { 3366 Diag(StartLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type); 3367 } else if (!getLangOpts().ObjC2) { 3368 if (getLangOpts().CPlusPlus) 3369 Diag(StartLoc, diag::ext_cxx11_enum_fixed_underlying_type) << Range; 3370 else 3371 Diag(StartLoc, diag::ext_c_enum_fixed_underlying_type) << Range; 3372 } 3373 } 3374 } 3375 3376 // There are four options here. If we have 'friend enum foo;' then this is a 3377 // friend declaration, and cannot have an accompanying definition. If we have 3378 // 'enum foo;', then this is a forward declaration. If we have 3379 // 'enum foo {...' then this is a definition. Otherwise we have something 3380 // like 'enum foo xyz', a reference. 3381 // 3382 // This is needed to handle stuff like this right (C99 6.7.2.3p11): 3383 // enum foo {..}; void bar() { enum foo; } <- new foo in bar. 3384 // enum foo {..}; void bar() { enum foo x; } <- use of old foo. 3385 // 3386 Sema::TagUseKind TUK; 3387 if (!AllowDeclaration) { 3388 TUK = Sema::TUK_Reference; 3389 } else if (Tok.is(tok::l_brace)) { 3390 if (DS.isFriendSpecified()) { 3391 Diag(Tok.getLocation(), diag::err_friend_decl_defines_type) 3392 << SourceRange(DS.getFriendSpecLoc()); 3393 ConsumeBrace(); 3394 SkipUntil(tok::r_brace); 3395 TUK = Sema::TUK_Friend; 3396 } else { 3397 TUK = Sema::TUK_Definition; 3398 } 3399 } else if (DSC != DSC_type_specifier && 3400 (Tok.is(tok::semi) || 3401 (Tok.isAtStartOfLine() && 3402 !isValidAfterTypeSpecifier(CanBeBitfield)))) { 3403 TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration; 3404 if (Tok.isNot(tok::semi)) { 3405 // A semicolon was missing after this declaration. Diagnose and recover. 3406 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_tagdecl, 3407 "enum"); 3408 PP.EnterToken(Tok); 3409 Tok.setKind(tok::semi); 3410 } 3411 } else { 3412 TUK = Sema::TUK_Reference; 3413 } 3414 3415 // If this is an elaborated type specifier, and we delayed 3416 // diagnostics before, just merge them into the current pool. 3417 if (TUK == Sema::TUK_Reference && shouldDelayDiagsInTag) { 3418 diagsFromTag.redelay(); 3419 } 3420 3421 MultiTemplateParamsArg TParams; 3422 if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate && 3423 TUK != Sema::TUK_Reference) { 3424 if (!getLangOpts().CPlusPlus11 || !SS.isSet()) { 3425 // Skip the rest of this declarator, up until the comma or semicolon. 3426 Diag(Tok, diag::err_enum_template); 3427 SkipUntil(tok::comma, true); 3428 return; 3429 } 3430 3431 if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation) { 3432 // Enumerations can't be explicitly instantiated. 3433 DS.SetTypeSpecError(); 3434 Diag(StartLoc, diag::err_explicit_instantiation_enum); 3435 return; 3436 } 3437 3438 assert(TemplateInfo.TemplateParams && "no template parameters"); 3439 TParams = MultiTemplateParamsArg(TemplateInfo.TemplateParams->data(), 3440 TemplateInfo.TemplateParams->size()); 3441 } 3442 3443 if (TUK == Sema::TUK_Reference) 3444 ProhibitAttributes(attrs); 3445 3446 if (!Name && TUK != Sema::TUK_Definition) { 3447 Diag(Tok, diag::err_enumerator_unnamed_no_def); 3448 3449 // Skip the rest of this declarator, up until the comma or semicolon. 3450 SkipUntil(tok::comma, true); 3451 return; 3452 } 3453 3454 bool Owned = false; 3455 bool IsDependent = false; 3456 const char *PrevSpec = 0; 3457 unsigned DiagID; 3458 Decl *TagDecl = Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK, 3459 StartLoc, SS, Name, NameLoc, attrs.getList(), 3460 AS, DS.getModulePrivateSpecLoc(), TParams, 3461 Owned, IsDependent, ScopedEnumKWLoc, 3462 IsScopedUsingClassTag, BaseType); 3463 3464 if (IsDependent) { 3465 // This enum has a dependent nested-name-specifier. Handle it as a 3466 // dependent tag. 3467 if (!Name) { 3468 DS.SetTypeSpecError(); 3469 Diag(Tok, diag::err_expected_type_name_after_typename); 3470 return; 3471 } 3472 3473 TypeResult Type = Actions.ActOnDependentTag(getCurScope(), DeclSpec::TST_enum, 3474 TUK, SS, Name, StartLoc, 3475 NameLoc); 3476 if (Type.isInvalid()) { 3477 DS.SetTypeSpecError(); 3478 return; 3479 } 3480 3481 if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc, 3482 NameLoc.isValid() ? NameLoc : StartLoc, 3483 PrevSpec, DiagID, Type.get())) 3484 Diag(StartLoc, DiagID) << PrevSpec; 3485 3486 return; 3487 } 3488 3489 if (!TagDecl) { 3490 // The action failed to produce an enumeration tag. If this is a 3491 // definition, consume the entire definition. 3492 if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference) { 3493 ConsumeBrace(); 3494 SkipUntil(tok::r_brace); 3495 } 3496 3497 DS.SetTypeSpecError(); 3498 return; 3499 } 3500 3501 if (Tok.is(tok::l_brace) && TUK != Sema::TUK_Reference) 3502