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