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