1 //===--- SemaDeclSpec.cpp - Declaration Specifier Semantic Analysis -------===// 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 semantic analysis for declaration specifiers. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Sema/DeclSpec.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/DeclCXX.h" 17 #include "clang/AST/Expr.h" 18 #include "clang/AST/NestedNameSpecifier.h" 19 #include "clang/AST/TypeLoc.h" 20 #include "clang/Basic/LangOptions.h" 21 #include "clang/Basic/TargetInfo.h" 22 #include "clang/Lex/Preprocessor.h" 23 #include "clang/Parse/ParseDiagnostic.h" // FIXME: remove this back-dependency! 24 #include "clang/Sema/LocInfoType.h" 25 #include "clang/Sema/ParsedTemplate.h" 26 #include "clang/Sema/Sema.h" 27 #include "clang/Sema/SemaDiagnostic.h" 28 #include "llvm/ADT/STLExtras.h" 29 #include "llvm/ADT/SmallString.h" 30 #include "llvm/Support/ErrorHandling.h" 31 #include <cstring> 32 using namespace clang; 33 34 35 static DiagnosticBuilder Diag(DiagnosticsEngine &D, SourceLocation Loc, 36 unsigned DiagID) { 37 return D.Report(Loc, DiagID); 38 } 39 40 41 void UnqualifiedId::setTemplateId(TemplateIdAnnotation *TemplateId) { 42 assert(TemplateId && "NULL template-id annotation?"); 43 Kind = IK_TemplateId; 44 this->TemplateId = TemplateId; 45 StartLocation = TemplateId->TemplateNameLoc; 46 EndLocation = TemplateId->RAngleLoc; 47 } 48 49 void UnqualifiedId::setConstructorTemplateId(TemplateIdAnnotation *TemplateId) { 50 assert(TemplateId && "NULL template-id annotation?"); 51 Kind = IK_ConstructorTemplateId; 52 this->TemplateId = TemplateId; 53 StartLocation = TemplateId->TemplateNameLoc; 54 EndLocation = TemplateId->RAngleLoc; 55 } 56 57 void CXXScopeSpec::Extend(ASTContext &Context, SourceLocation TemplateKWLoc, 58 TypeLoc TL, SourceLocation ColonColonLoc) { 59 Builder.Extend(Context, TemplateKWLoc, TL, ColonColonLoc); 60 if (Range.getBegin().isInvalid()) 61 Range.setBegin(TL.getBeginLoc()); 62 Range.setEnd(ColonColonLoc); 63 64 assert(Range == Builder.getSourceRange() && 65 "NestedNameSpecifierLoc range computation incorrect"); 66 } 67 68 void CXXScopeSpec::Extend(ASTContext &Context, IdentifierInfo *Identifier, 69 SourceLocation IdentifierLoc, 70 SourceLocation ColonColonLoc) { 71 Builder.Extend(Context, Identifier, IdentifierLoc, ColonColonLoc); 72 73 if (Range.getBegin().isInvalid()) 74 Range.setBegin(IdentifierLoc); 75 Range.setEnd(ColonColonLoc); 76 77 assert(Range == Builder.getSourceRange() && 78 "NestedNameSpecifierLoc range computation incorrect"); 79 } 80 81 void CXXScopeSpec::Extend(ASTContext &Context, NamespaceDecl *Namespace, 82 SourceLocation NamespaceLoc, 83 SourceLocation ColonColonLoc) { 84 Builder.Extend(Context, Namespace, NamespaceLoc, ColonColonLoc); 85 86 if (Range.getBegin().isInvalid()) 87 Range.setBegin(NamespaceLoc); 88 Range.setEnd(ColonColonLoc); 89 90 assert(Range == Builder.getSourceRange() && 91 "NestedNameSpecifierLoc range computation incorrect"); 92 } 93 94 void CXXScopeSpec::Extend(ASTContext &Context, NamespaceAliasDecl *Alias, 95 SourceLocation AliasLoc, 96 SourceLocation ColonColonLoc) { 97 Builder.Extend(Context, Alias, AliasLoc, ColonColonLoc); 98 99 if (Range.getBegin().isInvalid()) 100 Range.setBegin(AliasLoc); 101 Range.setEnd(ColonColonLoc); 102 103 assert(Range == Builder.getSourceRange() && 104 "NestedNameSpecifierLoc range computation incorrect"); 105 } 106 107 void CXXScopeSpec::MakeGlobal(ASTContext &Context, 108 SourceLocation ColonColonLoc) { 109 Builder.MakeGlobal(Context, ColonColonLoc); 110 111 Range = SourceRange(ColonColonLoc); 112 113 assert(Range == Builder.getSourceRange() && 114 "NestedNameSpecifierLoc range computation incorrect"); 115 } 116 117 void CXXScopeSpec::MakeSuper(ASTContext &Context, CXXRecordDecl *RD, 118 SourceLocation SuperLoc, 119 SourceLocation ColonColonLoc) { 120 Builder.MakeSuper(Context, RD, SuperLoc, ColonColonLoc); 121 122 Range.setBegin(SuperLoc); 123 Range.setEnd(ColonColonLoc); 124 125 assert(Range == Builder.getSourceRange() && 126 "NestedNameSpecifierLoc range computation incorrect"); 127 } 128 129 void CXXScopeSpec::MakeTrivial(ASTContext &Context, 130 NestedNameSpecifier *Qualifier, SourceRange R) { 131 Builder.MakeTrivial(Context, Qualifier, R); 132 Range = R; 133 } 134 135 void CXXScopeSpec::Adopt(NestedNameSpecifierLoc Other) { 136 if (!Other) { 137 Range = SourceRange(); 138 Builder.Clear(); 139 return; 140 } 141 142 Range = Other.getSourceRange(); 143 Builder.Adopt(Other); 144 } 145 146 SourceLocation CXXScopeSpec::getLastQualifierNameLoc() const { 147 if (!Builder.getRepresentation()) 148 return SourceLocation(); 149 return Builder.getTemporary().getLocalBeginLoc(); 150 } 151 152 NestedNameSpecifierLoc 153 CXXScopeSpec::getWithLocInContext(ASTContext &Context) const { 154 if (!Builder.getRepresentation()) 155 return NestedNameSpecifierLoc(); 156 157 return Builder.getWithLocInContext(Context); 158 } 159 160 /// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function. 161 /// "TheDeclarator" is the declarator that this will be added to. 162 DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto, 163 bool isAmbiguous, 164 SourceLocation LParenLoc, 165 ParamInfo *Params, 166 unsigned NumParams, 167 SourceLocation EllipsisLoc, 168 SourceLocation RParenLoc, 169 unsigned TypeQuals, 170 bool RefQualifierIsLvalueRef, 171 SourceLocation RefQualifierLoc, 172 SourceLocation ConstQualifierLoc, 173 SourceLocation 174 VolatileQualifierLoc, 175 SourceLocation 176 RestrictQualifierLoc, 177 SourceLocation MutableLoc, 178 ExceptionSpecificationType 179 ESpecType, 180 SourceLocation ESpecLoc, 181 ParsedType *Exceptions, 182 SourceRange *ExceptionRanges, 183 unsigned NumExceptions, 184 Expr *NoexceptExpr, 185 CachedTokens *ExceptionSpecTokens, 186 SourceLocation LocalRangeBegin, 187 SourceLocation LocalRangeEnd, 188 Declarator &TheDeclarator, 189 TypeResult TrailingReturnType) { 190 assert(!(TypeQuals & DeclSpec::TQ_atomic) && 191 "function cannot have _Atomic qualifier"); 192 193 DeclaratorChunk I; 194 I.Kind = Function; 195 I.Loc = LocalRangeBegin; 196 I.EndLoc = LocalRangeEnd; 197 I.Fun.AttrList = nullptr; 198 I.Fun.hasPrototype = hasProto; 199 I.Fun.isVariadic = EllipsisLoc.isValid(); 200 I.Fun.isAmbiguous = isAmbiguous; 201 I.Fun.LParenLoc = LParenLoc.getRawEncoding(); 202 I.Fun.EllipsisLoc = EllipsisLoc.getRawEncoding(); 203 I.Fun.RParenLoc = RParenLoc.getRawEncoding(); 204 I.Fun.DeleteParams = false; 205 I.Fun.TypeQuals = TypeQuals; 206 I.Fun.NumParams = NumParams; 207 I.Fun.Params = nullptr; 208 I.Fun.RefQualifierIsLValueRef = RefQualifierIsLvalueRef; 209 I.Fun.RefQualifierLoc = RefQualifierLoc.getRawEncoding(); 210 I.Fun.ConstQualifierLoc = ConstQualifierLoc.getRawEncoding(); 211 I.Fun.VolatileQualifierLoc = VolatileQualifierLoc.getRawEncoding(); 212 I.Fun.RestrictQualifierLoc = RestrictQualifierLoc.getRawEncoding(); 213 I.Fun.MutableLoc = MutableLoc.getRawEncoding(); 214 I.Fun.ExceptionSpecType = ESpecType; 215 I.Fun.ExceptionSpecLoc = ESpecLoc.getRawEncoding(); 216 I.Fun.NumExceptions = 0; 217 I.Fun.Exceptions = nullptr; 218 I.Fun.NoexceptExpr = nullptr; 219 I.Fun.HasTrailingReturnType = TrailingReturnType.isUsable() || 220 TrailingReturnType.isInvalid(); 221 I.Fun.TrailingReturnType = TrailingReturnType.get(); 222 223 assert(I.Fun.TypeQuals == TypeQuals && "bitfield overflow"); 224 assert(I.Fun.ExceptionSpecType == ESpecType && "bitfield overflow"); 225 226 // new[] a parameter array if needed. 227 if (NumParams) { 228 // If the 'InlineParams' in Declarator is unused and big enough, put our 229 // parameter list there (in an effort to avoid new/delete traffic). If it 230 // is already used (consider a function returning a function pointer) or too 231 // small (function with too many parameters), go to the heap. 232 if (!TheDeclarator.InlineParamsUsed && 233 NumParams <= llvm::array_lengthof(TheDeclarator.InlineParams)) { 234 I.Fun.Params = TheDeclarator.InlineParams; 235 I.Fun.DeleteParams = false; 236 TheDeclarator.InlineParamsUsed = true; 237 } else { 238 I.Fun.Params = new DeclaratorChunk::ParamInfo[NumParams]; 239 I.Fun.DeleteParams = true; 240 } 241 memcpy(I.Fun.Params, Params, sizeof(Params[0]) * NumParams); 242 } 243 244 // Check what exception specification information we should actually store. 245 switch (ESpecType) { 246 default: break; // By default, save nothing. 247 case EST_Dynamic: 248 // new[] an exception array if needed 249 if (NumExceptions) { 250 I.Fun.NumExceptions = NumExceptions; 251 I.Fun.Exceptions = new DeclaratorChunk::TypeAndRange[NumExceptions]; 252 for (unsigned i = 0; i != NumExceptions; ++i) { 253 I.Fun.Exceptions[i].Ty = Exceptions[i]; 254 I.Fun.Exceptions[i].Range = ExceptionRanges[i]; 255 } 256 } 257 break; 258 259 case EST_ComputedNoexcept: 260 I.Fun.NoexceptExpr = NoexceptExpr; 261 break; 262 263 case EST_Unparsed: 264 I.Fun.ExceptionSpecTokens = ExceptionSpecTokens; 265 break; 266 } 267 return I; 268 } 269 270 bool Declarator::isDeclarationOfFunction() const { 271 for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) { 272 switch (DeclTypeInfo[i].Kind) { 273 case DeclaratorChunk::Function: 274 return true; 275 case DeclaratorChunk::Paren: 276 continue; 277 case DeclaratorChunk::Pointer: 278 case DeclaratorChunk::Reference: 279 case DeclaratorChunk::Array: 280 case DeclaratorChunk::BlockPointer: 281 case DeclaratorChunk::MemberPointer: 282 return false; 283 } 284 llvm_unreachable("Invalid type chunk"); 285 } 286 287 switch (DS.getTypeSpecType()) { 288 case TST_atomic: 289 case TST_auto: 290 case TST_bool: 291 case TST_char: 292 case TST_char16: 293 case TST_char32: 294 case TST_class: 295 case TST_decimal128: 296 case TST_decimal32: 297 case TST_decimal64: 298 case TST_double: 299 case TST_enum: 300 case TST_error: 301 case TST_float: 302 case TST_half: 303 case TST_int: 304 case TST_int128: 305 case TST_struct: 306 case TST_interface: 307 case TST_union: 308 case TST_unknown_anytype: 309 case TST_unspecified: 310 case TST_void: 311 case TST_wchar: 312 return false; 313 314 case TST_decltype_auto: 315 // This must have an initializer, so can't be a function declaration, 316 // even if the initializer has function type. 317 return false; 318 319 case TST_decltype: 320 case TST_typeofExpr: 321 if (Expr *E = DS.getRepAsExpr()) 322 return E->getType()->isFunctionType(); 323 return false; 324 325 case TST_underlyingType: 326 case TST_typename: 327 case TST_typeofType: { 328 QualType QT = DS.getRepAsType().get(); 329 if (QT.isNull()) 330 return false; 331 332 if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) 333 QT = LIT->getType(); 334 335 if (QT.isNull()) 336 return false; 337 338 return QT->isFunctionType(); 339 } 340 } 341 342 llvm_unreachable("Invalid TypeSpecType!"); 343 } 344 345 bool Declarator::isStaticMember() { 346 assert(getContext() == MemberContext); 347 return getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static || 348 (getName().Kind == UnqualifiedId::IK_OperatorFunctionId && 349 CXXMethodDecl::isStaticOverloadedOperator( 350 getName().OperatorFunctionId.Operator)); 351 } 352 353 bool DeclSpec::hasTagDefinition() const { 354 if (!TypeSpecOwned) 355 return false; 356 return cast<TagDecl>(getRepAsDecl())->isCompleteDefinition(); 357 } 358 359 /// getParsedSpecifiers - Return a bitmask of which flavors of specifiers this 360 /// declaration specifier includes. 361 /// 362 unsigned DeclSpec::getParsedSpecifiers() const { 363 unsigned Res = 0; 364 if (StorageClassSpec != SCS_unspecified || 365 ThreadStorageClassSpec != TSCS_unspecified) 366 Res |= PQ_StorageClassSpecifier; 367 368 if (TypeQualifiers != TQ_unspecified) 369 Res |= PQ_TypeQualifier; 370 371 if (hasTypeSpecifier()) 372 Res |= PQ_TypeSpecifier; 373 374 if (FS_inline_specified || FS_virtual_specified || FS_explicit_specified || 375 FS_noreturn_specified || FS_forceinline_specified) 376 Res |= PQ_FunctionSpecifier; 377 return Res; 378 } 379 380 template <class T> static bool BadSpecifier(T TNew, T TPrev, 381 const char *&PrevSpec, 382 unsigned &DiagID, 383 bool IsExtension = true) { 384 PrevSpec = DeclSpec::getSpecifierName(TPrev); 385 if (TNew != TPrev) 386 DiagID = diag::err_invalid_decl_spec_combination; 387 else 388 DiagID = IsExtension ? diag::ext_duplicate_declspec : 389 diag::warn_duplicate_declspec; 390 return true; 391 } 392 393 const char *DeclSpec::getSpecifierName(DeclSpec::SCS S) { 394 switch (S) { 395 case DeclSpec::SCS_unspecified: return "unspecified"; 396 case DeclSpec::SCS_typedef: return "typedef"; 397 case DeclSpec::SCS_extern: return "extern"; 398 case DeclSpec::SCS_static: return "static"; 399 case DeclSpec::SCS_auto: return "auto"; 400 case DeclSpec::SCS_register: return "register"; 401 case DeclSpec::SCS_private_extern: return "__private_extern__"; 402 case DeclSpec::SCS_mutable: return "mutable"; 403 } 404 llvm_unreachable("Unknown typespec!"); 405 } 406 407 const char *DeclSpec::getSpecifierName(DeclSpec::TSCS S) { 408 switch (S) { 409 case DeclSpec::TSCS_unspecified: return "unspecified"; 410 case DeclSpec::TSCS___thread: return "__thread"; 411 case DeclSpec::TSCS_thread_local: return "thread_local"; 412 case DeclSpec::TSCS__Thread_local: return "_Thread_local"; 413 } 414 llvm_unreachable("Unknown typespec!"); 415 } 416 417 const char *DeclSpec::getSpecifierName(TSW W) { 418 switch (W) { 419 case TSW_unspecified: return "unspecified"; 420 case TSW_short: return "short"; 421 case TSW_long: return "long"; 422 case TSW_longlong: return "long long"; 423 } 424 llvm_unreachable("Unknown typespec!"); 425 } 426 427 const char *DeclSpec::getSpecifierName(TSC C) { 428 switch (C) { 429 case TSC_unspecified: return "unspecified"; 430 case TSC_imaginary: return "imaginary"; 431 case TSC_complex: return "complex"; 432 } 433 llvm_unreachable("Unknown typespec!"); 434 } 435 436 437 const char *DeclSpec::getSpecifierName(TSS S) { 438 switch (S) { 439 case TSS_unspecified: return "unspecified"; 440 case TSS_signed: return "signed"; 441 case TSS_unsigned: return "unsigned"; 442 } 443 llvm_unreachable("Unknown typespec!"); 444 } 445 446 const char *DeclSpec::getSpecifierName(DeclSpec::TST T, 447 const PrintingPolicy &Policy) { 448 switch (T) { 449 case DeclSpec::TST_unspecified: return "unspecified"; 450 case DeclSpec::TST_void: return "void"; 451 case DeclSpec::TST_char: return "char"; 452 case DeclSpec::TST_wchar: return Policy.MSWChar ? "__wchar_t" : "wchar_t"; 453 case DeclSpec::TST_char16: return "char16_t"; 454 case DeclSpec::TST_char32: return "char32_t"; 455 case DeclSpec::TST_int: return "int"; 456 case DeclSpec::TST_int128: return "__int128"; 457 case DeclSpec::TST_half: return "half"; 458 case DeclSpec::TST_float: return "float"; 459 case DeclSpec::TST_double: return "double"; 460 case DeclSpec::TST_bool: return Policy.Bool ? "bool" : "_Bool"; 461 case DeclSpec::TST_decimal32: return "_Decimal32"; 462 case DeclSpec::TST_decimal64: return "_Decimal64"; 463 case DeclSpec::TST_decimal128: return "_Decimal128"; 464 case DeclSpec::TST_enum: return "enum"; 465 case DeclSpec::TST_class: return "class"; 466 case DeclSpec::TST_union: return "union"; 467 case DeclSpec::TST_struct: return "struct"; 468 case DeclSpec::TST_interface: return "__interface"; 469 case DeclSpec::TST_typename: return "type-name"; 470 case DeclSpec::TST_typeofType: 471 case DeclSpec::TST_typeofExpr: return "typeof"; 472 case DeclSpec::TST_auto: return "auto"; 473 case DeclSpec::TST_decltype: return "(decltype)"; 474 case DeclSpec::TST_decltype_auto: return "decltype(auto)"; 475 case DeclSpec::TST_underlyingType: return "__underlying_type"; 476 case DeclSpec::TST_unknown_anytype: return "__unknown_anytype"; 477 case DeclSpec::TST_atomic: return "_Atomic"; 478 case DeclSpec::TST_error: return "(error)"; 479 } 480 llvm_unreachable("Unknown typespec!"); 481 } 482 483 const char *DeclSpec::getSpecifierName(TQ T) { 484 switch (T) { 485 case DeclSpec::TQ_unspecified: return "unspecified"; 486 case DeclSpec::TQ_const: return "const"; 487 case DeclSpec::TQ_restrict: return "restrict"; 488 case DeclSpec::TQ_volatile: return "volatile"; 489 case DeclSpec::TQ_atomic: return "_Atomic"; 490 } 491 llvm_unreachable("Unknown typespec!"); 492 } 493 494 bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, 495 const char *&PrevSpec, 496 unsigned &DiagID, 497 const PrintingPolicy &Policy) { 498 // OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class 499 // specifiers are not supported. 500 // It seems sensible to prohibit private_extern too 501 // The cl_clang_storage_class_specifiers extension enables support for 502 // these storage-class specifiers. 503 // OpenCL v1.2 s6.8 changes this to "The auto and register storage-class 504 // specifiers are not supported." 505 if (S.getLangOpts().OpenCL && 506 !S.getOpenCLOptions().cl_clang_storage_class_specifiers) { 507 switch (SC) { 508 case SCS_extern: 509 case SCS_private_extern: 510 case SCS_static: 511 if (S.getLangOpts().OpenCLVersion < 120) { 512 DiagID = diag::err_opencl_unknown_type_specifier; 513 PrevSpec = getSpecifierName(SC); 514 return true; 515 } 516 break; 517 case SCS_auto: 518 case SCS_register: 519 DiagID = diag::err_opencl_unknown_type_specifier; 520 PrevSpec = getSpecifierName(SC); 521 return true; 522 default: 523 break; 524 } 525 } 526 527 if (StorageClassSpec != SCS_unspecified) { 528 // Maybe this is an attempt to use C++11 'auto' outside of C++11 mode. 529 bool isInvalid = true; 530 if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) { 531 if (SC == SCS_auto) 532 return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID, Policy); 533 if (StorageClassSpec == SCS_auto) { 534 isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc, 535 PrevSpec, DiagID, Policy); 536 assert(!isInvalid && "auto SCS -> TST recovery failed"); 537 } 538 } 539 540 // Changing storage class is allowed only if the previous one 541 // was the 'extern' that is part of a linkage specification and 542 // the new storage class is 'typedef'. 543 if (isInvalid && 544 !(SCS_extern_in_linkage_spec && 545 StorageClassSpec == SCS_extern && 546 SC == SCS_typedef)) 547 return BadSpecifier(SC, (SCS)StorageClassSpec, PrevSpec, DiagID); 548 } 549 StorageClassSpec = SC; 550 StorageClassSpecLoc = Loc; 551 assert((unsigned)SC == StorageClassSpec && "SCS constants overflow bitfield"); 552 return false; 553 } 554 555 bool DeclSpec::SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc, 556 const char *&PrevSpec, 557 unsigned &DiagID) { 558 if (ThreadStorageClassSpec != TSCS_unspecified) 559 return BadSpecifier(TSC, (TSCS)ThreadStorageClassSpec, PrevSpec, DiagID); 560 561 ThreadStorageClassSpec = TSC; 562 ThreadStorageClassSpecLoc = Loc; 563 return false; 564 } 565 566 /// These methods set the specified attribute of the DeclSpec, but return true 567 /// and ignore the request if invalid (e.g. "extern" then "auto" is 568 /// specified). 569 bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc, 570 const char *&PrevSpec, 571 unsigned &DiagID, 572 const PrintingPolicy &Policy) { 573 // Overwrite TSWLoc only if TypeSpecWidth was unspecified, so that 574 // for 'long long' we will keep the source location of the first 'long'. 575 if (TypeSpecWidth == TSW_unspecified) 576 TSWLoc = Loc; 577 // Allow turning long -> long long. 578 else if (W != TSW_longlong || TypeSpecWidth != TSW_long) 579 return BadSpecifier(W, (TSW)TypeSpecWidth, PrevSpec, DiagID); 580 TypeSpecWidth = W; 581 return false; 582 } 583 584 bool DeclSpec::SetTypeSpecComplex(TSC C, SourceLocation Loc, 585 const char *&PrevSpec, 586 unsigned &DiagID) { 587 if (TypeSpecComplex != TSC_unspecified) 588 return BadSpecifier(C, (TSC)TypeSpecComplex, PrevSpec, DiagID); 589 TypeSpecComplex = C; 590 TSCLoc = Loc; 591 return false; 592 } 593 594 bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc, 595 const char *&PrevSpec, 596 unsigned &DiagID) { 597 if (TypeSpecSign != TSS_unspecified) 598 return BadSpecifier(S, (TSS)TypeSpecSign, PrevSpec, DiagID); 599 TypeSpecSign = S; 600 TSSLoc = Loc; 601 return false; 602 } 603 604 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, 605 const char *&PrevSpec, 606 unsigned &DiagID, 607 ParsedType Rep, 608 const PrintingPolicy &Policy) { 609 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Policy); 610 } 611 612 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc, 613 SourceLocation TagNameLoc, 614 const char *&PrevSpec, 615 unsigned &DiagID, 616 ParsedType Rep, 617 const PrintingPolicy &Policy) { 618 assert(isTypeRep(T) && "T does not store a type"); 619 assert(Rep && "no type provided!"); 620 if (TypeSpecType != TST_unspecified) { 621 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy); 622 DiagID = diag::err_invalid_decl_spec_combination; 623 return true; 624 } 625 TypeSpecType = T; 626 TypeRep = Rep; 627 TSTLoc = TagKwLoc; 628 TSTNameLoc = TagNameLoc; 629 TypeSpecOwned = false; 630 return false; 631 } 632 633 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, 634 const char *&PrevSpec, 635 unsigned &DiagID, 636 Expr *Rep, 637 const PrintingPolicy &Policy) { 638 assert(isExprRep(T) && "T does not store an expr"); 639 assert(Rep && "no expression provided!"); 640 if (TypeSpecType != TST_unspecified) { 641 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy); 642 DiagID = diag::err_invalid_decl_spec_combination; 643 return true; 644 } 645 TypeSpecType = T; 646 ExprRep = Rep; 647 TSTLoc = Loc; 648 TSTNameLoc = Loc; 649 TypeSpecOwned = false; 650 return false; 651 } 652 653 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, 654 const char *&PrevSpec, 655 unsigned &DiagID, 656 Decl *Rep, bool Owned, 657 const PrintingPolicy &Policy) { 658 return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned, Policy); 659 } 660 661 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc, 662 SourceLocation TagNameLoc, 663 const char *&PrevSpec, 664 unsigned &DiagID, 665 Decl *Rep, bool Owned, 666 const PrintingPolicy &Policy) { 667 assert(isDeclRep(T) && "T does not store a decl"); 668 // Unlike the other cases, we don't assert that we actually get a decl. 669 670 if (TypeSpecType != TST_unspecified) { 671 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy); 672 DiagID = diag::err_invalid_decl_spec_combination; 673 return true; 674 } 675 TypeSpecType = T; 676 DeclRep = Rep; 677 TSTLoc = TagKwLoc; 678 TSTNameLoc = TagNameLoc; 679 TypeSpecOwned = Owned && Rep != nullptr; 680 return false; 681 } 682 683 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, 684 const char *&PrevSpec, 685 unsigned &DiagID, 686 const PrintingPolicy &Policy) { 687 assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) && 688 "rep required for these type-spec kinds!"); 689 if (TypeSpecType != TST_unspecified) { 690 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy); 691 DiagID = diag::err_invalid_decl_spec_combination; 692 return true; 693 } 694 TSTLoc = Loc; 695 TSTNameLoc = Loc; 696 if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) { 697 TypeAltiVecBool = true; 698 return false; 699 } 700 TypeSpecType = T; 701 TypeSpecOwned = false; 702 return false; 703 } 704 705 bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc, 706 const char *&PrevSpec, unsigned &DiagID, 707 const PrintingPolicy &Policy) { 708 if (TypeSpecType != TST_unspecified) { 709 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy); 710 DiagID = diag::err_invalid_vector_decl_spec_combination; 711 return true; 712 } 713 TypeAltiVecVector = isAltiVecVector; 714 AltiVecLoc = Loc; 715 return false; 716 } 717 718 bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc, 719 const char *&PrevSpec, unsigned &DiagID, 720 const PrintingPolicy &Policy) { 721 if (!TypeAltiVecVector || TypeAltiVecPixel || 722 (TypeSpecType != TST_unspecified)) { 723 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy); 724 DiagID = diag::err_invalid_pixel_decl_spec_combination; 725 return true; 726 } 727 TypeAltiVecPixel = isAltiVecPixel; 728 TSTLoc = Loc; 729 TSTNameLoc = Loc; 730 return false; 731 } 732 733 bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc, 734 const char *&PrevSpec, unsigned &DiagID, 735 const PrintingPolicy &Policy) { 736 if (!TypeAltiVecVector || TypeAltiVecBool || 737 (TypeSpecType != TST_unspecified)) { 738 PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy); 739 DiagID = diag::err_invalid_vector_bool_decl_spec; 740 return true; 741 } 742 TypeAltiVecBool = isAltiVecBool; 743 TSTLoc = Loc; 744 TSTNameLoc = Loc; 745 return false; 746 } 747 748 bool DeclSpec::SetTypeSpecError() { 749 TypeSpecType = TST_error; 750 TypeSpecOwned = false; 751 TSTLoc = SourceLocation(); 752 TSTNameLoc = SourceLocation(); 753 return false; 754 } 755 756 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec, 757 unsigned &DiagID, const LangOptions &Lang) { 758 // Duplicates are permitted in C99 onwards, but are not permitted in C89 or 759 // C++. However, since this is likely not what the user intended, we will 760 // always warn. We do not need to set the qualifier's location since we 761 // already have it. 762 if (TypeQualifiers & T) { 763 bool IsExtension = true; 764 if (Lang.C99) 765 IsExtension = false; 766 return BadSpecifier(T, T, PrevSpec, DiagID, IsExtension); 767 } 768 TypeQualifiers |= T; 769 770 switch (T) { 771 case TQ_unspecified: break; 772 case TQ_const: TQ_constLoc = Loc; return false; 773 case TQ_restrict: TQ_restrictLoc = Loc; return false; 774 case TQ_volatile: TQ_volatileLoc = Loc; return false; 775 case TQ_atomic: TQ_atomicLoc = Loc; return false; 776 } 777 778 llvm_unreachable("Unknown type qualifier!"); 779 } 780 781 bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec, 782 unsigned &DiagID) { 783 // 'inline inline' is ok. However, since this is likely not what the user 784 // intended, we will always warn, similar to duplicates of type qualifiers. 785 if (FS_inline_specified) { 786 DiagID = diag::warn_duplicate_declspec; 787 PrevSpec = "inline"; 788 return true; 789 } 790 FS_inline_specified = true; 791 FS_inlineLoc = Loc; 792 return false; 793 } 794 795 bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec, 796 unsigned &DiagID) { 797 if (FS_forceinline_specified) { 798 DiagID = diag::warn_duplicate_declspec; 799 PrevSpec = "__forceinline"; 800 return true; 801 } 802 FS_forceinline_specified = true; 803 FS_forceinlineLoc = Loc; 804 return false; 805 } 806 807 bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc, 808 const char *&PrevSpec, 809 unsigned &DiagID) { 810 // 'virtual virtual' is ok, but warn as this is likely not what the user 811 // intended. 812 if (FS_virtual_specified) { 813 DiagID = diag::warn_duplicate_declspec; 814 PrevSpec = "virtual"; 815 return true; 816 } 817 FS_virtual_specified = true; 818 FS_virtualLoc = Loc; 819 return false; 820 } 821 822 bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc, 823 const char *&PrevSpec, 824 unsigned &DiagID) { 825 // 'explicit explicit' is ok, but warn as this is likely not what the user 826 // intended. 827 if (FS_explicit_specified) { 828 DiagID = diag::warn_duplicate_declspec; 829 PrevSpec = "explicit"; 830 return true; 831 } 832 FS_explicit_specified = true; 833 FS_explicitLoc = Loc; 834 return false; 835 } 836 837 bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc, 838 const char *&PrevSpec, 839 unsigned &DiagID) { 840 // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user 841 // intended. 842 if (FS_noreturn_specified) { 843 DiagID = diag::warn_duplicate_declspec; 844 PrevSpec = "_Noreturn"; 845 return true; 846 } 847 FS_noreturn_specified = true; 848 FS_noreturnLoc = Loc; 849 return false; 850 } 851 852 bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec, 853 unsigned &DiagID) { 854 if (Friend_specified) { 855 PrevSpec = "friend"; 856 // Keep the later location, so that we can later diagnose ill-formed 857 // declarations like 'friend class X friend;'. Per [class.friend]p3, 858 // 'friend' must be the first token in a friend declaration that is 859 // not a function declaration. 860 FriendLoc = Loc; 861 DiagID = diag::warn_duplicate_declspec; 862 return true; 863 } 864 865 Friend_specified = true; 866 FriendLoc = Loc; 867 return false; 868 } 869 870 bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec, 871 unsigned &DiagID) { 872 if (isModulePrivateSpecified()) { 873 PrevSpec = "__module_private__"; 874 DiagID = diag::ext_duplicate_declspec; 875 return true; 876 } 877 878 ModulePrivateLoc = Loc; 879 return false; 880 } 881 882 bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec, 883 unsigned &DiagID) { 884 // 'constexpr constexpr' is ok, but warn as this is likely not what the user 885 // intended. 886 if (Constexpr_specified) { 887 DiagID = diag::warn_duplicate_declspec; 888 PrevSpec = "constexpr"; 889 return true; 890 } 891 Constexpr_specified = true; 892 ConstexprLoc = Loc; 893 return false; 894 } 895 896 void DeclSpec::setProtocolQualifiers(Decl * const *Protos, 897 unsigned NP, 898 SourceLocation *ProtoLocs, 899 SourceLocation LAngleLoc) { 900 if (NP == 0) return; 901 Decl **ProtoQuals = new Decl*[NP]; 902 memcpy(ProtoQuals, Protos, sizeof(Decl*)*NP); 903 ProtocolQualifiers = ProtoQuals; 904 ProtocolLocs = new SourceLocation[NP]; 905 memcpy(ProtocolLocs, ProtoLocs, sizeof(SourceLocation)*NP); 906 NumProtocolQualifiers = NP; 907 ProtocolLAngleLoc = LAngleLoc; 908 } 909 910 void DeclSpec::SaveWrittenBuiltinSpecs() { 911 writtenBS.Sign = getTypeSpecSign(); 912 writtenBS.Width = getTypeSpecWidth(); 913 writtenBS.Type = getTypeSpecType(); 914 // Search the list of attributes for the presence of a mode attribute. 915 writtenBS.ModeAttr = false; 916 AttributeList* attrs = getAttributes().getList(); 917 while (attrs) { 918 if (attrs->getKind() == AttributeList::AT_Mode) { 919 writtenBS.ModeAttr = true; 920 break; 921 } 922 attrs = attrs->getNext(); 923 } 924 } 925 926 /// Finish - This does final analysis of the declspec, rejecting things like 927 /// "_Imaginary" (lacking an FP type). This returns a diagnostic to issue or 928 /// diag::NUM_DIAGNOSTICS if there is no error. After calling this method, 929 /// DeclSpec is guaranteed self-consistent, even if an error occurred. 930 void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP, const PrintingPolicy &Policy) { 931 // Before possibly changing their values, save specs as written. 932 SaveWrittenBuiltinSpecs(); 933 934 // Check the type specifier components first. 935 936 // If decltype(auto) is used, no other type specifiers are permitted. 937 if (TypeSpecType == TST_decltype_auto && 938 (TypeSpecWidth != TSW_unspecified || 939 TypeSpecComplex != TSC_unspecified || 940 TypeSpecSign != TSS_unspecified || 941 TypeAltiVecVector || TypeAltiVecPixel || TypeAltiVecBool || 942 TypeQualifiers)) { 943 const unsigned NumLocs = 8; 944 SourceLocation ExtraLocs[NumLocs] = { 945 TSWLoc, TSCLoc, TSSLoc, AltiVecLoc, 946 TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc 947 }; 948 FixItHint Hints[NumLocs]; 949 SourceLocation FirstLoc; 950 for (unsigned I = 0; I != NumLocs; ++I) { 951 if (!ExtraLocs[I].isInvalid()) { 952 if (FirstLoc.isInvalid() || 953 PP.getSourceManager().isBeforeInTranslationUnit(ExtraLocs[I], 954 FirstLoc)) 955 FirstLoc = ExtraLocs[I]; 956 Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]); 957 } 958 } 959 TypeSpecWidth = TSW_unspecified; 960 TypeSpecComplex = TSC_unspecified; 961 TypeSpecSign = TSS_unspecified; 962 TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false; 963 TypeQualifiers = 0; 964 Diag(D, TSTLoc, diag::err_decltype_auto_cannot_be_combined) 965 << Hints[0] << Hints[1] << Hints[2] << Hints[3] 966 << Hints[4] << Hints[5] << Hints[6] << Hints[7]; 967 } 968 969 // Validate and finalize AltiVec vector declspec. 970 if (TypeAltiVecVector) { 971 if (TypeAltiVecBool) { 972 // Sign specifiers are not allowed with vector bool. (PIM 2.1) 973 if (TypeSpecSign != TSS_unspecified) { 974 Diag(D, TSSLoc, diag::err_invalid_vector_bool_decl_spec) 975 << getSpecifierName((TSS)TypeSpecSign); 976 } 977 978 // Only char/int are valid with vector bool. (PIM 2.1) 979 if (((TypeSpecType != TST_unspecified) && (TypeSpecType != TST_char) && 980 (TypeSpecType != TST_int)) || TypeAltiVecPixel) { 981 Diag(D, TSTLoc, diag::err_invalid_vector_bool_decl_spec) 982 << (TypeAltiVecPixel ? "__pixel" : 983 getSpecifierName((TST)TypeSpecType, Policy)); 984 } 985 986 // Only 'short' is valid with vector bool. (PIM 2.1) 987 if ((TypeSpecWidth != TSW_unspecified) && (TypeSpecWidth != TSW_short)) 988 Diag(D, TSWLoc, diag::err_invalid_vector_bool_decl_spec) 989 << getSpecifierName((TSW)TypeSpecWidth); 990 991 // Elements of vector bool are interpreted as unsigned. (PIM 2.1) 992 if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) || 993 (TypeSpecWidth != TSW_unspecified)) 994 TypeSpecSign = TSS_unsigned; 995 } else if (TypeSpecType == TST_double) { 996 // vector long double and vector long long double are never allowed. 997 // vector double is OK for Power7 and later. 998 if (TypeSpecWidth == TSW_long || TypeSpecWidth == TSW_longlong) 999 Diag(D, TSWLoc, diag::err_invalid_vector_long_double_decl_spec); 1000 else if (!PP.getTargetInfo().hasFeature("vsx")) 1001 Diag(D, TSTLoc, diag::err_invalid_vector_double_decl_spec); 1002 } else if (TypeSpecWidth == TSW_long) { 1003 Diag(D, TSWLoc, diag::warn_vector_long_decl_spec_combination) 1004 << getSpecifierName((TST)TypeSpecType, Policy); 1005 } 1006 1007 if (TypeAltiVecPixel) { 1008 //TODO: perform validation 1009 TypeSpecType = TST_int; 1010 TypeSpecSign = TSS_unsigned; 1011 TypeSpecWidth = TSW_short; 1012 TypeSpecOwned = false; 1013 } 1014 } 1015 1016 // signed/unsigned are only valid with int/char/wchar_t. 1017 if (TypeSpecSign != TSS_unspecified) { 1018 if (TypeSpecType == TST_unspecified) 1019 TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int. 1020 else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 && 1021 TypeSpecType != TST_char && TypeSpecType != TST_wchar) { 1022 Diag(D, TSSLoc, diag::err_invalid_sign_spec) 1023 << getSpecifierName((TST)TypeSpecType, Policy); 1024 // signed double -> double. 1025 TypeSpecSign = TSS_unspecified; 1026 } 1027 } 1028 1029 // Validate the width of the type. 1030 switch (TypeSpecWidth) { 1031 case TSW_unspecified: break; 1032 case TSW_short: // short int 1033 case TSW_longlong: // long long int 1034 if (TypeSpecType == TST_unspecified) 1035 TypeSpecType = TST_int; // short -> short int, long long -> long long int. 1036 else if (TypeSpecType != TST_int) { 1037 Diag(D, TSWLoc, 1038 TypeSpecWidth == TSW_short ? diag::err_invalid_short_spec 1039 : diag::err_invalid_longlong_spec) 1040 << getSpecifierName((TST)TypeSpecType, Policy); 1041 TypeSpecType = TST_int; 1042 TypeSpecOwned = false; 1043 } 1044 break; 1045 case TSW_long: // long double, long int 1046 if (TypeSpecType == TST_unspecified) 1047 TypeSpecType = TST_int; // long -> long int. 1048 else if (TypeSpecType != TST_int && TypeSpecType != TST_double) { 1049 Diag(D, TSWLoc, diag::err_invalid_long_spec) 1050 << getSpecifierName((TST)TypeSpecType, Policy); 1051 TypeSpecType = TST_int; 1052 TypeSpecOwned = false; 1053 } 1054 break; 1055 } 1056 1057 // TODO: if the implementation does not implement _Complex or _Imaginary, 1058 // disallow their use. Need information about the backend. 1059 if (TypeSpecComplex != TSC_unspecified) { 1060 if (TypeSpecType == TST_unspecified) { 1061 Diag(D, TSCLoc, diag::ext_plain_complex) 1062 << FixItHint::CreateInsertion( 1063 PP.getLocForEndOfToken(getTypeSpecComplexLoc()), 1064 " double"); 1065 TypeSpecType = TST_double; // _Complex -> _Complex double. 1066 } else if (TypeSpecType == TST_int || TypeSpecType == TST_char) { 1067 // Note that this intentionally doesn't include _Complex _Bool. 1068 if (!PP.getLangOpts().CPlusPlus) 1069 Diag(D, TSTLoc, diag::ext_integer_complex); 1070 } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) { 1071 Diag(D, TSCLoc, diag::err_invalid_complex_spec) 1072 << getSpecifierName((TST)TypeSpecType, Policy); 1073 TypeSpecComplex = TSC_unspecified; 1074 } 1075 } 1076 1077 // C11 6.7.1/3, C++11 [dcl.stc]p1, GNU TLS: __thread, thread_local and 1078 // _Thread_local can only appear with the 'static' and 'extern' storage class 1079 // specifiers. We also allow __private_extern__ as an extension. 1080 if (ThreadStorageClassSpec != TSCS_unspecified) { 1081 switch (StorageClassSpec) { 1082 case SCS_unspecified: 1083 case SCS_extern: 1084 case SCS_private_extern: 1085 case SCS_static: 1086 break; 1087 default: 1088 if (PP.getSourceManager().isBeforeInTranslationUnit( 1089 getThreadStorageClassSpecLoc(), getStorageClassSpecLoc())) 1090 Diag(D, getStorageClassSpecLoc(), 1091 diag::err_invalid_decl_spec_combination) 1092 << DeclSpec::getSpecifierName(getThreadStorageClassSpec()) 1093 << SourceRange(getThreadStorageClassSpecLoc()); 1094 else 1095 Diag(D, getThreadStorageClassSpecLoc(), 1096 diag::err_invalid_decl_spec_combination) 1097 << DeclSpec::getSpecifierName(getStorageClassSpec()) 1098 << SourceRange(getStorageClassSpecLoc()); 1099 // Discard the thread storage class specifier to recover. 1100 ThreadStorageClassSpec = TSCS_unspecified; 1101 ThreadStorageClassSpecLoc = SourceLocation(); 1102 } 1103 } 1104 1105 // If no type specifier was provided and we're parsing a language where 1106 // the type specifier is not optional, but we got 'auto' as a storage 1107 // class specifier, then assume this is an attempt to use C++0x's 'auto' 1108 // type specifier. 1109 if (PP.getLangOpts().CPlusPlus && 1110 TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) { 1111 TypeSpecType = TST_auto; 1112 StorageClassSpec = SCS_unspecified; 1113 TSTLoc = TSTNameLoc = StorageClassSpecLoc; 1114 StorageClassSpecLoc = SourceLocation(); 1115 } 1116 // Diagnose if we've recovered from an ill-formed 'auto' storage class 1117 // specifier in a pre-C++11 dialect of C++. 1118 if (!PP.getLangOpts().CPlusPlus11 && TypeSpecType == TST_auto) 1119 Diag(D, TSTLoc, diag::ext_auto_type_specifier); 1120 if (PP.getLangOpts().CPlusPlus && !PP.getLangOpts().CPlusPlus11 && 1121 StorageClassSpec == SCS_auto) 1122 Diag(D, StorageClassSpecLoc, diag::warn_auto_storage_class) 1123 << FixItHint::CreateRemoval(StorageClassSpecLoc); 1124 if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32) 1125 Diag(D, TSTLoc, diag::warn_cxx98_compat_unicode_type) 1126 << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t"); 1127 if (Constexpr_specified) 1128 Diag(D, ConstexprLoc, diag::warn_cxx98_compat_constexpr); 1129 1130 // C++ [class.friend]p6: 1131 // No storage-class-specifier shall appear in the decl-specifier-seq 1132 // of a friend declaration. 1133 if (isFriendSpecified() && 1134 (getStorageClassSpec() || getThreadStorageClassSpec())) { 1135 SmallString<32> SpecName; 1136 SourceLocation SCLoc; 1137 FixItHint StorageHint, ThreadHint; 1138 1139 if (DeclSpec::SCS SC = getStorageClassSpec()) { 1140 SpecName = getSpecifierName(SC); 1141 SCLoc = getStorageClassSpecLoc(); 1142 StorageHint = FixItHint::CreateRemoval(SCLoc); 1143 } 1144 1145 if (DeclSpec::TSCS TSC = getThreadStorageClassSpec()) { 1146 if (!SpecName.empty()) SpecName += " "; 1147 SpecName += getSpecifierName(TSC); 1148 SCLoc = getThreadStorageClassSpecLoc(); 1149 ThreadHint = FixItHint::CreateRemoval(SCLoc); 1150 } 1151 1152 Diag(D, SCLoc, diag::err_friend_decl_spec) 1153 << SpecName << StorageHint << ThreadHint; 1154 1155 ClearStorageClassSpecs(); 1156 } 1157 1158 // C++11 [dcl.fct.spec]p5: 1159 // The virtual specifier shall be used only in the initial 1160 // declaration of a non-static class member function; 1161 // C++11 [dcl.fct.spec]p6: 1162 // The explicit specifier shall be used only in the declaration of 1163 // a constructor or conversion function within its class 1164 // definition; 1165 if (isFriendSpecified() && (isVirtualSpecified() || isExplicitSpecified())) { 1166 StringRef Keyword; 1167 SourceLocation SCLoc; 1168 1169 if (isVirtualSpecified()) { 1170 Keyword = "virtual"; 1171 SCLoc = getVirtualSpecLoc(); 1172 } else { 1173 Keyword = "explicit"; 1174 SCLoc = getExplicitSpecLoc(); 1175 } 1176 1177 FixItHint Hint = FixItHint::CreateRemoval(SCLoc); 1178 Diag(D, SCLoc, diag::err_friend_decl_spec) 1179 << Keyword << Hint; 1180 1181 FS_virtual_specified = FS_explicit_specified = false; 1182 FS_virtualLoc = FS_explicitLoc = SourceLocation(); 1183 } 1184 1185 assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType)); 1186 1187 // Okay, now we can infer the real type. 1188 1189 // TODO: return "auto function" and other bad things based on the real type. 1190 1191 // 'data definition has no type or storage class'? 1192 } 1193 1194 bool DeclSpec::isMissingDeclaratorOk() { 1195 TST tst = getTypeSpecType(); 1196 return isDeclRep(tst) && getRepAsDecl() != nullptr && 1197 StorageClassSpec != DeclSpec::SCS_typedef; 1198 } 1199 1200 void UnqualifiedId::setOperatorFunctionId(SourceLocation OperatorLoc, 1201 OverloadedOperatorKind Op, 1202 SourceLocation SymbolLocations[3]) { 1203 Kind = IK_OperatorFunctionId; 1204 StartLocation = OperatorLoc; 1205 EndLocation = OperatorLoc; 1206 OperatorFunctionId.Operator = Op; 1207 for (unsigned I = 0; I != 3; ++I) { 1208 OperatorFunctionId.SymbolLocations[I] = SymbolLocations[I].getRawEncoding(); 1209 1210 if (SymbolLocations[I].isValid()) 1211 EndLocation = SymbolLocations[I]; 1212 } 1213 } 1214 1215 bool VirtSpecifiers::SetSpecifier(Specifier VS, SourceLocation Loc, 1216 const char *&PrevSpec) { 1217 LastLocation = Loc; 1218 1219 if (Specifiers & VS) { 1220 PrevSpec = getSpecifierName(VS); 1221 return true; 1222 } 1223 1224 Specifiers |= VS; 1225 1226 switch (VS) { 1227 default: llvm_unreachable("Unknown specifier!"); 1228 case VS_Override: VS_overrideLoc = Loc; break; 1229 case VS_Sealed: 1230 case VS_Final: VS_finalLoc = Loc; break; 1231 } 1232 1233 return false; 1234 } 1235 1236 const char *VirtSpecifiers::getSpecifierName(Specifier VS) { 1237 switch (VS) { 1238 default: llvm_unreachable("Unknown specifier"); 1239 case VS_Override: return "override"; 1240 case VS_Final: return "final"; 1241 case VS_Sealed: return "sealed"; 1242 } 1243 } 1244