1 //===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===// 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 declarations. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Sema/SemaInternal.h" 15 #include "TypeLocBuilder.h" 16 #include "clang/AST/ASTConsumer.h" 17 #include "clang/AST/ASTContext.h" 18 #include "clang/AST/ASTLambda.h" 19 #include "clang/AST/ASTMutationListener.h" 20 #include "clang/AST/CXXInheritance.h" 21 #include "clang/AST/CharUnits.h" 22 #include "clang/AST/CommentDiagnostic.h" 23 #include "clang/AST/DeclCXX.h" 24 #include "clang/AST/DeclObjC.h" 25 #include "clang/AST/DeclTemplate.h" 26 #include "clang/AST/EvaluatedExprVisitor.h" 27 #include "clang/AST/ExprCXX.h" 28 #include "clang/AST/StmtCXX.h" 29 #include "clang/Basic/Builtins.h" 30 #include "clang/Basic/PartialDiagnostic.h" 31 #include "clang/Basic/SourceManager.h" 32 #include "clang/Basic/TargetInfo.h" 33 #include "clang/Lex/HeaderSearch.h" // TODO: Sema shouldn't depend on Lex 34 #include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering. 35 #include "clang/Lex/ModuleLoader.h" // TODO: Sema shouldn't depend on Lex 36 #include "clang/Lex/Preprocessor.h" // Included for isCodeCompletionEnabled() 37 #include "clang/Parse/ParseDiagnostic.h" 38 #include "clang/Sema/CXXFieldCollector.h" 39 #include "clang/Sema/DeclSpec.h" 40 #include "clang/Sema/DelayedDiagnostic.h" 41 #include "clang/Sema/Initialization.h" 42 #include "clang/Sema/Lookup.h" 43 #include "clang/Sema/ParsedTemplate.h" 44 #include "clang/Sema/Scope.h" 45 #include "clang/Sema/ScopeInfo.h" 46 #include "clang/Sema/Template.h" 47 #include "llvm/ADT/SmallString.h" 48 #include "llvm/ADT/Triple.h" 49 #include <algorithm> 50 #include <cstring> 51 #include <functional> 52 using namespace clang; 53 using namespace sema; 54 55 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) { 56 if (OwnedType) { 57 Decl *Group[2] = { OwnedType, Ptr }; 58 return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2)); 59 } 60 61 return DeclGroupPtrTy::make(DeclGroupRef(Ptr)); 62 } 63 64 namespace { 65 66 class TypeNameValidatorCCC : public CorrectionCandidateCallback { 67 public: 68 TypeNameValidatorCCC(bool AllowInvalid, bool WantClass=false, 69 bool AllowTemplates=false) 70 : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass), 71 AllowClassTemplates(AllowTemplates) { 72 WantExpressionKeywords = false; 73 WantCXXNamedCasts = false; 74 WantRemainingKeywords = false; 75 } 76 77 bool ValidateCandidate(const TypoCorrection &candidate) override { 78 if (NamedDecl *ND = candidate.getCorrectionDecl()) { 79 bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND); 80 bool AllowedTemplate = AllowClassTemplates && isa<ClassTemplateDecl>(ND); 81 return (IsType || AllowedTemplate) && 82 (AllowInvalidDecl || !ND->isInvalidDecl()); 83 } 84 return !WantClassName && candidate.isKeyword(); 85 } 86 87 private: 88 bool AllowInvalidDecl; 89 bool WantClassName; 90 bool AllowClassTemplates; 91 }; 92 93 } 94 95 /// \brief Determine whether the token kind starts a simple-type-specifier. 96 bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const { 97 switch (Kind) { 98 // FIXME: Take into account the current language when deciding whether a 99 // token kind is a valid type specifier 100 case tok::kw_short: 101 case tok::kw_long: 102 case tok::kw___int64: 103 case tok::kw___int128: 104 case tok::kw_signed: 105 case tok::kw_unsigned: 106 case tok::kw_void: 107 case tok::kw_char: 108 case tok::kw_int: 109 case tok::kw_half: 110 case tok::kw_float: 111 case tok::kw_double: 112 case tok::kw_wchar_t: 113 case tok::kw_bool: 114 case tok::kw___underlying_type: 115 return true; 116 117 case tok::annot_typename: 118 case tok::kw_char16_t: 119 case tok::kw_char32_t: 120 case tok::kw_typeof: 121 case tok::annot_decltype: 122 case tok::kw_decltype: 123 return getLangOpts().CPlusPlus; 124 125 default: 126 break; 127 } 128 129 return false; 130 } 131 132 namespace { 133 enum class UnqualifiedTypeNameLookupResult { 134 NotFound, 135 FoundNonType, 136 FoundType 137 }; 138 } // namespace 139 140 /// \brief Tries to perform unqualified lookup of the type decls in bases for 141 /// dependent class. 142 /// \return \a NotFound if no any decls is found, \a FoundNotType if found not a 143 /// type decl, \a FoundType if only type decls are found. 144 static UnqualifiedTypeNameLookupResult 145 lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II, 146 SourceLocation NameLoc, 147 const CXXRecordDecl *RD) { 148 if (!RD->hasDefinition()) 149 return UnqualifiedTypeNameLookupResult::NotFound; 150 // Look for type decls in base classes. 151 UnqualifiedTypeNameLookupResult FoundTypeDecl = 152 UnqualifiedTypeNameLookupResult::NotFound; 153 for (const auto &Base : RD->bases()) { 154 const CXXRecordDecl *BaseRD = nullptr; 155 if (auto *BaseTT = Base.getType()->getAs<TagType>()) 156 BaseRD = BaseTT->getAsCXXRecordDecl(); 157 else if (auto *TST = Base.getType()->getAs<TemplateSpecializationType>()) { 158 // Look for type decls in dependent base classes that have known primary 159 // templates. 160 if (!TST || !TST->isDependentType()) 161 continue; 162 auto *TD = TST->getTemplateName().getAsTemplateDecl(); 163 if (!TD) 164 continue; 165 auto *BasePrimaryTemplate = 166 dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl()); 167 if (!BasePrimaryTemplate) 168 continue; 169 BaseRD = BasePrimaryTemplate; 170 } 171 if (BaseRD) { 172 for (NamedDecl *ND : BaseRD->lookup(&II)) { 173 if (!isa<TypeDecl>(ND)) 174 return UnqualifiedTypeNameLookupResult::FoundNonType; 175 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType; 176 } 177 if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) { 178 switch (lookupUnqualifiedTypeNameInBase(S, II, NameLoc, BaseRD)) { 179 case UnqualifiedTypeNameLookupResult::FoundNonType: 180 return UnqualifiedTypeNameLookupResult::FoundNonType; 181 case UnqualifiedTypeNameLookupResult::FoundType: 182 FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType; 183 break; 184 case UnqualifiedTypeNameLookupResult::NotFound: 185 break; 186 } 187 } 188 } 189 } 190 191 return FoundTypeDecl; 192 } 193 194 static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, 195 const IdentifierInfo &II, 196 SourceLocation NameLoc) { 197 // Lookup in the parent class template context, if any. 198 const CXXRecordDecl *RD = nullptr; 199 UnqualifiedTypeNameLookupResult FoundTypeDecl = 200 UnqualifiedTypeNameLookupResult::NotFound; 201 for (DeclContext *DC = S.CurContext; 202 DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound; 203 DC = DC->getParent()) { 204 // Look for type decls in dependent base classes that have known primary 205 // templates. 206 RD = dyn_cast<CXXRecordDecl>(DC); 207 if (RD && RD->getDescribedClassTemplate()) 208 FoundTypeDecl = lookupUnqualifiedTypeNameInBase(S, II, NameLoc, RD); 209 } 210 if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType) 211 return ParsedType(); 212 213 // We found some types in dependent base classes. Recover as if the user 214 // wrote 'typename MyClass::II' instead of 'II'. We'll fully resolve the 215 // lookup during template instantiation. 216 S.Diag(NameLoc, diag::ext_found_via_dependent_bases_lookup) << &II; 217 218 ASTContext &Context = S.Context; 219 auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false, 220 cast<Type>(Context.getRecordType(RD))); 221 QualType T = Context.getDependentNameType(ETK_Typename, NNS, &II); 222 223 CXXScopeSpec SS; 224 SS.MakeTrivial(Context, NNS, SourceRange(NameLoc)); 225 226 TypeLocBuilder Builder; 227 DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T); 228 DepTL.setNameLoc(NameLoc); 229 DepTL.setElaboratedKeywordLoc(SourceLocation()); 230 DepTL.setQualifierLoc(SS.getWithLocInContext(Context)); 231 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 232 } 233 234 /// \brief If the identifier refers to a type name within this scope, 235 /// return the declaration of that type. 236 /// 237 /// This routine performs ordinary name lookup of the identifier II 238 /// within the given scope, with optional C++ scope specifier SS, to 239 /// determine whether the name refers to a type. If so, returns an 240 /// opaque pointer (actually a QualType) corresponding to that 241 /// type. Otherwise, returns NULL. 242 ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, 243 Scope *S, CXXScopeSpec *SS, 244 bool isClassName, bool HasTrailingDot, 245 ParsedType ObjectTypePtr, 246 bool IsCtorOrDtorName, 247 bool WantNontrivialTypeSourceInfo, 248 IdentifierInfo **CorrectedII) { 249 // Determine where we will perform name lookup. 250 DeclContext *LookupCtx = nullptr; 251 if (ObjectTypePtr) { 252 QualType ObjectType = ObjectTypePtr.get(); 253 if (ObjectType->isRecordType()) 254 LookupCtx = computeDeclContext(ObjectType); 255 } else if (SS && SS->isNotEmpty()) { 256 LookupCtx = computeDeclContext(*SS, false); 257 258 if (!LookupCtx) { 259 if (isDependentScopeSpecifier(*SS)) { 260 // C++ [temp.res]p3: 261 // A qualified-id that refers to a type and in which the 262 // nested-name-specifier depends on a template-parameter (14.6.2) 263 // shall be prefixed by the keyword typename to indicate that the 264 // qualified-id denotes a type, forming an 265 // elaborated-type-specifier (7.1.5.3). 266 // 267 // We therefore do not perform any name lookup if the result would 268 // refer to a member of an unknown specialization. 269 if (!isClassName && !IsCtorOrDtorName) 270 return ParsedType(); 271 272 // We know from the grammar that this name refers to a type, 273 // so build a dependent node to describe the type. 274 if (WantNontrivialTypeSourceInfo) 275 return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get(); 276 277 NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context); 278 QualType T = CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc, 279 II, NameLoc); 280 return ParsedType::make(T); 281 } 282 283 return ParsedType(); 284 } 285 286 if (!LookupCtx->isDependentContext() && 287 RequireCompleteDeclContext(*SS, LookupCtx)) 288 return ParsedType(); 289 } 290 291 // FIXME: LookupNestedNameSpecifierName isn't the right kind of 292 // lookup for class-names. 293 LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName : 294 LookupOrdinaryName; 295 LookupResult Result(*this, &II, NameLoc, Kind); 296 if (LookupCtx) { 297 // Perform "qualified" name lookup into the declaration context we 298 // computed, which is either the type of the base of a member access 299 // expression or the declaration context associated with a prior 300 // nested-name-specifier. 301 LookupQualifiedName(Result, LookupCtx); 302 303 if (ObjectTypePtr && Result.empty()) { 304 // C++ [basic.lookup.classref]p3: 305 // If the unqualified-id is ~type-name, the type-name is looked up 306 // in the context of the entire postfix-expression. If the type T of 307 // the object expression is of a class type C, the type-name is also 308 // looked up in the scope of class C. At least one of the lookups shall 309 // find a name that refers to (possibly cv-qualified) T. 310 LookupName(Result, S); 311 } 312 } else { 313 // Perform unqualified name lookup. 314 LookupName(Result, S); 315 316 // For unqualified lookup in a class template in MSVC mode, look into 317 // dependent base classes where the primary class template is known. 318 if (Result.empty() && getLangOpts().MSVCCompat && (!SS || SS->isEmpty())) { 319 if (ParsedType TypeInBase = 320 recoverFromTypeInKnownDependentBase(*this, II, NameLoc)) 321 return TypeInBase; 322 } 323 } 324 325 NamedDecl *IIDecl = nullptr; 326 switch (Result.getResultKind()) { 327 case LookupResult::NotFound: 328 case LookupResult::NotFoundInCurrentInstantiation: 329 if (CorrectedII) { 330 TypoCorrection Correction = CorrectTypo( 331 Result.getLookupNameInfo(), Kind, S, SS, 332 llvm::make_unique<TypeNameValidatorCCC>(true, isClassName), 333 CTK_ErrorRecovery); 334 IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo(); 335 TemplateTy Template; 336 bool MemberOfUnknownSpecialization; 337 UnqualifiedId TemplateName; 338 TemplateName.setIdentifier(NewII, NameLoc); 339 NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier(); 340 CXXScopeSpec NewSS, *NewSSPtr = SS; 341 if (SS && NNS) { 342 NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc)); 343 NewSSPtr = &NewSS; 344 } 345 if (Correction && (NNS || NewII != &II) && 346 // Ignore a correction to a template type as the to-be-corrected 347 // identifier is not a template (typo correction for template names 348 // is handled elsewhere). 349 !(getLangOpts().CPlusPlus && NewSSPtr && 350 isTemplateName(S, *NewSSPtr, false, TemplateName, ParsedType(), 351 false, Template, MemberOfUnknownSpecialization))) { 352 ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr, 353 isClassName, HasTrailingDot, ObjectTypePtr, 354 IsCtorOrDtorName, 355 WantNontrivialTypeSourceInfo); 356 if (Ty) { 357 diagnoseTypo(Correction, 358 PDiag(diag::err_unknown_type_or_class_name_suggest) 359 << Result.getLookupName() << isClassName); 360 if (SS && NNS) 361 SS->MakeTrivial(Context, NNS, SourceRange(NameLoc)); 362 *CorrectedII = NewII; 363 return Ty; 364 } 365 } 366 } 367 // If typo correction failed or was not performed, fall through 368 case LookupResult::FoundOverloaded: 369 case LookupResult::FoundUnresolvedValue: 370 Result.suppressDiagnostics(); 371 return ParsedType(); 372 373 case LookupResult::Ambiguous: 374 // Recover from type-hiding ambiguities by hiding the type. We'll 375 // do the lookup again when looking for an object, and we can 376 // diagnose the error then. If we don't do this, then the error 377 // about hiding the type will be immediately followed by an error 378 // that only makes sense if the identifier was treated like a type. 379 if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) { 380 Result.suppressDiagnostics(); 381 return ParsedType(); 382 } 383 384 // Look to see if we have a type anywhere in the list of results. 385 for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end(); 386 Res != ResEnd; ++Res) { 387 if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) { 388 if (!IIDecl || 389 (*Res)->getLocation().getRawEncoding() < 390 IIDecl->getLocation().getRawEncoding()) 391 IIDecl = *Res; 392 } 393 } 394 395 if (!IIDecl) { 396 // None of the entities we found is a type, so there is no way 397 // to even assume that the result is a type. In this case, don't 398 // complain about the ambiguity. The parser will either try to 399 // perform this lookup again (e.g., as an object name), which 400 // will produce the ambiguity, or will complain that it expected 401 // a type name. 402 Result.suppressDiagnostics(); 403 return ParsedType(); 404 } 405 406 // We found a type within the ambiguous lookup; diagnose the 407 // ambiguity and then return that type. This might be the right 408 // answer, or it might not be, but it suppresses any attempt to 409 // perform the name lookup again. 410 break; 411 412 case LookupResult::Found: 413 IIDecl = Result.getFoundDecl(); 414 break; 415 } 416 417 assert(IIDecl && "Didn't find decl"); 418 419 QualType T; 420 if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) { 421 DiagnoseUseOfDecl(IIDecl, NameLoc); 422 423 T = Context.getTypeDeclType(TD); 424 MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false); 425 426 // NOTE: avoid constructing an ElaboratedType(Loc) if this is a 427 // constructor or destructor name (in such a case, the scope specifier 428 // will be attached to the enclosing Expr or Decl node). 429 if (SS && SS->isNotEmpty() && !IsCtorOrDtorName) { 430 if (WantNontrivialTypeSourceInfo) { 431 // Construct a type with type-source information. 432 TypeLocBuilder Builder; 433 Builder.pushTypeSpec(T).setNameLoc(NameLoc); 434 435 T = getElaboratedType(ETK_None, *SS, T); 436 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T); 437 ElabTL.setElaboratedKeywordLoc(SourceLocation()); 438 ElabTL.setQualifierLoc(SS->getWithLocInContext(Context)); 439 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 440 } else { 441 T = getElaboratedType(ETK_None, *SS, T); 442 } 443 } 444 } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) { 445 (void)DiagnoseUseOfDecl(IDecl, NameLoc); 446 if (!HasTrailingDot) 447 T = Context.getObjCInterfaceType(IDecl); 448 } 449 450 if (T.isNull()) { 451 // If it's not plausibly a type, suppress diagnostics. 452 Result.suppressDiagnostics(); 453 return ParsedType(); 454 } 455 return ParsedType::make(T); 456 } 457 458 // Builds a fake NNS for the given decl context. 459 static NestedNameSpecifier * 460 synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC) { 461 for (;; DC = DC->getLookupParent()) { 462 DC = DC->getPrimaryContext(); 463 auto *ND = dyn_cast<NamespaceDecl>(DC); 464 if (ND && !ND->isInline() && !ND->isAnonymousNamespace()) 465 return NestedNameSpecifier::Create(Context, nullptr, ND); 466 else if (auto *RD = dyn_cast<CXXRecordDecl>(DC)) 467 return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(), 468 RD->getTypeForDecl()); 469 else if (isa<TranslationUnitDecl>(DC)) 470 return NestedNameSpecifier::GlobalSpecifier(Context); 471 } 472 llvm_unreachable("something isn't in TU scope?"); 473 } 474 475 ParsedType Sema::ActOnDelayedDefaultTemplateArg(const IdentifierInfo &II, 476 SourceLocation NameLoc) { 477 // Accepting an undeclared identifier as a default argument for a template 478 // type parameter is a Microsoft extension. 479 Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II; 480 481 // Build a fake DependentNameType that will perform lookup into CurContext at 482 // instantiation time. The name specifier isn't dependent, so template 483 // instantiation won't transform it. It will retry the lookup, however. 484 NestedNameSpecifier *NNS = 485 synthesizeCurrentNestedNameSpecifier(Context, CurContext); 486 QualType T = Context.getDependentNameType(ETK_None, NNS, &II); 487 488 // Build type location information. We synthesized the qualifier, so we have 489 // to build a fake NestedNameSpecifierLoc. 490 NestedNameSpecifierLocBuilder NNSLocBuilder; 491 NNSLocBuilder.MakeTrivial(Context, NNS, SourceRange(NameLoc)); 492 NestedNameSpecifierLoc QualifierLoc = NNSLocBuilder.getWithLocInContext(Context); 493 494 TypeLocBuilder Builder; 495 DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T); 496 DepTL.setNameLoc(NameLoc); 497 DepTL.setElaboratedKeywordLoc(SourceLocation()); 498 DepTL.setQualifierLoc(QualifierLoc); 499 return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 500 } 501 502 /// isTagName() - This method is called *for error recovery purposes only* 503 /// to determine if the specified name is a valid tag name ("struct foo"). If 504 /// so, this returns the TST for the tag corresponding to it (TST_enum, 505 /// TST_union, TST_struct, TST_interface, TST_class). This is used to diagnose 506 /// cases in C where the user forgot to specify the tag. 507 DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) { 508 // Do a tag name lookup in this scope. 509 LookupResult R(*this, &II, SourceLocation(), LookupTagName); 510 LookupName(R, S, false); 511 R.suppressDiagnostics(); 512 if (R.getResultKind() == LookupResult::Found) 513 if (const TagDecl *TD = R.getAsSingle<TagDecl>()) { 514 switch (TD->getTagKind()) { 515 case TTK_Struct: return DeclSpec::TST_struct; 516 case TTK_Interface: return DeclSpec::TST_interface; 517 case TTK_Union: return DeclSpec::TST_union; 518 case TTK_Class: return DeclSpec::TST_class; 519 case TTK_Enum: return DeclSpec::TST_enum; 520 } 521 } 522 523 return DeclSpec::TST_unspecified; 524 } 525 526 /// isMicrosoftMissingTypename - In Microsoft mode, within class scope, 527 /// if a CXXScopeSpec's type is equal to the type of one of the base classes 528 /// then downgrade the missing typename error to a warning. 529 /// This is needed for MSVC compatibility; Example: 530 /// @code 531 /// template<class T> class A { 532 /// public: 533 /// typedef int TYPE; 534 /// }; 535 /// template<class T> class B : public A<T> { 536 /// public: 537 /// A<T>::TYPE a; // no typename required because A<T> is a base class. 538 /// }; 539 /// @endcode 540 bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) { 541 if (CurContext->isRecord()) { 542 if (SS->getScopeRep()->getKind() == NestedNameSpecifier::Super) 543 return true; 544 545 const Type *Ty = SS->getScopeRep()->getAsType(); 546 547 CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext); 548 for (const auto &Base : RD->bases()) 549 if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base.getType())) 550 return true; 551 return S->isFunctionPrototypeScope(); 552 } 553 return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope(); 554 } 555 556 void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, 557 SourceLocation IILoc, 558 Scope *S, 559 CXXScopeSpec *SS, 560 ParsedType &SuggestedType, 561 bool AllowClassTemplates) { 562 // We don't have anything to suggest (yet). 563 SuggestedType = ParsedType(); 564 565 // There may have been a typo in the name of the type. Look up typo 566 // results, in case we have something that we can suggest. 567 if (TypoCorrection Corrected = 568 CorrectTypo(DeclarationNameInfo(II, IILoc), LookupOrdinaryName, S, SS, 569 llvm::make_unique<TypeNameValidatorCCC>( 570 false, false, AllowClassTemplates), 571 CTK_ErrorRecovery)) { 572 if (Corrected.isKeyword()) { 573 // We corrected to a keyword. 574 diagnoseTypo(Corrected, PDiag(diag::err_unknown_typename_suggest) << II); 575 II = Corrected.getCorrectionAsIdentifierInfo(); 576 } else { 577 // We found a similarly-named type or interface; suggest that. 578 if (!SS || !SS->isSet()) { 579 diagnoseTypo(Corrected, 580 PDiag(diag::err_unknown_typename_suggest) << II); 581 } else if (DeclContext *DC = computeDeclContext(*SS, false)) { 582 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 583 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() && 584 II->getName().equals(CorrectedStr); 585 diagnoseTypo(Corrected, 586 PDiag(diag::err_unknown_nested_typename_suggest) 587 << II << DC << DroppedSpecifier << SS->getRange()); 588 } else { 589 llvm_unreachable("could not have corrected a typo here"); 590 } 591 592 CXXScopeSpec tmpSS; 593 if (Corrected.getCorrectionSpecifier()) 594 tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(), 595 SourceRange(IILoc)); 596 SuggestedType = getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), 597 IILoc, S, tmpSS.isSet() ? &tmpSS : SS, false, 598 false, ParsedType(), 599 /*IsCtorOrDtorName=*/false, 600 /*NonTrivialTypeSourceInfo=*/true); 601 } 602 return; 603 } 604 605 if (getLangOpts().CPlusPlus) { 606 // See if II is a class template that the user forgot to pass arguments to. 607 UnqualifiedId Name; 608 Name.setIdentifier(II, IILoc); 609 CXXScopeSpec EmptySS; 610 TemplateTy TemplateResult; 611 bool MemberOfUnknownSpecialization; 612 if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false, 613 Name, ParsedType(), true, TemplateResult, 614 MemberOfUnknownSpecialization) == TNK_Type_template) { 615 TemplateName TplName = TemplateResult.get(); 616 Diag(IILoc, diag::err_template_missing_args) << TplName; 617 if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) { 618 Diag(TplDecl->getLocation(), diag::note_template_decl_here) 619 << TplDecl->getTemplateParameters()->getSourceRange(); 620 } 621 return; 622 } 623 } 624 625 // FIXME: Should we move the logic that tries to recover from a missing tag 626 // (struct, union, enum) from Parser::ParseImplicitInt here, instead? 627 628 if (!SS || (!SS->isSet() && !SS->isInvalid())) 629 Diag(IILoc, diag::err_unknown_typename) << II; 630 else if (DeclContext *DC = computeDeclContext(*SS, false)) 631 Diag(IILoc, diag::err_typename_nested_not_found) 632 << II << DC << SS->getRange(); 633 else if (isDependentScopeSpecifier(*SS)) { 634 unsigned DiagID = diag::err_typename_missing; 635 if (getLangOpts().MSVCCompat && isMicrosoftMissingTypename(SS, S)) 636 DiagID = diag::ext_typename_missing; 637 638 Diag(SS->getRange().getBegin(), DiagID) 639 << SS->getScopeRep() << II->getName() 640 << SourceRange(SS->getRange().getBegin(), IILoc) 641 << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename "); 642 SuggestedType = ActOnTypenameType(S, SourceLocation(), 643 *SS, *II, IILoc).get(); 644 } else { 645 assert(SS && SS->isInvalid() && 646 "Invalid scope specifier has already been diagnosed"); 647 } 648 } 649 650 /// \brief Determine whether the given result set contains either a type name 651 /// or 652 static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) { 653 bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus && 654 NextToken.is(tok::less); 655 656 for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) { 657 if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I)) 658 return true; 659 660 if (CheckTemplate && isa<TemplateDecl>(*I)) 661 return true; 662 } 663 664 return false; 665 } 666 667 static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, 668 Scope *S, CXXScopeSpec &SS, 669 IdentifierInfo *&Name, 670 SourceLocation NameLoc) { 671 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName); 672 SemaRef.LookupParsedName(R, S, &SS); 673 if (TagDecl *Tag = R.getAsSingle<TagDecl>()) { 674 StringRef FixItTagName; 675 switch (Tag->getTagKind()) { 676 case TTK_Class: 677 FixItTagName = "class "; 678 break; 679 680 case TTK_Enum: 681 FixItTagName = "enum "; 682 break; 683 684 case TTK_Struct: 685 FixItTagName = "struct "; 686 break; 687 688 case TTK_Interface: 689 FixItTagName = "__interface "; 690 break; 691 692 case TTK_Union: 693 FixItTagName = "union "; 694 break; 695 } 696 697 StringRef TagName = FixItTagName.drop_back(); 698 SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag) 699 << Name << TagName << SemaRef.getLangOpts().CPlusPlus 700 << FixItHint::CreateInsertion(NameLoc, FixItTagName); 701 702 for (LookupResult::iterator I = Result.begin(), IEnd = Result.end(); 703 I != IEnd; ++I) 704 SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type) 705 << Name << TagName; 706 707 // Replace lookup results with just the tag decl. 708 Result.clear(Sema::LookupTagName); 709 SemaRef.LookupParsedName(Result, S, &SS); 710 return true; 711 } 712 713 return false; 714 } 715 716 /// Build a ParsedType for a simple-type-specifier with a nested-name-specifier. 717 static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS, 718 QualType T, SourceLocation NameLoc) { 719 ASTContext &Context = S.Context; 720 721 TypeLocBuilder Builder; 722 Builder.pushTypeSpec(T).setNameLoc(NameLoc); 723 724 T = S.getElaboratedType(ETK_None, SS, T); 725 ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T); 726 ElabTL.setElaboratedKeywordLoc(SourceLocation()); 727 ElabTL.setQualifierLoc(SS.getWithLocInContext(Context)); 728 return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T)); 729 } 730 731 Sema::NameClassification 732 Sema::ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, 733 SourceLocation NameLoc, const Token &NextToken, 734 bool IsAddressOfOperand, 735 std::unique_ptr<CorrectionCandidateCallback> CCC) { 736 DeclarationNameInfo NameInfo(Name, NameLoc); 737 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 738 739 if (NextToken.is(tok::coloncolon)) { 740 BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(), 741 QualType(), false, SS, nullptr, false); 742 } 743 744 LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName); 745 LookupParsedName(Result, S, &SS, !CurMethod); 746 747 // For unqualified lookup in a class template in MSVC mode, look into 748 // dependent base classes where the primary class template is known. 749 if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) { 750 if (ParsedType TypeInBase = 751 recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc)) 752 return TypeInBase; 753 } 754 755 // Perform lookup for Objective-C instance variables (including automatically 756 // synthesized instance variables), if we're in an Objective-C method. 757 // FIXME: This lookup really, really needs to be folded in to the normal 758 // unqualified lookup mechanism. 759 if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) { 760 ExprResult E = LookupInObjCMethod(Result, S, Name, true); 761 if (E.get() || E.isInvalid()) 762 return E; 763 } 764 765 bool SecondTry = false; 766 bool IsFilteredTemplateName = false; 767 768 Corrected: 769 switch (Result.getResultKind()) { 770 case LookupResult::NotFound: 771 // If an unqualified-id is followed by a '(', then we have a function 772 // call. 773 if (!SS.isSet() && NextToken.is(tok::l_paren)) { 774 // In C++, this is an ADL-only call. 775 // FIXME: Reference? 776 if (getLangOpts().CPlusPlus) 777 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true); 778 779 // C90 6.3.2.2: 780 // If the expression that precedes the parenthesized argument list in a 781 // function call consists solely of an identifier, and if no 782 // declaration is visible for this identifier, the identifier is 783 // implicitly declared exactly as if, in the innermost block containing 784 // the function call, the declaration 785 // 786 // extern int identifier (); 787 // 788 // appeared. 789 // 790 // We also allow this in C99 as an extension. 791 if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) { 792 Result.addDecl(D); 793 Result.resolveKind(); 794 return BuildDeclarationNameExpr(SS, Result, /*ADL=*/false); 795 } 796 } 797 798 // In C, we first see whether there is a tag type by the same name, in 799 // which case it's likely that the user just forget to write "enum", 800 // "struct", or "union". 801 if (!getLangOpts().CPlusPlus && !SecondTry && 802 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) { 803 break; 804 } 805 806 // Perform typo correction to determine if there is another name that is 807 // close to this name. 808 if (!SecondTry && CCC) { 809 SecondTry = true; 810 if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(), 811 Result.getLookupKind(), S, 812 &SS, std::move(CCC), 813 CTK_ErrorRecovery)) { 814 unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest; 815 unsigned QualifiedDiag = diag::err_no_member_suggest; 816 817 NamedDecl *FirstDecl = Corrected.getCorrectionDecl(); 818 NamedDecl *UnderlyingFirstDecl 819 = FirstDecl? FirstDecl->getUnderlyingDecl() : nullptr; 820 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 821 UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) { 822 UnqualifiedDiag = diag::err_no_template_suggest; 823 QualifiedDiag = diag::err_no_member_template_suggest; 824 } else if (UnderlyingFirstDecl && 825 (isa<TypeDecl>(UnderlyingFirstDecl) || 826 isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) || 827 isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) { 828 UnqualifiedDiag = diag::err_unknown_typename_suggest; 829 QualifiedDiag = diag::err_unknown_nested_typename_suggest; 830 } 831 832 if (SS.isEmpty()) { 833 diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name); 834 } else {// FIXME: is this even reachable? Test it. 835 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 836 bool DroppedSpecifier = Corrected.WillReplaceSpecifier() && 837 Name->getName().equals(CorrectedStr); 838 diagnoseTypo(Corrected, PDiag(QualifiedDiag) 839 << Name << computeDeclContext(SS, false) 840 << DroppedSpecifier << SS.getRange()); 841 } 842 843 // Update the name, so that the caller has the new name. 844 Name = Corrected.getCorrectionAsIdentifierInfo(); 845 846 // Typo correction corrected to a keyword. 847 if (Corrected.isKeyword()) 848 return Name; 849 850 // Also update the LookupResult... 851 // FIXME: This should probably go away at some point 852 Result.clear(); 853 Result.setLookupName(Corrected.getCorrection()); 854 if (FirstDecl) 855 Result.addDecl(FirstDecl); 856 857 // If we found an Objective-C instance variable, let 858 // LookupInObjCMethod build the appropriate expression to 859 // reference the ivar. 860 // FIXME: This is a gross hack. 861 if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) { 862 Result.clear(); 863 ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier())); 864 return E; 865 } 866 867 goto Corrected; 868 } 869 } 870 871 // We failed to correct; just fall through and let the parser deal with it. 872 Result.suppressDiagnostics(); 873 return NameClassification::Unknown(); 874 875 case LookupResult::NotFoundInCurrentInstantiation: { 876 // We performed name lookup into the current instantiation, and there were 877 // dependent bases, so we treat this result the same way as any other 878 // dependent nested-name-specifier. 879 880 // C++ [temp.res]p2: 881 // A name used in a template declaration or definition and that is 882 // dependent on a template-parameter is assumed not to name a type 883 // unless the applicable name lookup finds a type name or the name is 884 // qualified by the keyword typename. 885 // 886 // FIXME: If the next token is '<', we might want to ask the parser to 887 // perform some heroics to see if we actually have a 888 // template-argument-list, which would indicate a missing 'template' 889 // keyword here. 890 return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(), 891 NameInfo, IsAddressOfOperand, 892 /*TemplateArgs=*/nullptr); 893 } 894 895 case LookupResult::Found: 896 case LookupResult::FoundOverloaded: 897 case LookupResult::FoundUnresolvedValue: 898 break; 899 900 case LookupResult::Ambiguous: 901 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 902 hasAnyAcceptableTemplateNames(Result)) { 903 // C++ [temp.local]p3: 904 // A lookup that finds an injected-class-name (10.2) can result in an 905 // ambiguity in certain cases (for example, if it is found in more than 906 // one base class). If all of the injected-class-names that are found 907 // refer to specializations of the same class template, and if the name 908 // is followed by a template-argument-list, the reference refers to the 909 // class template itself and not a specialization thereof, and is not 910 // ambiguous. 911 // 912 // This filtering can make an ambiguous result into an unambiguous one, 913 // so try again after filtering out template names. 914 FilterAcceptableTemplateNames(Result); 915 if (!Result.isAmbiguous()) { 916 IsFilteredTemplateName = true; 917 break; 918 } 919 } 920 921 // Diagnose the ambiguity and return an error. 922 return NameClassification::Error(); 923 } 924 925 if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && 926 (IsFilteredTemplateName || hasAnyAcceptableTemplateNames(Result))) { 927 // C++ [temp.names]p3: 928 // After name lookup (3.4) finds that a name is a template-name or that 929 // an operator-function-id or a literal- operator-id refers to a set of 930 // overloaded functions any member of which is a function template if 931 // this is followed by a <, the < is always taken as the delimiter of a 932 // template-argument-list and never as the less-than operator. 933 if (!IsFilteredTemplateName) 934 FilterAcceptableTemplateNames(Result); 935 936 if (!Result.empty()) { 937 bool IsFunctionTemplate; 938 bool IsVarTemplate; 939 TemplateName Template; 940 if (Result.end() - Result.begin() > 1) { 941 IsFunctionTemplate = true; 942 Template = Context.getOverloadedTemplateName(Result.begin(), 943 Result.end()); 944 } else { 945 TemplateDecl *TD 946 = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl()); 947 IsFunctionTemplate = isa<FunctionTemplateDecl>(TD); 948 IsVarTemplate = isa<VarTemplateDecl>(TD); 949 950 if (SS.isSet() && !SS.isInvalid()) 951 Template = Context.getQualifiedTemplateName(SS.getScopeRep(), 952 /*TemplateKeyword=*/false, 953 TD); 954 else 955 Template = TemplateName(TD); 956 } 957 958 if (IsFunctionTemplate) { 959 // Function templates always go through overload resolution, at which 960 // point we'll perform the various checks (e.g., accessibility) we need 961 // to based on which function we selected. 962 Result.suppressDiagnostics(); 963 964 return NameClassification::FunctionTemplate(Template); 965 } 966 967 return IsVarTemplate ? NameClassification::VarTemplate(Template) 968 : NameClassification::TypeTemplate(Template); 969 } 970 } 971 972 NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl(); 973 if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) { 974 DiagnoseUseOfDecl(Type, NameLoc); 975 MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false); 976 QualType T = Context.getTypeDeclType(Type); 977 if (SS.isNotEmpty()) 978 return buildNestedType(*this, SS, T, NameLoc); 979 return ParsedType::make(T); 980 } 981 982 ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl); 983 if (!Class) { 984 // FIXME: It's unfortunate that we don't have a Type node for handling this. 985 if (ObjCCompatibleAliasDecl *Alias = 986 dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl)) 987 Class = Alias->getClassInterface(); 988 } 989 990 if (Class) { 991 DiagnoseUseOfDecl(Class, NameLoc); 992 993 if (NextToken.is(tok::period)) { 994 // Interface. <something> is parsed as a property reference expression. 995 // Just return "unknown" as a fall-through for now. 996 Result.suppressDiagnostics(); 997 return NameClassification::Unknown(); 998 } 999 1000 QualType T = Context.getObjCInterfaceType(Class); 1001 return ParsedType::make(T); 1002 } 1003 1004 // We can have a type template here if we're classifying a template argument. 1005 if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl)) 1006 return NameClassification::TypeTemplate( 1007 TemplateName(cast<TemplateDecl>(FirstDecl))); 1008 1009 // Check for a tag type hidden by a non-type decl in a few cases where it 1010 // seems likely a type is wanted instead of the non-type that was found. 1011 bool NextIsOp = NextToken.is(tok::amp) || NextToken.is(tok::star); 1012 if ((NextToken.is(tok::identifier) || 1013 (NextIsOp && 1014 FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) && 1015 isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) { 1016 TypeDecl *Type = Result.getAsSingle<TypeDecl>(); 1017 DiagnoseUseOfDecl(Type, NameLoc); 1018 QualType T = Context.getTypeDeclType(Type); 1019 if (SS.isNotEmpty()) 1020 return buildNestedType(*this, SS, T, NameLoc); 1021 return ParsedType::make(T); 1022 } 1023 1024 if (FirstDecl->isCXXClassMember()) 1025 return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result, 1026 nullptr); 1027 1028 bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren)); 1029 return BuildDeclarationNameExpr(SS, Result, ADL); 1030 } 1031 1032 // Determines the context to return to after temporarily entering a 1033 // context. This depends in an unnecessarily complicated way on the 1034 // exact ordering of callbacks from the parser. 1035 DeclContext *Sema::getContainingDC(DeclContext *DC) { 1036 1037 // Functions defined inline within classes aren't parsed until we've 1038 // finished parsing the top-level class, so the top-level class is 1039 // the context we'll need to return to. 1040 // A Lambda call operator whose parent is a class must not be treated 1041 // as an inline member function. A Lambda can be used legally 1042 // either as an in-class member initializer or a default argument. These 1043 // are parsed once the class has been marked complete and so the containing 1044 // context would be the nested class (when the lambda is defined in one); 1045 // If the class is not complete, then the lambda is being used in an 1046 // ill-formed fashion (such as to specify the width of a bit-field, or 1047 // in an array-bound) - in which case we still want to return the 1048 // lexically containing DC (which could be a nested class). 1049 if (isa<FunctionDecl>(DC) && !isLambdaCallOperator(DC)) { 1050 DC = DC->getLexicalParent(); 1051 1052 // A function not defined within a class will always return to its 1053 // lexical context. 1054 if (!isa<CXXRecordDecl>(DC)) 1055 return DC; 1056 1057 // A C++ inline method/friend is parsed *after* the topmost class 1058 // it was declared in is fully parsed ("complete"); the topmost 1059 // class is the context we need to return to. 1060 while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent())) 1061 DC = RD; 1062 1063 // Return the declaration context of the topmost class the inline method is 1064 // declared in. 1065 return DC; 1066 } 1067 1068 return DC->getLexicalParent(); 1069 } 1070 1071 void Sema::PushDeclContext(Scope *S, DeclContext *DC) { 1072 assert(getContainingDC(DC) == CurContext && 1073 "The next DeclContext should be lexically contained in the current one."); 1074 CurContext = DC; 1075 S->setEntity(DC); 1076 } 1077 1078 void Sema::PopDeclContext() { 1079 assert(CurContext && "DeclContext imbalance!"); 1080 1081 CurContext = getContainingDC(CurContext); 1082 assert(CurContext && "Popped translation unit!"); 1083 } 1084 1085 /// EnterDeclaratorContext - Used when we must lookup names in the context 1086 /// of a declarator's nested name specifier. 1087 /// 1088 void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) { 1089 // C++0x [basic.lookup.unqual]p13: 1090 // A name used in the definition of a static data member of class 1091 // X (after the qualified-id of the static member) is looked up as 1092 // if the name was used in a member function of X. 1093 // C++0x [basic.lookup.unqual]p14: 1094 // If a variable member of a namespace is defined outside of the 1095 // scope of its namespace then any name used in the definition of 1096 // the variable member (after the declarator-id) is looked up as 1097 // if the definition of the variable member occurred in its 1098 // namespace. 1099 // Both of these imply that we should push a scope whose context 1100 // is the semantic context of the declaration. We can't use 1101 // PushDeclContext here because that context is not necessarily 1102 // lexically contained in the current context. Fortunately, 1103 // the containing scope should have the appropriate information. 1104 1105 assert(!S->getEntity() && "scope already has entity"); 1106 1107 #ifndef NDEBUG 1108 Scope *Ancestor = S->getParent(); 1109 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 1110 assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch"); 1111 #endif 1112 1113 CurContext = DC; 1114 S->setEntity(DC); 1115 } 1116 1117 void Sema::ExitDeclaratorContext(Scope *S) { 1118 assert(S->getEntity() == CurContext && "Context imbalance!"); 1119 1120 // Switch back to the lexical context. The safety of this is 1121 // enforced by an assert in EnterDeclaratorContext. 1122 Scope *Ancestor = S->getParent(); 1123 while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent(); 1124 CurContext = Ancestor->getEntity(); 1125 1126 // We don't need to do anything with the scope, which is going to 1127 // disappear. 1128 } 1129 1130 1131 void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) { 1132 // We assume that the caller has already called 1133 // ActOnReenterTemplateScope so getTemplatedDecl() works. 1134 FunctionDecl *FD = D->getAsFunction(); 1135 if (!FD) 1136 return; 1137 1138 // Same implementation as PushDeclContext, but enters the context 1139 // from the lexical parent, rather than the top-level class. 1140 assert(CurContext == FD->getLexicalParent() && 1141 "The next DeclContext should be lexically contained in the current one."); 1142 CurContext = FD; 1143 S->setEntity(CurContext); 1144 1145 for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) { 1146 ParmVarDecl *Param = FD->getParamDecl(P); 1147 // If the parameter has an identifier, then add it to the scope 1148 if (Param->getIdentifier()) { 1149 S->AddDecl(Param); 1150 IdResolver.AddDecl(Param); 1151 } 1152 } 1153 } 1154 1155 1156 void Sema::ActOnExitFunctionContext() { 1157 // Same implementation as PopDeclContext, but returns to the lexical parent, 1158 // rather than the top-level class. 1159 assert(CurContext && "DeclContext imbalance!"); 1160 CurContext = CurContext->getLexicalParent(); 1161 assert(CurContext && "Popped translation unit!"); 1162 } 1163 1164 1165 /// \brief Determine whether we allow overloading of the function 1166 /// PrevDecl with another declaration. 1167 /// 1168 /// This routine determines whether overloading is possible, not 1169 /// whether some new function is actually an overload. It will return 1170 /// true in C++ (where we can always provide overloads) or, as an 1171 /// extension, in C when the previous function is already an 1172 /// overloaded function declaration or has the "overloadable" 1173 /// attribute. 1174 static bool AllowOverloadingOfFunction(LookupResult &Previous, 1175 ASTContext &Context) { 1176 if (Context.getLangOpts().CPlusPlus) 1177 return true; 1178 1179 if (Previous.getResultKind() == LookupResult::FoundOverloaded) 1180 return true; 1181 1182 return (Previous.getResultKind() == LookupResult::Found 1183 && Previous.getFoundDecl()->hasAttr<OverloadableAttr>()); 1184 } 1185 1186 /// Add this decl to the scope shadowed decl chains. 1187 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) { 1188 // Move up the scope chain until we find the nearest enclosing 1189 // non-transparent context. The declaration will be introduced into this 1190 // scope. 1191 while (S->getEntity() && S->getEntity()->isTransparentContext()) 1192 S = S->getParent(); 1193 1194 // Add scoped declarations into their context, so that they can be 1195 // found later. Declarations without a context won't be inserted 1196 // into any context. 1197 if (AddToContext) 1198 CurContext->addDecl(D); 1199 1200 // Out-of-line definitions shouldn't be pushed into scope in C++, unless they 1201 // are function-local declarations. 1202 if (getLangOpts().CPlusPlus && D->isOutOfLine() && 1203 !D->getDeclContext()->getRedeclContext()->Equals( 1204 D->getLexicalDeclContext()->getRedeclContext()) && 1205 !D->getLexicalDeclContext()->isFunctionOrMethod()) 1206 return; 1207 1208 // Template instantiations should also not be pushed into scope. 1209 if (isa<FunctionDecl>(D) && 1210 cast<FunctionDecl>(D)->isFunctionTemplateSpecialization()) 1211 return; 1212 1213 // If this replaces anything in the current scope, 1214 IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()), 1215 IEnd = IdResolver.end(); 1216 for (; I != IEnd; ++I) { 1217 if (S->isDeclScope(*I) && D->declarationReplaces(*I)) { 1218 S->RemoveDecl(*I); 1219 IdResolver.RemoveDecl(*I); 1220 1221 // Should only need to replace one decl. 1222 break; 1223 } 1224 } 1225 1226 S->AddDecl(D); 1227 1228 if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) { 1229 // Implicitly-generated labels may end up getting generated in an order that 1230 // isn't strictly lexical, which breaks name lookup. Be careful to insert 1231 // the label at the appropriate place in the identifier chain. 1232 for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) { 1233 DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext(); 1234 if (IDC == CurContext) { 1235 if (!S->isDeclScope(*I)) 1236 continue; 1237 } else if (IDC->Encloses(CurContext)) 1238 break; 1239 } 1240 1241 IdResolver.InsertDeclAfter(I, D); 1242 } else { 1243 IdResolver.AddDecl(D); 1244 } 1245 } 1246 1247 void Sema::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) { 1248 if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope) 1249 TUScope->AddDecl(D); 1250 } 1251 1252 bool Sema::isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S, 1253 bool AllowInlineNamespace) { 1254 return IdResolver.isDeclInScope(D, Ctx, S, AllowInlineNamespace); 1255 } 1256 1257 Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) { 1258 DeclContext *TargetDC = DC->getPrimaryContext(); 1259 do { 1260 if (DeclContext *ScopeDC = S->getEntity()) 1261 if (ScopeDC->getPrimaryContext() == TargetDC) 1262 return S; 1263 } while ((S = S->getParent())); 1264 1265 return nullptr; 1266 } 1267 1268 static bool isOutOfScopePreviousDeclaration(NamedDecl *, 1269 DeclContext*, 1270 ASTContext&); 1271 1272 /// Filters out lookup results that don't fall within the given scope 1273 /// as determined by isDeclInScope. 1274 void Sema::FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, 1275 bool ConsiderLinkage, 1276 bool AllowInlineNamespace) { 1277 LookupResult::Filter F = R.makeFilter(); 1278 while (F.hasNext()) { 1279 NamedDecl *D = F.next(); 1280 1281 if (isDeclInScope(D, Ctx, S, AllowInlineNamespace)) 1282 continue; 1283 1284 if (ConsiderLinkage && isOutOfScopePreviousDeclaration(D, Ctx, Context)) 1285 continue; 1286 1287 F.erase(); 1288 } 1289 1290 F.done(); 1291 } 1292 1293 static bool isUsingDecl(NamedDecl *D) { 1294 return isa<UsingShadowDecl>(D) || 1295 isa<UnresolvedUsingTypenameDecl>(D) || 1296 isa<UnresolvedUsingValueDecl>(D); 1297 } 1298 1299 /// Removes using shadow declarations from the lookup results. 1300 static void RemoveUsingDecls(LookupResult &R) { 1301 LookupResult::Filter F = R.makeFilter(); 1302 while (F.hasNext()) 1303 if (isUsingDecl(F.next())) 1304 F.erase(); 1305 1306 F.done(); 1307 } 1308 1309 /// \brief Check for this common pattern: 1310 /// @code 1311 /// class S { 1312 /// S(const S&); // DO NOT IMPLEMENT 1313 /// void operator=(const S&); // DO NOT IMPLEMENT 1314 /// }; 1315 /// @endcode 1316 static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) { 1317 // FIXME: Should check for private access too but access is set after we get 1318 // the decl here. 1319 if (D->doesThisDeclarationHaveABody()) 1320 return false; 1321 1322 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 1323 return CD->isCopyConstructor(); 1324 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) 1325 return Method->isCopyAssignmentOperator(); 1326 return false; 1327 } 1328 1329 // We need this to handle 1330 // 1331 // typedef struct { 1332 // void *foo() { return 0; } 1333 // } A; 1334 // 1335 // When we see foo we don't know if after the typedef we will get 'A' or '*A' 1336 // for example. If 'A', foo will have external linkage. If we have '*A', 1337 // foo will have no linkage. Since we can't know until we get to the end 1338 // of the typedef, this function finds out if D might have non-external linkage. 1339 // Callers should verify at the end of the TU if it D has external linkage or 1340 // not. 1341 bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) { 1342 const DeclContext *DC = D->getDeclContext(); 1343 while (!DC->isTranslationUnit()) { 1344 if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){ 1345 if (!RD->hasNameForLinkage()) 1346 return true; 1347 } 1348 DC = DC->getParent(); 1349 } 1350 1351 return !D->isExternallyVisible(); 1352 } 1353 1354 // FIXME: This needs to be refactored; some other isInMainFile users want 1355 // these semantics. 1356 static bool isMainFileLoc(const Sema &S, SourceLocation Loc) { 1357 if (S.TUKind != TU_Complete) 1358 return false; 1359 return S.SourceMgr.isInMainFile(Loc); 1360 } 1361 1362 bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const { 1363 assert(D); 1364 1365 if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>()) 1366 return false; 1367 1368 // Ignore all entities declared within templates, and out-of-line definitions 1369 // of members of class templates. 1370 if (D->getDeclContext()->isDependentContext() || 1371 D->getLexicalDeclContext()->isDependentContext()) 1372 return false; 1373 1374 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1375 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1376 return false; 1377 1378 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 1379 if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD)) 1380 return false; 1381 } else { 1382 // 'static inline' functions are defined in headers; don't warn. 1383 if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation())) 1384 return false; 1385 } 1386 1387 if (FD->doesThisDeclarationHaveABody() && 1388 Context.DeclMustBeEmitted(FD)) 1389 return false; 1390 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1391 // Constants and utility variables are defined in headers with internal 1392 // linkage; don't warn. (Unlike functions, there isn't a convenient marker 1393 // like "inline".) 1394 if (!isMainFileLoc(*this, VD->getLocation())) 1395 return false; 1396 1397 if (Context.DeclMustBeEmitted(VD)) 1398 return false; 1399 1400 if (VD->isStaticDataMember() && 1401 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 1402 return false; 1403 } else { 1404 return false; 1405 } 1406 1407 // Only warn for unused decls internal to the translation unit. 1408 // FIXME: This seems like a bogus check; it suppresses -Wunused-function 1409 // for inline functions defined in the main source file, for instance. 1410 return mightHaveNonExternalLinkage(D); 1411 } 1412 1413 void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) { 1414 if (!D) 1415 return; 1416 1417 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1418 const FunctionDecl *First = FD->getFirstDecl(); 1419 if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1420 return; // First should already be in the vector. 1421 } 1422 1423 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1424 const VarDecl *First = VD->getFirstDecl(); 1425 if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First)) 1426 return; // First should already be in the vector. 1427 } 1428 1429 if (ShouldWarnIfUnusedFileScopedDecl(D)) 1430 UnusedFileScopedDecls.push_back(D); 1431 } 1432 1433 static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) { 1434 if (D->isInvalidDecl()) 1435 return false; 1436 1437 if (D->isReferenced() || D->isUsed() || D->hasAttr<UnusedAttr>() || 1438 D->hasAttr<ObjCPreciseLifetimeAttr>()) 1439 return false; 1440 1441 if (isa<LabelDecl>(D)) 1442 return true; 1443 1444 // Except for labels, we only care about unused decls that are local to 1445 // functions. 1446 bool WithinFunction = D->getDeclContext()->isFunctionOrMethod(); 1447 if (const auto *R = dyn_cast<CXXRecordDecl>(D->getDeclContext())) 1448 // For dependent types, the diagnostic is deferred. 1449 WithinFunction = 1450 WithinFunction || (R->isLocalClass() && !R->isDependentType()); 1451 if (!WithinFunction) 1452 return false; 1453 1454 if (isa<TypedefNameDecl>(D)) 1455 return true; 1456 1457 // White-list anything that isn't a local variable. 1458 if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D)) 1459 return false; 1460 1461 // Types of valid local variables should be complete, so this should succeed. 1462 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1463 1464 // White-list anything with an __attribute__((unused)) type. 1465 QualType Ty = VD->getType(); 1466 1467 // Only look at the outermost level of typedef. 1468 if (const TypedefType *TT = Ty->getAs<TypedefType>()) { 1469 if (TT->getDecl()->hasAttr<UnusedAttr>()) 1470 return false; 1471 } 1472 1473 // If we failed to complete the type for some reason, or if the type is 1474 // dependent, don't diagnose the variable. 1475 if (Ty->isIncompleteType() || Ty->isDependentType()) 1476 return false; 1477 1478 if (const TagType *TT = Ty->getAs<TagType>()) { 1479 const TagDecl *Tag = TT->getDecl(); 1480 if (Tag->hasAttr<UnusedAttr>()) 1481 return false; 1482 1483 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) { 1484 if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>()) 1485 return false; 1486 1487 if (const Expr *Init = VD->getInit()) { 1488 if (const ExprWithCleanups *Cleanups = 1489 dyn_cast<ExprWithCleanups>(Init)) 1490 Init = Cleanups->getSubExpr(); 1491 const CXXConstructExpr *Construct = 1492 dyn_cast<CXXConstructExpr>(Init); 1493 if (Construct && !Construct->isElidable()) { 1494 CXXConstructorDecl *CD = Construct->getConstructor(); 1495 if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>()) 1496 return false; 1497 } 1498 } 1499 } 1500 } 1501 1502 // TODO: __attribute__((unused)) templates? 1503 } 1504 1505 return true; 1506 } 1507 1508 static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, 1509 FixItHint &Hint) { 1510 if (isa<LabelDecl>(D)) { 1511 SourceLocation AfterColon = Lexer::findLocationAfterToken(D->getLocEnd(), 1512 tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), true); 1513 if (AfterColon.isInvalid()) 1514 return; 1515 Hint = FixItHint::CreateRemoval(CharSourceRange:: 1516 getCharRange(D->getLocStart(), AfterColon)); 1517 } 1518 return; 1519 } 1520 1521 void Sema::DiagnoseUnusedNestedTypedefs(const RecordDecl *D) { 1522 if (D->getTypeForDecl()->isDependentType()) 1523 return; 1524 1525 for (auto *TmpD : D->decls()) { 1526 if (const auto *T = dyn_cast<TypedefNameDecl>(TmpD)) 1527 DiagnoseUnusedDecl(T); 1528 else if(const auto *R = dyn_cast<RecordDecl>(TmpD)) 1529 DiagnoseUnusedNestedTypedefs(R); 1530 } 1531 } 1532 1533 /// DiagnoseUnusedDecl - Emit warnings about declarations that are not used 1534 /// unless they are marked attr(unused). 1535 void Sema::DiagnoseUnusedDecl(const NamedDecl *D) { 1536 if (!ShouldDiagnoseUnusedDecl(D)) 1537 return; 1538 1539 if (auto *TD = dyn_cast<TypedefNameDecl>(D)) { 1540 // typedefs can be referenced later on, so the diagnostics are emitted 1541 // at end-of-translation-unit. 1542 UnusedLocalTypedefNameCandidates.insert(TD); 1543 return; 1544 } 1545 1546 FixItHint Hint; 1547 GenerateFixForUnusedDecl(D, Context, Hint); 1548 1549 unsigned DiagID; 1550 if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable()) 1551 DiagID = diag::warn_unused_exception_param; 1552 else if (isa<LabelDecl>(D)) 1553 DiagID = diag::warn_unused_label; 1554 else 1555 DiagID = diag::warn_unused_variable; 1556 1557 Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint; 1558 } 1559 1560 static void CheckPoppedLabel(LabelDecl *L, Sema &S) { 1561 // Verify that we have no forward references left. If so, there was a goto 1562 // or address of a label taken, but no definition of it. Label fwd 1563 // definitions are indicated with a null substmt which is also not a resolved 1564 // MS inline assembly label name. 1565 bool Diagnose = false; 1566 if (L->isMSAsmLabel()) 1567 Diagnose = !L->isResolvedMSAsmLabel(); 1568 else 1569 Diagnose = L->getStmt() == nullptr; 1570 if (Diagnose) 1571 S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName(); 1572 } 1573 1574 void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { 1575 S->mergeNRVOIntoParent(); 1576 1577 if (S->decl_empty()) return; 1578 assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) && 1579 "Scope shouldn't contain decls!"); 1580 1581 for (auto *TmpD : S->decls()) { 1582 assert(TmpD && "This decl didn't get pushed??"); 1583 1584 assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?"); 1585 NamedDecl *D = cast<NamedDecl>(TmpD); 1586 1587 if (!D->getDeclName()) continue; 1588 1589 // Diagnose unused variables in this scope. 1590 if (!S->hasUnrecoverableErrorOccurred()) { 1591 DiagnoseUnusedDecl(D); 1592 if (const auto *RD = dyn_cast<RecordDecl>(D)) 1593 DiagnoseUnusedNestedTypedefs(RD); 1594 } 1595 1596 // If this was a forward reference to a label, verify it was defined. 1597 if (LabelDecl *LD = dyn_cast<LabelDecl>(D)) 1598 CheckPoppedLabel(LD, *this); 1599 1600 // Remove this name from our lexical scope. 1601 IdResolver.RemoveDecl(D); 1602 } 1603 } 1604 1605 /// \brief Look for an Objective-C class in the translation unit. 1606 /// 1607 /// \param Id The name of the Objective-C class we're looking for. If 1608 /// typo-correction fixes this name, the Id will be updated 1609 /// to the fixed name. 1610 /// 1611 /// \param IdLoc The location of the name in the translation unit. 1612 /// 1613 /// \param DoTypoCorrection If true, this routine will attempt typo correction 1614 /// if there is no class with the given name. 1615 /// 1616 /// \returns The declaration of the named Objective-C class, or NULL if the 1617 /// class could not be found. 1618 ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id, 1619 SourceLocation IdLoc, 1620 bool DoTypoCorrection) { 1621 // The third "scope" argument is 0 since we aren't enabling lazy built-in 1622 // creation from this context. 1623 NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName); 1624 1625 if (!IDecl && DoTypoCorrection) { 1626 // Perform typo correction at the given location, but only if we 1627 // find an Objective-C class name. 1628 if (TypoCorrection C = CorrectTypo( 1629 DeclarationNameInfo(Id, IdLoc), LookupOrdinaryName, TUScope, nullptr, 1630 llvm::make_unique<DeclFilterCCC<ObjCInterfaceDecl>>(), 1631 CTK_ErrorRecovery)) { 1632 diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id); 1633 IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>(); 1634 Id = IDecl->getIdentifier(); 1635 } 1636 } 1637 ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl); 1638 // This routine must always return a class definition, if any. 1639 if (Def && Def->getDefinition()) 1640 Def = Def->getDefinition(); 1641 return Def; 1642 } 1643 1644 /// getNonFieldDeclScope - Retrieves the innermost scope, starting 1645 /// from S, where a non-field would be declared. This routine copes 1646 /// with the difference between C and C++ scoping rules in structs and 1647 /// unions. For example, the following code is well-formed in C but 1648 /// ill-formed in C++: 1649 /// @code 1650 /// struct S6 { 1651 /// enum { BAR } e; 1652 /// }; 1653 /// 1654 /// void test_S6() { 1655 /// struct S6 a; 1656 /// a.e = BAR; 1657 /// } 1658 /// @endcode 1659 /// For the declaration of BAR, this routine will return a different 1660 /// scope. The scope S will be the scope of the unnamed enumeration 1661 /// within S6. In C++, this routine will return the scope associated 1662 /// with S6, because the enumeration's scope is a transparent 1663 /// context but structures can contain non-field names. In C, this 1664 /// routine will return the translation unit scope, since the 1665 /// enumeration's scope is a transparent context and structures cannot 1666 /// contain non-field names. 1667 Scope *Sema::getNonFieldDeclScope(Scope *S) { 1668 while (((S->getFlags() & Scope::DeclScope) == 0) || 1669 (S->getEntity() && S->getEntity()->isTransparentContext()) || 1670 (S->isClassScope() && !getLangOpts().CPlusPlus)) 1671 S = S->getParent(); 1672 return S; 1673 } 1674 1675 /// \brief Looks up the declaration of "struct objc_super" and 1676 /// saves it for later use in building builtin declaration of 1677 /// objc_msgSendSuper and objc_msgSendSuper_stret. If no such 1678 /// pre-existing declaration exists no action takes place. 1679 static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S, 1680 IdentifierInfo *II) { 1681 if (!II->isStr("objc_msgSendSuper")) 1682 return; 1683 ASTContext &Context = ThisSema.Context; 1684 1685 LookupResult Result(ThisSema, &Context.Idents.get("objc_super"), 1686 SourceLocation(), Sema::LookupTagName); 1687 ThisSema.LookupName(Result, S); 1688 if (Result.getResultKind() == LookupResult::Found) 1689 if (const TagDecl *TD = Result.getAsSingle<TagDecl>()) 1690 Context.setObjCSuperType(Context.getTagDeclType(TD)); 1691 } 1692 1693 static StringRef getHeaderName(ASTContext::GetBuiltinTypeError Error) { 1694 switch (Error) { 1695 case ASTContext::GE_None: 1696 return ""; 1697 case ASTContext::GE_Missing_stdio: 1698 return "stdio.h"; 1699 case ASTContext::GE_Missing_setjmp: 1700 return "setjmp.h"; 1701 case ASTContext::GE_Missing_ucontext: 1702 return "ucontext.h"; 1703 } 1704 llvm_unreachable("unhandled error kind"); 1705 } 1706 1707 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at 1708 /// file scope. lazily create a decl for it. ForRedeclaration is true 1709 /// if we're creating this built-in in anticipation of redeclaring the 1710 /// built-in. 1711 NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, 1712 Scope *S, bool ForRedeclaration, 1713 SourceLocation Loc) { 1714 LookupPredefedObjCSuperType(*this, S, II); 1715 1716 ASTContext::GetBuiltinTypeError Error; 1717 QualType R = Context.GetBuiltinType(ID, Error); 1718 if (Error) { 1719 if (ForRedeclaration) 1720 Diag(Loc, diag::warn_implicit_decl_requires_sysheader) 1721 << getHeaderName(Error) 1722 << Context.BuiltinInfo.GetName(ID); 1723 return nullptr; 1724 } 1725 1726 if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(ID)) { 1727 Diag(Loc, diag::ext_implicit_lib_function_decl) 1728 << Context.BuiltinInfo.GetName(ID) 1729 << R; 1730 if (Context.BuiltinInfo.getHeaderName(ID) && 1731 !Diags.isIgnored(diag::ext_implicit_lib_function_decl, Loc)) 1732 Diag(Loc, diag::note_include_header_or_declare) 1733 << Context.BuiltinInfo.getHeaderName(ID) 1734 << Context.BuiltinInfo.GetName(ID); 1735 } 1736 1737 DeclContext *Parent = Context.getTranslationUnitDecl(); 1738 if (getLangOpts().CPlusPlus) { 1739 LinkageSpecDecl *CLinkageDecl = 1740 LinkageSpecDecl::Create(Context, Parent, Loc, Loc, 1741 LinkageSpecDecl::lang_c, false); 1742 CLinkageDecl->setImplicit(); 1743 Parent->addDecl(CLinkageDecl); 1744 Parent = CLinkageDecl; 1745 } 1746 1747 FunctionDecl *New = FunctionDecl::Create(Context, 1748 Parent, 1749 Loc, Loc, II, R, /*TInfo=*/nullptr, 1750 SC_Extern, 1751 false, 1752 /*hasPrototype=*/true); 1753 New->setImplicit(); 1754 1755 // Create Decl objects for each parameter, adding them to the 1756 // FunctionDecl. 1757 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) { 1758 SmallVector<ParmVarDecl*, 16> Params; 1759 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) { 1760 ParmVarDecl *parm = 1761 ParmVarDecl::Create(Context, New, SourceLocation(), SourceLocation(), 1762 nullptr, FT->getParamType(i), /*TInfo=*/nullptr, 1763 SC_None, nullptr); 1764 parm->setScopeInfo(0, i); 1765 Params.push_back(parm); 1766 } 1767 New->setParams(Params); 1768 } 1769 1770 AddKnownFunctionAttributes(New); 1771 RegisterLocallyScopedExternCDecl(New, S); 1772 1773 // TUScope is the translation-unit scope to insert this function into. 1774 // FIXME: This is hideous. We need to teach PushOnScopeChains to 1775 // relate Scopes to DeclContexts, and probably eliminate CurContext 1776 // entirely, but we're not there yet. 1777 DeclContext *SavedContext = CurContext; 1778 CurContext = Parent; 1779 PushOnScopeChains(New, TUScope); 1780 CurContext = SavedContext; 1781 return New; 1782 } 1783 1784 /// \brief Filter out any previous declarations that the given declaration 1785 /// should not consider because they are not permitted to conflict, e.g., 1786 /// because they come from hidden sub-modules and do not refer to the same 1787 /// entity. 1788 static void filterNonConflictingPreviousDecls(ASTContext &context, 1789 NamedDecl *decl, 1790 LookupResult &previous){ 1791 // This is only interesting when modules are enabled. 1792 if (!context.getLangOpts().Modules) 1793 return; 1794 1795 // Empty sets are uninteresting. 1796 if (previous.empty()) 1797 return; 1798 1799 LookupResult::Filter filter = previous.makeFilter(); 1800 while (filter.hasNext()) { 1801 NamedDecl *old = filter.next(); 1802 1803 // Non-hidden declarations are never ignored. 1804 if (!old->isHidden()) 1805 continue; 1806 1807 if (!old->isExternallyVisible()) 1808 filter.erase(); 1809 } 1810 1811 filter.done(); 1812 } 1813 1814 /// Typedef declarations don't have linkage, but they still denote the same 1815 /// entity if their types are the same. 1816 /// FIXME: This is notionally doing the same thing as ASTReaderDecl's 1817 /// isSameEntity. 1818 static void filterNonConflictingPreviousTypedefDecls(ASTContext &Context, 1819 TypedefNameDecl *Decl, 1820 LookupResult &Previous) { 1821 // This is only interesting when modules are enabled. 1822 if (!Context.getLangOpts().Modules) 1823 return; 1824 1825 // Empty sets are uninteresting. 1826 if (Previous.empty()) 1827 return; 1828 1829 LookupResult::Filter Filter = Previous.makeFilter(); 1830 while (Filter.hasNext()) { 1831 NamedDecl *Old = Filter.next(); 1832 1833 // Non-hidden declarations are never ignored. 1834 if (!Old->isHidden()) 1835 continue; 1836 1837 // Declarations of the same entity are not ignored, even if they have 1838 // different linkages. 1839 if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) { 1840 if (Context.hasSameType(OldTD->getUnderlyingType(), 1841 Decl->getUnderlyingType())) 1842 continue; 1843 1844 // If both declarations give a tag declaration a typedef name for linkage 1845 // purposes, then they declare the same entity. 1846 if (OldTD->getAnonDeclWithTypedefName() && 1847 Decl->getAnonDeclWithTypedefName()) 1848 continue; 1849 } 1850 1851 if (!Old->isExternallyVisible()) 1852 Filter.erase(); 1853 } 1854 1855 Filter.done(); 1856 } 1857 1858 bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) { 1859 QualType OldType; 1860 if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old)) 1861 OldType = OldTypedef->getUnderlyingType(); 1862 else 1863 OldType = Context.getTypeDeclType(Old); 1864 QualType NewType = New->getUnderlyingType(); 1865 1866 if (NewType->isVariablyModifiedType()) { 1867 // Must not redefine a typedef with a variably-modified type. 1868 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 1869 Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef) 1870 << Kind << NewType; 1871 if (Old->getLocation().isValid()) 1872 Diag(Old->getLocation(), diag::note_previous_definition); 1873 New->setInvalidDecl(); 1874 return true; 1875 } 1876 1877 if (OldType != NewType && 1878 !OldType->isDependentType() && 1879 !NewType->isDependentType() && 1880 !Context.hasSameType(OldType, NewType)) { 1881 int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0; 1882 Diag(New->getLocation(), diag::err_redefinition_different_typedef) 1883 << Kind << NewType << OldType; 1884 if (Old->getLocation().isValid()) 1885 Diag(Old->getLocation(), diag::note_previous_definition); 1886 New->setInvalidDecl(); 1887 return true; 1888 } 1889 return false; 1890 } 1891 1892 /// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the 1893 /// same name and scope as a previous declaration 'Old'. Figure out 1894 /// how to resolve this situation, merging decls or emitting 1895 /// diagnostics as appropriate. If there was an error, set New to be invalid. 1896 /// 1897 void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) { 1898 // If the new decl is known invalid already, don't bother doing any 1899 // merging checks. 1900 if (New->isInvalidDecl()) return; 1901 1902 // Allow multiple definitions for ObjC built-in typedefs. 1903 // FIXME: Verify the underlying types are equivalent! 1904 if (getLangOpts().ObjC1) { 1905 const IdentifierInfo *TypeID = New->getIdentifier(); 1906 switch (TypeID->getLength()) { 1907 default: break; 1908 case 2: 1909 { 1910 if (!TypeID->isStr("id")) 1911 break; 1912 QualType T = New->getUnderlyingType(); 1913 if (!T->isPointerType()) 1914 break; 1915 if (!T->isVoidPointerType()) { 1916 QualType PT = T->getAs<PointerType>()->getPointeeType(); 1917 if (!PT->isStructureType()) 1918 break; 1919 } 1920 Context.setObjCIdRedefinitionType(T); 1921 // Install the built-in type for 'id', ignoring the current definition. 1922 New->setTypeForDecl(Context.getObjCIdType().getTypePtr()); 1923 return; 1924 } 1925 case 5: 1926 if (!TypeID->isStr("Class")) 1927 break; 1928 Context.setObjCClassRedefinitionType(New->getUnderlyingType()); 1929 // Install the built-in type for 'Class', ignoring the current definition. 1930 New->setTypeForDecl(Context.getObjCClassType().getTypePtr()); 1931 return; 1932 case 3: 1933 if (!TypeID->isStr("SEL")) 1934 break; 1935 Context.setObjCSelRedefinitionType(New->getUnderlyingType()); 1936 // Install the built-in type for 'SEL', ignoring the current definition. 1937 New->setTypeForDecl(Context.getObjCSelType().getTypePtr()); 1938 return; 1939 } 1940 // Fall through - the typedef name was not a builtin type. 1941 } 1942 1943 // Verify the old decl was also a type. 1944 TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>(); 1945 if (!Old) { 1946 Diag(New->getLocation(), diag::err_redefinition_different_kind) 1947 << New->getDeclName(); 1948 1949 NamedDecl *OldD = OldDecls.getRepresentativeDecl(); 1950 if (OldD->getLocation().isValid()) 1951 Diag(OldD->getLocation(), diag::note_previous_definition); 1952 1953 return New->setInvalidDecl(); 1954 } 1955 1956 // If the old declaration is invalid, just give up here. 1957 if (Old->isInvalidDecl()) 1958 return New->setInvalidDecl(); 1959 1960 if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) { 1961 auto *OldTag = OldTD->getAnonDeclWithTypedefName(); 1962 auto *NewTag = New->getAnonDeclWithTypedefName(); 1963 NamedDecl *Hidden = nullptr; 1964 if (getLangOpts().CPlusPlus && OldTag && NewTag && 1965 OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() && 1966 !hasVisibleDefinition(OldTag, &Hidden)) { 1967 // There is a definition of this tag, but it is not visible. Use it 1968 // instead of our tag. 1969 New->setTypeForDecl(OldTD->getTypeForDecl()); 1970 if (OldTD->isModed()) 1971 New->setModedTypeSourceInfo(OldTD->getTypeSourceInfo(), 1972 OldTD->getUnderlyingType()); 1973 else 1974 New->setTypeSourceInfo(OldTD->getTypeSourceInfo()); 1975 1976 // Make the old tag definition visible. 1977 if (auto *Listener = getASTMutationListener()) 1978 Listener->RedefinedHiddenDefinition(Hidden, NewTag->getLocation()); 1979 Hidden->setHidden(false); 1980 } 1981 } 1982 1983 // If the typedef types are not identical, reject them in all languages and 1984 // with any extensions enabled. 1985 if (isIncompatibleTypedef(Old, New)) 1986 return; 1987 1988 // The types match. Link up the redeclaration chain and merge attributes if 1989 // the old declaration was a typedef. 1990 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) { 1991 New->setPreviousDecl(Typedef); 1992 mergeDeclAttributes(New, Old); 1993 } 1994 1995 if (getLangOpts().MicrosoftExt) 1996 return; 1997 1998 if (getLangOpts().CPlusPlus) { 1999 // C++ [dcl.typedef]p2: 2000 // In a given non-class scope, a typedef specifier can be used to 2001 // redefine the name of any type declared in that scope to refer 2002 // to the type to which it already refers. 2003 if (!isa<CXXRecordDecl>(CurContext)) 2004 return; 2005 2006 // C++0x [dcl.typedef]p4: 2007 // In a given class scope, a typedef specifier can be used to redefine 2008 // any class-name declared in that scope that is not also a typedef-name 2009 // to refer to the type to which it already refers. 2010 // 2011 // This wording came in via DR424, which was a correction to the 2012 // wording in DR56, which accidentally banned code like: 2013 // 2014 // struct S { 2015 // typedef struct A { } A; 2016 // }; 2017 // 2018 // in the C++03 standard. We implement the C++0x semantics, which 2019 // allow the above but disallow 2020 // 2021 // struct S { 2022 // typedef int I; 2023 // typedef int I; 2024 // }; 2025 // 2026 // since that was the intent of DR56. 2027 if (!isa<TypedefNameDecl>(Old)) 2028 return; 2029 2030 Diag(New->getLocation(), diag::err_redefinition) 2031 << New->getDeclName(); 2032 Diag(Old->getLocation(), diag::note_previous_definition); 2033 return New->setInvalidDecl(); 2034 } 2035 2036 // Modules always permit redefinition of typedefs, as does C11. 2037 if (getLangOpts().Modules || getLangOpts().C11) 2038 return; 2039 2040 // If we have a redefinition of a typedef in C, emit a warning. This warning 2041 // is normally mapped to an error, but can be controlled with 2042 // -Wtypedef-redefinition. If either the original or the redefinition is 2043 // in a system header, don't emit this for compatibility with GCC. 2044 if (getDiagnostics().getSuppressSystemWarnings() && 2045 (Context.getSourceManager().isInSystemHeader(Old->getLocation()) || 2046 Context.getSourceManager().isInSystemHeader(New->getLocation()))) 2047 return; 2048 2049 Diag(New->getLocation(), diag::ext_redefinition_of_typedef) 2050 << New->getDeclName(); 2051 Diag(Old->getLocation(), diag::note_previous_definition); 2052 } 2053 2054 /// DeclhasAttr - returns true if decl Declaration already has the target 2055 /// attribute. 2056 static bool DeclHasAttr(const Decl *D, const Attr *A) { 2057 const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A); 2058 const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A); 2059 for (const auto *i : D->attrs()) 2060 if (i->getKind() == A->getKind()) { 2061 if (Ann) { 2062 if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation()) 2063 return true; 2064 continue; 2065 } 2066 // FIXME: Don't hardcode this check 2067 if (OA && isa<OwnershipAttr>(i)) 2068 return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind(); 2069 return true; 2070 } 2071 2072 return false; 2073 } 2074 2075 static bool isAttributeTargetADefinition(Decl *D) { 2076 if (VarDecl *VD = dyn_cast<VarDecl>(D)) 2077 return VD->isThisDeclarationADefinition(); 2078 if (TagDecl *TD = dyn_cast<TagDecl>(D)) 2079 return TD->isCompleteDefinition() || TD->isBeingDefined(); 2080 return true; 2081 } 2082 2083 /// Merge alignment attributes from \p Old to \p New, taking into account the 2084 /// special semantics of C11's _Alignas specifier and C++11's alignas attribute. 2085 /// 2086 /// \return \c true if any attributes were added to \p New. 2087 static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) { 2088 // Look for alignas attributes on Old, and pick out whichever attribute 2089 // specifies the strictest alignment requirement. 2090 AlignedAttr *OldAlignasAttr = nullptr; 2091 AlignedAttr *OldStrictestAlignAttr = nullptr; 2092 unsigned OldAlign = 0; 2093 for (auto *I : Old->specific_attrs<AlignedAttr>()) { 2094 // FIXME: We have no way of representing inherited dependent alignments 2095 // in a case like: 2096 // template<int A, int B> struct alignas(A) X; 2097 // template<int A, int B> struct alignas(B) X {}; 2098 // For now, we just ignore any alignas attributes which are not on the 2099 // definition in such a case. 2100 if (I->isAlignmentDependent()) 2101 return false; 2102 2103 if (I->isAlignas()) 2104 OldAlignasAttr = I; 2105 2106 unsigned Align = I->getAlignment(S.Context); 2107 if (Align > OldAlign) { 2108 OldAlign = Align; 2109 OldStrictestAlignAttr = I; 2110 } 2111 } 2112 2113 // Look for alignas attributes on New. 2114 AlignedAttr *NewAlignasAttr = nullptr; 2115 unsigned NewAlign = 0; 2116 for (auto *I : New->specific_attrs<AlignedAttr>()) { 2117 if (I->isAlignmentDependent()) 2118 return false; 2119 2120 if (I->isAlignas()) 2121 NewAlignasAttr = I; 2122 2123 unsigned Align = I->getAlignment(S.Context); 2124 if (Align > NewAlign) 2125 NewAlign = Align; 2126 } 2127 2128 if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) { 2129 // Both declarations have 'alignas' attributes. We require them to match. 2130 // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but 2131 // fall short. (If two declarations both have alignas, they must both match 2132 // every definition, and so must match each other if there is a definition.) 2133 2134 // If either declaration only contains 'alignas(0)' specifiers, then it 2135 // specifies the natural alignment for the type. 2136 if (OldAlign == 0 || NewAlign == 0) { 2137 QualType Ty; 2138 if (ValueDecl *VD = dyn_cast<ValueDecl>(New)) 2139 Ty = VD->getType(); 2140 else 2141 Ty = S.Context.getTagDeclType(cast<TagDecl>(New)); 2142 2143 if (OldAlign == 0) 2144 OldAlign = S.Context.getTypeAlign(Ty); 2145 if (NewAlign == 0) 2146 NewAlign = S.Context.getTypeAlign(Ty); 2147 } 2148 2149 if (OldAlign != NewAlign) { 2150 S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch) 2151 << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity() 2152 << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity(); 2153 S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration); 2154 } 2155 } 2156 2157 if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) { 2158 // C++11 [dcl.align]p6: 2159 // if any declaration of an entity has an alignment-specifier, 2160 // every defining declaration of that entity shall specify an 2161 // equivalent alignment. 2162 // C11 6.7.5/7: 2163 // If the definition of an object does not have an alignment 2164 // specifier, any other declaration of that object shall also 2165 // have no alignment specifier. 2166 S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition) 2167 << OldAlignasAttr; 2168 S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration) 2169 << OldAlignasAttr; 2170 } 2171 2172 bool AnyAdded = false; 2173 2174 // Ensure we have an attribute representing the strictest alignment. 2175 if (OldAlign > NewAlign) { 2176 AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context); 2177 Clone->setInherited(true); 2178 New->addAttr(Clone); 2179 AnyAdded = true; 2180 } 2181 2182 // Ensure we have an alignas attribute if the old declaration had one. 2183 if (OldAlignasAttr && !NewAlignasAttr && 2184 !(AnyAdded && OldStrictestAlignAttr->isAlignas())) { 2185 AlignedAttr *Clone = OldAlignasAttr->clone(S.Context); 2186 Clone->setInherited(true); 2187 New->addAttr(Clone); 2188 AnyAdded = true; 2189 } 2190 2191 return AnyAdded; 2192 } 2193 2194 static bool mergeDeclAttribute(Sema &S, NamedDecl *D, 2195 const InheritableAttr *Attr, bool Override) { 2196 InheritableAttr *NewAttr = nullptr; 2197 unsigned AttrSpellingListIndex = Attr->getSpellingListIndex(); 2198 if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr)) 2199 NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(), 2200 AA->getIntroduced(), AA->getDeprecated(), 2201 AA->getObsoleted(), AA->getUnavailable(), 2202 AA->getMessage(), Override, 2203 AttrSpellingListIndex); 2204 else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr)) 2205 NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(), 2206 AttrSpellingListIndex); 2207 else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr)) 2208 NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(), 2209 AttrSpellingListIndex); 2210 else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr)) 2211 NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(), 2212 AttrSpellingListIndex); 2213 else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr)) 2214 NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(), 2215 AttrSpellingListIndex); 2216 else if (const auto *FA = dyn_cast<FormatAttr>(Attr)) 2217 NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(), 2218 FA->getFormatIdx(), FA->getFirstArg(), 2219 AttrSpellingListIndex); 2220 else if (const auto *SA = dyn_cast<SectionAttr>(Attr)) 2221 NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(), 2222 AttrSpellingListIndex); 2223 else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr)) 2224 NewAttr = S.mergeMSInheritanceAttr(D, IA->getRange(), IA->getBestCase(), 2225 AttrSpellingListIndex, 2226 IA->getSemanticSpelling()); 2227 else if (const auto *AA = dyn_cast<AlwaysInlineAttr>(Attr)) 2228 NewAttr = S.mergeAlwaysInlineAttr(D, AA->getRange(), 2229 &S.Context.Idents.get(AA->getSpelling()), 2230 AttrSpellingListIndex); 2231 else if (const auto *MA = dyn_cast<MinSizeAttr>(Attr)) 2232 NewAttr = S.mergeMinSizeAttr(D, MA->getRange(), AttrSpellingListIndex); 2233 else if (const auto *OA = dyn_cast<OptimizeNoneAttr>(Attr)) 2234 NewAttr = S.mergeOptimizeNoneAttr(D, OA->getRange(), AttrSpellingListIndex); 2235 else if (isa<AlignedAttr>(Attr)) 2236 // AlignedAttrs are handled separately, because we need to handle all 2237 // such attributes on a declaration at the same time. 2238 NewAttr = nullptr; 2239 else if (isa<DeprecatedAttr>(Attr) && Override) 2240 NewAttr = nullptr; 2241 else if (Attr->duplicatesAllowed() || !DeclHasAttr(D, Attr)) 2242 NewAttr = cast<InheritableAttr>(Attr->clone(S.Context)); 2243 2244 if (NewAttr) { 2245 NewAttr->setInherited(true); 2246 D->addAttr(NewAttr); 2247 return true; 2248 } 2249 2250 return false; 2251 } 2252 2253 static const Decl *getDefinition(const Decl *D) { 2254 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) 2255 return TD->getDefinition(); 2256 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 2257 const VarDecl *Def = VD->getDefinition(); 2258 if (Def) 2259 return Def; 2260 return VD->getActingDefinition(); 2261 } 2262 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2263 const FunctionDecl* Def; 2264 if (FD->isDefined(Def)) 2265 return Def; 2266 } 2267 return nullptr; 2268 } 2269 2270 static bool hasAttribute(const Decl *D, attr::Kind Kind) { 2271 for (const auto *Attribute : D->attrs()) 2272 if (Attribute->getKind() == Kind) 2273 return true; 2274 return false; 2275 } 2276 2277 /// checkNewAttributesAfterDef - If we already have a definition, check that 2278 /// there are no new attributes in this declaration. 2279 static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) { 2280 if (!New->hasAttrs()) 2281 return; 2282 2283 const Decl *Def = getDefinition(Old); 2284 if (!Def || Def == New) 2285 return; 2286 2287 AttrVec &NewAttributes = New->getAttrs(); 2288 for (unsigned I = 0, E = NewAttributes.size(); I != E;) { 2289 const Attr *NewAttribute = NewAttributes[I]; 2290 2291 if (isa<AliasAttr>(NewAttribute)) { 2292 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) 2293 S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def)); 2294 else { 2295 VarDecl *VD = cast<VarDecl>(New); 2296 unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() == 2297 VarDecl::TentativeDefinition 2298 ? diag::err_alias_after_tentative 2299 : diag::err_redefinition; 2300 S.Diag(VD->getLocation(), Diag) << VD->getDeclName(); 2301 S.Diag(Def->getLocation(), diag::note_previous_definition); 2302 VD->setInvalidDecl(); 2303 } 2304 ++I; 2305 continue; 2306 } 2307 2308 if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) { 2309 // Tentative definitions are only interesting for the alias check above. 2310 if (VD->isThisDeclarationADefinition() != VarDecl::Definition) { 2311 ++I; 2312 continue; 2313 } 2314 } 2315 2316 if (hasAttribute(Def, NewAttribute->getKind())) { 2317 ++I; 2318 continue; // regular attr merging will take care of validating this. 2319 } 2320 2321 if (isa<C11NoReturnAttr>(NewAttribute)) { 2322 // C's _Noreturn is allowed to be added to a function after it is defined. 2323 ++I; 2324 continue; 2325 } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) { 2326 if (AA->isAlignas()) { 2327 // C++11 [dcl.align]p6: 2328 // if any declaration of an entity has an alignment-specifier, 2329 // every defining declaration of that entity shall specify an 2330 // equivalent alignment. 2331 // C11 6.7.5/7: 2332 // If the definition of an object does not have an alignment 2333 // specifier, any other declaration of that object shall also 2334 // have no alignment specifier. 2335 S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition) 2336 << AA; 2337 S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration) 2338 << AA; 2339 NewAttributes.erase(NewAttributes.begin() + I); 2340 --E; 2341 continue; 2342 } 2343 } 2344 2345 S.Diag(NewAttribute->getLocation(), 2346 diag::warn_attribute_precede_definition); 2347 S.Diag(Def->getLocation(), diag::note_previous_definition); 2348 NewAttributes.erase(NewAttributes.begin() + I); 2349 --E; 2350 } 2351 } 2352 2353 /// mergeDeclAttributes - Copy attributes from the Old decl to the New one. 2354 void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, 2355 AvailabilityMergeKind AMK) { 2356 if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) { 2357 UsedAttr *NewAttr = OldAttr->clone(Context); 2358 NewAttr->setInherited(true); 2359 New->addAttr(NewAttr); 2360 } 2361 2362 if (!Old->hasAttrs() && !New->hasAttrs()) 2363 return; 2364 2365 // attributes declared post-definition are currently ignored 2366 checkNewAttributesAfterDef(*this, New, Old); 2367 2368 if (!Old->hasAttrs()) 2369 return; 2370 2371 bool foundAny = New->hasAttrs(); 2372 2373 // Ensure that any moving of objects within the allocated map is done before 2374 // we process them. 2375 if (!foundAny) New->setAttrs(AttrVec()); 2376 2377 for (auto *I : Old->specific_attrs<InheritableAttr>()) { 2378 bool Override = false; 2379 // Ignore deprecated/unavailable/availability attributes if requested. 2380 if (isa<DeprecatedAttr>(I) || 2381 isa<UnavailableAttr>(I) || 2382 isa<AvailabilityAttr>(I)) { 2383 switch (AMK) { 2384 case AMK_None: 2385 continue; 2386 2387 case AMK_Redeclaration: 2388 break; 2389 2390 case AMK_Override: 2391 Override = true; 2392 break; 2393 } 2394 } 2395 2396 // Already handled. 2397 if (isa<UsedAttr>(I)) 2398 continue; 2399 2400 if (mergeDeclAttribute(*this, New, I, Override)) 2401 foundAny = true; 2402 } 2403 2404 if (mergeAlignedAttrs(*this, New, Old)) 2405 foundAny = true; 2406 2407 if (!foundAny) New->dropAttrs(); 2408 } 2409 2410 /// mergeParamDeclAttributes - Copy attributes from the old parameter 2411 /// to the new one. 2412 static void mergeParamDeclAttributes(ParmVarDecl *newDecl, 2413 const ParmVarDecl *oldDecl, 2414 Sema &S) { 2415 // C++11 [dcl.attr.depend]p2: 2416 // The first declaration of a function shall specify the 2417 // carries_dependency attribute for its declarator-id if any declaration 2418 // of the function specifies the carries_dependency attribute. 2419 const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>(); 2420 if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) { 2421 S.Diag(CDA->getLocation(), 2422 diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/; 2423 // Find the first declaration of the parameter. 2424 // FIXME: Should we build redeclaration chains for function parameters? 2425 const FunctionDecl *FirstFD = 2426 cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl(); 2427 const ParmVarDecl *FirstVD = 2428 FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex()); 2429 S.Diag(FirstVD->getLocation(), 2430 diag::note_carries_dependency_missing_first_decl) << 1/*Param*/; 2431 } 2432 2433 if (!oldDecl->hasAttrs()) 2434 return; 2435 2436 bool foundAny = newDecl->hasAttrs(); 2437 2438 // Ensure that any moving of objects within the allocated map is 2439 // done before we process them. 2440 if (!foundAny) newDecl->setAttrs(AttrVec()); 2441 2442 for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) { 2443 if (!DeclHasAttr(newDecl, I)) { 2444 InheritableAttr *newAttr = 2445 cast<InheritableParamAttr>(I->clone(S.Context)); 2446 newAttr->setInherited(true); 2447 newDecl->addAttr(newAttr); 2448 foundAny = true; 2449 } 2450 } 2451 2452 if (!foundAny) newDecl->dropAttrs(); 2453 } 2454 2455 namespace { 2456 2457 /// Used in MergeFunctionDecl to keep track of function parameters in 2458 /// C. 2459 struct GNUCompatibleParamWarning { 2460 ParmVarDecl *OldParm; 2461 ParmVarDecl *NewParm; 2462 QualType PromotedType; 2463 }; 2464 2465 } 2466 2467 /// getSpecialMember - get the special member enum for a method. 2468 Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) { 2469 if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) { 2470 if (Ctor->isDefaultConstructor()) 2471 return Sema::CXXDefaultConstructor; 2472 2473 if (Ctor->isCopyConstructor()) 2474 return Sema::CXXCopyConstructor; 2475 2476 if (Ctor->isMoveConstructor()) 2477 return Sema::CXXMoveConstructor; 2478 } else if (isa<CXXDestructorDecl>(MD)) { 2479 return Sema::CXXDestructor; 2480 } else if (MD->isCopyAssignmentOperator()) { 2481 return Sema::CXXCopyAssignment; 2482 } else if (MD->isMoveAssignmentOperator()) { 2483 return Sema::CXXMoveAssignment; 2484 } 2485 2486 return Sema::CXXInvalid; 2487 } 2488 2489 // Determine whether the previous declaration was a definition, implicit 2490 // declaration, or a declaration. 2491 template <typename T> 2492 static std::pair<diag::kind, SourceLocation> 2493 getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) { 2494 diag::kind PrevDiag; 2495 SourceLocation OldLocation = Old->getLocation(); 2496 if (Old->isThisDeclarationADefinition()) 2497 PrevDiag = diag::note_previous_definition; 2498 else if (Old->isImplicit()) { 2499 PrevDiag = diag::note_previous_implicit_declaration; 2500 if (OldLocation.isInvalid()) 2501 OldLocation = New->getLocation(); 2502 } else 2503 PrevDiag = diag::note_previous_declaration; 2504 return std::make_pair(PrevDiag, OldLocation); 2505 } 2506 2507 /// canRedefineFunction - checks if a function can be redefined. Currently, 2508 /// only extern inline functions can be redefined, and even then only in 2509 /// GNU89 mode. 2510 static bool canRedefineFunction(const FunctionDecl *FD, 2511 const LangOptions& LangOpts) { 2512 return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) && 2513 !LangOpts.CPlusPlus && 2514 FD->isInlineSpecified() && 2515 FD->getStorageClass() == SC_Extern); 2516 } 2517 2518 const AttributedType *Sema::getCallingConvAttributedType(QualType T) const { 2519 const AttributedType *AT = T->getAs<AttributedType>(); 2520 while (AT && !AT->isCallingConv()) 2521 AT = AT->getModifiedType()->getAs<AttributedType>(); 2522 return AT; 2523 } 2524 2525 template <typename T> 2526 static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) { 2527 const DeclContext *DC = Old->getDeclContext(); 2528 if (DC->isRecord()) 2529 return false; 2530 2531 LanguageLinkage OldLinkage = Old->getLanguageLinkage(); 2532 if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext()) 2533 return true; 2534 if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext()) 2535 return true; 2536 return false; 2537 } 2538 2539 /// MergeFunctionDecl - We just parsed a function 'New' from 2540 /// declarator D which has the same name and scope as a previous 2541 /// declaration 'Old'. Figure out how to resolve this situation, 2542 /// merging decls or emitting diagnostics as appropriate. 2543 /// 2544 /// In C++, New and Old must be declarations that are not 2545 /// overloaded. Use IsOverload to determine whether New and Old are 2546 /// overloaded, and to select the Old declaration that New should be 2547 /// merged with. 2548 /// 2549 /// Returns true if there was an error, false otherwise. 2550 bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, 2551 Scope *S, bool MergeTypeWithOld) { 2552 // Verify the old decl was also a function. 2553 FunctionDecl *Old = OldD->getAsFunction(); 2554 if (!Old) { 2555 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) { 2556 if (New->getFriendObjectKind()) { 2557 Diag(New->getLocation(), diag::err_using_decl_friend); 2558 Diag(Shadow->getTargetDecl()->getLocation(), 2559 diag::note_using_decl_target); 2560 Diag(Shadow->getUsingDecl()->getLocation(), 2561 diag::note_using_decl) << 0; 2562 return true; 2563 } 2564 2565 // C++11 [namespace.udecl]p14: 2566 // If a function declaration in namespace scope or block scope has the 2567 // same name and the same parameter-type-list as a function introduced 2568 // by a using-declaration, and the declarations do not declare the same 2569 // function, the program is ill-formed. 2570 2571 // Check whether the two declarations might declare the same function. 2572 Old = dyn_cast<FunctionDecl>(Shadow->getTargetDecl()); 2573 if (Old && 2574 !Old->getDeclContext()->getRedeclContext()->Equals( 2575 New->getDeclContext()->getRedeclContext()) && 2576 !(Old->isExternC() && New->isExternC())) 2577 Old = nullptr; 2578 2579 if (!Old) { 2580 Diag(New->getLocation(), diag::err_using_decl_conflict_reverse); 2581 Diag(Shadow->getTargetDecl()->getLocation(), 2582 diag::note_using_decl_target); 2583 Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0; 2584 return true; 2585 } 2586 OldD = Old; 2587 } else { 2588 Diag(New->getLocation(), diag::err_redefinition_different_kind) 2589 << New->getDeclName(); 2590 Diag(OldD->getLocation(), diag::note_previous_definition); 2591 return true; 2592 } 2593 } 2594 2595 // If the old declaration is invalid, just give up here. 2596 if (Old->isInvalidDecl()) 2597 return true; 2598 2599 diag::kind PrevDiag; 2600 SourceLocation OldLocation; 2601 std::tie(PrevDiag, OldLocation) = 2602 getNoteDiagForInvalidRedeclaration(Old, New); 2603 2604 // Don't complain about this if we're in GNU89 mode and the old function 2605 // is an extern inline function. 2606 // Don't complain about specializations. They are not supposed to have 2607 // storage classes. 2608 if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) && 2609 New->getStorageClass() == SC_Static && 2610 Old->hasExternalFormalLinkage() && 2611 !New->getTemplateSpecializationInfo() && 2612 !canRedefineFunction(Old, getLangOpts())) { 2613 if (getLangOpts().MicrosoftExt) { 2614 Diag(New->getLocation(), diag::ext_static_non_static) << New; 2615 Diag(OldLocation, PrevDiag); 2616 } else { 2617 Diag(New->getLocation(), diag::err_static_non_static) << New; 2618 Diag(OldLocation, PrevDiag); 2619 return true; 2620 } 2621 } 2622 2623 2624 // If a function is first declared with a calling convention, but is later 2625 // declared or defined without one, all following decls assume the calling 2626 // convention of the first. 2627 // 2628 // It's OK if a function is first declared without a calling convention, 2629 // but is later declared or defined with the default calling convention. 2630 // 2631 // To test if either decl has an explicit calling convention, we look for 2632 // AttributedType sugar nodes on the type as written. If they are missing or 2633 // were canonicalized away, we assume the calling convention was implicit. 2634 // 2635 // Note also that we DO NOT return at this point, because we still have 2636 // other tests to run. 2637 QualType OldQType = Context.getCanonicalType(Old->getType()); 2638 QualType NewQType = Context.getCanonicalType(New->getType()); 2639 const FunctionType *OldType = cast<FunctionType>(OldQType); 2640 const FunctionType *NewType = cast<FunctionType>(NewQType); 2641 FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo(); 2642 FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo(); 2643 bool RequiresAdjustment = false; 2644 2645 if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) { 2646 FunctionDecl *First = Old->getFirstDecl(); 2647 const FunctionType *FT = 2648 First->getType().getCanonicalType()->castAs<FunctionType>(); 2649 FunctionType::ExtInfo FI = FT->getExtInfo(); 2650 bool NewCCExplicit = getCallingConvAttributedType(New->getType()); 2651 if (!NewCCExplicit) { 2652 // Inherit the CC from the previous declaration if it was specified 2653 // there but not here. 2654 NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC()); 2655 RequiresAdjustment = true; 2656 } else { 2657 // Calling conventions aren't compatible, so complain. 2658 bool FirstCCExplicit = getCallingConvAttributedType(First->getType()); 2659 Diag(New->getLocation(), diag::err_cconv_change) 2660 << FunctionType::getNameForCallConv(NewTypeInfo.getCC()) 2661 << !FirstCCExplicit 2662 << (!FirstCCExplicit ? "" : 2663 FunctionType::getNameForCallConv(FI.getCC())); 2664 2665 // Put the note on the first decl, since it is the one that matters. 2666 Diag(First->getLocation(), diag::note_previous_declaration); 2667 return true; 2668 } 2669 } 2670 2671 // FIXME: diagnose the other way around? 2672 if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) { 2673 NewTypeInfo = NewTypeInfo.withNoReturn(true); 2674 RequiresAdjustment = true; 2675 } 2676 2677 // Merge regparm attribute. 2678 if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() || 2679 OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) { 2680 if (NewTypeInfo.getHasRegParm()) { 2681 Diag(New->getLocation(), diag::err_regparm_mismatch) 2682 << NewType->getRegParmType() 2683 << OldType->getRegParmType(); 2684 Diag(OldLocation, diag::note_previous_declaration); 2685 return true; 2686 } 2687 2688 NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm()); 2689 RequiresAdjustment = true; 2690 } 2691 2692 // Merge ns_returns_retained attribute. 2693 if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) { 2694 if (NewTypeInfo.getProducesResult()) { 2695 Diag(New->getLocation(), diag::err_returns_retained_mismatch); 2696 Diag(OldLocation, diag::note_previous_declaration); 2697 return true; 2698 } 2699 2700 NewTypeInfo = NewTypeInfo.withProducesResult(true); 2701 RequiresAdjustment = true; 2702 } 2703 2704 if (RequiresAdjustment) { 2705 const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>(); 2706 AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo); 2707 New->setType(QualType(AdjustedType, 0)); 2708 NewQType = Context.getCanonicalType(New->getType()); 2709 NewType = cast<FunctionType>(NewQType); 2710 } 2711 2712 // If this redeclaration makes the function inline, we may need to add it to 2713 // UndefinedButUsed. 2714 if (!Old->isInlined() && New->isInlined() && 2715 !New->hasAttr<GNUInlineAttr>() && 2716 (getLangOpts().CPlusPlus || !getLangOpts().GNUInline) && 2717 Old->isUsed(false) && 2718 !Old->isDefined() && !New->isThisDeclarationADefinition()) 2719 UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(), 2720 SourceLocation())); 2721 2722 // If this redeclaration makes it newly gnu_inline, we don't want to warn 2723 // about it. 2724 if (New->hasAttr<GNUInlineAttr>() && 2725 Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) { 2726 UndefinedButUsed.erase(Old->getCanonicalDecl()); 2727 } 2728 2729 if (getLangOpts().CPlusPlus) { 2730 // (C++98 13.1p2): 2731 // Certain function declarations cannot be overloaded: 2732 // -- Function declarations that differ only in the return type 2733 // cannot be overloaded. 2734 2735 // Go back to the type source info to compare the declared return types, 2736 // per C++1y [dcl.type.auto]p13: 2737 // Redeclarations or specializations of a function or function template 2738 // with a declared return type that uses a placeholder type shall also 2739 // use that placeholder, not a deduced type. 2740 QualType OldDeclaredReturnType = 2741 (Old->getTypeSourceInfo() 2742 ? Old->getTypeSourceInfo()->getType()->castAs<FunctionType>() 2743 : OldType)->getReturnType(); 2744 QualType NewDeclaredReturnType = 2745 (New->getTypeSourceInfo() 2746 ? New->getTypeSourceInfo()->getType()->castAs<FunctionType>() 2747 : NewType)->getReturnType(); 2748 QualType ResQT; 2749 if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) && 2750 !((NewQType->isDependentType() || OldQType->isDependentType()) && 2751 New->isLocalExternDecl())) { 2752 if (NewDeclaredReturnType->isObjCObjectPointerType() && 2753 OldDeclaredReturnType->isObjCObjectPointerType()) 2754 ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType); 2755 if (ResQT.isNull()) { 2756 if (New->isCXXClassMember() && New->isOutOfLine()) 2757 Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type) 2758 << New << New->getReturnTypeSourceRange(); 2759 else 2760 Diag(New->getLocation(), diag::err_ovl_diff_return_type) 2761 << New->getReturnTypeSourceRange(); 2762 Diag(OldLocation, PrevDiag) << Old << Old->getType() 2763 << Old->getReturnTypeSourceRange(); 2764 return true; 2765 } 2766 else 2767 NewQType = ResQT; 2768 } 2769 2770 QualType OldReturnType = OldType->getReturnType(); 2771 QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType(); 2772 if (OldReturnType != NewReturnType) { 2773 // If this function has a deduced return type and has already been 2774 // defined, copy the deduced value from the old declaration. 2775 AutoType *OldAT = Old->getReturnType()->getContainedAutoType(); 2776 if (OldAT && OldAT->isDeduced()) { 2777 New->setType( 2778 SubstAutoType(New->getType(), 2779 OldAT->isDependentType() ? Context.DependentTy 2780 : OldAT->getDeducedType())); 2781 NewQType = Context.getCanonicalType( 2782 SubstAutoType(NewQType, 2783 OldAT->isDependentType() ? Context.DependentTy 2784 : OldAT->getDeducedType())); 2785 } 2786 } 2787 2788 const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old); 2789 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New); 2790 if (OldMethod && NewMethod) { 2791 // Preserve triviality. 2792 NewMethod->setTrivial(OldMethod->isTrivial()); 2793 2794 // MSVC allows explicit template specialization at class scope: 2795 // 2 CXXMethodDecls referring to the same function will be injected. 2796 // We don't want a redeclaration error. 2797 bool IsClassScopeExplicitSpecialization = 2798 OldMethod->isFunctionTemplateSpecialization() && 2799 NewMethod->isFunctionTemplateSpecialization(); 2800 bool isFriend = NewMethod->getFriendObjectKind(); 2801 2802 if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() && 2803 !IsClassScopeExplicitSpecialization) { 2804 // -- Member function declarations with the same name and the 2805 // same parameter types cannot be overloaded if any of them 2806 // is a static member function declaration. 2807 if (OldMethod->isStatic() != NewMethod->isStatic()) { 2808 Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member); 2809 Diag(OldLocation, PrevDiag) << Old << Old->getType(); 2810 return true; 2811 } 2812 2813 // C++ [class.mem]p1: 2814 // [...] A member shall not be declared twice in the 2815 // member-specification, except that a nested class or member 2816 // class template can be declared and then later defined. 2817 if (ActiveTemplateInstantiations.empty()) { 2818 unsigned NewDiag; 2819 if (isa<CXXConstructorDecl>(OldMethod)) 2820 NewDiag = diag::err_constructor_redeclared; 2821 else if (isa<CXXDestructorDecl>(NewMethod)) 2822 NewDiag = diag::err_destructor_redeclared; 2823 else if (isa<CXXConversionDecl>(NewMethod)) 2824 NewDiag = diag::err_conv_function_redeclared; 2825 else 2826 NewDiag = diag::err_member_redeclared; 2827 2828 Diag(New->getLocation(), NewDiag); 2829 } else { 2830 Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation) 2831 << New << New->getType(); 2832 } 2833 Diag(OldLocation, PrevDiag) << Old << Old->getType(); 2834 return true; 2835 2836 // Complain if this is an explicit declaration of a special 2837 // member that was initially declared implicitly. 2838 // 2839 // As an exception, it's okay to befriend such methods in order 2840 // to permit the implicit constructor/destructor/operator calls. 2841 } else if (OldMethod->isImplicit()) { 2842 if (isFriend) { 2843 NewMethod->setImplicit(); 2844 } else { 2845 Diag(NewMethod->getLocation(), 2846 diag::err_definition_of_implicitly_declared_member) 2847 << New << getSpecialMember(OldMethod); 2848 return true; 2849 } 2850 } else if (OldMethod->isExplicitlyDefaulted() && !isFriend) { 2851 Diag(NewMethod->getLocation(), 2852 diag::err_definition_of_explicitly_defaulted_member) 2853 << getSpecialMember(OldMethod); 2854 return true; 2855 } 2856 } 2857 2858 // C++11 [dcl.attr.noreturn]p1: 2859 // The first declaration of a function shall specify the noreturn 2860 // attribute if any declaration of that function specifies the noreturn 2861 // attribute. 2862 const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>(); 2863 if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) { 2864 Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl); 2865 Diag(Old->getFirstDecl()->getLocation(), 2866 diag::note_noreturn_missing_first_decl); 2867 } 2868 2869 // C++11 [dcl.attr.depend]p2: 2870 // The first declaration of a function shall specify the 2871 // carries_dependency attribute for its declarator-id if any declaration 2872 // of the function specifies the carries_dependency attribute. 2873 const CarriesDependencyAttr *CDA = New->getAttr<CarriesDependencyAttr>(); 2874 if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) { 2875 Diag(CDA->getLocation(), 2876 diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/; 2877 Diag(Old->getFirstDecl()->getLocation(), 2878 diag::note_carries_dependency_missing_first_decl) << 0/*Function*/; 2879 } 2880 2881 // (C++98 8.3.5p3): 2882 // All declarations for a function shall agree exactly in both the 2883 // return type and the parameter-type-list. 2884 // We also want to respect all the extended bits except noreturn. 2885 2886 // noreturn should now match unless the old type info didn't have it. 2887 QualType OldQTypeForComparison = OldQType; 2888 if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) { 2889 assert(OldQType == QualType(OldType, 0)); 2890 const FunctionType *OldTypeForComparison 2891 = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true)); 2892 OldQTypeForComparison = QualType(OldTypeForComparison, 0); 2893 assert(OldQTypeForComparison.isCanonical()); 2894 } 2895 2896 if (haveIncompatibleLanguageLinkages(Old, New)) { 2897 // As a special case, retain the language linkage from previous 2898 // declarations of a friend function as an extension. 2899 // 2900 // This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC 2901 // and is useful because there's otherwise no way to specify language 2902 // linkage within class scope. 2903 // 2904 // Check cautiously as the friend object kind isn't yet complete. 2905 if (New->getFriendObjectKind() != Decl::FOK_None) { 2906 Diag(New->getLocation(), diag::ext_retained_language_linkage) << New; 2907 Diag(OldLocation, PrevDiag); 2908 } else { 2909 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 2910 Diag(OldLocation, PrevDiag); 2911 return true; 2912 } 2913 } 2914 2915 if (OldQTypeForComparison == NewQType) 2916 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2917 2918 if ((NewQType->isDependentType() || OldQType->isDependentType()) && 2919 New->isLocalExternDecl()) { 2920 // It's OK if we couldn't merge types for a local function declaraton 2921 // if either the old or new type is dependent. We'll merge the types 2922 // when we instantiate the function. 2923 return false; 2924 } 2925 2926 // Fall through for conflicting redeclarations and redefinitions. 2927 } 2928 2929 // C: Function types need to be compatible, not identical. This handles 2930 // duplicate function decls like "void f(int); void f(enum X);" properly. 2931 if (!getLangOpts().CPlusPlus && 2932 Context.typesAreCompatible(OldQType, NewQType)) { 2933 const FunctionType *OldFuncType = OldQType->getAs<FunctionType>(); 2934 const FunctionType *NewFuncType = NewQType->getAs<FunctionType>(); 2935 const FunctionProtoType *OldProto = nullptr; 2936 if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) && 2937 (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) { 2938 // The old declaration provided a function prototype, but the 2939 // new declaration does not. Merge in the prototype. 2940 assert(!OldProto->hasExceptionSpec() && "Exception spec in C"); 2941 SmallVector<QualType, 16> ParamTypes(OldProto->param_types()); 2942 NewQType = 2943 Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes, 2944 OldProto->getExtProtoInfo()); 2945 New->setType(NewQType); 2946 New->setHasInheritedPrototype(); 2947 2948 // Synthesize parameters with the same types. 2949 SmallVector<ParmVarDecl*, 16> Params; 2950 for (const auto &ParamType : OldProto->param_types()) { 2951 ParmVarDecl *Param = ParmVarDecl::Create(Context, New, SourceLocation(), 2952 SourceLocation(), nullptr, 2953 ParamType, /*TInfo=*/nullptr, 2954 SC_None, nullptr); 2955 Param->setScopeInfo(0, Params.size()); 2956 Param->setImplicit(); 2957 Params.push_back(Param); 2958 } 2959 2960 New->setParams(Params); 2961 } 2962 2963 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 2964 } 2965 2966 // GNU C permits a K&R definition to follow a prototype declaration 2967 // if the declared types of the parameters in the K&R definition 2968 // match the types in the prototype declaration, even when the 2969 // promoted types of the parameters from the K&R definition differ 2970 // from the types in the prototype. GCC then keeps the types from 2971 // the prototype. 2972 // 2973 // If a variadic prototype is followed by a non-variadic K&R definition, 2974 // the K&R definition becomes variadic. This is sort of an edge case, but 2975 // it's legal per the standard depending on how you read C99 6.7.5.3p15 and 2976 // C99 6.9.1p8. 2977 if (!getLangOpts().CPlusPlus && 2978 Old->hasPrototype() && !New->hasPrototype() && 2979 New->getType()->getAs<FunctionProtoType>() && 2980 Old->getNumParams() == New->getNumParams()) { 2981 SmallVector<QualType, 16> ArgTypes; 2982 SmallVector<GNUCompatibleParamWarning, 16> Warnings; 2983 const FunctionProtoType *OldProto 2984 = Old->getType()->getAs<FunctionProtoType>(); 2985 const FunctionProtoType *NewProto 2986 = New->getType()->getAs<FunctionProtoType>(); 2987 2988 // Determine whether this is the GNU C extension. 2989 QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(), 2990 NewProto->getReturnType()); 2991 bool LooseCompatible = !MergedReturn.isNull(); 2992 for (unsigned Idx = 0, End = Old->getNumParams(); 2993 LooseCompatible && Idx != End; ++Idx) { 2994 ParmVarDecl *OldParm = Old->getParamDecl(Idx); 2995 ParmVarDecl *NewParm = New->getParamDecl(Idx); 2996 if (Context.typesAreCompatible(OldParm->getType(), 2997 NewProto->getParamType(Idx))) { 2998 ArgTypes.push_back(NewParm->getType()); 2999 } else if (Context.typesAreCompatible(OldParm->getType(), 3000 NewParm->getType(), 3001 /*CompareUnqualified=*/true)) { 3002 GNUCompatibleParamWarning Warn = { OldParm, NewParm, 3003 NewProto->getParamType(Idx) }; 3004 Warnings.push_back(Warn); 3005 ArgTypes.push_back(NewParm->getType()); 3006 } else 3007 LooseCompatible = false; 3008 } 3009 3010 if (LooseCompatible) { 3011 for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) { 3012 Diag(Warnings[Warn].NewParm->getLocation(), 3013 diag::ext_param_promoted_not_compatible_with_prototype) 3014 << Warnings[Warn].PromotedType 3015 << Warnings[Warn].OldParm->getType(); 3016 if (Warnings[Warn].OldParm->getLocation().isValid()) 3017 Diag(Warnings[Warn].OldParm->getLocation(), 3018 diag::note_previous_declaration); 3019 } 3020 3021 if (MergeTypeWithOld) 3022 New->setType(Context.getFunctionType(MergedReturn, ArgTypes, 3023 OldProto->getExtProtoInfo())); 3024 return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld); 3025 } 3026 3027 // Fall through to diagnose conflicting types. 3028 } 3029 3030 // A function that has already been declared has been redeclared or 3031 // defined with a different type; show an appropriate diagnostic. 3032 3033 // If the previous declaration was an implicitly-generated builtin 3034 // declaration, then at the very least we should use a specialized note. 3035 unsigned BuiltinID; 3036 if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) { 3037 // If it's actually a library-defined builtin function like 'malloc' 3038 // or 'printf', just warn about the incompatible redeclaration. 3039 if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) { 3040 Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New; 3041 Diag(OldLocation, diag::note_previous_builtin_declaration) 3042 << Old << Old->getType(); 3043 3044 // If this is a global redeclaration, just forget hereafter 3045 // about the "builtin-ness" of the function. 3046 // 3047 // Doing this for local extern declarations is problematic. If 3048 // the builtin declaration remains visible, a second invalid 3049 // local declaration will produce a hard error; if it doesn't 3050 // remain visible, a single bogus local redeclaration (which is 3051 // actually only a warning) could break all the downstream code. 3052 if (!New->getLexicalDeclContext()->isFunctionOrMethod()) 3053 New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin); 3054 3055 return false; 3056 } 3057 3058 PrevDiag = diag::note_previous_builtin_declaration; 3059 } 3060 3061 Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName(); 3062 Diag(OldLocation, PrevDiag) << Old << Old->getType(); 3063 return true; 3064 } 3065 3066 /// \brief Completes the merge of two function declarations that are 3067 /// known to be compatible. 3068 /// 3069 /// This routine handles the merging of attributes and other 3070 /// properties of function declarations from the old declaration to 3071 /// the new declaration, once we know that New is in fact a 3072 /// redeclaration of Old. 3073 /// 3074 /// \returns false 3075 bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, 3076 Scope *S, bool MergeTypeWithOld) { 3077 // Merge the attributes 3078 mergeDeclAttributes(New, Old); 3079 3080 // Merge "pure" flag. 3081 if (Old->isPure()) 3082 New->setPure(); 3083 3084 // Merge "used" flag. 3085 if (Old->getMostRecentDecl()->isUsed(false)) 3086 New->setIsUsed(); 3087 3088 // Merge attributes from the parameters. These can mismatch with K&R 3089 // declarations. 3090 if (New->getNumParams() == Old->getNumParams()) 3091 for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) 3092 mergeParamDeclAttributes(New->getParamDecl(i), Old->getParamDecl(i), 3093 *this); 3094 3095 if (getLangOpts().CPlusPlus) 3096 return MergeCXXFunctionDecl(New, Old, S); 3097 3098 // Merge the function types so the we get the composite types for the return 3099 // and argument types. Per C11 6.2.7/4, only update the type if the old decl 3100 // was visible. 3101 QualType Merged = Context.mergeTypes(Old->getType(), New->getType()); 3102 if (!Merged.isNull() && MergeTypeWithOld) 3103 New->setType(Merged); 3104 3105 return false; 3106 } 3107 3108 3109 void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod, 3110 ObjCMethodDecl *oldMethod) { 3111 3112 // Merge the attributes, including deprecated/unavailable 3113 AvailabilityMergeKind MergeKind = 3114 isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration 3115 : AMK_Override; 3116 mergeDeclAttributes(newMethod, oldMethod, MergeKind); 3117 3118 // Merge attributes from the parameters. 3119 ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(), 3120 oe = oldMethod->param_end(); 3121 for (ObjCMethodDecl::param_iterator 3122 ni = newMethod->param_begin(), ne = newMethod->param_end(); 3123 ni != ne && oi != oe; ++ni, ++oi) 3124 mergeParamDeclAttributes(*ni, *oi, *this); 3125 3126 CheckObjCMethodOverride(newMethod, oldMethod); 3127 } 3128 3129 /// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and 3130 /// scope as a previous declaration 'Old'. Figure out how to merge their types, 3131 /// emitting diagnostics as appropriate. 3132 /// 3133 /// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back 3134 /// to here in AddInitializerToDecl. We can't check them before the initializer 3135 /// is attached. 3136 void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old, 3137 bool MergeTypeWithOld) { 3138 if (New->isInvalidDecl() || Old->isInvalidDecl()) 3139 return; 3140 3141 QualType MergedT; 3142 if (getLangOpts().CPlusPlus) { 3143 if (New->getType()->isUndeducedType()) { 3144 // We don't know what the new type is until the initializer is attached. 3145 return; 3146 } else if (Context.hasSameType(New->getType(), Old->getType())) { 3147 // These could still be something that needs exception specs checked. 3148 return MergeVarDeclExceptionSpecs(New, Old); 3149 } 3150 // C++ [basic.link]p10: 3151 // [...] the types specified by all declarations referring to a given 3152 // object or function shall be identical, except that declarations for an 3153 // array object can specify array types that differ by the presence or 3154 // absence of a major array bound (8.3.4). 3155 else if (Old->getType()->isIncompleteArrayType() && 3156 New->getType()->isArrayType()) { 3157 const ArrayType *OldArray = Context.getAsArrayType(Old->getType()); 3158 const ArrayType *NewArray = Context.getAsArrayType(New->getType()); 3159 if (Context.hasSameType(OldArray->getElementType(), 3160 NewArray->getElementType())) 3161 MergedT = New->getType(); 3162 } else if (Old->getType()->isArrayType() && 3163 New->getType()->isIncompleteArrayType()) { 3164 const ArrayType *OldArray = Context.getAsArrayType(Old->getType()); 3165 const ArrayType *NewArray = Context.getAsArrayType(New->getType()); 3166 if (Context.hasSameType(OldArray->getElementType(), 3167 NewArray->getElementType())) 3168 MergedT = Old->getType(); 3169 } else if (New->getType()->isObjCObjectPointerType() && 3170 Old->getType()->isObjCObjectPointerType()) { 3171 MergedT = Context.mergeObjCGCQualifiers(New->getType(), 3172 Old->getType()); 3173 } 3174 } else { 3175 // C 6.2.7p2: 3176 // All declarations that refer to the same object or function shall have 3177 // compatible type. 3178 MergedT = Context.mergeTypes(New->getType(), Old->getType()); 3179 } 3180 if (MergedT.isNull()) { 3181 // It's OK if we couldn't merge types if either type is dependent, for a 3182 // block-scope variable. In other cases (static data members of class 3183 // templates, variable templates, ...), we require the types to be 3184 // equivalent. 3185 // FIXME: The C++ standard doesn't say anything about this. 3186 if ((New->getType()->isDependentType() || 3187 Old->getType()->isDependentType()) && New->isLocalVarDecl()) { 3188 // If the old type was dependent, we can't merge with it, so the new type 3189 // becomes dependent for now. We'll reproduce the original type when we 3190 // instantiate the TypeSourceInfo for the variable. 3191 if (!New->getType()->isDependentType() && MergeTypeWithOld) 3192 New->setType(Context.DependentTy); 3193 return; 3194 } 3195 3196 // FIXME: Even if this merging succeeds, some other non-visible declaration 3197 // of this variable might have an incompatible type. For instance: 3198 // 3199 // extern int arr[]; 3200 // void f() { extern int arr[2]; } 3201 // void g() { extern int arr[3]; } 3202 // 3203 // Neither C nor C++ requires a diagnostic for this, but we should still try 3204 // to diagnose it. 3205 Diag(New->getLocation(), diag::err_redefinition_different_type) 3206 << New->getDeclName() << New->getType() << Old->getType(); 3207 Diag(Old->getLocation(), diag::note_previous_definition); 3208 return New->setInvalidDecl(); 3209 } 3210 3211 // Don't actually update the type on the new declaration if the old 3212 // declaration was an extern declaration in a different scope. 3213 if (MergeTypeWithOld) 3214 New->setType(MergedT); 3215 } 3216 3217 static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, 3218 LookupResult &Previous) { 3219 // C11 6.2.7p4: 3220 // For an identifier with internal or external linkage declared 3221 // in a scope in which a prior declaration of that identifier is 3222 // visible, if the prior declaration specifies internal or 3223 // external linkage, the type of the identifier at the later 3224 // declaration becomes the composite type. 3225 // 3226 // If the variable isn't visible, we do not merge with its type. 3227 if (Previous.isShadowed()) 3228 return false; 3229 3230 if (S.getLangOpts().CPlusPlus) { 3231 // C++11 [dcl.array]p3: 3232 // If there is a preceding declaration of the entity in the same 3233 // scope in which the bound was specified, an omitted array bound 3234 // is taken to be the same as in that earlier declaration. 3235 return NewVD->isPreviousDeclInSameBlockScope() || 3236 (!OldVD->getLexicalDeclContext()->isFunctionOrMethod() && 3237 !NewVD->getLexicalDeclContext()->isFunctionOrMethod()); 3238 } else { 3239 // If the old declaration was function-local, don't merge with its 3240 // type unless we're in the same function. 3241 return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() || 3242 OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext(); 3243 } 3244 } 3245 3246 /// MergeVarDecl - We just parsed a variable 'New' which has the same name 3247 /// and scope as a previous declaration 'Old'. Figure out how to resolve this 3248 /// situation, merging decls or emitting diagnostics as appropriate. 3249 /// 3250 /// Tentative definition rules (C99 6.9.2p2) are checked by 3251 /// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative 3252 /// definitions here, since the initializer hasn't been attached. 3253 /// 3254 void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) { 3255 // If the new decl is already invalid, don't do any other checking. 3256 if (New->isInvalidDecl()) 3257 return; 3258 3259 VarTemplateDecl *NewTemplate = New->getDescribedVarTemplate(); 3260 3261 // Verify the old decl was also a variable or variable template. 3262 VarDecl *Old = nullptr; 3263 VarTemplateDecl *OldTemplate = nullptr; 3264 if (Previous.isSingleResult()) { 3265 if (NewTemplate) { 3266 OldTemplate = dyn_cast<VarTemplateDecl>(Previous.getFoundDecl()); 3267 Old = OldTemplate ? OldTemplate->getTemplatedDecl() : nullptr; 3268 } else 3269 Old = dyn_cast<VarDecl>(Previous.getFoundDecl()); 3270 } 3271 if (!Old) { 3272 Diag(New->getLocation(), diag::err_redefinition_different_kind) 3273 << New->getDeclName(); 3274 Diag(Previous.getRepresentativeDecl()->getLocation(), 3275 diag::note_previous_definition); 3276 return New->setInvalidDecl(); 3277 } 3278 3279 if (!shouldLinkPossiblyHiddenDecl(Old, New)) 3280 return; 3281 3282 // Ensure the template parameters are compatible. 3283 if (NewTemplate && 3284 !TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(), 3285 OldTemplate->getTemplateParameters(), 3286 /*Complain=*/true, TPL_TemplateMatch)) 3287 return; 3288 3289 // C++ [class.mem]p1: 3290 // A member shall not be declared twice in the member-specification [...] 3291 // 3292 // Here, we need only consider static data members. 3293 if (Old->isStaticDataMember() && !New->isOutOfLine()) { 3294 Diag(New->getLocation(), diag::err_duplicate_member) 3295 << New->getIdentifier(); 3296 Diag(Old->getLocation(), diag::note_previous_declaration); 3297 New->setInvalidDecl(); 3298 } 3299 3300 mergeDeclAttributes(New, Old); 3301 // Warn if an already-declared variable is made a weak_import in a subsequent 3302 // declaration 3303 if (New->hasAttr<WeakImportAttr>() && 3304 Old->getStorageClass() == SC_None && 3305 !Old->hasAttr<WeakImportAttr>()) { 3306 Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName(); 3307 Diag(Old->getLocation(), diag::note_previous_definition); 3308 // Remove weak_import attribute on new declaration. 3309 New->dropAttr<WeakImportAttr>(); 3310 } 3311 3312 // Merge the types. 3313 VarDecl *MostRecent = Old->getMostRecentDecl(); 3314 if (MostRecent != Old) { 3315 MergeVarDeclTypes(New, MostRecent, 3316 mergeTypeWithPrevious(*this, New, MostRecent, Previous)); 3317 if (New->isInvalidDecl()) 3318 return; 3319 } 3320 3321 MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous)); 3322 if (New->isInvalidDecl()) 3323 return; 3324 3325 diag::kind PrevDiag; 3326 SourceLocation OldLocation; 3327 std::tie(PrevDiag, OldLocation) = 3328 getNoteDiagForInvalidRedeclaration(Old, New); 3329 3330 // [dcl.stc]p8: Check if we have a non-static decl followed by a static. 3331 if (New->getStorageClass() == SC_Static && 3332 !New->isStaticDataMember() && 3333 Old->hasExternalFormalLinkage()) { 3334 if (getLangOpts().MicrosoftExt) { 3335 Diag(New->getLocation(), diag::ext_static_non_static) 3336 << New->getDeclName(); 3337 Diag(OldLocation, PrevDiag); 3338 } else { 3339 Diag(New->getLocation(), diag::err_static_non_static) 3340 << New->getDeclName(); 3341 Diag(OldLocation, PrevDiag); 3342 return New->setInvalidDecl(); 3343 } 3344 } 3345 // C99 6.2.2p4: 3346 // For an identifier declared with the storage-class specifier 3347 // extern in a scope in which a prior declaration of that 3348 // identifier is visible,23) if the prior declaration specifies 3349 // internal or external linkage, the linkage of the identifier at 3350 // the later declaration is the same as the linkage specified at 3351 // the prior declaration. If no prior declaration is visible, or 3352 // if the prior declaration specifies no linkage, then the 3353 // identifier has external linkage. 3354 if (New->hasExternalStorage() && Old->hasLinkage()) 3355 /* Okay */; 3356 else if (New->getCanonicalDecl()->getStorageClass() != SC_Static && 3357 !New->isStaticDataMember() && 3358 Old->getCanonicalDecl()->getStorageClass() == SC_Static) { 3359 Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName(); 3360 Diag(OldLocation, PrevDiag); 3361 return New->setInvalidDecl(); 3362 } 3363 3364 // Check if extern is followed by non-extern and vice-versa. 3365 if (New->hasExternalStorage() && 3366 !Old->hasLinkage() && Old->isLocalVarDeclOrParm()) { 3367 Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName(); 3368 Diag(OldLocation, PrevDiag); 3369 return New->setInvalidDecl(); 3370 } 3371 if (Old->hasLinkage() && New->isLocalVarDeclOrParm() && 3372 !New->hasExternalStorage()) { 3373 Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName(); 3374 Diag(OldLocation, PrevDiag); 3375 return New->setInvalidDecl(); 3376 } 3377 3378 // Variables with external linkage are analyzed in FinalizeDeclaratorGroup. 3379 3380 // FIXME: The test for external storage here seems wrong? We still 3381 // need to check for mismatches. 3382 if (!New->hasExternalStorage() && !New->isFileVarDecl() && 3383 // Don't complain about out-of-line definitions of static members. 3384 !(Old->getLexicalDeclContext()->isRecord() && 3385 !New->getLexicalDeclContext()->isRecord())) { 3386 Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName(); 3387 Diag(OldLocation, PrevDiag); 3388 return New->setInvalidDecl(); 3389 } 3390 3391 if (New->getTLSKind() != Old->getTLSKind()) { 3392 if (!Old->getTLSKind()) { 3393 Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName(); 3394 Diag(OldLocation, PrevDiag); 3395 } else if (!New->getTLSKind()) { 3396 Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName(); 3397 Diag(OldLocation, PrevDiag); 3398 } else { 3399 // Do not allow redeclaration to change the variable between requiring 3400 // static and dynamic initialization. 3401 // FIXME: GCC allows this, but uses the TLS keyword on the first 3402 // declaration to determine the kind. Do we need to be compatible here? 3403 Diag(New->getLocation(), diag::err_thread_thread_different_kind) 3404 << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic); 3405 Diag(OldLocation, PrevDiag); 3406 } 3407 } 3408 3409 // C++ doesn't have tentative definitions, so go right ahead and check here. 3410 const VarDecl *Def; 3411 if (getLangOpts().CPlusPlus && 3412 New->isThisDeclarationADefinition() == VarDecl::Definition && 3413 (Def = Old->getDefinition())) { 3414 Diag(New->getLocation(), diag::err_redefinition) << New; 3415 Diag(Def->getLocation(), diag::note_previous_definition); 3416 New->setInvalidDecl(); 3417 return; 3418 } 3419 3420 if (haveIncompatibleLanguageLinkages(Old, New)) { 3421 Diag(New->getLocation(), diag::err_different_language_linkage) << New; 3422 Diag(OldLocation, PrevDiag); 3423 New->setInvalidDecl(); 3424 return; 3425 } 3426 3427 // Merge "used" flag. 3428 if (Old->getMostRecentDecl()->isUsed(false)) 3429 New->setIsUsed(); 3430 3431 // Keep a chain of previous declarations. 3432 New->setPreviousDecl(Old); 3433 if (NewTemplate) 3434 NewTemplate->setPreviousDecl(OldTemplate); 3435 3436 // Inherit access appropriately. 3437 New->setAccess(Old->getAccess()); 3438 if (NewTemplate) 3439 NewTemplate->setAccess(New->getAccess()); 3440 } 3441 3442 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 3443 /// no declarator (e.g. "struct foo;") is parsed. 3444 Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, 3445 DeclSpec &DS) { 3446 return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg()); 3447 } 3448 3449 // The MS ABI changed between VS2013 and VS2015 with regard to numbers used to 3450 // disambiguate entities defined in different scopes. 3451 // While the VS2015 ABI fixes potential miscompiles, it is also breaks 3452 // compatibility. 3453 // We will pick our mangling number depending on which version of MSVC is being 3454 // targeted. 3455 static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S) { 3456 return LO.isCompatibleWithMSVC(19) ? S->getMSCurManglingNumber() 3457 : S->getMSLastManglingNumber(); 3458 } 3459 3460 void Sema::handleTagNumbering(const TagDecl *Tag, Scope *TagScope) { 3461 if (!Context.getLangOpts().CPlusPlus) 3462 return; 3463 3464 if (isa<CXXRecordDecl>(Tag->getParent())) { 3465 // If this tag is the direct child of a class, number it if 3466 // it is anonymous. 3467 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl()) 3468 return; 3469 MangleNumberingContext &MCtx = 3470 Context.getManglingNumberContext(Tag->getParent()); 3471 Context.setManglingNumber( 3472 Tag, MCtx.getManglingNumber( 3473 Tag, getMSManglingNumber(getLangOpts(), TagScope))); 3474 return; 3475 } 3476 3477 // If this tag isn't a direct child of a class, number it if it is local. 3478 Decl *ManglingContextDecl; 3479 if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext( 3480 Tag->getDeclContext(), ManglingContextDecl)) { 3481 Context.setManglingNumber( 3482 Tag, MCtx->getManglingNumber( 3483 Tag, getMSManglingNumber(getLangOpts(), TagScope))); 3484 } 3485 } 3486 3487 void Sema::setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, 3488 TypedefNameDecl *NewTD) { 3489 // Do nothing if the tag is not anonymous or already has an 3490 // associated typedef (from an earlier typedef in this decl group). 3491 if (TagFromDeclSpec->getIdentifier()) 3492 return; 3493 if (TagFromDeclSpec->getTypedefNameForAnonDecl()) 3494 return; 3495 3496 // A well-formed anonymous tag must always be a TUK_Definition. 3497 assert(TagFromDeclSpec->isThisDeclarationADefinition()); 3498 3499 // The type must match the tag exactly; no qualifiers allowed. 3500 if (!Context.hasSameType(NewTD->getUnderlyingType(), 3501 Context.getTagDeclType(TagFromDeclSpec))) 3502 return; 3503 3504 // If we've already computed linkage for the anonymous tag, then 3505 // adding a typedef name for the anonymous decl can change that 3506 // linkage, which might be a serious problem. Diagnose this as 3507 // unsupported and ignore the typedef name. TODO: we should 3508 // pursue this as a language defect and establish a formal rule 3509 // for how to handle it. 3510 if (TagFromDeclSpec->hasLinkageBeenComputed()) { 3511 Diag(NewTD->getLocation(), diag::err_typedef_changes_linkage); 3512 3513 SourceLocation tagLoc = TagFromDeclSpec->getInnerLocStart(); 3514 tagLoc = getLocForEndOfToken(tagLoc); 3515 3516 llvm::SmallString<40> textToInsert; 3517 textToInsert += ' '; 3518 textToInsert += NewTD->getIdentifier()->getName(); 3519 Diag(tagLoc, diag::note_typedef_changes_linkage) 3520 << FixItHint::CreateInsertion(tagLoc, textToInsert); 3521 return; 3522 } 3523 3524 // Otherwise, set this is the anon-decl typedef for the tag. 3525 TagFromDeclSpec->setTypedefNameForAnonDecl(NewTD); 3526 } 3527 3528 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with 3529 /// no declarator (e.g. "struct foo;") is parsed. It also accepts template 3530 /// parameters to cope with template friend declarations. 3531 Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, 3532 DeclSpec &DS, 3533 MultiTemplateParamsArg TemplateParams, 3534 bool IsExplicitInstantiation) { 3535 Decl *TagD = nullptr; 3536 TagDecl *Tag = nullptr; 3537 if (DS.getTypeSpecType() == DeclSpec::TST_class || 3538 DS.getTypeSpecType() == DeclSpec::TST_struct || 3539 DS.getTypeSpecType() == DeclSpec::TST_interface || 3540 DS.getTypeSpecType() == DeclSpec::TST_union || 3541 DS.getTypeSpecType() == DeclSpec::TST_enum) { 3542 TagD = DS.getRepAsDecl(); 3543 3544 if (!TagD) // We probably had an error 3545 return nullptr; 3546 3547 // Note that the above type specs guarantee that the 3548 // type rep is a Decl, whereas in many of the others 3549 // it's a Type. 3550 if (isa<TagDecl>(TagD)) 3551 Tag = cast<TagDecl>(TagD); 3552 else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD)) 3553 Tag = CTD->getTemplatedDecl(); 3554 } 3555 3556 if (Tag) { 3557 handleTagNumbering(Tag, S); 3558 Tag->setFreeStanding(); 3559 if (Tag->isInvalidDecl()) 3560 return Tag; 3561 } 3562 3563 if (unsigned TypeQuals = DS.getTypeQualifiers()) { 3564 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object 3565 // or incomplete types shall not be restrict-qualified." 3566 if (TypeQuals & DeclSpec::TQ_restrict) 3567 Diag(DS.getRestrictSpecLoc(), 3568 diag::err_typecheck_invalid_restrict_not_pointer_noarg) 3569 << DS.getSourceRange(); 3570 } 3571 3572 if (DS.isConstexprSpecified()) { 3573 // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations 3574 // and definitions of functions and variables. 3575 if (Tag) 3576 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag) 3577 << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : 3578 DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : 3579 DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : 3580 DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4); 3581 else 3582 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators); 3583 // Don't emit warnings after this error. 3584 return TagD; 3585 } 3586 3587 DiagnoseFunctionSpecifiers(DS); 3588 3589 if (DS.isFriendSpecified()) { 3590 // If we're dealing with a decl but not a TagDecl, assume that 3591 // whatever routines created it handled the friendship aspect. 3592 if (TagD && !Tag) 3593 return nullptr; 3594 return ActOnFriendTypeDecl(S, DS, TemplateParams); 3595 } 3596 3597 const CXXScopeSpec &SS = DS.getTypeSpecScope(); 3598 bool IsExplicitSpecialization = 3599 !TemplateParams.empty() && TemplateParams.back()->size() == 0; 3600 if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() && 3601 !IsExplicitInstantiation && !IsExplicitSpecialization) { 3602 // Per C++ [dcl.type.elab]p1, a class declaration cannot have a 3603 // nested-name-specifier unless it is an explicit instantiation 3604 // or an explicit specialization. 3605 // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either. 3606 Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier) 3607 << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 : 3608 DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 : 3609 DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 : 3610 DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4) 3611 << SS.getRange(); 3612 return nullptr; 3613 } 3614 3615 // Track whether this decl-specifier declares anything. 3616 bool DeclaresAnything = true; 3617 3618 // Handle anonymous struct definitions. 3619 if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) { 3620 if (!Record->getDeclName() && Record->isCompleteDefinition() && 3621 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) { 3622 if (getLangOpts().CPlusPlus || 3623 Record->getDeclContext()->isRecord()) 3624 return BuildAnonymousStructOrUnion(S, DS, AS, Record, 3625 Context.getPrintingPolicy()); 3626 3627 DeclaresAnything = false; 3628 } 3629 } 3630 3631 // C11 6.7.2.1p2: 3632 // A struct-declaration that does not declare an anonymous structure or 3633 // anonymous union shall contain a struct-declarator-list. 3634 // 3635 // This rule also existed in C89 and C99; the grammar for struct-declaration 3636 // did not permit a struct-declaration without a struct-declarator-list. 3637 if (!getLangOpts().CPlusPlus && CurContext->isRecord() && 3638 DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) { 3639 // Check for Microsoft C extension: anonymous struct/union member. 3640 // Handle 2 kinds of anonymous struct/union: 3641 // struct STRUCT; 3642 // union UNION; 3643 // and 3644 // STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct. 3645 // UNION_TYPE; <- where UNION_TYPE is a typedef union. 3646 if ((Tag && Tag->getDeclName()) || 3647 DS.getTypeSpecType() == DeclSpec::TST_typename) { 3648 RecordDecl *Record = nullptr; 3649 if (Tag) 3650 Record = dyn_cast<RecordDecl>(Tag); 3651 else if (const RecordType *RT = 3652 DS.getRepAsType().get()->getAsStructureType()) 3653 Record = RT->getDecl(); 3654 else if (const RecordType *UT = DS.getRepAsType().get()->getAsUnionType()) 3655 Record = UT->getDecl(); 3656 3657 if (Record && getLangOpts().MicrosoftExt) { 3658 Diag(DS.getLocStart(), diag::ext_ms_anonymous_record) 3659 << Record->isUnion() << DS.getSourceRange(); 3660 return BuildMicrosoftCAnonymousStruct(S, DS, Record); 3661 } 3662 3663 DeclaresAnything = false; 3664 } 3665 } 3666 3667 // Skip all the checks below if we have a type error. 3668 if (DS.getTypeSpecType() == DeclSpec::TST_error || 3669 (TagD && TagD->isInvalidDecl())) 3670 return TagD; 3671 3672 if (getLangOpts().CPlusPlus && 3673 DS.getStorageClassSpec() != DeclSpec::SCS_typedef) 3674 if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag)) 3675 if (Enum->enumerator_begin() == Enum->enumerator_end() && 3676 !Enum->getIdentifier() && !Enum->isInvalidDecl()) 3677 DeclaresAnything = false; 3678 3679 if (!DS.isMissingDeclaratorOk()) { 3680 // Customize diagnostic for a typedef missing a name. 3681 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) 3682 Diag(DS.getLocStart(), diag::ext_typedef_without_a_name) 3683 << DS.getSourceRange(); 3684 else 3685 DeclaresAnything = false; 3686 } 3687 3688 if (DS.isModulePrivateSpecified() && 3689 Tag && Tag->getDeclContext()->isFunctionOrMethod()) 3690 Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class) 3691 << Tag->getTagKind() 3692 << FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc()); 3693 3694 ActOnDocumentableDecl(TagD); 3695 3696 // C 6.7/2: 3697 // A declaration [...] shall declare at least a declarator [...], a tag, 3698 // or the members of an enumeration. 3699 // C++ [dcl.dcl]p3: 3700 // [If there are no declarators], and except for the declaration of an 3701 // unnamed bit-field, the decl-specifier-seq shall introduce one or more 3702 // names into the program, or shall redeclare a name introduced by a 3703 // previous declaration. 3704 if (!DeclaresAnything) { 3705 // In C, we allow this as a (popular) extension / bug. Don't bother 3706 // producing further diagnostics for redundant qualifiers after this. 3707 Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange(); 3708 return TagD; 3709 } 3710 3711 // C++ [dcl.stc]p1: 3712 // If a storage-class-specifier appears in a decl-specifier-seq, [...] the 3713 // init-declarator-list of the declaration shall not be empty. 3714 // C++ [dcl.fct.spec]p1: 3715 // If a cv-qualifier appears in a decl-specifier-seq, the 3716 // init-declarator-list of the declaration shall not be empty. 3717 // 3718 // Spurious qualifiers here appear to be valid in C. 3719 unsigned DiagID = diag::warn_standalone_specifier; 3720 if (getLangOpts().CPlusPlus) 3721 DiagID = diag::ext_standalone_specifier; 3722 3723 // Note that a linkage-specification sets a storage class, but 3724 // 'extern "C" struct foo;' is actually valid and not theoretically 3725 // useless. 3726 if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) { 3727 if (SCS == DeclSpec::SCS_mutable) 3728 // Since mutable is not a viable storage class specifier in C, there is 3729 // no reason to treat it as an extension. Instead, diagnose as an error. 3730 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_nonmember); 3731 else if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef) 3732 Diag(DS.getStorageClassSpecLoc(), DiagID) 3733 << DeclSpec::getSpecifierName(SCS); 3734 } 3735 3736 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 3737 Diag(DS.getThreadStorageClassSpecLoc(), DiagID) 3738 << DeclSpec::getSpecifierName(TSCS); 3739 if (DS.getTypeQualifiers()) { 3740 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 3741 Diag(DS.getConstSpecLoc(), DiagID) << "const"; 3742 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 3743 Diag(DS.getConstSpecLoc(), DiagID) << "volatile"; 3744 // Restrict is covered above. 3745 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 3746 Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic"; 3747 } 3748 3749 // Warn about ignored type attributes, for example: 3750 // __attribute__((aligned)) struct A; 3751 // Attributes should be placed after tag to apply to type declaration. 3752 if (!DS.getAttributes().empty()) { 3753 DeclSpec::TST TypeSpecType = DS.getTypeSpecType(); 3754 if (TypeSpecType == DeclSpec::TST_class || 3755 TypeSpecType == DeclSpec::TST_struct || 3756 TypeSpecType == DeclSpec::TST_interface || 3757 TypeSpecType == DeclSpec::TST_union || 3758 TypeSpecType == DeclSpec::TST_enum) { 3759 AttributeList* attrs = DS.getAttributes().getList(); 3760 while (attrs) { 3761 Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored) 3762 << attrs->getName() 3763 << (TypeSpecType == DeclSpec::TST_class ? 0 : 3764 TypeSpecType == DeclSpec::TST_struct ? 1 : 3765 TypeSpecType == DeclSpec::TST_union ? 2 : 3766 TypeSpecType == DeclSpec::TST_interface ? 3 : 4); 3767 attrs = attrs->getNext(); 3768 } 3769 } 3770 } 3771 3772 return TagD; 3773 } 3774 3775 /// We are trying to inject an anonymous member into the given scope; 3776 /// check if there's an existing declaration that can't be overloaded. 3777 /// 3778 /// \return true if this is a forbidden redeclaration 3779 static bool CheckAnonMemberRedeclaration(Sema &SemaRef, 3780 Scope *S, 3781 DeclContext *Owner, 3782 DeclarationName Name, 3783 SourceLocation NameLoc, 3784 unsigned diagnostic) { 3785 LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName, 3786 Sema::ForRedeclaration); 3787 if (!SemaRef.LookupName(R, S)) return false; 3788 3789 if (R.getAsSingle<TagDecl>()) 3790 return false; 3791 3792 // Pick a representative declaration. 3793 NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl(); 3794 assert(PrevDecl && "Expected a non-null Decl"); 3795 3796 if (!SemaRef.isDeclInScope(PrevDecl, Owner, S)) 3797 return false; 3798 3799 SemaRef.Diag(NameLoc, diagnostic) << Name; 3800 SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 3801 3802 return true; 3803 } 3804 3805 /// InjectAnonymousStructOrUnionMembers - Inject the members of the 3806 /// anonymous struct or union AnonRecord into the owning context Owner 3807 /// and scope S. This routine will be invoked just after we realize 3808 /// that an unnamed union or struct is actually an anonymous union or 3809 /// struct, e.g., 3810 /// 3811 /// @code 3812 /// union { 3813 /// int i; 3814 /// float f; 3815 /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and 3816 /// // f into the surrounding scope.x 3817 /// @endcode 3818 /// 3819 /// This routine is recursive, injecting the names of nested anonymous 3820 /// structs/unions into the owning context and scope as well. 3821 static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, 3822 DeclContext *Owner, 3823 RecordDecl *AnonRecord, 3824 AccessSpecifier AS, 3825 SmallVectorImpl<NamedDecl *> &Chaining, 3826 bool MSAnonStruct) { 3827 unsigned diagKind 3828 = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl 3829 : diag::err_anonymous_struct_member_redecl; 3830 3831 bool Invalid = false; 3832 3833 // Look every FieldDecl and IndirectFieldDecl with a name. 3834 for (auto *D : AnonRecord->decls()) { 3835 if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) && 3836 cast<NamedDecl>(D)->getDeclName()) { 3837 ValueDecl *VD = cast<ValueDecl>(D); 3838 if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(), 3839 VD->getLocation(), diagKind)) { 3840 // C++ [class.union]p2: 3841 // The names of the members of an anonymous union shall be 3842 // distinct from the names of any other entity in the 3843 // scope in which the anonymous union is declared. 3844 Invalid = true; 3845 } else { 3846 // C++ [class.union]p2: 3847 // For the purpose of name lookup, after the anonymous union 3848 // definition, the members of the anonymous union are 3849 // considered to have been defined in the scope in which the 3850 // anonymous union is declared. 3851 unsigned OldChainingSize = Chaining.size(); 3852 if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD)) 3853 Chaining.append(IF->chain_begin(), IF->chain_end()); 3854 else 3855 Chaining.push_back(VD); 3856 3857 assert(Chaining.size() >= 2); 3858 NamedDecl **NamedChain = 3859 new (SemaRef.Context)NamedDecl*[Chaining.size()]; 3860 for (unsigned i = 0; i < Chaining.size(); i++) 3861 NamedChain[i] = Chaining[i]; 3862 3863 IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create( 3864 SemaRef.Context, Owner, VD->getLocation(), VD->getIdentifier(), 3865 VD->getType(), NamedChain, Chaining.size()); 3866 3867 for (const auto *Attr : VD->attrs()) 3868 IndirectField->addAttr(Attr->clone(SemaRef.Context)); 3869 3870 IndirectField->setAccess(AS); 3871 IndirectField->setImplicit(); 3872 SemaRef.PushOnScopeChains(IndirectField, S); 3873 3874 // That includes picking up the appropriate access specifier. 3875 if (AS != AS_none) IndirectField->setAccess(AS); 3876 3877 Chaining.resize(OldChainingSize); 3878 } 3879 } 3880 } 3881 3882 return Invalid; 3883 } 3884 3885 /// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to 3886 /// a VarDecl::StorageClass. Any error reporting is up to the caller: 3887 /// illegal input values are mapped to SC_None. 3888 static StorageClass 3889 StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) { 3890 DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec(); 3891 assert(StorageClassSpec != DeclSpec::SCS_typedef && 3892 "Parser allowed 'typedef' as storage class VarDecl."); 3893 switch (StorageClassSpec) { 3894 case DeclSpec::SCS_unspecified: return SC_None; 3895 case DeclSpec::SCS_extern: 3896 if (DS.isExternInLinkageSpec()) 3897 return SC_None; 3898 return SC_Extern; 3899 case DeclSpec::SCS_static: return SC_Static; 3900 case DeclSpec::SCS_auto: return SC_Auto; 3901 case DeclSpec::SCS_register: return SC_Register; 3902 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 3903 // Illegal SCSs map to None: error reporting is up to the caller. 3904 case DeclSpec::SCS_mutable: // Fall through. 3905 case DeclSpec::SCS_typedef: return SC_None; 3906 } 3907 llvm_unreachable("unknown storage class specifier"); 3908 } 3909 3910 static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record) { 3911 assert(Record->hasInClassInitializer()); 3912 3913 for (const auto *I : Record->decls()) { 3914 const auto *FD = dyn_cast<FieldDecl>(I); 3915 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I)) 3916 FD = IFD->getAnonField(); 3917 if (FD && FD->hasInClassInitializer()) 3918 return FD->getLocation(); 3919 } 3920 3921 llvm_unreachable("couldn't find in-class initializer"); 3922 } 3923 3924 static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, 3925 SourceLocation DefaultInitLoc) { 3926 if (!Parent->isUnion() || !Parent->hasInClassInitializer()) 3927 return; 3928 3929 S.Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization); 3930 S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0; 3931 } 3932 3933 static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, 3934 CXXRecordDecl *AnonUnion) { 3935 if (!Parent->isUnion() || !Parent->hasInClassInitializer()) 3936 return; 3937 3938 checkDuplicateDefaultInit(S, Parent, findDefaultInitializer(AnonUnion)); 3939 } 3940 3941 /// BuildAnonymousStructOrUnion - Handle the declaration of an 3942 /// anonymous structure or union. Anonymous unions are a C++ feature 3943 /// (C++ [class.union]) and a C11 feature; anonymous structures 3944 /// are a C11 feature and GNU C++ extension. 3945 Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, 3946 AccessSpecifier AS, 3947 RecordDecl *Record, 3948 const PrintingPolicy &Policy) { 3949 DeclContext *Owner = Record->getDeclContext(); 3950 3951 // Diagnose whether this anonymous struct/union is an extension. 3952 if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11) 3953 Diag(Record->getLocation(), diag::ext_anonymous_union); 3954 else if (!Record->isUnion() && getLangOpts().CPlusPlus) 3955 Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct); 3956 else if (!Record->isUnion() && !getLangOpts().C11) 3957 Diag(Record->getLocation(), diag::ext_c11_anonymous_struct); 3958 3959 // C and C++ require different kinds of checks for anonymous 3960 // structs/unions. 3961 bool Invalid = false; 3962 if (getLangOpts().CPlusPlus) { 3963 const char *PrevSpec = nullptr; 3964 unsigned DiagID; 3965 if (Record->isUnion()) { 3966 // C++ [class.union]p6: 3967 // Anonymous unions declared in a named namespace or in the 3968 // global namespace shall be declared static. 3969 if (DS.getStorageClassSpec() != DeclSpec::SCS_static && 3970 (isa<TranslationUnitDecl>(Owner) || 3971 (isa<NamespaceDecl>(Owner) && 3972 cast<NamespaceDecl>(Owner)->getDeclName()))) { 3973 Diag(Record->getLocation(), diag::err_anonymous_union_not_static) 3974 << FixItHint::CreateInsertion(Record->getLocation(), "static "); 3975 3976 // Recover by adding 'static'. 3977 DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(), 3978 PrevSpec, DiagID, Policy); 3979 } 3980 // C++ [class.union]p6: 3981 // A storage class is not allowed in a declaration of an 3982 // anonymous union in a class scope. 3983 else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && 3984 isa<RecordDecl>(Owner)) { 3985 Diag(DS.getStorageClassSpecLoc(), 3986 diag::err_anonymous_union_with_storage_spec) 3987 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 3988 3989 // Recover by removing the storage specifier. 3990 DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified, 3991 SourceLocation(), 3992 PrevSpec, DiagID, Context.getPrintingPolicy()); 3993 } 3994 } 3995 3996 // Ignore const/volatile/restrict qualifiers. 3997 if (DS.getTypeQualifiers()) { 3998 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 3999 Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified) 4000 << Record->isUnion() << "const" 4001 << FixItHint::CreateRemoval(DS.getConstSpecLoc()); 4002 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 4003 Diag(DS.getVolatileSpecLoc(), 4004 diag::ext_anonymous_struct_union_qualified) 4005 << Record->isUnion() << "volatile" 4006 << FixItHint::CreateRemoval(DS.getVolatileSpecLoc()); 4007 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict) 4008 Diag(DS.getRestrictSpecLoc(), 4009 diag::ext_anonymous_struct_union_qualified) 4010 << Record->isUnion() << "restrict" 4011 << FixItHint::CreateRemoval(DS.getRestrictSpecLoc()); 4012 if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic) 4013 Diag(DS.getAtomicSpecLoc(), 4014 diag::ext_anonymous_struct_union_qualified) 4015 << Record->isUnion() << "_Atomic" 4016 << FixItHint::CreateRemoval(DS.getAtomicSpecLoc()); 4017 4018 DS.ClearTypeQualifiers(); 4019 } 4020 4021 // C++ [class.union]p2: 4022 // The member-specification of an anonymous union shall only 4023 // define non-static data members. [Note: nested types and 4024 // functions cannot be declared within an anonymous union. ] 4025 for (auto *Mem : Record->decls()) { 4026 if (auto *FD = dyn_cast<FieldDecl>(Mem)) { 4027 // C++ [class.union]p3: 4028 // An anonymous union shall not have private or protected 4029 // members (clause 11). 4030 assert(FD->getAccess() != AS_none); 4031 if (FD->getAccess() != AS_public) { 4032 Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member) 4033 << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected); 4034 Invalid = true; 4035 } 4036 4037 // C++ [class.union]p1 4038 // An object of a class with a non-trivial constructor, a non-trivial 4039 // copy constructor, a non-trivial destructor, or a non-trivial copy 4040 // assignment operator cannot be a member of a union, nor can an 4041 // array of such objects. 4042 if (CheckNontrivialField(FD)) 4043 Invalid = true; 4044 } else if (Mem->isImplicit()) { 4045 // Any implicit members are fine. 4046 } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) { 4047 // This is a type that showed up in an 4048 // elaborated-type-specifier inside the anonymous struct or 4049 // union, but which actually declares a type outside of the 4050 // anonymous struct or union. It's okay. 4051 } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) { 4052 if (!MemRecord->isAnonymousStructOrUnion() && 4053 MemRecord->getDeclName()) { 4054 // Visual C++ allows type definition in anonymous struct or union. 4055 if (getLangOpts().MicrosoftExt) 4056 Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type) 4057 << (int)Record->isUnion(); 4058 else { 4059 // This is a nested type declaration. 4060 Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type) 4061 << (int)Record->isUnion(); 4062 Invalid = true; 4063 } 4064 } else { 4065 // This is an anonymous type definition within another anonymous type. 4066 // This is a popular extension, provided by Plan9, MSVC and GCC, but 4067 // not part of standard C++. 4068 Diag(MemRecord->getLocation(), 4069 diag::ext_anonymous_record_with_anonymous_type) 4070 << (int)Record->isUnion(); 4071 } 4072 } else if (isa<AccessSpecDecl>(Mem)) { 4073 // Any access specifier is fine. 4074 } else if (isa<StaticAssertDecl>(Mem)) { 4075 // In C++1z, static_assert declarations are also fine. 4076 } else { 4077 // We have something that isn't a non-static data 4078 // member. Complain about it. 4079 unsigned DK = diag::err_anonymous_record_bad_member; 4080 if (isa<TypeDecl>(Mem)) 4081 DK = diag::err_anonymous_record_with_type; 4082 else if (isa<FunctionDecl>(Mem)) 4083 DK = diag::err_anonymous_record_with_function; 4084 else if (isa<VarDecl>(Mem)) 4085 DK = diag::err_anonymous_record_with_static; 4086 4087 // Visual C++ allows type definition in anonymous struct or union. 4088 if (getLangOpts().MicrosoftExt && 4089 DK == diag::err_anonymous_record_with_type) 4090 Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type) 4091 << (int)Record->isUnion(); 4092 else { 4093 Diag(Mem->getLocation(), DK) 4094 << (int)Record->isUnion(); 4095 Invalid = true; 4096 } 4097 } 4098 } 4099 4100 // C++11 [class.union]p8 (DR1460): 4101 // At most one variant member of a union may have a 4102 // brace-or-equal-initializer. 4103 if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() && 4104 Owner->isRecord()) 4105 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Owner), 4106 cast<CXXRecordDecl>(Record)); 4107 } 4108 4109 if (!Record->isUnion() && !Owner->isRecord()) { 4110 Diag(Record->getLocation(), diag::err_anonymous_struct_not_member) 4111 << (int)getLangOpts().CPlusPlus; 4112 Invalid = true; 4113 } 4114 4115 // Mock up a declarator. 4116 Declarator Dc(DS, Declarator::MemberContext); 4117 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 4118 assert(TInfo && "couldn't build declarator info for anonymous struct/union"); 4119 4120 // Create a declaration for this anonymous struct/union. 4121 NamedDecl *Anon = nullptr; 4122 if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) { 4123 Anon = FieldDecl::Create(Context, OwningClass, 4124 DS.getLocStart(), 4125 Record->getLocation(), 4126 /*IdentifierInfo=*/nullptr, 4127 Context.getTypeDeclType(Record), 4128 TInfo, 4129 /*BitWidth=*/nullptr, /*Mutable=*/false, 4130 /*InitStyle=*/ICIS_NoInit); 4131 Anon->setAccess(AS); 4132 if (getLangOpts().CPlusPlus) 4133 FieldCollector->Add(cast<FieldDecl>(Anon)); 4134 } else { 4135 DeclSpec::SCS SCSpec = DS.getStorageClassSpec(); 4136 StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS); 4137 if (SCSpec == DeclSpec::SCS_mutable) { 4138 // mutable can only appear on non-static class members, so it's always 4139 // an error here 4140 Diag(Record->getLocation(), diag::err_mutable_nonmember); 4141 Invalid = true; 4142 SC = SC_None; 4143 } 4144 4145 Anon = VarDecl::Create(Context, Owner, 4146 DS.getLocStart(), 4147 Record->getLocation(), /*IdentifierInfo=*/nullptr, 4148 Context.getTypeDeclType(Record), 4149 TInfo, SC); 4150 4151 // Default-initialize the implicit variable. This initialization will be 4152 // trivial in almost all cases, except if a union member has an in-class 4153 // initializer: 4154 // union { int n = 0; }; 4155 ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false); 4156 } 4157 Anon->setImplicit(); 4158 4159 // Mark this as an anonymous struct/union type. 4160 Record->setAnonymousStructOrUnion(true); 4161 4162 // Add the anonymous struct/union object to the current 4163 // context. We'll be referencing this object when we refer to one of 4164 // its members. 4165 Owner->addDecl(Anon); 4166 4167 // Inject the members of the anonymous struct/union into the owning 4168 // context and into the identifier resolver chain for name lookup 4169 // purposes. 4170 SmallVector<NamedDecl*, 2> Chain; 4171 Chain.push_back(Anon); 4172 4173 if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS, 4174 Chain, false)) 4175 Invalid = true; 4176 4177 if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) { 4178 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) { 4179 Decl *ManglingContextDecl; 4180 if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext( 4181 NewVD->getDeclContext(), ManglingContextDecl)) { 4182 Context.setManglingNumber( 4183 NewVD, MCtx->getManglingNumber( 4184 NewVD, getMSManglingNumber(getLangOpts(), S))); 4185 Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD)); 4186 } 4187 } 4188 } 4189 4190 if (Invalid) 4191 Anon->setInvalidDecl(); 4192 4193 return Anon; 4194 } 4195 4196 /// BuildMicrosoftCAnonymousStruct - Handle the declaration of an 4197 /// Microsoft C anonymous structure. 4198 /// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx 4199 /// Example: 4200 /// 4201 /// struct A { int a; }; 4202 /// struct B { struct A; int b; }; 4203 /// 4204 /// void foo() { 4205 /// B var; 4206 /// var.a = 3; 4207 /// } 4208 /// 4209 Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, 4210 RecordDecl *Record) { 4211 assert(Record && "expected a record!"); 4212 4213 // Mock up a declarator. 4214 Declarator Dc(DS, Declarator::TypeNameContext); 4215 TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S); 4216 assert(TInfo && "couldn't build declarator info for anonymous struct"); 4217 4218 auto *ParentDecl = cast<RecordDecl>(CurContext); 4219 QualType RecTy = Context.getTypeDeclType(Record); 4220 4221 // Create a declaration for this anonymous struct. 4222 NamedDecl *Anon = FieldDecl::Create(Context, 4223 ParentDecl, 4224 DS.getLocStart(), 4225 DS.getLocStart(), 4226 /*IdentifierInfo=*/nullptr, 4227 RecTy, 4228 TInfo, 4229 /*BitWidth=*/nullptr, /*Mutable=*/false, 4230 /*InitStyle=*/ICIS_NoInit); 4231 Anon->setImplicit(); 4232 4233 // Add the anonymous struct object to the current context. 4234 CurContext->addDecl(Anon); 4235 4236 // Inject the members of the anonymous struct into the current 4237 // context and into the identifier resolver chain for name lookup 4238 // purposes. 4239 SmallVector<NamedDecl*, 2> Chain; 4240 Chain.push_back(Anon); 4241 4242 RecordDecl *RecordDef = Record->getDefinition(); 4243 if (RequireCompleteType(Anon->getLocation(), RecTy, 4244 diag::err_field_incomplete) || 4245 InjectAnonymousStructOrUnionMembers(*this, S, CurContext, RecordDef, 4246 AS_none, Chain, true)) { 4247 Anon->setInvalidDecl(); 4248 ParentDecl->setInvalidDecl(); 4249 } 4250 4251 return Anon; 4252 } 4253 4254 /// GetNameForDeclarator - Determine the full declaration name for the 4255 /// given Declarator. 4256 DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) { 4257 return GetNameFromUnqualifiedId(D.getName()); 4258 } 4259 4260 /// \brief Retrieves the declaration name from a parsed unqualified-id. 4261 DeclarationNameInfo 4262 Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) { 4263 DeclarationNameInfo NameInfo; 4264 NameInfo.setLoc(Name.StartLocation); 4265 4266 switch (Name.getKind()) { 4267 4268 case UnqualifiedId::IK_ImplicitSelfParam: 4269 case UnqualifiedId::IK_Identifier: 4270 NameInfo.setName(Name.Identifier); 4271 NameInfo.setLoc(Name.StartLocation); 4272 return NameInfo; 4273 4274 case UnqualifiedId::IK_OperatorFunctionId: 4275 NameInfo.setName(Context.DeclarationNames.getCXXOperatorName( 4276 Name.OperatorFunctionId.Operator)); 4277 NameInfo.setLoc(Name.StartLocation); 4278 NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc 4279 = Name.OperatorFunctionId.SymbolLocations[0]; 4280 NameInfo.getInfo().CXXOperatorName.EndOpNameLoc 4281 = Name.EndLocation.getRawEncoding(); 4282 return NameInfo; 4283 4284 case UnqualifiedId::IK_LiteralOperatorId: 4285 NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName( 4286 Name.Identifier)); 4287 NameInfo.setLoc(Name.StartLocation); 4288 NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation); 4289 return NameInfo; 4290 4291 case UnqualifiedId::IK_ConversionFunctionId: { 4292 TypeSourceInfo *TInfo; 4293 QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo); 4294 if (Ty.isNull()) 4295 return DeclarationNameInfo(); 4296 NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName( 4297 Context.getCanonicalType(Ty))); 4298 NameInfo.setLoc(Name.StartLocation); 4299 NameInfo.setNamedTypeInfo(TInfo); 4300 return NameInfo; 4301 } 4302 4303 case UnqualifiedId::IK_ConstructorName: { 4304 TypeSourceInfo *TInfo; 4305 QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo); 4306 if (Ty.isNull()) 4307 return DeclarationNameInfo(); 4308 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 4309 Context.getCanonicalType(Ty))); 4310 NameInfo.setLoc(Name.StartLocation); 4311 NameInfo.setNamedTypeInfo(TInfo); 4312 return NameInfo; 4313 } 4314 4315 case UnqualifiedId::IK_ConstructorTemplateId: { 4316 // In well-formed code, we can only have a constructor 4317 // template-id that refers to the current context, so go there 4318 // to find the actual type being constructed. 4319 CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext); 4320 if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name) 4321 return DeclarationNameInfo(); 4322 4323 // Determine the type of the class being constructed. 4324 QualType CurClassType = Context.getTypeDeclType(CurClass); 4325 4326 // FIXME: Check two things: that the template-id names the same type as 4327 // CurClassType, and that the template-id does not occur when the name 4328 // was qualified. 4329 4330 NameInfo.setName(Context.DeclarationNames.getCXXConstructorName( 4331 Context.getCanonicalType(CurClassType))); 4332 NameInfo.setLoc(Name.StartLocation); 4333 // FIXME: should we retrieve TypeSourceInfo? 4334 NameInfo.setNamedTypeInfo(nullptr); 4335 return NameInfo; 4336 } 4337 4338 case UnqualifiedId::IK_DestructorName: { 4339 TypeSourceInfo *TInfo; 4340 QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo); 4341 if (Ty.isNull()) 4342 return DeclarationNameInfo(); 4343 NameInfo.setName(Context.DeclarationNames.getCXXDestructorName( 4344 Context.getCanonicalType(Ty))); 4345 NameInfo.setLoc(Name.StartLocation); 4346 NameInfo.setNamedTypeInfo(TInfo); 4347 return NameInfo; 4348 } 4349 4350 case UnqualifiedId::IK_TemplateId: { 4351 TemplateName TName = Name.TemplateId->Template.get(); 4352 SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc; 4353 return Context.getNameForTemplate(TName, TNameLoc); 4354 } 4355 4356 } // switch (Name.getKind()) 4357 4358 llvm_unreachable("Unknown name kind"); 4359 } 4360 4361 static QualType getCoreType(QualType Ty) { 4362 do { 4363 if (Ty->isPointerType() || Ty->isReferenceType()) 4364 Ty = Ty->getPointeeType(); 4365 else if (Ty->isArrayType()) 4366 Ty = Ty->castAsArrayTypeUnsafe()->getElementType(); 4367 else 4368 return Ty.withoutLocalFastQualifiers(); 4369 } while (true); 4370 } 4371 4372 /// hasSimilarParameters - Determine whether the C++ functions Declaration 4373 /// and Definition have "nearly" matching parameters. This heuristic is 4374 /// used to improve diagnostics in the case where an out-of-line function 4375 /// definition doesn't match any declaration within the class or namespace. 4376 /// Also sets Params to the list of indices to the parameters that differ 4377 /// between the declaration and the definition. If hasSimilarParameters 4378 /// returns true and Params is empty, then all of the parameters match. 4379 static bool hasSimilarParameters(ASTContext &Context, 4380 FunctionDecl *Declaration, 4381 FunctionDecl *Definition, 4382 SmallVectorImpl<unsigned> &Params) { 4383 Params.clear(); 4384 if (Declaration->param_size() != Definition->param_size()) 4385 return false; 4386 for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) { 4387 QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType(); 4388 QualType DefParamTy = Definition->getParamDecl(Idx)->getType(); 4389 4390 // The parameter types are identical 4391 if (Context.hasSameType(DefParamTy, DeclParamTy)) 4392 continue; 4393 4394 QualType DeclParamBaseTy = getCoreType(DeclParamTy); 4395 QualType DefParamBaseTy = getCoreType(DefParamTy); 4396 const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier(); 4397 const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier(); 4398 4399 if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) || 4400 (DeclTyName && DeclTyName == DefTyName)) 4401 Params.push_back(Idx); 4402 else // The two parameters aren't even close 4403 return false; 4404 } 4405 4406 return true; 4407 } 4408 4409 /// NeedsRebuildingInCurrentInstantiation - Checks whether the given 4410 /// declarator needs to be rebuilt in the current instantiation. 4411 /// Any bits of declarator which appear before the name are valid for 4412 /// consideration here. That's specifically the type in the decl spec 4413 /// and the base type in any member-pointer chunks. 4414 static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, 4415 DeclarationName Name) { 4416 // The types we specifically need to rebuild are: 4417 // - typenames, typeofs, and decltypes 4418 // - types which will become injected class names 4419 // Of course, we also need to rebuild any type referencing such a 4420 // type. It's safest to just say "dependent", but we call out a 4421 // few cases here. 4422 4423 DeclSpec &DS = D.getMutableDeclSpec(); 4424 switch (DS.getTypeSpecType()) { 4425 case DeclSpec::TST_typename: 4426 case DeclSpec::TST_typeofType: 4427 case DeclSpec::TST_underlyingType: 4428 case DeclSpec::TST_atomic: { 4429 // Grab the type from the parser. 4430 TypeSourceInfo *TSI = nullptr; 4431 QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI); 4432 if (T.isNull() || !T->isDependentType()) break; 4433 4434 // Make sure there's a type source info. This isn't really much 4435 // of a waste; most dependent types should have type source info 4436 // attached already. 4437 if (!TSI) 4438 TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc()); 4439 4440 // Rebuild the type in the current instantiation. 4441 TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name); 4442 if (!TSI) return true; 4443 4444 // Store the new type back in the decl spec. 4445 ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI); 4446 DS.UpdateTypeRep(LocType); 4447 break; 4448 } 4449 4450 case DeclSpec::TST_decltype: 4451 case DeclSpec::TST_typeofExpr: { 4452 Expr *E = DS.getRepAsExpr(); 4453 ExprResult Result = S.RebuildExprInCurrentInstantiation(E); 4454 if (Result.isInvalid()) return true; 4455 DS.UpdateExprRep(Result.get()); 4456 break; 4457 } 4458 4459 default: 4460 // Nothing to do for these decl specs. 4461 break; 4462 } 4463 4464 // It doesn't matter what order we do this in. 4465 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) { 4466 DeclaratorChunk &Chunk = D.getTypeObject(I); 4467 4468 // The only type information in the declarator which can come 4469 // before the declaration name is the base type of a member 4470 // pointer. 4471 if (Chunk.Kind != DeclaratorChunk::MemberPointer) 4472 continue; 4473 4474 // Rebuild the scope specifier in-place. 4475 CXXScopeSpec &SS = Chunk.Mem.Scope(); 4476 if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS)) 4477 return true; 4478 } 4479 4480 return false; 4481 } 4482 4483 Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) { 4484 D.setFunctionDefinitionKind(FDK_Declaration); 4485 Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg()); 4486 4487 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() && 4488 Dcl && Dcl->getDeclContext()->isFileContext()) 4489 Dcl->setTopLevelDeclInObjCContainer(); 4490 4491 return Dcl; 4492 } 4493 4494 /// DiagnoseClassNameShadow - Implement C++ [class.mem]p13: 4495 /// If T is the name of a class, then each of the following shall have a 4496 /// name different from T: 4497 /// - every static data member of class T; 4498 /// - every member function of class T 4499 /// - every member of class T that is itself a type; 4500 /// \returns true if the declaration name violates these rules. 4501 bool Sema::DiagnoseClassNameShadow(DeclContext *DC, 4502 DeclarationNameInfo NameInfo) { 4503 DeclarationName Name = NameInfo.getName(); 4504 4505 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC)) 4506 if (Record->getIdentifier() && Record->getDeclName() == Name) { 4507 Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name; 4508 return true; 4509 } 4510 4511 return false; 4512 } 4513 4514 /// \brief Diagnose a declaration whose declarator-id has the given 4515 /// nested-name-specifier. 4516 /// 4517 /// \param SS The nested-name-specifier of the declarator-id. 4518 /// 4519 /// \param DC The declaration context to which the nested-name-specifier 4520 /// resolves. 4521 /// 4522 /// \param Name The name of the entity being declared. 4523 /// 4524 /// \param Loc The location of the name of the entity being declared. 4525 /// 4526 /// \returns true if we cannot safely recover from this error, false otherwise. 4527 bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, 4528 DeclarationName Name, 4529 SourceLocation Loc) { 4530 DeclContext *Cur = CurContext; 4531 while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur)) 4532 Cur = Cur->getParent(); 4533 4534 // If the user provided a superfluous scope specifier that refers back to the 4535 // class in which the entity is already declared, diagnose and ignore it. 4536 // 4537 // class X { 4538 // void X::f(); 4539 // }; 4540 // 4541 // Note, it was once ill-formed to give redundant qualification in all 4542 // contexts, but that rule was removed by DR482. 4543 if (Cur->Equals(DC)) { 4544 if (Cur->isRecord()) { 4545 Diag(Loc, LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification 4546 : diag::err_member_extra_qualification) 4547 << Name << FixItHint::CreateRemoval(SS.getRange()); 4548 SS.clear(); 4549 } else { 4550 Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name; 4551 } 4552 return false; 4553 } 4554 4555 // Check whether the qualifying scope encloses the scope of the original 4556 // declaration. 4557 if (!Cur->Encloses(DC)) { 4558 if (Cur->isRecord()) 4559 Diag(Loc, diag::err_member_qualification) 4560 << Name << SS.getRange(); 4561 else if (isa<TranslationUnitDecl>(DC)) 4562 Diag(Loc, diag::err_invalid_declarator_global_scope) 4563 << Name << SS.getRange(); 4564 else if (isa<FunctionDecl>(Cur)) 4565 Diag(Loc, diag::err_invalid_declarator_in_function) 4566 << Name << SS.getRange(); 4567 else if (isa<BlockDecl>(Cur)) 4568 Diag(Loc, diag::err_invalid_declarator_in_block) 4569 << Name << SS.getRange(); 4570 else 4571 Diag(Loc, diag::err_invalid_declarator_scope) 4572 << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange(); 4573 4574 return true; 4575 } 4576 4577 if (Cur->isRecord()) { 4578 // Cannot qualify members within a class. 4579 Diag(Loc, diag::err_member_qualification) 4580 << Name << SS.getRange(); 4581 SS.clear(); 4582 4583 // C++ constructors and destructors with incorrect scopes can break 4584 // our AST invariants by having the wrong underlying types. If 4585 // that's the case, then drop this declaration entirely. 4586 if ((Name.getNameKind() == DeclarationName::CXXConstructorName || 4587 Name.getNameKind() == DeclarationName::CXXDestructorName) && 4588 !Context.hasSameType(Name.getCXXNameType(), 4589 Context.getTypeDeclType(cast<CXXRecordDecl>(Cur)))) 4590 return true; 4591 4592 return false; 4593 } 4594 4595 // C++11 [dcl.meaning]p1: 4596 // [...] "The nested-name-specifier of the qualified declarator-id shall 4597 // not begin with a decltype-specifer" 4598 NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data()); 4599 while (SpecLoc.getPrefix()) 4600 SpecLoc = SpecLoc.getPrefix(); 4601 if (dyn_cast_or_null<DecltypeType>( 4602 SpecLoc.getNestedNameSpecifier()->getAsType())) 4603 Diag(Loc, diag::err_decltype_in_declarator) 4604 << SpecLoc.getTypeLoc().getSourceRange(); 4605 4606 return false; 4607 } 4608 4609 NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D, 4610 MultiTemplateParamsArg TemplateParamLists) { 4611 // TODO: consider using NameInfo for diagnostic. 4612 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 4613 DeclarationName Name = NameInfo.getName(); 4614 4615 // All of these full declarators require an identifier. If it doesn't have 4616 // one, the ParsedFreeStandingDeclSpec action should be used. 4617 if (!Name) { 4618 if (!D.isInvalidType()) // Reject this if we think it is valid. 4619 Diag(D.getDeclSpec().getLocStart(), 4620 diag::err_declarator_need_ident) 4621 << D.getDeclSpec().getSourceRange() << D.getSourceRange(); 4622 return nullptr; 4623 } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType)) 4624 return nullptr; 4625 4626 // The scope passed in may not be a decl scope. Zip up the scope tree until 4627 // we find one that is. 4628 while ((S->getFlags() & Scope::DeclScope) == 0 || 4629 (S->getFlags() & Scope::TemplateParamScope) != 0) 4630 S = S->getParent(); 4631 4632 DeclContext *DC = CurContext; 4633 if (D.getCXXScopeSpec().isInvalid()) 4634 D.setInvalidType(); 4635 else if (D.getCXXScopeSpec().isSet()) { 4636 if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(), 4637 UPPC_DeclarationQualifier)) 4638 return nullptr; 4639 4640 bool EnteringContext = !D.getDeclSpec().isFriendSpecified(); 4641 DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext); 4642 if (!DC || isa<EnumDecl>(DC)) { 4643 // If we could not compute the declaration context, it's because the 4644 // declaration context is dependent but does not refer to a class, 4645 // class template, or class template partial specialization. Complain 4646 // and return early, to avoid the coming semantic disaster. 4647 Diag(D.getIdentifierLoc(), 4648 diag::err_template_qualified_declarator_no_match) 4649 << D.getCXXScopeSpec().getScopeRep() 4650 << D.getCXXScopeSpec().getRange(); 4651 return nullptr; 4652 } 4653 bool IsDependentContext = DC->isDependentContext(); 4654 4655 if (!IsDependentContext && 4656 RequireCompleteDeclContext(D.getCXXScopeSpec(), DC)) 4657 return nullptr; 4658 4659 if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) { 4660 Diag(D.getIdentifierLoc(), 4661 diag::err_member_def_undefined_record) 4662 << Name << DC << D.getCXXScopeSpec().getRange(); 4663 D.setInvalidType(); 4664 } else if (!D.getDeclSpec().isFriendSpecified()) { 4665 if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC, 4666 Name, D.getIdentifierLoc())) { 4667 if (DC->isRecord()) 4668 return nullptr; 4669 4670 D.setInvalidType(); 4671 } 4672 } 4673 4674 // Check whether we need to rebuild the type of the given 4675 // declaration in the current instantiation. 4676 if (EnteringContext && IsDependentContext && 4677 TemplateParamLists.size() != 0) { 4678 ContextRAII SavedContext(*this, DC); 4679 if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name)) 4680 D.setInvalidType(); 4681 } 4682 } 4683 4684 if (DiagnoseClassNameShadow(DC, NameInfo)) 4685 // If this is a typedef, we'll end up spewing multiple diagnostics. 4686 // Just return early; it's safer. 4687 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 4688 return nullptr; 4689 4690 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 4691 QualType R = TInfo->getType(); 4692 4693 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 4694 UPPC_DeclarationType)) 4695 D.setInvalidType(); 4696 4697 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, 4698 ForRedeclaration); 4699 4700 // See if this is a redefinition of a variable in the same scope. 4701 if (!D.getCXXScopeSpec().isSet()) { 4702 bool IsLinkageLookup = false; 4703 bool CreateBuiltins = false; 4704 4705 // If the declaration we're planning to build will be a function 4706 // or object with linkage, then look for another declaration with 4707 // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6). 4708 // 4709 // If the declaration we're planning to build will be declared with 4710 // external linkage in the translation unit, create any builtin with 4711 // the same name. 4712 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 4713 /* Do nothing*/; 4714 else if (CurContext->isFunctionOrMethod() && 4715 (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern || 4716 R->isFunctionType())) { 4717 IsLinkageLookup = true; 4718 CreateBuiltins = 4719 CurContext->getEnclosingNamespaceContext()->isTranslationUnit(); 4720 } else if (CurContext->getRedeclContext()->isTranslationUnit() && 4721 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) 4722 CreateBuiltins = true; 4723 4724 if (IsLinkageLookup) 4725 Previous.clear(LookupRedeclarationWithLinkage); 4726 4727 LookupName(Previous, S, CreateBuiltins); 4728 } else { // Something like "int foo::x;" 4729 LookupQualifiedName(Previous, DC); 4730 4731 // C++ [dcl.meaning]p1: 4732 // When the declarator-id is qualified, the declaration shall refer to a 4733 // previously declared member of the class or namespace to which the 4734 // qualifier refers (or, in the case of a namespace, of an element of the 4735 // inline namespace set of that namespace (7.3.1)) or to a specialization 4736 // thereof; [...] 4737 // 4738 // Note that we already checked the context above, and that we do not have 4739 // enough information to make sure that Previous contains the declaration 4740 // we want to match. For example, given: 4741 // 4742 // class X { 4743 // void f(); 4744 // void f(float); 4745 // }; 4746 // 4747 // void X::f(int) { } // ill-formed 4748 // 4749 // In this case, Previous will point to the overload set 4750 // containing the two f's declared in X, but neither of them 4751 // matches. 4752 4753 // C++ [dcl.meaning]p1: 4754 // [...] the member shall not merely have been introduced by a 4755 // using-declaration in the scope of the class or namespace nominated by 4756 // the nested-name-specifier of the declarator-id. 4757 RemoveUsingDecls(Previous); 4758 } 4759 4760 if (Previous.isSingleResult() && 4761 Previous.getFoundDecl()->isTemplateParameter()) { 4762 // Maybe we will complain about the shadowed template parameter. 4763 if (!D.isInvalidType()) 4764 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), 4765 Previous.getFoundDecl()); 4766 4767 // Just pretend that we didn't see the previous declaration. 4768 Previous.clear(); 4769 } 4770 4771 // In C++, the previous declaration we find might be a tag type 4772 // (class or enum). In this case, the new declaration will hide the 4773 // tag type. Note that this does does not apply if we're declaring a 4774 // typedef (C++ [dcl.typedef]p4). 4775 if (Previous.isSingleTagDecl() && 4776 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef) 4777 Previous.clear(); 4778 4779 // Check that there are no default arguments other than in the parameters 4780 // of a function declaration (C++ only). 4781 if (getLangOpts().CPlusPlus) 4782 CheckExtraCXXDefaultArguments(D); 4783 4784 NamedDecl *New; 4785 4786 bool AddToScope = true; 4787 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) { 4788 if (TemplateParamLists.size()) { 4789 Diag(D.getIdentifierLoc(), diag::err_template_typedef); 4790 return nullptr; 4791 } 4792 4793 New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous); 4794 } else if (R->isFunctionType()) { 4795 New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous, 4796 TemplateParamLists, 4797 AddToScope); 4798 } else { 4799 New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists, 4800 AddToScope); 4801 } 4802 4803 if (!New) 4804 return nullptr; 4805 4806 // If this has an identifier and is not an invalid redeclaration or 4807 // function template specialization, add it to the scope stack. 4808 if (New->getDeclName() && AddToScope && 4809 !(D.isRedeclaration() && New->isInvalidDecl())) { 4810 // Only make a locally-scoped extern declaration visible if it is the first 4811 // declaration of this entity. Qualified lookup for such an entity should 4812 // only find this declaration if there is no visible declaration of it. 4813 bool AddToContext = !D.isRedeclaration() || !New->isLocalExternDecl(); 4814 PushOnScopeChains(New, S, AddToContext); 4815 if (!AddToContext) 4816 CurContext->addHiddenDecl(New); 4817 } 4818 4819 return New; 4820 } 4821 4822 /// Helper method to turn variable array types into constant array 4823 /// types in certain situations which would otherwise be errors (for 4824 /// GCC compatibility). 4825 static QualType TryToFixInvalidVariablyModifiedType(QualType T, 4826 ASTContext &Context, 4827 bool &SizeIsNegative, 4828 llvm::APSInt &Oversized) { 4829 // This method tries to turn a variable array into a constant 4830 // array even when the size isn't an ICE. This is necessary 4831 // for compatibility with code that depends on gcc's buggy 4832 // constant expression folding, like struct {char x[(int)(char*)2];} 4833 SizeIsNegative = false; 4834 Oversized = 0; 4835 4836 if (T->isDependentType()) 4837 return QualType(); 4838 4839 QualifierCollector Qs; 4840 const Type *Ty = Qs.strip(T); 4841 4842 if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) { 4843 QualType Pointee = PTy->getPointeeType(); 4844 QualType FixedType = 4845 TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative, 4846 Oversized); 4847 if (FixedType.isNull()) return FixedType; 4848 FixedType = Context.getPointerType(FixedType); 4849 return Qs.apply(Context, FixedType); 4850 } 4851 if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) { 4852 QualType Inner = PTy->getInnerType(); 4853 QualType FixedType = 4854 TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative, 4855 Oversized); 4856 if (FixedType.isNull()) return FixedType; 4857 FixedType = Context.getParenType(FixedType); 4858 return Qs.apply(Context, FixedType); 4859 } 4860 4861 const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T); 4862 if (!VLATy) 4863 return QualType(); 4864 // FIXME: We should probably handle this case 4865 if (VLATy->getElementType()->isVariablyModifiedType()) 4866 return QualType(); 4867 4868 llvm::APSInt Res; 4869 if (!VLATy->getSizeExpr() || 4870 !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context)) 4871 return QualType(); 4872 4873 // Check whether the array size is negative. 4874 if (Res.isSigned() && Res.isNegative()) { 4875 SizeIsNegative = true; 4876 return QualType(); 4877 } 4878 4879 // Check whether the array is too large to be addressed. 4880 unsigned ActiveSizeBits 4881 = ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(), 4882 Res); 4883 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) { 4884 Oversized = Res; 4885 return QualType(); 4886 } 4887 4888 return Context.getConstantArrayType(VLATy->getElementType(), 4889 Res, ArrayType::Normal, 0); 4890 } 4891 4892 static void 4893 FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) { 4894 if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) { 4895 PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>(); 4896 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(), 4897 DstPTL.getPointeeLoc()); 4898 DstPTL.setStarLoc(SrcPTL.getStarLoc()); 4899 return; 4900 } 4901 if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) { 4902 ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>(); 4903 FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(), 4904 DstPTL.getInnerLoc()); 4905 DstPTL.setLParenLoc(SrcPTL.getLParenLoc()); 4906 DstPTL.setRParenLoc(SrcPTL.getRParenLoc()); 4907 return; 4908 } 4909 ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>(); 4910 ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>(); 4911 TypeLoc SrcElemTL = SrcATL.getElementLoc(); 4912 TypeLoc DstElemTL = DstATL.getElementLoc(); 4913 DstElemTL.initializeFullCopy(SrcElemTL); 4914 DstATL.setLBracketLoc(SrcATL.getLBracketLoc()); 4915 DstATL.setSizeExpr(SrcATL.getSizeExpr()); 4916 DstATL.setRBracketLoc(SrcATL.getRBracketLoc()); 4917 } 4918 4919 /// Helper method to turn variable array types into constant array 4920 /// types in certain situations which would otherwise be errors (for 4921 /// GCC compatibility). 4922 static TypeSourceInfo* 4923 TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, 4924 ASTContext &Context, 4925 bool &SizeIsNegative, 4926 llvm::APSInt &Oversized) { 4927 QualType FixedTy 4928 = TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context, 4929 SizeIsNegative, Oversized); 4930 if (FixedTy.isNull()) 4931 return nullptr; 4932 TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy); 4933 FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(), 4934 FixedTInfo->getTypeLoc()); 4935 return FixedTInfo; 4936 } 4937 4938 /// \brief Register the given locally-scoped extern "C" declaration so 4939 /// that it can be found later for redeclarations. We include any extern "C" 4940 /// declaration that is not visible in the translation unit here, not just 4941 /// function-scope declarations. 4942 void 4943 Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) { 4944 if (!getLangOpts().CPlusPlus && 4945 ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit()) 4946 // Don't need to track declarations in the TU in C. 4947 return; 4948 4949 // Note that we have a locally-scoped external with this name. 4950 Context.getExternCContextDecl()->makeDeclVisibleInContext(ND); 4951 } 4952 4953 NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) { 4954 // FIXME: We can have multiple results via __attribute__((overloadable)). 4955 auto Result = Context.getExternCContextDecl()->lookup(Name); 4956 return Result.empty() ? nullptr : *Result.begin(); 4957 } 4958 4959 /// \brief Diagnose function specifiers on a declaration of an identifier that 4960 /// does not identify a function. 4961 void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) { 4962 // FIXME: We should probably indicate the identifier in question to avoid 4963 // confusion for constructs like "inline int a(), b;" 4964 if (DS.isInlineSpecified()) 4965 Diag(DS.getInlineSpecLoc(), 4966 diag::err_inline_non_function); 4967 4968 if (DS.isVirtualSpecified()) 4969 Diag(DS.getVirtualSpecLoc(), 4970 diag::err_virtual_non_function); 4971 4972 if (DS.isExplicitSpecified()) 4973 Diag(DS.getExplicitSpecLoc(), 4974 diag::err_explicit_non_function); 4975 4976 if (DS.isNoreturnSpecified()) 4977 Diag(DS.getNoreturnSpecLoc(), 4978 diag::err_noreturn_non_function); 4979 } 4980 4981 NamedDecl* 4982 Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC, 4983 TypeSourceInfo *TInfo, LookupResult &Previous) { 4984 // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1). 4985 if (D.getCXXScopeSpec().isSet()) { 4986 Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator) 4987 << D.getCXXScopeSpec().getRange(); 4988 D.setInvalidType(); 4989 // Pretend we didn't see the scope specifier. 4990 DC = CurContext; 4991 Previous.clear(); 4992 } 4993 4994 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 4995 4996 if (D.getDeclSpec().isConstexprSpecified()) 4997 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr) 4998 << 1; 4999 5000 if (D.getName().Kind != UnqualifiedId::IK_Identifier) { 5001 Diag(D.getName().StartLocation, diag::err_typedef_not_identifier) 5002 << D.getName().getSourceRange(); 5003 return nullptr; 5004 } 5005 5006 TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo); 5007 if (!NewTD) return nullptr; 5008 5009 // Handle attributes prior to checking for duplicates in MergeVarDecl 5010 ProcessDeclAttributes(S, NewTD, D); 5011 5012 CheckTypedefForVariablyModifiedType(S, NewTD); 5013 5014 bool Redeclaration = D.isRedeclaration(); 5015 NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration); 5016 D.setRedeclaration(Redeclaration); 5017 return ND; 5018 } 5019 5020 void 5021 Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) { 5022 // C99 6.7.7p2: If a typedef name specifies a variably modified type 5023 // then it shall have block scope. 5024 // Note that variably modified types must be fixed before merging the decl so 5025 // that redeclarations will match. 5026 TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo(); 5027 QualType T = TInfo->getType(); 5028 if (T->isVariablyModifiedType()) { 5029 getCurFunction()->setHasBranchProtectedScope(); 5030 5031 if (S->getFnParent() == nullptr) { 5032 bool SizeIsNegative; 5033 llvm::APSInt Oversized; 5034 TypeSourceInfo *FixedTInfo = 5035 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 5036 SizeIsNegative, 5037 Oversized); 5038 if (FixedTInfo) { 5039 Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size); 5040 NewTD->setTypeSourceInfo(FixedTInfo); 5041 } else { 5042 if (SizeIsNegative) 5043 Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size); 5044 else if (T->isVariableArrayType()) 5045 Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope); 5046 else if (Oversized.getBoolValue()) 5047 Diag(NewTD->getLocation(), diag::err_array_too_large) 5048 << Oversized.toString(10); 5049 else 5050 Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope); 5051 NewTD->setInvalidDecl(); 5052 } 5053 } 5054 } 5055 } 5056 5057 5058 /// ActOnTypedefNameDecl - Perform semantic checking for a declaration which 5059 /// declares a typedef-name, either using the 'typedef' type specifier or via 5060 /// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'. 5061 NamedDecl* 5062 Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD, 5063 LookupResult &Previous, bool &Redeclaration) { 5064 // Merge the decl with the existing one if appropriate. If the decl is 5065 // in an outer scope, it isn't the same thing. 5066 FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/false, 5067 /*AllowInlineNamespace*/false); 5068 filterNonConflictingPreviousTypedefDecls(Context, NewTD, Previous); 5069 if (!Previous.empty()) { 5070 Redeclaration = true; 5071 MergeTypedefNameDecl(NewTD, Previous); 5072 } 5073 5074 // If this is the C FILE type, notify the AST context. 5075 if (IdentifierInfo *II = NewTD->getIdentifier()) 5076 if (!NewTD->isInvalidDecl() && 5077 NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 5078 if (II->isStr("FILE")) 5079 Context.setFILEDecl(NewTD); 5080 else if (II->isStr("jmp_buf")) 5081 Context.setjmp_bufDecl(NewTD); 5082 else if (II->isStr("sigjmp_buf")) 5083 Context.setsigjmp_bufDecl(NewTD); 5084 else if (II->isStr("ucontext_t")) 5085 Context.setucontext_tDecl(NewTD); 5086 } 5087 5088 return NewTD; 5089 } 5090 5091 /// \brief Determines whether the given declaration is an out-of-scope 5092 /// previous declaration. 5093 /// 5094 /// This routine should be invoked when name lookup has found a 5095 /// previous declaration (PrevDecl) that is not in the scope where a 5096 /// new declaration by the same name is being introduced. If the new 5097 /// declaration occurs in a local scope, previous declarations with 5098 /// linkage may still be considered previous declarations (C99 5099 /// 6.2.2p4-5, C++ [basic.link]p6). 5100 /// 5101 /// \param PrevDecl the previous declaration found by name 5102 /// lookup 5103 /// 5104 /// \param DC the context in which the new declaration is being 5105 /// declared. 5106 /// 5107 /// \returns true if PrevDecl is an out-of-scope previous declaration 5108 /// for a new delcaration with the same name. 5109 static bool 5110 isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC, 5111 ASTContext &Context) { 5112 if (!PrevDecl) 5113 return false; 5114 5115 if (!PrevDecl->hasLinkage()) 5116 return false; 5117 5118 if (Context.getLangOpts().CPlusPlus) { 5119 // C++ [basic.link]p6: 5120 // If there is a visible declaration of an entity with linkage 5121 // having the same name and type, ignoring entities declared 5122 // outside the innermost enclosing namespace scope, the block 5123 // scope declaration declares that same entity and receives the 5124 // linkage of the previous declaration. 5125 DeclContext *OuterContext = DC->getRedeclContext(); 5126 if (!OuterContext->isFunctionOrMethod()) 5127 // This rule only applies to block-scope declarations. 5128 return false; 5129 5130 DeclContext *PrevOuterContext = PrevDecl->getDeclContext(); 5131 if (PrevOuterContext->isRecord()) 5132 // We found a member function: ignore it. 5133 return false; 5134 5135 // Find the innermost enclosing namespace for the new and 5136 // previous declarations. 5137 OuterContext = OuterContext->getEnclosingNamespaceContext(); 5138 PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext(); 5139 5140 // The previous declaration is in a different namespace, so it 5141 // isn't the same function. 5142 if (!OuterContext->Equals(PrevOuterContext)) 5143 return false; 5144 } 5145 5146 return true; 5147 } 5148 5149 static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) { 5150 CXXScopeSpec &SS = D.getCXXScopeSpec(); 5151 if (!SS.isSet()) return; 5152 DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext())); 5153 } 5154 5155 bool Sema::inferObjCARCLifetime(ValueDecl *decl) { 5156 QualType type = decl->getType(); 5157 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime(); 5158 if (lifetime == Qualifiers::OCL_Autoreleasing) { 5159 // Various kinds of declaration aren't allowed to be __autoreleasing. 5160 unsigned kind = -1U; 5161 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 5162 if (var->hasAttr<BlocksAttr>()) 5163 kind = 0; // __block 5164 else if (!var->hasLocalStorage()) 5165 kind = 1; // global 5166 } else if (isa<ObjCIvarDecl>(decl)) { 5167 kind = 3; // ivar 5168 } else if (isa<FieldDecl>(decl)) { 5169 kind = 2; // field 5170 } 5171 5172 if (kind != -1U) { 5173 Diag(decl->getLocation(), diag::err_arc_autoreleasing_var) 5174 << kind; 5175 } 5176 } else if (lifetime == Qualifiers::OCL_None) { 5177 // Try to infer lifetime. 5178 if (!type->isObjCLifetimeType()) 5179 return false; 5180 5181 lifetime = type->getObjCARCImplicitLifetime(); 5182 type = Context.getLifetimeQualifiedType(type, lifetime); 5183 decl->setType(type); 5184 } 5185 5186 if (VarDecl *var = dyn_cast<VarDecl>(decl)) { 5187 // Thread-local variables cannot have lifetime. 5188 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone && 5189 var->getTLSKind()) { 5190 Diag(var->getLocation(), diag::err_arc_thread_ownership) 5191 << var->getType(); 5192 return true; 5193 } 5194 } 5195 5196 return false; 5197 } 5198 5199 static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) { 5200 // Ensure that an auto decl is deduced otherwise the checks below might cache 5201 // the wrong linkage. 5202 assert(S.ParsingInitForAutoVars.count(&ND) == 0); 5203 5204 // 'weak' only applies to declarations with external linkage. 5205 if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) { 5206 if (!ND.isExternallyVisible()) { 5207 S.Diag(Attr->getLocation(), diag::err_attribute_weak_static); 5208 ND.dropAttr<WeakAttr>(); 5209 } 5210 } 5211 if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) { 5212 if (ND.isExternallyVisible()) { 5213 S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static); 5214 ND.dropAttr<WeakRefAttr>(); 5215 ND.dropAttr<AliasAttr>(); 5216 } 5217 } 5218 5219 if (auto *VD = dyn_cast<VarDecl>(&ND)) { 5220 if (VD->hasInit()) { 5221 if (const auto *Attr = VD->getAttr<AliasAttr>()) { 5222 assert(VD->isThisDeclarationADefinition() && 5223 !VD->isExternallyVisible() && "Broken AliasAttr handled late!"); 5224 S.Diag(Attr->getLocation(), diag::err_alias_is_definition) << VD; 5225 VD->dropAttr<AliasAttr>(); 5226 } 5227 } 5228 } 5229 5230 // 'selectany' only applies to externally visible varable declarations. 5231 // It does not apply to functions. 5232 if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) { 5233 if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) { 5234 S.Diag(Attr->getLocation(), diag::err_attribute_selectany_non_extern_data); 5235 ND.dropAttr<SelectAnyAttr>(); 5236 } 5237 } 5238 5239 // dll attributes require external linkage. 5240 if (const InheritableAttr *Attr = getDLLAttr(&ND)) { 5241 if (!ND.isExternallyVisible()) { 5242 S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern) 5243 << &ND << Attr; 5244 ND.setInvalidDecl(); 5245 } 5246 } 5247 } 5248 5249 static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, 5250 NamedDecl *NewDecl, 5251 bool IsSpecialization) { 5252 if (TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl)) 5253 OldDecl = OldTD->getTemplatedDecl(); 5254 if (TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl)) 5255 NewDecl = NewTD->getTemplatedDecl(); 5256 5257 if (!OldDecl || !NewDecl) 5258 return; 5259 5260 const DLLImportAttr *OldImportAttr = OldDecl->getAttr<DLLImportAttr>(); 5261 const DLLExportAttr *OldExportAttr = OldDecl->getAttr<DLLExportAttr>(); 5262 const DLLImportAttr *NewImportAttr = NewDecl->getAttr<DLLImportAttr>(); 5263 const DLLExportAttr *NewExportAttr = NewDecl->getAttr<DLLExportAttr>(); 5264 5265 // dllimport and dllexport are inheritable attributes so we have to exclude 5266 // inherited attribute instances. 5267 bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) || 5268 (NewExportAttr && !NewExportAttr->isInherited()); 5269 5270 // A redeclaration is not allowed to add a dllimport or dllexport attribute, 5271 // the only exception being explicit specializations. 5272 // Implicitly generated declarations are also excluded for now because there 5273 // is no other way to switch these to use dllimport or dllexport. 5274 bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr; 5275 5276 if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) { 5277 // If the declaration hasn't been used yet, allow with a warning for 5278 // free functions and global variables. 5279 bool JustWarn = false; 5280 if (!OldDecl->isUsed() && !OldDecl->isCXXClassMember()) { 5281 auto *VD = dyn_cast<VarDecl>(OldDecl); 5282 if (VD && !VD->getDescribedVarTemplate()) 5283 JustWarn = true; 5284 auto *FD = dyn_cast<FunctionDecl>(OldDecl); 5285 if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) 5286 JustWarn = true; 5287 } 5288 5289 unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration 5290 : diag::err_attribute_dll_redeclaration; 5291 S.Diag(NewDecl->getLocation(), DiagID) 5292 << NewDecl 5293 << (NewImportAttr ? (const Attr *)NewImportAttr : NewExportAttr); 5294 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration); 5295 if (!JustWarn) { 5296 NewDecl->setInvalidDecl(); 5297 return; 5298 } 5299 } 5300 5301 // A redeclaration is not allowed to drop a dllimport attribute, the only 5302 // exceptions being inline function definitions, local extern declarations, 5303 // and qualified friend declarations. 5304 // NB: MSVC converts such a declaration to dllexport. 5305 bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false; 5306 if (const auto *VD = dyn_cast<VarDecl>(NewDecl)) 5307 // Ignore static data because out-of-line definitions are diagnosed 5308 // separately. 5309 IsStaticDataMember = VD->isStaticDataMember(); 5310 else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) { 5311 IsInline = FD->isInlined(); 5312 IsQualifiedFriend = FD->getQualifier() && 5313 FD->getFriendObjectKind() == Decl::FOK_Declared; 5314 } 5315 5316 if (OldImportAttr && !HasNewAttr && !IsInline && !IsStaticDataMember && 5317 !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) { 5318 S.Diag(NewDecl->getLocation(), 5319 diag::warn_redeclaration_without_attribute_prev_attribute_ignored) 5320 << NewDecl << OldImportAttr; 5321 S.Diag(OldDecl->getLocation(), diag::note_previous_declaration); 5322 S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute); 5323 OldDecl->dropAttr<DLLImportAttr>(); 5324 NewDecl->dropAttr<DLLImportAttr>(); 5325 } else if (IsInline && OldImportAttr && 5326 !S.Context.getTargetInfo().getCXXABI().isMicrosoft()) { 5327 // In MinGW, seeing a function declared inline drops the dllimport attribute. 5328 OldDecl->dropAttr<DLLImportAttr>(); 5329 NewDecl->dropAttr<DLLImportAttr>(); 5330 S.Diag(NewDecl->getLocation(), 5331 diag::warn_dllimport_dropped_from_inline_function) 5332 << NewDecl << OldImportAttr; 5333 } 5334 } 5335 5336 /// Given that we are within the definition of the given function, 5337 /// will that definition behave like C99's 'inline', where the 5338 /// definition is discarded except for optimization purposes? 5339 static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) { 5340 // Try to avoid calling GetGVALinkageForFunction. 5341 5342 // All cases of this require the 'inline' keyword. 5343 if (!FD->isInlined()) return false; 5344 5345 // This is only possible in C++ with the gnu_inline attribute. 5346 if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>()) 5347 return false; 5348 5349 // Okay, go ahead and call the relatively-more-expensive function. 5350 5351 #ifndef NDEBUG 5352 // AST quite reasonably asserts that it's working on a function 5353 // definition. We don't really have a way to tell it that we're 5354 // currently defining the function, so just lie to it in +Asserts 5355 // builds. This is an awful hack. 5356 FD->setLazyBody(1); 5357 #endif 5358 5359 bool isC99Inline = 5360 S.Context.GetGVALinkageForFunction(FD) == GVA_AvailableExternally; 5361 5362 #ifndef NDEBUG 5363 FD->setLazyBody(0); 5364 #endif 5365 5366 return isC99Inline; 5367 } 5368 5369 /// Determine whether a variable is extern "C" prior to attaching 5370 /// an initializer. We can't just call isExternC() here, because that 5371 /// will also compute and cache whether the declaration is externally 5372 /// visible, which might change when we attach the initializer. 5373 /// 5374 /// This can only be used if the declaration is known to not be a 5375 /// redeclaration of an internal linkage declaration. 5376 /// 5377 /// For instance: 5378 /// 5379 /// auto x = []{}; 5380 /// 5381 /// Attaching the initializer here makes this declaration not externally 5382 /// visible, because its type has internal linkage. 5383 /// 5384 /// FIXME: This is a hack. 5385 template<typename T> 5386 static bool isIncompleteDeclExternC(Sema &S, const T *D) { 5387 if (S.getLangOpts().CPlusPlus) { 5388 // In C++, the overloadable attribute negates the effects of extern "C". 5389 if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>()) 5390 return false; 5391 } 5392 return D->isExternC(); 5393 } 5394 5395 static bool shouldConsiderLinkage(const VarDecl *VD) { 5396 const DeclContext *DC = VD->getDeclContext()->getRedeclContext(); 5397 if (DC->isFunctionOrMethod()) 5398 return VD->hasExternalStorage(); 5399 if (DC->isFileContext()) 5400 return true; 5401 if (DC->isRecord()) 5402 return false; 5403 llvm_unreachable("Unexpected context"); 5404 } 5405 5406 static bool shouldConsiderLinkage(const FunctionDecl *FD) { 5407 const DeclContext *DC = FD->getDeclContext()->getRedeclContext(); 5408 if (DC->isFileContext() || DC->isFunctionOrMethod()) 5409 return true; 5410 if (DC->isRecord()) 5411 return false; 5412 llvm_unreachable("Unexpected context"); 5413 } 5414 5415 static bool hasParsedAttr(Scope *S, const AttributeList *AttrList, 5416 AttributeList::Kind Kind) { 5417 for (const AttributeList *L = AttrList; L; L = L->getNext()) 5418 if (L->getKind() == Kind) 5419 return true; 5420 return false; 5421 } 5422 5423 static bool hasParsedAttr(Scope *S, const Declarator &PD, 5424 AttributeList::Kind Kind) { 5425 // Check decl attributes on the DeclSpec. 5426 if (hasParsedAttr(S, PD.getDeclSpec().getAttributes().getList(), Kind)) 5427 return true; 5428 5429 // Walk the declarator structure, checking decl attributes that were in a type 5430 // position to the decl itself. 5431 for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) { 5432 if (hasParsedAttr(S, PD.getTypeObject(I).getAttrs(), Kind)) 5433 return true; 5434 } 5435 5436 // Finally, check attributes on the decl itself. 5437 return hasParsedAttr(S, PD.getAttributes(), Kind); 5438 } 5439 5440 /// Adjust the \c DeclContext for a function or variable that might be a 5441 /// function-local external declaration. 5442 bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) { 5443 if (!DC->isFunctionOrMethod()) 5444 return false; 5445 5446 // If this is a local extern function or variable declared within a function 5447 // template, don't add it into the enclosing namespace scope until it is 5448 // instantiated; it might have a dependent type right now. 5449 if (DC->isDependentContext()) 5450 return true; 5451 5452 // C++11 [basic.link]p7: 5453 // When a block scope declaration of an entity with linkage is not found to 5454 // refer to some other declaration, then that entity is a member of the 5455 // innermost enclosing namespace. 5456 // 5457 // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a 5458 // semantically-enclosing namespace, not a lexically-enclosing one. 5459 while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC)) 5460 DC = DC->getParent(); 5461 return true; 5462 } 5463 5464 NamedDecl * 5465 Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, 5466 TypeSourceInfo *TInfo, LookupResult &Previous, 5467 MultiTemplateParamsArg TemplateParamLists, 5468 bool &AddToScope) { 5469 QualType R = TInfo->getType(); 5470 DeclarationName Name = GetNameForDeclarator(D).getName(); 5471 5472 DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec(); 5473 StorageClass SC = StorageClassSpecToVarDeclStorageClass(D.getDeclSpec()); 5474 5475 // dllimport globals without explicit storage class are treated as extern. We 5476 // have to change the storage class this early to get the right DeclContext. 5477 if (SC == SC_None && !DC->isRecord() && 5478 hasParsedAttr(S, D, AttributeList::AT_DLLImport) && 5479 !hasParsedAttr(S, D, AttributeList::AT_DLLExport)) 5480 SC = SC_Extern; 5481 5482 DeclContext *OriginalDC = DC; 5483 bool IsLocalExternDecl = SC == SC_Extern && 5484 adjustContextForLocalExternDecl(DC); 5485 5486 if (getLangOpts().OpenCL) { 5487 // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed. 5488 QualType NR = R; 5489 while (NR->isPointerType()) { 5490 if (NR->isFunctionPointerType()) { 5491 Diag(D.getIdentifierLoc(), diag::err_opencl_function_pointer_variable); 5492 D.setInvalidType(); 5493 break; 5494 } 5495 NR = NR->getPointeeType(); 5496 } 5497 5498 if (!getOpenCLOptions().cl_khr_fp16) { 5499 // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and 5500 // half array type (unless the cl_khr_fp16 extension is enabled). 5501 if (Context.getBaseElementType(R)->isHalfType()) { 5502 Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R; 5503 D.setInvalidType(); 5504 } 5505 } 5506 } 5507 5508 if (SCSpec == DeclSpec::SCS_mutable) { 5509 // mutable can only appear on non-static class members, so it's always 5510 // an error here 5511 Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember); 5512 D.setInvalidType(); 5513 SC = SC_None; 5514 } 5515 5516 if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register && 5517 !D.getAsmLabel() && !getSourceManager().isInSystemMacro( 5518 D.getDeclSpec().getStorageClassSpecLoc())) { 5519 // In C++11, the 'register' storage class specifier is deprecated. 5520 // Suppress the warning in system macros, it's used in macros in some 5521 // popular C system headers, such as in glibc's htonl() macro. 5522 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 5523 diag::warn_deprecated_register) 5524 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 5525 } 5526 5527 IdentifierInfo *II = Name.getAsIdentifierInfo(); 5528 if (!II) { 5529 Diag(D.getIdentifierLoc(), diag::err_bad_variable_name) 5530 << Name; 5531 return nullptr; 5532 } 5533 5534 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 5535 5536 if (!DC->isRecord() && S->getFnParent() == nullptr) { 5537 // C99 6.9p2: The storage-class specifiers auto and register shall not 5538 // appear in the declaration specifiers in an external declaration. 5539 // Global Register+Asm is a GNU extension we support. 5540 if (SC == SC_Auto || (SC == SC_Register && !D.getAsmLabel())) { 5541 Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope); 5542 D.setInvalidType(); 5543 } 5544 } 5545 5546 if (getLangOpts().OpenCL) { 5547 // Set up the special work-group-local storage class for variables in the 5548 // OpenCL __local address space. 5549 if (R.getAddressSpace() == LangAS::opencl_local) { 5550 SC = SC_OpenCLWorkGroupLocal; 5551 } 5552 5553 // OpenCL v1.2 s6.9.b p4: 5554 // The sampler type cannot be used with the __local and __global address 5555 // space qualifiers. 5556 if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local || 5557 R.getAddressSpace() == LangAS::opencl_global)) { 5558 Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace); 5559 } 5560 5561 // OpenCL 1.2 spec, p6.9 r: 5562 // The event type cannot be used to declare a program scope variable. 5563 // The event type cannot be used with the __local, __constant and __global 5564 // address space qualifiers. 5565 if (R->isEventT()) { 5566 if (S->getParent() == nullptr) { 5567 Diag(D.getLocStart(), diag::err_event_t_global_var); 5568 D.setInvalidType(); 5569 } 5570 5571 if (R.getAddressSpace()) { 5572 Diag(D.getLocStart(), diag::err_event_t_addr_space_qual); 5573 D.setInvalidType(); 5574 } 5575 } 5576 } 5577 5578 bool IsExplicitSpecialization = false; 5579 bool IsVariableTemplateSpecialization = false; 5580 bool IsPartialSpecialization = false; 5581 bool IsVariableTemplate = false; 5582 VarDecl *NewVD = nullptr; 5583 VarTemplateDecl *NewTemplate = nullptr; 5584 TemplateParameterList *TemplateParams = nullptr; 5585 if (!getLangOpts().CPlusPlus) { 5586 NewVD = VarDecl::Create(Context, DC, D.getLocStart(), 5587 D.getIdentifierLoc(), II, 5588 R, TInfo, SC); 5589 5590 if (D.isInvalidType()) 5591 NewVD->setInvalidDecl(); 5592 } else { 5593 bool Invalid = false; 5594 5595 if (DC->isRecord() && !CurContext->isRecord()) { 5596 // This is an out-of-line definition of a static data member. 5597 switch (SC) { 5598 case SC_None: 5599 break; 5600 case SC_Static: 5601 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 5602 diag::err_static_out_of_line) 5603 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 5604 break; 5605 case SC_Auto: 5606 case SC_Register: 5607 case SC_Extern: 5608 // [dcl.stc] p2: The auto or register specifiers shall be applied only 5609 // to names of variables declared in a block or to function parameters. 5610 // [dcl.stc] p6: The extern specifier cannot be used in the declaration 5611 // of class members 5612 5613 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 5614 diag::err_storage_class_for_static_member) 5615 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 5616 break; 5617 case SC_PrivateExtern: 5618 llvm_unreachable("C storage class in c++!"); 5619 case SC_OpenCLWorkGroupLocal: 5620 llvm_unreachable("OpenCL storage class in c++!"); 5621 } 5622 } 5623 5624 if (SC == SC_Static && CurContext->isRecord()) { 5625 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) { 5626 if (RD->isLocalClass()) 5627 Diag(D.getIdentifierLoc(), 5628 diag::err_static_data_member_not_allowed_in_local_class) 5629 << Name << RD->getDeclName(); 5630 5631 // C++98 [class.union]p1: If a union contains a static data member, 5632 // the program is ill-formed. C++11 drops this restriction. 5633 if (RD->isUnion()) 5634 Diag(D.getIdentifierLoc(), 5635 getLangOpts().CPlusPlus11 5636 ? diag::warn_cxx98_compat_static_data_member_in_union 5637 : diag::ext_static_data_member_in_union) << Name; 5638 // We conservatively disallow static data members in anonymous structs. 5639 else if (!RD->getDeclName()) 5640 Diag(D.getIdentifierLoc(), 5641 diag::err_static_data_member_not_allowed_in_anon_struct) 5642 << Name << RD->isUnion(); 5643 } 5644 } 5645 5646 // Match up the template parameter lists with the scope specifier, then 5647 // determine whether we have a template or a template specialization. 5648 TemplateParams = MatchTemplateParametersToScopeSpecifier( 5649 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(), 5650 D.getCXXScopeSpec(), 5651 D.getName().getKind() == UnqualifiedId::IK_TemplateId 5652 ? D.getName().TemplateId 5653 : nullptr, 5654 TemplateParamLists, 5655 /*never a friend*/ false, IsExplicitSpecialization, Invalid); 5656 5657 if (TemplateParams) { 5658 if (!TemplateParams->size() && 5659 D.getName().getKind() != UnqualifiedId::IK_TemplateId) { 5660 // There is an extraneous 'template<>' for this variable. Complain 5661 // about it, but allow the declaration of the variable. 5662 Diag(TemplateParams->getTemplateLoc(), 5663 diag::err_template_variable_noparams) 5664 << II 5665 << SourceRange(TemplateParams->getTemplateLoc(), 5666 TemplateParams->getRAngleLoc()); 5667 TemplateParams = nullptr; 5668 } else { 5669 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 5670 // This is an explicit specialization or a partial specialization. 5671 // FIXME: Check that we can declare a specialization here. 5672 IsVariableTemplateSpecialization = true; 5673 IsPartialSpecialization = TemplateParams->size() > 0; 5674 } else { // if (TemplateParams->size() > 0) 5675 // This is a template declaration. 5676 IsVariableTemplate = true; 5677 5678 // Check that we can declare a template here. 5679 if (CheckTemplateDeclScope(S, TemplateParams)) 5680 return nullptr; 5681 5682 // Only C++1y supports variable templates (N3651). 5683 Diag(D.getIdentifierLoc(), 5684 getLangOpts().CPlusPlus14 5685 ? diag::warn_cxx11_compat_variable_template 5686 : diag::ext_variable_template); 5687 } 5688 } 5689 } else { 5690 assert( 5691 (Invalid || D.getName().getKind() != UnqualifiedId::IK_TemplateId) && 5692 "should have a 'template<>' for this decl"); 5693 } 5694 5695 if (IsVariableTemplateSpecialization) { 5696 SourceLocation TemplateKWLoc = 5697 TemplateParamLists.size() > 0 5698 ? TemplateParamLists[0]->getTemplateLoc() 5699 : SourceLocation(); 5700 DeclResult Res = ActOnVarTemplateSpecialization( 5701 S, D, TInfo, TemplateKWLoc, TemplateParams, SC, 5702 IsPartialSpecialization); 5703 if (Res.isInvalid()) 5704 return nullptr; 5705 NewVD = cast<VarDecl>(Res.get()); 5706 AddToScope = false; 5707 } else 5708 NewVD = VarDecl::Create(Context, DC, D.getLocStart(), 5709 D.getIdentifierLoc(), II, R, TInfo, SC); 5710 5711 // If this is supposed to be a variable template, create it as such. 5712 if (IsVariableTemplate) { 5713 NewTemplate = 5714 VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name, 5715 TemplateParams, NewVD); 5716 NewVD->setDescribedVarTemplate(NewTemplate); 5717 } 5718 5719 // If this decl has an auto type in need of deduction, make a note of the 5720 // Decl so we can diagnose uses of it in its own initializer. 5721 if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType()) 5722 ParsingInitForAutoVars.insert(NewVD); 5723 5724 if (D.isInvalidType() || Invalid) { 5725 NewVD->setInvalidDecl(); 5726 if (NewTemplate) 5727 NewTemplate->setInvalidDecl(); 5728 } 5729 5730 SetNestedNameSpecifier(NewVD, D); 5731 5732 // If we have any template parameter lists that don't directly belong to 5733 // the variable (matching the scope specifier), store them. 5734 unsigned VDTemplateParamLists = TemplateParams ? 1 : 0; 5735 if (TemplateParamLists.size() > VDTemplateParamLists) 5736 NewVD->setTemplateParameterListsInfo( 5737 Context, TemplateParamLists.size() - VDTemplateParamLists, 5738 TemplateParamLists.data()); 5739 5740 if (D.getDeclSpec().isConstexprSpecified()) 5741 NewVD->setConstexpr(true); 5742 } 5743 5744 // Set the lexical context. If the declarator has a C++ scope specifier, the 5745 // lexical context will be different from the semantic context. 5746 NewVD->setLexicalDeclContext(CurContext); 5747 if (NewTemplate) 5748 NewTemplate->setLexicalDeclContext(CurContext); 5749 5750 if (IsLocalExternDecl) 5751 NewVD->setLocalExternDecl(); 5752 5753 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) { 5754 // C++11 [dcl.stc]p4: 5755 // When thread_local is applied to a variable of block scope the 5756 // storage-class-specifier static is implied if it does not appear 5757 // explicitly. 5758 // Core issue: 'static' is not implied if the variable is declared 5759 // 'extern'. 5760 if (NewVD->hasLocalStorage() && 5761 (SCSpec != DeclSpec::SCS_unspecified || 5762 TSCS != DeclSpec::TSCS_thread_local || 5763 !DC->isFunctionOrMethod())) 5764 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 5765 diag::err_thread_non_global) 5766 << DeclSpec::getSpecifierName(TSCS); 5767 else if (!Context.getTargetInfo().isTLSSupported()) 5768 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 5769 diag::err_thread_unsupported); 5770 else 5771 NewVD->setTSCSpec(TSCS); 5772 } 5773 5774 // C99 6.7.4p3 5775 // An inline definition of a function with external linkage shall 5776 // not contain a definition of a modifiable object with static or 5777 // thread storage duration... 5778 // We only apply this when the function is required to be defined 5779 // elsewhere, i.e. when the function is not 'extern inline'. Note 5780 // that a local variable with thread storage duration still has to 5781 // be marked 'static'. Also note that it's possible to get these 5782 // semantics in C++ using __attribute__((gnu_inline)). 5783 if (SC == SC_Static && S->getFnParent() != nullptr && 5784 !NewVD->getType().isConstQualified()) { 5785 FunctionDecl *CurFD = getCurFunctionDecl(); 5786 if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) { 5787 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 5788 diag::warn_static_local_in_extern_inline); 5789 MaybeSuggestAddingStaticToDecl(CurFD); 5790 } 5791 } 5792 5793 if (D.getDeclSpec().isModulePrivateSpecified()) { 5794 if (IsVariableTemplateSpecialization) 5795 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 5796 << (IsPartialSpecialization ? 1 : 0) 5797 << FixItHint::CreateRemoval( 5798 D.getDeclSpec().getModulePrivateSpecLoc()); 5799 else if (IsExplicitSpecialization) 5800 Diag(NewVD->getLocation(), diag::err_module_private_specialization) 5801 << 2 5802 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 5803 else if (NewVD->hasLocalStorage()) 5804 Diag(NewVD->getLocation(), diag::err_module_private_local) 5805 << 0 << NewVD->getDeclName() 5806 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 5807 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 5808 else { 5809 NewVD->setModulePrivate(); 5810 if (NewTemplate) 5811 NewTemplate->setModulePrivate(); 5812 } 5813 } 5814 5815 // Handle attributes prior to checking for duplicates in MergeVarDecl 5816 ProcessDeclAttributes(S, NewVD, D); 5817 5818 if (getLangOpts().CUDA) { 5819 // CUDA B.2.5: "__shared__ and __constant__ variables have implied static 5820 // storage [duration]." 5821 if (SC == SC_None && S->getFnParent() != nullptr && 5822 (NewVD->hasAttr<CUDASharedAttr>() || 5823 NewVD->hasAttr<CUDAConstantAttr>())) { 5824 NewVD->setStorageClass(SC_Static); 5825 } 5826 } 5827 5828 // Ensure that dllimport globals without explicit storage class are treated as 5829 // extern. The storage class is set above using parsed attributes. Now we can 5830 // check the VarDecl itself. 5831 assert(!NewVD->hasAttr<DLLImportAttr>() || 5832 NewVD->getAttr<DLLImportAttr>()->isInherited() || 5833 NewVD->isStaticDataMember() || NewVD->getStorageClass() != SC_None); 5834 5835 // In auto-retain/release, infer strong retension for variables of 5836 // retainable type. 5837 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD)) 5838 NewVD->setInvalidDecl(); 5839 5840 // Handle GNU asm-label extension (encoded as an attribute). 5841 if (Expr *E = (Expr*)D.getAsmLabel()) { 5842 // The parser guarantees this is a string. 5843 StringLiteral *SE = cast<StringLiteral>(E); 5844 StringRef Label = SE->getString(); 5845 if (S->getFnParent() != nullptr) { 5846 switch (SC) { 5847 case SC_None: 5848 case SC_Auto: 5849 Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label; 5850 break; 5851 case SC_Register: 5852 // Local Named register 5853 if (!Context.getTargetInfo().isValidGCCRegisterName(Label)) 5854 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label; 5855 break; 5856 case SC_Static: 5857 case SC_Extern: 5858 case SC_PrivateExtern: 5859 case SC_OpenCLWorkGroupLocal: 5860 break; 5861 } 5862 } else if (SC == SC_Register) { 5863 // Global Named register 5864 if (!Context.getTargetInfo().isValidGCCRegisterName(Label)) 5865 Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label; 5866 if (!R->isIntegralType(Context) && !R->isPointerType()) { 5867 Diag(D.getLocStart(), diag::err_asm_bad_register_type); 5868 NewVD->setInvalidDecl(true); 5869 } 5870 } 5871 5872 NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), 5873 Context, Label, 0)); 5874 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 5875 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 5876 ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier()); 5877 if (I != ExtnameUndeclaredIdentifiers.end()) { 5878 NewVD->addAttr(I->second); 5879 ExtnameUndeclaredIdentifiers.erase(I); 5880 } 5881 } 5882 5883 // Diagnose shadowed variables before filtering for scope. 5884 if (D.getCXXScopeSpec().isEmpty()) 5885 CheckShadow(S, NewVD, Previous); 5886 5887 // Don't consider existing declarations that are in a different 5888 // scope and are out-of-semantic-context declarations (if the new 5889 // declaration has linkage). 5890 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewVD), 5891 D.getCXXScopeSpec().isNotEmpty() || 5892 IsExplicitSpecialization || 5893 IsVariableTemplateSpecialization); 5894 5895 // Check whether the previous declaration is in the same block scope. This 5896 // affects whether we merge types with it, per C++11 [dcl.array]p3. 5897 if (getLangOpts().CPlusPlus && 5898 NewVD->isLocalVarDecl() && NewVD->hasExternalStorage()) 5899 NewVD->setPreviousDeclInSameBlockScope( 5900 Previous.isSingleResult() && !Previous.isShadowed() && 5901 isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false)); 5902 5903 if (!getLangOpts().CPlusPlus) { 5904 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous)); 5905 } else { 5906 // If this is an explicit specialization of a static data member, check it. 5907 if (IsExplicitSpecialization && !NewVD->isInvalidDecl() && 5908 CheckMemberSpecialization(NewVD, Previous)) 5909 NewVD->setInvalidDecl(); 5910 5911 // Merge the decl with the existing one if appropriate. 5912 if (!Previous.empty()) { 5913 if (Previous.isSingleResult() && 5914 isa<FieldDecl>(Previous.getFoundDecl()) && 5915 D.getCXXScopeSpec().isSet()) { 5916 // The user tried to define a non-static data member 5917 // out-of-line (C++ [dcl.meaning]p1). 5918 Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line) 5919 << D.getCXXScopeSpec().getRange(); 5920 Previous.clear(); 5921 NewVD->setInvalidDecl(); 5922 } 5923 } else if (D.getCXXScopeSpec().isSet()) { 5924 // No previous declaration in the qualifying scope. 5925 Diag(D.getIdentifierLoc(), diag::err_no_member) 5926 << Name << computeDeclContext(D.getCXXScopeSpec(), true) 5927 << D.getCXXScopeSpec().getRange(); 5928 NewVD->setInvalidDecl(); 5929 } 5930 5931 if (!IsVariableTemplateSpecialization) 5932 D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous)); 5933 5934 if (NewTemplate) { 5935 VarTemplateDecl *PrevVarTemplate = 5936 NewVD->getPreviousDecl() 5937 ? NewVD->getPreviousDecl()->getDescribedVarTemplate() 5938 : nullptr; 5939 5940 // Check the template parameter list of this declaration, possibly 5941 // merging in the template parameter list from the previous variable 5942 // template declaration. 5943 if (CheckTemplateParameterList( 5944 TemplateParams, 5945 PrevVarTemplate ? PrevVarTemplate->getTemplateParameters() 5946 : nullptr, 5947 (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() && 5948 DC->isDependentContext()) 5949 ? TPC_ClassTemplateMember 5950 : TPC_VarTemplate)) 5951 NewVD->setInvalidDecl(); 5952 5953 // If we are providing an explicit specialization of a static variable 5954 // template, make a note of that. 5955 if (PrevVarTemplate && 5956 PrevVarTemplate->getInstantiatedFromMemberTemplate()) 5957 PrevVarTemplate->setMemberSpecialization(); 5958 } 5959 } 5960 5961 ProcessPragmaWeak(S, NewVD); 5962 5963 // If this is the first declaration of an extern C variable, update 5964 // the map of such variables. 5965 if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() && 5966 isIncompleteDeclExternC(*this, NewVD)) 5967 RegisterLocallyScopedExternCDecl(NewVD, S); 5968 5969 if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) { 5970 Decl *ManglingContextDecl; 5971 if (MangleNumberingContext *MCtx = getCurrentMangleNumberContext( 5972 NewVD->getDeclContext(), ManglingContextDecl)) { 5973 Context.setManglingNumber( 5974 NewVD, MCtx->getManglingNumber( 5975 NewVD, getMSManglingNumber(getLangOpts(), S))); 5976 Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD)); 5977 } 5978 } 5979 5980 if (D.isRedeclaration() && !Previous.empty()) { 5981 checkDLLAttributeRedeclaration( 5982 *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewVD, 5983 IsExplicitSpecialization); 5984 } 5985 5986 if (NewTemplate) { 5987 if (NewVD->isInvalidDecl()) 5988 NewTemplate->setInvalidDecl(); 5989 ActOnDocumentableDecl(NewTemplate); 5990 return NewTemplate; 5991 } 5992 5993 return NewVD; 5994 } 5995 5996 /// \brief Diagnose variable or built-in function shadowing. Implements 5997 /// -Wshadow. 5998 /// 5999 /// This method is called whenever a VarDecl is added to a "useful" 6000 /// scope. 6001 /// 6002 /// \param S the scope in which the shadowing name is being declared 6003 /// \param R the lookup of the name 6004 /// 6005 void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) { 6006 // Return if warning is ignored. 6007 if (Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc())) 6008 return; 6009 6010 // Don't diagnose declarations at file scope. 6011 if (D->hasGlobalStorage()) 6012 return; 6013 6014 DeclContext *NewDC = D->getDeclContext(); 6015 6016 // Only diagnose if we're shadowing an unambiguous field or variable. 6017 if (R.getResultKind() != LookupResult::Found) 6018 return; 6019 6020 NamedDecl* ShadowedDecl = R.getFoundDecl(); 6021 if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl)) 6022 return; 6023 6024 // Fields are not shadowed by variables in C++ static methods. 6025 if (isa<FieldDecl>(ShadowedDecl)) 6026 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC)) 6027 if (MD->isStatic()) 6028 return; 6029 6030 if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl)) 6031 if (shadowedVar->isExternC()) { 6032 // For shadowing external vars, make sure that we point to the global 6033 // declaration, not a locally scoped extern declaration. 6034 for (auto I : shadowedVar->redecls()) 6035 if (I->isFileVarDecl()) { 6036 ShadowedDecl = I; 6037 break; 6038 } 6039 } 6040 6041 DeclContext *OldDC = ShadowedDecl->getDeclContext(); 6042 6043 // Only warn about certain kinds of shadowing for class members. 6044 if (NewDC && NewDC->isRecord()) { 6045 // In particular, don't warn about shadowing non-class members. 6046 if (!OldDC->isRecord()) 6047 return; 6048 6049 // TODO: should we warn about static data members shadowing 6050 // static data members from base classes? 6051 6052 // TODO: don't diagnose for inaccessible shadowed members. 6053 // This is hard to do perfectly because we might friend the 6054 // shadowing context, but that's just a false negative. 6055 } 6056 6057 // Determine what kind of declaration we're shadowing. 6058 unsigned Kind; 6059 if (isa<RecordDecl>(OldDC)) { 6060 if (isa<FieldDecl>(ShadowedDecl)) 6061 Kind = 3; // field 6062 else 6063 Kind = 2; // static data member 6064 } else if (OldDC->isFileContext()) 6065 Kind = 1; // global 6066 else 6067 Kind = 0; // local 6068 6069 DeclarationName Name = R.getLookupName(); 6070 6071 // Emit warning and note. 6072 if (getSourceManager().isInSystemMacro(R.getNameLoc())) 6073 return; 6074 Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC; 6075 Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration); 6076 } 6077 6078 /// \brief Check -Wshadow without the advantage of a previous lookup. 6079 void Sema::CheckShadow(Scope *S, VarDecl *D) { 6080 if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation())) 6081 return; 6082 6083 LookupResult R(*this, D->getDeclName(), D->getLocation(), 6084 Sema::LookupOrdinaryName, Sema::ForRedeclaration); 6085 LookupName(R, S); 6086 CheckShadow(S, D, R); 6087 } 6088 6089 /// Check for conflict between this global or extern "C" declaration and 6090 /// previous global or extern "C" declarations. This is only used in C++. 6091 template<typename T> 6092 static bool checkGlobalOrExternCConflict( 6093 Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) { 6094 assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\""); 6095 NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName()); 6096 6097 if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) { 6098 // The common case: this global doesn't conflict with any extern "C" 6099 // declaration. 6100 return false; 6101 } 6102 6103 if (Prev) { 6104 if (!IsGlobal || isIncompleteDeclExternC(S, ND)) { 6105 // Both the old and new declarations have C language linkage. This is a 6106 // redeclaration. 6107 Previous.clear(); 6108 Previous.addDecl(Prev); 6109 return true; 6110 } 6111 6112 // This is a global, non-extern "C" declaration, and there is a previous 6113 // non-global extern "C" declaration. Diagnose if this is a variable 6114 // declaration. 6115 if (!isa<VarDecl>(ND)) 6116 return false; 6117 } else { 6118 // The declaration is extern "C". Check for any declaration in the 6119 // translation unit which might conflict. 6120 if (IsGlobal) { 6121 // We have already performed the lookup into the translation unit. 6122 IsGlobal = false; 6123 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 6124 I != E; ++I) { 6125 if (isa<VarDecl>(*I)) { 6126 Prev = *I; 6127 break; 6128 } 6129 } 6130 } else { 6131 DeclContext::lookup_result R = 6132 S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName()); 6133 for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end(); 6134 I != E; ++I) { 6135 if (isa<VarDecl>(*I)) { 6136 Prev = *I; 6137 break; 6138 } 6139 // FIXME: If we have any other entity with this name in global scope, 6140 // the declaration is ill-formed, but that is a defect: it breaks the 6141 // 'stat' hack, for instance. Only variables can have mangled name 6142 // clashes with extern "C" declarations, so only they deserve a 6143 // diagnostic. 6144 } 6145 } 6146 6147 if (!Prev) 6148 return false; 6149 } 6150 6151 // Use the first declaration's location to ensure we point at something which 6152 // is lexically inside an extern "C" linkage-spec. 6153 assert(Prev && "should have found a previous declaration to diagnose"); 6154 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev)) 6155 Prev = FD->getFirstDecl(); 6156 else 6157 Prev = cast<VarDecl>(Prev)->getFirstDecl(); 6158 6159 S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict) 6160 << IsGlobal << ND; 6161 S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict) 6162 << IsGlobal; 6163 return false; 6164 } 6165 6166 /// Apply special rules for handling extern "C" declarations. Returns \c true 6167 /// if we have found that this is a redeclaration of some prior entity. 6168 /// 6169 /// Per C++ [dcl.link]p6: 6170 /// Two declarations [for a function or variable] with C language linkage 6171 /// with the same name that appear in different scopes refer to the same 6172 /// [entity]. An entity with C language linkage shall not be declared with 6173 /// the same name as an entity in global scope. 6174 template<typename T> 6175 static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, 6176 LookupResult &Previous) { 6177 if (!S.getLangOpts().CPlusPlus) { 6178 // In C, when declaring a global variable, look for a corresponding 'extern' 6179 // variable declared in function scope. We don't need this in C++, because 6180 // we find local extern decls in the surrounding file-scope DeclContext. 6181 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 6182 if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) { 6183 Previous.clear(); 6184 Previous.addDecl(Prev); 6185 return true; 6186 } 6187 } 6188 return false; 6189 } 6190 6191 // A declaration in the translation unit can conflict with an extern "C" 6192 // declaration. 6193 if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) 6194 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous); 6195 6196 // An extern "C" declaration can conflict with a declaration in the 6197 // translation unit or can be a redeclaration of an extern "C" declaration 6198 // in another scope. 6199 if (isIncompleteDeclExternC(S,ND)) 6200 return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous); 6201 6202 // Neither global nor extern "C": nothing to do. 6203 return false; 6204 } 6205 6206 void Sema::CheckVariableDeclarationType(VarDecl *NewVD) { 6207 // If the decl is already known invalid, don't check it. 6208 if (NewVD->isInvalidDecl()) 6209 return; 6210 6211 TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo(); 6212 QualType T = TInfo->getType(); 6213 6214 // Defer checking an 'auto' type until its initializer is attached. 6215 if (T->isUndeducedType()) 6216 return; 6217 6218 if (NewVD->hasAttrs()) 6219 CheckAlignasUnderalignment(NewVD); 6220 6221 if (T->isObjCObjectType()) { 6222 Diag(NewVD->getLocation(), diag::err_statically_allocated_object) 6223 << FixItHint::CreateInsertion(NewVD->getLocation(), "*"); 6224 T = Context.getObjCObjectPointerType(T); 6225 NewVD->setType(T); 6226 } 6227 6228 // Emit an error if an address space was applied to decl with local storage. 6229 // This includes arrays of objects with address space qualifiers, but not 6230 // automatic variables that point to other address spaces. 6231 // ISO/IEC TR 18037 S5.1.2 6232 if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) { 6233 Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl); 6234 NewVD->setInvalidDecl(); 6235 return; 6236 } 6237 6238 // OpenCL v1.2 s6.5 - All program scope variables must be declared in the 6239 // __constant address space. 6240 if (getLangOpts().OpenCL && NewVD->isFileVarDecl() 6241 && T.getAddressSpace() != LangAS::opencl_constant 6242 && !T->isSamplerT()){ 6243 Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space); 6244 NewVD->setInvalidDecl(); 6245 return; 6246 } 6247 6248 // OpenCL v1.2 s6.8 -- The static qualifier is valid only in program 6249 // scope. 6250 if ((getLangOpts().OpenCLVersion >= 120) 6251 && NewVD->isStaticLocal()) { 6252 Diag(NewVD->getLocation(), diag::err_static_function_scope); 6253 NewVD->setInvalidDecl(); 6254 return; 6255 } 6256 6257 if (NewVD->hasLocalStorage() && T.isObjCGCWeak() 6258 && !NewVD->hasAttr<BlocksAttr>()) { 6259 if (getLangOpts().getGC() != LangOptions::NonGC) 6260 Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local); 6261 else { 6262 assert(!getLangOpts().ObjCAutoRefCount); 6263 Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local); 6264 } 6265 } 6266 6267 bool isVM = T->isVariablyModifiedType(); 6268 if (isVM || NewVD->hasAttr<CleanupAttr>() || 6269 NewVD->hasAttr<BlocksAttr>()) 6270 getCurFunction()->setHasBranchProtectedScope(); 6271 6272 if ((isVM && NewVD->hasLinkage()) || 6273 (T->isVariableArrayType() && NewVD->hasGlobalStorage())) { 6274 bool SizeIsNegative; 6275 llvm::APSInt Oversized; 6276 TypeSourceInfo *FixedTInfo = 6277 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 6278 SizeIsNegative, Oversized); 6279 if (!FixedTInfo && T->isVariableArrayType()) { 6280 const VariableArrayType *VAT = Context.getAsVariableArrayType(T); 6281 // FIXME: This won't give the correct result for 6282 // int a[10][n]; 6283 SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange(); 6284 6285 if (NewVD->isFileVarDecl()) 6286 Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope) 6287 << SizeRange; 6288 else if (NewVD->isStaticLocal()) 6289 Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage) 6290 << SizeRange; 6291 else 6292 Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage) 6293 << SizeRange; 6294 NewVD->setInvalidDecl(); 6295 return; 6296 } 6297 6298 if (!FixedTInfo) { 6299 if (NewVD->isFileVarDecl()) 6300 Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope); 6301 else 6302 Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage); 6303 NewVD->setInvalidDecl(); 6304 return; 6305 } 6306 6307 Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size); 6308 NewVD->setType(FixedTInfo->getType()); 6309 NewVD->setTypeSourceInfo(FixedTInfo); 6310 } 6311 6312 if (T->isVoidType()) { 6313 // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names 6314 // of objects and functions. 6315 if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) { 6316 Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type) 6317 << T; 6318 NewVD->setInvalidDecl(); 6319 return; 6320 } 6321 } 6322 6323 if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) { 6324 Diag(NewVD->getLocation(), diag::err_block_on_nonlocal); 6325 NewVD->setInvalidDecl(); 6326 return; 6327 } 6328 6329 if (isVM && NewVD->hasAttr<BlocksAttr>()) { 6330 Diag(NewVD->getLocation(), diag::err_block_on_vm); 6331 NewVD->setInvalidDecl(); 6332 return; 6333 } 6334 6335 if (NewVD->isConstexpr() && !T->isDependentType() && 6336 RequireLiteralType(NewVD->getLocation(), T, 6337 diag::err_constexpr_var_non_literal)) { 6338 NewVD->setInvalidDecl(); 6339 return; 6340 } 6341 } 6342 6343 /// \brief Perform semantic checking on a newly-created variable 6344 /// declaration. 6345 /// 6346 /// This routine performs all of the type-checking required for a 6347 /// variable declaration once it has been built. It is used both to 6348 /// check variables after they have been parsed and their declarators 6349 /// have been translated into a declaration, and to check variables 6350 /// that have been instantiated from a template. 6351 /// 6352 /// Sets NewVD->isInvalidDecl() if an error was encountered. 6353 /// 6354 /// Returns true if the variable declaration is a redeclaration. 6355 bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) { 6356 CheckVariableDeclarationType(NewVD); 6357 6358 // If the decl is already known invalid, don't check it. 6359 if (NewVD->isInvalidDecl()) 6360 return false; 6361 6362 // If we did not find anything by this name, look for a non-visible 6363 // extern "C" declaration with the same name. 6364 if (Previous.empty() && 6365 checkForConflictWithNonVisibleExternC(*this, NewVD, Previous)) 6366 Previous.setShadowed(); 6367 6368 // Filter out any non-conflicting previous declarations. 6369 filterNonConflictingPreviousDecls(Context, NewVD, Previous); 6370 6371 if (!Previous.empty()) { 6372 MergeVarDecl(NewVD, Previous); 6373 return true; 6374 } 6375 return false; 6376 } 6377 6378 /// \brief Data used with FindOverriddenMethod 6379 struct FindOverriddenMethodData { 6380 Sema *S; 6381 CXXMethodDecl *Method; 6382 }; 6383 6384 /// \brief Member lookup function that determines whether a given C++ 6385 /// method overrides a method in a base class, to be used with 6386 /// CXXRecordDecl::lookupInBases(). 6387 static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier, 6388 CXXBasePath &Path, 6389 void *UserData) { 6390 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl(); 6391 6392 FindOverriddenMethodData *Data 6393 = reinterpret_cast<FindOverriddenMethodData*>(UserData); 6394 6395 DeclarationName Name = Data->Method->getDeclName(); 6396 6397 // FIXME: Do we care about other names here too? 6398 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 6399 // We really want to find the base class destructor here. 6400 QualType T = Data->S->Context.getTypeDeclType(BaseRecord); 6401 CanQualType CT = Data->S->Context.getCanonicalType(T); 6402 6403 Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT); 6404 } 6405 6406 for (Path.Decls = BaseRecord->lookup(Name); 6407 !Path.Decls.empty(); 6408 Path.Decls = Path.Decls.slice(1)) { 6409 NamedDecl *D = Path.Decls.front(); 6410 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 6411 if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, false)) 6412 return true; 6413 } 6414 } 6415 6416 return false; 6417 } 6418 6419 namespace { 6420 enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted }; 6421 } 6422 /// \brief Report an error regarding overriding, along with any relevant 6423 /// overriden methods. 6424 /// 6425 /// \param DiagID the primary error to report. 6426 /// \param MD the overriding method. 6427 /// \param OEK which overrides to include as notes. 6428 static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD, 6429 OverrideErrorKind OEK = OEK_All) { 6430 S.Diag(MD->getLocation(), DiagID) << MD->getDeclName(); 6431 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(), 6432 E = MD->end_overridden_methods(); 6433 I != E; ++I) { 6434 // This check (& the OEK parameter) could be replaced by a predicate, but 6435 // without lambdas that would be overkill. This is still nicer than writing 6436 // out the diag loop 3 times. 6437 if ((OEK == OEK_All) || 6438 (OEK == OEK_NonDeleted && !(*I)->isDeleted()) || 6439 (OEK == OEK_Deleted && (*I)->isDeleted())) 6440 S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function); 6441 } 6442 } 6443 6444 /// AddOverriddenMethods - See if a method overrides any in the base classes, 6445 /// and if so, check that it's a valid override and remember it. 6446 bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) { 6447 // Look for methods in base classes that this method might override. 6448 CXXBasePaths Paths; 6449 FindOverriddenMethodData Data; 6450 Data.Method = MD; 6451 Data.S = this; 6452 bool hasDeletedOverridenMethods = false; 6453 bool hasNonDeletedOverridenMethods = false; 6454 bool AddedAny = false; 6455 if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) { 6456 for (auto *I : Paths.found_decls()) { 6457 if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(I)) { 6458 MD->addOverriddenMethod(OldMD->getCanonicalDecl()); 6459 if (!CheckOverridingFunctionReturnType(MD, OldMD) && 6460 !CheckOverridingFunctionAttributes(MD, OldMD) && 6461 !CheckOverridingFunctionExceptionSpec(MD, OldMD) && 6462 !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) { 6463 hasDeletedOverridenMethods |= OldMD->isDeleted(); 6464 hasNonDeletedOverridenMethods |= !OldMD->isDeleted(); 6465 AddedAny = true; 6466 } 6467 } 6468 } 6469 } 6470 6471 if (hasDeletedOverridenMethods && !MD->isDeleted()) { 6472 ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted); 6473 } 6474 if (hasNonDeletedOverridenMethods && MD->isDeleted()) { 6475 ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted); 6476 } 6477 6478 return AddedAny; 6479 } 6480 6481 namespace { 6482 // Struct for holding all of the extra arguments needed by 6483 // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator. 6484 struct ActOnFDArgs { 6485 Scope *S; 6486 Declarator &D; 6487 MultiTemplateParamsArg TemplateParamLists; 6488 bool AddToScope; 6489 }; 6490 } 6491 6492 namespace { 6493 6494 // Callback to only accept typo corrections that have a non-zero edit distance. 6495 // Also only accept corrections that have the same parent decl. 6496 class DifferentNameValidatorCCC : public CorrectionCandidateCallback { 6497 public: 6498 DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD, 6499 CXXRecordDecl *Parent) 6500 : Context(Context), OriginalFD(TypoFD), 6501 ExpectedParent(Parent ? Parent->getCanonicalDecl() : nullptr) {} 6502 6503 bool ValidateCandidate(const TypoCorrection &candidate) override { 6504 if (candidate.getEditDistance() == 0) 6505 return false; 6506 6507 SmallVector<unsigned, 1> MismatchedParams; 6508 for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(), 6509 CDeclEnd = candidate.end(); 6510 CDecl != CDeclEnd; ++CDecl) { 6511 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 6512 6513 if (FD && !FD->hasBody() && 6514 hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) { 6515 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 6516 CXXRecordDecl *Parent = MD->getParent(); 6517 if (Parent && Parent->getCanonicalDecl() == ExpectedParent) 6518 return true; 6519 } else if (!ExpectedParent) { 6520 return true; 6521 } 6522 } 6523 } 6524 6525 return false; 6526 } 6527 6528 private: 6529 ASTContext &Context; 6530 FunctionDecl *OriginalFD; 6531 CXXRecordDecl *ExpectedParent; 6532 }; 6533 6534 } 6535 6536 /// \brief Generate diagnostics for an invalid function redeclaration. 6537 /// 6538 /// This routine handles generating the diagnostic messages for an invalid 6539 /// function redeclaration, including finding possible similar declarations 6540 /// or performing typo correction if there are no previous declarations with 6541 /// the same name. 6542 /// 6543 /// Returns a NamedDecl iff typo correction was performed and substituting in 6544 /// the new declaration name does not cause new errors. 6545 static NamedDecl *DiagnoseInvalidRedeclaration( 6546 Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, 6547 ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) { 6548 DeclarationName Name = NewFD->getDeclName(); 6549 DeclContext *NewDC = NewFD->getDeclContext(); 6550 SmallVector<unsigned, 1> MismatchedParams; 6551 SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches; 6552 TypoCorrection Correction; 6553 bool IsDefinition = ExtraArgs.D.isFunctionDefinition(); 6554 unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend 6555 : diag::err_member_decl_does_not_match; 6556 LookupResult Prev(SemaRef, Name, NewFD->getLocation(), 6557 IsLocalFriend ? Sema::LookupLocalFriendName 6558 : Sema::LookupOrdinaryName, 6559 Sema::ForRedeclaration); 6560 6561 NewFD->setInvalidDecl(); 6562 if (IsLocalFriend) 6563 SemaRef.LookupName(Prev, S); 6564 else 6565 SemaRef.LookupQualifiedName(Prev, NewDC); 6566 assert(!Prev.isAmbiguous() && 6567 "Cannot have an ambiguity in previous-declaration lookup"); 6568 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 6569 if (!Prev.empty()) { 6570 for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end(); 6571 Func != FuncEnd; ++Func) { 6572 FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func); 6573 if (FD && 6574 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 6575 // Add 1 to the index so that 0 can mean the mismatch didn't 6576 // involve a parameter 6577 unsigned ParamNum = 6578 MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1; 6579 NearMatches.push_back(std::make_pair(FD, ParamNum)); 6580 } 6581 } 6582 // If the qualified name lookup yielded nothing, try typo correction 6583 } else if ((Correction = SemaRef.CorrectTypo( 6584 Prev.getLookupNameInfo(), Prev.getLookupKind(), S, 6585 &ExtraArgs.D.getCXXScopeSpec(), 6586 llvm::make_unique<DifferentNameValidatorCCC>( 6587 SemaRef.Context, NewFD, MD ? MD->getParent() : nullptr), 6588 Sema::CTK_ErrorRecovery, IsLocalFriend ? nullptr : NewDC))) { 6589 // Set up everything for the call to ActOnFunctionDeclarator 6590 ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(), 6591 ExtraArgs.D.getIdentifierLoc()); 6592 Previous.clear(); 6593 Previous.setLookupName(Correction.getCorrection()); 6594 for (TypoCorrection::decl_iterator CDecl = Correction.begin(), 6595 CDeclEnd = Correction.end(); 6596 CDecl != CDeclEnd; ++CDecl) { 6597 FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl); 6598 if (FD && !FD->hasBody() && 6599 hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) { 6600 Previous.addDecl(FD); 6601 } 6602 } 6603 bool wasRedeclaration = ExtraArgs.D.isRedeclaration(); 6604 6605 NamedDecl *Result; 6606 // Retry building the function declaration with the new previous 6607 // declarations, and with errors suppressed. 6608 { 6609 // Trap errors. 6610 Sema::SFINAETrap Trap(SemaRef); 6611 6612 // TODO: Refactor ActOnFunctionDeclarator so that we can call only the 6613 // pieces need to verify the typo-corrected C++ declaration and hopefully 6614 // eliminate the need for the parameter pack ExtraArgs. 6615 Result = SemaRef.ActOnFunctionDeclarator( 6616 ExtraArgs.S, ExtraArgs.D, 6617 Correction.getCorrectionDecl()->getDeclContext(), 6618 NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists, 6619 ExtraArgs.AddToScope); 6620 6621 if (Trap.hasErrorOccurred()) 6622 Result = nullptr; 6623 } 6624 6625 if (Result) { 6626 // Determine which correction we picked. 6627 Decl *Canonical = Result->getCanonicalDecl(); 6628 for (LookupResult::iterator I = Previous.begin(), E = Previous.end(); 6629 I != E; ++I) 6630 if ((*I)->getCanonicalDecl() == Canonical) 6631 Correction.setCorrectionDecl(*I); 6632 6633 SemaRef.diagnoseTypo( 6634 Correction, 6635 SemaRef.PDiag(IsLocalFriend 6636 ? diag::err_no_matching_local_friend_suggest 6637 : diag::err_member_decl_does_not_match_suggest) 6638 << Name << NewDC << IsDefinition); 6639 return Result; 6640 } 6641 6642 // Pretend the typo correction never occurred 6643 ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(), 6644 ExtraArgs.D.getIdentifierLoc()); 6645 ExtraArgs.D.setRedeclaration(wasRedeclaration); 6646 Previous.clear(); 6647 Previous.setLookupName(Name); 6648 } 6649 6650 SemaRef.Diag(NewFD->getLocation(), DiagMsg) 6651 << Name << NewDC << IsDefinition << NewFD->getLocation(); 6652 6653 bool NewFDisConst = false; 6654 if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD)) 6655 NewFDisConst = NewMD->isConst(); 6656 6657 for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator 6658 NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end(); 6659 NearMatch != NearMatchEnd; ++NearMatch) { 6660 FunctionDecl *FD = NearMatch->first; 6661 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD); 6662 bool FDisConst = MD && MD->isConst(); 6663 bool IsMember = MD || !IsLocalFriend; 6664 6665 // FIXME: These notes are poorly worded for the local friend case. 6666 if (unsigned Idx = NearMatch->second) { 6667 ParmVarDecl *FDParam = FD->getParamDecl(Idx-1); 6668 SourceLocation Loc = FDParam->getTypeSpecStartLoc(); 6669 if (Loc.isInvalid()) Loc = FD->getLocation(); 6670 SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match 6671 : diag::note_local_decl_close_param_match) 6672 << Idx << FDParam->getType() 6673 << NewFD->getParamDecl(Idx - 1)->getType(); 6674 } else if (FDisConst != NewFDisConst) { 6675 SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match) 6676 << NewFDisConst << FD->getSourceRange().getEnd(); 6677 } else 6678 SemaRef.Diag(FD->getLocation(), 6679 IsMember ? diag::note_member_def_close_match 6680 : diag::note_local_decl_close_match); 6681 } 6682 return nullptr; 6683 } 6684 6685 static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D) { 6686 switch (D.getDeclSpec().getStorageClassSpec()) { 6687 default: llvm_unreachable("Unknown storage class!"); 6688 case DeclSpec::SCS_auto: 6689 case DeclSpec::SCS_register: 6690 case DeclSpec::SCS_mutable: 6691 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6692 diag::err_typecheck_sclass_func); 6693 D.setInvalidType(); 6694 break; 6695 case DeclSpec::SCS_unspecified: break; 6696 case DeclSpec::SCS_extern: 6697 if (D.getDeclSpec().isExternInLinkageSpec()) 6698 return SC_None; 6699 return SC_Extern; 6700 case DeclSpec::SCS_static: { 6701 if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) { 6702 // C99 6.7.1p5: 6703 // The declaration of an identifier for a function that has 6704 // block scope shall have no explicit storage-class specifier 6705 // other than extern 6706 // See also (C++ [dcl.stc]p4). 6707 SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(), 6708 diag::err_static_block_func); 6709 break; 6710 } else 6711 return SC_Static; 6712 } 6713 case DeclSpec::SCS_private_extern: return SC_PrivateExtern; 6714 } 6715 6716 // No explicit storage class has already been returned 6717 return SC_None; 6718 } 6719 6720 static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, 6721 DeclContext *DC, QualType &R, 6722 TypeSourceInfo *TInfo, 6723 StorageClass SC, 6724 bool &IsVirtualOkay) { 6725 DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D); 6726 DeclarationName Name = NameInfo.getName(); 6727 6728 FunctionDecl *NewFD = nullptr; 6729 bool isInline = D.getDeclSpec().isInlineSpecified(); 6730 6731 if (!SemaRef.getLangOpts().CPlusPlus) { 6732 // Determine whether the function was written with a 6733 // prototype. This true when: 6734 // - there is a prototype in the declarator, or 6735 // - the type R of the function is some kind of typedef or other reference 6736 // to a type name (which eventually refers to a function type). 6737 bool HasPrototype = 6738 (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) || 6739 (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType()); 6740 6741 NewFD = FunctionDecl::Create(SemaRef.Context, DC, 6742 D.getLocStart(), NameInfo, R, 6743 TInfo, SC, isInline, 6744 HasPrototype, false); 6745 if (D.isInvalidType()) 6746 NewFD->setInvalidDecl(); 6747 6748 return NewFD; 6749 } 6750 6751 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 6752 bool isConstexpr = D.getDeclSpec().isConstexprSpecified(); 6753 6754 // Check that the return type is not an abstract class type. 6755 // For record types, this is done by the AbstractClassUsageDiagnoser once 6756 // the class has been completely parsed. 6757 if (!DC->isRecord() && 6758 SemaRef.RequireNonAbstractType( 6759 D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(), 6760 diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType)) 6761 D.setInvalidType(); 6762 6763 if (Name.getNameKind() == DeclarationName::CXXConstructorName) { 6764 // This is a C++ constructor declaration. 6765 assert(DC->isRecord() && 6766 "Constructors can only be declared in a member context"); 6767 6768 R = SemaRef.CheckConstructorDeclarator(D, R, SC); 6769 return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC), 6770 D.getLocStart(), NameInfo, 6771 R, TInfo, isExplicit, isInline, 6772 /*isImplicitlyDeclared=*/false, 6773 isConstexpr); 6774 6775 } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 6776 // This is a C++ destructor declaration. 6777 if (DC->isRecord()) { 6778 R = SemaRef.CheckDestructorDeclarator(D, R, SC); 6779 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); 6780 CXXDestructorDecl *NewDD = CXXDestructorDecl::Create( 6781 SemaRef.Context, Record, 6782 D.getLocStart(), 6783 NameInfo, R, TInfo, isInline, 6784 /*isImplicitlyDeclared=*/false); 6785 6786 // If the class is complete, then we now create the implicit exception 6787 // specification. If the class is incomplete or dependent, we can't do 6788 // it yet. 6789 if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() && 6790 Record->getDefinition() && !Record->isBeingDefined() && 6791 R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) { 6792 SemaRef.AdjustDestructorExceptionSpec(Record, NewDD); 6793 } 6794 6795 IsVirtualOkay = true; 6796 return NewDD; 6797 6798 } else { 6799 SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member); 6800 D.setInvalidType(); 6801 6802 // Create a FunctionDecl to satisfy the function definition parsing 6803 // code path. 6804 return FunctionDecl::Create(SemaRef.Context, DC, 6805 D.getLocStart(), 6806 D.getIdentifierLoc(), Name, R, TInfo, 6807 SC, isInline, 6808 /*hasPrototype=*/true, isConstexpr); 6809 } 6810 6811 } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 6812 if (!DC->isRecord()) { 6813 SemaRef.Diag(D.getIdentifierLoc(), 6814 diag::err_conv_function_not_member); 6815 return nullptr; 6816 } 6817 6818 SemaRef.CheckConversionDeclarator(D, R, SC); 6819 IsVirtualOkay = true; 6820 return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC), 6821 D.getLocStart(), NameInfo, 6822 R, TInfo, isInline, isExplicit, 6823 isConstexpr, SourceLocation()); 6824 6825 } else if (DC->isRecord()) { 6826 // If the name of the function is the same as the name of the record, 6827 // then this must be an invalid constructor that has a return type. 6828 // (The parser checks for a return type and makes the declarator a 6829 // constructor if it has no return type). 6830 if (Name.getAsIdentifierInfo() && 6831 Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){ 6832 SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type) 6833 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc()) 6834 << SourceRange(D.getIdentifierLoc()); 6835 return nullptr; 6836 } 6837 6838 // This is a C++ method declaration. 6839 CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context, 6840 cast<CXXRecordDecl>(DC), 6841 D.getLocStart(), NameInfo, R, 6842 TInfo, SC, isInline, 6843 isConstexpr, SourceLocation()); 6844 IsVirtualOkay = !Ret->isStatic(); 6845 return Ret; 6846 } else { 6847 bool isFriend = 6848 SemaRef.getLangOpts().CPlusPlus && D.getDeclSpec().isFriendSpecified(); 6849 if (!isFriend && SemaRef.CurContext->isRecord()) 6850 return nullptr; 6851 6852 // Determine whether the function was written with a 6853 // prototype. This true when: 6854 // - we're in C++ (where every function has a prototype), 6855 return FunctionDecl::Create(SemaRef.Context, DC, 6856 D.getLocStart(), 6857 NameInfo, R, TInfo, SC, isInline, 6858 true/*HasPrototype*/, isConstexpr); 6859 } 6860 } 6861 6862 enum OpenCLParamType { 6863 ValidKernelParam, 6864 PtrPtrKernelParam, 6865 PtrKernelParam, 6866 PrivatePtrKernelParam, 6867 InvalidKernelParam, 6868 RecordKernelParam 6869 }; 6870 6871 static OpenCLParamType getOpenCLKernelParameterType(QualType PT) { 6872 if (PT->isPointerType()) { 6873 QualType PointeeType = PT->getPointeeType(); 6874 if (PointeeType->isPointerType()) 6875 return PtrPtrKernelParam; 6876 return PointeeType.getAddressSpace() == 0 ? PrivatePtrKernelParam 6877 : PtrKernelParam; 6878 } 6879 6880 // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can 6881 // be used as builtin types. 6882 6883 if (PT->isImageType()) 6884 return PtrKernelParam; 6885 6886 if (PT->isBooleanType()) 6887 return InvalidKernelParam; 6888 6889 if (PT->isEventT()) 6890 return InvalidKernelParam; 6891 6892 if (PT->isHalfType()) 6893 return InvalidKernelParam; 6894 6895 if (PT->isRecordType()) 6896 return RecordKernelParam; 6897 6898 return ValidKernelParam; 6899 } 6900 6901 static void checkIsValidOpenCLKernelParameter( 6902 Sema &S, 6903 Declarator &D, 6904 ParmVarDecl *Param, 6905 llvm::SmallPtrSetImpl<const Type *> &ValidTypes) { 6906 QualType PT = Param->getType(); 6907 6908 // Cache the valid types we encounter to avoid rechecking structs that are 6909 // used again 6910 if (ValidTypes.count(PT.getTypePtr())) 6911 return; 6912 6913 switch (getOpenCLKernelParameterType(PT)) { 6914 case PtrPtrKernelParam: 6915 // OpenCL v1.2 s6.9.a: 6916 // A kernel function argument cannot be declared as a 6917 // pointer to a pointer type. 6918 S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param); 6919 D.setInvalidType(); 6920 return; 6921 6922 case PrivatePtrKernelParam: 6923 // OpenCL v1.2 s6.9.a: 6924 // A kernel function argument cannot be declared as a 6925 // pointer to the private address space. 6926 S.Diag(Param->getLocation(), diag::err_opencl_private_ptr_kernel_param); 6927 D.setInvalidType(); 6928 return; 6929 6930 // OpenCL v1.2 s6.9.k: 6931 // Arguments to kernel functions in a program cannot be declared with the 6932 // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and 6933 // uintptr_t or a struct and/or union that contain fields declared to be 6934 // one of these built-in scalar types. 6935 6936 case InvalidKernelParam: 6937 // OpenCL v1.2 s6.8 n: 6938 // A kernel function argument cannot be declared 6939 // of event_t type. 6940 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 6941 D.setInvalidType(); 6942 return; 6943 6944 case PtrKernelParam: 6945 case ValidKernelParam: 6946 ValidTypes.insert(PT.getTypePtr()); 6947 return; 6948 6949 case RecordKernelParam: 6950 break; 6951 } 6952 6953 // Track nested structs we will inspect 6954 SmallVector<const Decl *, 4> VisitStack; 6955 6956 // Track where we are in the nested structs. Items will migrate from 6957 // VisitStack to HistoryStack as we do the DFS for bad field. 6958 SmallVector<const FieldDecl *, 4> HistoryStack; 6959 HistoryStack.push_back(nullptr); 6960 6961 const RecordDecl *PD = PT->castAs<RecordType>()->getDecl(); 6962 VisitStack.push_back(PD); 6963 6964 assert(VisitStack.back() && "First decl null?"); 6965 6966 do { 6967 const Decl *Next = VisitStack.pop_back_val(); 6968 if (!Next) { 6969 assert(!HistoryStack.empty()); 6970 // Found a marker, we have gone up a level 6971 if (const FieldDecl *Hist = HistoryStack.pop_back_val()) 6972 ValidTypes.insert(Hist->getType().getTypePtr()); 6973 6974 continue; 6975 } 6976 6977 // Adds everything except the original parameter declaration (which is not a 6978 // field itself) to the history stack. 6979 const RecordDecl *RD; 6980 if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) { 6981 HistoryStack.push_back(Field); 6982 RD = Field->getType()->castAs<RecordType>()->getDecl(); 6983 } else { 6984 RD = cast<RecordDecl>(Next); 6985 } 6986 6987 // Add a null marker so we know when we've gone back up a level 6988 VisitStack.push_back(nullptr); 6989 6990 for (const auto *FD : RD->fields()) { 6991 QualType QT = FD->getType(); 6992 6993 if (ValidTypes.count(QT.getTypePtr())) 6994 continue; 6995 6996 OpenCLParamType ParamType = getOpenCLKernelParameterType(QT); 6997 if (ParamType == ValidKernelParam) 6998 continue; 6999 7000 if (ParamType == RecordKernelParam) { 7001 VisitStack.push_back(FD); 7002 continue; 7003 } 7004 7005 // OpenCL v1.2 s6.9.p: 7006 // Arguments to kernel functions that are declared to be a struct or union 7007 // do not allow OpenCL objects to be passed as elements of the struct or 7008 // union. 7009 if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam || 7010 ParamType == PrivatePtrKernelParam) { 7011 S.Diag(Param->getLocation(), 7012 diag::err_record_with_pointers_kernel_param) 7013 << PT->isUnionType() 7014 << PT; 7015 } else { 7016 S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT; 7017 } 7018 7019 S.Diag(PD->getLocation(), diag::note_within_field_of_type) 7020 << PD->getDeclName(); 7021 7022 // We have an error, now let's go back up through history and show where 7023 // the offending field came from 7024 for (ArrayRef<const FieldDecl *>::const_iterator 7025 I = HistoryStack.begin() + 1, 7026 E = HistoryStack.end(); 7027 I != E; ++I) { 7028 const FieldDecl *OuterField = *I; 7029 S.Diag(OuterField->getLocation(), diag::note_within_field_of_type) 7030 << OuterField->getType(); 7031 } 7032 7033 S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here) 7034 << QT->isPointerType() 7035 << QT; 7036 D.setInvalidType(); 7037 return; 7038 } 7039 } while (!VisitStack.empty()); 7040 } 7041 7042 NamedDecl* 7043 Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, 7044 TypeSourceInfo *TInfo, LookupResult &Previous, 7045 MultiTemplateParamsArg TemplateParamLists, 7046 bool &AddToScope) { 7047 QualType R = TInfo->getType(); 7048 7049 assert(R.getTypePtr()->isFunctionType()); 7050 7051 // TODO: consider using NameInfo for diagnostic. 7052 DeclarationNameInfo NameInfo = GetNameForDeclarator(D); 7053 DeclarationName Name = NameInfo.getName(); 7054 StorageClass SC = getFunctionStorageClass(*this, D); 7055 7056 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 7057 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 7058 diag::err_invalid_thread) 7059 << DeclSpec::getSpecifierName(TSCS); 7060 7061 if (D.isFirstDeclarationOfMember()) 7062 adjustMemberFunctionCC(R, D.isStaticMember()); 7063 7064 bool isFriend = false; 7065 FunctionTemplateDecl *FunctionTemplate = nullptr; 7066 bool isExplicitSpecialization = false; 7067 bool isFunctionTemplateSpecialization = false; 7068 7069 bool isDependentClassScopeExplicitSpecialization = false; 7070 bool HasExplicitTemplateArgs = false; 7071 TemplateArgumentListInfo TemplateArgs; 7072 7073 bool isVirtualOkay = false; 7074 7075 DeclContext *OriginalDC = DC; 7076 bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC); 7077 7078 FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC, 7079 isVirtualOkay); 7080 if (!NewFD) return nullptr; 7081 7082 if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer()) 7083 NewFD->setTopLevelDeclInObjCContainer(); 7084 7085 // Set the lexical context. If this is a function-scope declaration, or has a 7086 // C++ scope specifier, or is the object of a friend declaration, the lexical 7087 // context will be different from the semantic context. 7088 NewFD->setLexicalDeclContext(CurContext); 7089 7090 if (IsLocalExternDecl) 7091 NewFD->setLocalExternDecl(); 7092 7093 if (getLangOpts().CPlusPlus) { 7094 bool isInline = D.getDeclSpec().isInlineSpecified(); 7095 bool isVirtual = D.getDeclSpec().isVirtualSpecified(); 7096 bool isExplicit = D.getDeclSpec().isExplicitSpecified(); 7097 bool isConstexpr = D.getDeclSpec().isConstexprSpecified(); 7098 isFriend = D.getDeclSpec().isFriendSpecified(); 7099 if (isFriend && !isInline && D.isFunctionDefinition()) { 7100 // C++ [class.friend]p5 7101 // A function can be defined in a friend declaration of a 7102 // class . . . . Such a function is implicitly inline. 7103 NewFD->setImplicitlyInline(); 7104 } 7105 7106 // If this is a method defined in an __interface, and is not a constructor 7107 // or an overloaded operator, then set the pure flag (isVirtual will already 7108 // return true). 7109 if (const CXXRecordDecl *Parent = 7110 dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) { 7111 if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided()) 7112 NewFD->setPure(true); 7113 } 7114 7115 SetNestedNameSpecifier(NewFD, D); 7116 isExplicitSpecialization = false; 7117 isFunctionTemplateSpecialization = false; 7118 if (D.isInvalidType()) 7119 NewFD->setInvalidDecl(); 7120 7121 // Match up the template parameter lists with the scope specifier, then 7122 // determine whether we have a template or a template specialization. 7123 bool Invalid = false; 7124 if (TemplateParameterList *TemplateParams = 7125 MatchTemplateParametersToScopeSpecifier( 7126 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(), 7127 D.getCXXScopeSpec(), 7128 D.getName().getKind() == UnqualifiedId::IK_TemplateId 7129 ? D.getName().TemplateId 7130 : nullptr, 7131 TemplateParamLists, isFriend, isExplicitSpecialization, 7132 Invalid)) { 7133 if (TemplateParams->size() > 0) { 7134 // This is a function template 7135 7136 // Check that we can declare a template here. 7137 if (CheckTemplateDeclScope(S, TemplateParams)) 7138 NewFD->setInvalidDecl(); 7139 7140 // A destructor cannot be a template. 7141 if (Name.getNameKind() == DeclarationName::CXXDestructorName) { 7142 Diag(NewFD->getLocation(), diag::err_destructor_template); 7143 NewFD->setInvalidDecl(); 7144 } 7145 7146 // If we're adding a template to a dependent context, we may need to 7147 // rebuilding some of the types used within the template parameter list, 7148 // now that we know what the current instantiation is. 7149 if (DC->isDependentContext()) { 7150 ContextRAII SavedContext(*this, DC); 7151 if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams)) 7152 Invalid = true; 7153 } 7154 7155 7156 FunctionTemplate = FunctionTemplateDecl::Create(Context, DC, 7157 NewFD->getLocation(), 7158 Name, TemplateParams, 7159 NewFD); 7160 FunctionTemplate->setLexicalDeclContext(CurContext); 7161 NewFD->setDescribedFunctionTemplate(FunctionTemplate); 7162 7163 // For source fidelity, store the other template param lists. 7164 if (TemplateParamLists.size() > 1) { 7165 NewFD->setTemplateParameterListsInfo(Context, 7166 TemplateParamLists.size() - 1, 7167 TemplateParamLists.data()); 7168 } 7169 } else { 7170 // This is a function template specialization. 7171 isFunctionTemplateSpecialization = true; 7172 // For source fidelity, store all the template param lists. 7173 if (TemplateParamLists.size() > 0) 7174 NewFD->setTemplateParameterListsInfo(Context, 7175 TemplateParamLists.size(), 7176 TemplateParamLists.data()); 7177 7178 // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);". 7179 if (isFriend) { 7180 // We want to remove the "template<>", found here. 7181 SourceRange RemoveRange = TemplateParams->getSourceRange(); 7182 7183 // If we remove the template<> and the name is not a 7184 // template-id, we're actually silently creating a problem: 7185 // the friend declaration will refer to an untemplated decl, 7186 // and clearly the user wants a template specialization. So 7187 // we need to insert '<>' after the name. 7188 SourceLocation InsertLoc; 7189 if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) { 7190 InsertLoc = D.getName().getSourceRange().getEnd(); 7191 InsertLoc = getLocForEndOfToken(InsertLoc); 7192 } 7193 7194 Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend) 7195 << Name << RemoveRange 7196 << FixItHint::CreateRemoval(RemoveRange) 7197 << FixItHint::CreateInsertion(InsertLoc, "<>"); 7198 } 7199 } 7200 } 7201 else { 7202 // All template param lists were matched against the scope specifier: 7203 // this is NOT (an explicit specialization of) a template. 7204 if (TemplateParamLists.size() > 0) 7205 // For source fidelity, store all the template param lists. 7206 NewFD->setTemplateParameterListsInfo(Context, 7207 TemplateParamLists.size(), 7208 TemplateParamLists.data()); 7209 } 7210 7211 if (Invalid) { 7212 NewFD->setInvalidDecl(); 7213 if (FunctionTemplate) 7214 FunctionTemplate->setInvalidDecl(); 7215 } 7216 7217 // C++ [dcl.fct.spec]p5: 7218 // The virtual specifier shall only be used in declarations of 7219 // nonstatic class member functions that appear within a 7220 // member-specification of a class declaration; see 10.3. 7221 // 7222 if (isVirtual && !NewFD->isInvalidDecl()) { 7223 if (!isVirtualOkay) { 7224 Diag(D.getDeclSpec().getVirtualSpecLoc(), 7225 diag::err_virtual_non_function); 7226 } else if (!CurContext->isRecord()) { 7227 // 'virtual' was specified outside of the class. 7228 Diag(D.getDeclSpec().getVirtualSpecLoc(), 7229 diag::err_virtual_out_of_class) 7230 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 7231 } else if (NewFD->getDescribedFunctionTemplate()) { 7232 // C++ [temp.mem]p3: 7233 // A member function template shall not be virtual. 7234 Diag(D.getDeclSpec().getVirtualSpecLoc(), 7235 diag::err_virtual_member_function_template) 7236 << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc()); 7237 } else { 7238 // Okay: Add virtual to the method. 7239 NewFD->setVirtualAsWritten(true); 7240 } 7241 7242 if (getLangOpts().CPlusPlus14 && 7243 NewFD->getReturnType()->isUndeducedType()) 7244 Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual); 7245 } 7246 7247 if (getLangOpts().CPlusPlus14 && 7248 (NewFD->isDependentContext() || 7249 (isFriend && CurContext->isDependentContext())) && 7250 NewFD->getReturnType()->isUndeducedType()) { 7251 // If the function template is referenced directly (for instance, as a 7252 // member of the current instantiation), pretend it has a dependent type. 7253 // This is not really justified by the standard, but is the only sane 7254 // thing to do. 7255 // FIXME: For a friend function, we have not marked the function as being 7256 // a friend yet, so 'isDependentContext' on the FD doesn't work. 7257 const FunctionProtoType *FPT = 7258 NewFD->getType()->castAs<FunctionProtoType>(); 7259 QualType Result = 7260 SubstAutoType(FPT->getReturnType(), Context.DependentTy); 7261 NewFD->setType(Context.getFunctionType(Result, FPT->getParamTypes(), 7262 FPT->getExtProtoInfo())); 7263 } 7264 7265 // C++ [dcl.fct.spec]p3: 7266 // The inline specifier shall not appear on a block scope function 7267 // declaration. 7268 if (isInline && !NewFD->isInvalidDecl()) { 7269 if (CurContext->isFunctionOrMethod()) { 7270 // 'inline' is not allowed on block scope function declaration. 7271 Diag(D.getDeclSpec().getInlineSpecLoc(), 7272 diag::err_inline_declaration_block_scope) << Name 7273 << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc()); 7274 } 7275 } 7276 7277 // C++ [dcl.fct.spec]p6: 7278 // The explicit specifier shall be used only in the declaration of a 7279 // constructor or conversion function within its class definition; 7280 // see 12.3.1 and 12.3.2. 7281 if (isExplicit && !NewFD->isInvalidDecl()) { 7282 if (!CurContext->isRecord()) { 7283 // 'explicit' was specified outside of the class. 7284 Diag(D.getDeclSpec().getExplicitSpecLoc(), 7285 diag::err_explicit_out_of_class) 7286 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 7287 } else if (!isa<CXXConstructorDecl>(NewFD) && 7288 !isa<CXXConversionDecl>(NewFD)) { 7289 // 'explicit' was specified on a function that wasn't a constructor 7290 // or conversion function. 7291 Diag(D.getDeclSpec().getExplicitSpecLoc(), 7292 diag::err_explicit_non_ctor_or_conv_function) 7293 << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc()); 7294 } 7295 } 7296 7297 if (isConstexpr) { 7298 // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors 7299 // are implicitly inline. 7300 NewFD->setImplicitlyInline(); 7301 7302 // C++11 [dcl.constexpr]p3: functions declared constexpr are required to 7303 // be either constructors or to return a literal type. Therefore, 7304 // destructors cannot be declared constexpr. 7305 if (isa<CXXDestructorDecl>(NewFD)) 7306 Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor); 7307 } 7308 7309 // If __module_private__ was specified, mark the function accordingly. 7310 if (D.getDeclSpec().isModulePrivateSpecified()) { 7311 if (isFunctionTemplateSpecialization) { 7312 SourceLocation ModulePrivateLoc 7313 = D.getDeclSpec().getModulePrivateSpecLoc(); 7314 Diag(ModulePrivateLoc, diag::err_module_private_specialization) 7315 << 0 7316 << FixItHint::CreateRemoval(ModulePrivateLoc); 7317 } else { 7318 NewFD->setModulePrivate(); 7319 if (FunctionTemplate) 7320 FunctionTemplate->setModulePrivate(); 7321 } 7322 } 7323 7324 if (isFriend) { 7325 if (FunctionTemplate) { 7326 FunctionTemplate->setObjectOfFriendDecl(); 7327 FunctionTemplate->setAccess(AS_public); 7328 } 7329 NewFD->setObjectOfFriendDecl(); 7330 NewFD->setAccess(AS_public); 7331 } 7332 7333 // If a function is defined as defaulted or deleted, mark it as such now. 7334 // FIXME: Does this ever happen? ActOnStartOfFunctionDef forces the function 7335 // definition kind to FDK_Definition. 7336 switch (D.getFunctionDefinitionKind()) { 7337 case FDK_Declaration: 7338 case FDK_Definition: 7339 break; 7340 7341 case FDK_Defaulted: 7342 NewFD->setDefaulted(); 7343 break; 7344 7345 case FDK_Deleted: 7346 NewFD->setDeletedAsWritten(); 7347 break; 7348 } 7349 7350 if (isa<CXXMethodDecl>(NewFD) && DC == CurContext && 7351 D.isFunctionDefinition()) { 7352 // C++ [class.mfct]p2: 7353 // A member function may be defined (8.4) in its class definition, in 7354 // which case it is an inline member function (7.1.2) 7355 NewFD->setImplicitlyInline(); 7356 } 7357 7358 if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) && 7359 !CurContext->isRecord()) { 7360 // C++ [class.static]p1: 7361 // A data or function member of a class may be declared static 7362 // in a class definition, in which case it is a static member of 7363 // the class. 7364 7365 // Complain about the 'static' specifier if it's on an out-of-line 7366 // member function definition. 7367 Diag(D.getDeclSpec().getStorageClassSpecLoc(), 7368 diag::err_static_out_of_line) 7369 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc()); 7370 } 7371 7372 // C++11 [except.spec]p15: 7373 // A deallocation function with no exception-specification is treated 7374 // as if it were specified with noexcept(true). 7375 const FunctionProtoType *FPT = R->getAs<FunctionProtoType>(); 7376 if ((Name.getCXXOverloadedOperator() == OO_Delete || 7377 Name.getCXXOverloadedOperator() == OO_Array_Delete) && 7378 getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec()) 7379 NewFD->setType(Context.getFunctionType( 7380 FPT->getReturnType(), FPT->getParamTypes(), 7381 FPT->getExtProtoInfo().withExceptionSpec(EST_BasicNoexcept))); 7382 } 7383 7384 // Filter out previous declarations that don't match the scope. 7385 FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD), 7386 D.getCXXScopeSpec().isNotEmpty() || 7387 isExplicitSpecialization || 7388 isFunctionTemplateSpecialization); 7389 7390 // Handle GNU asm-label extension (encoded as an attribute). 7391 if (Expr *E = (Expr*) D.getAsmLabel()) { 7392 // The parser guarantees this is a string. 7393 StringLiteral *SE = cast<StringLiteral>(E); 7394 NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context, 7395 SE->getString(), 0)); 7396 } else if (!ExtnameUndeclaredIdentifiers.empty()) { 7397 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I = 7398 ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier()); 7399 if (I != ExtnameUndeclaredIdentifiers.end()) { 7400 NewFD->addAttr(I->second); 7401 ExtnameUndeclaredIdentifiers.erase(I); 7402 } 7403 } 7404 7405 // Copy the parameter declarations from the declarator D to the function 7406 // declaration NewFD, if they are available. First scavenge them into Params. 7407 SmallVector<ParmVarDecl*, 16> Params; 7408 if (D.isFunctionDeclarator()) { 7409 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 7410 7411 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs 7412 // function that takes no arguments, not a function that takes a 7413 // single void argument. 7414 // We let through "const void" here because Sema::GetTypeForDeclarator 7415 // already checks for that case. 7416 if (FTIHasNonVoidParameters(FTI) && FTI.Params[0].Param) { 7417 for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) { 7418 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param); 7419 assert(Param->getDeclContext() != NewFD && "Was set before ?"); 7420 Param->setDeclContext(NewFD); 7421 Params.push_back(Param); 7422 7423 if (Param->isInvalidDecl()) 7424 NewFD->setInvalidDecl(); 7425 } 7426 } 7427 7428 } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) { 7429 // When we're declaring a function with a typedef, typeof, etc as in the 7430 // following example, we'll need to synthesize (unnamed) 7431 // parameters for use in the declaration. 7432 // 7433 // @code 7434 // typedef void fn(int); 7435 // fn f; 7436 // @endcode 7437 7438 // Synthesize a parameter for each argument type. 7439 for (const auto &AI : FT->param_types()) { 7440 ParmVarDecl *Param = 7441 BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI); 7442 Param->setScopeInfo(0, Params.size()); 7443 Params.push_back(Param); 7444 } 7445 } else { 7446 assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 && 7447 "Should not need args for typedef of non-prototype fn"); 7448 } 7449 7450 // Finally, we know we have the right number of parameters, install them. 7451 NewFD->setParams(Params); 7452 7453 // Find all anonymous symbols defined during the declaration of this function 7454 // and add to NewFD. This lets us track decls such 'enum Y' in: 7455 // 7456 // void f(enum Y {AA} x) {} 7457 // 7458 // which would otherwise incorrectly end up in the translation unit scope. 7459 NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope); 7460 DeclsInPrototypeScope.clear(); 7461 7462 if (D.getDeclSpec().isNoreturnSpecified()) 7463 NewFD->addAttr( 7464 ::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(), 7465 Context, 0)); 7466 7467 // Functions returning a variably modified type violate C99 6.7.5.2p2 7468 // because all functions have linkage. 7469 if (!NewFD->isInvalidDecl() && 7470 NewFD->getReturnType()->isVariablyModifiedType()) { 7471 Diag(NewFD->getLocation(), diag::err_vm_func_decl); 7472 NewFD->setInvalidDecl(); 7473 } 7474 7475 // Apply an implicit SectionAttr if #pragma code_seg is active. 7476 if (CodeSegStack.CurrentValue && D.isFunctionDefinition() && 7477 !NewFD->hasAttr<SectionAttr>()) { 7478 NewFD->addAttr( 7479 SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate, 7480 CodeSegStack.CurrentValue->getString(), 7481 CodeSegStack.CurrentPragmaLocation)); 7482 if (UnifySection(CodeSegStack.CurrentValue->getString(), 7483 ASTContext::PSF_Implicit | ASTContext::PSF_Execute | 7484 ASTContext::PSF_Read, 7485 NewFD)) 7486 NewFD->dropAttr<SectionAttr>(); 7487 } 7488 7489 // Handle attributes. 7490 ProcessDeclAttributes(S, NewFD, D); 7491 7492 if (getLangOpts().OpenCL) { 7493 // OpenCL v1.1 s6.5: Using an address space qualifier in a function return 7494 // type declaration will generate a compilation error. 7495 unsigned AddressSpace = NewFD->getReturnType().getAddressSpace(); 7496 if (AddressSpace == LangAS::opencl_local || 7497 AddressSpace == LangAS::opencl_global || 7498 AddressSpace == LangAS::opencl_constant) { 7499 Diag(NewFD->getLocation(), 7500 diag::err_opencl_return_value_with_address_space); 7501 NewFD->setInvalidDecl(); 7502 } 7503 } 7504 7505 if (!getLangOpts().CPlusPlus) { 7506 // Perform semantic checking on the function declaration. 7507 bool isExplicitSpecialization=false; 7508 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 7509 CheckMain(NewFD, D.getDeclSpec()); 7510 7511 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint()) 7512 CheckMSVCRTEntryPoint(NewFD); 7513 7514 if (!NewFD->isInvalidDecl()) 7515 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 7516 isExplicitSpecialization)); 7517 else if (!Previous.empty()) 7518 // Recover gracefully from an invalid redeclaration. 7519 D.setRedeclaration(true); 7520 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 7521 Previous.getResultKind() != LookupResult::FoundOverloaded) && 7522 "previous declaration set still overloaded"); 7523 7524 // Diagnose no-prototype function declarations with calling conventions that 7525 // don't support variadic calls. Only do this in C and do it after merging 7526 // possibly prototyped redeclarations. 7527 const FunctionType *FT = NewFD->getType()->castAs<FunctionType>(); 7528 if (isa<FunctionNoProtoType>(FT) && !D.isFunctionDefinition()) { 7529 CallingConv CC = FT->getExtInfo().getCC(); 7530 if (!supportsVariadicCall(CC)) { 7531 // Windows system headers sometimes accidentally use stdcall without 7532 // (void) parameters, so we relax this to a warning. 7533 int DiagID = 7534 CC == CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr; 7535 Diag(NewFD->getLocation(), DiagID) 7536 << FunctionType::getNameForCallConv(CC); 7537 } 7538 } 7539 } else { 7540 // C++11 [replacement.functions]p3: 7541 // The program's definitions shall not be specified as inline. 7542 // 7543 // N.B. We diagnose declarations instead of definitions per LWG issue 2340. 7544 // 7545 // Suppress the diagnostic if the function is __attribute__((used)), since 7546 // that forces an external definition to be emitted. 7547 if (D.getDeclSpec().isInlineSpecified() && 7548 NewFD->isReplaceableGlobalAllocationFunction() && 7549 !NewFD->hasAttr<UsedAttr>()) 7550 Diag(D.getDeclSpec().getInlineSpecLoc(), 7551 diag::ext_operator_new_delete_declared_inline) 7552 << NewFD->getDeclName(); 7553 7554 // If the declarator is a template-id, translate the parser's template 7555 // argument list into our AST format. 7556 if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) { 7557 TemplateIdAnnotation *TemplateId = D.getName().TemplateId; 7558 TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc); 7559 TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc); 7560 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), 7561 TemplateId->NumArgs); 7562 translateTemplateArguments(TemplateArgsPtr, 7563 TemplateArgs); 7564 7565 HasExplicitTemplateArgs = true; 7566 7567 if (NewFD->isInvalidDecl()) { 7568 HasExplicitTemplateArgs = false; 7569 } else if (FunctionTemplate) { 7570 // Function template with explicit template arguments. 7571 Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec) 7572 << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc); 7573 7574 HasExplicitTemplateArgs = false; 7575 } else { 7576 assert((isFunctionTemplateSpecialization || 7577 D.getDeclSpec().isFriendSpecified()) && 7578 "should have a 'template<>' for this decl"); 7579 // "friend void foo<>(int);" is an implicit specialization decl. 7580 isFunctionTemplateSpecialization = true; 7581 } 7582 } else if (isFriend && isFunctionTemplateSpecialization) { 7583 // This combination is only possible in a recovery case; the user 7584 // wrote something like: 7585 // template <> friend void foo(int); 7586 // which we're recovering from as if the user had written: 7587 // friend void foo<>(int); 7588 // Go ahead and fake up a template id. 7589 HasExplicitTemplateArgs = true; 7590 TemplateArgs.setLAngleLoc(D.getIdentifierLoc()); 7591 TemplateArgs.setRAngleLoc(D.getIdentifierLoc()); 7592 } 7593 7594 // If it's a friend (and only if it's a friend), it's possible 7595 // that either the specialized function type or the specialized 7596 // template is dependent, and therefore matching will fail. In 7597 // this case, don't check the specialization yet. 7598 bool InstantiationDependent = false; 7599 if (isFunctionTemplateSpecialization && isFriend && 7600 (NewFD->getType()->isDependentType() || DC->isDependentContext() || 7601 TemplateSpecializationType::anyDependentTemplateArguments( 7602 TemplateArgs.getArgumentArray(), TemplateArgs.size(), 7603 InstantiationDependent))) { 7604 assert(HasExplicitTemplateArgs && 7605 "friend function specialization without template args"); 7606 if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs, 7607 Previous)) 7608 NewFD->setInvalidDecl(); 7609 } else if (isFunctionTemplateSpecialization) { 7610 if (CurContext->isDependentContext() && CurContext->isRecord() 7611 && !isFriend) { 7612 isDependentClassScopeExplicitSpecialization = true; 7613 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 7614 diag::ext_function_specialization_in_class : 7615 diag::err_function_specialization_in_class) 7616 << NewFD->getDeclName(); 7617 } else if (CheckFunctionTemplateSpecialization(NewFD, 7618 (HasExplicitTemplateArgs ? &TemplateArgs 7619 : nullptr), 7620 Previous)) 7621 NewFD->setInvalidDecl(); 7622 7623 // C++ [dcl.stc]p1: 7624 // A storage-class-specifier shall not be specified in an explicit 7625 // specialization (14.7.3) 7626 FunctionTemplateSpecializationInfo *Info = 7627 NewFD->getTemplateSpecializationInfo(); 7628 if (Info && SC != SC_None) { 7629 if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass()) 7630 Diag(NewFD->getLocation(), 7631 diag::err_explicit_specialization_inconsistent_storage_class) 7632 << SC 7633 << FixItHint::CreateRemoval( 7634 D.getDeclSpec().getStorageClassSpecLoc()); 7635 7636 else 7637 Diag(NewFD->getLocation(), 7638 diag::ext_explicit_specialization_storage_class) 7639 << FixItHint::CreateRemoval( 7640 D.getDeclSpec().getStorageClassSpecLoc()); 7641 } 7642 7643 } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) { 7644 if (CheckMemberSpecialization(NewFD, Previous)) 7645 NewFD->setInvalidDecl(); 7646 } 7647 7648 // Perform semantic checking on the function declaration. 7649 if (!isDependentClassScopeExplicitSpecialization) { 7650 if (!NewFD->isInvalidDecl() && NewFD->isMain()) 7651 CheckMain(NewFD, D.getDeclSpec()); 7652 7653 if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint()) 7654 CheckMSVCRTEntryPoint(NewFD); 7655 7656 if (!NewFD->isInvalidDecl()) 7657 D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous, 7658 isExplicitSpecialization)); 7659 else if (!Previous.empty()) 7660 // Recover gracefully from an invalid redeclaration. 7661 D.setRedeclaration(true); 7662 } 7663 7664 assert((NewFD->isInvalidDecl() || !D.isRedeclaration() || 7665 Previous.getResultKind() != LookupResult::FoundOverloaded) && 7666 "previous declaration set still overloaded"); 7667 7668 NamedDecl *PrincipalDecl = (FunctionTemplate 7669 ? cast<NamedDecl>(FunctionTemplate) 7670 : NewFD); 7671 7672 if (isFriend && D.isRedeclaration()) { 7673 AccessSpecifier Access = AS_public; 7674 if (!NewFD->isInvalidDecl()) 7675 Access = NewFD->getPreviousDecl()->getAccess(); 7676 7677 NewFD->setAccess(Access); 7678 if (FunctionTemplate) FunctionTemplate->setAccess(Access); 7679 } 7680 7681 if (NewFD->isOverloadedOperator() && !DC->isRecord() && 7682 PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 7683 PrincipalDecl->setNonMemberOperator(); 7684 7685 // If we have a function template, check the template parameter 7686 // list. This will check and merge default template arguments. 7687 if (FunctionTemplate) { 7688 FunctionTemplateDecl *PrevTemplate = 7689 FunctionTemplate->getPreviousDecl(); 7690 CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(), 7691 PrevTemplate ? PrevTemplate->getTemplateParameters() 7692 : nullptr, 7693 D.getDeclSpec().isFriendSpecified() 7694 ? (D.isFunctionDefinition() 7695 ? TPC_FriendFunctionTemplateDefinition 7696 : TPC_FriendFunctionTemplate) 7697 : (D.getCXXScopeSpec().isSet() && 7698 DC && DC->isRecord() && 7699 DC->isDependentContext()) 7700 ? TPC_ClassTemplateMember 7701 : TPC_FunctionTemplate); 7702 } 7703 7704 if (NewFD->isInvalidDecl()) { 7705 // Ignore all the rest of this. 7706 } else if (!D.isRedeclaration()) { 7707 struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists, 7708 AddToScope }; 7709 // Fake up an access specifier if it's supposed to be a class member. 7710 if (isa<CXXRecordDecl>(NewFD->getDeclContext())) 7711 NewFD->setAccess(AS_public); 7712 7713 // Qualified decls generally require a previous declaration. 7714 if (D.getCXXScopeSpec().isSet()) { 7715 // ...with the major exception of templated-scope or 7716 // dependent-scope friend declarations. 7717 7718 // TODO: we currently also suppress this check in dependent 7719 // contexts because (1) the parameter depth will be off when 7720 // matching friend templates and (2) we might actually be 7721 // selecting a friend based on a dependent factor. But there 7722 // are situations where these conditions don't apply and we 7723 // can actually do this check immediately. 7724 if (isFriend && 7725 (TemplateParamLists.size() || 7726 D.getCXXScopeSpec().getScopeRep()->isDependent() || 7727 CurContext->isDependentContext())) { 7728 // ignore these 7729 } else { 7730 // The user tried to provide an out-of-line definition for a 7731 // function that is a member of a class or namespace, but there 7732 // was no such member function declared (C++ [class.mfct]p2, 7733 // C++ [namespace.memdef]p2). For example: 7734 // 7735 // class X { 7736 // void f() const; 7737 // }; 7738 // 7739 // void X::f() { } // ill-formed 7740 // 7741 // Complain about this problem, and attempt to suggest close 7742 // matches (e.g., those that differ only in cv-qualifiers and 7743 // whether the parameter types are references). 7744 7745 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 7746 *this, Previous, NewFD, ExtraArgs, false, nullptr)) { 7747 AddToScope = ExtraArgs.AddToScope; 7748 return Result; 7749 } 7750 } 7751 7752 // Unqualified local friend declarations are required to resolve 7753 // to something. 7754 } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) { 7755 if (NamedDecl *Result = DiagnoseInvalidRedeclaration( 7756 *this, Previous, NewFD, ExtraArgs, true, S)) { 7757 AddToScope = ExtraArgs.AddToScope; 7758 return Result; 7759 } 7760 } 7761 7762 } else if (!D.isFunctionDefinition() && 7763 isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() && 7764 !isFriend && !isFunctionTemplateSpecialization && 7765 !isExplicitSpecialization) { 7766 // An out-of-line member function declaration must also be a 7767 // definition (C++ [class.mfct]p2). 7768 // Note that this is not the case for explicit specializations of 7769 // function templates or member functions of class templates, per 7770 // C++ [temp.expl.spec]p2. We also allow these declarations as an 7771 // extension for compatibility with old SWIG code which likes to 7772 // generate them. 7773 Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration) 7774 << D.getCXXScopeSpec().getRange(); 7775 } 7776 } 7777 7778 ProcessPragmaWeak(S, NewFD); 7779 checkAttributesAfterMerging(*this, *NewFD); 7780 7781 AddKnownFunctionAttributes(NewFD); 7782 7783 if (NewFD->hasAttr<OverloadableAttr>() && 7784 !NewFD->getType()->getAs<FunctionProtoType>()) { 7785 Diag(NewFD->getLocation(), 7786 diag::err_attribute_overloadable_no_prototype) 7787 << NewFD; 7788 7789 // Turn this into a variadic function with no parameters. 7790 const FunctionType *FT = NewFD->getType()->getAs<FunctionType>(); 7791 FunctionProtoType::ExtProtoInfo EPI( 7792 Context.getDefaultCallingConvention(true, false)); 7793 EPI.Variadic = true; 7794 EPI.ExtInfo = FT->getExtInfo(); 7795 7796 QualType R = Context.getFunctionType(FT->getReturnType(), None, EPI); 7797 NewFD->setType(R); 7798 } 7799 7800 // If there's a #pragma GCC visibility in scope, and this isn't a class 7801 // member, set the visibility of this function. 7802 if (!DC->isRecord() && NewFD->isExternallyVisible()) 7803 AddPushedVisibilityAttribute(NewFD); 7804 7805 // If there's a #pragma clang arc_cf_code_audited in scope, consider 7806 // marking the function. 7807 AddCFAuditedAttribute(NewFD); 7808 7809 // If this is a function definition, check if we have to apply optnone due to 7810 // a pragma. 7811 if(D.isFunctionDefinition()) 7812 AddRangeBasedOptnone(NewFD); 7813 7814 // If this is the first declaration of an extern C variable, update 7815 // the map of such variables. 7816 if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() && 7817 isIncompleteDeclExternC(*this, NewFD)) 7818 RegisterLocallyScopedExternCDecl(NewFD, S); 7819 7820 // Set this FunctionDecl's range up to the right paren. 7821 NewFD->setRangeEnd(D.getSourceRange().getEnd()); 7822 7823 if (D.isRedeclaration() && !Previous.empty()) { 7824 checkDLLAttributeRedeclaration( 7825 *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewFD, 7826 isExplicitSpecialization || isFunctionTemplateSpecialization); 7827 } 7828 7829 if (getLangOpts().CPlusPlus) { 7830 if (FunctionTemplate) { 7831 if (NewFD->isInvalidDecl()) 7832 FunctionTemplate->setInvalidDecl(); 7833 return FunctionTemplate; 7834 } 7835 } 7836 7837 if (NewFD->hasAttr<OpenCLKernelAttr>()) { 7838 // OpenCL v1.2 s6.8 static is invalid for kernel functions. 7839 if ((getLangOpts().OpenCLVersion >= 120) 7840 && (SC == SC_Static)) { 7841 Diag(D.getIdentifierLoc(), diag::err_static_kernel); 7842 D.setInvalidType(); 7843 } 7844 7845 // OpenCL v1.2, s6.9 -- Kernels can only have return type void. 7846 if (!NewFD->getReturnType()->isVoidType()) { 7847 SourceRange RTRange = NewFD->getReturnTypeSourceRange(); 7848 Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type) 7849 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void") 7850 : FixItHint()); 7851 D.setInvalidType(); 7852 } 7853 7854 llvm::SmallPtrSet<const Type *, 16> ValidTypes; 7855 for (auto Param : NewFD->params()) 7856 checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes); 7857 } 7858 7859 MarkUnusedFileScopedDecl(NewFD); 7860 7861 if (getLangOpts().CUDA) 7862 if (IdentifierInfo *II = NewFD->getIdentifier()) 7863 if (!NewFD->isInvalidDecl() && 7864 NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { 7865 if (II->isStr("cudaConfigureCall")) { 7866 if (!R->getAs<FunctionType>()->getReturnType()->isScalarType()) 7867 Diag(NewFD->getLocation(), diag::err_config_scalar_return); 7868 7869 Context.setcudaConfigureCallDecl(NewFD); 7870 } 7871 } 7872 7873 // Here we have an function template explicit specialization at class scope. 7874 // The actually specialization will be postponed to template instatiation 7875 // time via the ClassScopeFunctionSpecializationDecl node. 7876 if (isDependentClassScopeExplicitSpecialization) { 7877 ClassScopeFunctionSpecializationDecl *NewSpec = 7878 ClassScopeFunctionSpecializationDecl::Create( 7879 Context, CurContext, SourceLocation(), 7880 cast<CXXMethodDecl>(NewFD), 7881 HasExplicitTemplateArgs, TemplateArgs); 7882 CurContext->addDecl(NewSpec); 7883 AddToScope = false; 7884 } 7885 7886 return NewFD; 7887 } 7888 7889 /// \brief Perform semantic checking of a new function declaration. 7890 /// 7891 /// Performs semantic analysis of the new function declaration 7892 /// NewFD. This routine performs all semantic checking that does not 7893 /// require the actual declarator involved in the declaration, and is 7894 /// used both for the declaration of functions as they are parsed 7895 /// (called via ActOnDeclarator) and for the declaration of functions 7896 /// that have been instantiated via C++ template instantiation (called 7897 /// via InstantiateDecl). 7898 /// 7899 /// \param IsExplicitSpecialization whether this new function declaration is 7900 /// an explicit specialization of the previous declaration. 7901 /// 7902 /// This sets NewFD->isInvalidDecl() to true if there was an error. 7903 /// 7904 /// \returns true if the function declaration is a redeclaration. 7905 bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, 7906 LookupResult &Previous, 7907 bool IsExplicitSpecialization) { 7908 assert(!NewFD->getReturnType()->isVariablyModifiedType() && 7909 "Variably modified return types are not handled here"); 7910 7911 // Determine whether the type of this function should be merged with 7912 // a previous visible declaration. This never happens for functions in C++, 7913 // and always happens in C if the previous declaration was visible. 7914 bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus && 7915 !Previous.isShadowed(); 7916 7917 // Filter out any non-conflicting previous declarations. 7918 filterNonConflictingPreviousDecls(Context, NewFD, Previous); 7919 7920 bool Redeclaration = false; 7921 NamedDecl *OldDecl = nullptr; 7922 7923 // Merge or overload the declaration with an existing declaration of 7924 // the same name, if appropriate. 7925 if (!Previous.empty()) { 7926 // Determine whether NewFD is an overload of PrevDecl or 7927 // a declaration that requires merging. If it's an overload, 7928 // there's no more work to do here; we'll just add the new 7929 // function to the scope. 7930 if (!AllowOverloadingOfFunction(Previous, Context)) { 7931 NamedDecl *Candidate = Previous.getFoundDecl(); 7932 if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) { 7933 Redeclaration = true; 7934 OldDecl = Candidate; 7935 } 7936 } else { 7937 switch (CheckOverload(S, NewFD, Previous, OldDecl, 7938 /*NewIsUsingDecl*/ false)) { 7939 case Ovl_Match: 7940 Redeclaration = true; 7941 break; 7942 7943 case Ovl_NonFunction: 7944 Redeclaration = true; 7945 break; 7946 7947 case Ovl_Overload: 7948 Redeclaration = false; 7949 break; 7950 } 7951 7952 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) { 7953 // If a function name is overloadable in C, then every function 7954 // with that name must be marked "overloadable". 7955 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing) 7956 << Redeclaration << NewFD; 7957 NamedDecl *OverloadedDecl = nullptr; 7958 if (Redeclaration) 7959 OverloadedDecl = OldDecl; 7960 else if (!Previous.empty()) 7961 OverloadedDecl = Previous.getRepresentativeDecl(); 7962 if (OverloadedDecl) 7963 Diag(OverloadedDecl->getLocation(), 7964 diag::note_attribute_overloadable_prev_overload); 7965 NewFD->addAttr(OverloadableAttr::CreateImplicit(Context)); 7966 } 7967 } 7968 } 7969 7970 // Check for a previous extern "C" declaration with this name. 7971 if (!Redeclaration && 7972 checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) { 7973 filterNonConflictingPreviousDecls(Context, NewFD, Previous); 7974 if (!Previous.empty()) { 7975 // This is an extern "C" declaration with the same name as a previous 7976 // declaration, and thus redeclares that entity... 7977 Redeclaration = true; 7978 OldDecl = Previous.getFoundDecl(); 7979 MergeTypeWithPrevious = false; 7980 7981 // ... except in the presence of __attribute__((overloadable)). 7982 if (OldDecl->hasAttr<OverloadableAttr>()) { 7983 if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) { 7984 Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing) 7985 << Redeclaration << NewFD; 7986 Diag(Previous.getFoundDecl()->getLocation(), 7987 diag::note_attribute_overloadable_prev_overload); 7988 NewFD->addAttr(OverloadableAttr::CreateImplicit(Context)); 7989 } 7990 if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) { 7991 Redeclaration = false; 7992 OldDecl = nullptr; 7993 } 7994 } 7995 } 7996 } 7997 7998 // C++11 [dcl.constexpr]p8: 7999 // A constexpr specifier for a non-static member function that is not 8000 // a constructor declares that member function to be const. 8001 // 8002 // This needs to be delayed until we know whether this is an out-of-line 8003 // definition of a static member function. 8004 // 8005 // This rule is not present in C++1y, so we produce a backwards 8006 // compatibility warning whenever it happens in C++11. 8007 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD); 8008 if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() && 8009 !MD->isStatic() && !isa<CXXConstructorDecl>(MD) && 8010 (MD->getTypeQualifiers() & Qualifiers::Const) == 0) { 8011 CXXMethodDecl *OldMD = nullptr; 8012 if (OldDecl) 8013 OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl->getAsFunction()); 8014 if (!OldMD || !OldMD->isStatic()) { 8015 const FunctionProtoType *FPT = 8016 MD->getType()->castAs<FunctionProtoType>(); 8017 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 8018 EPI.TypeQuals |= Qualifiers::Const; 8019 MD->setType(Context.getFunctionType(FPT->getReturnType(), 8020 FPT->getParamTypes(), EPI)); 8021 8022 // Warn that we did this, if we're not performing template instantiation. 8023 // In that case, we'll have warned already when the template was defined. 8024 if (ActiveTemplateInstantiations.empty()) { 8025 SourceLocation AddConstLoc; 8026 if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc() 8027 .IgnoreParens().getAs<FunctionTypeLoc>()) 8028 AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc()); 8029 8030 Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const) 8031 << FixItHint::CreateInsertion(AddConstLoc, " const"); 8032 } 8033 } 8034 } 8035 8036 if (Redeclaration) { 8037 // NewFD and OldDecl represent declarations that need to be 8038 // merged. 8039 if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) { 8040 NewFD->setInvalidDecl(); 8041 return Redeclaration; 8042 } 8043 8044 Previous.clear(); 8045 Previous.addDecl(OldDecl); 8046 8047 if (FunctionTemplateDecl *OldTemplateDecl 8048 = dyn_cast<FunctionTemplateDecl>(OldDecl)) { 8049 NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl()); 8050 FunctionTemplateDecl *NewTemplateDecl 8051 = NewFD->getDescribedFunctionTemplate(); 8052 assert(NewTemplateDecl && "Template/non-template mismatch"); 8053 if (CXXMethodDecl *Method 8054 = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) { 8055 Method->setAccess(OldTemplateDecl->getAccess()); 8056 NewTemplateDecl->setAccess(OldTemplateDecl->getAccess()); 8057 } 8058 8059 // If this is an explicit specialization of a member that is a function 8060 // template, mark it as a member specialization. 8061 if (IsExplicitSpecialization && 8062 NewTemplateDecl->getInstantiatedFromMemberTemplate()) { 8063 NewTemplateDecl->setMemberSpecialization(); 8064 assert(OldTemplateDecl->isMemberSpecialization()); 8065 } 8066 8067 } else { 8068 // This needs to happen first so that 'inline' propagates. 8069 NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl)); 8070 8071 if (isa<CXXMethodDecl>(NewFD)) 8072 NewFD->setAccess(OldDecl->getAccess()); 8073 } 8074 } 8075 8076 // Semantic checking for this function declaration (in isolation). 8077 8078 if (getLangOpts().CPlusPlus) { 8079 // C++-specific checks. 8080 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) { 8081 CheckConstructor(Constructor); 8082 } else if (CXXDestructorDecl *Destructor = 8083 dyn_cast<CXXDestructorDecl>(NewFD)) { 8084 CXXRecordDecl *Record = Destructor->getParent(); 8085 QualType ClassType = Context.getTypeDeclType(Record); 8086 8087 // FIXME: Shouldn't we be able to perform this check even when the class 8088 // type is dependent? Both gcc and edg can handle that. 8089 if (!ClassType->isDependentType()) { 8090 DeclarationName Name 8091 = Context.DeclarationNames.getCXXDestructorName( 8092 Context.getCanonicalType(ClassType)); 8093 if (NewFD->getDeclName() != Name) { 8094 Diag(NewFD->getLocation(), diag::err_destructor_name); 8095 NewFD->setInvalidDecl(); 8096 return Redeclaration; 8097 } 8098 } 8099 } else if (CXXConversionDecl *Conversion 8100 = dyn_cast<CXXConversionDecl>(NewFD)) { 8101 ActOnConversionDeclarator(Conversion); 8102 } 8103 8104 // Find any virtual functions that this function overrides. 8105 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) { 8106 if (!Method->isFunctionTemplateSpecialization() && 8107 !Method->getDescribedFunctionTemplate() && 8108 Method->isCanonicalDecl()) { 8109 if (AddOverriddenMethods(Method->getParent(), Method)) { 8110 // If the function was marked as "static", we have a problem. 8111 if (NewFD->getStorageClass() == SC_Static) { 8112 ReportOverrides(*this, diag::err_static_overrides_virtual, Method); 8113 } 8114 } 8115 } 8116 8117 if (Method->isStatic()) 8118 checkThisInStaticMemberFunctionType(Method); 8119 } 8120 8121 // Extra checking for C++ overloaded operators (C++ [over.oper]). 8122 if (NewFD->isOverloadedOperator() && 8123 CheckOverloadedOperatorDeclaration(NewFD)) { 8124 NewFD->setInvalidDecl(); 8125 return Redeclaration; 8126 } 8127 8128 // Extra checking for C++0x literal operators (C++0x [over.literal]). 8129 if (NewFD->getLiteralIdentifier() && 8130 CheckLiteralOperatorDeclaration(NewFD)) { 8131 NewFD->setInvalidDecl(); 8132 return Redeclaration; 8133 } 8134 8135 // In C++, check default arguments now that we have merged decls. Unless 8136 // the lexical context is the class, because in this case this is done 8137 // during delayed parsing anyway. 8138 if (!CurContext->isRecord()) 8139 CheckCXXDefaultArguments(NewFD); 8140 8141 // If this function declares a builtin function, check the type of this 8142 // declaration against the expected type for the builtin. 8143 if (unsigned BuiltinID = NewFD->getBuiltinID()) { 8144 ASTContext::GetBuiltinTypeError Error; 8145 LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier()); 8146 QualType T = Context.GetBuiltinType(BuiltinID, Error); 8147 if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) { 8148 // The type of this function differs from the type of the builtin, 8149 // so forget about the builtin entirely. 8150 Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents); 8151 } 8152 } 8153 8154 // If this function is declared as being extern "C", then check to see if 8155 // the function returns a UDT (class, struct, or union type) that is not C 8156 // compatible, and if it does, warn the user. 8157 // But, issue any diagnostic on the first declaration only. 8158 if (Previous.empty() && NewFD->isExternC()) { 8159 QualType R = NewFD->getReturnType(); 8160 if (R->isIncompleteType() && !R->isVoidType()) 8161 Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete) 8162 << NewFD << R; 8163 else if (!R.isPODType(Context) && !R->isVoidType() && 8164 !R->isObjCObjectPointerType()) 8165 Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R; 8166 } 8167 } 8168 return Redeclaration; 8169 } 8170 8171 void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) { 8172 // C++11 [basic.start.main]p3: 8173 // A program that [...] declares main to be inline, static or 8174 // constexpr is ill-formed. 8175 // C11 6.7.4p4: In a hosted environment, no function specifier(s) shall 8176 // appear in a declaration of main. 8177 // static main is not an error under C99, but we should warn about it. 8178 // We accept _Noreturn main as an extension. 8179 if (FD->getStorageClass() == SC_Static) 8180 Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus 8181 ? diag::err_static_main : diag::warn_static_main) 8182 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 8183 if (FD->isInlineSpecified()) 8184 Diag(DS.getInlineSpecLoc(), diag::err_inline_main) 8185 << FixItHint::CreateRemoval(DS.getInlineSpecLoc()); 8186 if (DS.isNoreturnSpecified()) { 8187 SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc(); 8188 SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc)); 8189 Diag(NoreturnLoc, diag::ext_noreturn_main); 8190 Diag(NoreturnLoc, diag::note_main_remove_noreturn) 8191 << FixItHint::CreateRemoval(NoreturnRange); 8192 } 8193 if (FD->isConstexpr()) { 8194 Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main) 8195 << FixItHint::CreateRemoval(DS.getConstexprSpecLoc()); 8196 FD->setConstexpr(false); 8197 } 8198 8199 if (getLangOpts().OpenCL) { 8200 Diag(FD->getLocation(), diag::err_opencl_no_main) 8201 << FD->hasAttr<OpenCLKernelAttr>(); 8202 FD->setInvalidDecl(); 8203 return; 8204 } 8205 8206 QualType T = FD->getType(); 8207 assert(T->isFunctionType() && "function decl is not of function type"); 8208 const FunctionType* FT = T->castAs<FunctionType>(); 8209 8210 if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) { 8211 // In C with GNU extensions we allow main() to have non-integer return 8212 // type, but we should warn about the extension, and we disable the 8213 // implicit-return-zero rule. 8214 8215 // GCC in C mode accepts qualified 'int'. 8216 if (Context.hasSameUnqualifiedType(FT->getReturnType(), Context.IntTy)) 8217 FD->setHasImplicitReturnZero(true); 8218 else { 8219 Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint); 8220 SourceRange RTRange = FD->getReturnTypeSourceRange(); 8221 if (RTRange.isValid()) 8222 Diag(RTRange.getBegin(), diag::note_main_change_return_type) 8223 << FixItHint::CreateReplacement(RTRange, "int"); 8224 } 8225 } else { 8226 // In C and C++, main magically returns 0 if you fall off the end; 8227 // set the flag which tells us that. 8228 // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3. 8229 8230 // All the standards say that main() should return 'int'. 8231 if (Context.hasSameType(FT->getReturnType(), Context.IntTy)) 8232 FD->setHasImplicitReturnZero(true); 8233 else { 8234 // Otherwise, this is just a flat-out error. 8235 SourceRange RTRange = FD->getReturnTypeSourceRange(); 8236 Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint) 8237 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "int") 8238 : FixItHint()); 8239 FD->setInvalidDecl(true); 8240 } 8241 } 8242 8243 // Treat protoless main() as nullary. 8244 if (isa<FunctionNoProtoType>(FT)) return; 8245 8246 const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT); 8247 unsigned nparams = FTP->getNumParams(); 8248 assert(FD->getNumParams() == nparams); 8249 8250 bool HasExtraParameters = (nparams > 3); 8251 8252 // Darwin passes an undocumented fourth argument of type char**. If 8253 // other platforms start sprouting these, the logic below will start 8254 // getting shifty. 8255 if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin()) 8256 HasExtraParameters = false; 8257 8258 if (HasExtraParameters) { 8259 Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams; 8260 FD->setInvalidDecl(true); 8261 nparams = 3; 8262 } 8263 8264 // FIXME: a lot of the following diagnostics would be improved 8265 // if we had some location information about types. 8266 8267 QualType CharPP = 8268 Context.getPointerType(Context.getPointerType(Context.CharTy)); 8269 QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP }; 8270 8271 for (unsigned i = 0; i < nparams; ++i) { 8272 QualType AT = FTP->getParamType(i); 8273 8274 bool mismatch = true; 8275 8276 if (Context.hasSameUnqualifiedType(AT, Expected[i])) 8277 mismatch = false; 8278 else if (Expected[i] == CharPP) { 8279 // As an extension, the following forms are okay: 8280 // char const ** 8281 // char const * const * 8282 // char * const * 8283 8284 QualifierCollector qs; 8285 const PointerType* PT; 8286 if ((PT = qs.strip(AT)->getAs<PointerType>()) && 8287 (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) && 8288 Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0), 8289 Context.CharTy)) { 8290 qs.removeConst(); 8291 mismatch = !qs.empty(); 8292 } 8293 } 8294 8295 if (mismatch) { 8296 Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i]; 8297 // TODO: suggest replacing given type with expected type 8298 FD->setInvalidDecl(true); 8299 } 8300 } 8301 8302 if (nparams == 1 && !FD->isInvalidDecl()) { 8303 Diag(FD->getLocation(), diag::warn_main_one_arg); 8304 } 8305 8306 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 8307 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD; 8308 FD->setInvalidDecl(); 8309 } 8310 } 8311 8312 void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) { 8313 QualType T = FD->getType(); 8314 assert(T->isFunctionType() && "function decl is not of function type"); 8315 const FunctionType *FT = T->castAs<FunctionType>(); 8316 8317 // Set an implicit return of 'zero' if the function can return some integral, 8318 // enumeration, pointer or nullptr type. 8319 if (FT->getReturnType()->isIntegralOrEnumerationType() || 8320 FT->getReturnType()->isAnyPointerType() || 8321 FT->getReturnType()->isNullPtrType()) 8322 // DllMain is exempt because a return value of zero means it failed. 8323 if (FD->getName() != "DllMain") 8324 FD->setHasImplicitReturnZero(true); 8325 8326 if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) { 8327 Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD; 8328 FD->setInvalidDecl(); 8329 } 8330 } 8331 8332 bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) { 8333 // FIXME: Need strict checking. In C89, we need to check for 8334 // any assignment, increment, decrement, function-calls, or 8335 // commas outside of a sizeof. In C99, it's the same list, 8336 // except that the aforementioned are allowed in unevaluated 8337 // expressions. Everything else falls under the 8338 // "may accept other forms of constant expressions" exception. 8339 // (We never end up here for C++, so the constant expression 8340 // rules there don't matter.) 8341 const Expr *Culprit; 8342 if (Init->isConstantInitializer(Context, false, &Culprit)) 8343 return false; 8344 Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant) 8345 << Culprit->getSourceRange(); 8346 return true; 8347 } 8348 8349 namespace { 8350 // Visits an initialization expression to see if OrigDecl is evaluated in 8351 // its own initialization and throws a warning if it does. 8352 class SelfReferenceChecker 8353 : public EvaluatedExprVisitor<SelfReferenceChecker> { 8354 Sema &S; 8355 Decl *OrigDecl; 8356 bool isRecordType; 8357 bool isPODType; 8358 bool isReferenceType; 8359 8360 bool isInitList; 8361 llvm::SmallVector<unsigned, 4> InitFieldIndex; 8362 public: 8363 typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited; 8364 8365 SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context), 8366 S(S), OrigDecl(OrigDecl) { 8367 isPODType = false; 8368 isRecordType = false; 8369 isReferenceType = false; 8370 isInitList = false; 8371 if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) { 8372 isPODType = VD->getType().isPODType(S.Context); 8373 isRecordType = VD->getType()->isRecordType(); 8374 isReferenceType = VD->getType()->isReferenceType(); 8375 } 8376 } 8377 8378 // For most expressions, just call the visitor. For initializer lists, 8379 // track the index of the field being initialized since fields are 8380 // initialized in order allowing use of previously initialized fields. 8381 void CheckExpr(Expr *E) { 8382 InitListExpr *InitList = dyn_cast<InitListExpr>(E); 8383 if (!InitList) { 8384 Visit(E); 8385 return; 8386 } 8387 8388 // Track and increment the index here. 8389 isInitList = true; 8390 InitFieldIndex.push_back(0); 8391 for (auto Child : InitList->children()) { 8392 CheckExpr(cast<Expr>(Child)); 8393 ++InitFieldIndex.back(); 8394 } 8395 InitFieldIndex.pop_back(); 8396 } 8397 8398 // Returns true if MemberExpr is checked and no futher checking is needed. 8399 // Returns false if additional checking is required. 8400 bool CheckInitListMemberExpr(MemberExpr *E, bool CheckReference) { 8401 llvm::SmallVector<FieldDecl*, 4> Fields; 8402 Expr *Base = E; 8403 bool ReferenceField = false; 8404 8405 // Get the field memebers used. 8406 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 8407 FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()); 8408 if (!FD) 8409 return false; 8410 Fields.push_back(FD); 8411 if (FD->getType()->isReferenceType()) 8412 ReferenceField = true; 8413 Base = ME->getBase()->IgnoreParenImpCasts(); 8414 } 8415 8416 // Keep checking only if the base Decl is the same. 8417 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base); 8418 if (!DRE || DRE->getDecl() != OrigDecl) 8419 return false; 8420 8421 // A reference field can be bound to an unininitialized field. 8422 if (CheckReference && !ReferenceField) 8423 return true; 8424 8425 // Convert FieldDecls to their index number. 8426 llvm::SmallVector<unsigned, 4> UsedFieldIndex; 8427 for (auto I = Fields.rbegin(), E = Fields.rend(); I != E; ++I) { 8428 UsedFieldIndex.push_back((*I)->getFieldIndex()); 8429 } 8430 8431 // See if a warning is needed by checking the first difference in index 8432 // numbers. If field being used has index less than the field being 8433 // initialized, then the use is safe. 8434 for (auto UsedIter = UsedFieldIndex.begin(), 8435 UsedEnd = UsedFieldIndex.end(), 8436 OrigIter = InitFieldIndex.begin(), 8437 OrigEnd = InitFieldIndex.end(); 8438 UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) { 8439 if (*UsedIter < *OrigIter) 8440 return true; 8441 if (*UsedIter > *OrigIter) 8442 break; 8443 } 8444 8445 // TODO: Add a different warning which will print the field names. 8446 HandleDeclRefExpr(DRE); 8447 return true; 8448 } 8449 8450 // For most expressions, the cast is directly above the DeclRefExpr. 8451 // For conditional operators, the cast can be outside the conditional 8452 // operator if both expressions are DeclRefExpr's. 8453 void HandleValue(Expr *E) { 8454 E = E->IgnoreParens(); 8455 if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) { 8456 HandleDeclRefExpr(DRE); 8457 return; 8458 } 8459 8460 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 8461 Visit(CO->getCond()); 8462 HandleValue(CO->getTrueExpr()); 8463 HandleValue(CO->getFalseExpr()); 8464 return; 8465 } 8466 8467 if (BinaryConditionalOperator *BCO = 8468 dyn_cast<BinaryConditionalOperator>(E)) { 8469 Visit(BCO->getCond()); 8470 HandleValue(BCO->getFalseExpr()); 8471 return; 8472 } 8473 8474 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) { 8475 HandleValue(OVE->getSourceExpr()); 8476 return; 8477 } 8478 8479 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 8480 if (BO->getOpcode() == BO_Comma) { 8481 Visit(BO->getLHS()); 8482 HandleValue(BO->getRHS()); 8483 return; 8484 } 8485 } 8486 8487 if (isa<MemberExpr>(E)) { 8488 if (isInitList) { 8489 if (CheckInitListMemberExpr(cast<MemberExpr>(E), 8490 false /*CheckReference*/)) 8491 return; 8492 } 8493 8494 Expr *Base = E->IgnoreParenImpCasts(); 8495 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 8496 // Check for static member variables and don't warn on them. 8497 if (!isa<FieldDecl>(ME->getMemberDecl())) 8498 return; 8499 Base = ME->getBase()->IgnoreParenImpCasts(); 8500 } 8501 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) 8502 HandleDeclRefExpr(DRE); 8503 return; 8504 } 8505 8506 Visit(E); 8507 } 8508 8509 // Reference types not handled in HandleValue are handled here since all 8510 // uses of references are bad, not just r-value uses. 8511 void VisitDeclRefExpr(DeclRefExpr *E) { 8512 if (isReferenceType) 8513 HandleDeclRefExpr(E); 8514 } 8515 8516 void VisitImplicitCastExpr(ImplicitCastExpr *E) { 8517 if (E->getCastKind() == CK_LValueToRValue) { 8518 HandleValue(E->getSubExpr()); 8519 return; 8520 } 8521 8522 Inherited::VisitImplicitCastExpr(E); 8523 } 8524 8525 void VisitMemberExpr(MemberExpr *E) { 8526 if (isInitList) { 8527 if (CheckInitListMemberExpr(E, true /*CheckReference*/)) 8528 return; 8529 } 8530 8531 // Don't warn on arrays since they can be treated as pointers. 8532 if (E->getType()->canDecayToPointerType()) return; 8533 8534 // Warn when a non-static method call is followed by non-static member 8535 // field accesses, which is followed by a DeclRefExpr. 8536 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl()); 8537 bool Warn = (MD && !MD->isStatic()); 8538 Expr *Base = E->getBase()->IgnoreParenImpCasts(); 8539 while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) { 8540 if (!isa<FieldDecl>(ME->getMemberDecl())) 8541 Warn = false; 8542 Base = ME->getBase()->IgnoreParenImpCasts(); 8543 } 8544 8545 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) { 8546 if (Warn) 8547 HandleDeclRefExpr(DRE); 8548 return; 8549 } 8550 8551 // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr. 8552 // Visit that expression. 8553 Visit(Base); 8554 } 8555 8556 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { 8557 Expr *Callee = E->getCallee(); 8558 8559 if (isa<UnresolvedLookupExpr>(Callee)) 8560 return Inherited::VisitCXXOperatorCallExpr(E); 8561 8562 Visit(Callee); 8563 for (auto Arg: E->arguments()) 8564 HandleValue(Arg->IgnoreParenImpCasts()); 8565 } 8566 8567 void VisitUnaryOperator(UnaryOperator *E) { 8568 // For POD record types, addresses of its own members are well-defined. 8569 if (E->getOpcode() == UO_AddrOf && isRecordType && 8570 isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) { 8571 if (!isPODType) 8572 HandleValue(E->getSubExpr()); 8573 return; 8574 } 8575 8576 if (E->isIncrementDecrementOp()) { 8577 HandleValue(E->getSubExpr()); 8578 return; 8579 } 8580 8581 Inherited::VisitUnaryOperator(E); 8582 } 8583 8584 void VisitObjCMessageExpr(ObjCMessageExpr *E) { return; } 8585 8586 void VisitCXXConstructExpr(CXXConstructExpr *E) { 8587 if (E->getConstructor()->isCopyConstructor()) { 8588 Expr *ArgExpr = E->getArg(0); 8589 if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr)) 8590 if (ILE->getNumInits() == 1) 8591 ArgExpr = ILE->getInit(0); 8592 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr)) 8593 if (ICE->getCastKind() == CK_NoOp) 8594 ArgExpr = ICE->getSubExpr(); 8595 HandleValue(ArgExpr); 8596 return; 8597 } 8598 Inherited::VisitCXXConstructExpr(E); 8599 } 8600 8601 void VisitCallExpr(CallExpr *E) { 8602 // Treat std::move as a use. 8603 if (E->getNumArgs() == 1) { 8604 if (FunctionDecl *FD = E->getDirectCallee()) { 8605 if (FD->isInStdNamespace() && FD->getIdentifier() && 8606 FD->getIdentifier()->isStr("move")) { 8607 HandleValue(E->getArg(0)); 8608 return; 8609 } 8610 } 8611 } 8612 8613 Inherited::VisitCallExpr(E); 8614 } 8615 8616 void VisitBinaryOperator(BinaryOperator *E) { 8617 if (E->isCompoundAssignmentOp()) { 8618 HandleValue(E->getLHS()); 8619 Visit(E->getRHS()); 8620 return; 8621 } 8622 8623 Inherited::VisitBinaryOperator(E); 8624 } 8625 8626 // A custom visitor for BinaryConditionalOperator is needed because the 8627 // regular visitor would check the condition and true expression separately 8628 // but both point to the same place giving duplicate diagnostics. 8629 void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) { 8630 Visit(E->getCond()); 8631 Visit(E->getFalseExpr()); 8632 } 8633 8634 void HandleDeclRefExpr(DeclRefExpr *DRE) { 8635 Decl* ReferenceDecl = DRE->getDecl(); 8636 if (OrigDecl != ReferenceDecl) return; 8637 unsigned diag; 8638 if (isReferenceType) { 8639 diag = diag::warn_uninit_self_reference_in_reference_init; 8640 } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) { 8641 diag = diag::warn_static_self_reference_in_init; 8642 } else if (isa<TranslationUnitDecl>(OrigDecl->getDeclContext()) || 8643 isa<NamespaceDecl>(OrigDecl->getDeclContext()) || 8644 DRE->getDecl()->getType()->isRecordType()) { 8645 diag = diag::warn_uninit_self_reference_in_init; 8646 } else { 8647 // Local variables will be handled by the CFG analysis. 8648 return; 8649 } 8650 8651 S.DiagRuntimeBehavior(DRE->getLocStart(), DRE, 8652 S.PDiag(diag) 8653 << DRE->getNameInfo().getName() 8654 << OrigDecl->getLocation() 8655 << DRE->getSourceRange()); 8656 } 8657 }; 8658 8659 /// CheckSelfReference - Warns if OrigDecl is used in expression E. 8660 static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E, 8661 bool DirectInit) { 8662 // Parameters arguments are occassionially constructed with itself, 8663 // for instance, in recursive functions. Skip them. 8664 if (isa<ParmVarDecl>(OrigDecl)) 8665 return; 8666 8667 E = E->IgnoreParens(); 8668 8669 // Skip checking T a = a where T is not a record or reference type. 8670 // Doing so is a way to silence uninitialized warnings. 8671 if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType()) 8672 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 8673 if (ICE->getCastKind() == CK_LValueToRValue) 8674 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) 8675 if (DRE->getDecl() == OrigDecl) 8676 return; 8677 8678 SelfReferenceChecker(S, OrigDecl).CheckExpr(E); 8679 } 8680 } 8681 8682 /// AddInitializerToDecl - Adds the initializer Init to the 8683 /// declaration dcl. If DirectInit is true, this is C++ direct 8684 /// initialization rather than copy initialization. 8685 void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, 8686 bool DirectInit, bool TypeMayContainAuto) { 8687 // If there is no declaration, there was an error parsing it. Just ignore 8688 // the initializer. 8689 if (!RealDecl || RealDecl->isInvalidDecl()) { 8690 CorrectDelayedTyposInExpr(Init); 8691 return; 8692 } 8693 8694 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) { 8695 // With declarators parsed the way they are, the parser cannot 8696 // distinguish between a normal initializer and a pure-specifier. 8697 // Thus this grotesque test. 8698 IntegerLiteral *IL; 8699 if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 && 8700 Context.getCanonicalType(IL->getType()) == Context.IntTy) 8701 CheckPureMethod(Method, Init->getSourceRange()); 8702 else { 8703 Diag(Method->getLocation(), diag::err_member_function_initialization) 8704 << Method->getDeclName() << Init->getSourceRange(); 8705 Method->setInvalidDecl(); 8706 } 8707 return; 8708 } 8709 8710 VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl); 8711 if (!VDecl) { 8712 assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here"); 8713 Diag(RealDecl->getLocation(), diag::err_illegal_initializer); 8714 RealDecl->setInvalidDecl(); 8715 return; 8716 } 8717 ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init); 8718 8719 // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for. 8720 if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) { 8721 // Attempt typo correction early so that the type of the init expression can 8722 // be deduced based on the chosen correction:if the original init contains a 8723 // TypoExpr. 8724 ExprResult Res = CorrectDelayedTyposInExpr(Init); 8725 if (!Res.isUsable()) { 8726 RealDecl->setInvalidDecl(); 8727 return; 8728 } 8729 if (Res.get() != Init) { 8730 Init = Res.get(); 8731 if (CXXDirectInit) 8732 CXXDirectInit = dyn_cast<ParenListExpr>(Init); 8733 } 8734 8735 Expr *DeduceInit = Init; 8736 // Initializer could be a C++ direct-initializer. Deduction only works if it 8737 // contains exactly one expression. 8738 if (CXXDirectInit) { 8739 if (CXXDirectInit->getNumExprs() == 0) { 8740 // It isn't possible to write this directly, but it is possible to 8741 // end up in this situation with "auto x(some_pack...);" 8742 Diag(CXXDirectInit->getLocStart(), 8743 VDecl->isInitCapture() ? diag::err_init_capture_no_expression 8744 : diag::err_auto_var_init_no_expression) 8745 << VDecl->getDeclName() << VDecl->getType() 8746 << VDecl->getSourceRange(); 8747 RealDecl->setInvalidDecl(); 8748 return; 8749 } else if (CXXDirectInit->getNumExprs() > 1) { 8750 Diag(CXXDirectInit->getExpr(1)->getLocStart(), 8751 VDecl->isInitCapture() 8752 ? diag::err_init_capture_multiple_expressions 8753 : diag::err_auto_var_init_multiple_expressions) 8754 << VDecl->getDeclName() << VDecl->getType() 8755 << VDecl->getSourceRange(); 8756 RealDecl->setInvalidDecl(); 8757 return; 8758 } else { 8759 DeduceInit = CXXDirectInit->getExpr(0); 8760 if (isa<InitListExpr>(DeduceInit)) 8761 Diag(CXXDirectInit->getLocStart(), 8762 diag::err_auto_var_init_paren_braces) 8763 << VDecl->getDeclName() << VDecl->getType() 8764 << VDecl->getSourceRange(); 8765 } 8766 } 8767 8768 // Expressions default to 'id' when we're in a debugger. 8769 bool DefaultedToAuto = false; 8770 if (getLangOpts().DebuggerCastResultToId && 8771 Init->getType() == Context.UnknownAnyTy) { 8772 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 8773 if (Result.isInvalid()) { 8774 VDecl->setInvalidDecl(); 8775 return; 8776 } 8777 Init = Result.get(); 8778 DefaultedToAuto = true; 8779 } 8780 8781 QualType DeducedType; 8782 if (DeduceAutoType(VDecl->getTypeSourceInfo(), DeduceInit, DeducedType) == 8783 DAR_Failed) 8784 DiagnoseAutoDeductionFailure(VDecl, DeduceInit); 8785 if (DeducedType.isNull()) { 8786 RealDecl->setInvalidDecl(); 8787 return; 8788 } 8789 VDecl->setType(DeducedType); 8790 assert(VDecl->isLinkageValid()); 8791 8792 // In ARC, infer lifetime. 8793 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl)) 8794 VDecl->setInvalidDecl(); 8795 8796 // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using 8797 // 'id' instead of a specific object type prevents most of our usual checks. 8798 // We only want to warn outside of template instantiations, though: 8799 // inside a template, the 'id' could have come from a parameter. 8800 if (ActiveTemplateInstantiations.empty() && !DefaultedToAuto && 8801 DeducedType->isObjCIdType()) { 8802 SourceLocation Loc = 8803 VDecl->getTypeSourceInfo()->getTypeLoc().getBeginLoc(); 8804 Diag(Loc, diag::warn_auto_var_is_id) 8805 << VDecl->getDeclName() << DeduceInit->getSourceRange(); 8806 } 8807 8808 // If this is a redeclaration, check that the type we just deduced matches 8809 // the previously declared type. 8810 if (VarDecl *Old = VDecl->getPreviousDecl()) { 8811 // We never need to merge the type, because we cannot form an incomplete 8812 // array of auto, nor deduce such a type. 8813 MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/false); 8814 } 8815 8816 // Check the deduced type is valid for a variable declaration. 8817 CheckVariableDeclarationType(VDecl); 8818 if (VDecl->isInvalidDecl()) 8819 return; 8820 8821 // If all looks well, warn if this is a case that will change meaning when 8822 // we implement N3922. 8823 if (DirectInit && !CXXDirectInit && isa<InitListExpr>(Init)) { 8824 Diag(Init->getLocStart(), 8825 diag::warn_auto_var_direct_list_init) 8826 << FixItHint::CreateInsertion(Init->getLocStart(), "="); 8827 } 8828 } 8829 8830 // dllimport cannot be used on variable definitions. 8831 if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) { 8832 Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition); 8833 VDecl->setInvalidDecl(); 8834 return; 8835 } 8836 8837 if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) { 8838 // C99 6.7.8p5. C++ has no such restriction, but that is a defect. 8839 Diag(VDecl->getLocation(), diag::err_block_extern_cant_init); 8840 VDecl->setInvalidDecl(); 8841 return; 8842 } 8843 8844 if (!VDecl->getType()->isDependentType()) { 8845 // A definition must end up with a complete type, which means it must be 8846 // complete with the restriction that an array type might be completed by 8847 // the initializer; note that later code assumes this restriction. 8848 QualType BaseDeclType = VDecl->getType(); 8849 if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType)) 8850 BaseDeclType = Array->getElementType(); 8851 if (RequireCompleteType(VDecl->getLocation(), BaseDeclType, 8852 diag::err_typecheck_decl_incomplete_type)) { 8853 RealDecl->setInvalidDecl(); 8854 return; 8855 } 8856 8857 // The variable can not have an abstract class type. 8858 if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(), 8859 diag::err_abstract_type_in_decl, 8860 AbstractVariableType)) 8861 VDecl->setInvalidDecl(); 8862 } 8863 8864 const VarDecl *Def; 8865 if ((Def = VDecl->getDefinition()) && Def != VDecl) { 8866 Diag(VDecl->getLocation(), diag::err_redefinition) 8867 << VDecl->getDeclName(); 8868 Diag(Def->getLocation(), diag::note_previous_definition); 8869 VDecl->setInvalidDecl(); 8870 return; 8871 } 8872 8873 const VarDecl *PrevInit = nullptr; 8874 if (getLangOpts().CPlusPlus) { 8875 // C++ [class.static.data]p4 8876 // If a static data member is of const integral or const 8877 // enumeration type, its declaration in the class definition can 8878 // specify a constant-initializer which shall be an integral 8879 // constant expression (5.19). In that case, the member can appear 8880 // in integral constant expressions. The member shall still be 8881 // defined in a namespace scope if it is used in the program and the 8882 // namespace scope definition shall not contain an initializer. 8883 // 8884 // We already performed a redefinition check above, but for static 8885 // data members we also need to check whether there was an in-class 8886 // declaration with an initializer. 8887 if (VDecl->isStaticDataMember() && VDecl->getAnyInitializer(PrevInit)) { 8888 Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization) 8889 << VDecl->getDeclName(); 8890 Diag(PrevInit->getInit()->getExprLoc(), diag::note_previous_initializer) << 0; 8891 return; 8892 } 8893 8894 if (VDecl->hasLocalStorage()) 8895 getCurFunction()->setHasBranchProtectedScope(); 8896 8897 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) { 8898 VDecl->setInvalidDecl(); 8899 return; 8900 } 8901 } 8902 8903 // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside 8904 // a kernel function cannot be initialized." 8905 if (VDecl->getStorageClass() == SC_OpenCLWorkGroupLocal) { 8906 Diag(VDecl->getLocation(), diag::err_local_cant_init); 8907 VDecl->setInvalidDecl(); 8908 return; 8909 } 8910 8911 // Get the decls type and save a reference for later, since 8912 // CheckInitializerTypes may change it. 8913 QualType DclT = VDecl->getType(), SavT = DclT; 8914 8915 // Expressions default to 'id' when we're in a debugger 8916 // and we are assigning it to a variable of Objective-C pointer type. 8917 if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() && 8918 Init->getType() == Context.UnknownAnyTy) { 8919 ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType()); 8920 if (Result.isInvalid()) { 8921 VDecl->setInvalidDecl(); 8922 return; 8923 } 8924 Init = Result.get(); 8925 } 8926 8927 // Perform the initialization. 8928 if (!VDecl->isInvalidDecl()) { 8929 InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl); 8930 InitializationKind Kind 8931 = DirectInit ? 8932 CXXDirectInit ? InitializationKind::CreateDirect(VDecl->getLocation(), 8933 Init->getLocStart(), 8934 Init->getLocEnd()) 8935 : InitializationKind::CreateDirectList( 8936 VDecl->getLocation()) 8937 : InitializationKind::CreateCopy(VDecl->getLocation(), 8938 Init->getLocStart()); 8939 8940 MultiExprArg Args = Init; 8941 if (CXXDirectInit) 8942 Args = MultiExprArg(CXXDirectInit->getExprs(), 8943 CXXDirectInit->getNumExprs()); 8944 8945 // Try to correct any TypoExprs in the initialization arguments. 8946 for (size_t Idx = 0; Idx < Args.size(); ++Idx) { 8947 ExprResult Res = 8948 CorrectDelayedTyposInExpr(Args[Idx], [this, Entity, Kind](Expr *E) { 8949 InitializationSequence Init(*this, Entity, Kind, MultiExprArg(E)); 8950 return Init.Failed() ? ExprError() : E; 8951 }); 8952 if (Res.isInvalid()) { 8953 VDecl->setInvalidDecl(); 8954 } else if (Res.get() != Args[Idx]) { 8955 Args[Idx] = Res.get(); 8956 } 8957 } 8958 if (VDecl->isInvalidDecl()) 8959 return; 8960 8961 InitializationSequence InitSeq(*this, Entity, Kind, Args); 8962 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT); 8963 if (Result.isInvalid()) { 8964 VDecl->setInvalidDecl(); 8965 return; 8966 } 8967 8968 Init = Result.getAs<Expr>(); 8969 } 8970 8971 // Check for self-references within variable initializers. 8972 // Variables declared within a function/method body (except for references) 8973 // are handled by a dataflow analysis. 8974 if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() || 8975 VDecl->getType()->isReferenceType()) { 8976 CheckSelfReference(*this, RealDecl, Init, DirectInit); 8977 } 8978 8979 // If the type changed, it means we had an incomplete type that was 8980 // completed by the initializer. For example: 8981 // int ary[] = { 1, 3, 5 }; 8982 // "ary" transitions from an IncompleteArrayType to a ConstantArrayType. 8983 if (!VDecl->isInvalidDecl() && (DclT != SavT)) 8984 VDecl->setType(DclT); 8985 8986 if (!VDecl->isInvalidDecl()) { 8987 checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init); 8988 8989 if (VDecl->hasAttr<BlocksAttr>()) 8990 checkRetainCycles(VDecl, Init); 8991 8992 // It is safe to assign a weak reference into a strong variable. 8993 // Although this code can still have problems: 8994 // id x = self.weakProp; 8995 // id y = self.weakProp; 8996 // we do not warn to warn spuriously when 'x' and 'y' are on separate 8997 // paths through the function. This should be revisited if 8998 // -Wrepeated-use-of-weak is made flow-sensitive. 8999 if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong && 9000 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, 9001 Init->getLocStart())) 9002 getCurFunction()->markSafeWeakUse(Init); 9003 } 9004 9005 // The initialization is usually a full-expression. 9006 // 9007 // FIXME: If this is a braced initialization of an aggregate, it is not 9008 // an expression, and each individual field initializer is a separate 9009 // full-expression. For instance, in: 9010 // 9011 // struct Temp { ~Temp(); }; 9012 // struct S { S(Temp); }; 9013 // struct T { S a, b; } t = { Temp(), Temp() } 9014 // 9015 // we should destroy the first Temp before constructing the second. 9016 ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(), 9017 false, 9018 VDecl->isConstexpr()); 9019 if (Result.isInvalid()) { 9020 VDecl->setInvalidDecl(); 9021 return; 9022 } 9023 Init = Result.get(); 9024 9025 // Attach the initializer to the decl. 9026 VDecl->setInit(Init); 9027 9028 if (VDecl->isLocalVarDecl()) { 9029 // C99 6.7.8p4: All the expressions in an initializer for an object that has 9030 // static storage duration shall be constant expressions or string literals. 9031 // C++ does not have this restriction. 9032 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) { 9033 const Expr *Culprit; 9034 if (VDecl->getStorageClass() == SC_Static) 9035 CheckForConstantInitializer(Init, DclT); 9036 // C89 is stricter than C99 for non-static aggregate types. 9037 // C89 6.5.7p3: All the expressions [...] in an initializer list 9038 // for an object that has aggregate or union type shall be 9039 // constant expressions. 9040 else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() && 9041 isa<InitListExpr>(Init) && 9042 !Init->isConstantInitializer(Context, false, &Culprit)) 9043 Diag(Culprit->getExprLoc(), 9044 diag::ext_aggregate_init_not_constant) 9045 << Culprit->getSourceRange(); 9046 } 9047 } else if (VDecl->isStaticDataMember() && 9048 VDecl->getLexicalDeclContext()->isRecord()) { 9049 // This is an in-class initialization for a static data member, e.g., 9050 // 9051 // struct S { 9052 // static const int value = 17; 9053 // }; 9054 9055 // C++ [class.mem]p4: 9056 // A member-declarator can contain a constant-initializer only 9057 // if it declares a static member (9.4) of const integral or 9058 // const enumeration type, see 9.4.2. 9059 // 9060 // C++11 [class.static.data]p3: 9061 // If a non-volatile const static data member is of integral or 9062 // enumeration type, its declaration in the class definition can 9063 // specify a brace-or-equal-initializer in which every initalizer-clause 9064 // that is an assignment-expression is a constant expression. A static 9065 // data member of literal type can be declared in the class definition 9066 // with the constexpr specifier; if so, its declaration shall specify a 9067 // brace-or-equal-initializer in which every initializer-clause that is 9068 // an assignment-expression is a constant expression. 9069 9070 // Do nothing on dependent types. 9071 if (DclT->isDependentType()) { 9072 9073 // Allow any 'static constexpr' members, whether or not they are of literal 9074 // type. We separately check that every constexpr variable is of literal 9075 // type. 9076 } else if (VDecl->isConstexpr()) { 9077 9078 // Require constness. 9079 } else if (!DclT.isConstQualified()) { 9080 Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const) 9081 << Init->getSourceRange(); 9082 VDecl->setInvalidDecl(); 9083 9084 // We allow integer constant expressions in all cases. 9085 } else if (DclT->isIntegralOrEnumerationType()) { 9086 // Check whether the expression is a constant expression. 9087 SourceLocation Loc; 9088 if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified()) 9089 // In C++11, a non-constexpr const static data member with an 9090 // in-class initializer cannot be volatile. 9091 Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile); 9092 else if (Init->isValueDependent()) 9093 ; // Nothing to check. 9094 else if (Init->isIntegerConstantExpr(Context, &Loc)) 9095 ; // Ok, it's an ICE! 9096 else if (Init->isEvaluatable(Context)) { 9097 // If we can constant fold the initializer through heroics, accept it, 9098 // but report this as a use of an extension for -pedantic. 9099 Diag(Loc, diag::ext_in_class_initializer_non_constant) 9100 << Init->getSourceRange(); 9101 } else { 9102 // Otherwise, this is some crazy unknown case. Report the issue at the 9103 // location provided by the isIntegerConstantExpr failed check. 9104 Diag(Loc, diag::err_in_class_initializer_non_constant) 9105 << Init->getSourceRange(); 9106 VDecl->setInvalidDecl(); 9107 } 9108 9109 // We allow foldable floating-point constants as an extension. 9110 } else if (DclT->isFloatingType()) { // also permits complex, which is ok 9111 // In C++98, this is a GNU extension. In C++11, it is not, but we support 9112 // it anyway and provide a fixit to add the 'constexpr'. 9113 if (getLangOpts().CPlusPlus11) { 9114 Diag(VDecl->getLocation(), 9115 diag::ext_in_class_initializer_float_type_cxx11) 9116 << DclT << Init->getSourceRange(); 9117 Diag(VDecl->getLocStart(), 9118 diag::note_in_class_initializer_float_type_cxx11) 9119 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr "); 9120 } else { 9121 Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type) 9122 << DclT << Init->getSourceRange(); 9123 9124 if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) { 9125 Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant) 9126 << Init->getSourceRange(); 9127 VDecl->setInvalidDecl(); 9128 } 9129 } 9130 9131 // Suggest adding 'constexpr' in C++11 for literal types. 9132 } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) { 9133 Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type) 9134 << DclT << Init->getSourceRange() 9135 << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr "); 9136 VDecl->setConstexpr(true); 9137 9138 } else { 9139 Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type) 9140 << DclT << Init->getSourceRange(); 9141 VDecl->setInvalidDecl(); 9142 } 9143 } else if (VDecl->isFileVarDecl()) { 9144 if (VDecl->getStorageClass() == SC_Extern && 9145 (!getLangOpts().CPlusPlus || 9146 !(Context.getBaseElementType(VDecl->getType()).isConstQualified() || 9147 VDecl->isExternC())) && 9148 !isTemplateInstantiation(VDecl->getTemplateSpecializationKind())) 9149 Diag(VDecl->getLocation(), diag::warn_extern_init); 9150 9151 // C99 6.7.8p4. All file scoped initializers need to be constant. 9152 if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) 9153 CheckForConstantInitializer(Init, DclT); 9154 } 9155 9156 // We will represent direct-initialization similarly to copy-initialization: 9157 // int x(1); -as-> int x = 1; 9158 // ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c); 9159 // 9160 // Clients that want to distinguish between the two forms, can check for 9161 // direct initializer using VarDecl::getInitStyle(). 9162 // A major benefit is that clients that don't particularly care about which 9163 // exactly form was it (like the CodeGen) can handle both cases without 9164 // special case code. 9165 9166 // C++ 8.5p11: 9167 // The form of initialization (using parentheses or '=') is generally 9168 // insignificant, but does matter when the entity being initialized has a 9169 // class type. 9170 if (CXXDirectInit) { 9171 assert(DirectInit && "Call-style initializer must be direct init."); 9172 VDecl->setInitStyle(VarDecl::CallInit); 9173 } else if (DirectInit) { 9174 // This must be list-initialization. No other way is direct-initialization. 9175 VDecl->setInitStyle(VarDecl::ListInit); 9176 } 9177 9178 CheckCompleteVariableDeclaration(VDecl); 9179 } 9180 9181 /// ActOnInitializerError - Given that there was an error parsing an 9182 /// initializer for the given declaration, try to return to some form 9183 /// of sanity. 9184 void Sema::ActOnInitializerError(Decl *D) { 9185 // Our main concern here is re-establishing invariants like "a 9186 // variable's type is either dependent or complete". 9187 if (!D || D->isInvalidDecl()) return; 9188 9189 VarDecl *VD = dyn_cast<VarDecl>(D); 9190 if (!VD) return; 9191 9192 // Auto types are meaningless if we can't make sense of the initializer. 9193 if (ParsingInitForAutoVars.count(D)) { 9194 D->setInvalidDecl(); 9195 return; 9196 } 9197 9198 QualType Ty = VD->getType(); 9199 if (Ty->isDependentType()) return; 9200 9201 // Require a complete type. 9202 if (RequireCompleteType(VD->getLocation(), 9203 Context.getBaseElementType(Ty), 9204 diag::err_typecheck_decl_incomplete_type)) { 9205 VD->setInvalidDecl(); 9206 return; 9207 } 9208 9209 // Require a non-abstract type. 9210 if (RequireNonAbstractType(VD->getLocation(), Ty, 9211 diag::err_abstract_type_in_decl, 9212 AbstractVariableType)) { 9213 VD->setInvalidDecl(); 9214 return; 9215 } 9216 9217 // Don't bother complaining about constructors or destructors, 9218 // though. 9219 } 9220 9221 void Sema::ActOnUninitializedDecl(Decl *RealDecl, 9222 bool TypeMayContainAuto) { 9223 // If there is no declaration, there was an error parsing it. Just ignore it. 9224 if (!RealDecl) 9225 return; 9226 9227 if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) { 9228 QualType Type = Var->getType(); 9229 9230 // C++11 [dcl.spec.auto]p3 9231 if (TypeMayContainAuto && Type->getContainedAutoType()) { 9232 Diag(Var->getLocation(), diag::err_auto_var_requires_init) 9233 << Var->getDeclName() << Type; 9234 Var->setInvalidDecl(); 9235 return; 9236 } 9237 9238 // C++11 [class.static.data]p3: A static data member can be declared with 9239 // the constexpr specifier; if so, its declaration shall specify 9240 // a brace-or-equal-initializer. 9241 // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to 9242 // the definition of a variable [...] or the declaration of a static data 9243 // member. 9244 if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) { 9245 if (Var->isStaticDataMember()) 9246 Diag(Var->getLocation(), 9247 diag::err_constexpr_static_mem_var_requires_init) 9248 << Var->getDeclName(); 9249 else 9250 Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl); 9251 Var->setInvalidDecl(); 9252 return; 9253 } 9254 9255 // OpenCL v1.1 s6.5.3: variables declared in the constant address space must 9256 // be initialized. 9257 if (!Var->isInvalidDecl() && 9258 Var->getType().getAddressSpace() == LangAS::opencl_constant && 9259 Var->getStorageClass() != SC_Extern && !Var->getInit()) { 9260 Diag(Var->getLocation(), diag::err_opencl_constant_no_init); 9261 Var->setInvalidDecl(); 9262 return; 9263 } 9264 9265 switch (Var->isThisDeclarationADefinition()) { 9266 case VarDecl::Definition: 9267 if (!Var->isStaticDataMember() || !Var->getAnyInitializer()) 9268 break; 9269 9270 // We have an out-of-line definition of a static data member 9271 // that has an in-class initializer, so we type-check this like 9272 // a declaration. 9273 // 9274 // Fall through 9275 9276 case VarDecl::DeclarationOnly: 9277 // It's only a declaration. 9278 9279 // Block scope. C99 6.7p7: If an identifier for an object is 9280 // declared with no linkage (C99 6.2.2p6), the type for the 9281 // object shall be complete. 9282 if (!Type->isDependentType() && Var->isLocalVarDecl() && 9283 !Var->hasLinkage() && !Var->isInvalidDecl() && 9284 RequireCompleteType(Var->getLocation(), Type, 9285 diag::err_typecheck_decl_incomplete_type)) 9286 Var->setInvalidDecl(); 9287 9288 // Make sure that the type is not abstract. 9289 if (!Type->isDependentType() && !Var->isInvalidDecl() && 9290 RequireNonAbstractType(Var->getLocation(), Type, 9291 diag::err_abstract_type_in_decl, 9292 AbstractVariableType)) 9293 Var->setInvalidDecl(); 9294 if (!Type->isDependentType() && !Var->isInvalidDecl() && 9295 Var->getStorageClass() == SC_PrivateExtern) { 9296 Diag(Var->getLocation(), diag::warn_private_extern); 9297 Diag(Var->getLocation(), diag::note_private_extern); 9298 } 9299 9300 return; 9301 9302 case VarDecl::TentativeDefinition: 9303 // File scope. C99 6.9.2p2: A declaration of an identifier for an 9304 // object that has file scope without an initializer, and without a 9305 // storage-class specifier or with the storage-class specifier "static", 9306 // constitutes a tentative definition. Note: A tentative definition with 9307 // external linkage is valid (C99 6.2.2p5). 9308 if (!Var->isInvalidDecl()) { 9309 if (const IncompleteArrayType *ArrayT 9310 = Context.getAsIncompleteArrayType(Type)) { 9311 if (RequireCompleteType(Var->getLocation(), 9312 ArrayT->getElementType(), 9313 diag::err_illegal_decl_array_incomplete_type)) 9314 Var->setInvalidDecl(); 9315 } else if (Var->getStorageClass() == SC_Static) { 9316 // C99 6.9.2p3: If the declaration of an identifier for an object is 9317 // a tentative definition and has internal linkage (C99 6.2.2p3), the 9318 // declared type shall not be an incomplete type. 9319 // NOTE: code such as the following 9320 // static struct s; 9321 // struct s { int a; }; 9322 // is accepted by gcc. Hence here we issue a warning instead of 9323 // an error and we do not invalidate the static declaration. 9324 // NOTE: to avoid multiple warnings, only check the first declaration. 9325 if (Var->isFirstDecl()) 9326 RequireCompleteType(Var->getLocation(), Type, 9327 diag::ext_typecheck_decl_incomplete_type); 9328 } 9329 } 9330 9331 // Record the tentative definition; we're done. 9332 if (!Var->isInvalidDecl()) 9333 TentativeDefinitions.push_back(Var); 9334 return; 9335 } 9336 9337 // Provide a specific diagnostic for uninitialized variable 9338 // definitions with incomplete array type. 9339 if (Type->isIncompleteArrayType()) { 9340 Diag(Var->getLocation(), 9341 diag::err_typecheck_incomplete_array_needs_initializer); 9342 Var->setInvalidDecl(); 9343 return; 9344 } 9345 9346 // Provide a specific diagnostic for uninitialized variable 9347 // definitions with reference type. 9348 if (Type->isReferenceType()) { 9349 Diag(Var->getLocation(), diag::err_reference_var_requires_init) 9350 << Var->getDeclName() 9351 << SourceRange(Var->getLocation(), Var->getLocation()); 9352 Var->setInvalidDecl(); 9353 return; 9354 } 9355 9356 // Do not attempt to type-check the default initializer for a 9357 // variable with dependent type. 9358 if (Type->isDependentType()) 9359 return; 9360 9361 if (Var->isInvalidDecl()) 9362 return; 9363 9364 if (!Var->hasAttr<AliasAttr>()) { 9365 if (RequireCompleteType(Var->getLocation(), 9366 Context.getBaseElementType(Type), 9367 diag::err_typecheck_decl_incomplete_type)) { 9368 Var->setInvalidDecl(); 9369 return; 9370 } 9371 } else { 9372 return; 9373 } 9374 9375 // The variable can not have an abstract class type. 9376 if (RequireNonAbstractType(Var->getLocation(), Type, 9377 diag::err_abstract_type_in_decl, 9378 AbstractVariableType)) { 9379 Var->setInvalidDecl(); 9380 return; 9381 } 9382 9383 // Check for jumps past the implicit initializer. C++0x 9384 // clarifies that this applies to a "variable with automatic 9385 // storage duration", not a "local variable". 9386 // C++11 [stmt.dcl]p3 9387 // A program that jumps from a point where a variable with automatic 9388 // storage duration is not in scope to a point where it is in scope is 9389 // ill-formed unless the variable has scalar type, class type with a 9390 // trivial default constructor and a trivial destructor, a cv-qualified 9391 // version of one of these types, or an array of one of the preceding 9392 // types and is declared without an initializer. 9393 if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) { 9394 if (const RecordType *Record 9395 = Context.getBaseElementType(Type)->getAs<RecordType>()) { 9396 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl()); 9397 // Mark the function for further checking even if the looser rules of 9398 // C++11 do not require such checks, so that we can diagnose 9399 // incompatibilities with C++98. 9400 if (!CXXRecord->isPOD()) 9401 getCurFunction()->setHasBranchProtectedScope(); 9402 } 9403 } 9404 9405 // C++03 [dcl.init]p9: 9406 // If no initializer is specified for an object, and the 9407 // object is of (possibly cv-qualified) non-POD class type (or 9408 // array thereof), the object shall be default-initialized; if 9409 // the object is of const-qualified type, the underlying class 9410 // type shall have a user-declared default 9411 // constructor. Otherwise, if no initializer is specified for 9412 // a non- static object, the object and its subobjects, if 9413 // any, have an indeterminate initial value); if the object 9414 // or any of its subobjects are of const-qualified type, the 9415 // program is ill-formed. 9416 // C++0x [dcl.init]p11: 9417 // If no initializer is specified for an object, the object is 9418 // default-initialized; [...]. 9419 InitializedEntity Entity = InitializedEntity::InitializeVariable(Var); 9420 InitializationKind Kind 9421 = InitializationKind::CreateDefault(Var->getLocation()); 9422 9423 InitializationSequence InitSeq(*this, Entity, Kind, None); 9424 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None); 9425 if (Init.isInvalid()) 9426 Var->setInvalidDecl(); 9427 else if (Init.get()) { 9428 Var->setInit(MaybeCreateExprWithCleanups(Init.get())); 9429 // This is important for template substitution. 9430 Var->setInitStyle(VarDecl::CallInit); 9431 } 9432 9433 CheckCompleteVariableDeclaration(Var); 9434 } 9435 } 9436 9437 void Sema::ActOnCXXForRangeDecl(Decl *D) { 9438 VarDecl *VD = dyn_cast<VarDecl>(D); 9439 if (!VD) { 9440 Diag(D->getLocation(), diag::err_for_range_decl_must_be_var); 9441 D->setInvalidDecl(); 9442 return; 9443 } 9444 9445 VD->setCXXForRangeDecl(true); 9446 9447 // for-range-declaration cannot be given a storage class specifier. 9448 int Error = -1; 9449 switch (VD->getStorageClass()) { 9450 case SC_None: 9451 break; 9452 case SC_Extern: 9453 Error = 0; 9454 break; 9455 case SC_Static: 9456 Error = 1; 9457 break; 9458 case SC_PrivateExtern: 9459 Error = 2; 9460 break; 9461 case SC_Auto: 9462 Error = 3; 9463 break; 9464 case SC_Register: 9465 Error = 4; 9466 break; 9467 case SC_OpenCLWorkGroupLocal: 9468 llvm_unreachable("Unexpected storage class"); 9469 } 9470 if (Error != -1) { 9471 Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class) 9472 << VD->getDeclName() << Error; 9473 D->setInvalidDecl(); 9474 } 9475 } 9476 9477 StmtResult 9478 Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, 9479 IdentifierInfo *Ident, 9480 ParsedAttributes &Attrs, 9481 SourceLocation AttrEnd) { 9482 // C++1y [stmt.iter]p1: 9483 // A range-based for statement of the form 9484 // for ( for-range-identifier : for-range-initializer ) statement 9485 // is equivalent to 9486 // for ( auto&& for-range-identifier : for-range-initializer ) statement 9487 DeclSpec DS(Attrs.getPool().getFactory()); 9488 9489 const char *PrevSpec; 9490 unsigned DiagID; 9491 DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID, 9492 getPrintingPolicy()); 9493 9494 Declarator D(DS, Declarator::ForContext); 9495 D.SetIdentifier(Ident, IdentLoc); 9496 D.takeAttributes(Attrs, AttrEnd); 9497 9498 ParsedAttributes EmptyAttrs(Attrs.getPool().getFactory()); 9499 D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/false), 9500 EmptyAttrs, IdentLoc); 9501 Decl *Var = ActOnDeclarator(S, D); 9502 cast<VarDecl>(Var)->setCXXForRangeDecl(true); 9503 FinalizeDeclaration(Var); 9504 return ActOnDeclStmt(FinalizeDeclaratorGroup(S, DS, Var), IdentLoc, 9505 AttrEnd.isValid() ? AttrEnd : IdentLoc); 9506 } 9507 9508 void Sema::CheckCompleteVariableDeclaration(VarDecl *var) { 9509 if (var->isInvalidDecl()) return; 9510 9511 // In ARC, don't allow jumps past the implicit initialization of a 9512 // local retaining variable. 9513 if (getLangOpts().ObjCAutoRefCount && 9514 var->hasLocalStorage()) { 9515 switch (var->getType().getObjCLifetime()) { 9516 case Qualifiers::OCL_None: 9517 case Qualifiers::OCL_ExplicitNone: 9518 case Qualifiers::OCL_Autoreleasing: 9519 break; 9520 9521 case Qualifiers::OCL_Weak: 9522 case Qualifiers::OCL_Strong: 9523 getCurFunction()->setHasBranchProtectedScope(); 9524 break; 9525 } 9526 } 9527 9528 // Warn about externally-visible variables being defined without a 9529 // prior declaration. We only want to do this for global 9530 // declarations, but we also specifically need to avoid doing it for 9531 // class members because the linkage of an anonymous class can 9532 // change if it's later given a typedef name. 9533 if (var->isThisDeclarationADefinition() && 9534 var->getDeclContext()->getRedeclContext()->isFileContext() && 9535 var->isExternallyVisible() && var->hasLinkage() && 9536 !getDiagnostics().isIgnored(diag::warn_missing_variable_declarations, 9537 var->getLocation())) { 9538 // Find a previous declaration that's not a definition. 9539 VarDecl *prev = var->getPreviousDecl(); 9540 while (prev && prev->isThisDeclarationADefinition()) 9541 prev = prev->getPreviousDecl(); 9542 9543 if (!prev) 9544 Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var; 9545 } 9546 9547 if (var->getTLSKind() == VarDecl::TLS_Static) { 9548 const Expr *Culprit; 9549 if (var->getType().isDestructedType()) { 9550 // GNU C++98 edits for __thread, [basic.start.term]p3: 9551 // The type of an object with thread storage duration shall not 9552 // have a non-trivial destructor. 9553 Diag(var->getLocation(), diag::err_thread_nontrivial_dtor); 9554 if (getLangOpts().CPlusPlus11) 9555 Diag(var->getLocation(), diag::note_use_thread_local); 9556 } else if (getLangOpts().CPlusPlus && var->hasInit() && 9557 !var->getInit()->isConstantInitializer( 9558 Context, var->getType()->isReferenceType(), &Culprit)) { 9559 // GNU C++98 edits for __thread, [basic.start.init]p4: 9560 // An object of thread storage duration shall not require dynamic 9561 // initialization. 9562 // FIXME: Need strict checking here. 9563 Diag(Culprit->getExprLoc(), diag::err_thread_dynamic_init) 9564 << Culprit->getSourceRange(); 9565 if (getLangOpts().CPlusPlus11) 9566 Diag(var->getLocation(), diag::note_use_thread_local); 9567 } 9568 9569 } 9570 9571 // Apply section attributes and pragmas to global variables. 9572 bool GlobalStorage = var->hasGlobalStorage(); 9573 if (GlobalStorage && var->isThisDeclarationADefinition() && 9574 ActiveTemplateInstantiations.empty()) { 9575 PragmaStack<StringLiteral *> *Stack = nullptr; 9576 int SectionFlags = ASTContext::PSF_Implicit | ASTContext::PSF_Read; 9577 if (var->getType().isConstQualified()) 9578 Stack = &ConstSegStack; 9579 else if (!var->getInit()) { 9580 Stack = &BSSSegStack; 9581 SectionFlags |= ASTContext::PSF_Write; 9582 } else { 9583 Stack = &DataSegStack; 9584 SectionFlags |= ASTContext::PSF_Write; 9585 } 9586 if (Stack->CurrentValue && !var->hasAttr<SectionAttr>()) { 9587 var->addAttr(SectionAttr::CreateImplicit( 9588 Context, SectionAttr::Declspec_allocate, 9589 Stack->CurrentValue->getString(), Stack->CurrentPragmaLocation)); 9590 } 9591 if (const SectionAttr *SA = var->getAttr<SectionAttr>()) 9592 if (UnifySection(SA->getName(), SectionFlags, var)) 9593 var->dropAttr<SectionAttr>(); 9594 9595 // Apply the init_seg attribute if this has an initializer. If the 9596 // initializer turns out to not be dynamic, we'll end up ignoring this 9597 // attribute. 9598 if (CurInitSeg && var->getInit()) 9599 var->addAttr(InitSegAttr::CreateImplicit(Context, CurInitSeg->getString(), 9600 CurInitSegLoc)); 9601 } 9602 9603 // All the following checks are C++ only. 9604 if (!getLangOpts().CPlusPlus) return; 9605 9606 QualType type = var->getType(); 9607 if (type->isDependentType()) return; 9608 9609 // __block variables might require us to capture a copy-initializer. 9610 if (var->hasAttr<BlocksAttr>()) { 9611 // It's currently invalid to ever have a __block variable with an 9612 // array type; should we diagnose that here? 9613 9614 // Regardless, we don't want to ignore array nesting when 9615 // constructing this copy. 9616 if (type->isStructureOrClassType()) { 9617 EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated); 9618 SourceLocation poi = var->getLocation(); 9619 Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi); 9620 ExprResult result 9621 = PerformMoveOrCopyInitialization( 9622 InitializedEntity::InitializeBlock(poi, type, false), 9623 var, var->getType(), varRef, /*AllowNRVO=*/true); 9624 if (!result.isInvalid()) { 9625 result = MaybeCreateExprWithCleanups(result); 9626 Expr *init = result.getAs<Expr>(); 9627 Context.setBlockVarCopyInits(var, init); 9628 } 9629 } 9630 } 9631 9632 Expr *Init = var->getInit(); 9633 bool IsGlobal = GlobalStorage && !var->isStaticLocal(); 9634 QualType baseType = Context.getBaseElementType(type); 9635 9636 if (!var->getDeclContext()->isDependentContext() && 9637 Init && !Init->isValueDependent()) { 9638 if (IsGlobal && !var->isConstexpr() && 9639 !getDiagnostics().isIgnored(diag::warn_global_constructor, 9640 var->getLocation())) { 9641 // Warn about globals which don't have a constant initializer. Don't 9642 // warn about globals with a non-trivial destructor because we already 9643 // warned about them. 9644 CXXRecordDecl *RD = baseType->getAsCXXRecordDecl(); 9645 if (!(RD && !RD->hasTrivialDestructor()) && 9646 !Init->isConstantInitializer(Context, baseType->isReferenceType())) 9647 Diag(var->getLocation(), diag::warn_global_constructor) 9648 << Init->getSourceRange(); 9649 } 9650 9651 if (var->isConstexpr()) { 9652 SmallVector<PartialDiagnosticAt, 8> Notes; 9653 if (!var->evaluateValue(Notes) || !var->isInitICE()) { 9654 SourceLocation DiagLoc = var->getLocation(); 9655 // If the note doesn't add any useful information other than a source 9656 // location, fold it into the primary diagnostic. 9657 if (Notes.size() == 1 && Notes[0].second.getDiagID() == 9658 diag::note_invalid_subexpr_in_const_expr) { 9659 DiagLoc = Notes[0].first; 9660 Notes.clear(); 9661 } 9662 Diag(DiagLoc, diag::err_constexpr_var_requires_const_init) 9663 << var << Init->getSourceRange(); 9664 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 9665 Diag(Notes[I].first, Notes[I].second); 9666 } 9667 } else if (var->isUsableInConstantExpressions(Context)) { 9668 // Check whether the initializer of a const variable of integral or 9669 // enumeration type is an ICE now, since we can't tell whether it was 9670 // initialized by a constant expression if we check later. 9671 var->checkInitIsICE(); 9672 } 9673 } 9674 9675 // Require the destructor. 9676 if (const RecordType *recordType = baseType->getAs<RecordType>()) 9677 FinalizeVarWithDestructor(var, recordType); 9678 } 9679 9680 /// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform 9681 /// any semantic actions necessary after any initializer has been attached. 9682 void 9683 Sema::FinalizeDeclaration(Decl *ThisDecl) { 9684 // Note that we are no longer parsing the initializer for this declaration. 9685 ParsingInitForAutoVars.erase(ThisDecl); 9686 9687 VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl); 9688 if (!VD) 9689 return; 9690 9691 checkAttributesAfterMerging(*this, *VD); 9692 9693 // Static locals inherit dll attributes from their function. 9694 if (VD->isStaticLocal()) { 9695 if (FunctionDecl *FD = 9696 dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod())) { 9697 if (Attr *A = getDLLAttr(FD)) { 9698 auto *NewAttr = cast<InheritableAttr>(A->clone(getASTContext())); 9699 NewAttr->setInherited(true); 9700 VD->addAttr(NewAttr); 9701 } 9702 } 9703 } 9704 9705 // Grab the dllimport or dllexport attribute off of the VarDecl. 9706 const InheritableAttr *DLLAttr = getDLLAttr(VD); 9707 9708 // Imported static data members cannot be defined out-of-line. 9709 if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) { 9710 if (VD->isStaticDataMember() && VD->isOutOfLine() && 9711 VD->isThisDeclarationADefinition()) { 9712 // We allow definitions of dllimport class template static data members 9713 // with a warning. 9714 CXXRecordDecl *Context = 9715 cast<CXXRecordDecl>(VD->getFirstDecl()->getDeclContext()); 9716 bool IsClassTemplateMember = 9717 isa<ClassTemplatePartialSpecializationDecl>(Context) || 9718 Context->getDescribedClassTemplate(); 9719 9720 Diag(VD->getLocation(), 9721 IsClassTemplateMember 9722 ? diag::warn_attribute_dllimport_static_field_definition 9723 : diag::err_attribute_dllimport_static_field_definition); 9724 Diag(IA->getLocation(), diag::note_attribute); 9725 if (!IsClassTemplateMember) 9726 VD->setInvalidDecl(); 9727 } 9728 } 9729 9730 // dllimport/dllexport variables cannot be thread local, their TLS index 9731 // isn't exported with the variable. 9732 if (DLLAttr && VD->getTLSKind()) { 9733 Diag(VD->getLocation(), diag::err_attribute_dll_thread_local) << VD 9734 << DLLAttr; 9735 VD->setInvalidDecl(); 9736 } 9737 9738 if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) { 9739 if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) { 9740 Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr; 9741 VD->dropAttr<UsedAttr>(); 9742 } 9743 } 9744 9745 const DeclContext *DC = VD->getDeclContext(); 9746 // If there's a #pragma GCC visibility in scope, and this isn't a class 9747 // member, set the visibility of this variable. 9748 if (DC->getRedeclContext()->isFileContext() && VD->isExternallyVisible()) 9749 AddPushedVisibilityAttribute(VD); 9750 9751 // FIXME: Warn on unused templates. 9752 if (VD->isFileVarDecl() && !VD->getDescribedVarTemplate() && 9753 !isa<VarTemplatePartialSpecializationDecl>(VD)) 9754 MarkUnusedFileScopedDecl(VD); 9755 9756 // Now we have parsed the initializer and can update the table of magic 9757 // tag values. 9758 if (!VD->hasAttr<TypeTagForDatatypeAttr>() || 9759 !VD->getType()->isIntegralOrEnumerationType()) 9760 return; 9761 9762 for (const auto *I : ThisDecl->specific_attrs<TypeTagForDatatypeAttr>()) { 9763 const Expr *MagicValueExpr = VD->getInit(); 9764 if (!MagicValueExpr) { 9765 continue; 9766 } 9767 llvm::APSInt MagicValueInt; 9768 if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) { 9769 Diag(I->getRange().getBegin(), 9770 diag::err_type_tag_for_datatype_not_ice) 9771 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 9772 continue; 9773 } 9774 if (MagicValueInt.getActiveBits() > 64) { 9775 Diag(I->getRange().getBegin(), 9776 diag::err_type_tag_for_datatype_too_large) 9777 << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange(); 9778 continue; 9779 } 9780 uint64_t MagicValue = MagicValueInt.getZExtValue(); 9781 RegisterTypeTagForDatatype(I->getArgumentKind(), 9782 MagicValue, 9783 I->getMatchingCType(), 9784 I->getLayoutCompatible(), 9785 I->getMustBeNull()); 9786 } 9787 } 9788 9789 Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, 9790 ArrayRef<Decl *> Group) { 9791 SmallVector<Decl*, 8> Decls; 9792 9793 if (DS.isTypeSpecOwned()) 9794 Decls.push_back(DS.getRepAsDecl()); 9795 9796 DeclaratorDecl *FirstDeclaratorInGroup = nullptr; 9797 for (unsigned i = 0, e = Group.size(); i != e; ++i) 9798 if (Decl *D = Group[i]) { 9799 if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) 9800 if (!FirstDeclaratorInGroup) 9801 FirstDeclaratorInGroup = DD; 9802 Decls.push_back(D); 9803 } 9804 9805 if (DeclSpec::isDeclRep(DS.getTypeSpecType())) { 9806 if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) { 9807 handleTagNumbering(Tag, S); 9808 if (!Tag->hasNameForLinkage() && !Tag->hasDeclaratorForAnonDecl()) 9809 Tag->setDeclaratorForAnonDecl(FirstDeclaratorInGroup); 9810 } 9811 } 9812 9813 return BuildDeclaratorGroup(Decls, DS.containsPlaceholderType()); 9814 } 9815 9816 /// BuildDeclaratorGroup - convert a list of declarations into a declaration 9817 /// group, performing any necessary semantic checking. 9818 Sema::DeclGroupPtrTy 9819 Sema::BuildDeclaratorGroup(MutableArrayRef<Decl *> Group, 9820 bool TypeMayContainAuto) { 9821 // C++0x [dcl.spec.auto]p7: 9822 // If the type deduced for the template parameter U is not the same in each 9823 // deduction, the program is ill-formed. 9824 // FIXME: When initializer-list support is added, a distinction is needed 9825 // between the deduced type U and the deduced type which 'auto' stands for. 9826 // auto a = 0, b = { 1, 2, 3 }; 9827 // is legal because the deduced type U is 'int' in both cases. 9828 if (TypeMayContainAuto && Group.size() > 1) { 9829 QualType Deduced; 9830 CanQualType DeducedCanon; 9831 VarDecl *DeducedDecl = nullptr; 9832 for (unsigned i = 0, e = Group.size(); i != e; ++i) { 9833 if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) { 9834 AutoType *AT = D->getType()->getContainedAutoType(); 9835 // Don't reissue diagnostics when instantiating a template. 9836 if (AT && D->isInvalidDecl()) 9837 break; 9838 QualType U = AT ? AT->getDeducedType() : QualType(); 9839 if (!U.isNull()) { 9840 CanQualType UCanon = Context.getCanonicalType(U); 9841 if (Deduced.isNull()) { 9842 Deduced = U; 9843 DeducedCanon = UCanon; 9844 DeducedDecl = D; 9845 } else if (DeducedCanon != UCanon) { 9846 Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(), 9847 diag::err_auto_different_deductions) 9848 << (AT->isDecltypeAuto() ? 1 : 0) 9849 << Deduced << DeducedDecl->getDeclName() 9850 << U << D->getDeclName() 9851 << DeducedDecl->getInit()->getSourceRange() 9852 << D->getInit()->getSourceRange(); 9853 D->setInvalidDecl(); 9854 break; 9855 } 9856 } 9857 } 9858 } 9859 } 9860 9861 ActOnDocumentableDecls(Group); 9862 9863 return DeclGroupPtrTy::make( 9864 DeclGroupRef::Create(Context, Group.data(), Group.size())); 9865 } 9866 9867 void Sema::ActOnDocumentableDecl(Decl *D) { 9868 ActOnDocumentableDecls(D); 9869 } 9870 9871 void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) { 9872 // Don't parse the comment if Doxygen diagnostics are ignored. 9873 if (Group.empty() || !Group[0]) 9874 return; 9875 9876 if (Diags.isIgnored(diag::warn_doc_param_not_found, 9877 Group[0]->getLocation()) && 9878 Diags.isIgnored(diag::warn_unknown_comment_command_name, 9879 Group[0]->getLocation())) 9880 return; 9881 9882 if (Group.size() >= 2) { 9883 // This is a decl group. Normally it will contain only declarations 9884 // produced from declarator list. But in case we have any definitions or 9885 // additional declaration references: 9886 // 'typedef struct S {} S;' 9887 // 'typedef struct S *S;' 9888 // 'struct S *pS;' 9889 // FinalizeDeclaratorGroup adds these as separate declarations. 9890 Decl *MaybeTagDecl = Group[0]; 9891 if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) { 9892 Group = Group.slice(1); 9893 } 9894 } 9895 9896 // See if there are any new comments that are not attached to a decl. 9897 ArrayRef<RawComment *> Comments = Context.getRawCommentList().getComments(); 9898 if (!Comments.empty() && 9899 !Comments.back()->isAttached()) { 9900 // There is at least one comment that not attached to a decl. 9901 // Maybe it should be attached to one of these decls? 9902 // 9903 // Note that this way we pick up not only comments that precede the 9904 // declaration, but also comments that *follow* the declaration -- thanks to 9905 // the lookahead in the lexer: we've consumed the semicolon and looked 9906 // ahead through comments. 9907 for (unsigned i = 0, e = Group.size(); i != e; ++i) 9908 Context.getCommentForDecl(Group[i], &PP); 9909 } 9910 } 9911 9912 /// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator() 9913 /// to introduce parameters into function prototype scope. 9914 Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) { 9915 const DeclSpec &DS = D.getDeclSpec(); 9916 9917 // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'. 9918 9919 // C++03 [dcl.stc]p2 also permits 'auto'. 9920 StorageClass SC = SC_None; 9921 if (DS.getStorageClassSpec() == DeclSpec::SCS_register) { 9922 SC = SC_Register; 9923 } else if (getLangOpts().CPlusPlus && 9924 DS.getStorageClassSpec() == DeclSpec::SCS_auto) { 9925 SC = SC_Auto; 9926 } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) { 9927 Diag(DS.getStorageClassSpecLoc(), 9928 diag::err_invalid_storage_class_in_func_decl); 9929 D.getMutableDeclSpec().ClearStorageClassSpecs(); 9930 } 9931 9932 if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec()) 9933 Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread) 9934 << DeclSpec::getSpecifierName(TSCS); 9935 if (DS.isConstexprSpecified()) 9936 Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr) 9937 << 0; 9938 9939 DiagnoseFunctionSpecifiers(DS); 9940 9941 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 9942 QualType parmDeclType = TInfo->getType(); 9943 9944 if (getLangOpts().CPlusPlus) { 9945 // Check that there are no default arguments inside the type of this 9946 // parameter. 9947 CheckExtraCXXDefaultArguments(D); 9948 9949 // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1). 9950 if (D.getCXXScopeSpec().isSet()) { 9951 Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator) 9952 << D.getCXXScopeSpec().getRange(); 9953 D.getCXXScopeSpec().clear(); 9954 } 9955 } 9956 9957 // Ensure we have a valid name 9958 IdentifierInfo *II = nullptr; 9959 if (D.hasName()) { 9960 II = D.getIdentifier(); 9961 if (!II) { 9962 Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name) 9963 << GetNameForDeclarator(D).getName(); 9964 D.setInvalidType(true); 9965 } 9966 } 9967 9968 // Check for redeclaration of parameters, e.g. int foo(int x, int x); 9969 if (II) { 9970 LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName, 9971 ForRedeclaration); 9972 LookupName(R, S); 9973 if (R.isSingleResult()) { 9974 NamedDecl *PrevDecl = R.getFoundDecl(); 9975 if (PrevDecl->isTemplateParameter()) { 9976 // Maybe we will complain about the shadowed template parameter. 9977 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 9978 // Just pretend that we didn't see the previous declaration. 9979 PrevDecl = nullptr; 9980 } else if (S->isDeclScope(PrevDecl)) { 9981 Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II; 9982 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 9983 9984 // Recover by removing the name 9985 II = nullptr; 9986 D.SetIdentifier(nullptr, D.getIdentifierLoc()); 9987 D.setInvalidType(true); 9988 } 9989 } 9990 } 9991 9992 // Temporarily put parameter variables in the translation unit, not 9993 // the enclosing context. This prevents them from accidentally 9994 // looking like class members in C++. 9995 ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(), 9996 D.getLocStart(), 9997 D.getIdentifierLoc(), II, 9998 parmDeclType, TInfo, 9999 SC); 10000 10001 if (D.isInvalidType()) 10002 New->setInvalidDecl(); 10003 10004 assert(S->isFunctionPrototypeScope()); 10005 assert(S->getFunctionPrototypeDepth() >= 1); 10006 New->setScopeInfo(S->getFunctionPrototypeDepth() - 1, 10007 S->getNextFunctionPrototypeIndex()); 10008 10009 // Add the parameter declaration into this scope. 10010 S->AddDecl(New); 10011 if (II) 10012 IdResolver.AddDecl(New); 10013 10014 ProcessDeclAttributes(S, New, D); 10015 10016 if (D.getDeclSpec().isModulePrivateSpecified()) 10017 Diag(New->getLocation(), diag::err_module_private_local) 10018 << 1 << New->getDeclName() 10019 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 10020 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 10021 10022 if (New->hasAttr<BlocksAttr>()) { 10023 Diag(New->getLocation(), diag::err_block_on_nonlocal); 10024 } 10025 return New; 10026 } 10027 10028 /// \brief Synthesizes a variable for a parameter arising from a 10029 /// typedef. 10030 ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC, 10031 SourceLocation Loc, 10032 QualType T) { 10033 /* FIXME: setting StartLoc == Loc. 10034 Would it be worth to modify callers so as to provide proper source 10035 location for the unnamed parameters, embedding the parameter's type? */ 10036 ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr, 10037 T, Context.getTrivialTypeSourceInfo(T, Loc), 10038 SC_None, nullptr); 10039 Param->setImplicit(); 10040 return Param; 10041 } 10042 10043 void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param, 10044 ParmVarDecl * const *ParamEnd) { 10045 // Don't diagnose unused-parameter errors in template instantiations; we 10046 // will already have done so in the template itself. 10047 if (!ActiveTemplateInstantiations.empty()) 10048 return; 10049 10050 for (; Param != ParamEnd; ++Param) { 10051 if (!(*Param)->isReferenced() && (*Param)->getDeclName() && 10052 !(*Param)->hasAttr<UnusedAttr>()) { 10053 Diag((*Param)->getLocation(), diag::warn_unused_parameter) 10054 << (*Param)->getDeclName(); 10055 } 10056 } 10057 } 10058 10059 void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param, 10060 ParmVarDecl * const *ParamEnd, 10061 QualType ReturnTy, 10062 NamedDecl *D) { 10063 if (LangOpts.NumLargeByValueCopy == 0) // No check. 10064 return; 10065 10066 // Warn if the return value is pass-by-value and larger than the specified 10067 // threshold. 10068 if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) { 10069 unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity(); 10070 if (Size > LangOpts.NumLargeByValueCopy) 10071 Diag(D->getLocation(), diag::warn_return_value_size) 10072 << D->getDeclName() << Size; 10073 } 10074 10075 // Warn if any parameter is pass-by-value and larger than the specified 10076 // threshold. 10077 for (; Param != ParamEnd; ++Param) { 10078 QualType T = (*Param)->getType(); 10079 if (T->isDependentType() || !T.isPODType(Context)) 10080 continue; 10081 unsigned Size = Context.getTypeSizeInChars(T).getQuantity(); 10082 if (Size > LangOpts.NumLargeByValueCopy) 10083 Diag((*Param)->getLocation(), diag::warn_parameter_size) 10084 << (*Param)->getDeclName() << Size; 10085 } 10086 } 10087 10088 ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, 10089 SourceLocation NameLoc, IdentifierInfo *Name, 10090 QualType T, TypeSourceInfo *TSInfo, 10091 StorageClass SC) { 10092 // In ARC, infer a lifetime qualifier for appropriate parameter types. 10093 if (getLangOpts().ObjCAutoRefCount && 10094 T.getObjCLifetime() == Qualifiers::OCL_None && 10095 T->isObjCLifetimeType()) { 10096 10097 Qualifiers::ObjCLifetime lifetime; 10098 10099 // Special cases for arrays: 10100 // - if it's const, use __unsafe_unretained 10101 // - otherwise, it's an error 10102 if (T->isArrayType()) { 10103 if (!T.isConstQualified()) { 10104 DelayedDiagnostics.add( 10105 sema::DelayedDiagnostic::makeForbiddenType( 10106 NameLoc, diag::err_arc_array_param_no_ownership, T, false)); 10107 } 10108 lifetime = Qualifiers::OCL_ExplicitNone; 10109 } else { 10110 lifetime = T->getObjCARCImplicitLifetime(); 10111 } 10112 T = Context.getLifetimeQualifiedType(T, lifetime); 10113 } 10114 10115 ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name, 10116 Context.getAdjustedParameterType(T), 10117 TSInfo, SC, nullptr); 10118 10119 // Parameters can not be abstract class types. 10120 // For record types, this is done by the AbstractClassUsageDiagnoser once 10121 // the class has been completely parsed. 10122 if (!CurContext->isRecord() && 10123 RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl, 10124 AbstractParamType)) 10125 New->setInvalidDecl(); 10126 10127 // Parameter declarators cannot be interface types. All ObjC objects are 10128 // passed by reference. 10129 if (T->isObjCObjectType()) { 10130 SourceLocation TypeEndLoc = TSInfo->getTypeLoc().getLocEnd(); 10131 Diag(NameLoc, 10132 diag::err_object_cannot_be_passed_returned_by_value) << 1 << T 10133 << FixItHint::CreateInsertion(TypeEndLoc, "*"); 10134 T = Context.getObjCObjectPointerType(T); 10135 New->setType(T); 10136 } 10137 10138 // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage 10139 // duration shall not be qualified by an address-space qualifier." 10140 // Since all parameters have automatic store duration, they can not have 10141 // an address space. 10142 if (T.getAddressSpace() != 0) { 10143 // OpenCL allows function arguments declared to be an array of a type 10144 // to be qualified with an address space. 10145 if (!(getLangOpts().OpenCL && T->isArrayType())) { 10146 Diag(NameLoc, diag::err_arg_with_address_space); 10147 New->setInvalidDecl(); 10148 } 10149 } 10150 10151 return New; 10152 } 10153 10154 void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, 10155 SourceLocation LocAfterDecls) { 10156 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo(); 10157 10158 // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared' 10159 // for a K&R function. 10160 if (!FTI.hasPrototype) { 10161 for (int i = FTI.NumParams; i != 0; /* decrement in loop */) { 10162 --i; 10163 if (FTI.Params[i].Param == nullptr) { 10164 SmallString<256> Code; 10165 llvm::raw_svector_ostream(Code) 10166 << " int " << FTI.Params[i].Ident->getName() << ";\n"; 10167 Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared) 10168 << FTI.Params[i].Ident 10169 << FixItHint::CreateInsertion(LocAfterDecls, Code); 10170 10171 // Implicitly declare the argument as type 'int' for lack of a better 10172 // type. 10173 AttributeFactory attrs; 10174 DeclSpec DS(attrs); 10175 const char* PrevSpec; // unused 10176 unsigned DiagID; // unused 10177 DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec, 10178 DiagID, Context.getPrintingPolicy()); 10179 // Use the identifier location for the type source range. 10180 DS.SetRangeStart(FTI.Params[i].IdentLoc); 10181 DS.SetRangeEnd(FTI.Params[i].IdentLoc); 10182 Declarator ParamD(DS, Declarator::KNRTypeListContext); 10183 ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc); 10184 FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD); 10185 } 10186 } 10187 } 10188 } 10189 10190 Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) { 10191 assert(getCurFunctionDecl() == nullptr && "Function parsing confused"); 10192 assert(D.isFunctionDeclarator() && "Not a function declarator!"); 10193 Scope *ParentScope = FnBodyScope->getParent(); 10194 10195 D.setFunctionDefinitionKind(FDK_Definition); 10196 Decl *DP = HandleDeclarator(ParentScope, D, MultiTemplateParamsArg()); 10197 return ActOnStartOfFunctionDef(FnBodyScope, DP); 10198 } 10199 10200 void Sema::ActOnFinishInlineMethodDef(CXXMethodDecl *D) { 10201 Consumer.HandleInlineMethodDefinition(D); 10202 } 10203 10204 static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, 10205 const FunctionDecl*& PossibleZeroParamPrototype) { 10206 // Don't warn about invalid declarations. 10207 if (FD->isInvalidDecl()) 10208 return false; 10209 10210 // Or declarations that aren't global. 10211 if (!FD->isGlobal()) 10212 return false; 10213 10214 // Don't warn about C++ member functions. 10215 if (isa<CXXMethodDecl>(FD)) 10216 return false; 10217 10218 // Don't warn about 'main'. 10219 if (FD->isMain()) 10220 return false; 10221 10222 // Don't warn about inline functions. 10223 if (FD->isInlined()) 10224 return false; 10225 10226 // Don't warn about function templates. 10227 if (FD->getDescribedFunctionTemplate()) 10228 return false; 10229 10230 // Don't warn about function template specializations. 10231 if (FD->isFunctionTemplateSpecialization()) 10232 return false; 10233 10234 // Don't warn for OpenCL kernels. 10235 if (FD->hasAttr<OpenCLKernelAttr>()) 10236 return false; 10237 10238 // Don't warn on explicitly deleted functions. 10239 if (FD->isDeleted()) 10240 return false; 10241 10242 bool MissingPrototype = true; 10243 for (const FunctionDecl *Prev = FD->getPreviousDecl(); 10244 Prev; Prev = Prev->getPreviousDecl()) { 10245 // Ignore any declarations that occur in function or method 10246 // scope, because they aren't visible from the header. 10247 if (Prev->getLexicalDeclContext()->isFunctionOrMethod()) 10248 continue; 10249 10250 MissingPrototype = !Prev->getType()->isFunctionProtoType(); 10251 if (FD->getNumParams() == 0) 10252 PossibleZeroParamPrototype = Prev; 10253 break; 10254 } 10255 10256 return MissingPrototype; 10257 } 10258 10259 void 10260 Sema::CheckForFunctionRedefinition(FunctionDecl *FD, 10261 const FunctionDecl *EffectiveDefinition) { 10262 // Don't complain if we're in GNU89 mode and the previous definition 10263 // was an extern inline function. 10264 const FunctionDecl *Definition = EffectiveDefinition; 10265 if (!Definition) 10266 if (!FD->isDefined(Definition)) 10267 return; 10268 10269 if (canRedefineFunction(Definition, getLangOpts())) 10270 return; 10271 10272 // If we don't have a visible definition of the function, and it's inline or 10273 // a template, it's OK to form another definition of it. 10274 // 10275 // FIXME: Should we skip the body of the function and use the old definition 10276 // in this case? That may be necessary for functions that return local types 10277 // through a deduced return type, or instantiate templates with local types. 10278 if (!hasVisibleDefinition(Definition) && 10279 (Definition->isInlineSpecified() || 10280 Definition->getDescribedFunctionTemplate() || 10281 Definition->getNumTemplateParameterLists())) 10282 return; 10283 10284 if (getLangOpts().GNUMode && Definition->isInlineSpecified() && 10285 Definition->getStorageClass() == SC_Extern) 10286 Diag(FD->getLocation(), diag::err_redefinition_extern_inline) 10287 << FD->getDeclName() << getLangOpts().CPlusPlus; 10288 else 10289 Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName(); 10290 10291 Diag(Definition->getLocation(), diag::note_previous_definition); 10292 FD->setInvalidDecl(); 10293 } 10294 10295 10296 static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator, 10297 Sema &S) { 10298 CXXRecordDecl *const LambdaClass = CallOperator->getParent(); 10299 10300 LambdaScopeInfo *LSI = S.PushLambdaScope(); 10301 LSI->CallOperator = CallOperator; 10302 LSI->Lambda = LambdaClass; 10303 LSI->ReturnType = CallOperator->getReturnType(); 10304 const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault(); 10305 10306 if (LCD == LCD_None) 10307 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_None; 10308 else if (LCD == LCD_ByCopy) 10309 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByval; 10310 else if (LCD == LCD_ByRef) 10311 LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByref; 10312 DeclarationNameInfo DNI = CallOperator->getNameInfo(); 10313 10314 LSI->IntroducerRange = DNI.getCXXOperatorNameRange(); 10315 LSI->Mutable = !CallOperator->isConst(); 10316 10317 // Add the captures to the LSI so they can be noted as already 10318 // captured within tryCaptureVar. 10319 auto I = LambdaClass->field_begin(); 10320 for (const auto &C : LambdaClass->captures()) { 10321 if (C.capturesVariable()) { 10322 VarDecl *VD = C.getCapturedVar(); 10323 if (VD->isInitCapture()) 10324 S.CurrentInstantiationScope->InstantiatedLocal(VD, VD); 10325 QualType CaptureType = VD->getType(); 10326 const bool ByRef = C.getCaptureKind() == LCK_ByRef; 10327 LSI->addCapture(VD, /*IsBlock*/false, ByRef, 10328 /*RefersToEnclosingVariableOrCapture*/true, C.getLocation(), 10329 /*EllipsisLoc*/C.isPackExpansion() 10330 ? C.getEllipsisLoc() : SourceLocation(), 10331 CaptureType, /*Expr*/ nullptr); 10332 10333 } else if (C.capturesThis()) { 10334 LSI->addThisCapture(/*Nested*/ false, C.getLocation(), 10335 S.getCurrentThisType(), /*Expr*/ nullptr); 10336 } else { 10337 LSI->addVLATypeCapture(C.getLocation(), I->getType()); 10338 } 10339 ++I; 10340 } 10341 } 10342 10343 Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) { 10344 // Clear the last template instantiation error context. 10345 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation(); 10346 10347 if (!D) 10348 return D; 10349 FunctionDecl *FD = nullptr; 10350 10351 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 10352 FD = FunTmpl->getTemplatedDecl(); 10353 else 10354 FD = cast<FunctionDecl>(D); 10355 // If we are instantiating a generic lambda call operator, push 10356 // a LambdaScopeInfo onto the function stack. But use the information 10357 // that's already been calculated (ActOnLambdaExpr) to prime the current 10358 // LambdaScopeInfo. 10359 // When the template operator is being specialized, the LambdaScopeInfo, 10360 // has to be properly restored so that tryCaptureVariable doesn't try 10361 // and capture any new variables. In addition when calculating potential 10362 // captures during transformation of nested lambdas, it is necessary to 10363 // have the LSI properly restored. 10364 if (isGenericLambdaCallOperatorSpecialization(FD)) { 10365 assert(ActiveTemplateInstantiations.size() && 10366 "There should be an active template instantiation on the stack " 10367 "when instantiating a generic lambda!"); 10368 RebuildLambdaScopeInfo(cast<CXXMethodDecl>(D), *this); 10369 } 10370 else 10371 // Enter a new function scope 10372 PushFunctionScope(); 10373 10374 // See if this is a redefinition. 10375 if (!FD->isLateTemplateParsed()) 10376 CheckForFunctionRedefinition(FD); 10377 10378 // Builtin functions cannot be defined. 10379 if (unsigned BuiltinID = FD->getBuiltinID()) { 10380 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) && 10381 !Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) { 10382 Diag(FD->getLocation(), diag::err_builtin_definition) << FD; 10383 FD->setInvalidDecl(); 10384 } 10385 } 10386 10387 // The return type of a function definition must be complete 10388 // (C99 6.9.1p3, C++ [dcl.fct]p6). 10389 QualType ResultType = FD->getReturnType(); 10390 if (!ResultType->isDependentType() && !ResultType->isVoidType() && 10391 !FD->isInvalidDecl() && 10392 RequireCompleteType(FD->getLocation(), ResultType, 10393 diag::err_func_def_incomplete_result)) 10394 FD->setInvalidDecl(); 10395 10396 if (FnBodyScope) 10397 PushDeclContext(FnBodyScope, FD); 10398 10399 // Check the validity of our function parameters 10400 CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(), 10401 /*CheckParameterNames=*/true); 10402 10403 // Introduce our parameters into the function scope 10404 for (auto Param : FD->params()) { 10405 Param->setOwningFunction(FD); 10406 10407 // If this has an identifier, add it to the scope stack. 10408 if (Param->getIdentifier() && FnBodyScope) { 10409 CheckShadow(FnBodyScope, Param); 10410 10411 PushOnScopeChains(Param, FnBodyScope); 10412 } 10413 } 10414 10415 // If we had any tags defined in the function prototype, 10416 // introduce them into the function scope. 10417 if (FnBodyScope) { 10418 for (ArrayRef<NamedDecl *>::iterator 10419 I = FD->getDeclsInPrototypeScope().begin(), 10420 E = FD->getDeclsInPrototypeScope().end(); 10421 I != E; ++I) { 10422 NamedDecl *D = *I; 10423 10424 // Some of these decls (like enums) may have been pinned to the 10425 // translation unit for lack of a real context earlier. If so, remove 10426 // from the translation unit and reattach to the current context. 10427 if (D->getLexicalDeclContext() == Context.getTranslationUnitDecl()) { 10428 // Is the decl actually in the context? 10429 for (const auto *DI : Context.getTranslationUnitDecl()->decls()) { 10430 if (DI == D) { 10431 Context.getTranslationUnitDecl()->removeDecl(D); 10432 break; 10433 } 10434 } 10435 // Either way, reassign the lexical decl context to our FunctionDecl. 10436 D->setLexicalDeclContext(CurContext); 10437 } 10438 10439 // If the decl has a non-null name, make accessible in the current scope. 10440 if (!D->getName().empty()) 10441 PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false); 10442 10443 // Similarly, dive into enums and fish their constants out, making them 10444 // accessible in this scope. 10445 if (auto *ED = dyn_cast<EnumDecl>(D)) { 10446 for (auto *EI : ED->enumerators()) 10447 PushOnScopeChains(EI, FnBodyScope, /*AddToContext=*/false); 10448 } 10449 } 10450 } 10451 10452 // Ensure that the function's exception specification is instantiated. 10453 if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>()) 10454 ResolveExceptionSpec(D->getLocation(), FPT); 10455 10456 // dllimport cannot be applied to non-inline function definitions. 10457 if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() && 10458 !FD->isTemplateInstantiation()) { 10459 assert(!FD->hasAttr<DLLExportAttr>()); 10460 Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition); 10461 FD->setInvalidDecl(); 10462 return D; 10463 } 10464 // We want to attach documentation to original Decl (which might be 10465 // a function template). 10466 ActOnDocumentableDecl(D); 10467 if (getCurLexicalContext()->isObjCContainer() && 10468 getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl && 10469 getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation) 10470 Diag(FD->getLocation(), diag::warn_function_def_in_objc_container); 10471 10472 return D; 10473 } 10474 10475 /// \brief Given the set of return statements within a function body, 10476 /// compute the variables that are subject to the named return value 10477 /// optimization. 10478 /// 10479 /// Each of the variables that is subject to the named return value 10480 /// optimization will be marked as NRVO variables in the AST, and any 10481 /// return statement that has a marked NRVO variable as its NRVO candidate can 10482 /// use the named return value optimization. 10483 /// 10484 /// This function applies a very simplistic algorithm for NRVO: if every return 10485 /// statement in the scope of a variable has the same NRVO candidate, that 10486 /// candidate is an NRVO variable. 10487 void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) { 10488 ReturnStmt **Returns = Scope->Returns.data(); 10489 10490 for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) { 10491 if (const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) { 10492 if (!NRVOCandidate->isNRVOVariable()) 10493 Returns[I]->setNRVOCandidate(nullptr); 10494 } 10495 } 10496 } 10497 10498 bool Sema::canDelayFunctionBody(const Declarator &D) { 10499 // We can't delay parsing the body of a constexpr function template (yet). 10500 if (D.getDeclSpec().isConstexprSpecified()) 10501 return false; 10502 10503 // We can't delay parsing the body of a function template with a deduced 10504 // return type (yet). 10505 if (D.getDeclSpec().containsPlaceholderType()) { 10506 // If the placeholder introduces a non-deduced trailing return type, 10507 // we can still delay parsing it. 10508 if (D.getNumTypeObjects()) { 10509 const auto &Outer = D.getTypeObject(D.getNumTypeObjects() - 1); 10510 if (Outer.Kind == DeclaratorChunk::Function && 10511 Outer.Fun.hasTrailingReturnType()) { 10512 QualType Ty = GetTypeFromParser(Outer.Fun.getTrailingReturnType()); 10513 return Ty.isNull() || !Ty->isUndeducedType(); 10514 } 10515 } 10516 return false; 10517 } 10518 10519 return true; 10520 } 10521 10522 bool Sema::canSkipFunctionBody(Decl *D) { 10523 // We cannot skip the body of a function (or function template) which is 10524 // constexpr, since we may need to evaluate its body in order to parse the 10525 // rest of the file. 10526 // We cannot skip the body of a function with an undeduced return type, 10527 // because any callers of that function need to know the type. 10528 if (const FunctionDecl *FD = D->getAsFunction()) 10529 if (FD->isConstexpr() || FD->getReturnType()->isUndeducedType()) 10530 return false; 10531 return Consumer.shouldSkipFunctionBody(D); 10532 } 10533 10534 Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) { 10535 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl)) 10536 FD->setHasSkippedBody(); 10537 else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl)) 10538 MD->setHasSkippedBody(); 10539 return ActOnFinishFunctionBody(Decl, nullptr); 10540 } 10541 10542 Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) { 10543 return ActOnFinishFunctionBody(D, BodyArg, false); 10544 } 10545 10546 Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, 10547 bool IsInstantiation) { 10548 FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr; 10549 10550 sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy(); 10551 sema::AnalysisBasedWarnings::Policy *ActivePolicy = nullptr; 10552 10553 if (FD) { 10554 FD->setBody(Body); 10555 10556 if (getLangOpts().CPlusPlus14 && !FD->isInvalidDecl() && Body && 10557 !FD->isDependentContext() && FD->getReturnType()->isUndeducedType()) { 10558 // If the function has a deduced result type but contains no 'return' 10559 // statements, the result type as written must be exactly 'auto', and 10560 // the deduced result type is 'void'. 10561 if (!FD->getReturnType()->getAs<AutoType>()) { 10562 Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto) 10563 << FD->getReturnType(); 10564 FD->setInvalidDecl(); 10565 } else { 10566 // Substitute 'void' for the 'auto' in the type. 10567 TypeLoc ResultType = getReturnTypeLoc(FD); 10568 Context.adjustDeducedFunctionResultType( 10569 FD, SubstAutoType(ResultType.getType(), Context.VoidTy)); 10570 } 10571 } 10572 10573 // The only way to be included in UndefinedButUsed is if there is an 10574 // ODR use before the definition. Avoid the expensive map lookup if this 10575 // is the first declaration. 10576 if (!FD->isFirstDecl() && FD->getPreviousDecl()->isUsed()) { 10577 if (!FD->isExternallyVisible()) 10578 UndefinedButUsed.erase(FD); 10579 else if (FD->isInlined() && 10580 (LangOpts.CPlusPlus || !LangOpts.GNUInline) && 10581 (!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>())) 10582 UndefinedButUsed.erase(FD); 10583 } 10584 10585 // If the function implicitly returns zero (like 'main') or is naked, 10586 // don't complain about missing return statements. 10587 if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>()) 10588 WP.disableCheckFallThrough(); 10589 10590 // MSVC permits the use of pure specifier (=0) on function definition, 10591 // defined at class scope, warn about this non-standard construct. 10592 if (getLangOpts().MicrosoftExt && FD->isPure() && FD->isCanonicalDecl()) 10593 Diag(FD->getLocation(), diag::ext_pure_function_definition); 10594 10595 if (!FD->isInvalidDecl()) { 10596 // Don't diagnose unused parameters of defaulted or deleted functions. 10597 if (!FD->isDeleted() && !FD->isDefaulted()) 10598 DiagnoseUnusedParameters(FD->param_begin(), FD->param_end()); 10599 DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(), 10600 FD->getReturnType(), FD); 10601 10602 // If this is a structor, we need a vtable. 10603 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD)) 10604 MarkVTableUsed(FD->getLocation(), Constructor->getParent()); 10605 else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(FD)) 10606 MarkVTableUsed(FD->getLocation(), Destructor->getParent()); 10607 10608 // Try to apply the named return value optimization. We have to check 10609 // if we can do this here because lambdas keep return statements around 10610 // to deduce an implicit return type. 10611 if (getLangOpts().CPlusPlus && FD->getReturnType()->isRecordType() && 10612 !FD->isDependentContext()) 10613 computeNRVO(Body, getCurFunction()); 10614 } 10615 10616 // GNU warning -Wmissing-prototypes: 10617 // Warn if a global function is defined without a previous 10618 // prototype declaration. This warning is issued even if the 10619 // definition itself provides a prototype. The aim is to detect 10620 // global functions that fail to be declared in header files. 10621 const FunctionDecl *PossibleZeroParamPrototype = nullptr; 10622 if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) { 10623 Diag(FD->getLocation(), diag::warn_missing_prototype) << FD; 10624 10625 if (PossibleZeroParamPrototype) { 10626 // We found a declaration that is not a prototype, 10627 // but that could be a zero-parameter prototype 10628 if (TypeSourceInfo *TI = 10629 PossibleZeroParamPrototype->getTypeSourceInfo()) { 10630 TypeLoc TL = TI->getTypeLoc(); 10631 if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>()) 10632 Diag(PossibleZeroParamPrototype->getLocation(), 10633 diag::note_declaration_not_a_prototype) 10634 << PossibleZeroParamPrototype 10635 << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void"); 10636 } 10637 } 10638 } 10639 10640 if (auto *MD = dyn_cast<CXXMethodDecl>(FD)) { 10641 const CXXMethodDecl *KeyFunction; 10642 if (MD->isOutOfLine() && (MD = MD->getCanonicalDecl()) && 10643 MD->isVirtual() && 10644 (KeyFunction = Context.getCurrentKeyFunction(MD->getParent())) && 10645 MD == KeyFunction->getCanonicalDecl()) { 10646 // Update the key-function state if necessary for this ABI. 10647 if (FD->isInlined() && 10648 !Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) { 10649 Context.setNonKeyFunction(MD); 10650 10651 // If the newly-chosen key function is already defined, then we 10652 // need to mark the vtable as used retroactively. 10653 KeyFunction = Context.getCurrentKeyFunction(MD->getParent()); 10654 const FunctionDecl *Definition; 10655 if (KeyFunction && KeyFunction->isDefined(Definition)) 10656 MarkVTableUsed(Definition->getLocation(), MD->getParent(), true); 10657 } else { 10658 // We just defined they key function; mark the vtable as used. 10659 MarkVTableUsed(FD->getLocation(), MD->getParent(), true); 10660 } 10661 } 10662 } 10663 10664 assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) && 10665 "Function parsing confused"); 10666 } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) { 10667 assert(MD == getCurMethodDecl() && "Method parsing confused"); 10668 MD->setBody(Body); 10669 if (!MD->isInvalidDecl()) { 10670 DiagnoseUnusedParameters(MD->param_begin(), MD->param_end()); 10671 DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(), 10672 MD->getReturnType(), MD); 10673 10674 if (Body) 10675 computeNRVO(Body, getCurFunction()); 10676 } 10677 if (getCurFunction()->ObjCShouldCallSuper) { 10678 Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call) 10679 << MD->getSelector().getAsString(); 10680 getCurFunction()->ObjCShouldCallSuper = false; 10681 } 10682 if (getCurFunction()->ObjCWarnForNoDesignatedInitChain) { 10683 const ObjCMethodDecl *InitMethod = nullptr; 10684 bool isDesignated = 10685 MD->isDesignatedInitializerForTheInterface(&InitMethod); 10686 assert(isDesignated && InitMethod); 10687 (void)isDesignated; 10688 10689 auto superIsNSObject = [&](const ObjCMethodDecl *MD) { 10690 auto IFace = MD->getClassInterface(); 10691 if (!IFace) 10692 return false; 10693 auto SuperD = IFace->getSuperClass(); 10694 if (!SuperD) 10695 return false; 10696 return SuperD->getIdentifier() == 10697 NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject); 10698 }; 10699 // Don't issue this warning for unavailable inits or direct subclasses 10700 // of NSObject. 10701 if (!MD->isUnavailable() && !superIsNSObject(MD)) { 10702 Diag(MD->getLocation(), 10703 diag::warn_objc_designated_init_missing_super_call); 10704 Diag(InitMethod->getLocation(), 10705 diag::note_objc_designated_init_marked_here); 10706 } 10707 getCurFunction()->ObjCWarnForNoDesignatedInitChain = false; 10708 } 10709 if (getCurFunction()->ObjCWarnForNoInitDelegation) { 10710 // Don't issue this warning for unavaialable inits. 10711 if (!MD->isUnavailable()) 10712 Diag(MD->getLocation(), 10713 diag::warn_objc_secondary_init_missing_init_call); 10714 getCurFunction()->ObjCWarnForNoInitDelegation = false; 10715 } 10716 } else { 10717 return nullptr; 10718 } 10719 10720 assert(!getCurFunction()->ObjCShouldCallSuper && 10721 "This should only be set for ObjC methods, which should have been " 10722 "handled in the block above."); 10723 10724 // Verify and clean out per-function state. 10725 if (Body && (!FD || !FD->isDefaulted())) { 10726 // C++ constructors that have function-try-blocks can't have return 10727 // statements in the handlers of that block. (C++ [except.handle]p14) 10728 // Verify this. 10729 if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body)) 10730 DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body)); 10731 10732 // Verify that gotos and switch cases don't jump into scopes illegally. 10733 if (getCurFunction()->NeedsScopeChecking() && 10734 !PP.isCodeCompletionEnabled()) 10735 DiagnoseInvalidJumps(Body); 10736 10737 if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) { 10738 if (!Destructor->getParent()->isDependentType()) 10739 CheckDestructor(Destructor); 10740 10741 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(), 10742 Destructor->getParent()); 10743 } 10744 10745 // If any errors have occurred, clear out any temporaries that may have 10746 // been leftover. This ensures that these temporaries won't be picked up for 10747 // deletion in some later function. 10748 if (getDiagnostics().hasErrorOccurred() || 10749 getDiagnostics().getSuppressAllDiagnostics()) { 10750 DiscardCleanupsInEvaluationContext(); 10751 } 10752 if (!getDiagnostics().hasUncompilableErrorOccurred() && 10753 !isa<FunctionTemplateDecl>(dcl)) { 10754 // Since the body is valid, issue any analysis-based warnings that are 10755 // enabled. 10756 ActivePolicy = &WP; 10757 } 10758 10759 if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() && 10760 (!CheckConstexprFunctionDecl(FD) || 10761 !CheckConstexprFunctionBody(FD, Body))) 10762 FD->setInvalidDecl(); 10763 10764 if (FD && FD->hasAttr<NakedAttr>()) { 10765 for (const Stmt *S : Body->children()) { 10766 if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) { 10767 Diag(S->getLocStart(), diag::err_non_asm_stmt_in_naked_function); 10768 Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute); 10769 FD->setInvalidDecl(); 10770 break; 10771 } 10772 } 10773 } 10774 10775 assert(ExprCleanupObjects.size() == 10776 ExprEvalContexts.back().NumCleanupObjects && 10777 "Leftover temporaries in function"); 10778 assert(!ExprNeedsCleanups && "Unaccounted cleanups in function"); 10779 assert(MaybeODRUseExprs.empty() && 10780 "Leftover expressions for odr-use checking"); 10781 } 10782 10783 if (!IsInstantiation) 10784 PopDeclContext(); 10785 10786 PopFunctionScopeInfo(ActivePolicy, dcl); 10787 // If any errors have occurred, clear out any temporaries that may have 10788 // been leftover. This ensures that these temporaries won't be picked up for 10789 // deletion in some later function. 10790 if (getDiagnostics().hasErrorOccurred()) { 10791 DiscardCleanupsInEvaluationContext(); 10792 } 10793 10794 return dcl; 10795 } 10796 10797 10798 /// When we finish delayed parsing of an attribute, we must attach it to the 10799 /// relevant Decl. 10800 void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D, 10801 ParsedAttributes &Attrs) { 10802 // Always attach attributes to the underlying decl. 10803 if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D)) 10804 D = TD->getTemplatedDecl(); 10805 ProcessDeclAttributeList(S, D, Attrs.getList()); 10806 10807 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D)) 10808 if (Method->isStatic()) 10809 checkThisInStaticMemberFunctionAttributes(Method); 10810 } 10811 10812 10813 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function 10814 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2). 10815 NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, 10816 IdentifierInfo &II, Scope *S) { 10817 // Before we produce a declaration for an implicitly defined 10818 // function, see whether there was a locally-scoped declaration of 10819 // this name as a function or variable. If so, use that 10820 // (non-visible) declaration, and complain about it. 10821 if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) { 10822 Diag(Loc, diag::warn_use_out_of_scope_declaration) << ExternCPrev; 10823 Diag(ExternCPrev->getLocation(), diag::note_previous_declaration); 10824 return ExternCPrev; 10825 } 10826 10827 // Extension in C99. Legal in C90, but warn about it. 10828 unsigned diag_id; 10829 if (II.getName().startswith("__builtin_")) 10830 diag_id = diag::warn_builtin_unknown; 10831 else if (getLangOpts().C99) 10832 diag_id = diag::ext_implicit_function_decl; 10833 else 10834 diag_id = diag::warn_implicit_function_decl; 10835 Diag(Loc, diag_id) << &II; 10836 10837 // Because typo correction is expensive, only do it if the implicit 10838 // function declaration is going to be treated as an error. 10839 if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) { 10840 TypoCorrection Corrected; 10841 if (S && 10842 (Corrected = CorrectTypo( 10843 DeclarationNameInfo(&II, Loc), LookupOrdinaryName, S, nullptr, 10844 llvm::make_unique<DeclFilterCCC<FunctionDecl>>(), CTK_NonError))) 10845 diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion), 10846 /*ErrorRecovery*/false); 10847 } 10848 10849 // Set a Declarator for the implicit definition: int foo(); 10850 const char *Dummy; 10851 AttributeFactory attrFactory; 10852 DeclSpec DS(attrFactory); 10853 unsigned DiagID; 10854 bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID, 10855 Context.getPrintingPolicy()); 10856 (void)Error; // Silence warning. 10857 assert(!Error && "Error setting up implicit decl!"); 10858 SourceLocation NoLoc; 10859 Declarator D(DS, Declarator::BlockContext); 10860 D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false, 10861 /*IsAmbiguous=*/false, 10862 /*LParenLoc=*/NoLoc, 10863 /*Params=*/nullptr, 10864 /*NumParams=*/0, 10865 /*EllipsisLoc=*/NoLoc, 10866 /*RParenLoc=*/NoLoc, 10867 /*TypeQuals=*/0, 10868 /*RefQualifierIsLvalueRef=*/true, 10869 /*RefQualifierLoc=*/NoLoc, 10870 /*ConstQualifierLoc=*/NoLoc, 10871 /*VolatileQualifierLoc=*/NoLoc, 10872 /*RestrictQualifierLoc=*/NoLoc, 10873 /*MutableLoc=*/NoLoc, 10874 EST_None, 10875 /*ESpecLoc=*/NoLoc, 10876 /*Exceptions=*/nullptr, 10877 /*ExceptionRanges=*/nullptr, 10878 /*NumExceptions=*/0, 10879 /*NoexceptExpr=*/nullptr, 10880 /*ExceptionSpecTokens=*/nullptr, 10881 Loc, Loc, D), 10882 DS.getAttributes(), 10883 SourceLocation()); 10884 D.SetIdentifier(&II, Loc); 10885 10886 // Insert this function into translation-unit scope. 10887 10888 DeclContext *PrevDC = CurContext; 10889 CurContext = Context.getTranslationUnitDecl(); 10890 10891 FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D)); 10892 FD->setImplicit(); 10893 10894 CurContext = PrevDC; 10895 10896 AddKnownFunctionAttributes(FD); 10897 10898 return FD; 10899 } 10900 10901 /// \brief Adds any function attributes that we know a priori based on 10902 /// the declaration of this function. 10903 /// 10904 /// These attributes can apply both to implicitly-declared builtins 10905 /// (like __builtin___printf_chk) or to library-declared functions 10906 /// like NSLog or printf. 10907 /// 10908 /// We need to check for duplicate attributes both here and where user-written 10909 /// attributes are applied to declarations. 10910 void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) { 10911 if (FD->isInvalidDecl()) 10912 return; 10913 10914 // If this is a built-in function, map its builtin attributes to 10915 // actual attributes. 10916 if (unsigned BuiltinID = FD->getBuiltinID()) { 10917 // Handle printf-formatting attributes. 10918 unsigned FormatIdx; 10919 bool HasVAListArg; 10920 if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) { 10921 if (!FD->hasAttr<FormatAttr>()) { 10922 const char *fmt = "printf"; 10923 unsigned int NumParams = FD->getNumParams(); 10924 if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf) 10925 FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType()) 10926 fmt = "NSString"; 10927 FD->addAttr(FormatAttr::CreateImplicit(Context, 10928 &Context.Idents.get(fmt), 10929 FormatIdx+1, 10930 HasVAListArg ? 0 : FormatIdx+2, 10931 FD->getLocation())); 10932 } 10933 } 10934 if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx, 10935 HasVAListArg)) { 10936 if (!FD->hasAttr<FormatAttr>()) 10937 FD->addAttr(FormatAttr::CreateImplicit(Context, 10938 &Context.Idents.get("scanf"), 10939 FormatIdx+1, 10940 HasVAListArg ? 0 : FormatIdx+2, 10941 FD->getLocation())); 10942 } 10943 10944 // Mark const if we don't care about errno and that is the only 10945 // thing preventing the function from being const. This allows 10946 // IRgen to use LLVM intrinsics for such functions. 10947 if (!getLangOpts().MathErrno && 10948 Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) { 10949 if (!FD->hasAttr<ConstAttr>()) 10950 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation())); 10951 } 10952 10953 if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) && 10954 !FD->hasAttr<ReturnsTwiceAttr>()) 10955 FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context, 10956 FD->getLocation())); 10957 if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>()) 10958 FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation())); 10959 if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>()) 10960 FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation())); 10961 } 10962 10963 IdentifierInfo *Name = FD->getIdentifier(); 10964 if (!Name) 10965 return; 10966 if ((!getLangOpts().CPlusPlus && 10967 FD->getDeclContext()->isTranslationUnit()) || 10968 (isa<LinkageSpecDecl>(FD->getDeclContext()) && 10969 cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() == 10970 LinkageSpecDecl::lang_c)) { 10971 // Okay: this could be a libc/libm/Objective-C function we know 10972 // about. 10973 } else 10974 return; 10975 10976 if (Name->isStr("asprintf") || Name->isStr("vasprintf")) { 10977 // FIXME: asprintf and vasprintf aren't C99 functions. Should they be 10978 // target-specific builtins, perhaps? 10979 if (!FD->hasAttr<FormatAttr>()) 10980 FD->addAttr(FormatAttr::CreateImplicit(Context, 10981 &Context.Idents.get("printf"), 2, 10982 Name->isStr("vasprintf") ? 0 : 3, 10983 FD->getLocation())); 10984 } 10985 10986 if (Name->isStr("__CFStringMakeConstantString")) { 10987 // We already have a __builtin___CFStringMakeConstantString, 10988 // but builds that use -fno-constant-cfstrings don't go through that. 10989 if (!FD->hasAttr<FormatArgAttr>()) 10990 FD->addAttr(FormatArgAttr::CreateImplicit(Context, 1, 10991 FD->getLocation())); 10992 } 10993 } 10994 10995 TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, 10996 TypeSourceInfo *TInfo) { 10997 assert(D.getIdentifier() && "Wrong callback for declspec without declarator"); 10998 assert(!T.isNull() && "GetTypeForDeclarator() returned null type"); 10999 11000 if (!TInfo) { 11001 assert(D.isInvalidType() && "no declarator info for valid type"); 11002 TInfo = Context.getTrivialTypeSourceInfo(T); 11003 } 11004 11005 // Scope manipulation handled by caller. 11006 TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext, 11007 D.getLocStart(), 11008 D.getIdentifierLoc(), 11009 D.getIdentifier(), 11010 TInfo); 11011 11012 // Bail out immediately if we have an invalid declaration. 11013 if (D.isInvalidType()) { 11014 NewTD->setInvalidDecl(); 11015 return NewTD; 11016 } 11017 11018 if (D.getDeclSpec().isModulePrivateSpecified()) { 11019 if (CurContext->isFunctionOrMethod()) 11020 Diag(NewTD->getLocation(), diag::err_module_private_local) 11021 << 2 << NewTD->getDeclName() 11022 << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc()) 11023 << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc()); 11024 else 11025 NewTD->setModulePrivate(); 11026 } 11027 11028 // C++ [dcl.typedef]p8: 11029 // If the typedef declaration defines an unnamed class (or 11030 // enum), the first typedef-name declared by the declaration 11031 // to be that class type (or enum type) is used to denote the 11032 // class type (or enum type) for linkage purposes only. 11033 // We need to check whether the type was declared in the declaration. 11034 switch (D.getDeclSpec().getTypeSpecType()) { 11035 case TST_enum: 11036 case TST_struct: 11037 case TST_interface: 11038 case TST_union: 11039 case TST_class: { 11040 TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl()); 11041 setTagNameForLinkagePurposes(tagFromDeclSpec, NewTD); 11042 break; 11043 } 11044 11045 default: 11046 break; 11047 } 11048 11049 return NewTD; 11050 } 11051 11052 11053 /// \brief Check that this is a valid underlying type for an enum declaration. 11054 bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) { 11055 SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc(); 11056 QualType T = TI->getType(); 11057 11058 if (T->isDependentType()) 11059 return false; 11060 11061 if (const BuiltinType *BT = T->getAs<BuiltinType>()) 11062 if (BT->isInteger()) 11063 return false; 11064 11065 Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T; 11066 return true; 11067 } 11068 11069 /// Check whether this is a valid redeclaration of a previous enumeration. 11070 /// \return true if the redeclaration was invalid. 11071 bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, 11072 QualType EnumUnderlyingTy, 11073 const EnumDecl *Prev) { 11074 bool IsFixed = !EnumUnderlyingTy.isNull(); 11075 11076 if (IsScoped != Prev->isScoped()) { 11077 Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch) 11078 << Prev->isScoped(); 11079 Diag(Prev->getLocation(), diag::note_previous_declaration); 11080 return true; 11081 } 11082 11083 if (IsFixed && Prev->isFixed()) { 11084 if (!EnumUnderlyingTy->isDependentType() && 11085 !Prev->getIntegerType()->isDependentType() && 11086 !Context.hasSameUnqualifiedType(EnumUnderlyingTy, 11087 Prev->getIntegerType())) { 11088 // TODO: Highlight the underlying type of the redeclaration. 11089 Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch) 11090 << EnumUnderlyingTy << Prev->getIntegerType(); 11091 Diag(Prev->getLocation(), diag::note_previous_declaration) 11092 << Prev->getIntegerTypeRange(); 11093 return true; 11094 } 11095 } else if (IsFixed != Prev->isFixed()) { 11096 Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch) 11097 << Prev->isFixed(); 11098 Diag(Prev->getLocation(), diag::note_previous_declaration); 11099 return true; 11100 } 11101 11102 return false; 11103 } 11104 11105 /// \brief Get diagnostic %select index for tag kind for 11106 /// redeclaration diagnostic message. 11107 /// WARNING: Indexes apply to particular diagnostics only! 11108 /// 11109 /// \returns diagnostic %select index. 11110 static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) { 11111 switch (Tag) { 11112 case TTK_Struct: return 0; 11113 case TTK_Interface: return 1; 11114 case TTK_Class: return 2; 11115 default: llvm_unreachable("Invalid tag kind for redecl diagnostic!"); 11116 } 11117 } 11118 11119 /// \brief Determine if tag kind is a class-key compatible with 11120 /// class for redeclaration (class, struct, or __interface). 11121 /// 11122 /// \returns true iff the tag kind is compatible. 11123 static bool isClassCompatTagKind(TagTypeKind Tag) 11124 { 11125 return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface; 11126 } 11127 11128 /// \brief Determine whether a tag with a given kind is acceptable 11129 /// as a redeclaration of the given tag declaration. 11130 /// 11131 /// \returns true if the new tag kind is acceptable, false otherwise. 11132 bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous, 11133 TagTypeKind NewTag, bool isDefinition, 11134 SourceLocation NewTagLoc, 11135 const IdentifierInfo &Name) { 11136 // C++ [dcl.type.elab]p3: 11137 // The class-key or enum keyword present in the 11138 // elaborated-type-specifier shall agree in kind with the 11139 // declaration to which the name in the elaborated-type-specifier 11140 // refers. This rule also applies to the form of 11141 // elaborated-type-specifier that declares a class-name or 11142 // friend class since it can be construed as referring to the 11143 // definition of the class. Thus, in any 11144 // elaborated-type-specifier, the enum keyword shall be used to 11145 // refer to an enumeration (7.2), the union class-key shall be 11146 // used to refer to a union (clause 9), and either the class or 11147 // struct class-key shall be used to refer to a class (clause 9) 11148 // declared using the class or struct class-key. 11149 TagTypeKind OldTag = Previous->getTagKind(); 11150 if (!isDefinition || !isClassCompatTagKind(NewTag)) 11151 if (OldTag == NewTag) 11152 return true; 11153 11154 if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) { 11155 // Warn about the struct/class tag mismatch. 11156 bool isTemplate = false; 11157 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous)) 11158 isTemplate = Record->getDescribedClassTemplate(); 11159 11160 if (!ActiveTemplateInstantiations.empty()) { 11161 // In a template instantiation, do not offer fix-its for tag mismatches 11162 // since they usually mess up the template instead of fixing the problem. 11163 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 11164 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 11165 << getRedeclDiagFromTagKind(OldTag); 11166 return true; 11167 } 11168 11169 if (isDefinition) { 11170 // On definitions, check previous tags and issue a fix-it for each 11171 // one that doesn't match the current tag. 11172 if (Previous->getDefinition()) { 11173 // Don't suggest fix-its for redefinitions. 11174 return true; 11175 } 11176 11177 bool previousMismatch = false; 11178 for (auto I : Previous->redecls()) { 11179 if (I->getTagKind() != NewTag) { 11180 if (!previousMismatch) { 11181 previousMismatch = true; 11182 Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch) 11183 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 11184 << getRedeclDiagFromTagKind(I->getTagKind()); 11185 } 11186 Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion) 11187 << getRedeclDiagFromTagKind(NewTag) 11188 << FixItHint::CreateReplacement(I->getInnerLocStart(), 11189 TypeWithKeyword::getTagTypeKindName(NewTag)); 11190 } 11191 } 11192 return true; 11193 } 11194 11195 // Check for a previous definition. If current tag and definition 11196 // are same type, do nothing. If no definition, but disagree with 11197 // with previous tag type, give a warning, but no fix-it. 11198 const TagDecl *Redecl = Previous->getDefinition() ? 11199 Previous->getDefinition() : Previous; 11200 if (Redecl->getTagKind() == NewTag) { 11201 return true; 11202 } 11203 11204 Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch) 11205 << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name 11206 << getRedeclDiagFromTagKind(OldTag); 11207 Diag(Redecl->getLocation(), diag::note_previous_use); 11208 11209 // If there is a previous definition, suggest a fix-it. 11210 if (Previous->getDefinition()) { 11211 Diag(NewTagLoc, diag::note_struct_class_suggestion) 11212 << getRedeclDiagFromTagKind(Redecl->getTagKind()) 11213 << FixItHint::CreateReplacement(SourceRange(NewTagLoc), 11214 TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind())); 11215 } 11216 11217 return true; 11218 } 11219 return false; 11220 } 11221 11222 /// Add a minimal nested name specifier fixit hint to allow lookup of a tag name 11223 /// from an outer enclosing namespace or file scope inside a friend declaration. 11224 /// This should provide the commented out code in the following snippet: 11225 /// namespace N { 11226 /// struct X; 11227 /// namespace M { 11228 /// struct Y { friend struct /*N::*/ X; }; 11229 /// } 11230 /// } 11231 static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, 11232 SourceLocation NameLoc) { 11233 // While the decl is in a namespace, do repeated lookup of that name and see 11234 // if we get the same namespace back. If we do not, continue until 11235 // translation unit scope, at which point we have a fully qualified NNS. 11236 SmallVector<IdentifierInfo *, 4> Namespaces; 11237 DeclContext *DC = ND->getDeclContext()->getRedeclContext(); 11238 for (; !DC->isTranslationUnit(); DC = DC->getParent()) { 11239 // This tag should be declared in a namespace, which can only be enclosed by 11240 // other namespaces. Bail if there's an anonymous namespace in the chain. 11241 NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC); 11242 if (!Namespace || Namespace->isAnonymousNamespace()) 11243 return FixItHint(); 11244 IdentifierInfo *II = Namespace->getIdentifier(); 11245 Namespaces.push_back(II); 11246 NamedDecl *Lookup = SemaRef.LookupSingleName( 11247 S, II, NameLoc, Sema::LookupNestedNameSpecifierName); 11248 if (Lookup == Namespace) 11249 break; 11250 } 11251 11252 // Once we have all the namespaces, reverse them to go outermost first, and 11253 // build an NNS. 11254 SmallString<64> Insertion; 11255 llvm::raw_svector_ostream OS(Insertion); 11256 if (DC->isTranslationUnit()) 11257 OS << "::"; 11258 std::reverse(Namespaces.begin(), Namespaces.end()); 11259 for (auto *II : Namespaces) 11260 OS << II->getName() << "::"; 11261 OS.flush(); 11262 return FixItHint::CreateInsertion(NameLoc, Insertion); 11263 } 11264 11265 /// \brief This is invoked when we see 'struct foo' or 'struct {'. In the 11266 /// former case, Name will be non-null. In the later case, Name will be null. 11267 /// TagSpec indicates what kind of tag this is. TUK indicates whether this is a 11268 /// reference/declaration/definition of a tag. 11269 /// 11270 /// \param IsTypeSpecifier \c true if this is a type-specifier (or 11271 /// trailing-type-specifier) other than one in an alias-declaration. 11272 /// 11273 /// \param SkipBody If non-null, will be set to true if the caller should skip 11274 /// the definition of this tag, and treat it as if it were a declaration. 11275 Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, 11276 SourceLocation KWLoc, CXXScopeSpec &SS, 11277 IdentifierInfo *Name, SourceLocation NameLoc, 11278 AttributeList *Attr, AccessSpecifier AS, 11279 SourceLocation ModulePrivateLoc, 11280 MultiTemplateParamsArg TemplateParameterLists, 11281 bool &OwnedDecl, bool &IsDependent, 11282 SourceLocation ScopedEnumKWLoc, 11283 bool ScopedEnumUsesClassTag, 11284 TypeResult UnderlyingType, 11285 bool IsTypeSpecifier, bool *SkipBody) { 11286 // If this is not a definition, it must have a name. 11287 IdentifierInfo *OrigName = Name; 11288 assert((Name != nullptr || TUK == TUK_Definition) && 11289 "Nameless record must be a definition!"); 11290 assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference); 11291 11292 OwnedDecl = false; 11293 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec); 11294 bool ScopedEnum = ScopedEnumKWLoc.isValid(); 11295 11296 // FIXME: Check explicit specializations more carefully. 11297 bool isExplicitSpecialization = false; 11298 bool Invalid = false; 11299 11300 // We only need to do this matching if we have template parameters 11301 // or a scope specifier, which also conveniently avoids this work 11302 // for non-C++ cases. 11303 if (TemplateParameterLists.size() > 0 || 11304 (SS.isNotEmpty() && TUK != TUK_Reference)) { 11305 if (TemplateParameterList *TemplateParams = 11306 MatchTemplateParametersToScopeSpecifier( 11307 KWLoc, NameLoc, SS, nullptr, TemplateParameterLists, 11308 TUK == TUK_Friend, isExplicitSpecialization, Invalid)) { 11309 if (Kind == TTK_Enum) { 11310 Diag(KWLoc, diag::err_enum_template); 11311 return nullptr; 11312 } 11313 11314 if (TemplateParams->size() > 0) { 11315 // This is a declaration or definition of a class template (which may 11316 // be a member of another template). 11317 11318 if (Invalid) 11319 return nullptr; 11320 11321 OwnedDecl = false; 11322 DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc, 11323 SS, Name, NameLoc, Attr, 11324 TemplateParams, AS, 11325 ModulePrivateLoc, 11326 /*FriendLoc*/SourceLocation(), 11327 TemplateParameterLists.size()-1, 11328 TemplateParameterLists.data(), 11329 SkipBody); 11330 return Result.get(); 11331 } else { 11332 // The "template<>" header is extraneous. 11333 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams) 11334 << TypeWithKeyword::getTagTypeKindName(Kind) << Name; 11335 isExplicitSpecialization = true; 11336 } 11337 } 11338 } 11339 11340 // Figure out the underlying type if this a enum declaration. We need to do 11341 // this early, because it's needed to detect if this is an incompatible 11342 // redeclaration. 11343 llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying; 11344 11345 if (Kind == TTK_Enum) { 11346 if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum)) 11347 // No underlying type explicitly specified, or we failed to parse the 11348 // type, default to int. 11349 EnumUnderlying = Context.IntTy.getTypePtr(); 11350 else if (UnderlyingType.get()) { 11351 // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an 11352 // integral type; any cv-qualification is ignored. 11353 TypeSourceInfo *TI = nullptr; 11354 GetTypeFromParser(UnderlyingType.get(), &TI); 11355 EnumUnderlying = TI; 11356 11357 if (CheckEnumUnderlyingType(TI)) 11358 // Recover by falling back to int. 11359 EnumUnderlying = Context.IntTy.getTypePtr(); 11360 11361 if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI, 11362 UPPC_FixedUnderlyingType)) 11363 EnumUnderlying = Context.IntTy.getTypePtr(); 11364 11365 } else if (getLangOpts().MSVCCompat) 11366 // Microsoft enums are always of int type. 11367 EnumUnderlying = Context.IntTy.getTypePtr(); 11368 } 11369 11370 DeclContext *SearchDC = CurContext; 11371 DeclContext *DC = CurContext; 11372 bool isStdBadAlloc = false; 11373 11374 RedeclarationKind Redecl = ForRedeclaration; 11375 if (TUK == TUK_Friend || TUK == TUK_Reference) 11376 Redecl = NotForRedeclaration; 11377 11378 LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl); 11379 if (Name && SS.isNotEmpty()) { 11380 // We have a nested-name tag ('struct foo::bar'). 11381 11382 // Check for invalid 'foo::'. 11383 if (SS.isInvalid()) { 11384 Name = nullptr; 11385 goto CreateNewDecl; 11386 } 11387 11388 // If this is a friend or a reference to a class in a dependent 11389 // context, don't try to make a decl for it. 11390 if (TUK == TUK_Friend || TUK == TUK_Reference) { 11391 DC = computeDeclContext(SS, false); 11392 if (!DC) { 11393 IsDependent = true; 11394 return nullptr; 11395 } 11396 } else { 11397 DC = computeDeclContext(SS, true); 11398 if (!DC) { 11399 Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec) 11400 << SS.getRange(); 11401 return nullptr; 11402 } 11403 } 11404 11405 if (RequireCompleteDeclContext(SS, DC)) 11406 return nullptr; 11407 11408 SearchDC = DC; 11409 // Look-up name inside 'foo::'. 11410 LookupQualifiedName(Previous, DC); 11411 11412 if (Previous.isAmbiguous()) 11413 return nullptr; 11414 11415 if (Previous.empty()) { 11416 // Name lookup did not find anything. However, if the 11417 // nested-name-specifier refers to the current instantiation, 11418 // and that current instantiation has any dependent base 11419 // classes, we might find something at instantiation time: treat 11420 // this as a dependent elaborated-type-specifier. 11421 // But this only makes any sense for reference-like lookups. 11422 if (Previous.wasNotFoundInCurrentInstantiation() && 11423 (TUK == TUK_Reference || TUK == TUK_Friend)) { 11424 IsDependent = true; 11425 return nullptr; 11426 } 11427 11428 // A tag 'foo::bar' must already exist. 11429 Diag(NameLoc, diag::err_not_tag_in_scope) 11430 << Kind << Name << DC << SS.getRange(); 11431 Name = nullptr; 11432 Invalid = true; 11433 goto CreateNewDecl; 11434 } 11435 } else if (Name) { 11436 // If this is a named struct, check to see if there was a previous forward 11437 // declaration or definition. 11438 // FIXME: We're looking into outer scopes here, even when we 11439 // shouldn't be. Doing so can result in ambiguities that we 11440 // shouldn't be diagnosing. 11441 LookupName(Previous, S); 11442 11443 // When declaring or defining a tag, ignore ambiguities introduced 11444 // by types using'ed into this scope. 11445 if (Previous.isAmbiguous() && 11446 (TUK == TUK_Definition || TUK == TUK_Declaration)) { 11447 LookupResult::Filter F = Previous.makeFilter(); 11448 while (F.hasNext()) { 11449 NamedDecl *ND = F.next(); 11450 if (ND->getDeclContext()->getRedeclContext() != SearchDC) 11451 F.erase(); 11452 } 11453 F.done(); 11454 } 11455 11456 // C++11 [namespace.memdef]p3: 11457 // If the name in a friend declaration is neither qualified nor 11458 // a template-id and the declaration is a function or an 11459 // elaborated-type-specifier, the lookup to determine whether 11460 // the entity has been previously declared shall not consider 11461 // any scopes outside the innermost enclosing namespace. 11462 // 11463 // MSVC doesn't implement the above rule for types, so a friend tag 11464 // declaration may be a redeclaration of a type declared in an enclosing 11465 // scope. They do implement this rule for friend functions. 11466 // 11467 // Does it matter that this should be by scope instead of by 11468 // semantic context? 11469 if (!Previous.empty() && TUK == TUK_Friend) { 11470 DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext(); 11471 LookupResult::Filter F = Previous.makeFilter(); 11472 bool FriendSawTagOutsideEnclosingNamespace = false; 11473 while (F.hasNext()) { 11474 NamedDecl *ND = F.next(); 11475 DeclContext *DC = ND->getDeclContext()->getRedeclContext(); 11476 if (DC->isFileContext() && 11477 !EnclosingNS->Encloses(ND->getDeclContext())) { 11478 if (getLangOpts().MSVCCompat) 11479 FriendSawTagOutsideEnclosingNamespace = true; 11480 else 11481 F.erase(); 11482 } 11483 } 11484 F.done(); 11485 11486 // Diagnose this MSVC extension in the easy case where lookup would have 11487 // unambiguously found something outside the enclosing namespace. 11488 if (Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) { 11489 NamedDecl *ND = Previous.getFoundDecl(); 11490 Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace) 11491 << createFriendTagNNSFixIt(*this, ND, S, NameLoc); 11492 } 11493 } 11494 11495 // Note: there used to be some attempt at recovery here. 11496 if (Previous.isAmbiguous()) 11497 return nullptr; 11498 11499 if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) { 11500 // FIXME: This makes sure that we ignore the contexts associated 11501 // with C structs, unions, and enums when looking for a matching 11502 // tag declaration or definition. See the similar lookup tweak 11503 // in Sema::LookupName; is there a better way to deal with this? 11504 while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC)) 11505 SearchDC = SearchDC->getParent(); 11506 } 11507 } 11508 11509 if (Previous.isSingleResult() && 11510 Previous.getFoundDecl()->isTemplateParameter()) { 11511 // Maybe we will complain about the shadowed template parameter. 11512 DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl()); 11513 // Just pretend that we didn't see the previous declaration. 11514 Previous.clear(); 11515 } 11516 11517 if (getLangOpts().CPlusPlus && Name && DC && StdNamespace && 11518 DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) { 11519 // This is a declaration of or a reference to "std::bad_alloc". 11520 isStdBadAlloc = true; 11521 11522 if (Previous.empty() && StdBadAlloc) { 11523 // std::bad_alloc has been implicitly declared (but made invisible to 11524 // name lookup). Fill in this implicit declaration as the previous 11525 // declaration, so that the declarations get chained appropriately. 11526 Previous.addDecl(getStdBadAlloc()); 11527 } 11528 } 11529 11530 // If we didn't find a previous declaration, and this is a reference 11531 // (or friend reference), move to the correct scope. In C++, we 11532 // also need to do a redeclaration lookup there, just in case 11533 // there's a shadow friend decl. 11534 if (Name && Previous.empty() && 11535 (TUK == TUK_Reference || TUK == TUK_Friend)) { 11536 if (Invalid) goto CreateNewDecl; 11537 assert(SS.isEmpty()); 11538 11539 if (TUK == TUK_Reference) { 11540 // C++ [basic.scope.pdecl]p5: 11541 // -- for an elaborated-type-specifier of the form 11542 // 11543 // class-key identifier 11544 // 11545 // if the elaborated-type-specifier is used in the 11546 // decl-specifier-seq or parameter-declaration-clause of a 11547 // function defined in namespace scope, the identifier is 11548 // declared as a class-name in the namespace that contains 11549 // the declaration; otherwise, except as a friend 11550 // declaration, the identifier is declared in the smallest 11551 // non-class, non-function-prototype scope that contains the 11552 // declaration. 11553 // 11554 // C99 6.7.2.3p8 has a similar (but not identical!) provision for 11555 // C structs and unions. 11556 // 11557 // It is an error in C++ to declare (rather than define) an enum 11558 // type, including via an elaborated type specifier. We'll 11559 // diagnose that later; for now, declare the enum in the same 11560 // scope as we would have picked for any other tag type. 11561 // 11562 // GNU C also supports this behavior as part of its incomplete 11563 // enum types extension, while GNU C++ does not. 11564 // 11565 // Find the context where we'll be declaring the tag. 11566 // FIXME: We would like to maintain the current DeclContext as the 11567 // lexical context, 11568 while (!SearchDC->isFileContext() && !SearchDC->isFunctionOrMethod()) 11569 SearchDC = SearchDC->getParent(); 11570 11571 // Find the scope where we'll be declaring the tag. 11572 while (S->isClassScope() || 11573 (getLangOpts().CPlusPlus && 11574 S->isFunctionPrototypeScope()) || 11575 ((S->getFlags() & Scope::DeclScope) == 0) || 11576 (S->getEntity() && S->getEntity()->isTransparentContext())) 11577 S = S->getParent(); 11578 } else { 11579 assert(TUK == TUK_Friend); 11580 // C++ [namespace.memdef]p3: 11581 // If a friend declaration in a non-local class first declares a 11582 // class or function, the friend class or function is a member of 11583 // the innermost enclosing namespace. 11584 SearchDC = SearchDC->getEnclosingNamespaceContext(); 11585 } 11586 11587 // In C++, we need to do a redeclaration lookup to properly 11588 // diagnose some problems. 11589 if (getLangOpts().CPlusPlus) { 11590 Previous.setRedeclarationKind(ForRedeclaration); 11591 LookupQualifiedName(Previous, SearchDC); 11592 } 11593 } 11594 11595 if (!Previous.empty()) { 11596 NamedDecl *PrevDecl = Previous.getFoundDecl(); 11597 NamedDecl *DirectPrevDecl = 11598 getLangOpts().MSVCCompat ? *Previous.begin() : PrevDecl; 11599 11600 // It's okay to have a tag decl in the same scope as a typedef 11601 // which hides a tag decl in the same scope. Finding this 11602 // insanity with a redeclaration lookup can only actually happen 11603 // in C++. 11604 // 11605 // This is also okay for elaborated-type-specifiers, which is 11606 // technically forbidden by the current standard but which is 11607 // okay according to the likely resolution of an open issue; 11608 // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407 11609 if (getLangOpts().CPlusPlus) { 11610 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) { 11611 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) { 11612 TagDecl *Tag = TT->getDecl(); 11613 if (Tag->getDeclName() == Name && 11614 Tag->getDeclContext()->getRedeclContext() 11615 ->Equals(TD->getDeclContext()->getRedeclContext())) { 11616 PrevDecl = Tag; 11617 Previous.clear(); 11618 Previous.addDecl(Tag); 11619 Previous.resolveKind(); 11620 } 11621 } 11622 } 11623 } 11624 11625 if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) { 11626 // If this is a use of a previous tag, or if the tag is already declared 11627 // in the same scope (so that the definition/declaration completes or 11628 // rementions the tag), reuse the decl. 11629 if (TUK == TUK_Reference || TUK == TUK_Friend || 11630 isDeclInScope(DirectPrevDecl, SearchDC, S, 11631 SS.isNotEmpty() || isExplicitSpecialization)) { 11632 // Make sure that this wasn't declared as an enum and now used as a 11633 // struct or something similar. 11634 if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, 11635 TUK == TUK_Definition, KWLoc, 11636 *Name)) { 11637 bool SafeToContinue 11638 = (PrevTagDecl->getTagKind() != TTK_Enum && 11639 Kind != TTK_Enum); 11640 if (SafeToContinue) 11641 Diag(KWLoc, diag::err_use_with_wrong_tag) 11642 << Name 11643 << FixItHint::CreateReplacement(SourceRange(KWLoc), 11644 PrevTagDecl->getKindName()); 11645 else 11646 Diag(KWLoc, diag::err_use_with_wrong_tag) << Name; 11647 Diag(PrevTagDecl->getLocation(), diag::note_previous_use); 11648 11649 if (SafeToContinue) 11650 Kind = PrevTagDecl->getTagKind(); 11651 else { 11652 // Recover by making this an anonymous redefinition. 11653 Name = nullptr; 11654 Previous.clear(); 11655 Invalid = true; 11656 } 11657 } 11658 11659 if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) { 11660 const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl); 11661 11662 // If this is an elaborated-type-specifier for a scoped enumeration, 11663 // the 'class' keyword is not necessary and not permitted. 11664 if (TUK == TUK_Reference || TUK == TUK_Friend) { 11665 if (ScopedEnum) 11666 Diag(ScopedEnumKWLoc, diag::err_enum_class_reference) 11667 << PrevEnum->isScoped() 11668 << FixItHint::CreateRemoval(ScopedEnumKWLoc); 11669 return PrevTagDecl; 11670 } 11671 11672 QualType EnumUnderlyingTy; 11673 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 11674 EnumUnderlyingTy = TI->getType().getUnqualifiedType(); 11675 else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>()) 11676 EnumUnderlyingTy = QualType(T, 0); 11677 11678 // All conflicts with previous declarations are recovered by 11679 // returning the previous declaration, unless this is a definition, 11680 // in which case we want the caller to bail out. 11681 if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc, 11682 ScopedEnum, EnumUnderlyingTy, PrevEnum)) 11683 return TUK == TUK_Declaration ? PrevTagDecl : nullptr; 11684 } 11685 11686 // C++11 [class.mem]p1: 11687 // A member shall not be declared twice in the member-specification, 11688 // except that a nested class or member class template can be declared 11689 // and then later defined. 11690 if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() && 11691 S->isDeclScope(PrevDecl)) { 11692 Diag(NameLoc, diag::ext_member_redeclared); 11693 Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration); 11694 } 11695 11696 if (!Invalid) { 11697 // If this is a use, just return the declaration we found, unless 11698 // we have attributes. 11699 11700 // FIXME: In the future, return a variant or some other clue 11701 // for the consumer of this Decl to know it doesn't own it. 11702 // For our current ASTs this shouldn't be a problem, but will 11703 // need to be changed with DeclGroups. 11704 if (!Attr && 11705 ((TUK == TUK_Reference && 11706 (!PrevTagDecl->getFriendObjectKind() || getLangOpts().MicrosoftExt)) 11707 || TUK == TUK_Friend)) 11708 return PrevTagDecl; 11709 11710 // Diagnose attempts to redefine a tag. 11711 if (TUK == TUK_Definition) { 11712 if (NamedDecl *Def = PrevTagDecl->getDefinition()) { 11713 // If we're defining a specialization and the previous definition 11714 // is from an implicit instantiation, don't emit an error 11715 // here; we'll catch this in the general case below. 11716 bool IsExplicitSpecializationAfterInstantiation = false; 11717 if (isExplicitSpecialization) { 11718 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def)) 11719 IsExplicitSpecializationAfterInstantiation = 11720 RD->getTemplateSpecializationKind() != 11721 TSK_ExplicitSpecialization; 11722 else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def)) 11723 IsExplicitSpecializationAfterInstantiation = 11724 ED->getTemplateSpecializationKind() != 11725 TSK_ExplicitSpecialization; 11726 } 11727 11728 NamedDecl *Hidden = nullptr; 11729 if (SkipBody && getLangOpts().CPlusPlus && 11730 !hasVisibleDefinition(Def, &Hidden)) { 11731 // There is a definition of this tag, but it is not visible. We 11732 // explicitly make use of C++'s one definition rule here, and 11733 // assume that this definition is identical to the hidden one 11734 // we already have. Make the existing definition visible and 11735 // use it in place of this one. 11736 *SkipBody = true; 11737 if (auto *Listener = getASTMutationListener()) 11738 Listener->RedefinedHiddenDefinition(Hidden, KWLoc); 11739 Hidden->setHidden(false); 11740 return Def; 11741 } else if (!IsExplicitSpecializationAfterInstantiation) { 11742 // A redeclaration in function prototype scope in C isn't 11743 // visible elsewhere, so merely issue a warning. 11744 if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope()) 11745 Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name; 11746 else 11747 Diag(NameLoc, diag::err_redefinition) << Name; 11748 Diag(Def->getLocation(), diag::note_previous_definition); 11749 // If this is a redefinition, recover by making this 11750 // struct be anonymous, which will make any later 11751 // references get the previous definition. 11752 Name = nullptr; 11753 Previous.clear(); 11754 Invalid = true; 11755 } 11756 } else { 11757 // If the type is currently being defined, complain 11758 // about a nested redefinition. 11759 auto *TD = Context.getTagDeclType(PrevTagDecl)->getAsTagDecl(); 11760 if (TD->isBeingDefined()) { 11761 Diag(NameLoc, diag::err_nested_redefinition) << Name; 11762 Diag(PrevTagDecl->getLocation(), 11763 diag::note_previous_definition); 11764 Name = nullptr; 11765 Previous.clear(); 11766 Invalid = true; 11767 } 11768 } 11769 11770 // Okay, this is definition of a previously declared or referenced 11771 // tag. We're going to create a new Decl for it. 11772 } 11773 11774 // Okay, we're going to make a redeclaration. If this is some kind 11775 // of reference, make sure we build the redeclaration in the same DC 11776 // as the original, and ignore the current access specifier. 11777 if (TUK == TUK_Friend || TUK == TUK_Reference) { 11778 SearchDC = PrevTagDecl->getDeclContext(); 11779 AS = AS_none; 11780 } 11781 } 11782 // If we get here we have (another) forward declaration or we 11783 // have a definition. Just create a new decl. 11784 11785 } else { 11786 // If we get here, this is a definition of a new tag type in a nested 11787 // scope, e.g. "struct foo; void bar() { struct foo; }", just create a 11788 // new decl/type. We set PrevDecl to NULL so that the entities 11789 // have distinct types. 11790 Previous.clear(); 11791 } 11792 // If we get here, we're going to create a new Decl. If PrevDecl 11793 // is non-NULL, it's a definition of the tag declared by 11794 // PrevDecl. If it's NULL, we have a new definition. 11795 11796 11797 // Otherwise, PrevDecl is not a tag, but was found with tag 11798 // lookup. This is only actually possible in C++, where a few 11799 // things like templates still live in the tag namespace. 11800 } else { 11801 // Use a better diagnostic if an elaborated-type-specifier 11802 // found the wrong kind of type on the first 11803 // (non-redeclaration) lookup. 11804 if ((TUK == TUK_Reference || TUK == TUK_Friend) && 11805 !Previous.isForRedeclaration()) { 11806 unsigned Kind = 0; 11807 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 11808 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 11809 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 11810 Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind; 11811 Diag(PrevDecl->getLocation(), diag::note_declared_at); 11812 Invalid = true; 11813 11814 // Otherwise, only diagnose if the declaration is in scope. 11815 } else if (!isDeclInScope(PrevDecl, SearchDC, S, 11816 SS.isNotEmpty() || isExplicitSpecialization)) { 11817 // do nothing 11818 11819 // Diagnose implicit declarations introduced by elaborated types. 11820 } else if (TUK == TUK_Reference || TUK == TUK_Friend) { 11821 unsigned Kind = 0; 11822 if (isa<TypedefDecl>(PrevDecl)) Kind = 1; 11823 else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2; 11824 else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3; 11825 Diag(NameLoc, diag::err_tag_reference_conflict) << Kind; 11826 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 11827 Invalid = true; 11828 11829 // Otherwise it's a declaration. Call out a particularly common 11830 // case here. 11831 } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) { 11832 unsigned Kind = 0; 11833 if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1; 11834 Diag(NameLoc, diag::err_tag_definition_of_typedef) 11835 << Name << Kind << TND->getUnderlyingType(); 11836 Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl; 11837 Invalid = true; 11838 11839 // Otherwise, diagnose. 11840 } else { 11841 // The tag name clashes with something else in the target scope, 11842 // issue an error and recover by making this tag be anonymous. 11843 Diag(NameLoc, diag::err_redefinition_different_kind) << Name; 11844 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 11845 Name = nullptr; 11846 Invalid = true; 11847 } 11848 11849 // The existing declaration isn't relevant to us; we're in a 11850 // new scope, so clear out the previous declaration. 11851 Previous.clear(); 11852 } 11853 } 11854 11855 CreateNewDecl: 11856 11857 TagDecl *PrevDecl = nullptr; 11858 if (Previous.isSingleResult()) 11859 PrevDecl = cast<TagDecl>(Previous.getFoundDecl()); 11860 11861 // If there is an identifier, use the location of the identifier as the 11862 // location of the decl, otherwise use the location of the struct/union 11863 // keyword. 11864 SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc; 11865 11866 // Otherwise, create a new declaration. If there is a previous 11867 // declaration of the same entity, the two will be linked via 11868 // PrevDecl. 11869 TagDecl *New; 11870 11871 bool IsForwardReference = false; 11872 if (Kind == TTK_Enum) { 11873 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 11874 // enum X { A, B, C } D; D should chain to X. 11875 New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name, 11876 cast_or_null<EnumDecl>(PrevDecl), ScopedEnum, 11877 ScopedEnumUsesClassTag, !EnumUnderlying.isNull()); 11878 // If this is an undefined enum, warn. 11879 if (TUK != TUK_Definition && !Invalid) { 11880 TagDecl *Def; 11881 if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) && 11882 cast<EnumDecl>(New)->isFixed()) { 11883 // C++0x: 7.2p2: opaque-enum-declaration. 11884 // Conflicts are diagnosed above. Do nothing. 11885 } 11886 else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) { 11887 Diag(Loc, diag::ext_forward_ref_enum_def) 11888 << New; 11889 Diag(Def->getLocation(), diag::note_previous_definition); 11890 } else { 11891 unsigned DiagID = diag::ext_forward_ref_enum; 11892 if (getLangOpts().MSVCCompat) 11893 DiagID = diag::ext_ms_forward_ref_enum; 11894 else if (getLangOpts().CPlusPlus) 11895 DiagID = diag::err_forward_ref_enum; 11896 Diag(Loc, DiagID); 11897 11898 // If this is a forward-declared reference to an enumeration, make a 11899 // note of it; we won't actually be introducing the declaration into 11900 // the declaration context. 11901 if (TUK == TUK_Reference) 11902 IsForwardReference = true; 11903 } 11904 } 11905 11906 if (EnumUnderlying) { 11907 EnumDecl *ED = cast<EnumDecl>(New); 11908 if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>()) 11909 ED->setIntegerTypeSourceInfo(TI); 11910 else 11911 ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0)); 11912 ED->setPromotionType(ED->getIntegerType()); 11913 } 11914 11915 } else { 11916 // struct/union/class 11917 11918 // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.: 11919 // struct X { int A; } D; D should chain to X. 11920 if (getLangOpts().CPlusPlus) { 11921 // FIXME: Look for a way to use RecordDecl for simple structs. 11922 New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 11923 cast_or_null<CXXRecordDecl>(PrevDecl)); 11924 11925 if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit())) 11926 StdBadAlloc = cast<CXXRecordDecl>(New); 11927 } else 11928 New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name, 11929 cast_or_null<RecordDecl>(PrevDecl)); 11930 } 11931 11932 // C++11 [dcl.type]p3: 11933 // A type-specifier-seq shall not define a class or enumeration [...]. 11934 if (getLangOpts().CPlusPlus && IsTypeSpecifier && TUK == TUK_Definition) { 11935 Diag(New->getLocation(), diag::err_type_defined_in_type_specifier) 11936 << Context.getTagDeclType(New); 11937 Invalid = true; 11938 } 11939 11940 // Maybe add qualifier info. 11941 if (SS.isNotEmpty()) { 11942 if (SS.isSet()) { 11943 // If this is either a declaration or a definition, check the 11944 // nested-name-specifier against the current context. We don't do this 11945 // for explicit specializations, because they have similar checking 11946 // (with more specific diagnostics) in the call to 11947 // CheckMemberSpecialization, below. 11948 if (!isExplicitSpecialization && 11949 (TUK == TUK_Definition || TUK == TUK_Declaration) && 11950 diagnoseQualifiedDeclaration(SS, DC, OrigName, Loc)) 11951 Invalid = true; 11952 11953 New->setQualifierInfo(SS.getWithLocInContext(Context)); 11954 if (TemplateParameterLists.size() > 0) { 11955 New->setTemplateParameterListsInfo(Context, 11956 TemplateParameterLists.size(), 11957 TemplateParameterLists.data()); 11958 } 11959 } 11960 else 11961 Invalid = true; 11962 } 11963 11964 if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) { 11965 // Add alignment attributes if necessary; these attributes are checked when 11966 // the ASTContext lays out the structure. 11967 // 11968 // It is important for implementing the correct semantics that this 11969 // happen here (in act on tag decl). The #pragma pack stack is 11970 // maintained as a result of parser callbacks which can occur at 11971 // many points during the parsing of a struct declaration (because 11972 // the #pragma tokens are effectively skipped over during the 11973 // parsing of the struct). 11974 if (TUK == TUK_Definition) { 11975 AddAlignmentAttributesForRecord(RD); 11976 AddMsStructLayoutForRecord(RD); 11977 } 11978 } 11979 11980 if (ModulePrivateLoc.isValid()) { 11981 if (isExplicitSpecialization) 11982 Diag(New->getLocation(), diag::err_module_private_specialization) 11983 << 2 11984 << FixItHint::CreateRemoval(ModulePrivateLoc); 11985 // __module_private__ does not apply to local classes. However, we only 11986 // diagnose this as an error when the declaration specifiers are 11987 // freestanding. Here, we just ignore the __module_private__. 11988 else if (!SearchDC->isFunctionOrMethod()) 11989 New->setModulePrivate(); 11990 } 11991 11992 // If this is a specialization of a member class (of a class template), 11993 // check the specialization. 11994 if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous)) 11995 Invalid = true; 11996 11997 // If we're declaring or defining a tag in function prototype scope in C, 11998 // note that this type can only be used within the function and add it to 11999 // the list of decls to inject into the function definition scope. 12000 if ((Name || Kind == TTK_Enum) && 12001 getNonFieldDeclScope(S)->isFunctionPrototypeScope()) { 12002 if (getLangOpts().CPlusPlus) { 12003 // C++ [dcl.fct]p6: 12004 // Types shall not be defined in return or parameter types. 12005 if (TUK == TUK_Definition && !IsTypeSpecifier) { 12006 Diag(Loc, diag::err_type_defined_in_param_type) 12007 << Name; 12008 Invalid = true; 12009 } 12010 } else { 12011 Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New); 12012 } 12013 DeclsInPrototypeScope.push_back(New); 12014 } 12015 12016 if (Invalid) 12017 New->setInvalidDecl(); 12018 12019 if (Attr) 12020 ProcessDeclAttributeList(S, New, Attr); 12021 12022 // Set the lexical context. If the tag has a C++ scope specifier, the 12023 // lexical context will be different from the semantic context. 12024 New->setLexicalDeclContext(CurContext); 12025 12026 // Mark this as a friend decl if applicable. 12027 // In Microsoft mode, a friend declaration also acts as a forward 12028 // declaration so we always pass true to setObjectOfFriendDecl to make 12029 // the tag name visible. 12030 if (TUK == TUK_Friend) 12031 New->setObjectOfFriendDecl(getLangOpts().MSVCCompat); 12032 12033 // Set the access specifier. 12034 if (!Invalid && SearchDC->isRecord()) 12035 SetMemberAccessSpecifier(New, PrevDecl, AS); 12036 12037 if (TUK == TUK_Definition) 12038 New->startDefinition(); 12039 12040 // If this has an identifier, add it to the scope stack. 12041 if (TUK == TUK_Friend) { 12042 // We might be replacing an existing declaration in the lookup tables; 12043 // if so, borrow its access specifier. 12044 if (PrevDecl) 12045 New->setAccess(PrevDecl->getAccess()); 12046 12047 DeclContext *DC = New->getDeclContext()->getRedeclContext(); 12048 DC->makeDeclVisibleInContext(New); 12049 if (Name) // can be null along some error paths 12050 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC)) 12051 PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false); 12052 } else if (Name) { 12053 S = getNonFieldDeclScope(S); 12054 PushOnScopeChains(New, S, !IsForwardReference); 12055 if (IsForwardReference) 12056 SearchDC->makeDeclVisibleInContext(New); 12057 12058 } else { 12059 CurContext->addDecl(New); 12060 } 12061 12062 // If this is the C FILE type, notify the AST context. 12063 if (IdentifierInfo *II = New->getIdentifier()) 12064 if (!New->isInvalidDecl() && 12065 New->getDeclContext()->getRedeclContext()->isTranslationUnit() && 12066 II->isStr("FILE")) 12067 Context.setFILEDecl(New); 12068 12069 if (PrevDecl) 12070 mergeDeclAttributes(New, PrevDecl); 12071 12072 // If there's a #pragma GCC visibility in scope, set the visibility of this 12073 // record. 12074 AddPushedVisibilityAttribute(New); 12075 12076 OwnedDecl = true; 12077 // In C++, don't return an invalid declaration. We can't recover well from 12078 // the cases where we make the type anonymous. 12079 return (Invalid && getLangOpts().CPlusPlus) ? nullptr : New; 12080 } 12081 12082 void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) { 12083 AdjustDeclIfTemplate(TagD); 12084 TagDecl *Tag = cast<TagDecl>(TagD); 12085 12086 // Enter the tag context. 12087 PushDeclContext(S, Tag); 12088 12089 ActOnDocumentableDecl(TagD); 12090 12091 // If there's a #pragma GCC visibility in scope, set the visibility of this 12092 // record. 12093 AddPushedVisibilityAttribute(Tag); 12094 } 12095 12096 Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) { 12097 assert(isa<ObjCContainerDecl>(IDecl) && 12098 "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl"); 12099 DeclContext *OCD = cast<DeclContext>(IDecl); 12100 assert(getContainingDC(OCD) == CurContext && 12101 "The next DeclContext should be lexically contained in the current one."); 12102 CurContext = OCD; 12103 return IDecl; 12104 } 12105 12106 void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD, 12107 SourceLocation FinalLoc, 12108 bool IsFinalSpelledSealed, 12109 SourceLocation LBraceLoc) { 12110 AdjustDeclIfTemplate(TagD); 12111 CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD); 12112 12113 FieldCollector->StartClass(); 12114 12115 if (!Record->getIdentifier()) 12116 return; 12117 12118 if (FinalLoc.isValid()) 12119 Record->addAttr(new (Context) 12120 FinalAttr(FinalLoc, Context, IsFinalSpelledSealed)); 12121 12122 // C++ [class]p2: 12123 // [...] The class-name is also inserted into the scope of the 12124 // class itself; this is known as the injected-class-name. For 12125 // purposes of access checking, the injected-class-name is treated 12126 // as if it were a public member name. 12127 CXXRecordDecl *InjectedClassName 12128 = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext, 12129 Record->getLocStart(), Record->getLocation(), 12130 Record->getIdentifier(), 12131 /*PrevDecl=*/nullptr, 12132 /*DelayTypeCreation=*/true); 12133 Context.getTypeDeclType(InjectedClassName, Record); 12134 InjectedClassName->setImplicit(); 12135 InjectedClassName->setAccess(AS_public); 12136 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) 12137 InjectedClassName->setDescribedClassTemplate(Template); 12138 PushOnScopeChains(InjectedClassName, S); 12139 assert(InjectedClassName->isInjectedClassName() && 12140 "Broken injected-class-name"); 12141 } 12142 12143 void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD, 12144 SourceLocation RBraceLoc) { 12145 AdjustDeclIfTemplate(TagD); 12146 TagDecl *Tag = cast<TagDecl>(TagD); 12147 Tag->setRBraceLoc(RBraceLoc); 12148 12149 // Make sure we "complete" the definition even it is invalid. 12150 if (Tag->isBeingDefined()) { 12151 assert(Tag->isInvalidDecl() && "We should already have completed it"); 12152 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 12153 RD->completeDefinition(); 12154 } 12155 12156 if (isa<CXXRecordDecl>(Tag)) 12157 FieldCollector->FinishClass(); 12158 12159 // Exit this scope of this tag's definition. 12160 PopDeclContext(); 12161 12162 if (getCurLexicalContext()->isObjCContainer() && 12163 Tag->getDeclContext()->isFileContext()) 12164 Tag->setTopLevelDeclInObjCContainer(); 12165 12166 // Notify the consumer that we've defined a tag. 12167 if (!Tag->isInvalidDecl()) 12168 Consumer.HandleTagDeclDefinition(Tag); 12169 } 12170 12171 void Sema::ActOnObjCContainerFinishDefinition() { 12172 // Exit this scope of this interface definition. 12173 PopDeclContext(); 12174 } 12175 12176 void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) { 12177 assert(DC == CurContext && "Mismatch of container contexts"); 12178 OriginalLexicalContext = DC; 12179 ActOnObjCContainerFinishDefinition(); 12180 } 12181 12182 void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) { 12183 ActOnObjCContainerStartDefinition(cast<Decl>(DC)); 12184 OriginalLexicalContext = nullptr; 12185 } 12186 12187 void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) { 12188 AdjustDeclIfTemplate(TagD); 12189 TagDecl *Tag = cast<TagDecl>(TagD); 12190 Tag->setInvalidDecl(); 12191 12192 // Make sure we "complete" the definition even it is invalid. 12193 if (Tag->isBeingDefined()) { 12194 if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) 12195 RD->completeDefinition(); 12196 } 12197 12198 // We're undoing ActOnTagStartDefinition here, not 12199 // ActOnStartCXXMemberDeclarations, so we don't have to mess with 12200 // the FieldCollector. 12201 12202 PopDeclContext(); 12203 } 12204 12205 // Note that FieldName may be null for anonymous bitfields. 12206 ExprResult Sema::VerifyBitField(SourceLocation FieldLoc, 12207 IdentifierInfo *FieldName, 12208 QualType FieldTy, bool IsMsStruct, 12209 Expr *BitWidth, bool *ZeroWidth) { 12210 // Default to true; that shouldn't confuse checks for emptiness 12211 if (ZeroWidth) 12212 *ZeroWidth = true; 12213 12214 // C99 6.7.2.1p4 - verify the field type. 12215 // C++ 9.6p3: A bit-field shall have integral or enumeration type. 12216 if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) { 12217 // Handle incomplete types with specific error. 12218 if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete)) 12219 return ExprError(); 12220 if (FieldName) 12221 return Diag(FieldLoc, diag::err_not_integral_type_bitfield) 12222 << FieldName << FieldTy << BitWidth->getSourceRange(); 12223 return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield) 12224 << FieldTy << BitWidth->getSourceRange(); 12225 } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth), 12226 UPPC_BitFieldWidth)) 12227 return ExprError(); 12228 12229 // If the bit-width is type- or value-dependent, don't try to check 12230 // it now. 12231 if (BitWidth->isValueDependent() || BitWidth->isTypeDependent()) 12232 return BitWidth; 12233 12234 llvm::APSInt Value; 12235 ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value); 12236 if (ICE.isInvalid()) 12237 return ICE; 12238 BitWidth = ICE.get(); 12239 12240 if (Value != 0 && ZeroWidth) 12241 *ZeroWidth = false; 12242 12243 // Zero-width bitfield is ok for anonymous field. 12244 if (Value == 0 && FieldName) 12245 return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName; 12246 12247 if (Value.isSigned() && Value.isNegative()) { 12248 if (FieldName) 12249 return Diag(FieldLoc, diag::err_bitfield_has_negative_width) 12250 << FieldName << Value.toString(10); 12251 return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width) 12252 << Value.toString(10); 12253 } 12254 12255 if (!FieldTy->isDependentType()) { 12256 uint64_t TypeSize = Context.getTypeSize(FieldTy); 12257 if (Value.getZExtValue() > TypeSize) { 12258 if (!getLangOpts().CPlusPlus || IsMsStruct || 12259 Context.getTargetInfo().getCXXABI().isMicrosoft()) { 12260 if (FieldName) 12261 return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size) 12262 << FieldName << (unsigned)Value.getZExtValue() 12263 << (unsigned)TypeSize; 12264 12265 return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size) 12266 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 12267 } 12268 12269 if (FieldName) 12270 Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size) 12271 << FieldName << (unsigned)Value.getZExtValue() 12272 << (unsigned)TypeSize; 12273 else 12274 Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size) 12275 << (unsigned)Value.getZExtValue() << (unsigned)TypeSize; 12276 } 12277 } 12278 12279 return BitWidth; 12280 } 12281 12282 /// ActOnField - Each field of a C struct/union is passed into this in order 12283 /// to create a FieldDecl object for it. 12284 Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, 12285 Declarator &D, Expr *BitfieldWidth) { 12286 FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD), 12287 DeclStart, D, static_cast<Expr*>(BitfieldWidth), 12288 /*InitStyle=*/ICIS_NoInit, AS_public); 12289 return Res; 12290 } 12291 12292 /// HandleField - Analyze a field of a C struct or a C++ data member. 12293 /// 12294 FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record, 12295 SourceLocation DeclStart, 12296 Declarator &D, Expr *BitWidth, 12297 InClassInitStyle InitStyle, 12298 AccessSpecifier AS) { 12299 IdentifierInfo *II = D.getIdentifier(); 12300 SourceLocation Loc = DeclStart; 12301 if (II) Loc = D.getIdentifierLoc(); 12302 12303 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 12304 QualType T = TInfo->getType(); 12305 if (getLangOpts().CPlusPlus) { 12306 CheckExtraCXXDefaultArguments(D); 12307 12308 if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo, 12309 UPPC_DataMemberType)) { 12310 D.setInvalidType(); 12311 T = Context.IntTy; 12312 TInfo = Context.getTrivialTypeSourceInfo(T, Loc); 12313 } 12314 } 12315 12316 // TR 18037 does not allow fields to be declared with address spaces. 12317 if (T.getQualifiers().hasAddressSpace()) { 12318 Diag(Loc, diag::err_field_with_address_space); 12319 D.setInvalidType(); 12320 } 12321 12322 // OpenCL 1.2 spec, s6.9 r: 12323 // The event type cannot be used to declare a structure or union field. 12324 if (LangOpts.OpenCL && T->isEventT()) { 12325 Diag(Loc, diag::err_event_t_struct_field); 12326 D.setInvalidType(); 12327 } 12328 12329 DiagnoseFunctionSpecifiers(D.getDeclSpec()); 12330 12331 if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) 12332 Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(), 12333 diag::err_invalid_thread) 12334 << DeclSpec::getSpecifierName(TSCS); 12335 12336 // Check to see if this name was declared as a member previously 12337 NamedDecl *PrevDecl = nullptr; 12338 LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration); 12339 LookupName(Previous, S); 12340 switch (Previous.getResultKind()) { 12341 case LookupResult::Found: 12342 case LookupResult::FoundUnresolvedValue: 12343 PrevDecl = Previous.getAsSingle<NamedDecl>(); 12344 break; 12345 12346 case LookupResult::FoundOverloaded: 12347 PrevDecl = Previous.getRepresentativeDecl(); 12348 break; 12349 12350 case LookupResult::NotFound: 12351 case LookupResult::NotFoundInCurrentInstantiation: 12352 case LookupResult::Ambiguous: 12353 break; 12354 } 12355 Previous.suppressDiagnostics(); 12356 12357 if (PrevDecl && PrevDecl->isTemplateParameter()) { 12358 // Maybe we will complain about the shadowed template parameter. 12359 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl); 12360 // Just pretend that we didn't see the previous declaration. 12361 PrevDecl = nullptr; 12362 } 12363 12364 if (PrevDecl && !isDeclInScope(PrevDecl, Record, S)) 12365 PrevDecl = nullptr; 12366 12367 bool Mutable 12368 = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable); 12369 SourceLocation TSSL = D.getLocStart(); 12370 FieldDecl *NewFD 12371 = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle, 12372 TSSL, AS, PrevDecl, &D); 12373 12374 if (NewFD->isInvalidDecl()) 12375 Record->setInvalidDecl(); 12376 12377 if (D.getDeclSpec().isModulePrivateSpecified()) 12378 NewFD->setModulePrivate(); 12379 12380 if (NewFD->isInvalidDecl() && PrevDecl) { 12381 // Don't introduce NewFD into scope; there's already something 12382 // with the same name in the same scope. 12383 } else if (II) { 12384 PushOnScopeChains(NewFD, S); 12385 } else 12386 Record->addDecl(NewFD); 12387 12388 return NewFD; 12389 } 12390 12391 /// \brief Build a new FieldDecl and check its well-formedness. 12392 /// 12393 /// This routine builds a new FieldDecl given the fields name, type, 12394 /// record, etc. \p PrevDecl should refer to any previous declaration 12395 /// with the same name and in the same scope as the field to be 12396 /// created. 12397 /// 12398 /// \returns a new FieldDecl. 12399 /// 12400 /// \todo The Declarator argument is a hack. It will be removed once 12401 FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, 12402 TypeSourceInfo *TInfo, 12403 RecordDecl *Record, SourceLocation Loc, 12404 bool Mutable, Expr *BitWidth, 12405 InClassInitStyle InitStyle, 12406 SourceLocation TSSL, 12407 AccessSpecifier AS, NamedDecl *PrevDecl, 12408 Declarator *D) { 12409 IdentifierInfo *II = Name.getAsIdentifierInfo(); 12410 bool InvalidDecl = false; 12411 if (D) InvalidDecl = D->isInvalidType(); 12412 12413 // If we receive a broken type, recover by assuming 'int' and 12414 // marking this declaration as invalid. 12415 if (T.isNull()) { 12416 InvalidDecl = true; 12417 T = Context.IntTy; 12418 } 12419 12420 QualType EltTy = Context.getBaseElementType(T); 12421 if (!EltTy->isDependentType()) { 12422 if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) { 12423 // Fields of incomplete type force their record to be invalid. 12424 Record->setInvalidDecl(); 12425 InvalidDecl = true; 12426 } else { 12427 NamedDecl *Def; 12428 EltTy->isIncompleteType(&Def); 12429 if (Def && Def->isInvalidDecl()) { 12430 Record->setInvalidDecl(); 12431 InvalidDecl = true; 12432 } 12433 } 12434 } 12435 12436 // OpenCL v1.2 s6.9.c: bitfields are not supported. 12437 if (BitWidth && getLangOpts().OpenCL) { 12438 Diag(Loc, diag::err_opencl_bitfields); 12439 InvalidDecl = true; 12440 } 12441 12442 // C99 6.7.2.1p8: A member of a structure or union may have any type other 12443 // than a variably modified type. 12444 if (!InvalidDecl && T->isVariablyModifiedType()) { 12445 bool SizeIsNegative; 12446 llvm::APSInt Oversized; 12447 12448 TypeSourceInfo *FixedTInfo = 12449 TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context, 12450 SizeIsNegative, 12451 Oversized); 12452 if (FixedTInfo) { 12453 Diag(Loc, diag::warn_illegal_constant_array_size); 12454 TInfo = FixedTInfo; 12455 T = FixedTInfo->getType(); 12456 } else { 12457 if (SizeIsNegative) 12458 Diag(Loc, diag::err_typecheck_negative_array_size); 12459 else if (Oversized.getBoolValue()) 12460 Diag(Loc, diag::err_array_too_large) 12461 << Oversized.toString(10); 12462 else 12463 Diag(Loc, diag::err_typecheck_field_variable_size); 12464 InvalidDecl = true; 12465 } 12466 } 12467 12468 // Fields can not have abstract class types 12469 if (!InvalidDecl && RequireNonAbstractType(Loc, T, 12470 diag::err_abstract_type_in_decl, 12471 AbstractFieldType)) 12472 InvalidDecl = true; 12473 12474 bool ZeroWidth = false; 12475 // If this is declared as a bit-field, check the bit-field. 12476 if (!InvalidDecl && BitWidth) { 12477 BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth, 12478 &ZeroWidth).get(); 12479 if (!BitWidth) { 12480 InvalidDecl = true; 12481 BitWidth = nullptr; 12482 ZeroWidth = false; 12483 } 12484 } 12485 12486 // Check that 'mutable' is consistent with the type of the declaration. 12487 if (!InvalidDecl && Mutable) { 12488 unsigned DiagID = 0; 12489 if (T->isReferenceType()) 12490 DiagID = getLangOpts().MSVCCompat ? diag::ext_mutable_reference 12491 : diag::err_mutable_reference; 12492 else if (T.isConstQualified()) 12493 DiagID = diag::err_mutable_const; 12494 12495 if (DiagID) { 12496 SourceLocation ErrLoc = Loc; 12497 if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid()) 12498 ErrLoc = D->getDeclSpec().getStorageClassSpecLoc(); 12499 Diag(ErrLoc, DiagID); 12500 if (DiagID != diag::ext_mutable_reference) { 12501 Mutable = false; 12502 InvalidDecl = true; 12503 } 12504 } 12505 } 12506 12507 // C++11 [class.union]p8 (DR1460): 12508 // At most one variant member of a union may have a 12509 // brace-or-equal-initializer. 12510 if (InitStyle != ICIS_NoInit) 12511 checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc); 12512 12513 FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo, 12514 BitWidth, Mutable, InitStyle); 12515 if (InvalidDecl) 12516 NewFD->setInvalidDecl(); 12517 12518 if (PrevDecl && !isa<TagDecl>(PrevDecl)) { 12519 Diag(Loc, diag::err_duplicate_member) << II; 12520 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 12521 NewFD->setInvalidDecl(); 12522 } 12523 12524 if (!InvalidDecl && getLangOpts().CPlusPlus) { 12525 if (Record->isUnion()) { 12526 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 12527 CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl()); 12528 if (RDecl->getDefinition()) { 12529 // C++ [class.union]p1: An object of a class with a non-trivial 12530 // constructor, a non-trivial copy constructor, a non-trivial 12531 // destructor, or a non-trivial copy assignment operator 12532 // cannot be a member of a union, nor can an array of such 12533 // objects. 12534 if (CheckNontrivialField(NewFD)) 12535 NewFD->setInvalidDecl(); 12536 } 12537 } 12538 12539 // C++ [class.union]p1: If a union contains a member of reference type, 12540 // the program is ill-formed, except when compiling with MSVC extensions 12541 // enabled. 12542 if (EltTy->isReferenceType()) { 12543 Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? 12544 diag::ext_union_member_of_reference_type : 12545 diag::err_union_member_of_reference_type) 12546 << NewFD->getDeclName() << EltTy; 12547 if (!getLangOpts().MicrosoftExt) 12548 NewFD->setInvalidDecl(); 12549 } 12550 } 12551 } 12552 12553 // FIXME: We need to pass in the attributes given an AST 12554 // representation, not a parser representation. 12555 if (D) { 12556 // FIXME: The current scope is almost... but not entirely... correct here. 12557 ProcessDeclAttributes(getCurScope(), NewFD, *D); 12558 12559 if (NewFD->hasAttrs()) 12560 CheckAlignasUnderalignment(NewFD); 12561 } 12562 12563 // In auto-retain/release, infer strong retension for fields of 12564 // retainable type. 12565 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD)) 12566 NewFD->setInvalidDecl(); 12567 12568 if (T.isObjCGCWeak()) 12569 Diag(Loc, diag::warn_attribute_weak_on_field); 12570 12571 NewFD->setAccess(AS); 12572 return NewFD; 12573 } 12574 12575 bool Sema::CheckNontrivialField(FieldDecl *FD) { 12576 assert(FD); 12577 assert(getLangOpts().CPlusPlus && "valid check only for C++"); 12578 12579 if (FD->isInvalidDecl() || FD->getType()->isDependentType()) 12580 return false; 12581 12582 QualType EltTy = Context.getBaseElementType(FD->getType()); 12583 if (const RecordType *RT = EltTy->getAs<RecordType>()) { 12584 CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl()); 12585 if (RDecl->getDefinition()) { 12586 // We check for copy constructors before constructors 12587 // because otherwise we'll never get complaints about 12588 // copy constructors. 12589 12590 CXXSpecialMember member = CXXInvalid; 12591 // We're required to check for any non-trivial constructors. Since the 12592 // implicit default constructor is suppressed if there are any 12593 // user-declared constructors, we just need to check that there is a 12594 // trivial default constructor and a trivial copy constructor. (We don't 12595 // worry about move constructors here, since this is a C++98 check.) 12596 if (RDecl->hasNonTrivialCopyConstructor()) 12597 member = CXXCopyConstructor; 12598 else if (!RDecl->hasTrivialDefaultConstructor()) 12599 member = CXXDefaultConstructor; 12600 else if (RDecl->hasNonTrivialCopyAssignment()) 12601 member = CXXCopyAssignment; 12602 else if (RDecl->hasNonTrivialDestructor()) 12603 member = CXXDestructor; 12604 12605 if (member != CXXInvalid) { 12606 if (!getLangOpts().CPlusPlus11 && 12607 getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) { 12608 // Objective-C++ ARC: it is an error to have a non-trivial field of 12609 // a union. However, system headers in Objective-C programs 12610 // occasionally have Objective-C lifetime objects within unions, 12611 // and rather than cause the program to fail, we make those 12612 // members unavailable. 12613 SourceLocation Loc = FD->getLocation(); 12614 if (getSourceManager().isInSystemHeader(Loc)) { 12615 if (!FD->hasAttr<UnavailableAttr>()) 12616 FD->addAttr(UnavailableAttr::CreateImplicit(Context, 12617 "this system field has retaining ownership", 12618 Loc)); 12619 return false; 12620 } 12621 } 12622 12623 Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ? 12624 diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member : 12625 diag::err_illegal_union_or_anon_struct_member) 12626 << (int)FD->getParent()->isUnion() << FD->getDeclName() << member; 12627 DiagnoseNontrivial(RDecl, member); 12628 return !getLangOpts().CPlusPlus11; 12629 } 12630 } 12631 } 12632 12633 return false; 12634 } 12635 12636 /// TranslateIvarVisibility - Translate visibility from a token ID to an 12637 /// AST enum value. 12638 static ObjCIvarDecl::AccessControl 12639 TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) { 12640 switch (ivarVisibility) { 12641 default: llvm_unreachable("Unknown visitibility kind"); 12642 case tok::objc_private: return ObjCIvarDecl::Private; 12643 case tok::objc_public: return ObjCIvarDecl::Public; 12644 case tok::objc_protected: return ObjCIvarDecl::Protected; 12645 case tok::objc_package: return ObjCIvarDecl::Package; 12646 } 12647 } 12648 12649 /// ActOnIvar - Each ivar field of an objective-c class is passed into this 12650 /// in order to create an IvarDecl object for it. 12651 Decl *Sema::ActOnIvar(Scope *S, 12652 SourceLocation DeclStart, 12653 Declarator &D, Expr *BitfieldWidth, 12654 tok::ObjCKeywordKind Visibility) { 12655 12656 IdentifierInfo *II = D.getIdentifier(); 12657 Expr *BitWidth = (Expr*)BitfieldWidth; 12658 SourceLocation Loc = DeclStart; 12659 if (II) Loc = D.getIdentifierLoc(); 12660 12661 // FIXME: Unnamed fields can be handled in various different ways, for 12662 // example, unnamed unions inject all members into the struct namespace! 12663 12664 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 12665 QualType T = TInfo->getType(); 12666 12667 if (BitWidth) { 12668 // 6.7.2.1p3, 6.7.2.1p4 12669 BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).get(); 12670 if (!BitWidth) 12671 D.setInvalidType(); 12672 } else { 12673 // Not a bitfield. 12674 12675 // validate II. 12676 12677 } 12678 if (T->isReferenceType()) { 12679 Diag(Loc, diag::err_ivar_reference_type); 12680 D.setInvalidType(); 12681 } 12682 // C99 6.7.2.1p8: A member of a structure or union may have any type other 12683 // than a variably modified type. 12684 else if (T->isVariablyModifiedType()) { 12685 Diag(Loc, diag::err_typecheck_ivar_variable_size); 12686 D.setInvalidType(); 12687 } 12688 12689 // Get the visibility (access control) for this ivar. 12690 ObjCIvarDecl::AccessControl ac = 12691 Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility) 12692 : ObjCIvarDecl::None; 12693 // Must set ivar's DeclContext to its enclosing interface. 12694 ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext); 12695 if (!EnclosingDecl || EnclosingDecl->isInvalidDecl()) 12696 return nullptr; 12697 ObjCContainerDecl *EnclosingContext; 12698 if (ObjCImplementationDecl *IMPDecl = 12699 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 12700 if (LangOpts.ObjCRuntime.isFragile()) { 12701 // Case of ivar declared in an implementation. Context is that of its class. 12702 EnclosingContext = IMPDecl->getClassInterface(); 12703 assert(EnclosingContext && "Implementation has no class interface!"); 12704 } 12705 else 12706 EnclosingContext = EnclosingDecl; 12707 } else { 12708 if (ObjCCategoryDecl *CDecl = 12709 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 12710 if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) { 12711 Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension(); 12712 return nullptr; 12713 } 12714 } 12715 EnclosingContext = EnclosingDecl; 12716 } 12717 12718 // Construct the decl. 12719 ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext, 12720 DeclStart, Loc, II, T, 12721 TInfo, ac, (Expr *)BitfieldWidth); 12722 12723 if (II) { 12724 NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName, 12725 ForRedeclaration); 12726 if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S) 12727 && !isa<TagDecl>(PrevDecl)) { 12728 Diag(Loc, diag::err_duplicate_member) << II; 12729 Diag(PrevDecl->getLocation(), diag::note_previous_declaration); 12730 NewID->setInvalidDecl(); 12731 } 12732 } 12733 12734 // Process attributes attached to the ivar. 12735 ProcessDeclAttributes(S, NewID, D); 12736 12737 if (D.isInvalidType()) 12738 NewID->setInvalidDecl(); 12739 12740 // In ARC, infer 'retaining' for ivars of retainable type. 12741 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID)) 12742 NewID->setInvalidDecl(); 12743 12744 if (D.getDeclSpec().isModulePrivateSpecified()) 12745 NewID->setModulePrivate(); 12746 12747 if (II) { 12748 // FIXME: When interfaces are DeclContexts, we'll need to add 12749 // these to the interface. 12750 S->AddDecl(NewID); 12751 IdResolver.AddDecl(NewID); 12752 } 12753 12754 if (LangOpts.ObjCRuntime.isNonFragile() && 12755 !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl)) 12756 Diag(Loc, diag::warn_ivars_in_interface); 12757 12758 return NewID; 12759 } 12760 12761 /// ActOnLastBitfield - This routine handles synthesized bitfields rules for 12762 /// class and class extensions. For every class \@interface and class 12763 /// extension \@interface, if the last ivar is a bitfield of any type, 12764 /// then add an implicit `char :0` ivar to the end of that interface. 12765 void Sema::ActOnLastBitfield(SourceLocation DeclLoc, 12766 SmallVectorImpl<Decl *> &AllIvarDecls) { 12767 if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty()) 12768 return; 12769 12770 Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1]; 12771 ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl); 12772 12773 if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0) 12774 return; 12775 ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext); 12776 if (!ID) { 12777 if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) { 12778 if (!CD->IsClassExtension()) 12779 return; 12780 } 12781 // No need to add this to end of @implementation. 12782 else 12783 return; 12784 } 12785 // All conditions are met. Add a new bitfield to the tail end of ivars. 12786 llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0); 12787 Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc); 12788 12789 Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext), 12790 DeclLoc, DeclLoc, nullptr, 12791 Context.CharTy, 12792 Context.getTrivialTypeSourceInfo(Context.CharTy, 12793 DeclLoc), 12794 ObjCIvarDecl::Private, BW, 12795 true); 12796 AllIvarDecls.push_back(Ivar); 12797 } 12798 12799 void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, 12800 ArrayRef<Decl *> Fields, SourceLocation LBrac, 12801 SourceLocation RBrac, AttributeList *Attr) { 12802 assert(EnclosingDecl && "missing record or interface decl"); 12803 12804 // If this is an Objective-C @implementation or category and we have 12805 // new fields here we should reset the layout of the interface since 12806 // it will now change. 12807 if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) { 12808 ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl); 12809 switch (DC->getKind()) { 12810 default: break; 12811 case Decl::ObjCCategory: 12812 Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface()); 12813 break; 12814 case Decl::ObjCImplementation: 12815 Context. 12816 ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface()); 12817 break; 12818 } 12819 } 12820 12821 RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl); 12822 12823 // Start counting up the number of named members; make sure to include 12824 // members of anonymous structs and unions in the total. 12825 unsigned NumNamedMembers = 0; 12826 if (Record) { 12827 for (const auto *I : Record->decls()) { 12828 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I)) 12829 if (IFD->getDeclName()) 12830 ++NumNamedMembers; 12831 } 12832 } 12833 12834 // Verify that all the fields are okay. 12835 SmallVector<FieldDecl*, 32> RecFields; 12836 12837 bool ARCErrReported = false; 12838 for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end(); 12839 i != end; ++i) { 12840 FieldDecl *FD = cast<FieldDecl>(*i); 12841 12842 // Get the type for the field. 12843 const Type *FDTy = FD->getType().getTypePtr(); 12844 12845 if (!FD->isAnonymousStructOrUnion()) { 12846 // Remember all fields written by the user. 12847 RecFields.push_back(FD); 12848 } 12849 12850 // If the field is already invalid for some reason, don't emit more 12851 // diagnostics about it. 12852 if (FD->isInvalidDecl()) { 12853 EnclosingDecl->setInvalidDecl(); 12854 continue; 12855 } 12856 12857 // C99 6.7.2.1p2: 12858 // A structure or union shall not contain a member with 12859 // incomplete or function type (hence, a structure shall not 12860 // contain an instance of itself, but may contain a pointer to 12861 // an instance of itself), except that the last member of a 12862 // structure with more than one named member may have incomplete 12863 // array type; such a structure (and any union containing, 12864 // possibly recursively, a member that is such a structure) 12865 // shall not be a member of a structure or an element of an 12866 // array. 12867 if (FDTy->isFunctionType()) { 12868 // Field declared as a function. 12869 Diag(FD->getLocation(), diag::err_field_declared_as_function) 12870 << FD->getDeclName(); 12871 FD->setInvalidDecl(); 12872 EnclosingDecl->setInvalidDecl(); 12873 continue; 12874 } else if (FDTy->isIncompleteArrayType() && Record && 12875 ((i + 1 == Fields.end() && !Record->isUnion()) || 12876 ((getLangOpts().MicrosoftExt || 12877 getLangOpts().CPlusPlus) && 12878 (i + 1 == Fields.end() || Record->isUnion())))) { 12879 // Flexible array member. 12880 // Microsoft and g++ is more permissive regarding flexible array. 12881 // It will accept flexible array in union and also 12882 // as the sole element of a struct/class. 12883 unsigned DiagID = 0; 12884 if (Record->isUnion()) 12885 DiagID = getLangOpts().MicrosoftExt 12886 ? diag::ext_flexible_array_union_ms 12887 : getLangOpts().CPlusPlus 12888 ? diag::ext_flexible_array_union_gnu 12889 : diag::err_flexible_array_union; 12890 else if (Fields.size() == 1) 12891 DiagID = getLangOpts().MicrosoftExt 12892 ? diag::ext_flexible_array_empty_aggregate_ms 12893 : getLangOpts().CPlusPlus 12894 ? diag::ext_flexible_array_empty_aggregate_gnu 12895 : NumNamedMembers < 1 12896 ? diag::err_flexible_array_empty_aggregate 12897 : 0; 12898 12899 if (DiagID) 12900 Diag(FD->getLocation(), DiagID) << FD->getDeclName() 12901 << Record->getTagKind(); 12902 // While the layout of types that contain virtual bases is not specified 12903 // by the C++ standard, both the Itanium and Microsoft C++ ABIs place 12904 // virtual bases after the derived members. This would make a flexible 12905 // array member declared at the end of an object not adjacent to the end 12906 // of the type. 12907 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record)) 12908 if (RD->getNumVBases() != 0) 12909 Diag(FD->getLocation(), diag::err_flexible_array_virtual_base) 12910 << FD->getDeclName() << Record->getTagKind(); 12911 if (!getLangOpts().C99) 12912 Diag(FD->getLocation(), diag::ext_c99_flexible_array_member) 12913 << FD->getDeclName() << Record->getTagKind(); 12914 12915 // If the element type has a non-trivial destructor, we would not 12916 // implicitly destroy the elements, so disallow it for now. 12917 // 12918 // FIXME: GCC allows this. We should probably either implicitly delete 12919 // the destructor of the containing class, or just allow this. 12920 QualType BaseElem = Context.getBaseElementType(FD->getType()); 12921 if (!BaseElem->isDependentType() && BaseElem.isDestructedType()) { 12922 Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor) 12923 << FD->getDeclName() << FD->getType(); 12924 FD->setInvalidDecl(); 12925 EnclosingDecl->setInvalidDecl(); 12926 continue; 12927 } 12928 // Okay, we have a legal flexible array member at the end of the struct. 12929 Record->setHasFlexibleArrayMember(true); 12930 } else if (!FDTy->isDependentType() && 12931 RequireCompleteType(FD->getLocation(), FD->getType(), 12932 diag::err_field_incomplete)) { 12933 // Incomplete type 12934 FD->setInvalidDecl(); 12935 EnclosingDecl->setInvalidDecl(); 12936 continue; 12937 } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) { 12938 if (Record && FDTTy->getDecl()->hasFlexibleArrayMember()) { 12939 // A type which contains a flexible array member is considered to be a 12940 // flexible array member. 12941 Record->setHasFlexibleArrayMember(true); 12942 if (!Record->isUnion()) { 12943 // If this is a struct/class and this is not the last element, reject 12944 // it. Note that GCC supports variable sized arrays in the middle of 12945 // structures. 12946 if (i + 1 != Fields.end()) 12947 Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct) 12948 << FD->getDeclName() << FD->getType(); 12949 else { 12950 // We support flexible arrays at the end of structs in 12951 // other structs as an extension. 12952 Diag(FD->getLocation(), diag::ext_flexible_array_in_struct) 12953 << FD->getDeclName(); 12954 } 12955 } 12956 } 12957 if (isa<ObjCContainerDecl>(EnclosingDecl) && 12958 RequireNonAbstractType(FD->getLocation(), FD->getType(), 12959 diag::err_abstract_type_in_decl, 12960 AbstractIvarType)) { 12961 // Ivars can not have abstract class types 12962 FD->setInvalidDecl(); 12963 } 12964 if (Record && FDTTy->getDecl()->hasObjectMember()) 12965 Record->setHasObjectMember(true); 12966 if (Record && FDTTy->getDecl()->hasVolatileMember()) 12967 Record->setHasVolatileMember(true); 12968 } else if (FDTy->isObjCObjectType()) { 12969 /// A field cannot be an Objective-c object 12970 Diag(FD->getLocation(), diag::err_statically_allocated_object) 12971 << FixItHint::CreateInsertion(FD->getLocation(), "*"); 12972 QualType T = Context.getObjCObjectPointerType(FD->getType()); 12973 FD->setType(T); 12974 } else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported && 12975 (!getLangOpts().CPlusPlus || Record->isUnion())) { 12976 // It's an error in ARC if a field has lifetime. 12977 // We don't want to report this in a system header, though, 12978 // so we just make the field unavailable. 12979 // FIXME: that's really not sufficient; we need to make the type 12980 // itself invalid to, say, initialize or copy. 12981 QualType T = FD->getType(); 12982 Qualifiers::ObjCLifetime lifetime = T.getObjCLifetime(); 12983 if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) { 12984 SourceLocation loc = FD->getLocation(); 12985 if (getSourceManager().isInSystemHeader(loc)) { 12986 if (!FD->hasAttr<UnavailableAttr>()) { 12987 FD->addAttr(UnavailableAttr::CreateImplicit(Context, 12988 "this system field has retaining ownership", 12989 loc)); 12990 } 12991 } else { 12992 Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag) 12993 << T->isBlockPointerType() << Record->getTagKind(); 12994 } 12995 ARCErrReported = true; 12996 } 12997 } else if (getLangOpts().ObjC1 && 12998 getLangOpts().getGC() != LangOptions::NonGC && 12999 Record && !Record->hasObjectMember()) { 13000 if (FD->getType()->isObjCObjectPointerType() || 13001 FD->getType().isObjCGCStrong()) 13002 Record->setHasObjectMember(true); 13003 else if (Context.getAsArrayType(FD->getType())) { 13004 QualType BaseType = Context.getBaseElementType(FD->getType()); 13005 if (BaseType->isRecordType() && 13006 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember()) 13007 Record->setHasObjectMember(true); 13008 else if (BaseType->isObjCObjectPointerType() || 13009 BaseType.isObjCGCStrong()) 13010 Record->setHasObjectMember(true); 13011 } 13012 } 13013 if (Record && FD->getType().isVolatileQualified()) 13014 Record->setHasVolatileMember(true); 13015 // Keep track of the number of named members. 13016 if (FD->getIdentifier()) 13017 ++NumNamedMembers; 13018 } 13019 13020 // Okay, we successfully defined 'Record'. 13021 if (Record) { 13022 bool Completed = false; 13023 if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) { 13024 if (!CXXRecord->isInvalidDecl()) { 13025 // Set access bits correctly on the directly-declared conversions. 13026 for (CXXRecordDecl::conversion_iterator 13027 I = CXXRecord->conversion_begin(), 13028 E = CXXRecord->conversion_end(); I != E; ++I) 13029 I.setAccess((*I)->getAccess()); 13030 13031 if (!CXXRecord->isDependentType()) { 13032 if (CXXRecord->hasUserDeclaredDestructor()) { 13033 // Adjust user-defined destructor exception spec. 13034 if (getLangOpts().CPlusPlus11) 13035 AdjustDestructorExceptionSpec(CXXRecord, 13036 CXXRecord->getDestructor()); 13037 } 13038 13039 // Add any implicitly-declared members to this class. 13040 AddImplicitlyDeclaredMembersToClass(CXXRecord); 13041 13042 // If we have virtual base classes, we may end up finding multiple 13043 // final overriders for a given virtual function. Check for this 13044 // problem now. 13045 if (CXXRecord->getNumVBases()) { 13046 CXXFinalOverriderMap FinalOverriders; 13047 CXXRecord->getFinalOverriders(FinalOverriders); 13048 13049 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), 13050 MEnd = FinalOverriders.end(); 13051 M != MEnd; ++M) { 13052 for (OverridingMethods::iterator SO = M->second.begin(), 13053 SOEnd = M->second.end(); 13054 SO != SOEnd; ++SO) { 13055 assert(SO->second.size() > 0 && 13056 "Virtual function without overridding functions?"); 13057 if (SO->second.size() == 1) 13058 continue; 13059 13060 // C++ [class.virtual]p2: 13061 // In a derived class, if a virtual member function of a base 13062 // class subobject has more than one final overrider the 13063 // program is ill-formed. 13064 Diag(Record->getLocation(), diag::err_multiple_final_overriders) 13065 << (const NamedDecl *)M->first << Record; 13066 Diag(M->first->getLocation(), 13067 diag::note_overridden_virtual_function); 13068 for (OverridingMethods::overriding_iterator 13069 OM = SO->second.begin(), 13070 OMEnd = SO->second.end(); 13071 OM != OMEnd; ++OM) 13072 Diag(OM->Method->getLocation(), diag::note_final_overrider) 13073 << (const NamedDecl *)M->first << OM->Method->getParent(); 13074 13075 Record->setInvalidDecl(); 13076 } 13077 } 13078 CXXRecord->completeDefinition(&FinalOverriders); 13079 Completed = true; 13080 } 13081 } 13082 } 13083 } 13084 13085 if (!Completed) 13086 Record->completeDefinition(); 13087 13088 if (Record->hasAttrs()) { 13089 CheckAlignasUnderalignment(Record); 13090 13091 if (const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>()) 13092 checkMSInheritanceAttrOnDefinition(cast<CXXRecordDecl>(Record), 13093 IA->getRange(), IA->getBestCase(), 13094 IA->getSemanticSpelling()); 13095 } 13096 13097 // Check if the structure/union declaration is a type that can have zero 13098 // size in C. For C this is a language extension, for C++ it may cause 13099 // compatibility problems. 13100 bool CheckForZeroSize; 13101 if (!getLangOpts().CPlusPlus) { 13102 CheckForZeroSize = true; 13103 } else { 13104 // For C++ filter out types that cannot be referenced in C code. 13105 CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record); 13106 CheckForZeroSize = 13107 CXXRecord->getLexicalDeclContext()->isExternCContext() && 13108 !CXXRecord->isDependentType() && 13109 CXXRecord->isCLike(); 13110 } 13111 if (CheckForZeroSize) { 13112 bool ZeroSize = true; 13113 bool IsEmpty = true; 13114 unsigned NonBitFields = 0; 13115 for (RecordDecl::field_iterator I = Record->field_begin(), 13116 E = Record->field_end(); 13117 (NonBitFields == 0 || ZeroSize) && I != E; ++I) { 13118 IsEmpty = false; 13119 if (I->isUnnamedBitfield()) { 13120 if (I->getBitWidthValue(Context) > 0) 13121 ZeroSize = false; 13122 } else { 13123 ++NonBitFields; 13124 QualType FieldType = I->getType(); 13125 if (FieldType->isIncompleteType() || 13126 !Context.getTypeSizeInChars(FieldType).isZero()) 13127 ZeroSize = false; 13128 } 13129 } 13130 13131 // Empty structs are an extension in C (C99 6.7.2.1p7). They are 13132 // allowed in C++, but warn if its declaration is inside 13133 // extern "C" block. 13134 if (ZeroSize) { 13135 Diag(RecLoc, getLangOpts().CPlusPlus ? 13136 diag::warn_zero_size_struct_union_in_extern_c : 13137 diag::warn_zero_size_struct_union_compat) 13138 << IsEmpty << Record->isUnion() << (NonBitFields > 1); 13139 } 13140 13141 // Structs without named members are extension in C (C99 6.7.2.1p7), 13142 // but are accepted by GCC. 13143 if (NonBitFields == 0 && !getLangOpts().CPlusPlus) { 13144 Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union : 13145 diag::ext_no_named_members_in_struct_union) 13146 << Record->isUnion(); 13147 } 13148 } 13149 } else { 13150 ObjCIvarDecl **ClsFields = 13151 reinterpret_cast<ObjCIvarDecl**>(RecFields.data()); 13152 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) { 13153 ID->setEndOfDefinitionLoc(RBrac); 13154 // Add ivar's to class's DeclContext. 13155 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 13156 ClsFields[i]->setLexicalDeclContext(ID); 13157 ID->addDecl(ClsFields[i]); 13158 } 13159 // Must enforce the rule that ivars in the base classes may not be 13160 // duplicates. 13161 if (ID->getSuperClass()) 13162 DiagnoseDuplicateIvars(ID, ID->getSuperClass()); 13163 } else if (ObjCImplementationDecl *IMPDecl = 13164 dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) { 13165 assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl"); 13166 for (unsigned I = 0, N = RecFields.size(); I != N; ++I) 13167 // Ivar declared in @implementation never belongs to the implementation. 13168 // Only it is in implementation's lexical context. 13169 ClsFields[I]->setLexicalDeclContext(IMPDecl); 13170 CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac); 13171 IMPDecl->setIvarLBraceLoc(LBrac); 13172 IMPDecl->setIvarRBraceLoc(RBrac); 13173 } else if (ObjCCategoryDecl *CDecl = 13174 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) { 13175 // case of ivars in class extension; all other cases have been 13176 // reported as errors elsewhere. 13177 // FIXME. Class extension does not have a LocEnd field. 13178 // CDecl->setLocEnd(RBrac); 13179 // Add ivar's to class extension's DeclContext. 13180 // Diagnose redeclaration of private ivars. 13181 ObjCInterfaceDecl *IDecl = CDecl->getClassInterface(); 13182 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) { 13183 if (IDecl) { 13184 if (const ObjCIvarDecl *ClsIvar = 13185 IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) { 13186 Diag(ClsFields[i]->getLocation(), 13187 diag::err_duplicate_ivar_declaration); 13188 Diag(ClsIvar->getLocation(), diag::note_previous_definition); 13189 continue; 13190 } 13191 for (const auto *Ext : IDecl->known_extensions()) { 13192 if (const ObjCIvarDecl *ClsExtIvar 13193 = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) { 13194 Diag(ClsFields[i]->getLocation(), 13195 diag::err_duplicate_ivar_declaration); 13196 Diag(ClsExtIvar->getLocation(), diag::note_previous_definition); 13197 continue; 13198 } 13199 } 13200 } 13201 ClsFields[i]->setLexicalDeclContext(CDecl); 13202 CDecl->addDecl(ClsFields[i]); 13203 } 13204 CDecl->setIvarLBraceLoc(LBrac); 13205 CDecl->setIvarRBraceLoc(RBrac); 13206 } 13207 } 13208 13209 if (Attr) 13210 ProcessDeclAttributeList(S, Record, Attr); 13211 } 13212 13213 /// \brief Determine whether the given integral value is representable within 13214 /// the given type T. 13215 static bool isRepresentableIntegerValue(ASTContext &Context, 13216 llvm::APSInt &Value, 13217 QualType T) { 13218 assert(T->isIntegralType(Context) && "Integral type required!"); 13219 unsigned BitWidth = Context.getIntWidth(T); 13220 13221 if (Value.isUnsigned() || Value.isNonNegative()) { 13222 if (T->isSignedIntegerOrEnumerationType()) 13223 --BitWidth; 13224 return Value.getActiveBits() <= BitWidth; 13225 } 13226 return Value.getMinSignedBits() <= BitWidth; 13227 } 13228 13229 // \brief Given an integral type, return the next larger integral type 13230 // (or a NULL type of no such type exists). 13231 static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) { 13232 // FIXME: Int128/UInt128 support, which also needs to be introduced into 13233 // enum checking below. 13234 assert(T->isIntegralType(Context) && "Integral type required!"); 13235 const unsigned NumTypes = 4; 13236 QualType SignedIntegralTypes[NumTypes] = { 13237 Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy 13238 }; 13239 QualType UnsignedIntegralTypes[NumTypes] = { 13240 Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy, 13241 Context.UnsignedLongLongTy 13242 }; 13243 13244 unsigned BitWidth = Context.getTypeSize(T); 13245 QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes 13246 : UnsignedIntegralTypes; 13247 for (unsigned I = 0; I != NumTypes; ++I) 13248 if (Context.getTypeSize(Types[I]) > BitWidth) 13249 return Types[I]; 13250 13251 return QualType(); 13252 } 13253 13254 EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum, 13255 EnumConstantDecl *LastEnumConst, 13256 SourceLocation IdLoc, 13257 IdentifierInfo *Id, 13258 Expr *Val) { 13259 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 13260 llvm::APSInt EnumVal(IntWidth); 13261 QualType EltTy; 13262 13263 if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue)) 13264 Val = nullptr; 13265 13266 if (Val) 13267 Val = DefaultLvalueConversion(Val).get(); 13268 13269 if (Val) { 13270 if (Enum->isDependentType() || Val->isTypeDependent()) 13271 EltTy = Context.DependentTy; 13272 else { 13273 SourceLocation ExpLoc; 13274 if (getLangOpts().CPlusPlus11 && Enum->isFixed() && 13275 !getLangOpts().MSVCCompat) { 13276 // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the 13277 // constant-expression in the enumerator-definition shall be a converted 13278 // constant expression of the underlying type. 13279 EltTy = Enum->getIntegerType(); 13280 ExprResult Converted = 13281 CheckConvertedConstantExpression(Val, EltTy, EnumVal, 13282 CCEK_Enumerator); 13283 if (Converted.isInvalid()) 13284 Val = nullptr; 13285 else 13286 Val = Converted.get(); 13287 } else if (!Val->isValueDependent() && 13288 !(Val = VerifyIntegerConstantExpression(Val, 13289 &EnumVal).get())) { 13290 // C99 6.7.2.2p2: Make sure we have an integer constant expression. 13291 } else { 13292 if (Enum->isFixed()) { 13293 EltTy = Enum->getIntegerType(); 13294 13295 // In Obj-C and Microsoft mode, require the enumeration value to be 13296 // representable in the underlying type of the enumeration. In C++11, 13297 // we perform a non-narrowing conversion as part of converted constant 13298 // expression checking. 13299 if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 13300 if (getLangOpts().MSVCCompat) { 13301 Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy; 13302 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get(); 13303 } else 13304 Diag(IdLoc, diag::err_enumerator_too_large) << EltTy; 13305 } else 13306 Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get(); 13307 } else if (getLangOpts().CPlusPlus) { 13308 // C++11 [dcl.enum]p5: 13309 // If the underlying type is not fixed, the type of each enumerator 13310 // is the type of its initializing value: 13311 // - If an initializer is specified for an enumerator, the 13312 // initializing value has the same type as the expression. 13313 EltTy = Val->getType(); 13314 } else { 13315 // C99 6.7.2.2p2: 13316 // The expression that defines the value of an enumeration constant 13317 // shall be an integer constant expression that has a value 13318 // representable as an int. 13319 13320 // Complain if the value is not representable in an int. 13321 if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy)) 13322 Diag(IdLoc, diag::ext_enum_value_not_int) 13323 << EnumVal.toString(10) << Val->getSourceRange() 13324 << (EnumVal.isUnsigned() || EnumVal.isNonNegative()); 13325 else if (!Context.hasSameType(Val->getType(), Context.IntTy)) { 13326 // Force the type of the expression to 'int'. 13327 Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get(); 13328 } 13329 EltTy = Val->getType(); 13330 } 13331 } 13332 } 13333 } 13334 13335 if (!Val) { 13336 if (Enum->isDependentType()) 13337 EltTy = Context.DependentTy; 13338 else if (!LastEnumConst) { 13339 // C++0x [dcl.enum]p5: 13340 // If the underlying type is not fixed, the type of each enumerator 13341 // is the type of its initializing value: 13342 // - If no initializer is specified for the first enumerator, the 13343 // initializing value has an unspecified integral type. 13344 // 13345 // GCC uses 'int' for its unspecified integral type, as does 13346 // C99 6.7.2.2p3. 13347 if (Enum->isFixed()) { 13348 EltTy = Enum->getIntegerType(); 13349 } 13350 else { 13351 EltTy = Context.IntTy; 13352 } 13353 } else { 13354 // Assign the last value + 1. 13355 EnumVal = LastEnumConst->getInitVal(); 13356 ++EnumVal; 13357 EltTy = LastEnumConst->getType(); 13358 13359 // Check for overflow on increment. 13360 if (EnumVal < LastEnumConst->getInitVal()) { 13361 // C++0x [dcl.enum]p5: 13362 // If the underlying type is not fixed, the type of each enumerator 13363 // is the type of its initializing value: 13364 // 13365 // - Otherwise the type of the initializing value is the same as 13366 // the type of the initializing value of the preceding enumerator 13367 // unless the incremented value is not representable in that type, 13368 // in which case the type is an unspecified integral type 13369 // sufficient to contain the incremented value. If no such type 13370 // exists, the program is ill-formed. 13371 QualType T = getNextLargerIntegralType(Context, EltTy); 13372 if (T.isNull() || Enum->isFixed()) { 13373 // There is no integral type larger enough to represent this 13374 // value. Complain, then allow the value to wrap around. 13375 EnumVal = LastEnumConst->getInitVal(); 13376 EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2); 13377 ++EnumVal; 13378 if (Enum->isFixed()) 13379 // When the underlying type is fixed, this is ill-formed. 13380 Diag(IdLoc, diag::err_enumerator_wrapped) 13381 << EnumVal.toString(10) 13382 << EltTy; 13383 else 13384 Diag(IdLoc, diag::ext_enumerator_increment_too_large) 13385 << EnumVal.toString(10); 13386 } else { 13387 EltTy = T; 13388 } 13389 13390 // Retrieve the last enumerator's value, extent that type to the 13391 // type that is supposed to be large enough to represent the incremented 13392 // value, then increment. 13393 EnumVal = LastEnumConst->getInitVal(); 13394 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 13395 EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy)); 13396 ++EnumVal; 13397 13398 // If we're not in C++, diagnose the overflow of enumerator values, 13399 // which in C99 means that the enumerator value is not representable in 13400 // an int (C99 6.7.2.2p2). However, we support GCC's extension that 13401 // permits enumerator values that are representable in some larger 13402 // integral type. 13403 if (!getLangOpts().CPlusPlus && !T.isNull()) 13404 Diag(IdLoc, diag::warn_enum_value_overflow); 13405 } else if (!getLangOpts().CPlusPlus && 13406 !isRepresentableIntegerValue(Context, EnumVal, EltTy)) { 13407 // Enforce C99 6.7.2.2p2 even when we compute the next value. 13408 Diag(IdLoc, diag::ext_enum_value_not_int) 13409 << EnumVal.toString(10) << 1; 13410 } 13411 } 13412 } 13413 13414 if (!EltTy->isDependentType()) { 13415 // Make the enumerator value match the signedness and size of the 13416 // enumerator's type. 13417 EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy)); 13418 EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType()); 13419 } 13420 13421 return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy, 13422 Val, EnumVal); 13423 } 13424 13425 13426 Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst, 13427 SourceLocation IdLoc, IdentifierInfo *Id, 13428 AttributeList *Attr, 13429 SourceLocation EqualLoc, Expr *Val) { 13430 EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl); 13431 EnumConstantDecl *LastEnumConst = 13432 cast_or_null<EnumConstantDecl>(lastEnumConst); 13433 13434 // The scope passed in may not be a decl scope. Zip up the scope tree until 13435 // we find one that is. 13436 S = getNonFieldDeclScope(S); 13437 13438 // Verify that there isn't already something declared with this name in this 13439 // scope. 13440 NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName, 13441 ForRedeclaration); 13442 if (PrevDecl && PrevDecl->isTemplateParameter()) { 13443 // Maybe we will complain about the shadowed template parameter. 13444 DiagnoseTemplateParameterShadow(IdLoc, PrevDecl); 13445 // Just pretend that we didn't see the previous declaration. 13446 PrevDecl = nullptr; 13447 } 13448 13449 if (PrevDecl) { 13450 // When in C++, we may get a TagDecl with the same name; in this case the 13451 // enum constant will 'hide' the tag. 13452 assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) && 13453 "Received TagDecl when not in C++!"); 13454 if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) { 13455 if (isa<EnumConstantDecl>(PrevDecl)) 13456 Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id; 13457 else 13458 Diag(IdLoc, diag::err_redefinition) << Id; 13459 Diag(PrevDecl->getLocation(), diag::note_previous_definition); 13460 return nullptr; 13461 } 13462 } 13463 13464 // C++ [class.mem]p15: 13465 // If T is the name of a class, then each of the following shall have a name 13466 // different from T: 13467 // - every enumerator of every member of class T that is an unscoped 13468 // enumerated type 13469 if (CXXRecordDecl *Record 13470 = dyn_cast<CXXRecordDecl>( 13471 TheEnumDecl->getDeclContext()->getRedeclContext())) 13472 if (!TheEnumDecl->isScoped() && 13473 Record->getIdentifier() && Record->getIdentifier() == Id) 13474 Diag(IdLoc, diag::err_member_name_of_class) << Id; 13475 13476 EnumConstantDecl *New = 13477 CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val); 13478 13479 if (New) { 13480 // Process attributes. 13481 if (Attr) ProcessDeclAttributeList(S, New, Attr); 13482 13483 // Register this decl in the current scope stack. 13484 New->setAccess(TheEnumDecl->getAccess()); 13485 PushOnScopeChains(New, S); 13486 } 13487 13488 ActOnDocumentableDecl(New); 13489 13490 return New; 13491 } 13492 13493 // Returns true when the enum initial expression does not trigger the 13494 // duplicate enum warning. A few common cases are exempted as follows: 13495 // Element2 = Element1 13496 // Element2 = Element1 + 1 13497 // Element2 = Element1 - 1 13498 // Where Element2 and Element1 are from the same enum. 13499 static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) { 13500 Expr *InitExpr = ECD->getInitExpr(); 13501 if (!InitExpr) 13502 return true; 13503 InitExpr = InitExpr->IgnoreImpCasts(); 13504 13505 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) { 13506 if (!BO->isAdditiveOp()) 13507 return true; 13508 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS()); 13509 if (!IL) 13510 return true; 13511 if (IL->getValue() != 1) 13512 return true; 13513 13514 InitExpr = BO->getLHS(); 13515 } 13516 13517 // This checks if the elements are from the same enum. 13518 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr); 13519 if (!DRE) 13520 return true; 13521 13522 EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl()); 13523 if (!EnumConstant) 13524 return true; 13525 13526 if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) != 13527 Enum) 13528 return true; 13529 13530 return false; 13531 } 13532 13533 struct DupKey { 13534 int64_t val; 13535 bool isTombstoneOrEmptyKey; 13536 DupKey(int64_t val, bool isTombstoneOrEmptyKey) 13537 : val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {} 13538 }; 13539 13540 static DupKey GetDupKey(const llvm::APSInt& Val) { 13541 return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(), 13542 false); 13543 } 13544 13545 struct DenseMapInfoDupKey { 13546 static DupKey getEmptyKey() { return DupKey(0, true); } 13547 static DupKey getTombstoneKey() { return DupKey(1, true); } 13548 static unsigned getHashValue(const DupKey Key) { 13549 return (unsigned)(Key.val * 37); 13550 } 13551 static bool isEqual(const DupKey& LHS, const DupKey& RHS) { 13552 return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey && 13553 LHS.val == RHS.val; 13554 } 13555 }; 13556 13557 // Emits a warning when an element is implicitly set a value that 13558 // a previous element has already been set to. 13559 static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements, 13560 EnumDecl *Enum, 13561 QualType EnumType) { 13562 if (S.Diags.isIgnored(diag::warn_duplicate_enum_values, Enum->getLocation())) 13563 return; 13564 // Avoid anonymous enums 13565 if (!Enum->getIdentifier()) 13566 return; 13567 13568 // Only check for small enums. 13569 if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64) 13570 return; 13571 13572 typedef SmallVector<EnumConstantDecl *, 3> ECDVector; 13573 typedef SmallVector<ECDVector *, 3> DuplicatesVector; 13574 13575 typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector; 13576 typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey> 13577 ValueToVectorMap; 13578 13579 DuplicatesVector DupVector; 13580 ValueToVectorMap EnumMap; 13581 13582 // Populate the EnumMap with all values represented by enum constants without 13583 // an initialier. 13584 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 13585 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]); 13586 13587 // Null EnumConstantDecl means a previous diagnostic has been emitted for 13588 // this constant. Skip this enum since it may be ill-formed. 13589 if (!ECD) { 13590 return; 13591 } 13592 13593 if (ECD->getInitExpr()) 13594 continue; 13595 13596 DupKey Key = GetDupKey(ECD->getInitVal()); 13597 DeclOrVector &Entry = EnumMap[Key]; 13598 13599 // First time encountering this value. 13600 if (Entry.isNull()) 13601 Entry = ECD; 13602 } 13603 13604 // Create vectors for any values that has duplicates. 13605 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 13606 EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]); 13607 if (!ValidDuplicateEnum(ECD, Enum)) 13608 continue; 13609 13610 DupKey Key = GetDupKey(ECD->getInitVal()); 13611 13612 DeclOrVector& Entry = EnumMap[Key]; 13613 if (Entry.isNull()) 13614 continue; 13615 13616 if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) { 13617 // Ensure constants are different. 13618 if (D == ECD) 13619 continue; 13620 13621 // Create new vector and push values onto it. 13622 ECDVector *Vec = new ECDVector(); 13623 Vec->push_back(D); 13624 Vec->push_back(ECD); 13625 13626 // Update entry to point to the duplicates vector. 13627 Entry = Vec; 13628 13629 // Store the vector somewhere we can consult later for quick emission of 13630 // diagnostics. 13631 DupVector.push_back(Vec); 13632 continue; 13633 } 13634 13635 ECDVector *Vec = Entry.get<ECDVector*>(); 13636 // Make sure constants are not added more than once. 13637 if (*Vec->begin() == ECD) 13638 continue; 13639 13640 Vec->push_back(ECD); 13641 } 13642 13643 // Emit diagnostics. 13644 for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(), 13645 DupVectorEnd = DupVector.end(); 13646 DupVectorIter != DupVectorEnd; ++DupVectorIter) { 13647 ECDVector *Vec = *DupVectorIter; 13648 assert(Vec->size() > 1 && "ECDVector should have at least 2 elements."); 13649 13650 // Emit warning for one enum constant. 13651 ECDVector::iterator I = Vec->begin(); 13652 S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values) 13653 << (*I)->getName() << (*I)->getInitVal().toString(10) 13654 << (*I)->getSourceRange(); 13655 ++I; 13656 13657 // Emit one note for each of the remaining enum constants with 13658 // the same value. 13659 for (ECDVector::iterator E = Vec->end(); I != E; ++I) 13660 S.Diag((*I)->getLocation(), diag::note_duplicate_element) 13661 << (*I)->getName() << (*I)->getInitVal().toString(10) 13662 << (*I)->getSourceRange(); 13663 delete Vec; 13664 } 13665 } 13666 13667 bool 13668 Sema::IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, 13669 bool AllowMask) const { 13670 FlagEnumAttr *FEAttr = ED->getAttr<FlagEnumAttr>(); 13671 assert(FEAttr && "looking for value in non-flag enum"); 13672 13673 llvm::APInt FlagMask = ~FEAttr->getFlagBits(); 13674 unsigned Width = FlagMask.getBitWidth(); 13675 13676 // We will try a zero-extended value for the regular check first. 13677 llvm::APInt ExtVal = Val.zextOrSelf(Width); 13678 13679 // A value is in a flag enum if either its bits are a subset of the enum's 13680 // flag bits (the first condition) or we are allowing masks and the same is 13681 // true of its complement (the second condition). When masks are allowed, we 13682 // allow the common idiom of ~(enum1 | enum2) to be a valid enum value. 13683 // 13684 // While it's true that any value could be used as a mask, the assumption is 13685 // that a mask will have all of the insignificant bits set. Anything else is 13686 // likely a logic error. 13687 if (!(FlagMask & ExtVal)) 13688 return true; 13689 13690 if (AllowMask) { 13691 // Try a one-extended value instead. This can happen if the enum is wider 13692 // than the constant used, in C with extensions to allow for wider enums. 13693 // The mask will still have the correct behaviour, so we give the user the 13694 // benefit of the doubt. 13695 // 13696 // FIXME: This heuristic can cause weird results if the enum was extended 13697 // to a larger type and is signed, because then bit-masks of smaller types 13698 // that get extended will fall out of range (e.g. ~0x1u). We currently don't 13699 // detect that case and will get a false positive for it. In most cases, 13700 // though, it can be fixed by making it a signed type (e.g. ~0x1), so it may 13701 // be fine just to accept this as a warning. 13702 ExtVal |= llvm::APInt::getHighBitsSet(Width, Width - Val.getBitWidth()); 13703 if (!(FlagMask & ~ExtVal)) 13704 return true; 13705 } 13706 13707 return false; 13708 } 13709 13710 void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc, 13711 SourceLocation RBraceLoc, Decl *EnumDeclX, 13712 ArrayRef<Decl *> Elements, 13713 Scope *S, AttributeList *Attr) { 13714 EnumDecl *Enum = cast<EnumDecl>(EnumDeclX); 13715 QualType EnumType = Context.getTypeDeclType(Enum); 13716 13717 if (Attr) 13718 ProcessDeclAttributeList(S, Enum, Attr); 13719 13720 if (Enum->isDependentType()) { 13721 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 13722 EnumConstantDecl *ECD = 13723 cast_or_null<EnumConstantDecl>(Elements[i]); 13724 if (!ECD) continue; 13725 13726 ECD->setType(EnumType); 13727 } 13728 13729 Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0); 13730 return; 13731 } 13732 13733 // TODO: If the result value doesn't fit in an int, it must be a long or long 13734 // long value. ISO C does not support this, but GCC does as an extension, 13735 // emit a warning. 13736 unsigned IntWidth = Context.getTargetInfo().getIntWidth(); 13737 unsigned CharWidth = Context.getTargetInfo().getCharWidth(); 13738 unsigned ShortWidth = Context.getTargetInfo().getShortWidth(); 13739 13740 // Verify that all the values are okay, compute the size of the values, and 13741 // reverse the list. 13742 unsigned NumNegativeBits = 0; 13743 unsigned NumPositiveBits = 0; 13744 13745 // Keep track of whether all elements have type int. 13746 bool AllElementsInt = true; 13747 13748 for (unsigned i = 0, e = Elements.size(); i != e; ++i) { 13749 EnumConstantDecl *ECD = 13750 cast_or_null<EnumConstantDecl>(Elements[i]); 13751 if (!ECD) continue; // Already issued a diagnostic. 13752 13753 const llvm::APSInt &InitVal = ECD->getInitVal(); 13754 13755 // Keep track of the size of positive and negative values. 13756 if (InitVal.isUnsigned() || InitVal.isNonNegative()) 13757 NumPositiveBits = std::max(NumPositiveBits, 13758 (unsigned)InitVal.getActiveBits()); 13759 else 13760 NumNegativeBits = std::max(NumNegativeBits, 13761 (unsigned)InitVal.getMinSignedBits()); 13762 13763 // Keep track of whether every enum element has type int (very commmon). 13764 if (AllElementsInt) 13765 AllElementsInt = ECD->getType() == Context.IntTy; 13766 } 13767 13768 // Figure out the type that should be used for this enum. 13769 QualType BestType; 13770 unsigned BestWidth; 13771 13772 // C++0x N3000 [conv.prom]p3: 13773 // An rvalue of an unscoped enumeration type whose underlying 13774 // type is not fixed can be converted to an rvalue of the first 13775 // of the following types that can represent all the values of 13776 // the enumeration: int, unsigned int, long int, unsigned long 13777 // int, long long int, or unsigned long long int. 13778 // C99 6.4.4.3p2: 13779 // An identifier declared as an enumeration constant has type int. 13780 // The C99 rule is modified by a gcc extension 13781 QualType BestPromotionType; 13782 13783 bool Packed = Enum->hasAttr<PackedAttr>(); 13784 // -fshort-enums is the equivalent to specifying the packed attribute on all 13785 // enum definitions. 13786 if (LangOpts.ShortEnums) 13787 Packed = true; 13788 13789 if (Enum->isFixed()) { 13790 BestType = Enum->getIntegerType(); 13791 if (BestType->isPromotableIntegerType()) 13792 BestPromotionType = Context.getPromotedIntegerType(BestType); 13793 else 13794 BestPromotionType = BestType; 13795 13796 BestWidth = Context.getIntWidth(BestType); 13797 } 13798 else if (NumNegativeBits) { 13799 // If there is a negative value, figure out the smallest integer type (of 13800 // int/long/longlong) that fits. 13801 // If it's packed, check also if it fits a char or a short. 13802 if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) { 13803 BestType = Context.SignedCharTy; 13804 BestWidth = CharWidth; 13805 } else if (Packed && NumNegativeBits <= ShortWidth && 13806 NumPositiveBits < ShortWidth) { 13807 BestType = Context.ShortTy; 13808 BestWidth = ShortWidth; 13809 } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) { 13810 BestType = Context.IntTy; 13811 BestWidth = IntWidth; 13812 } else { 13813 BestWidth = Context.getTargetInfo().getLongWidth(); 13814 13815 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) { 13816 BestType = Context.LongTy; 13817 } else { 13818 BestWidth = Context.getTargetInfo().getLongLongWidth(); 13819 13820 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth) 13821 Diag(Enum->getLocation(), diag::ext_enum_too_large); 13822 BestType = Context.LongLongTy; 13823 } 13824 } 13825 BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType); 13826 } else { 13827 // If there is no negative value, figure out the smallest type that fits 13828 // all of the enumerator values. 13829 // If it's packed, check also if it fits a char or a short. 13830 if (Packed && NumPositiveBits <= CharWidth) { 13831 BestType = Context.UnsignedCharTy; 13832 BestPromotionType = Context.IntTy; 13833 BestWidth = CharWidth; 13834 } else if (Packed && NumPositiveBits <= ShortWidth) { 13835 BestType = Context.UnsignedShortTy; 13836 BestPromotionType = Context.IntTy; 13837 BestWidth = ShortWidth; 13838 } else if (NumPositiveBits <= IntWidth) { 13839 BestType = Context.UnsignedIntTy; 13840 BestWidth = IntWidth; 13841 BestPromotionType 13842 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 13843 ? Context.UnsignedIntTy : Context.IntTy; 13844 } else if (NumPositiveBits <= 13845 (BestWidth = Context.getTargetInfo().getLongWidth())) { 13846 BestType = Context.UnsignedLongTy; 13847 BestPromotionType 13848 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 13849 ? Context.UnsignedLongTy : Context.LongTy; 13850 } else { 13851 BestWidth = Context.getTargetInfo().getLongLongWidth(); 13852 assert(NumPositiveBits <= BestWidth && 13853 "How could an initializer get larger than ULL?"); 13854 BestType = Context.UnsignedLongLongTy; 13855 BestPromotionType 13856 = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus) 13857 ? Context.UnsignedLongLongTy : Context.LongLongTy; 13858 } 13859 } 13860 13861 FlagEnumAttr *FEAttr = Enum->getAttr<FlagEnumAttr>(); 13862 if (FEAttr) 13863 FEAttr->getFlagBits() = llvm::APInt(BestWidth, 0); 13864 13865 // Loop over all of the enumerator constants, changing their types to match 13866 // the type of the enum if needed. If we have a flag type, we also prepare the 13867 // FlagBits cache. 13868 for (auto *D : Elements) { 13869 auto *ECD = cast_or_null<EnumConstantDecl>(D); 13870 if (!ECD) continue; // Already issued a diagnostic. 13871 13872 // Standard C says the enumerators have int type, but we allow, as an 13873 // extension, the enumerators to be larger than int size. If each 13874 // enumerator value fits in an int, type it as an int, otherwise type it the 13875 // same as the enumerator decl itself. This means that in "enum { X = 1U }" 13876 // that X has type 'int', not 'unsigned'. 13877 13878 // Determine whether the value fits into an int. 13879 llvm::APSInt InitVal = ECD->getInitVal(); 13880 13881 // If it fits into an integer type, force it. Otherwise force it to match 13882 // the enum decl type. 13883 QualType NewTy; 13884 unsigned NewWidth; 13885 bool NewSign; 13886 if (!getLangOpts().CPlusPlus && 13887 !Enum->isFixed() && 13888 isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) { 13889 NewTy = Context.IntTy; 13890 NewWidth = IntWidth; 13891 NewSign = true; 13892 } else if (ECD->getType() == BestType) { 13893 // Already the right type! 13894 if (getLangOpts().CPlusPlus) 13895 // C++ [dcl.enum]p4: Following the closing brace of an 13896 // enum-specifier, each enumerator has the type of its 13897 // enumeration. 13898 ECD->setType(EnumType); 13899 goto flagbits; 13900 } else { 13901 NewTy = BestType; 13902 NewWidth = BestWidth; 13903 NewSign = BestType->isSignedIntegerOrEnumerationType(); 13904 } 13905 13906 // Adjust the APSInt value. 13907 InitVal = InitVal.extOrTrunc(NewWidth); 13908 InitVal.setIsSigned(NewSign); 13909 ECD->setInitVal(InitVal); 13910 13911 // Adjust the Expr initializer and type. 13912 if (ECD->getInitExpr() && 13913 !Context.hasSameType(NewTy, ECD->getInitExpr()->getType())) 13914 ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy, 13915 CK_IntegralCast, 13916 ECD->getInitExpr(), 13917 /*base paths*/ nullptr, 13918 VK_RValue)); 13919 if (getLangOpts().CPlusPlus) 13920 // C++ [dcl.enum]p4: Following the closing brace of an 13921 // enum-specifier, each enumerator has the type of its 13922 // enumeration. 13923 ECD->setType(EnumType); 13924 else 13925 ECD->setType(NewTy); 13926 13927 flagbits: 13928 // Check to see if we have a constant with exactly one bit set. Note that x 13929 // & (x - 1) will be nonzero if and only if x has more than one bit set. 13930 if (FEAttr) { 13931 llvm::APInt ExtVal = InitVal.zextOrSelf(BestWidth); 13932 if (ExtVal != 0 && !(ExtVal & (ExtVal - 1))) { 13933 FEAttr->getFlagBits() |= ExtVal; 13934 } 13935 } 13936 } 13937 13938 if (FEAttr) { 13939 for (Decl *D : Elements) { 13940 EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(D); 13941 if (!ECD) continue; // Already issued a diagnostic. 13942 13943 llvm::APSInt InitVal = ECD->getInitVal(); 13944 if (InitVal != 0 && !IsValueInFlagEnum(Enum, InitVal, true)) 13945 Diag(ECD->getLocation(), diag::warn_flag_enum_constant_out_of_range) 13946 << ECD << Enum; 13947 } 13948 } 13949 13950 13951 13952 Enum->completeDefinition(BestType, BestPromotionType, 13953 NumPositiveBits, NumNegativeBits); 13954 13955 CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType); 13956 13957 // Now that the enum type is defined, ensure it's not been underaligned. 13958 if (Enum->hasAttrs()) 13959 CheckAlignasUnderalignment(Enum); 13960 } 13961 13962 Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr, 13963 SourceLocation StartLoc, 13964 SourceLocation EndLoc) { 13965 StringLiteral *AsmString = cast<StringLiteral>(expr); 13966 13967 FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext, 13968 AsmString, StartLoc, 13969 EndLoc); 13970 CurContext->addDecl(New); 13971 return New; 13972 } 13973 13974 static void checkModuleImportContext(Sema &S, Module *M, 13975 SourceLocation ImportLoc, 13976 DeclContext *DC) { 13977 if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) { 13978 switch (LSD->getLanguage()) { 13979 case LinkageSpecDecl::lang_c: 13980 if (!M->IsExternC) { 13981 S.Diag(ImportLoc, diag::err_module_import_in_extern_c) 13982 << M->getFullModuleName(); 13983 S.Diag(LSD->getLocStart(), diag::note_module_import_in_extern_c); 13984 return; 13985 } 13986 break; 13987 case LinkageSpecDecl::lang_cxx: 13988 break; 13989 } 13990 DC = LSD->getParent(); 13991 } 13992 13993 while (isa<LinkageSpecDecl>(DC)) 13994 DC = DC->getParent(); 13995 if (!isa<TranslationUnitDecl>(DC)) { 13996 S.Diag(ImportLoc, diag::err_module_import_not_at_top_level) 13997 << M->getFullModuleName() << DC; 13998 S.Diag(cast<Decl>(DC)->getLocStart(), 13999 diag::note_module_import_not_at_top_level) 14000 << DC; 14001 } 14002 } 14003 14004 DeclResult Sema::ActOnModuleImport(SourceLocation AtLoc, 14005 SourceLocation ImportLoc, 14006 ModuleIdPath Path) { 14007 Module *Mod = 14008 getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible, 14009 /*IsIncludeDirective=*/false); 14010 if (!Mod) 14011 return true; 14012 14013 checkModuleImportContext(*this, Mod, ImportLoc, CurContext); 14014 14015 // FIXME: we should support importing a submodule within a different submodule 14016 // of the same top-level module. Until we do, make it an error rather than 14017 // silently ignoring the import. 14018 if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule) 14019 Diag(ImportLoc, diag::err_module_self_import) 14020 << Mod->getFullModuleName() << getLangOpts().CurrentModule; 14021 else if (Mod->getTopLevelModuleName() == getLangOpts().ImplementationOfModule) 14022 Diag(ImportLoc, diag::err_module_import_in_implementation) 14023 << Mod->getFullModuleName() << getLangOpts().ImplementationOfModule; 14024 14025 SmallVector<SourceLocation, 2> IdentifierLocs; 14026 Module *ModCheck = Mod; 14027 for (unsigned I = 0, N = Path.size(); I != N; ++I) { 14028 // If we've run out of module parents, just drop the remaining identifiers. 14029 // We need the length to be consistent. 14030 if (!ModCheck) 14031 break; 14032 ModCheck = ModCheck->Parent; 14033 14034 IdentifierLocs.push_back(Path[I].second); 14035 } 14036 14037 ImportDecl *Import = ImportDecl::Create(Context, 14038 Context.getTranslationUnitDecl(), 14039 AtLoc.isValid()? AtLoc : ImportLoc, 14040 Mod, IdentifierLocs); 14041 Context.getTranslationUnitDecl()->addDecl(Import); 14042 return Import; 14043 } 14044 14045 void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) { 14046 checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext); 14047 14048 // FIXME: Should we synthesize an ImportDecl here? 14049 getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, DirectiveLoc, 14050 /*Complain=*/true); 14051 } 14052 14053 void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc, 14054 Module *Mod) { 14055 // Bail if we're not allowed to implicitly import a module here. 14056 if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery) 14057 return; 14058 14059 // Create the implicit import declaration. 14060 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); 14061 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU, 14062 Loc, Mod, Loc); 14063 TU->addDecl(ImportD); 14064 Consumer.HandleImplicitImportDecl(ImportD); 14065 14066 // Make the module visible. 14067 getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc, 14068 /*Complain=*/false); 14069 } 14070 14071 void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name, 14072 IdentifierInfo* AliasName, 14073 SourceLocation PragmaLoc, 14074 SourceLocation NameLoc, 14075 SourceLocation AliasNameLoc) { 14076 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, 14077 LookupOrdinaryName); 14078 AsmLabelAttr *Attr = ::new (Context) AsmLabelAttr(AliasNameLoc, Context, 14079 AliasName->getName(), 0); 14080 14081 if (PrevDecl) 14082 PrevDecl->addAttr(Attr); 14083 else 14084 (void)ExtnameUndeclaredIdentifiers.insert( 14085 std::pair<IdentifierInfo*,AsmLabelAttr*>(Name, Attr)); 14086 } 14087 14088 void Sema::ActOnPragmaWeakID(IdentifierInfo* Name, 14089 SourceLocation PragmaLoc, 14090 SourceLocation NameLoc) { 14091 Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName); 14092 14093 if (PrevDecl) { 14094 PrevDecl->addAttr(WeakAttr::CreateImplicit(Context, PragmaLoc)); 14095 } else { 14096 (void)WeakUndeclaredIdentifiers.insert( 14097 std::pair<IdentifierInfo*,WeakInfo> 14098 (Name, WeakInfo((IdentifierInfo*)nullptr, NameLoc))); 14099 } 14100 } 14101 14102 void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name, 14103 IdentifierInfo* AliasName, 14104 SourceLocation PragmaLoc, 14105 SourceLocation NameLoc, 14106 SourceLocation AliasNameLoc) { 14107 Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc, 14108 LookupOrdinaryName); 14109 WeakInfo W = WeakInfo(Name, NameLoc); 14110 14111 if (PrevDecl) { 14112 if (!PrevDecl->hasAttr<AliasAttr>()) 14113 if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl)) 14114 DeclApplyPragmaWeak(TUScope, ND, W); 14115 } else { 14116 (void)WeakUndeclaredIdentifiers.insert( 14117 std::pair<IdentifierInfo*,WeakInfo>(AliasName, W)); 14118 } 14119 } 14120 14121 Decl *Sema::getObjCDeclContext() const { 14122 return (dyn_cast_or_null<ObjCContainerDecl>(CurContext)); 14123 } 14124 14125 AvailabilityResult Sema::getCurContextAvailability() const { 14126 const Decl *D = cast_or_null<Decl>(getCurObjCLexicalContext()); 14127 if (!D) 14128 return AR_Available; 14129 14130 // If we are within an Objective-C method, we should consult 14131 // both the availability of the method as well as the 14132 // enclosing class. If the class is (say) deprecated, 14133 // the entire method is considered deprecated from the 14134 // purpose of checking if the current context is deprecated. 14135 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 14136 AvailabilityResult R = MD->getAvailability(); 14137 if (R != AR_Available) 14138 return R; 14139 D = MD->getClassInterface(); 14140 } 14141 // If we are within an Objective-c @implementation, it 14142 // gets the same availability context as the @interface. 14143 else if (const ObjCImplementationDecl *ID = 14144 dyn_cast<ObjCImplementationDecl>(D)) { 14145 D = ID->getClassInterface(); 14146 } 14147 // Recover from user error. 14148 return D ? D->getAvailability() : AR_Available; 14149 } 14150